feat(app): token info and Vercel API structure\n\n- Move internal modules out of app/api so Vercel only deploys 5 route files\n (ai.ts, bot.ts, blockchain.ts, ping.ts, telegram.ts), avoiding 12-function limit\n- Add app/ai, app/blockchain, app/bot, app/shared, app/telegram, app/db;\n api routes import from ../ai, ../bot, etc. with .js extensions for Node\n- Bot: treat single-word ticker-like messages (e.g. DOGS, TON) as token_info;\n fall back to chat when token service is temporarily unavailable\n- Swap.Coffee: use tokens API with or without COFFEE key; fix verification\n params (multiple query keys instead of comma-separated) so token lookups work\n- Update scripts (migrate-db, run-bot-local) and Telegram.tsx to import from\n new app/ paths; add PULL_REQUEST.md

Made-with: Cursor

Author: anriltine

PULL_REQUEST.md

@@ -0,0 +1,49 @@
+# refactor: Unify API structure, user helpers, Vercel config, and remove SELF_URL
+
+## Summary
+
+This PR groups four related changes: shared user helpers for bot and API, simplified Vercel config and TypeScript ping, unified bot/telegram structure with legacy cleanup, and removal of the `SELF_URL` env in favor of Vercel URL variables. Together they simplify the app layout, reduce duplication, and make deployment configuration lighter.
+
+## Commits
+
+1. **`16996a6` — refactor(app): unify user helpers for bot and api**  
+   Single shared `app/api/users.ts` with `normalizeUsername`, `upsertUserFromTma`, and `upsertUserFromBot` backed by `api/db.ts`. Bot webhook, telegram POST handler, and local grammy bot use this module; removed duplicated `app/api/_users.ts` and `app/server/users.ts` so local polling and Vercel serverless share the same user logic.
+
+2. **`cb15afa` — chore(api): simplify vercel function config and move ping to TypeScript**  
+   Dropped explicit function overrides from `app/vercel.json` so API routes use Vercel defaults. Replaced `api/ping.js` with `api/ping.ts` that supports Request/Response and legacy `(req, res)` and returns `{ ok: true, ping: true }`.
+
+3. **`3e303ac` — refactor(api): unify bot and telegram structure and remove legacy scripts**  
+   Split `api/bot` into a thin route plus `bot/webhook` and shared `bot/grammy` used by both the Vercel webhook and local polling. Moved Telegram POST logic into `api/telegram/post`, added `api/shared/users` and centralized DB access in `api/db`. Removed duplicate webhooks, old JS set-webhook and build-output scripts, and duplicated user helpers to simplify the API layout while keeping behavior the same.
+
+4. **`26a50e0` — chore: remove SELF_URL env, use only Vercel URL vars**  
+   Dropped `SELF_URL` from webhook base URL logic. Base URL is now built from `VERCEL_PROJECT_PRODUCTION_URL` or `VERCEL_URL` only. Updated `webhook.ts`, `set-webhook.ts`, `.env.example`, README, and PR doc. Also removed obsolete files: `app/bot/grammy-bot.ts`, `app/bot/webhook.ts`, `app/security.md`, `app/security_plan.md`.
+
+## Changes Made (by area)
+
+### User helpers and DB (commit 1)
+- **`app/api/users.ts`**: New shared module with `normalizeUsername`, `upsertUserFromTma`, `upsertUserFromBot` using `api/db.ts`.
+- **Removed**: `app/api/_users.ts`, `app/server/users.ts`.
+- Bot webhook, telegram POST, and local grammy bot now import from `app/api/users.ts`.
+
+### Vercel and ping (commit 2)
+- **`app/vercel.json`**: Removed explicit function overrides; rely on Vercel defaults.
+- **`app/api/ping.ts`**: New TypeScript handler (replaces `api/ping.js`); supports Request/Response and legacy (req, res); returns `{ ok: true, ping: true }`.
+
+### Bot and telegram structure (commit 3)
+- **`app/api/bot`**: Thin route with shared `bot/webhook` and `bot/grammy`; used by Vercel webhook and local polling.
+- **`app/api/telegram/post`**: Heavy Telegram POST logic moved here; **`api/shared/users`** and **`api/db`** for centralized access.
+- **Removed**: Duplicate webhooks, old JS set-webhook and build-output scripts, duplicated user helpers.
+
+### SELF_URL removal and cleanup (commit 4)
+- **`app/api/bot/webhook.ts`**: Base URL from `VERCEL_PROJECT_PRODUCTION_URL` or `VERCEL_URL` only; no `SELF_URL`; comments and `expected_url` fallback updated.
+- **`app/scripts/set-webhook.ts`**: Same Vercel-only base URL; comment and env log no longer mention SELF_URL.
+- **`app/.env.example`**: Removed `SELF_URL` entry.
+- **Docs**: `app/README.md` and `docs/PULL_REQUEST_Dereal1.md` updated for Vercel-only URL and `BOT_TOKEN`-only deploy.
+- **Removed**: `app/bot/grammy-bot.ts`, `app/bot/webhook.ts`, `app/security.md`, `app/security_plan.md`.
+
+## Impact
+
+- **Single user/DB path**: Bot and API use one user helper and DB layer.
+- **Simpler Vercel config**: No custom function overrides; ping in TypeScript.
+- **Clearer API layout**: Bot vs telegram vs shared code is separated; legacy scripts removed.
+- **Simpler deployment**: No `SELF_URL`; webhook URL from `VERCEL_PROJECT_PRODUCTION_URL` or `VERCEL_URL` only.

app/.env.example

@@ -1,8 +1,19 @@
-# Copy to .env and fill in. Used by bot (npm run bot:local) and optionally by Expo.
-# Do not commit .env.
-
-# Telegram bot (required for local bot; optional for Expo app)
-# Get token from @BotFather on Telegram
-BOT_TOKEN=1234567890:ABCdefGHIjklMNOpqrsTUVwxyz-EXAMPLE
-# Neon/Postgres connection string (from Neon dashboard)
-DATABASE_URL=postgresql://user:password@ep-xxx-xxx.region.aws.neon.tech/neondb?sslmode=require
+# Copy to .env and fill in. Used by bot (npm run bot:local) and optionally by Expo.
+# Do not commit .env.
+
+# Telegram bot (required for local bot; optional for Expo app)
+# Get token from @BotFather on Telegram
+BOT_TOKEN=1234567890:ABCdefGHIjklMNOpqrsTUVwxyz-EXAMPLE
+# Neon/Postgres connection string (from Neon dashboard)
+DATABASE_URL=postgresql://user:password@ep-xxx-xxx.region.aws.neon.tech/neondb?sslmode=require
+# OpenAI API key for /api/ai (required for AI responses). Get from https://platform.openai.com/api-keys
+OPENAI=sk-proj-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+
+# Optional: base URL for calling APIs in dev (used by app and bot).
+# Example for local Vercel dev: http://localhost:3000
+# EXPO_PUBLIC_API_BASE_URL=http://localhost:3000
+
+# Optional: Swap.Coffee API key for TON token info and routing.
+# COFFEE=your-swap-coffee-api-key
+# COFFEE_BASE_URL=https://api.swap.coffee
+# COFFEE_TOKENS_BASE_URL=https://tokens.swap.coffee

app/ai/openai.ts

@@ -0,0 +1,80 @@
+import OpenAI from "openai";
+
+export type AiMode = "chat" | "token_info";
+
+export type AiRequestBase = {
+  input: string;
+  userId?: string;
+  context?: Record<string, unknown>;
+};
+
+export type AiResponseBase = {
+  ok: boolean;
+  provider: "openai";
+  output_text?: string;
+  error?: string;
+  mode: AiMode;
+  usage?: {
+    prompt_tokens?: number;
+    completion_tokens?: number;
+    total_tokens?: number;
+  };
+  meta?: Record<string, unknown>;
+};
+
+const OPENAI = process.env.OPENAI?.trim() || "";
+
+const client = OPENAI ? new OpenAI({ apiKey: OPENAI }) : null;
+
+export async function callOpenAiChat(
+  mode: AiMode,
+  params: AiRequestBase,
+): Promise<AiResponseBase> {
+  if (!client) {
+    return {
+      ok: false,
+      provider: "openai",
+      mode,
+      error: "OPENAI env is not configured on the server.",
+    };
+  }
+
+  const trimmed = params.input?.trim();
+  if (!trimmed) {
+    return {
+      ok: false,
+      provider: "openai",
+      mode,
+      error: "input is required.",
+    };
+  }
+
+  const prefix =
+    mode === "token_info"
+      ? "You are a blockchain and token analyst. Answer clearly and briefly.\n\n"
+      : "";
+
+  try {
+    const response = await client.responses.create({
+      model: "gpt-5.2",
+      input: `${prefix}${trimmed}`,
+    });
+
+    return {
+      ok: true,
+      provider: "openai",
+      mode,
+      output_text: (response as any).output_text ?? undefined,
+      usage: (response as any).usage ?? undefined,
+    };
+  } catch (e: any) {
+    const message =
+      e?.message ?? "Failed to call OpenAI. Check OPENAI env and network.";
+    return {
+      ok: false,
+      provider: "openai",
+      mode,
+      error: message,
+    };
+  }
+}

app/ai/transmitter.ts

@@ -0,0 +1,160 @@
+import type { AiMode, AiRequestBase, AiResponseBase } from "./openai.js";
+import { callOpenAiChat } from "./openai.js";
+import {
+  getTokenBySymbol,
+  normalizeSymbol,
+  type TokenSearchResult,
+} from "../blockchain/coffee.js";
+
+export type AiRequest = AiRequestBase & {
+  mode?: AiMode;
+};
+
+export type AiResponse = AiResponseBase;
+
+function extractSymbolCandidate(input: string): string | null {
+  const raw = input.trim();
+  if (!raw) return null;
+
+  // Simple patterns like "USDT", "$USDT", "USDT on TON".
+  const parts = raw.split(/\s+/);
+  const first = parts[0]?.replace(/^\$/g, "") ?? "";
+  const normalized = normalizeSymbol(first);
+  return normalized || null;
+}
+
+function buildTokenFactsBlock(symbol: string, token: any): string {
+  const lines: string[] = [];
+
+  const sym = token?.symbol ?? symbol;
+  const name = token?.name ?? null;
+  const address = token?.id ?? token?.address ?? null;
+  const type = token?.type ?? "token";
+  const decimals = token?.decimals ?? token?.metadata?.decimals ?? null;
+  const verification =
+    token?.verification ?? token?.metadata?.verification ?? null;
+
+  const market = token?.market_stats ?? {};
+  const holders =
+    market?.holders_count ?? token?.holders ?? market?.holders ?? null;
+  const priceUsd = market?.price_usd ?? null;
+  const mcap = market?.mcap ?? market?.fdmc ?? null;
+  const volume24h = market?.volume_usd_24h ?? null;
+
+  lines.push(`Symbol: ${sym}`);
+  if (name) {
+    lines.push(`Name: ${name}`);
+  }
+  lines.push(`Type: ${type}`);
+  lines.push(`Blockchain: TON`);
+  if (address) {
+    lines.push(`Address: ${address}`);
+  }
+  if (decimals != null) {
+    lines.push(`Decimals: ${decimals}`);
+  }
+  if (verification) {
+    lines.push(`Verification: ${verification}`);
+  }
+  if (holders != null) {
+    lines.push(`Holders: ${holders}`);
+  }
+  if (priceUsd != null) {
+    lines.push(`Price (USD): ${priceUsd}`);
+  }
+  if (mcap != null) {
+    lines.push(`Market cap (USD): ${mcap}`);
+  }
+  if (volume24h != null) {
+    lines.push(`24h volume (USD): ${volume24h}`);
+  }
+
+  return lines.join("\n");
+}
+
+async function handleTokenInfo(
+  request: AiRequest,
+): Promise<AiResponse> {
+  const trimmed = request.input?.trim() ?? "";
+  const symbolCandidate = extractSymbolCandidate(trimmed);
+
+  if (!symbolCandidate) {
+    return {
+      ok: false,
+      provider: "openai",
+      mode: "token_info",
+      error: "Could not detect a token symbol. Try sending something like USDT.",
+    };
+  }
+
+  const tokenResult: TokenSearchResult = await getTokenBySymbol(
+    symbolCandidate,
+  );
+
+  if (!tokenResult.ok) {
+    return {
+      ok: false,
+      provider: "openai",
+      mode: "token_info",
+      error:
+        tokenResult.error === "not_found"
+          ? `Token ${symbolCandidate} was not found on TON.`
+          : "Token service is temporarily unavailable.",
+      meta: {
+        symbol: symbolCandidate,
+        reason: tokenResult.reason,
+        status_code: tokenResult.status_code,
+      },
+    };
+  }
+
+  const token = tokenResult.data;
+  const facts = buildTokenFactsBlock(symbolCandidate, token);
+
+  const promptParts = [
+    "You are a concise TON token analyst.",
+    "",
+    "Facts about the token:",
+    facts,
+    "",
+    "User question or context:",
+    trimmed,
+  ];
+
+  const composedInput = promptParts.join("\n");
+
+  const result = await callOpenAiChat("token_info", {
+    input: composedInput,
+    userId: request.userId,
+    context: {
+      ...request.context,
+      symbol: symbolCandidate,
+      token,
+      source: "swap.coffee",
+    },
+  });
+
+  return {
+    ...result,
+    mode: "token_info",
+    meta: {
+      ...(result.meta ?? {}),
+      symbol: symbolCandidate,
+      token,
+    },
+  };
+}
+
+export async function transmit(request: AiRequest): Promise<AiResponse> {
+  const mode: AiMode = request.mode ?? "chat";
+
+  if (mode === "token_info") {
+    return handleTokenInfo(request);
+  }
+
+  return callOpenAiChat(mode, {
+    input: request.input,
+    userId: request.userId,
+    context: request.context,
+  });
+}