agentp 0.11.0 → 0.11.2

package/README.md

@@ -230,17 +230,7 @@ Non-text Telegram updates (photos, stickers, etc.) are silently ignored.
 |---|---|
 | `/help [topic]` | Show general help or help for a topic (`servers`, `sessions`, `agents`, `models`, `allow`, `think`, `record`, `queue`) |
 | `/servers` | List all running ocmux-served projects with URL + status (✅ idle / ⏳ busy) |
-| `/servers switch <name>` | Switch active server; matches by full path, basename, or substring |
-| `/sessions` | List recent sessions for the current server (max 50, with date headings) |
-| `/sessions switch <number\|name>` | Switch active session by position or partial name match |
-| `/agents` | List primary agents (▶ marker for the active one) |
-| `/agents switch <name>` | Switch active agent — persists on session and refreshes TUI |
-| `/models` | List connected providers with model counts, context limits, and costs |
-| `/status` | Show current server path, URL, busy status, and active session |
-| `/cancel` | Cancel the current AI response for the active server |
-| `/think [on\|off\|switch]` | Toggle forwarding of model thinking messages to the chat |
-| `/record [stop]` | Toggle recording of Telegram conversation for agentp context; `/record stop` clears and stops |
-| `/servers switch <name> [--force]` | Switch to a server; `--force` takes over from another chat |
+| `/servers switch <name> [--force]` | Switch active server; matches by full path, basename, or substring; `--force` takes over from another chat |
 | `/sessions` | List recent sessions for the current server (max 50, with date headings) |
 | `/sessions switch <number\|name>` | Switch active session by position or partial name match |
 | `/agents` | List primary agents (▶ marker for the active one) |
@@ -256,8 +246,15 @@ Non-text Telegram updates (photos, stickers, etc.) are silently ignored.
 | `/allow` | Approve a permission request once |
 | `/reject` | Deny a permission request |
 | `/always` | Approve and remember for the session |
+| `/answer <number>` | Respond to a question asked by the AI (structured multiple-choice) |
 | `/shutdown [force\|clear]` | (requires `--dev`) Stop tgagentp; `clear` also wipes saved connections |
 
+#### TUI Command Passthrough
+
+Messages starting with `//` are forwarded to the OpenCode TUI as raw keystrokes (not text sent to the AI):
+
+- **`//<command>`** — Sends `/command` directly to the TUI prompt. Useful for TUI-level commands like `/init`, `/clear`, `/history`, etc. The AI response is captured and forwarded to Telegram (or a confirmation is sent if the command is quick).
+
 ### Chat-server ownership
 
 Each server can be owned by at most one chat at a time. New chats start disconnected. Use `/servers switch <name>` to connect; `--force` takes over and notifies the previous owner. Connections are persisted to `/tmp/tgagentp-connections.json` and restored automatically on restart (server URL is re-discovered from `.ocmux.json`).

package/bin/tgagentp

@@ -5,7 +5,7 @@ const https = require('https');
 const fs = require('fs');
 const path = require('path');
 const { version } = require('../package.json');
-const { getAuthHeaders, sendText, listenForFinalAnswer, listSessions, createSession, updateSession, selectSession, sendToSession, sendToSessionAsync, respondToPermission, listenForSessionEvents, listAgents, listProviders, isServerAlive } = require('../lib/opencode.js');
+const { getAuthHeaders, sendText, listenForFinalAnswer, listSessions, createSession, updateSession, selectSession, sendToSession, sendToSessionAsync, respondToPermission, respondToQuestion, listenForSessionEvents, listAgents, listProviders, isServerAlive } = require('../lib/opencode.js');
 
 // Logger: info→stdout, error→stderr (always), debug→stderr (--verbose only)
 const log = {
@@ -19,7 +19,8 @@ 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 CONNECTIONS_FILE = '/tmp/tgagentp-connections.json';
-const { listServers, activateServer, resurrectServer, statefileFor, readState } = require('../lib/ocmux.js');
+const { listServers, activateServer, resurrectServer, statefileFor, readState, tuiPaneId } = require('../lib/ocmux.js');
+const { executeTuiCommand } = require('../lib/tui-cmd.js');
 
 // Persist chat↔server directory mappings across restarts
 function saveConnection(chatId, threadId, dir) {
@@ -383,14 +384,17 @@ async function cmdHelp(token, chatId, args, chatState) {
         'with status, context limit, and input/output costs.');
       return;
     }
-    if (topic === 'allow' || topic === 'reject' || topic === 'always') {
+    if (topic === 'allow' || topic === 'reject' || topic === 'always' || topic === 'answer') {
       await sendLongMessage(token, chatState,
         '`/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' +
+        '`/always` ─ approve and remember for the session\n' +
+        '`/answer <number>` ─ respond to a question from the AI\n\n' +
+        'These commands respond to OpenCode 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.');
+        '🔐 notification to the chat. Use one of these commands to answer.\n' +
+        'When the AI asks a multiple-choice question, tgagentp sends a ❓ notification\n' +
+        'with numbered options. Use `/answer <number>` to respond.');
       return;
     }
     if (topic === 'think') {
@@ -1061,6 +1065,24 @@ async function cmdAlways(token, chatId, args, chatState, setServerForChat, setAc
   }
 }
 
+async function cmdAnswer(token, chatId, args, chatState, setServerForChat, setActiveSessionForChat) {
+  const st = getState(chatState.serverBase);
+  if (!st.pendingQuestion) {
+    await sendLongMessage(token, chatState, 'No pending question. Use `/status` to check the current state.');
+    return;
+  }
+  const q = st.pendingQuestion;
+  const n = parseInt(args[0], 10);
+  if (isNaN(n) || n < 1 || n > q.options.length) {
+    await sendLongMessage(token, chatState, `Invalid answer. Use a number between 1 and ${q.options.length}.`);
+    return;
+  }
+  const answer = q.options[n - 1].text || q.options[n - 1];
+  await respondToQuestion(q.server, q.sessionId, q.questionId, answer);
+  await sendLongMessage(token, chatState, `✅ Answered: ${answer}`);
+  st.pendingQuestion = null;
+}
+
 async function cmdThink(token, chatId, args, chatState, setServerForChat, setActiveSessionForChat) {
   const st = getState(chatState.serverBase);
   const sub = args && args.length > 0 ? args[0].toLowerCase() : 'switch';
@@ -1331,6 +1353,7 @@ const COMMANDS = {
   'allow': cmdAllow,
   'reject': cmdReject,
   'always': cmdAlways,
+  'answer': cmdAnswer,
 };
 
 // --------------------------------------------------------------------------
@@ -1339,7 +1362,7 @@ const COMMANDS = {
 
 const serverState = {};
 function getState(url) {
-  return serverState[url] = serverState[url] || { busy: false, serverDead: false, pendingResponse: null, activeSessionId: null, activeSessionName: null, activeAgentName: null, taskId: 0, pendingPermission: null, thinkingEnabled: false, messageQueue: [] };
+  return serverState[url] = serverState[url] || { busy: false, serverDead: false, pendingResponse: null, activeSessionId: null, activeSessionName: null, activeAgentName: null, taskId: 0, pendingPermission: null, pendingQuestion: null, thinkingEnabled: false, messageQueue: [] };
 }
 
 function sessionLabel(st) {
@@ -1614,6 +1637,21 @@ async function main() {
             log.debug(`  → permission_replied: clearing pendingPermission`);
             getState(url).pendingPermission = null;
           },
+          onQuestion: (q) => {
+            const st2 = getState(url);
+            const qDump = JSON.stringify(q);
+            log.debug(`  → question_asked callback: ${qDump}`);
+            st2.pendingQuestion = { server: url, sessionId, questionId: q.id, question: q.question || 'Unknown question', options: q.options || [] };
+            const options = (q.options || []).map((opt, i) => `${i + 1}. ${opt.text || opt}`).join('\n');
+            const msg = '❓ **Question from the AI**\n\n'
+              + (q.question || 'Choose an option:') + '\n\n'
+              + (options ? options + '\n\n' : '')
+              + 'Use `/answer <number>` to respond.';
+            log.debug(`  → sending question notification to chat ${chatId}`);
+            sendLongMessage(token, chatState, msg, replyTo, threadId)
+              .then(() => log.debug(`  → question notification sent OK`))
+              .catch((err) => log.debug(`  → question notification failed: ${err.message}`));
+          },
         }, cancelRef).catch(() => {});
         await onConnected;
         answer = await sendToSession(url, sessionId, `[Telegram] ${text}`, st.activeAgentName, sessionCancelRef);
@@ -1799,6 +1837,12 @@ async function main() {
       await sendLongMessage(token, chatState, '⏳ Server is busy. Use `/cancel` to cancel or note again later.');
       return;
     }
+
+    // Auto-switch tmux window to this chat's server
+    const srvList = listServers();
+    const srvMatch = srvList.find(s => normalizeUrl(s.url) === normalizeUrl(url));
+    if (srvMatch) activateServer(srvMatch.dir, srvMatch.index, srvMatch.url);
+
     const intro = 'The following information is for your awareness. Reply with only "Ack" and do not take any action:';
     st.busy = true;
     const myTaskId = ++st.taskId;
@@ -1989,6 +2033,47 @@ async function main() {
       // Build reply context if this message is a Telegram reply
       const replyContext = quoteReply(msg);
 
+      // Intercept //commands (raw TUI passthrough via tmux send-keys)
+      if (text.startsWith('//')) {
+        const tuiCmd = text.slice(1);
+        if (!cs.serverBase) {
+          await sendLongMessage(token, cs, '🔌 Not connected to any server.');
+          continue;
+        }
+        const st = getState(cs.serverBase);
+        if (st.busy) {
+          await sendLongMessage(token, cs, '⏳ Server is busy. Use `/cancel` to cancel first.');
+          continue;
+        }
+        const srvList = listServers();
+        const srvMatch = srvList.find(s => normalizeUrl(s.url) === normalizeUrl(cs.serverBase));
+        if (!srvMatch) {
+          await sendLongMessage(token, cs, '❌ Server not found in tmux.');
+          continue;
+        }
+        activateServer(srvMatch.dir, srvMatch.index, srvMatch.url);
+        const paneId = tuiPaneId(srvMatch.index);
+        if (!paneId) {
+          await sendLongMessage(token, cs, '❌ TUI pane not found.');
+          continue;
+        }
+        st.busy = true;
+        try {
+          const answer = await executeTuiCommand(paneId, cs.serverBase, tuiCmd);
+          if (answer && answer.trim()) {
+            await sendLongMessage(token, cs, answer.trim());
+          } else {
+            await sendLongMessage(token, cs, `✅ \`${tuiCmd}\` submitted.`);
+          }
+        } catch (err) {
+          log.error(`Error executing TUI command ${tuiCmd}: ${err.message}`);
+          try { await sendLongMessage(token, cs, `Error executing \`${tuiCmd}\`: ${err.message}`); } catch (_) {}
+        } finally {
+          st.busy = false;
+        }
+        continue;
+      }
+
       // Intercept /commands
       if (text.startsWith('/')) {
         const parts = text.slice(1).split(' ');
@@ -2061,6 +2146,12 @@ async function main() {
         await sendLongMessage(token, cs, '⏳ Server is busy. Use `/cancel` to cancel or `/queue <message>` to queue your message.');
         continue;
       }
+
+      // Auto-switch tmux window to this chat's server
+      const srvList = listServers();
+      const srvMatch = srvList.find(s => normalizeUrl(s.url) === normalizeUrl(cs.serverBase));
+      if (srvMatch) activateServer(srvMatch.dir, srvMatch.index, srvMatch.url);
+
       st.busy = true;
       const myTaskId = ++st.taskId;
       log.debug(`  → started background processing (task ${myTaskId})`);

package/docs/specification.md

@@ -16,7 +16,7 @@ All tools share `lib/opencode.js` (HTTP session API client) and `lib/ocmux.js` (
 
 ### `package.json`
 
-**Version:** 0.13.0
+**Version:** 0.11.2
 
 Fields:
 - `"bin"` — registers `agentp`, `ocmux`, `tgagentp`
@@ -117,6 +117,7 @@ Shared by `bin/agentp` and `bin/tgagentp`. Functions:
 | `sendToSession(server, id, text, agent?, cancelRef?)` | POST /session/:id/message | Synchronous message; optional abort |
 | `sendToSessionAsync(server, id, text, agent?)` | POST /session/:id/prompt_async | Non-blocking (204); answer via SSE |
 | `respondToPermission(server, id, permissionId, response)` | POST /session/:id/permissions/:id | Permission response |
+| `respondToQuestion(server, id, questionId, answer)` | POST /session/:id/questions/:id | Question response |
 | `selectSession(server, id)` | POST /session/:id/select | TUI navigation |
 | `listAgents(server)` | GET /agent | Returns parsed array |
 | `listProviders(server)` | GET /provider | Returns parsed array |
@@ -342,6 +343,50 @@ Both command and non-command paths in the message loop check `cs.serverBase`:
 
 ---
 
+## `//command` TUI Passthrough
+
+Messages starting with `//` are forwarded to the TUI as raw keystrokes (not AI text). The `//` prefix is stripped, a trailing space is appended to activate the TUI as-you-type menu, and `tmux send-keys` sends the keys to the TUI pane. An SSE listener connects before the Enter key to catch the AI response.
+
+**Flow:**
+1. Chat message: `//init`
+2. Strips `//` → `init`
+3. Prepends `/` → `/init`
+4. Appends space → `/init ` (selects TUI menu item)
+5. `tmux send-keys` to TUI pane: `C-u` (clear line), type `/init `, Enter
+6. SSE listener starts before Enter (15s timeout)
+7. If AI responds: forwards full answer to Telegram
+8. If timeout: sends `✅ /init submitted.` confirmation
+
+**Busy guard:** `//command` is blocked when `st.busy` is true (same "use /cancel" message as regular messages).
+
+**Commands that trigger AI responses:** `//init`, `//clear`, `//history` (and any other TUI command that produces an AI answer). Quick commands like `/exit` timeout without an answer.
+
+---
+
+## Question Handling
+
+When the AI asks a structured multiple-choice question (via `question.asked` SSE event), tgagentp forwards the question to Telegram with numbered options.
+
+**Notification format:**
+```
+❓ **Question from the AI**
+
+What would you like to test?
+
+1. Option A
+2. Option B
+3. Option C
+
+Use /answer <number> to respond.
+```
+
+**Response:**
+- `/answer <number>` → `POST /session/:id/questions/:id` with the selected option's value
+- Only one question can be pending at a time per server
+- The question is stored per-server in `chatStates.pendingQuestion`
+
+---
+
 ## Logging Conventions (tgagentp)
 
 - **stdout** — informational messages (startup, discovery, session switches)

package/lib/opencode.js

@@ -318,7 +318,7 @@ async function respondToPermission(server, sessionId, permissionId, response, re
 
 // Listen for session events via SSE, collecting assistant text parts and detecting
 // permission requests. Resolves with the full collected text when the session goes idle.
-// callbacks: { onText(chunk), onPermission(permission), onThinking(chunk), onConnected() }
+// callbacks: { onText(chunk), onPermission(permission), onThinking(chunk), onConnected(), onQuestion(question) }
 // cancelRef — allows aborting the SSE stream via req.destroy()
 // logFn — optional logger; if provided, used instead of process.stderr.write
 function listenForSessionEvents(server, sessionId, callbacks, cancelRef, logFn) {
@@ -413,6 +413,18 @@ function listenForSessionEvents(server, sessionId, callbacks, cancelRef, logFn)
               continue;
             }
 
+            if (event.type === 'question.asked') {
+              const qStr = JSON.stringify(props);
+              sseLog(`  [SSE] QUESTION ASKED: ${qStr}\n`);
+              if (callbacks.onQuestion) {
+                sseLog(`  [SSE] calling onQuestion callback\n`);
+                callbacks.onQuestion(props);
+              } else {
+                sseLog(`  [SSE] WARNING: no onQuestion callback registered\n`);
+              }
+              continue;
+            }
+
             // Completion signals
             if (event.type === 'session.idle') {
               clearTimeout(safetyTimer);
@@ -510,6 +522,14 @@ function isServerAlive(url) {
   });
 }
 
+// Respond to a question (choice) asked by the AI.
+async function respondToQuestion(server, sessionId, questionId, answer) {
+  const url = `${server}/session/${encodeURIComponent(sessionId)}/questions/${encodeURIComponent(questionId)}`;
+  const body = JSON.stringify({ answer });
+  const { status } = await makeRequest(buildJsonRequest(url, 'POST', body), body);
+  if (status !== 200) throw new Error(`Failed to respond to question: ${status}`);
+}
+
 module.exports = {
   getAuthHeaders,
   makeRequest,
@@ -519,6 +539,7 @@ module.exports = {
   submitPrompt,
   sendText,
   listenForFinalAnswer,
+  respondToQuestion,
   listSessions,
   getSession,
   createSession,

package/lib/tui-cmd.js

@@ -0,0 +1,30 @@
+const child_process = require('child_process')
+const { listenForFinalAnswer } = require('./opencode.js')
+
+async function executeTuiCommand(paneId, server, command) {
+  const commandWithSpace = command + ' '
+  const cancelRef = { current: null }
+
+  const answerPromise = listenForFinalAnswer(server, null, cancelRef)
+
+  child_process.spawnSync('tmux', ['send-keys', '-t', paneId, 'C-u'])
+  child_process.spawnSync('tmux', ['send-keys', '-t', paneId, '-l', commandWithSpace])
+  child_process.spawnSync('tmux', ['send-keys', '-t', paneId, 'Enter'])
+
+  const timeoutMs = 15000
+  const timeoutPromise = new Promise((_, reject) => {
+    setTimeout(() => reject(new Error('timeout')), timeoutMs)
+  })
+
+  try {
+    return await Promise.race([answerPromise, timeoutPromise])
+  } catch {
+    if (cancelRef.current) {
+      cancelRef.current.destroy()
+      cancelRef.current = null
+    }
+    return null
+  }
+}
+
+module.exports = { executeTuiCommand }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentp",
-  "version": "0.11.0",
+  "version": "0.11.2",
   "description": "Pipe prompts into a running OpenCode TUI session and stream the final answer",
   "bin": {
     "agentp": "bin/agentp",