opencode-plugin-teleprompt 0.1.12 → 0.2.1

package/dist/runtime/controller.js

@@ -1,5 +1,6 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
+import { appendFileSync } from "node:fs";
 import { getCurrentOrCreateSessionID } from "../opencode/binding.js";
 import { replyPermission, toPendingPermission, formatPermissionRequestMessage } from "../opencode/permissions.js";
 import { createTelegramUserMessageID, submitPrompt } from "../opencode/submit.js";
@@ -119,6 +120,7 @@ function resolvePresetModel(preset, models) {
 export class BridgeController {
     api;
     config;
+    storePath;
     deps;
     instanceID;
     client;
@@ -136,9 +138,11 @@ export class BridgeController {
     lastEscAt = 0;
     sessionCredentials;
     activePromptCheckInFlight = false;
+    completionInFlight = false;
     constructor(api, config, storePath, deps) {
         this.api = api;
         this.config = config;
+        this.storePath = storePath;
         this.deps = { ...DEFAULT_DEPS, ...deps };
         this.instanceID = this.deps.randomID();
         this.client = api.client;
@@ -146,6 +150,16 @@ export class BridgeController {
         this.store = new BridgeStore(storePath, config.channelID ?? "");
         this.lease = new LeaseManager(this.instanceID, this.deps.now, config.leaseTtlMs);
     }
+    log(message) {
+        try {
+            const logPath = this.storePath.replace(/\.json$/, ".log");
+            const timestamp = new Date().toISOString();
+            appendFileSync(logPath, `[${timestamp}] ${message}\n`, "utf8");
+        }
+        catch {
+            // ignore
+        }
+    }
     async init() {
         this.data = await this.store.load();
     }
@@ -156,7 +170,17 @@ export class BridgeController {
         this.config.botToken = resolvedCredentials.botToken;
         this.config.channelID = resolvedCredentials.channelID;
         this.store.setChannelID(resolvedCredentials.channelID);
+        this.log(`bindCurrent: api.route.current = ${JSON.stringify(this.api.route.current)}`);
+        try {
+            const listResponse = await this.client.session.list({ directory: this.api.state.path.directory }, { responseStyle: "data", throwOnError: true });
+            const sessions = Array.isArray(listResponse) ? listResponse : (listResponse?.sessions || listResponse?.items || listResponse?.data || []);
+            this.log(`bindCurrent: available sessions: ${JSON.stringify(sessions.map((s) => ({ id: s.id, title: s.title })))}`);
+        }
+        catch (e) {
+            this.log(`bindCurrent: failed to list sessions: ${String(e)}`);
+        }
         const sessionID = await getCurrentOrCreateSessionID(this.api, this.client);
+        this.log(`bindCurrent: getCurrentOrCreateSessionID returned ${sessionID}`);
         const state = await this.syncState();
         const claimed = this.lease.claim(state);
         const next = this.resetBoundSessionState(claimed, sessionID, resolvedCredentials.channelID);
@@ -222,10 +246,12 @@ export class BridgeController {
         return lines.join("\n");
     }
     async handleTelegramCommand(command) {
+        this.log(`handleTelegramCommand: kind=${command.command.kind}, updateID=${command.updateID}, messageID=${command.messageID}`);
         const state = await this.syncState();
         const isOwner = this.lease.isOwner(state);
         const alwaysAllowed = new Set(["status", "who", "health", "reclaim", "version"]);
         if (!isOwner && !alwaysAllowed.has(command.command.kind)) {
+            this.log(`handleTelegramCommand: rejected because not owner (isOwner=${isOwner}, kind=${command.command.kind})`);
             await this.telegram.sendMessage(this.config.channelID, "Bridge is currently owned by another OpenCode instance. Use /tp:reclaim first.", { replyToMessageID: command.messageID });
             return;
         }
@@ -308,9 +334,11 @@ export class BridgeController {
             return;
         }
         if (state.bound.status !== "online" || !state.bound.sessionID) {
+            this.log(`handleTelegramCommand: rejected because offline or missing session ID (status=${state.bound.status}, sessionID=${state.bound.sessionID})`);
             await this.telegram.sendMessage(this.config.channelID, "Bridge is offline. Run /tp:start in OpenCode first.", { replyToMessageID: command.messageID });
             return;
         }
+        this.log(`handleTelegramCommand: accepting prompt, sending accepted to Telegram`);
         await this.telegram.sendMessage(this.config.channelID, "accepted", { replyToMessageID: command.messageID });
         const job = {
             telegramUpdateID: command.updateID,
@@ -414,19 +442,32 @@ export class BridgeController {
         });
     }
     async processPromptQueue() {
-        if (this.processingQueue)
+        if (this.processingQueue) {
+            this.log("processPromptQueue: queue processing already in progress");
             return;
+        }
         this.processingQueue = true;
+        this.log("processPromptQueue: started processing queue");
         try {
             while (true) {
                 const state = await this.syncState();
-                if (!this.lease.isOwner(state))
+                if (!this.lease.isOwner(state)) {
+                    this.log(`processPromptQueue: stopped - not owner of lease`);
                     return;
-                if (state.activePrompt || state.promptQueue.length === 0)
+                }
+                if (state.activePrompt) {
+                    this.log(`processPromptQueue: stopped - another prompt is active (activePromptID=${state.activePrompt.userMessageID})`);
+                    return;
+                }
+                if (state.promptQueue.length === 0) {
+                    this.log(`processPromptQueue: queue is empty`);
                     return;
+                }
                 const job = state.promptQueue[0];
-                if (!state.bound.sessionID)
+                if (!state.bound.sessionID) {
+                    this.log(`processPromptQueue: error - missing sessionID in state`);
                     return;
+                }
                 const startedAt = this.deps.now();
                 const activeJob = {
                     ...job,
@@ -438,16 +479,20 @@ export class BridgeController {
                     promptQueue: state.promptQueue.slice(1),
                 };
                 await this.persist(next);
+                this.log(`processPromptQueue: activeJob set to userMessageID=${activeJob.userMessageID}`);
                 this.api.ui.toast({
                     variant: "info",
                     message: `Teleprompt: sending prompt to session ${state.bound.sessionID}...`,
                 });
-                await this.telegram.sendMessage(this.config.channelID, "running", { replyToMessageID: activeJob.telegramMessageID });
                 try {
-                    const submitted = await submitPrompt(this.client, state.bound.sessionID, job.prompt, job.telegramUpdateID, state.bound.model);
+                    this.log(`processPromptQueue: submitting to client: prompt="${job.prompt}"`);
+                    const submitted = await submitPrompt(this.client, state.bound.sessionID, job.prompt, job.telegramUpdateID, this.api.state.path.directory, state.bound.model);
+                    this.log(`processPromptQueue: submitted successfully. userMessageID=${submitted.userMessageID}, assistantMessageID=${submitted.assistantMessageID}. Waiting for completion...`);
                     await this.waitForPromptCompletion(state.bound.sessionID, submitted.userMessageID, submitted.assistantMessageID);
+                    this.log(`processPromptQueue: completed successfully`);
                 }
                 catch (error) {
+                    this.log(`processPromptQueue: execution failed: ${String(error)}`);
                     const latest = await this.requireState();
                     if (latest.activePrompt?.userMessageID === activeJob.userMessageID) {
                         await this.persist(this.appendPromptHistory({
@@ -468,37 +513,52 @@ export class BridgeController {
         }
         finally {
             this.processingQueue = false;
+            this.log("processPromptQueue: finished processing queue");
         }
     }
-    async onAssistantCompleted(sessionID, assistantMessageID, parentUserMessageID) {
-        await this.completeActivePrompt(sessionID, assistantMessageID, parentUserMessageID);
+    async onAssistantCompleted(_sessionID, _assistantMessageID, _parentUserMessageID) {
+        // Intentionally a no-op. Completion is handled by waitForPromptCompletion
+        // polling. The event stream fires for EVERY completed assistant message,
+        // including intermediate ones during the agent tool-call loop, so reacting
+        // here would prematurely abort the agent before the final answer arrives.
     }
     async completeActivePrompt(sessionID, assistantMessageID, diffMessageID, directParts) {
-        const state = await this.syncState();
-        if (!this.lease.isOwner(state))
-            return;
-        if (!state.activePrompt)
+        // Guard against duplicate completion from event stream + polling race
+        if (this.completionInFlight)
             return;
-        if (state.bound.sessionID !== sessionID)
-            return;
-        const summary = await this.buildSummary(sessionID, assistantMessageID, diffMessageID, directParts);
-        const completedAt = this.deps.now();
-        const elapsed = completedAt - (state.activePrompt.startedAt ?? state.activePrompt.createdAt);
-        const message = formatSummaryForTelegram(summary, this.config.summaryMaxChars);
-        await this.telegram.sendMessage(this.config.channelID, `completed in ${formatAgeMs(Math.max(0, elapsed))}`, { replyToMessageID: state.activePrompt.telegramMessageID });
-        await this.telegram.sendMessage(this.config.channelID, message, { replyToMessageID: state.activePrompt.telegramMessageID });
-        await this.persist(this.appendPromptHistory({
-            ...state,
-            activePrompt: undefined,
-        }, {
-            jobID: state.activePrompt.userMessageID,
-            prompt: state.activePrompt.prompt,
-            summary: summary.text,
-            changedFiles: summary.changedFiles,
-            status: "completed",
-            at: completedAt,
-        }));
-        await this.processPromptQueue();
+        this.completionInFlight = true;
+        try {
+            const state = await this.syncState();
+            if (!this.lease.isOwner(state))
+                return;
+            if (!state.activePrompt)
+                return;
+            if (state.bound.sessionID !== sessionID)
+                return;
+            // Removed session.abort() because we want the agent to finish its turn naturally,
+            // avoiding "interrupted" UI states.
+            const summary = await this.buildSummary(sessionID, assistantMessageID, diffMessageID, directParts);
+            const completedAt = this.deps.now();
+            const elapsed = completedAt - (state.activePrompt.startedAt ?? state.activePrompt.createdAt);
+            const resultText = formatSummaryForTelegram(summary, this.config.summaryMaxChars);
+            const combinedMessage = `✅ completed in ${formatAgeMs(Math.max(0, elapsed))}\n\n${resultText}`;
+            await this.telegram.sendMessage(this.config.channelID, combinedMessage, { replyToMessageID: state.activePrompt.telegramMessageID });
+            await this.persist(this.appendPromptHistory({
+                ...state,
+                activePrompt: undefined,
+            }, {
+                jobID: state.activePrompt.userMessageID,
+                prompt: state.activePrompt.prompt,
+                summary: summary.text,
+                changedFiles: summary.changedFiles,
+                status: "completed",
+                at: completedAt,
+            }));
+            await this.processPromptQueue();
+        }
+        finally {
+            this.completionInFlight = false;
+        }
     }
     async onUserMessage(sessionID, userMessageID) {
         const state = await this.syncState();
@@ -508,12 +568,12 @@ export class BridgeController {
             return;
         if (state.bound.sessionID !== sessionID)
             return;
-        if (userMessageID.startsWith("tg-"))
+        if (userMessageID.startsWith("msg_tg_"))
             return;
         if (state.activePrompt)
             return;
         try {
-            await this.client.session.abort({ path: { id: sessionID } });
+            await this.client.session.abort({ sessionID, directory: this.api.state.path.directory });
         }
         catch { }
         this.api.ui.toast({
@@ -653,14 +713,7 @@ export class BridgeController {
             .trim();
         let changedFiles = [];
         try {
-            const diffResponse = await this.client.session.message({
-                path: {
-                    id: sessionID,
-                    messageID: userMessageID,
-                },
-                responseStyle: "data",
-                throwOnError: true,
-            });
+            const diffResponse = await this.client.session.message({ sessionID, messageID: userMessageID, directory: this.api.state.path.directory }, { responseStyle: "data", throwOnError: true });
             const diff = diffResponse?.diff;
             changedFiles = (diff || []).map((item) => item.file);
         }
@@ -804,11 +857,7 @@ export class BridgeController {
             return;
         }
         try {
-            await this.client.session.summarize({
-                path: { id: state.bound.sessionID },
-                responseStyle: "data",
-                throwOnError: true,
-            });
+            await this.client.session.summarize({ sessionID: state.bound.sessionID, directory: this.api.state.path.directory }, { responseStyle: "data", throwOnError: true });
             await this.telegram.sendMessage(this.config.channelID, `Compaction requested for session ${state.bound.sessionID}.`, { replyToMessageID });
         }
         catch (error) {
@@ -932,7 +981,7 @@ export class BridgeController {
             return;
         }
         try {
-            await this.client.session.abort({ path: { id: state.bound.sessionID } });
+            await this.client.session.abort({ sessionID: state.bound.sessionID, directory: this.api.state.path.directory });
             const latest = await this.requireState();
             if (latest.activePrompt?.userMessageID === state.activePrompt.userMessageID) {
                 await this.persist(this.appendPromptHistory({
@@ -1006,11 +1055,7 @@ export class BridgeController {
         if (!sessionID)
             return undefined;
         try {
-            const response = await this.client.session.get({
-                path: { id: sessionID },
-                responseStyle: "data",
-                throwOnError: true,
-            });
+            const response = await this.client.session.get({ sessionID, directory: this.api.state.path.directory }, { responseStyle: "data", throwOnError: true });
             const title = response?.title ?? response?.session?.title;
             if (typeof title === "string" && title.trim().length > 0)
                 return title.trim();
@@ -1271,13 +1316,7 @@ export class BridgeController {
             return;
         this.activePromptCheckInFlight = true;
         try {
-            const response = await this.client.session.messages({
-                path: {
-                    id: state.bound.sessionID,
-                },
-                responseStyle: "data",
-                throwOnError: true,
-            });
+            const response = await this.client.session.messages({ sessionID: state.bound.sessionID, directory: this.api.state.path.directory }, { responseStyle: "data", throwOnError: true });
             const messages = Array.isArray(response) ? response : (response?.messages || response?.items || response?.data || []);
             const threshold = (state.activePrompt.startedAt ?? state.activePrompt.createdAt) - 1_000;
             const latestCompletedAssistant = [...messages]
@@ -1300,17 +1339,17 @@ export class BridgeController {
     }
     async clearTuiPrompt() {
         try {
-            await this.client.tui.clearPrompt({
-                responseStyle: "data",
-                throwOnError: true,
-            });
+            await this.client.tui.clearPrompt({}, { responseStyle: "data", throwOnError: true });
         }
         catch { }
     }
-    async waitForPromptCompletion(sessionID, userMessageID, assistantMessageID) {
+    async waitForPromptCompletion(sessionID, userMessageID, _assistantMessageID) {
         const startedAt = this.deps.now();
         const timeoutMs = 10 * 60 * 1000;
         const pollEveryMs = 2000;
+        const stableDelayMs = 3000; // Wait 3s of no new messages before declaring done
+        let lastSeenAssistantID;
+        let stableSince;
         while (this.deps.now() - startedAt < timeoutMs) {
             const state = await this.syncState();
             if (!this.lease.isOwner(state))
@@ -1320,41 +1359,68 @@ export class BridgeController {
             if (!state.activePrompt || state.activePrompt.userMessageID !== userMessageID)
                 return;
             try {
-                const response = await this.client.session.messages({
-                    path: {
-                        id: sessionID,
-                    },
-                    responseStyle: "data",
-                    throwOnError: true,
-                });
+                // 1. Poll the session status
+                let isIdle = false;
+                try {
+                    const statusResponse = await this.client.session.status({ query: { directory: this.api.state.path.directory } }, { responseStyle: "data", throwOnError: true });
+                    const statusType = statusResponse?.type || statusResponse?.data?.type;
+                    isIdle = statusType === "idle";
+                }
+                catch (statusErr) {
+                    this.log(`waitForPromptCompletion: failed to get session status: ${String(statusErr)}`);
+                }
+                const response = await this.client.session.messages({ sessionID, directory: this.api.state.path.directory }, { responseStyle: "data", throwOnError: true });
                 const messages = Array.isArray(response) ? response : (response?.messages || response?.items || response?.data || []);
+                // 2. Find the user message created after we started
+                const userMessage = [...messages]
+                    .reverse()
+                    .find((entry) => {
+                    const info = entry?.info;
+                    if (info?.role !== "user")
+                        return false;
+                    const created = info?.time?.created || 0;
+                    if (created > 0 && created < startedAt - 5000)
+                        return false;
+                    return true;
+                });
+                const actualUserMessageID = userMessage?.info?.id || userMessageID;
+                // Find the LATEST completed assistant message created after we started
                 const completedAssistant = [...messages]
                     .reverse()
                     .find((entry) => {
                     const info = entry?.info;
                     if (info?.role !== "assistant")
                         return false;
-                    if (assistantMessageID && info.id !== assistantMessageID)
+                    if (!info?.time?.completed)
                         return false;
-                    if (info?.error)
-                        return true;
-                    const isCompleted = typeof info?.time?.completed === "number";
-                    if (!isCompleted)
+                    const created = info?.time?.created || 0;
+                    if (created > 0 && created < startedAt - 5000)
                         return false;
-                    // If we don't have a specific ID, ensure this message wasn't created before we started
-                    if (!assistantMessageID) {
-                        const created = info?.time?.created || 0;
-                        if (created > 0 && created < startedAt - 5000)
-                            return false; // 5s buffer
-                    }
                     return true;
                 });
                 if (completedAssistant?.info?.id) {
                     if (completedAssistant.info.error) {
                         throw new Error(`Assistant error: ${JSON.stringify(completedAssistant.info.error)}`);
                     }
-                    await this.completeActivePrompt(sessionID, completedAssistant.info.id, userMessageID, completedAssistant.parts);
-                    return;
+                    // If the session status is idle, we can fast-path immediately
+                    if (isIdle) {
+                        this.log(`waitForPromptCompletion: session is idle, fast-path completing`);
+                        await this.completeActivePrompt(sessionID, completedAssistant.info.id, actualUserMessageID, completedAssistant.parts);
+                        return;
+                    }
+                    // Stable-state detection: wait until no NEW assistant messages appear
+                    if (completedAssistant.info.id !== lastSeenAssistantID) {
+                        // New message appeared — reset the stability timer
+                        lastSeenAssistantID = completedAssistant.info.id;
+                        stableSince = this.deps.now();
+                        this.log(`waitForPromptCompletion: new assistant message ${completedAssistant.info.id}, resetting stability timer`);
+                    }
+                    else if (stableSince && (this.deps.now() - stableSince >= stableDelayMs)) {
+                        // Same message for stableDelayMs — model has stopped, we're done
+                        this.log(`waitForPromptCompletion: stable for ${stableDelayMs}ms, completing`);
+                        await this.completeActivePrompt(sessionID, completedAssistant.info.id, actualUserMessageID, completedAssistant.parts);
+                        return;
+                    }
                 }
             }
             catch (err) {