agentp 0.11.1 → 0.11.3

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) {
@@ -309,6 +310,8 @@ async function sendLongMessage(token, chatIdOrState, text, replyTo, threadId) {
 // Returns empty string if the message isn't a reply or has no text.
 // Uses a dynamic code-fence length (max consecutive backticks + 1)
 // so nested backticks never break the structure.
+const { ensureSharedDir, saveUploadedFile, formatFileSize } = require('../lib/file-share.js');
+
 function quoteReply(msg) {
   const rm = msg.reply_to_message;
   if (!rm || !rm.text) return '';
@@ -325,6 +328,58 @@ function quoteReply(msg) {
   return `In response to ${replyFrom} (${senderType}):\n\n${fence}\n${rm.text}\n${fence}\n\n`;
 }
 
+// ---------------------------------------------------------------------------
+// File upload helpers
+// ---------------------------------------------------------------------------
+
+// Download a file from Telegram's file storage.
+// Returns a Buffer of the file contents.
+async function downloadTelegramFile(token, fileId) {
+  const fileInfo = await telegramRequest(token, 'getFile', { file_id: fileId });
+  if (!fileInfo.ok || !fileInfo.result?.file_path) {
+    throw new Error('Failed to get file info from Telegram');
+  }
+  const filePath = fileInfo.result.file_path;
+  return new Promise((resolve, reject) => {
+    const req = https.get(`https://api.telegram.org/file/bot${token}/${filePath}`, (res) => {
+      const chunks = [];
+      res.on('data', (chunk) => chunks.push(chunk));
+      res.on('end', () => resolve(Buffer.concat(chunks)));
+    });
+    req.on('error', reject);
+  });
+}
+
+// Handle an uploaded file from Telegram.
+// Downloads the file, saves it, and returns a notification message.
+async function handleFileUpload(token, msg, projectDir) {
+  const doc = msg.document;
+  const photo = msg.photo;
+  if (!doc && !photo) return null;
+
+  let fileId;
+  let fileName;
+  let fileSize;
+
+  if (doc) {
+    fileId = doc.file_id;
+    fileName = doc.file_name || 'upload.bin';
+    fileSize = doc.file_size || 0;
+  } else if (photo) {
+    // Use the largest photo
+    const largest = photo[photo.length - 1];
+    fileId = largest.file_id;
+    fileName = 'photo.jpg';
+    fileSize = largest.file_size || 0;
+  }
+
+  const fileData = await downloadTelegramFile(token, fileId);
+  ensureSharedDir(projectDir);
+  const relativePath = saveUploadedFile(projectDir, fileName, fileData);
+  const sizeStr = fileSize > 0 ? ` (${formatFileSize(fileSize)})` : '';
+  return `📎 File uploaded: \`${relativePath}\`${sizeStr}`;
+}
+
 // ---------------------------------------------------------------------------
 // Telegram command handlers
 // ---------------------------------------------------------------------------
@@ -383,14 +438,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') {
@@ -600,7 +658,17 @@ async function cmdServers(token, chatId, args, chatState, setServerForChat, setA
   }
   const activeUrl = chatState.serverBase ? normalizeUrl(chatState.serverBase) : null;
   const lines = servers.map(s => {
-    const bullet = activeUrl && normalizeUrl(s.url) === activeUrl ? '▶ ' : ' · ';
+    const normalizedUrl = normalizeUrl(s.url);
+    const isActive = activeUrl && normalizedUrl === activeUrl;
+    const isOwned = Object.keys(serverOwners).some(url => normalizeUrl(url) === normalizedUrl);
+    let bullet;
+    if (isActive) {
+      bullet = '▶ ';
+    } else if (isOwned) {
+      bullet = ' · ';
+    } else {
+      bullet = '🔌 ';
+    }
     return bullet + `${s.url} → ${s.dir} (${s.status})`;
   });
   const prefix = chatState.serverBase ? 'Active servers:' : 'Available servers:';
@@ -805,7 +873,7 @@ async function cmdSessions(token, chatId, args, chatState, setServerForChat, set
 
       const name = sessionName(s);
       const pos = idx + 1;
-      const bullet = s.id === activeId ? '▶ ' : ' · ';
+      const bullet = s.id === activeId ? '▶ ' : '🔌 ';
       lines.push('`' + bullet + pos + ' ' + timeLabel + ' – ' + name.replace(/`/g, "'") + '`');
     });
 
@@ -934,7 +1002,7 @@ function startAgentpGateway(token, serverBaseResolver) {
   return new Promise((resolve) => {
     const server = http.createServer((req, res) => {
       try {
-        if (req.method !== 'POST' || req.url !== '/send') {
+        if (req.method !== 'POST') {
           res.writeHead(405);
           res.end('Method Not Allowed');
           return;
@@ -944,59 +1012,14 @@ function startAgentpGateway(token, serverBaseResolver) {
           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;
-            }
-
-            // Find the chat that owns this server
-            const targetUrl = normalizeUrl(server);
-            const owningChatId = Object.entries(serverOwners).find(([url]) => normalizeUrl(url) === targetUrl)?.[1];
-
-            // Return recorded conversation buffer for the owning chat
-            const buffered = owningChatId ? flushRecorded(owningChatId.chatId, owningChatId.threadId) : [];
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ buffered }));
-
-            if (!owningChatId) return;
-            const activeUrl = normalizeUrl(serverBaseResolver());
-
-            if (targetUrl === activeUrl) {
-              sendLongMessage(token, owningChatId, 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, owningChatId,
-                      `📥 ${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}`);
-          }
-        });
+        if (req.url === '/send') {
+          handleSendRequest(req, res, token, serverBaseResolver);
+        } else if (req.url === '/send-file') {
+          handleSendFileRequest(req, res, token, serverBaseResolver);
+        } else {
+          res.writeHead(404);
+          res.end('Not Found');
+        }
       } catch (err) {
         log.error(`Agentp gateway handler error: ${err.message}`);
       }
@@ -1013,6 +1036,193 @@ function startAgentpGateway(token, serverBaseResolver) {
   });
 }
 
+function handleSendRequest(req, res, token, serverBaseResolver) {
+  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;
+      }
+
+      // Find the chat that owns this server
+      const targetUrl = normalizeUrl(server);
+      const owningChatId = Object.entries(serverOwners).find(([url]) => normalizeUrl(url) === targetUrl)?.[1];
+
+      // Return recorded conversation buffer for the owning chat
+      const buffered = owningChatId ? flushRecorded(owningChatId.chatId, owningChatId.threadId) : [];
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ buffered }));
+
+      if (!owningChatId) return;
+      const activeUrl = normalizeUrl(serverBaseResolver());
+
+      if (targetUrl === activeUrl) {
+        sendLongMessage(token, owningChatId, 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, owningChatId,
+                `📥 ${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}`);
+    }
+  });
+}
+
+function handleSendFileRequest(req, res, token, serverBaseResolver) {
+  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 { filePath, server, message } = data;
+      if (typeof filePath !== 'string' || typeof server !== 'string') {
+        res.writeHead(400);
+        res.end('Bad Request: filePath and server are required');
+        return;
+      }
+
+      // Find the chat that owns this server
+      const targetUrl = normalizeUrl(server);
+      const owningChatId = Object.entries(serverOwners).find(([url]) => normalizeUrl(url) === targetUrl)?.[1];
+
+      if (!owningChatId) {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ sent: false, reason: 'no owner' }));
+        return;
+      }
+
+      // Resolve the file path relative to the server directory
+      const dir = serverDir(server);
+      if (!dir) {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ sent: false, reason: 'no server dir' }));
+        return;
+      }
+      const fullPath = path.resolve(dir, filePath);
+      if (!fs.existsSync(fullPath)) {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ sent: false, reason: 'file not found' }));
+        return;
+      }
+
+      const fileData = fs.readFileSync(fullPath);
+      const fileName = path.basename(fullPath);
+
+      // Send file to Telegram
+      sendTelegramDocument(token, owningChatId, fileData, fileName, message).then(() => {
+        // Clean up: only delete files from telegram-shared/downloads/
+        // to prevent accidental deletion of project files
+        const downloadsDir = path.join(dir, 'telegram-shared', 'downloads');
+        if (fullPath.startsWith(downloadsDir + path.sep)) {
+          try { fs.unlinkSync(fullPath); } catch (_) {}
+        }
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ sent: true }));
+      }).catch((err) => {
+        log.error(`Failed to send file: ${err.message}`);
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ sent: false, reason: err.message }));
+      });
+    } catch (err) {
+      log.error(`Agentp gateway handler error: ${err.message}`);
+      res.writeHead(500);
+      res.end('Internal Server Error');
+    }
+  });
+}
+
+// Send a document to Telegram using multipart/form-data.
+async function sendTelegramDocument(token, chatIdOrState, fileData, fileName, caption) {
+  const chatId = typeof chatIdOrState === 'object' && chatIdOrState.chatId != null
+    ? chatIdOrState.chatId : chatIdOrState;
+  const threadId = typeof chatIdOrState === 'object' ? chatIdOrState.threadId : undefined;
+
+  const boundary = '----tgagentpBoundary' + Math.random().toString(36).slice(2);
+  const parts = [];
+
+  // chat_id field
+  parts.push(Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="chat_id"\r\n\r\n${chatId}\r\n`));
+
+  // message_thread_id field (if present)
+  if (threadId) {
+    parts.push(Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="message_thread_id"\r\n\r\n${threadId}\r\n`));
+  }
+
+  // document field (the file)
+  const mimeType = 'application/octet-stream';
+  parts.push(Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="document"; filename="${fileName}"\r\nContent-Type: ${mimeType}\r\n\r\n`));
+  parts.push(fileData);
+  parts.push(Buffer.from('\r\n'));
+
+  // caption field (optional)
+  if (caption) {
+    parts.push(Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="caption"\r\n\r\n${caption}\r\n`));
+  }
+
+  // closing boundary
+  parts.push(Buffer.from(`--${boundary}--\r\n`));
+
+  const body = Buffer.concat(parts);
+
+  return new Promise((resolve, reject) => {
+    const options = {
+      hostname: 'api.telegram.org',
+      port: 443,
+      path: `/bot${token}/sendDocument`,
+      method: 'POST',
+      headers: {
+        'Content-Type': `multipart/form-data; boundary=${boundary}`,
+        'Content-Length': body.length,
+      },
+    };
+    const req = https.request(options, (res) => {
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        try {
+          const result = JSON.parse(data);
+          if (result.ok) resolve(result);
+          else reject(new Error(result.description || 'Telegram API error'));
+        } catch (e) {
+          reject(new Error(`Failed to parse Telegram response: ${data}`));
+        }
+      });
+    });
+    req.on('error', reject);
+    req.write(body);
+    req.end();
+  });
+}
+
 async function cmdAllow(token, chatId, args, chatState, setServerForChat, setActiveSessionForChat) {
   const st = getState(chatState.serverBase);
   if (!st.pendingPermission) {
@@ -1061,6 +1271,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 +1559,7 @@ const COMMANDS = {
   'allow': cmdAllow,
   'reject': cmdReject,
   'always': cmdAlways,
+  'answer': cmdAnswer,
 };
 
 // --------------------------------------------------------------------------
@@ -1339,7 +1568,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 +1843,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);
@@ -1963,12 +2207,9 @@ async function main() {
         continue;
       }
 
-      if (typeof msg.text !== 'string') continue;
-
       const chatId = String(msg.chat.id);
       const threadId = msg.message_thread_id || null;
       const replyTo = msg.message_id;
-      const text = msg.text;
       const from = msg.from?.username
         ? `@${msg.from.username}`
         : [msg.from?.first_name, msg.from?.last_name].filter(Boolean).join(' ') || 'unknown';
@@ -1989,12 +2230,135 @@ async function main() {
       // Per-chat state: get or create for this chat (thread-aware)
       const cs = getChatState(chatId, threadId);
 
+      // Handle file uploads (documents and photos)
+      if (msg.document || msg.photo) {
+        if (!cs.serverBase) {
+          await sendLongMessage(token, cs, '🔌 Not connected to any server. Upload ignored.');
+          continue;
+        }
+        const projectDir = serverDir(cs.serverBase);
+        if (!projectDir) {
+          await sendLongMessage(token, cs, '❌ Could not find project directory for this server.');
+          continue;
+        }
+        try {
+          const notification = await handleFileUpload(token, msg, projectDir);
+          // Verify the file is actually on disk before notifying
+          const relativePath = notification.match(/`([^`]+)`/)?.[1];
+          if (relativePath) {
+            const fullPath = path.join(projectDir, relativePath);
+            let retries = 5;
+            while (!fs.existsSync(fullPath) && retries > 0) {
+              await new Promise(r => setTimeout(r, 100));
+              retries--;
+            }
+            if (!fs.existsSync(fullPath)) {
+              log.error(`File not found after upload: ${fullPath}`);
+              await sendLongMessage(token, cs, `❌ File upload failed: file not saved to disk.`);
+              continue;
+            }
+          }
+          const userText = msg.caption || msg.text || '';
+          const fullMessage = notification + (userText ? '\n\nUser message: ' + userText : '');
+          log.debug(`[chat ${chatId}] ${from}: [file upload]`);
+          msgLog('in', chatId, from, '[file upload]');
+
+          // Buffer the upload notification for /record
+          bufferMessage(chatId, threadId, 'user', fullMessage);
+
+          const st = getState(cs.serverBase);
+          if (st.serverDead) {
+            const alive = await isServerAlive(cs.serverBase);
+            if (alive) st.serverDead = false;
+          }
+          if (st.serverDead) {
+            if (!st.messageQueue) st.messageQueue = [];
+            st.messageQueue.push({ text: fullMessage, replyTo });
+            const qlen = st.messageQueue.length;
+            await sendLongMessage(token, cs,
+              `⚠️ Server \`${cs.serverBase}\` is not reachable.\n\n` +
+              `Your file upload has been queued (#${qlen}). It will be sent when the server becomes available.\n\n` +
+              `**Options:**\n` +
+              `• Start the server: \`ocmux serve\`\n` +
+              `• Switch to another server: \`/servers switch <name>\`\n` +
+              `• Flush the queue: \`/flush\``);
+            continue;
+          }
+
+          if (st.busy) {
+            if (!st.messageQueue) st.messageQueue = [];
+            st.messageQueue.push({ text: fullMessage, replyTo });
+            await sendLongMessage(token, cs, `⏳ Server is busy. File upload queued (#${st.messageQueue.length}).`);
+            continue;
+          }
+
+          // Auto-switch tmux window
+          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(`  → processing file upload notification (task ${myTaskId})`);
+          processMessageAsync(chatId, fullMessage, cs.serverBase, !!st.activeSessionId, st.activeSessionId, myTaskId, replyTo, threadId);
+        } catch (err) {
+          log.error(`File upload error: ${err.message}`);
+          await sendLongMessage(token, cs, `❌ File upload failed: ${err.message}`);
+        }
+        continue;
+      }
+
+      if (typeof msg.text !== 'string') continue;
+
+      const text = msg.text;
+
       log.debug(`[chat ${chatId}] ${from}: ${text}`);
       msgLog('in', chatId, from, text);
 
       // 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(' ');

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.3
 
 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/file-share.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+// Ensure telegram-shared/{uploads,downloads}/ directories exist
+// and telegram-shared/ is in .gitignore.
+function ensureSharedDir(projectDir) {
+  const sharedDir = path.join(projectDir, 'telegram-shared');
+  const uploadsDir = path.join(sharedDir, 'uploads');
+  const downloadsDir = path.join(sharedDir, 'downloads');
+  if (!fs.existsSync(uploadsDir)) {
+    fs.mkdirSync(uploadsDir, { recursive: true });
+  }
+  if (!fs.existsSync(downloadsDir)) {
+    fs.mkdirSync(downloadsDir, { recursive: true });
+  }
+  // Ensure .gitignore has telegram-shared/
+  const gitignorePath = path.join(projectDir, '.gitignore');
+  let gitignoreContent = '';
+  try {
+    gitignoreContent = fs.readFileSync(gitignorePath, 'utf8');
+  } catch (_) {
+    // .gitignore doesn't exist, will create it
+  }
+  if (!gitignoreContent.split('\n').some(line => line.trim() === 'telegram-shared/' || line.trim() === 'telegram-shared')) {
+    const append = gitignoreContent.endsWith('\n') || gitignoreContent === '' ? '' : '\n';
+    fs.writeFileSync(gitignorePath, gitignoreContent + append + 'telegram-shared/\n');
+  }
+  return sharedDir;
+}
+
+// Save an uploaded file to the project's telegram-shared/uploads/ directory.
+// Returns the relative path (e.g., 'telegram-shared/uploads/20250610_143022_notes.md').
+function saveUploadedFile(projectDir, fileName, fileData) {
+  const uploadsDir = path.join(projectDir, 'telegram-shared', 'uploads');
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+  const safeName = fileName.replace(/[^a-zA-Z0-9._-]/g, '_');
+  const uniqueName = `${timestamp}_${safeName}`;
+  const filePath = path.join(uploadsDir, uniqueName);
+  fs.writeFileSync(filePath, fileData);
+  // Ensure data is flushed to disk so the file is immediately visible
+  const fd = fs.openSync(filePath, 'r');
+  fs.fsyncSync(fd);
+  fs.closeSync(fd);
+  return path.join('telegram-shared', 'uploads', uniqueName);
+}
+
+function formatFileSize(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+
+module.exports = {
+  ensureSharedDir,
+  saveUploadedFile,
+  formatFileSize,
+};

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.1",
+  "version": "0.11.3",
   "description": "Pipe prompts into a running OpenCode TUI session and stream the final answer",
   "bin": {
     "agentp": "bin/agentp",