codexapp 0.1.51 → 0.1.52

package/dist-cli/index.js

@@ -30,7 +30,7 @@ import { request as httpRequest } from "http";
 import { request as httpsRequest } from "https";
 import { homedir as homedir3 } from "os";
 import { tmpdir as tmpdir2 } from "os";
-import { basename as basename2, isAbsolute, join as join3, resolve } from "path";
+import { basename as basename3, isAbsolute, join as join3, resolve } from "path";
 import { createInterface } from "readline";
 import { writeFile as writeFile2 } from "fs/promises";
 
@@ -70,6 +70,17 @@ function getCodexHomeDir() {
 function getSkillsInstallDir() {
   return join(getCodexHomeDir(), "skills");
 }
+function resolveSkillInstallerScriptPath() {
+  const candidates = [
+    join(getCodexHomeDir(), "skills", ".system", "skill-installer", "scripts", "install-skill-from-github.py"),
+    join(homedir(), ".codex", "skills", ".system", "skill-installer", "scripts", "install-skill-from-github.py"),
+    join(homedir(), ".cursor", "skills", ".system", "skill-installer", "scripts", "install-skill-from-github.py")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate;
+  }
+  throw new Error(`Skill installer script not found. Checked: ${candidates.join(", ")}`);
+}
 async function runCommand(command, args, options = {}) {
   await new Promise((resolve3, reject) => {
     const proc = spawn(command, args, {
@@ -269,6 +280,23 @@ async function scanInstalledSkillsFromDisk() {
   }
   return map;
 }
+function extractSkillDescriptionFromMarkdown(markdown) {
+  const lines = markdown.split(/\r?\n/);
+  let inCodeFence = false;
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (line.startsWith("```")) {
+      inCodeFence = !inCodeFence;
+      continue;
+    }
+    if (inCodeFence || line.length === 0) continue;
+    if (line.startsWith("#")) continue;
+    if (line.startsWith(">")) continue;
+    if (line.startsWith("- ") || line.startsWith("* ")) continue;
+    return line;
+  }
+  return "";
+}
 function getSkillsSyncStatePath() {
   return join(getCodexHomeDir(), "skills-sync.json");
 }
@@ -994,7 +1022,7 @@ async function handleSkillsRoutes(req, res, url, context) {
       }
       const localDir = await detectUserSkillsDir(appServer);
       await pullInstalledSkillsFolderFromRepo(state.githubToken, state.repoOwner, state.repoName);
-      const installerScript = "/Users/igor/.cursor/skills/.system/skill-installer/scripts/install-skill-from-github.py";
+      const installerScript = resolveSkillInstallerScriptPath();
       const localSkills = await scanInstalledSkillsFromDisk();
       for (const skill of remote) {
         const owner = skill.owner || uniqueOwnerByName.get(skill.name) || "";
@@ -1041,15 +1069,29 @@ async function handleSkillsRoutes(req, res, url, context) {
     try {
       const owner = url.searchParams.get("owner") || "";
       const name = url.searchParams.get("name") || "";
+      const installed = url.searchParams.get("installed") === "true";
+      const skillPath = url.searchParams.get("path") || "";
       if (!owner || !name) {
         setJson(res, 400, { error: "Missing owner or name" });
         return true;
       }
+      if (installed) {
+        const installedMap = await scanInstalledSkillsFromDisk();
+        const installedInfo = installedMap.get(name);
+        const localSkillPath = installedInfo?.path || (skillPath ? skillPath.endsWith("/SKILL.md") ? skillPath : `${skillPath}/SKILL.md` : "");
+        if (localSkillPath) {
+          const content2 = await readFile(localSkillPath, "utf8");
+          const description2 = extractSkillDescriptionFromMarkdown(content2);
+          setJson(res, 200, { content: content2, description: description2, source: "local" });
+          return true;
+        }
+      }
       const rawUrl = `https://raw.githubusercontent.com/${HUB_SKILLS_OWNER}/${HUB_SKILLS_REPO}/main/skills/${owner}/${name}/SKILL.md`;
       const resp = await fetch(rawUrl);
       if (!resp.ok) throw new Error(`Failed to fetch SKILL.md: ${resp.status}`);
       const content = await resp.text();
-      setJson(res, 200, { content });
+      const description = extractSkillDescriptionFromMarkdown(content);
+      setJson(res, 200, { content, description, source: "remote" });
     } catch (error) {
       setJson(res, 502, { error: getErrorMessage(error, "Failed to fetch SKILL.md") });
     }
@@ -1064,7 +1106,7 @@ async function handleSkillsRoutes(req, res, url, context) {
         setJson(res, 400, { error: "Missing owner or name" });
         return true;
       }
-      const installerScript = "/Users/igor/.cursor/skills/.system/skill-installer/scripts/install-skill-from-github.py";
+      const installerScript = resolveSkillInstallerScriptPath();
       const installDest = await detectUserSkillsDir(appServer);
       await runCommand("python3", [
         installerScript,
@@ -1120,11 +1162,377 @@ async function handleSkillsRoutes(req, res, url, context) {
   return false;
 }
 
+// src/server/telegramThreadBridge.ts
+import { basename } from "path";
+function asRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function getErrorMessage2(payload, fallback) {
+  if (payload instanceof Error && payload.message.trim().length > 0) {
+    return payload.message;
+  }
+  const record = asRecord2(payload);
+  if (!record) return fallback;
+  const error = record.error;
+  if (typeof error === "string" && error.length > 0) return error;
+  const nestedError = asRecord2(error);
+  if (nestedError && typeof nestedError.message === "string" && nestedError.message.length > 0) {
+    return nestedError.message;
+  }
+  return fallback;
+}
+var TelegramThreadBridge = class {
+  constructor(appServer) {
+    this.threadIdByChatId = /* @__PURE__ */ new Map();
+    this.chatIdsByThreadId = /* @__PURE__ */ new Map();
+    this.lastForwardedTurnByThreadId = /* @__PURE__ */ new Map();
+    this.active = false;
+    this.pollingTask = null;
+    this.nextUpdateOffset = 0;
+    this.lastError = "";
+    this.appServer = appServer;
+    this.token = process.env.TELEGRAM_BOT_TOKEN?.trim() ?? "";
+    this.defaultCwd = process.env.TELEGRAM_DEFAULT_CWD?.trim() ?? process.cwd();
+  }
+  start() {
+    if (!this.token || this.active) return;
+    this.active = true;
+    void this.notifyOnlineForKnownChats().catch(() => {
+    });
+    this.pollingTask = this.pollLoop();
+    this.appServer.onNotification((notification) => {
+      void this.handleNotification(notification).catch(() => {
+      });
+    });
+  }
+  stop() {
+    this.active = false;
+  }
+  async pollLoop() {
+    while (this.active) {
+      try {
+        const updates = await this.getUpdates();
+        this.lastError = "";
+        for (const update of updates) {
+          const updateId = typeof update.update_id === "number" ? update.update_id : -1;
+          if (updateId >= 0) {
+            this.nextUpdateOffset = Math.max(this.nextUpdateOffset, updateId + 1);
+          }
+          await this.handleIncomingUpdate(update);
+        }
+      } catch (error) {
+        this.lastError = getErrorMessage2(error, "Telegram polling failed");
+        await new Promise((resolve3) => setTimeout(resolve3, 1500));
+      }
+    }
+  }
+  async getUpdates() {
+    if (!this.token) {
+      throw new Error("Telegram bot token is not configured");
+    }
+    const response = await fetch(this.apiUrl("getUpdates"), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        timeout: 45,
+        offset: this.nextUpdateOffset,
+        allowed_updates: ["message", "callback_query"]
+      })
+    });
+    const payload = asRecord2(await response.json());
+    const result = Array.isArray(payload?.result) ? payload.result : [];
+    return result;
+  }
+  apiUrl(method) {
+    return `https://api.telegram.org/bot${this.token}/${method}`;
+  }
+  configureToken(token) {
+    const normalizedToken = token.trim();
+    if (!normalizedToken) {
+      throw new Error("Telegram bot token is required");
+    }
+    this.token = normalizedToken;
+  }
+  getStatus() {
+    return {
+      configured: this.token.length > 0,
+      active: this.active,
+      mappedChats: this.threadIdByChatId.size,
+      mappedThreads: this.chatIdsByThreadId.size,
+      lastError: this.lastError
+    };
+  }
+  connectThread(threadId, chatId, token) {
+    const normalizedThreadId = threadId.trim();
+    if (!normalizedThreadId) {
+      throw new Error("threadId is required");
+    }
+    if (!Number.isFinite(chatId)) {
+      throw new Error("chatId must be a number");
+    }
+    if (typeof token === "string" && token.trim().length > 0) {
+      this.configureToken(token);
+    }
+    if (!this.token) {
+      throw new Error("Telegram bot token is not configured");
+    }
+    this.bindChatToThread(chatId, normalizedThreadId);
+    this.start();
+    void this.sendOnlineMessage(chatId).catch(() => {
+    });
+  }
+  async sendTelegramMessage(chatId, text, options = {}) {
+    const message = text.trim();
+    if (!message) return;
+    const payload = { chat_id: chatId, text: message };
+    if (options.replyMarkup) {
+      payload.reply_markup = options.replyMarkup;
+    }
+    await fetch(this.apiUrl("sendMessage"), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload)
+    });
+  }
+  async sendOnlineMessage(chatId) {
+    await this.sendTelegramMessage(chatId, "Codex thread bridge went online.");
+  }
+  async notifyOnlineForKnownChats() {
+    const knownChatIds = Array.from(this.threadIdByChatId.keys());
+    for (const chatId of knownChatIds) {
+      await this.sendOnlineMessage(chatId);
+    }
+  }
+  async handleIncomingUpdate(update) {
+    if (update.callback_query) {
+      await this.handleCallbackQuery(update.callback_query);
+      return;
+    }
+    const message = update.message;
+    const chatId = message?.chat?.id;
+    const text = message?.text?.trim();
+    if (typeof chatId !== "number" || !text) return;
+    if (text === "/start") {
+      await this.sendThreadPicker(chatId);
+      return;
+    }
+    if (text === "/newthread") {
+      const threadId2 = await this.createThreadForChat(chatId);
+      await this.sendTelegramMessage(chatId, `Mapped to new thread: ${threadId2}`);
+      return;
+    }
+    const threadCommand = text.match(/^\/thread\s+(\S+)$/);
+    if (threadCommand) {
+      const threadId2 = threadCommand[1];
+      this.bindChatToThread(chatId, threadId2);
+      await this.sendTelegramMessage(chatId, `Mapped to thread: ${threadId2}`);
+      return;
+    }
+    const threadId = await this.ensureThreadForChat(chatId);
+    try {
+      await this.appServer.rpc("turn/start", {
+        threadId,
+        input: [{ type: "text", text }]
+      });
+    } catch (error) {
+      const message2 = getErrorMessage2(error, "Failed to forward message to thread");
+      await this.sendTelegramMessage(chatId, `Forward failed: ${message2}`);
+    }
+  }
+  async handleCallbackQuery(callbackQuery) {
+    const callbackId = typeof callbackQuery.id === "string" ? callbackQuery.id : "";
+    const data = typeof callbackQuery.data === "string" ? callbackQuery.data : "";
+    const chatId = callbackQuery.message?.chat?.id;
+    if (!callbackId) return;
+    if (!data.startsWith("thread:") || typeof chatId !== "number") {
+      await this.answerCallbackQuery(callbackId, "Invalid selection");
+      return;
+    }
+    const threadId = data.slice("thread:".length).trim();
+    if (!threadId) {
+      await this.answerCallbackQuery(callbackId, "Invalid thread id");
+      return;
+    }
+    this.bindChatToThread(chatId, threadId);
+    await this.answerCallbackQuery(callbackId, "Thread connected");
+    await this.sendTelegramMessage(chatId, `Connected to thread: ${threadId}`);
+    const history = await this.readThreadHistorySummary(threadId);
+    if (history) {
+      await this.sendTelegramMessage(chatId, history);
+    }
+  }
+  async answerCallbackQuery(callbackQueryId, text) {
+    await fetch(this.apiUrl("answerCallbackQuery"), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        callback_query_id: callbackQueryId,
+        text
+      })
+    });
+  }
+  async sendThreadPicker(chatId) {
+    const threads = await this.listRecentThreads();
+    if (threads.length === 0) {
+      await this.sendTelegramMessage(chatId, "No threads found. Send /newthread to create one.");
+      return;
+    }
+    const inlineKeyboard = threads.map((thread) => [
+      {
+        text: thread.title,
+        callback_data: `thread:${thread.id}`
+      }
+    ]);
+    await this.sendTelegramMessage(chatId, "Select a thread to connect:", {
+      replyMarkup: { inline_keyboard: inlineKeyboard }
+    });
+  }
+  async listRecentThreads() {
+    const payload = asRecord2(await this.appServer.rpc("thread/list", {
+      archived: false,
+      limit: 20,
+      sortKey: "updated_at"
+    }));
+    const rows = Array.isArray(payload?.data) ? payload.data : [];
+    const threads = [];
+    for (const row of rows) {
+      const record = asRecord2(row);
+      const id = typeof record?.id === "string" ? record.id.trim() : "";
+      if (!id) continue;
+      const name = typeof record?.name === "string" ? record.name.trim() : "";
+      const preview = typeof record?.preview === "string" ? record.preview.trim() : "";
+      const cwd = typeof record?.cwd === "string" ? record.cwd.trim() : "";
+      const projectName = cwd ? basename(cwd) : "project";
+      const threadTitle = (name || preview || id).replace(/\s+/g, " ").trim();
+      const title = `${projectName}/${threadTitle}`.slice(0, 64);
+      threads.push({ id, title });
+    }
+    return threads;
+  }
+  async createThreadForChat(chatId) {
+    const response = asRecord2(await this.appServer.rpc("thread/start", { cwd: this.defaultCwd }));
+    const thread = asRecord2(response?.thread);
+    const threadId = typeof thread?.id === "string" ? thread.id : "";
+    if (!threadId) {
+      throw new Error("thread/start did not return thread id");
+    }
+    this.bindChatToThread(chatId, threadId);
+    return threadId;
+  }
+  async ensureThreadForChat(chatId) {
+    const existing = this.threadIdByChatId.get(chatId);
+    if (existing) return existing;
+    return this.createThreadForChat(chatId);
+  }
+  bindChatToThread(chatId, threadId) {
+    const previousThreadId = this.threadIdByChatId.get(chatId);
+    if (previousThreadId && previousThreadId !== threadId) {
+      const previousSet = this.chatIdsByThreadId.get(previousThreadId);
+      previousSet?.delete(chatId);
+      if (previousSet && previousSet.size === 0) {
+        this.chatIdsByThreadId.delete(previousThreadId);
+      }
+    }
+    this.threadIdByChatId.set(chatId, threadId);
+    const chatIds = this.chatIdsByThreadId.get(threadId) ?? /* @__PURE__ */ new Set();
+    chatIds.add(chatId);
+    this.chatIdsByThreadId.set(threadId, chatIds);
+  }
+  extractThreadId(notification) {
+    const params = asRecord2(notification.params);
+    if (!params) return "";
+    const directThreadId = typeof params.threadId === "string" ? params.threadId : "";
+    if (directThreadId) return directThreadId;
+    const turn = asRecord2(params.turn);
+    const turnThreadId = typeof turn?.threadId === "string" ? turn.threadId : "";
+    return turnThreadId;
+  }
+  extractTurnId(notification) {
+    const params = asRecord2(notification.params);
+    if (!params) return "";
+    const directTurnId = typeof params.turnId === "string" ? params.turnId : "";
+    if (directTurnId) return directTurnId;
+    const turn = asRecord2(params.turn);
+    const turnId = typeof turn?.id === "string" ? turn.id : "";
+    return turnId;
+  }
+  async handleNotification(notification) {
+    if (notification.method !== "turn/completed") return;
+    const threadId = this.extractThreadId(notification);
+    if (!threadId) return;
+    const chatIds = this.chatIdsByThreadId.get(threadId);
+    if (!chatIds || chatIds.size === 0) return;
+    const turnId = this.extractTurnId(notification);
+    const lastForwardedTurnId = this.lastForwardedTurnByThreadId.get(threadId);
+    if (turnId && lastForwardedTurnId === turnId) return;
+    const assistantReply = await this.readLatestAssistantMessage(threadId);
+    if (!assistantReply) return;
+    for (const chatId of chatIds) {
+      await this.sendTelegramMessage(chatId, assistantReply);
+    }
+    if (turnId) {
+      this.lastForwardedTurnByThreadId.set(threadId, turnId);
+    }
+  }
+  async readLatestAssistantMessage(threadId) {
+    const response = asRecord2(await this.appServer.rpc("thread/read", { threadId, includeTurns: true }));
+    const thread = asRecord2(response?.thread);
+    const turns = Array.isArray(thread?.turns) ? thread.turns : [];
+    for (let turnIndex = turns.length - 1; turnIndex >= 0; turnIndex -= 1) {
+      const turn = asRecord2(turns[turnIndex]);
+      const items = Array.isArray(turn?.items) ? turn.items : [];
+      for (let itemIndex = items.length - 1; itemIndex >= 0; itemIndex -= 1) {
+        const item = asRecord2(items[itemIndex]);
+        if (item?.type === "agentMessage") {
+          const text = typeof item.text === "string" ? item.text.trim() : "";
+          if (text) return text;
+        }
+      }
+    }
+    return "";
+  }
+  async readThreadHistorySummary(threadId) {
+    const response = asRecord2(await this.appServer.rpc("thread/read", { threadId, includeTurns: true }));
+    const thread = asRecord2(response?.thread);
+    const turns = Array.isArray(thread?.turns) ? thread.turns : [];
+    const historyRows = [];
+    for (const turn of turns) {
+      const turnRecord = asRecord2(turn);
+      const items = Array.isArray(turnRecord?.items) ? turnRecord.items : [];
+      for (const item of items) {
+        const itemRecord = asRecord2(item);
+        const type = typeof itemRecord?.type === "string" ? itemRecord.type : "";
+        if (type === "userMessage") {
+          const content = Array.isArray(itemRecord?.content) ? itemRecord.content : [];
+          for (const block of content) {
+            const blockRecord = asRecord2(block);
+            if (blockRecord?.type === "text" && typeof blockRecord.text === "string" && blockRecord.text.trim()) {
+              historyRows.push(`User: ${blockRecord.text.trim()}`);
+            }
+          }
+        }
+        if (type === "agentMessage" && typeof itemRecord?.text === "string" && itemRecord.text.trim()) {
+          historyRows.push(`Assistant: ${itemRecord.text.trim()}`);
+        }
+      }
+    }
+    if (historyRows.length === 0) {
+      return "Thread has no message history yet.";
+    }
+    const tail = historyRows.slice(-12).join("\n\n");
+    const maxLen = 3800;
+    const summary = tail.length > maxLen ? tail.slice(tail.length - maxLen) : tail;
+    return `Recent history:
+
+${summary}`;
+  }
+};
+
 // src/utils/commandInvocation.ts
 import { spawnSync } from "child_process";
 import { existsSync as existsSync2 } from "fs";
 import { homedir as homedir2 } from "os";
-import { basename, extname, join as join2 } from "path";
+import { basename as basename2, extname, join as join2 } from "path";
 var WINDOWS_CMD_NAMES = /* @__PURE__ */ new Set(["codex", "npm", "npx"]);
 function quoteCmdExeArg(value) {
   const normalized = value.replace(/"/g, '""');
@@ -1138,7 +1546,7 @@ function needsCmdExeWrapper(command) {
     return false;
   }
   const lowerCommand = command.toLowerCase();
-  const baseName = basename(lowerCommand);
+  const baseName = basename2(lowerCommand);
   if (/\.(cmd|bat)$/i.test(baseName)) {
     return true;
   }
@@ -1199,18 +1607,18 @@ function resolveCodexCommand() {
 }
 
 // src/server/codexAppServerBridge.ts
-function asRecord2(value) {
+function asRecord3(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
-function getErrorMessage2(payload, fallback) {
+function getErrorMessage3(payload, fallback) {
   if (payload instanceof Error && payload.message.trim().length > 0) {
     return payload.message;
   }
-  const record = asRecord2(payload);
+  const record = asRecord3(payload);
   if (!record) return fallback;
   const error = record.error;
   if (typeof error === "string" && error.length > 0) return error;
-  const nestedError = asRecord2(error);
+  const nestedError = asRecord3(error);
   if (nestedError && typeof nestedError.message === "string" && nestedError.message.length > 0) {
     return nestedError.message;
   }
@@ -1222,15 +1630,15 @@ function setJson2(res, statusCode, payload) {
   res.end(JSON.stringify(payload));
 }
 function extractThreadMessageText(threadReadPayload) {
-  const payload = asRecord2(threadReadPayload);
-  const thread = asRecord2(payload?.thread);
+  const payload = asRecord3(threadReadPayload);
+  const thread = asRecord3(payload?.thread);
   const turns = Array.isArray(thread?.turns) ? thread.turns : [];
   const parts = [];
   for (const turn of turns) {
-    const turnRecord = asRecord2(turn);
+    const turnRecord = asRecord3(turn);
     const items = Array.isArray(turnRecord?.items) ? turnRecord.items : [];
     for (const item of items) {
-      const itemRecord = asRecord2(item);
+      const itemRecord = asRecord3(item);
       const type = typeof itemRecord?.type === "string" ? itemRecord.type : "";
       if (type === "agentMessage" && typeof itemRecord?.text === "string" && itemRecord.text.trim().length > 0) {
         parts.push(itemRecord.text.trim());
@@ -1239,7 +1647,7 @@ function extractThreadMessageText(threadReadPayload) {
       if (type === "userMessage") {
         const content = Array.isArray(itemRecord?.content) ? itemRecord.content : [];
         for (const block of content) {
-          const blockRecord = asRecord2(block);
+          const blockRecord = asRecord3(block);
           if (blockRecord?.type === "text" && typeof blockRecord.text === "string" && blockRecord.text.trim().length > 0) {
             parts.push(blockRecord.text.trim());
           }
@@ -1273,54 +1681,6 @@ function scoreFileCandidate(path, query) {
   if (lowerPath.includes(lowerQuery)) return 4;
   return 10;
 }
-function decodeHtmlEntities(value) {
-  return value.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&#x2F;/gi, "/");
-}
-function stripHtml(value) {
-  return decodeHtmlEntities(value.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim());
-}
-function parseGithubTrendingHtml(html, limit) {
-  const rows = html.match(/<article[\s\S]*?<\/article>/g) ?? [];
-  const items = [];
-  let seq = Date.now();
-  for (const row of rows) {
-    const repoBlockMatch = row.match(/<h2[\s\S]*?<\/h2>/);
-    const hrefMatch = repoBlockMatch?.[0]?.match(/href="\/([A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+)"/);
-    if (!hrefMatch) continue;
-    const fullName = hrefMatch[1] ?? "";
-    if (!fullName || items.some((item) => item.fullName === fullName)) continue;
-    const descriptionMatch = row.match(/<p[^>]*class="[^"]*col-9[^"]*"[^>]*>([\s\S]*?)<\/p>/) ?? row.match(/<p[^>]*class="[^"]*color-fg-muted[^"]*"[^>]*>([\s\S]*?)<\/p>/) ?? row.match(/<p[^>]*>([\s\S]*?)<\/p>/);
-    const languageMatch = row.match(/programmingLanguage[^>]*>\s*([\s\S]*?)\s*<\/span>/);
-    const starsMatch = row.match(/href="\/[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+\/stargazers"[\s\S]*?>([\s\S]*?)<\/a>/);
-    const starsText = stripHtml(starsMatch?.[1] ?? "").replace(/,/g, "");
-    const stars = Number.parseInt(starsText, 10);
-    items.push({
-      id: seq,
-      fullName,
-      url: `https://github.com/${fullName}`,
-      description: stripHtml(descriptionMatch?.[1] ?? ""),
-      language: stripHtml(languageMatch?.[1] ?? ""),
-      stars: Number.isFinite(stars) ? stars : 0
-    });
-    seq += 1;
-    if (items.length >= limit) break;
-  }
-  return items;
-}
-async function fetchGithubTrending(since, limit) {
-  const endpoint = `https://github.com/trending?since=${since}`;
-  const response = await fetch(endpoint, {
-    headers: {
-      "User-Agent": "codex-web-local",
-      Accept: "text/html"
-    }
-  });
-  if (!response.ok) {
-    throw new Error(`GitHub trending fetch failed (${response.status})`);
-  }
-  const html = await response.text();
-  return parseGithubTrendingHtml(html, limit);
-}
 async function listFilesWithRipgrep(cwd) {
   return await new Promise((resolve3, reject) => {
     const proc = spawn2("rg", ["--files", "--hidden", "-g", "!.git", "-g", "!node_modules"], {
@@ -1380,11 +1740,11 @@ async function runCommand2(command, args, options = {}) {
   });
 }
 function isMissingHeadError(error) {
-  const message = getErrorMessage2(error, "").toLowerCase();
+  const message = getErrorMessage3(error, "").toLowerCase();
   return message.includes("not a valid object name: 'head'") || message.includes("not a valid object name: head") || message.includes("invalid reference: head");
 }
 function isNotGitRepositoryError(error) {
-  const message = getErrorMessage2(error, "").toLowerCase();
+  const message = getErrorMessage3(error, "").toLowerCase();
   return message.includes("not a git repository") || message.includes("fatal: not a git repository");
 }
 async function ensureRepoHasInitialCommit(repoRoot) {
@@ -1526,9 +1886,9 @@ var sessionIndexThreadTitleCacheState = {
   cache: EMPTY_THREAD_TITLE_CACHE
 };
 function normalizeThreadTitleCache(value) {
-  const record = asRecord2(value);
+  const record = asRecord3(value);
   if (!record) return EMPTY_THREAD_TITLE_CACHE;
-  const rawTitles = asRecord2(record.titles);
+  const rawTitles = asRecord3(record.titles);
   const titles = {};
   if (rawTitles) {
     for (const [k, v] of Object.entries(rawTitles)) {
@@ -1552,7 +1912,7 @@ function removeFromThreadTitleCache(cache, id) {
   return { titles, order: cache.order.filter((o) => o !== id) };
 }
 function normalizeSessionIndexThreadTitle(value) {
-  const record = asRecord2(value);
+  const record = asRecord3(value);
   if (!record) return null;
   const id = typeof record.id === "string" ? record.id.trim() : "";
   const title = typeof record.thread_name === "string" ? record.thread_name.trim() : "";
@@ -1596,7 +1956,7 @@ async function readThreadTitleCache() {
   const statePath = getCodexGlobalStatePath();
   try {
     const raw = await readFile2(statePath, "utf8");
-    const payload = asRecord2(JSON.parse(raw)) ?? {};
+    const payload = asRecord3(JSON.parse(raw)) ?? {};
     return normalizeThreadTitleCache(payload["thread-titles"]);
   } catch {
     return EMPTY_THREAD_TITLE_CACHE;
@@ -1607,7 +1967,7 @@ async function writeThreadTitleCache(cache) {
   let payload = {};
   try {
     const raw = await readFile2(statePath, "utf8");
-    payload = asRecord2(JSON.parse(raw)) ?? {};
+    payload = asRecord3(JSON.parse(raw)) ?? {};
   } catch {
     payload = {};
   }
@@ -1683,7 +2043,7 @@ async function readWorkspaceRootsState() {
   try {
     const raw = await readFile2(statePath, "utf8");
     const parsed = JSON.parse(raw);
-    payload = asRecord2(parsed) ?? {};
+    payload = asRecord3(parsed) ?? {};
   } catch {
     payload = {};
   }
@@ -1698,7 +2058,7 @@ async function writeWorkspaceRootsState(nextState) {
   let payload = {};
   try {
     const raw = await readFile2(statePath, "utf8");
-    payload = asRecord2(JSON.parse(raw)) ?? {};
+    payload = asRecord3(JSON.parse(raw)) ?? {};
   } catch {
     payload = {};
   }
@@ -1707,6 +2067,36 @@ async function writeWorkspaceRootsState(nextState) {
   payload["active-workspace-roots"] = normalizeStringArray(nextState.active);
   await writeFile2(statePath, JSON.stringify(payload), "utf8");
 }
+function normalizeTelegramBridgeConfig(value) {
+  const record = asRecord3(value);
+  if (!record) return { botToken: "" };
+  const botToken = typeof record.botToken === "string" ? record.botToken.trim() : "";
+  return { botToken };
+}
+async function readTelegramBridgeConfig() {
+  const statePath = getCodexGlobalStatePath();
+  try {
+    const raw = await readFile2(statePath, "utf8");
+    const payload = asRecord3(JSON.parse(raw)) ?? {};
+    return normalizeTelegramBridgeConfig(payload["telegram-bridge"]);
+  } catch {
+    return { botToken: "" };
+  }
+}
+async function writeTelegramBridgeConfig(nextState) {
+  const statePath = getCodexGlobalStatePath();
+  let payload = {};
+  try {
+    const raw = await readFile2(statePath, "utf8");
+    payload = asRecord3(JSON.parse(raw)) ?? {};
+  } catch {
+    payload = {};
+  }
+  payload["telegram-bridge"] = {
+    botToken: nextState.botToken.trim()
+  };
+  await writeFile2(statePath, JSON.stringify(payload), "utf8");
+}
 async function readJsonBody(req) {
   const raw = await readRawBody(req);
   if (raw.length === 0) return null;
@@ -1783,11 +2173,11 @@ function handleFileUpload(req, res) {
       await writeFile2(destPath, fileData);
       setJson2(res, 200, { path: destPath });
     } catch (err) {
-      setJson2(res, 500, { error: getErrorMessage2(err, "Upload failed") });
+      setJson2(res, 500, { error: getErrorMessage3(err, "Upload failed") });
     }
   });
   req.on("error", (err) => {
-    setJson2(res, 500, { error: getErrorMessage2(err, "Upload stream error") });
+    setJson2(res, 500, { error: getErrorMessage3(err, "Upload stream error") });
   });
 }
 function httpPost(url, headers, body) {
@@ -1981,7 +2371,7 @@ var AppServerProcess = class {
     }
     this.pendingServerRequests.delete(requestId);
     this.sendServerRequestReply(requestId, reply);
-    const requestParams = asRecord2(pendingRequest.params);
+    const requestParams = asRecord3(pendingRequest.params);
     const threadId = typeof requestParams?.threadId === "string" && requestParams.threadId.length > 0 ? requestParams.threadId : "";
     this.emitNotification({
       method: "server/request/resolved",
@@ -2050,7 +2440,7 @@ var AppServerProcess = class {
   }
   async respondToServerRequest(payload) {
     await this.ensureInitialized();
-    const body = asRecord2(payload);
+    const body = asRecord3(payload);
     if (!body) {
       throw new Error("Invalid response payload: expected object");
     }
@@ -2058,7 +2448,7 @@ var AppServerProcess = class {
     if (typeof id !== "number" || !Number.isInteger(id)) {
       throw new Error('Invalid response payload: "id" must be an integer');
     }
-    const rawError = asRecord2(body.error);
+    const rawError = asRecord3(body.error);
     if (rawError) {
       const message = typeof rawError.message === "string" && rawError.message.trim().length > 0 ? rawError.message.trim() : "Server request rejected by client";
       const code = typeof rawError.code === "number" && Number.isFinite(rawError.code) ? Math.trunc(rawError.code) : -32e3;
@@ -2133,13 +2523,13 @@ var MethodCatalog = class {
     });
   }
   extractMethodsFromClientRequest(payload) {
-    const root = asRecord2(payload);
+    const root = asRecord3(payload);
     const oneOf = Array.isArray(root?.oneOf) ? root.oneOf : [];
     const methods = /* @__PURE__ */ new Set();
     for (const entry of oneOf) {
-      const row = asRecord2(entry);
-      const properties = asRecord2(row?.properties);
-      const methodDef = asRecord2(properties?.method);
+      const row = asRecord3(entry);
+      const properties = asRecord3(row?.properties);
+      const methodDef = asRecord3(properties?.method);
       const methodEnum = Array.isArray(methodDef?.enum) ? methodDef.enum : [];
       for (const item of methodEnum) {
         if (typeof item === "string" && item.length > 0) {
@@ -2150,13 +2540,13 @@ var MethodCatalog = class {
     return Array.from(methods).sort((a, b) => a.localeCompare(b));
   }
   extractMethodsFromServerNotification(payload) {
-    const root = asRecord2(payload);
+    const root = asRecord3(payload);
     const oneOf = Array.isArray(root?.oneOf) ? root.oneOf : [];
     const methods = /* @__PURE__ */ new Set();
     for (const entry of oneOf) {
-      const row = asRecord2(entry);
-      const properties = asRecord2(row?.properties);
-      const methodDef = asRecord2(properties?.method);
+      const row = asRecord3(entry);
+      const properties = asRecord3(row?.properties);
+      const methodDef = asRecord3(properties?.method);
       const methodEnum = Array.isArray(methodDef?.enum) ? methodDef.enum : [];
       for (const item of methodEnum) {
         if (typeof item === "string" && item.length > 0) {
@@ -2198,9 +2588,11 @@ function getSharedBridgeState() {
   const globalScope = globalThis;
   const existing = globalScope[SHARED_BRIDGE_KEY];
   if (existing) return existing;
+  const appServer = new AppServerProcess();
   const created = {
-    appServer: new AppServerProcess(),
-    methodCatalog: new MethodCatalog()
+    appServer,
+    methodCatalog: new MethodCatalog(),
+    telegramBridge: new TelegramThreadBridge(appServer)
   };
   globalScope[SHARED_BRIDGE_KEY] = created;
   return created;
@@ -2209,7 +2601,7 @@ async function loadAllThreadsForSearch(appServer) {
   const threads = [];
   let cursor = null;
   do {
-    const response = asRecord2(await appServer.rpc("thread/list", {
+    const response = asRecord3(await appServer.rpc("thread/list", {
       archived: false,
       limit: 100,
       sortKey: "updated_at",
@@ -2217,7 +2609,7 @@ async function loadAllThreadsForSearch(appServer) {
     }));
     const data = Array.isArray(response?.data) ? response.data : [];
     for (const row of data) {
-      const record = asRecord2(row);
+      const record = asRecord3(row);
       const id = typeof record?.id === "string" ? record.id : "";
       if (!id) continue;
       const title = typeof record?.name === "string" && record.name.trim().length > 0 ? record.name.trim() : typeof record?.preview === "string" && record.preview.trim().length > 0 ? record.preview.trim() : "Untitled thread";
@@ -2266,7 +2658,7 @@ async function buildThreadSearchIndex(appServer) {
   return { docsById };
 }
 function createCodexBridgeMiddleware() {
-  const { appServer, methodCatalog } = getSharedBridgeState();
+  const { appServer, methodCatalog, telegramBridge } = getSharedBridgeState();
   let threadSearchIndex = null;
   let threadSearchIndexPromise = null;
   async function getThreadSearchIndex() {
@@ -2282,6 +2674,12 @@ function createCodexBridgeMiddleware() {
     return threadSearchIndexPromise;
   }
   void initializeSkillsSyncOnStartup(appServer);
+  void readTelegramBridgeConfig().then((config) => {
+    if (!config.botToken) return;
+    telegramBridge.configureToken(config.botToken);
+    telegramBridge.start();
+  }).catch(() => {
+  });
   const middleware = async (req, res, next) => {
     try {
       if (!req.url) {
@@ -2298,7 +2696,7 @@ function createCodexBridgeMiddleware() {
       }
       if (req.method === "POST" && url.pathname === "/codex-api/rpc") {
         const payload = await readJsonBody(req);
-        const body = asRecord2(payload);
+        const body = asRecord3(payload);
         if (!body || typeof body.method !== "string" || body.method.length === 0) {
           setJson2(res, 400, { error: "Invalid body: expected { method, params? }" });
           return;
@@ -2350,21 +2748,8 @@ function createCodexBridgeMiddleware() {
         setJson2(res, 200, { data: { path: homedir3() } });
         return;
       }
-      if (req.method === "GET" && url.pathname === "/codex-api/github-trending") {
-        const sinceRaw = (url.searchParams.get("since") ?? "").trim().toLowerCase();
-        const since = sinceRaw === "weekly" ? "weekly" : sinceRaw === "monthly" ? "monthly" : "daily";
-        const limitRaw = Number.parseInt((url.searchParams.get("limit") ?? "6").trim(), 10);
-        const limit = Number.isFinite(limitRaw) ? Math.max(1, Math.min(10, limitRaw)) : 6;
-        try {
-          const data = await fetchGithubTrending(since, limit);
-          setJson2(res, 200, { data });
-        } catch (error) {
-          setJson2(res, 502, { error: getErrorMessage2(error, "Failed to fetch GitHub trending") });
-        }
-        return;
-      }
       if (req.method === "POST" && url.pathname === "/codex-api/worktree/create") {
-        const payload = asRecord2(await readJsonBody(req));
+        const payload = asRecord3(await readJsonBody(req));
         const rawSourceCwd = typeof payload?.sourceCwd === "string" ? payload.sourceCwd.trim() : "";
         if (!rawSourceCwd) {
           setJson2(res, 400, { error: "Missing sourceCwd" });
@@ -2390,7 +2775,7 @@ function createCodexBridgeMiddleware() {
             await runCommand2("git", ["init"], { cwd: sourceCwd });
             gitRoot = await runCommandCapture("git", ["rev-parse", "--show-toplevel"], { cwd: sourceCwd });
           }
-          const repoName = basename2(gitRoot) || "repo";
+          const repoName = basename3(gitRoot) || "repo";
           const worktreesRoot = join3(getCodexHomeDir2(), "worktrees");
           await mkdir2(worktreesRoot, { recursive: true });
           let worktreeId = "";
@@ -2429,12 +2814,12 @@ function createCodexBridgeMiddleware() {
             }
           });
         } catch (error) {
-          setJson2(res, 500, { error: getErrorMessage2(error, "Failed to create worktree") });
+          setJson2(res, 500, { error: getErrorMessage3(error, "Failed to create worktree") });
         }
         return;
       }
       if (req.method === "POST" && url.pathname === "/codex-api/worktree/auto-commit") {
-        const payload = asRecord2(await readJsonBody(req));
+        const payload = asRecord3(await readJsonBody(req));
         const rawCwd = typeof payload?.cwd === "string" ? payload.cwd.trim() : "";
         const commitMessage = normalizeCommitMessage(payload?.message);
         if (!rawCwd) {
@@ -2472,12 +2857,12 @@ function createCodexBridgeMiddleware() {
           await runCommand2("git", ["commit", "-m", commitMessage], { cwd });
           setJson2(res, 200, { data: { committed: true } });
         } catch (error) {
-          setJson2(res, 500, { error: getErrorMessage2(error, "Failed to auto-commit worktree changes") });
+          setJson2(res, 500, { error: getErrorMessage3(error, "Failed to auto-commit worktree changes") });
         }
         return;
       }
       if (req.method === "POST" && url.pathname === "/codex-api/worktree/rollback-to-message") {
-        const payload = asRecord2(await readJsonBody(req));
+        const payload = asRecord3(await readJsonBody(req));
         const rawCwd = typeof payload?.cwd === "string" ? payload.cwd.trim() : "";
         const commitMessage = normalizeCommitMessage(payload?.message);
         if (!rawCwd) {
@@ -2522,13 +2907,13 @@ function createCodexBridgeMiddleware() {
           await runCommand2("git", ["reset", "--hard", resetTargetSha], { cwd });
           setJson2(res, 200, { data: { reset: true, commitSha, resetTargetSha, stashed } });
         } catch (error) {
-          setJson2(res, 500, { error: getErrorMessage2(error, "Failed to rollback worktree to user message commit") });
+          setJson2(res, 500, { error: getErrorMessage3(error, "Failed to rollback worktree to user message commit") });
         }
         return;
       }
       if (req.method === "PUT" && url.pathname === "/codex-api/workspace-roots-state") {
         const payload = await readJsonBody(req);
-        const record = asRecord2(payload);
+        const record = asRecord3(payload);
         if (!record) {
           setJson2(res, 400, { error: "Invalid body: expected object" });
           return;
@@ -2543,7 +2928,7 @@ function createCodexBridgeMiddleware() {
         return;
       }
       if (req.method === "POST" && url.pathname === "/codex-api/project-root") {
-        const payload = asRecord2(await readJsonBody(req));
+        const payload = asRecord3(await readJsonBody(req));
         const rawPath = typeof payload?.path === "string" ? payload.path.trim() : "";
         const createIfMissing = payload?.createIfMissing === true;
         const label = typeof payload?.label === "string" ? payload.label : "";
@@ -2617,7 +3002,7 @@ function createCodexBridgeMiddleware() {
         return;
       }
       if (req.method === "POST" && url.pathname === "/codex-api/composer-file-search") {
-        const payload = asRecord2(await readJsonBody(req));
+        const payload = asRecord3(await readJsonBody(req));
         const rawCwd = typeof payload?.cwd === "string" ? payload.cwd.trim() : "";
         const query = typeof payload?.query === "string" ? payload.query.trim() : "";
         const limitRaw = typeof payload?.limit === "number" ? payload.limit : 20;
@@ -2642,7 +3027,7 @@ function createCodexBridgeMiddleware() {
           const scored = files.map((path) => ({ path, score: scoreFileCandidate(path, query) })).filter((row) => query.length === 0 || row.score < 10).sort((a, b) => a.score - b.score || a.path.localeCompare(b.path)).slice(0, limit).map((row) => ({ path: row.path }));
           setJson2(res, 200, { data: scored });
         } catch (error) {
-          setJson2(res, 500, { error: getErrorMessage2(error, "Failed to search files") });
+          setJson2(res, 500, { error: getErrorMessage3(error, "Failed to search files") });
         }
         return;
       }
@@ -2652,7 +3037,7 @@ function createCodexBridgeMiddleware() {
         return;
       }
       if (req.method === "POST" && url.pathname === "/codex-api/thread-search") {
-        const payload = asRecord2(await readJsonBody(req));
+        const payload = asRecord3(await readJsonBody(req));
         const query = typeof payload?.query === "string" ? payload.query.trim() : "";
         const limitRaw = typeof payload?.limit === "number" ? payload.limit : 200;
         const limit = Math.max(1, Math.min(1e3, Math.floor(limitRaw)));
@@ -2666,7 +3051,7 @@ function createCodexBridgeMiddleware() {
         return;
       }
       if (req.method === "PUT" && url.pathname === "/codex-api/thread-titles") {
-        const payload = asRecord2(await readJsonBody(req));
+        const payload = asRecord3(await readJsonBody(req));
         const id = typeof payload?.id === "string" ? payload.id : "";
         const title = typeof payload?.title === "string" ? payload.title : "";
         if (!id) {
@@ -2679,6 +3064,23 @@ function createCodexBridgeMiddleware() {
         setJson2(res, 200, { ok: true });
         return;
       }
+      if (req.method === "POST" && url.pathname === "/codex-api/telegram/configure-bot") {
+        const payload = asRecord3(await readJsonBody(req));
+        const botToken = typeof payload?.botToken === "string" ? payload.botToken.trim() : "";
+        if (!botToken) {
+          setJson2(res, 400, { error: "Missing botToken" });
+          return;
+        }
+        telegramBridge.configureToken(botToken);
+        telegramBridge.start();
+        await writeTelegramBridgeConfig({ botToken });
+        setJson2(res, 200, { ok: true });
+        return;
+      }
+      if (req.method === "GET" && url.pathname === "/codex-api/telegram/status") {
+        setJson2(res, 200, { data: telegramBridge.getStatus() });
+        return;
+      }
       if (req.method === "GET" && url.pathname === "/codex-api/events") {
         res.statusCode = 200;
         res.setHeader("Content-Type", "text/event-stream; charset=utf-8");
@@ -2711,12 +3113,13 @@ data: ${JSON.stringify({ ok: true })}
       }
       next();
     } catch (error) {
-      const message = getErrorMessage2(error, "Unknown bridge error");
+      const message = getErrorMessage3(error, "Unknown bridge error");
       setJson2(res, 502, { error: message });
     }
   };
   middleware.dispose = () => {
     threadSearchIndex = null;
+    telegramBridge.stop();
     appServer.dispose();
   };
   middleware.subscribeNotifications = (listener) => {