cursor-telegram-mcp 0.5.0 → 0.7.0

package/dist/watchdog.js

@@ -0,0 +1,62 @@
+/**
+ * `cursor-telegram-mcp watchdog` — one-shot liveness check.
+ *
+ * Meant to be run on a short interval by launchd (or cron). It hits the
+ * worker's /health and, if the worker is unreachable OR its poll loop looks
+ * wedged (pollAgeSec too high — e.g. a stale socket the abort timeout somehow
+ * missed), it kicks the worker's launch agent so launchd restarts it. The
+ * worker's own retry/backoff handles the common cases; this is the belt-and-
+ * suspenders layer so the bot is never silently offline while the Mac is on.
+ *
+ * Exits 0 always (a transient blip should not spam launchd error logs).
+ */
+import { execFileSync } from "node:child_process";
+import { getConfig } from "./config.js";
+/** launchd label to restart; overridable so it works for legacy installs too. */
+const WORKER_LABEL = process.env.TG_WORKER_LABEL?.trim() || "com.cursor-telegram.worker";
+/** Restart if getUpdates has not returned successfully for this many seconds. */
+const MAX_POLL_AGE_SEC = Number.parseInt(process.env.TG_WATCHDOG_MAX_POLL_AGE_SEC ?? "120", 10);
+function log(msg) {
+    process.stderr.write(`[watchdog] ${new Date().toISOString()} ${msg}\n`);
+}
+function kick() {
+    const uid = process.getuid?.() ?? 501;
+    try {
+        execFileSync("launchctl", ["kickstart", "-k", `gui/${uid}/${WORKER_LABEL}`], {
+            stdio: "ignore",
+        });
+        log(`restarted ${WORKER_LABEL}`);
+    }
+    catch (err) {
+        log(`failed to restart ${WORKER_LABEL}: ${String(err)}`);
+    }
+}
+async function main() {
+    const url = `${getConfig(false).workerUrl}/health`;
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), 5000);
+    try {
+        const res = await fetch(url, { signal: ac.signal });
+        const body = (await res.json());
+        if (!body.ok || body.connected === false) {
+            log(`unhealthy (ok=${body.ok}, connected=${body.connected}); restarting`);
+            kick();
+            return;
+        }
+        const age = body.pollAgeSec ?? 0;
+        if (age > MAX_POLL_AGE_SEC) {
+            log(`poll loop wedged (pollAgeSec=${age} > ${MAX_POLL_AGE_SEC}); restarting`);
+            kick();
+            return;
+        }
+        log(`ok (pollAgeSec=${age})`);
+    }
+    catch (err) {
+        log(`worker unreachable at ${url}: ${String(err)}; restarting`);
+        kick();
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+await main();

package/dist/worker.js

@@ -18,23 +18,24 @@
  *
  * API (JSON, localhost only):
  *   GET  /health                       -> { ok, connected, target, pending, commandMode, queue }
- *   POST /notify   { summary, project } -> { ok } | 429 { error, waitMs } | 503
- *   POST /ask      { question, project }-> { id } | 429 | 503
- *   POST /mirror   { question, project } -> { id, mirrored } | 429 | 503
+ *   POST /notify   { summary, project, agent? } -> { ok } | 429 { error, waitMs } | 503
+ *   POST /ask      { question, project, agent? }-> { id } | 429 | 503
+ *   POST /mirror   { question, project, agent? } -> { id, mirrored } | 429 | 503
  *   GET  /response/:id                 -> { id, status, answer?, attachments?, elapsedMin } | 404
  *                                      optional ?waitMs=N long-polls until answered or N ms
  */
 import { createServer } from "node:http";
 import { notifyAnswered, waitForAnswer } from "./answerWaiters.js";
-import { readdirSync, statSync } from "node:fs";
-import { homedir } from "node:os";
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { homedir, hostname } from "node:os";
 import { delimiter, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { getConfig } from "./config.js";
+import { configDir, getConfig } from "./config.js";
 import { createStore } from "./store.js";
 import { createCommandRunner } from "./agentRunner.js";
-import { toPlainTelegram } from "./formatTelegram.js";
-import { splitInboundMessage } from "./parseInbound.js";
+import { Transcript } from "./transcript.js";
+import { labelPrefix, toPlainTelegram } from "./formatTelegram.js";
+import { parseTargetId, splitInboundMessage } from "./parseInbound.js";
 import { splitMessage } from "./splitMessage.js";
 import { createTaskQueue } from "./taskQueue.js";
 import { TelegramClient, createStderrLogger, } from "./telegram.js";
@@ -44,6 +45,17 @@ const COMMAND_TTL_MS = 60 * 60_000;
 const UPDATE_CHECK_MS = 15_000;
 /** Directory holding this worker's source (for self-update detection). */
 const SRC_DIR = dirname(fileURLToPath(import.meta.url));
+/** Worker version from package.json (one level up from src/ or dist/). */
+function readVersion() {
+    try {
+        const pkg = JSON.parse(readFileSync(join(SRC_DIR, "..", "package.json"), "utf8"));
+        return pkg.version ?? "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
+const WORKER_VERSION = readVersion();
 /**
  * Newest mtime among the worker's TypeScript source files. Used to notice when
  * a command-mode task has edited the worker's own code, so it can relaunch on
@@ -77,6 +89,11 @@ function cleanProject(raw) {
     const s = String(raw ?? "").trim().replace(/\s+/g, " ");
     return s === "" ? "default" : s.slice(0, 48);
 }
+/** Sanitize an optional per-agent label; empty string means "no agent label". */
+function cleanAgent(raw) {
+    const s = String(raw ?? "").trim().replace(/\s+/g, " ");
+    return s.slice(0, 48);
+}
 function sendJson(res, status, body) {
     res.writeHead(status, { "content-type": "application/json" });
     res.end(JSON.stringify(body));
@@ -108,16 +125,6 @@ function isReplyToQuestion(msg, store) {
     const pendings = store.listPending();
     return pendings.some((q) => q.sentMessageId && q.sentMessageId === msg.quotedMessageId);
 }
-function isCommandLike(segments) {
-    return segments.some((s) => s.kind === "ask" ||
-        s.kind === "plan" ||
-        s.kind === "ask_empty" ||
-        s.kind === "plan_empty" ||
-        s.kind === "status" ||
-        s.kind === "approve" ||
-        s.kind === "reject" ||
-        s.kind === "approval_footer");
-}
 async function main() {
     // Make sure the Cursor CLI (`cursor-agent`, used by command mode) is findable
     // even when launched by a GUI/launchd context with a minimal PATH.
@@ -130,18 +137,32 @@ async function main() {
     if (config.chatId === "") {
         log("TELEGRAM_CHAT_ID is not set. Run `npm run login` to find it, then set it in .env.");
     }
-    const store = createStore();
+    const store = createStore({ persistPath: join(configDir(), "questions.json") });
     const taskQueue = createTaskQueue();
+    const startedAt = Date.now();
+    let lastError;
+    const restoredPending = store.pendingCount();
     const runner = createCommandRunner({
         apiKey: config.cursorApiKey,
         cwd: config.agentCwd,
         model: config.agentModel,
         settingSources: config.agentLoadSettings ? ["all"] : [],
+        rolling: config.rolling,
+        sessionPath: config.sessionPath,
     });
-    const commandMode = runner.enabled;
+    const commandMode = runner.enabled && config.commandModeEnabled;
+    const transcript = new Transcript(config.transcriptPath);
     log(commandMode
         ? `Command mode ON (model ${config.agentModel}, cwd ${config.agentCwd}). /ask, /plan, or plain text to plan.`
-        : "Command mode OFF (set CURSOR_API_KEY to text tasks to the bot).");
+        : runner.enabled
+            ? "Command mode OFF (disabled via TG_COMMAND_MODE). Inbound text will not spawn tasks."
+            : "Command mode OFF (set CURSOR_API_KEY to text tasks to the bot).");
+    if (commandMode && config.rolling) {
+        const info = runner.rollingInfo();
+        log(info
+            ? `Rolling thread ON (resuming ${info.agentId}). Transcript: ${config.transcriptPath}`
+            : `Rolling thread ON (new thread on first message). Transcript: ${config.transcriptPath}`);
+    }
     const client = new TelegramClient({
         botToken: config.botToken,
         logger: createStderrLogger("warn"),
@@ -208,9 +229,11 @@ async function main() {
             });
             log(`Execution ${id} -> ${session.status}`);
             if (session.status === "done") {
+                transcript.append({ role: "done", id, text: session.result ?? "" });
                 await send(`Done (${id})\n\n${session.result ?? ""}`);
             }
             else if (session.status === "error") {
+                transcript.append({ role: "error", id, text: session.error ?? "unknown error" });
                 await send(`Command ${id} failed:\n${session.error ?? "unknown error"}`);
             }
         }
@@ -218,15 +241,35 @@ async function main() {
             clearHeartbeat();
         }
     }
+    /** One line per pending question: "Q-3 [project · agent]: question…". */
+    function pendingLines() {
+        return store.listPending().map((q) => {
+            const head = `${q.id} ${labelPrefix(q.projectLabel, q.agentLabel)}`;
+            const preview = q.question.replace(/\s+/g, " ").slice(0, 80);
+            return `${head}: ${preview}`;
+        });
+    }
+    /** Full reply to /pending: the list plus how to answer a specific one. */
+    function formatPendingList() {
+        const lines = pendingLines();
+        if (lines.length === 0)
+            return "No pending questions.";
+        const example = store.listPending()[0]?.id ?? "Q-1";
+        return (`Pending questions (${lines.length}):\n${lines.join("\n")}\n\n` +
+            `To answer a specific one, swipe-reply its message, or prefix your answer ` +
+            `with its id, e.g. "${example} your answer".`);
+    }
     function formatStatus() {
         const lines = [];
         lines.push(`Command mode: ${commandMode ? "ON" : "OFF"}`);
-        const pending = store.listPending();
+        const pending = pendingLines();
         if (pending.length === 0) {
             lines.push("Pending questions: none");
         }
         else {
-            lines.push(`Pending questions: ${pending.length} (${pending.map((q) => q.id).join(", ")})`);
+            lines.push(`Pending questions: ${pending.length}`);
+            for (const line of pending)
+                lines.push(`  ${line}`);
         }
         const awaiting = runner.listAwaitingApproval();
         if (awaiting.length === 0) {
@@ -244,13 +287,19 @@ async function main() {
             lines.push(`Active asks: ${activeAsks.map((s) => s.id).join(", ")}`);
         }
         lines.push(`Queued tasks: ${taskQueue.preview()}`);
+        if (commandMode && config.rolling) {
+            const info = runner.rollingInfo();
+            lines.push(`Rolling thread: ${info ? info.agentId : "not started yet"}`);
+            lines.push(`Transcript: ${config.transcriptPath}`);
+        }
         if (commandMode) {
-            lines.push("Commands: /ask question, /plan task, plain text plans too");
+            lines.push("Commands: /ask question, /plan task, plain text plans too, /reset for a new thread");
         }
         return lines.join("\n");
     }
     async function runPlanTask(task, attachments) {
         log(`New task received; planning...`);
+        transcript.append({ role: "you", text: task });
         await send(`Planning your request...`);
         let heartbeat;
         const clearHeartbeat = () => {
@@ -278,14 +327,17 @@ async function main() {
         clearHeartbeat();
         log(`Plan ${session.id} -> ${session.status}`);
         if (session.status === "awaiting_approval") {
+            transcript.append({ role: "plan", id: session.id, text: session.plan ?? "" });
             await send(`Plan (${session.id})\n\n${session.plan ?? ""}\n\nReply YES to run it or NO to cancel.`);
         }
         else {
+            transcript.append({ role: "error", id: session.id, text: session.error ?? "unknown error" });
             await send(`Could not plan that (${session.id}):\n${session.error ?? "unknown error"}`);
         }
     }
     async function runAskQuestion(question, attachments) {
         log(`Ask received; answering...`);
+        transcript.append({ role: "you", text: `/ask ${question}` });
         await send(`Answering...`);
         let heartbeat;
         const clearHeartbeat = () => {
@@ -313,9 +365,11 @@ async function main() {
         clearHeartbeat();
         log(`Ask ${session.id} -> ${session.status}`);
         if (session.status === "done") {
+            transcript.append({ role: "answer", id: session.id, text: session.answer ?? "" });
             await send(`Ask (${session.id})\n\n${session.answer ?? ""}`);
         }
         else {
+            transcript.append({ role: "error", id: session.id, text: session.error ?? "unknown error" });
             await send(`Could not answer (${session.id}):\n${session.error ?? "unknown error"}`);
         }
     }
@@ -359,6 +413,25 @@ async function main() {
             case "status":
                 await send(formatStatus());
                 return;
+            case "pending":
+                await send(formatPendingList());
+                return;
+            case "reset": {
+                if (!commandMode)
+                    return;
+                if (!config.rolling) {
+                    await send("Rolling thread is off; nothing to reset.");
+                    return;
+                }
+                if (isWorkerBusy()) {
+                    await send("BUSY: finish the current work before starting a new thread.");
+                    return;
+                }
+                runner.reset();
+                transcript.append({ role: "system", text: "New rolling thread started (memory cleared)." });
+                await send("Started a fresh thread. The next prompt begins a new conversation.");
+                return;
+            }
             case "approve": {
                 if (!commandMode)
                     return;
@@ -446,22 +519,75 @@ async function main() {
         const text = msg.text.trim();
         if (text === "" && attachments.length === 0)
             return;
+        const recordAnswer = async (matched) => {
+            log(`Recorded answer for ${matched.id} ${labelPrefix(matched.projectLabel, matched.agentLabel)}.`);
+            notifyAnswered(matched.id);
+            await send(`Answer recorded for ${matched.id}.`);
+        };
+        // 1) Explicit target prefix ("Q-3 ...", "#3 ...", "@Q-3 ...") wins over
+        //    everything else, so "Q-3 yes" answers Q-3 rather than reading as a
+        //    command. Only intercept when something is actually pending.
+        if (store.pendingCount() > 0) {
+            const target = parseTargetId(text);
+            if (target) {
+                if (!store.listPending().some((q) => q.id === target.id)) {
+                    await send(`No pending question ${target.id}.\n\n${formatPendingList()}`);
+                    return;
+                }
+                if (target.rest === "" && attachments.length === 0) {
+                    await send(`What's your answer to ${target.id}? Reply: ${target.id} your answer`);
+                    return;
+                }
+                const matched = store.matchAndAnswer(msg, { targetId: target.id, answerText: target.rest });
+                if (matched)
+                    await recordAnswer(matched);
+                return;
+            }
+        }
+        // 2) Swipe-reply to a specific pending question.
         if (isReplyToQuestion(msg, store)) {
             const matched = store.matchAndAnswer(msg);
-            if (matched) {
-                log(`Recorded answer for ${matched.id} [${matched.projectLabel}].`);
-                notifyAnswered(matched.id);
-                await send(`Answer recorded for ${matched.id}.`);
-            }
+            if (matched)
+                await recordAnswer(matched);
             return;
         }
-        if (store.pendingCount() > 0 && !isCommandLike(splitInboundMessage(text))) {
-            const matched = store.matchAndAnswer(msg);
-            if (matched) {
-                log(`Recorded answer for ${matched.id} [${matched.projectLabel}].`);
-                notifyAnswered(matched.id);
-                await send(`Answer recorded for ${matched.id}.`);
-                return;
+        // 3) Bare reply while questions are pending. A yes/no/ok parses as an
+        //    approve/reject COMMAND, but only when command mode is on AND a plan is
+        //    awaiting approval. Otherwise route it to the pending question so answers
+        //    like "Yes" are not silently swallowed.
+        if (store.pendingCount() > 0) {
+            const segs = splitInboundMessage(text);
+            const canApproveNow = commandMode && runner.latestAwaitingApproval() != null;
+            const actionableCommand = segs.some((s) => {
+                switch (s.kind) {
+                    case "ask":
+                    case "ask_empty":
+                    case "plan":
+                    case "plan_empty":
+                    case "status":
+                    case "pending":
+                        return true;
+                    case "reset":
+                        return commandMode;
+                    case "approve":
+                    case "reject":
+                    case "approval_footer":
+                        return canApproveNow;
+                    default:
+                        return false;
+                }
+            });
+            if (!actionableCommand) {
+                if (store.pendingCount() > 1) {
+                    // Ambiguous: don't guess at the oldest. Ask the human to target one.
+                    await send(`You have ${store.pendingCount()} questions waiting — tell me which to answer.\n\n${formatPendingList()}`);
+                    return;
+                }
+                const matched = store.matchAndAnswer(msg);
+                if (matched) {
+                    await recordAnswer(matched);
+                    return;
+                }
             }
         }
         const segments = splitInboundMessage(text);
@@ -481,7 +607,10 @@ async function main() {
             return;
         incomingChain = incomingChain
             .then(() => handleIncoming(msg))
-            .catch((err) => log(`handleIncoming error: ${String(err)}`));
+            .catch((err) => {
+            lastError = `handleIncoming: ${String(err)}`;
+            log(lastError);
+        });
     });
     function rateGuard() {
         const elapsed = Date.now() - lastSendAt;
@@ -492,7 +621,7 @@ async function main() {
     function dedupeMirrorKey(project, question) {
         return `${project}::${question.slice(0, 200)}`;
     }
-    async function mirrorQuestion(project, question) {
+    async function mirrorQuestion(project, question, agent) {
         const key = dedupeMirrorKey(project, question);
         const now = Date.now();
         const last = recentMirrors.get(key);
@@ -501,8 +630,8 @@ async function main() {
             return { id: existing?.id ?? "deduped", mirrored: false };
         }
         recentMirrors.set(key, now);
-        const record = store.addQuestion(project, question);
-        const text = `[${project}] ${record.id}\n${question}\n\nReply to this message to answer.`;
+        const record = store.addQuestion(project, question, agent);
+        const text = `${labelPrefix(project, agent)} ${record.id}\n${question}\n\nReply to this message to answer.`;
         const sentId = await send(text);
         if (sentId)
             store.setSentMessageId(record.id, sentId);
@@ -521,6 +650,10 @@ async function main() {
                     pending: store.pendingCount(),
                     commandMode,
                     queue: taskQueue.length(),
+                    version: WORKER_VERSION,
+                    uptimeSec: Math.floor((Date.now() - startedAt) / 1000),
+                    pollAgeSec: Math.floor(client.lastPollAgeMs() / 1000),
+                    lastError: lastError ?? null,
                 });
             }
             if (method === "POST" && path === "/notify") {
@@ -534,9 +667,10 @@ async function main() {
                 const body = await readJson(req);
                 const summary = String(body.summary ?? "").trim();
                 const project = cleanProject(body.project);
+                const agent = cleanAgent(body.agent);
                 if (!summary)
                     return sendJson(res, 400, { error: "summary is required" });
-                await send(`[${project}] Task complete\n\n${summary}`);
+                await send(`${labelPrefix(project, agent)} Task complete\n\n${summary}`);
                 return sendJson(res, 200, { ok: true });
             }
             if (method === "POST" && (path === "/ask" || path === "/mirror")) {
@@ -550,9 +684,10 @@ async function main() {
                 const body = await readJson(req);
                 const question = String(body.question ?? "").trim();
                 const project = cleanProject(body.project);
+                const agent = cleanAgent(body.agent);
                 if (!question)
                     return sendJson(res, 400, { error: "question is required" });
-                const { id, mirrored } = await mirrorQuestion(project, question);
+                const { id, mirrored } = await mirrorQuestion(project, question, agent);
                 return sendJson(res, 200, { id, mirrored: path === "/mirror" ? mirrored : true });
             }
             if (method === "GET" && path.startsWith("/response/")) {
@@ -616,6 +751,7 @@ async function main() {
             return sendJson(res, 404, { error: "not found" });
         }
         catch (err) {
+            lastError = `http: ${String(err)}`;
             return sendJson(res, 500, { error: String(err) });
         }
     });
@@ -633,6 +769,13 @@ async function main() {
     const sweep = setInterval(() => runner.sweepStale(COMMAND_TTL_MS), 10 * 60_000);
     sweep.unref?.();
     await client.connect().catch((err) => log(`Telegram connection error: ${String(err)}`));
+    // Startup ping: let the human know the worker is back online (opt-out via
+    // TG_STARTUP_PING=0). Includes restored pending-question count so a restart
+    // that recovered state is visible.
+    if (config.startupPing && client.isOpen() && config.chatId !== "") {
+        const restored = restoredPending > 0 ? `, restored ${restoredPending} pending` : "";
+        await send(`Worker online on ${hostname()} (v${WORKER_VERSION}). Command mode ${commandMode ? "ON" : "OFF"}${restored}.`);
+    }
     const shutdown = () => {
         log("Shutting down...");
         server.close();
@@ -643,23 +786,29 @@ async function main() {
     // Self-update: if a task edits the worker's own source, relaunch on the new
     // code once nothing is in flight. Only effective under a KeepAlive supervisor
     // (launchd `npm run worker:install`), which restarts the process after exit.
-    const startFingerprint = sourceFingerprint();
-    function isIdleForRestart() {
-        return (!isWorkerBusy() &&
+    // Disabled when TG_SELF_UPDATE is off: the worker then never restarts itself on
+    // source changes, so in-flight command-mode state can't be wiped mid-task (you
+    // restart manually to pick up new code).
+    if (config.selfUpdateEnabled) {
+        const startFingerprint = sourceFingerprint();
+        const isIdleForRestart = () => !isWorkerBusy() &&
             !draining &&
             taskQueue.length() === 0 &&
             runner.listAwaitingApproval().length === 0 &&
             runner.listActiveAsks().length === 0 &&
-            store.pendingCount() === 0);
+            store.pendingCount() === 0;
+        const updateCheck = setInterval(() => {
+            if (sourceFingerprint() > startFingerprint && isIdleForRestart()) {
+                log("Source changed and worker idle; restarting to load the latest version...");
+                clearInterval(updateCheck);
+                shutdown();
+            }
+        }, UPDATE_CHECK_MS);
+        updateCheck.unref?.();
+    }
+    else {
+        log("Self-update OFF (TG_SELF_UPDATE). Worker will not auto-restart on source changes.");
     }
-    const updateCheck = setInterval(() => {
-        if (sourceFingerprint() > startFingerprint && isIdleForRestart()) {
-            log("Source changed and worker idle; restarting to load the latest version...");
-            clearInterval(updateCheck);
-            shutdown();
-        }
-    }, UPDATE_CHECK_MS);
-    updateCheck.unref?.();
 }
 main().catch((err) => {
     log(`Fatal: ${err?.stack ?? err}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cursor-telegram-mcp",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "Manage Cursor from your phone over Telegram: an MCP server + auto-spawned local worker that notifies you, asks you questions, and (optionally) runs headless Cursor agents you text it. Local, bring-your-own-bot, runs entirely on your machine.",
   "type": "module",
   "license": "MIT",