agentp 0.8.0 → 0.9.0

package/bin/tgagentp

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 
+const http = require('http');
 const https = require('https');
 const fs = require('fs');
 const path = require('path');
@@ -15,8 +16,39 @@ const log = {
 };
 
 const STARTUP_CHAT_FILE = '/tmp/tgagentp-startup-chat';
+const TGAGENTP_PORT = parseInt(process.env.TGAGENTP_PORT || '0', 10);
+const PORT_FILE = '/tmp/tgagentp-port';
+const TGAGENTP_DEBOUNCE_MS = parseInt(process.env.TGAGENTP_DEBOUNCE_MS || '5000', 10);
 const { listServers, activateServer } = require('../lib/ocmux.js');
 
+// Agentp gateway message queue, keyed by server URL
+const agentpQueues = {};
+
+function validateAgentpAuth(req) {
+  const password = process.env.OPENCODE_SERVER_PASSWORD;
+  if (!password) return true;
+  const username = process.env.OPENCODE_SERVER_USERNAME || 'opencode';
+  const expected = 'Basic ' + Buffer.from(`${username}:${password}`).toString('base64');
+  return req.headers.authorization === expected;
+}
+
+function flushAgentpQueue(server, token, chatId) {
+  if (!chatId) return;
+  const q = agentpQueues[server];
+  if (!q || q.messages.length === 0) return;
+  const msgs = q.messages.splice(0);
+  q.notified = false;
+  if (q.notifyTimer) { clearTimeout(q.notifyTimer); q.notifyTimer = null; }
+  sendLongMessage(token, chatId,
+    `📨 Delivering ${msgs.length} queued agentp message(s):`)
+    .then(() => {
+      for (const msg of msgs) {
+        sendLongMessage(token, chatId, msg.trim()).catch(() => {});
+      }
+    })
+    .catch(() => {});
+}
+
 // ---------------------------------------------------------------------------
 // Telegram Bot API helpers
 // ---------------------------------------------------------------------------
@@ -72,7 +104,7 @@ function convertMarkdownToHtml(text) {
 
   return parts.map((part, i) => {
     if (i % 2 === 1) {
-      // Code block — strip language tag, escape entities, wrap in <pre>
+      // Code block ─ strip language tag, escape entities, wrap in <pre>
       const nl = part.indexOf('\n');
       const inner = nl >= 0 ? part.slice(nl + 1) : part;
       return '<pre>' + inner
@@ -207,25 +239,25 @@ async function cmdHelp(token, chatId, args) {
     const topic = args[0].toLowerCase();
     if (topic === 'servers') {
       await sendLongMessage(token, chatId,
-        '`/servers` — list all opencode servers (ocmux sessions)\n' +
-        '`/servers switch <name>` — switch target server\n\n' +
+        '`/servers` ─ list all opencode servers (ocmux sessions)\n' +
+        '`/servers switch <name>` ─ switch target server\n\n' +
         '`<name>` can be a full path or basename of the project directory.');
       return;
     }
     if (topic === 'sessions') {
       await sendLongMessage(token, chatId,
-        '`/sessions` — list active sessions (numbered, newest first, max 50)\n' +
-        '`/sessions switch <number-or-name>` — send messages to a specific session\n' +
-        '`/sessions new [name]` — create a new session\n' +
-        '`/sessions rename <name>` — rename the active session\n\n' +
+        '`/sessions` ─ list active sessions (numbered, newest first, max 50)\n' +
+        '`/sessions switch <number-or-name>` ─ send messages to a specific session\n' +
+        '`/sessions new [name]` ─ create a new session\n' +
+        '`/sessions rename <name>` ─ rename the active session\n\n' +
         'Switch by number (from the list) or by case-insensitive partial name match.\n' +
         'Use `/sessions` to find session numbers.');
       return;
     }
     if (topic === 'shutdown') {
       await sendLongMessage(token, chatId,
-        '`/shutdown` — stop tgagentp process\n' +
-        '`/shutdown force` — force shutdown even if busy (in-flight work will be lost)\n\n' +
+        '`/shutdown` ─ stop tgagentp process\n' +
+        '`/shutdown force` ─ force shutdown even if busy (in-flight work will be lost)\n\n' +
         'Only available when tgagentp is started with `--dev` flag.\n' +
         'Useful when running tgagentp in a restart loop:\n' +
         '`while true; do tgagentp --dev; done`');
@@ -233,32 +265,32 @@ async function cmdHelp(token, chatId, args) {
     }
     if (topic === 'agents') {
       await sendLongMessage(token, chatId,
-        '`/agents` — list all available agents (name, mode, assigned model, description).\n' +
-        '`/agents switch <name>` — switch the active agent. Subsequent messages will use this agent.\n\n' +
+        '`/agents` ─ list primary agents (with ▶ marker for the active one).\n' +
+        '`/agents switch <name>` ─ switch the active agent. Subsequent messages will use this agent.\n\n' +
         'Agent switching requires an active session (`/sessions switch` or `/sessions new`).');
       return;
     }
     if (topic === 'session') {
       await sendLongMessage(token, chatId,
         '`/session` is an alias for `/sessions`.\n\n' +
-        '`/sessions` — list active sessions\n' +
-        '`/sessions switch <number-or-name>` — switch to a session\n' +
-        '`/sessions new [name]` — create a new session\n' +
-        '`/sessions rename <name>` — rename the active session');
+        '`/sessions` ─ list active sessions\n' +
+        '`/sessions switch <number-or-name>` ─ switch to a session\n' +
+        '`/sessions new [name]` ─ create a new session\n' +
+        '`/sessions rename <name>` ─ rename the active session');
       return;
     }
     if (topic === 'models') {
       await sendLongMessage(token, chatId,
-        '`/models` — list all providers and their models.\n' +
+        '`/models` ─ list all providers and their models.\n' +
         'Shows provider name, connection status, default model, and up to 5 models per provider\n' +
         'with status, context limit, and input/output costs.');
       return;
     }
     if (topic === 'allow' || topic === 'reject' || topic === 'always') {
       await sendLongMessage(token, chatId,
-        '`/allow` — approve a permission request once\n' +
-        '`/reject` — deny a permission request\n' +
-        '`/always` — approve and remember for the session\n\n' +
+        '`/allow` ─ approve a permission request once\n' +
+        '`/reject` ─ deny a permission request\n' +
+        '`/always` ─ approve and remember for the session\n\n' +
         'These commands respond to OpenCode permission prompts forwarded by tgagentp.\n' +
         'When OpenCode needs approval (e.g. to run a shell command), tgagentp sends a\n' +
         '🔐 notification to the chat. Use one of these commands to answer.');
@@ -266,10 +298,10 @@ async function cmdHelp(token, chatId, args) {
     }
     if (topic === 'think') {
       await sendLongMessage(token, chatId,
-        '`/think` — toggle thinking message forwarding\n' +
-        '`/think on` — forward model thinking to the chat in real-time\n' +
-        '`/think off` — stop forwarding thinking messages (default)\n' +
-        '`/think switch` — toggle current state\n\n' +
+        '`/think` ─ toggle thinking message forwarding\n' +
+        '`/think on` ─ forward model thinking to the chat in real-time\n' +
+        '`/think off` ─ stop forwarding thinking messages (default)\n' +
+        '`/think switch` ─ toggle current state\n\n' +
         'When enabled, the model\'s internal reasoning steps are sent to the chat\n' +
         'as they are generated, prefixed with 💭.\n' +
         'Can also be enabled at startup with `--think` flag.');
@@ -280,23 +312,23 @@ async function cmdHelp(token, chatId, args) {
     return;
   }
   await sendLongMessage(token, chatId,
-    '`/help` — show this message\n' +
-    '`/help <topic>` — detailed help\n' +
-    '`/status` — show current server and session\n' +
-    '`/cancel` — cancel the running prompt\n' +
-    '`/servers` — list running opencode servers\n' +
-    '`/servers switch <name>` — switch to a different server\n' +
-    '`/sessions` — list/create/switch/rename sessions\n' +
-    '`/sessions switch <number-or-name>` — switch to a session\n' +
-    '`/sessions new [name]` — create a new session\n' +
-    '`/sessions rename <name>` — rename the active session\n' +
-    '`/session` — alias for `/sessions`\n' +
-    '`/agents` — list available agents\n' +
-    '`/agents switch <name>` — switch active agent\n' +
-    '`/models` — list providers and models\n' +
-    '`/think` — toggle thinking message forwarding\n' +
-    '`/allow` / `/reject` / `/always` — respond to permission requests\n' +
-    '`/shutdown` — stop tgagentp (only with `--dev` flag)\n\n' +
+    '`/help` ─ show this message\n' +
+    '`/help <topic>` ─ detailed help\n' +
+    '`/status` ─ show current server and session\n' +
+    '`/cancel` ─ cancel the running prompt\n' +
+    '`/servers` ─ list running opencode servers\n' +
+    '`/servers switch <name>` ─ switch to a different server\n' +
+    '`/sessions` ─ list/create/switch/rename sessions\n' +
+    '`/sessions switch <number-or-name>` ─ switch to a session\n' +
+    '`/sessions new [name]` ─ create a new session\n' +
+    '`/sessions rename <name>` ─ rename the active session\n' +
+    '`/session` ─ alias for `/sessions`\n' +
+    '`/agents` ─ list available agents\n' +
+    '`/agents switch <name>` ─ switch active agent\n' +
+    '`/models` ─ list providers and models\n' +
+    '`/think` ─ toggle thinking message forwarding\n' +
+    '`/allow` / `/reject` / `/always` ─ respond to permission requests\n' +
+    '`/shutdown` ─ stop tgagentp (only with `--dev` flag)\n\n' +
     'Everything else is forwarded to the active server as `[Telegram] <text>`.');
 }
 
@@ -493,10 +525,10 @@ async function cmdSessions(token, chatId, args, setServer, setActiveSession, ser
     await sendLongMessage(token, chatId,
       `Unknown subcommand: /sessions ${sub}\n\n` +
       'Usage:\n' +
-      '  `/sessions` — list sessions\n' +
-      '  `/sessions switch <number-or-name>` — switch to a session\n' +
-      '  `/sessions new [name]` — create a new session\n' +
-      '  `/sessions rename <name>` — rename the active session');
+      '  `/sessions` ─ list sessions\n' +
+      '  `/sessions switch <number-or-name>` ─ switch to a session\n' +
+      '  `/sessions new [name]` ─ create a new session\n' +
+      '  `/sessions rename <name>` ─ rename the active session');
     return;
   }
 
@@ -596,10 +628,14 @@ async function cmdAgents(token, chatId, args, setServer, setActiveSession, serve
       }
       const target = matches[0];
       getState(server).activeAgentName = target.name;
-      const mode = target.mode === 'primary' ? '' : ` (${target.mode})`;
-      const model = target.model ? ` — \`${target.model.providerID}/${target.model.modelID}\`` : '';
+      const st = getState(server);
+      if (st.activeSessionId) {
+        updateSession(server, st.activeSessionId, undefined, target.name);
+        selectSession(server, st.activeSessionId);
+      }
+      const model = target.model ? ` ─ \`${target.model.providerID}/${target.model.modelID}\`` : '';
       await sendLongMessage(token, chatId,
-        `Switched to agent: **${target.name}**${mode}${model}\nSubsequent messages will use this agent.`);
+        `Switched to agent: **${target.name}**${model}\nSubsequent messages will use this agent.`);
     } catch (err) {
       await sendLongMessage(token, chatId, `Error switching agent: ${err.message}`);
     }
@@ -612,13 +648,19 @@ async function cmdAgents(token, chatId, args, setServer, setActiveSession, serve
       await sendLongMessage(token, chatId, 'No agents available.');
       return;
     }
-    const lines = agents.map(a => {
-      const mode = a.mode === 'primary' ? '' : ` (${a.mode})`;
-      const model = a.model ? ` — \`${a.model.providerID}/${a.model.modelID}\`` : '';
+    const primary = agents.filter(a => a.mode === 'primary');
+    if (primary.length === 0) {
+      await sendLongMessage(token, chatId, 'No primary agents available.');
+      return;
+    }
+    const activeAgentName = getState(server).activeAgentName;
+    const lines = primary.map(a => {
+      const bullet = a.name === activeAgentName ? '▶ ' : ' · ';
+      const model = a.model ? ` ─ \`${a.model.providerID}/${a.model.modelID}\`` : '';
       const desc = a.description ? `. ${a.description}` : '';
-      return '**' + a.name + '**' + mode + model + desc;
+      return bullet + '**' + a.name + '**' + model + desc;
     });
-    await sendLongMessage(token, chatId, 'Agents:\n' + lines.join('\n'));
+    await sendLongMessage(token, chatId, 'Primary agents:\n' + lines.join('\n'));
   } catch (err) {
     await sendLongMessage(token, chatId, `Error listing agents: ${err.message}`);
   }
@@ -664,6 +706,88 @@ async function cmdModels(token, chatId, args, setServer, setActiveSession, serve
 
 const PERM_RESPONSE_HELP = ' No pending permission. Use `/status` to check the current state.';
 
+// ---------------------------------------------------------------------------
+// Agentp gateway ─ tiny HTTP server for agentp --tg
+// ---------------------------------------------------------------------------
+
+function startAgentpGateway(token, chatIdResolver, serverBaseResolver) {
+  return new Promise((resolve) => {
+    const server = http.createServer((req, res) => {
+      try {
+        if (req.method !== 'POST' || req.url !== '/send') {
+          res.writeHead(405);
+          res.end('Method Not Allowed');
+          return;
+        }
+        if (!validateAgentpAuth(req)) {
+          res.writeHead(401);
+          res.end('Unauthorized');
+          return;
+        }
+        let body = '';
+        req.on('data', (chunk) => { body += chunk; });
+        req.on('end', () => {
+          try {
+            let data;
+            try { data = JSON.parse(body); } catch {
+              res.writeHead(400);
+              res.end('Bad Request');
+              return;
+            }
+            const { text, server } = data;
+            if (typeof text !== 'string' || typeof server !== 'string') {
+              res.writeHead(400);
+              res.end('Bad Request: text and server are required');
+              return;
+            }
+            res.writeHead(200);
+            res.end('OK');
+
+            const chatId = chatIdResolver();
+            if (!chatId) return;
+            const activeUrl = normalizeUrl(serverBaseResolver());
+            const targetUrl = normalizeUrl(server);
+
+            if (targetUrl === activeUrl) {
+              sendLongMessage(token, chatId, text.trim()).catch(() => {});
+            } else {
+              if (!agentpQueues[server]) {
+                agentpQueues[server] = { messages: [], notifyTimer: null, notified: false };
+              }
+              const q = agentpQueues[server];
+              q.messages.push(text);
+              if (!q.notifyTimer) {
+                q.notifyTimer = setTimeout(() => {
+                  q.notifyTimer = null;
+                  if (q.messages.length > 0 && !q.notified) {
+                    q.notified = true;
+                    sendLongMessage(token, chatId,
+                      `📥 ${q.messages.length} agentp message(s) queued for server \`${server}\`. Switch servers to view them.`)
+                      .catch(() => {});
+                  }
+                }, TGAGENTP_DEBOUNCE_MS);
+              }
+            }
+          } catch (err) {
+            log.error(`Agentp gateway handler error: ${err.message}`);
+          }
+        });
+      } catch (err) {
+        log.error(`Agentp gateway handler error: ${err.message}`);
+      }
+    });
+    server.on('error', (err) => {
+      log.error(`Agentp gateway server error: ${err.message}`);
+    });
+    server.listen(TGAGENTP_PORT, '127.0.0.1', () => {
+      const port = server.address().port;
+      try { fs.writeFileSync(PORT_FILE, String(port)); } catch (_) {}
+      log.info(`Agentp gateway listening on port ${port}`);
+      resolve(port);
+    });
+  });
+}
+
 async function cmdAllow(token, chatId, args, setServer, setActiveSession, server) {
   const st = getState(server);
   if (!st.pendingPermission) {
@@ -797,10 +921,15 @@ async function main() {
       console.error('');
       console.error('Environment variables:');
       console.error('  TELEGRAM_BOT_TOKEN         Telegram bot token (required)');
-      console.error('  OPENCODE_SERVER_PASSWORD    OpenCode server password (optional)');
+      console.error('  OPENCODE_SERVER_PASSWORD    OpenCode server password (optional, also used for agentp gateway auth)');
       console.error('  OPENCODE_SERVER_USERNAME    OpenCode server username (optional, default: opencode)');
       console.error('  TGAGENTP_ALLOWED_CHAT_IDS   Comma-separated Telegram chat IDs (optional)');
       console.error('                               Example: "123456,-789012"');
+      console.error('  TGAGENTP_PORT               Agentp gateway listen port (optional, default: random)');
+      console.error('  TGAGENTP_DEBOUNCE_MS        Debounce interval for queued agentp messages (optional, default: 5000)');
+      console.error('');
+      console.error('Also starts an agentp gateway (tiny HTTP server on localhost) that');
+      console.error('accepts POST /send from agentp --tg and forwards answers to Telegram.');
       console.error('');
       console.error('See also: agentp, ocmux');
       console.error('');
@@ -859,10 +988,19 @@ async function main() {
 
   log.info('Waiting for Telegram messages... (Ctrl+C to stop)');
 
+  // Start agentp gateway (tiny HTTP server for agentp --tg)
+  const chatIdResolver = () => lockedChatId;
+  const serverBaseResolver = () => serverBase;
+  startAgentpGateway(token, chatIdResolver, serverBaseResolver);
+
   const setServer = async (url) => {
     serverBase = url;
     getState(url);
     log.info(`Switched to server: ${url}`);
+
+    // Flush agentp queue for the new active server
+    flushAgentpQueue(url, token, lockedChatId);
+
     const [discovered, agents] = await Promise.all([
       discoverActiveSession(url),
       listAgents(url).catch(() => []),
@@ -894,18 +1032,27 @@ async function main() {
     const st = getState(url);
     const isCancelled = () => getState(url).taskId !== myTaskId;
     const cancelRef = { current: null };
+    const sessionCancelRef = { current: null };
     st._cancelRef = cancelRef;
+    st._sessionReq = sessionCancelRef;
     try {
       let answer;
       if (useSession) {
-        // Event-driven flow: start SSE listener first, then send message async
+        // Dual approach:
+        // 1. SSE for permissions/thinking events (connected before sending)
+        // 2. Synchronous sendToSession (POST /session/:id/message) for reliable answer
         const notifiedPerms = new Set();
         let thinkingBuf = '';
-        const ssePromise = listenForSessionEvents(url, sessionId, {
+        let sseConnected;
+        const onConnected = Promise.race([
+          new Promise((resolve) => { sseConnected = resolve; }),
+          new Promise((resolve) => setTimeout(resolve, 5000)),
+        ]);
+        listenForSessionEvents(url, sessionId, {
           onText: null,
+          onConnected: sseConnected,
           onThinking: (chunk) => {
             if (!getState(url).thinkingEnabled) { thinkingBuf = ''; return; }
-            // Forward thinking chunks in real-time
             thinkingBuf += chunk;
             if (thinkingBuf.length >= 50 || chunk.endsWith('\n')) {
               const html = '💭 ' + thinkingBuf.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
@@ -942,23 +1089,18 @@ async function main() {
             log.debug(`  → permission_replied: clearing pendingPermission`);
             getState(url).pendingPermission = null;
           },
-        }, cancelRef);
-        // Send message (SSE is already listening — no race)
-        try {
-          await sendToSessionAsync(url, sessionId, `[Telegram] ${text}`, st.activeAgentName);
-        } catch (err) {
-          // Abort SSE listener on send failure to avoid resource leak
-          if (cancelRef.current) { cancelRef.current.destroy(); cancelRef.current = null; }
-          throw err;
-        }
-        // Wait for the SSE listener to collect the full answer
-        answer = await ssePromise;
+        }, cancelRef).catch(() => {});
+        // Wait for SSE to connect, then send synchronously
+        await onConnected;
+        answer = await sendToSession(url, sessionId, `[Telegram] ${text}`, st.activeAgentName, sessionCancelRef);
         // Flush any remaining thinking buffer
         if (thinkingBuf) {
           const html = '💭 ' + thinkingBuf.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
           sendLongMessage(token, chatId, html, replyTo).catch(() => {});
           thinkingBuf = '';
         }
+        // Clean up SSE listener
+        if (cancelRef.current) { cancelRef.current.destroy(); cancelRef.current = null; }
       } else {
         await sendText(url, `[Telegram] ${text}`);
         answer = await listenForFinalAnswer(url, null, cancelRef);
@@ -978,6 +1120,8 @@ async function main() {
         await sendLongMessage(token, chatId, `✅ Server \`${url}\` finished processing. Switch back to see the response.`, replyTo);
       }
     } catch (err) {
+      // Clean up SSE listener if it's still active
+      if (cancelRef.current) { cancelRef.current.destroy(); cancelRef.current = null; }
       if (isCancelled()) {
         log.debug(`  → cancelled, ignoring error from ${url}: ${err.message}`);
         st.pendingPermission = null;
@@ -990,6 +1134,7 @@ async function main() {
     } finally {
       st.pendingPermission = null;
       if (st._cancelRef === cancelRef) st._cancelRef = null;
+      if (st._sessionReq === sessionCancelRef) st._sessionReq = null;
       if (!isCancelled()) {
         getState(url).busy = false;
       }
@@ -1009,6 +1154,11 @@ async function main() {
       st._cancelRef.current.destroy();
       st._cancelRef.current = null;
     }
+    // Abort the synchronous session request if in progress
+    if (st._sessionReq && st._sessionReq.current) {
+      st._sessionReq.current.destroy();
+      st._sessionReq.current = null;
+    }
     await sendLongMessage(token, chatId, '✅ Cancelled.');
     log.debug(`  → /cancel on ${serverBase}`);
   }
@@ -1062,6 +1212,7 @@ async function main() {
     lines.push('**Session:** ' + sessionLabel(st));
     lines.push('**Agent:** ' + (st.activeAgentName ? '`' + st.activeAgentName + '`' : '*default*'));
     try { await sendLongMessage(token, savedChatId, lines.join('\n')); } catch (_) {}
+    lockedChatId = savedChatId;
     try { fs.unlinkSync(STARTUP_CHAT_FILE); } catch (_) {}
   }
 
@@ -1139,7 +1290,7 @@ async function main() {
         continue;
       }
 
-      // Non-command message — process in background
+      // Non-command message ─ process in background
       const st = getState(serverBase);
       if (st.busy) {
         await sendLongMessage(token, chatId, '⏳ Server is busy processing a previous message. Please wait for it to finish, or use /cancel to cancel it.');