agentp 0.11.4 → 0.11.6

package/bin/agentp

@@ -10,6 +10,7 @@ const {
   listSessions,
   createSession,
   getSession,
+  selectSession,
 } = require('../lib/opencode');
 
 const TGAGENTP_PORT_FILE = '/tmp/tgagentp-port';
@@ -356,168 +357,6 @@ async function main() {
     }
   }
 
-  let answer;
-  try {
-    answer = await sendToSession(serverBase, sessionId, promptText);
-  } catch (err) {
-    console.error('Error sending prompt:', err.message);
-    process.exit(1);
-  }
-      const n = parseInt(nStr, 10);
-      try {
-        const sessions = await listSessions(serverBase);
-        if (!sessions || sessions.length === 0) {
-          console.error('No sessions found.');
-          process.exit(1);
-        }
-        const sorted = sessions
-          .filter(s => s.time && s.time.updated)
-          .sort((a, b) => b.time.updated - a.time.updated);
-        const sessionId = sorted[0].id;
-
-        function buildPairsFromMessages(messages) {
-          const pairs = [];
-          let cur = null;
-          for (const raw of messages) {
-            // Normalize: export gives {role, parts: [{type, text}]}, SQLite gives {role, text}
-            const m = raw.parts ? raw : { role: raw.role, parts: [{ type: 'text', text: raw.text }] };
-            const role = m.role;
-            const text = (m.parts || []).filter(p => p.type === 'text').map(p => p.text).join('').trim();
-            if (!text) continue;
-            if (role === 'user') {
-              if (cur) pairs.push(cur);
-              cur = { prompt: text, answer: '' };
-            } else if (role === 'assistant' && cur) {
-              if (cur.answer) cur.answer += '\n';
-              cur.answer += text;
-            }
-          }
-          // Don't push incomplete pair (no answer yet)
-          return pairs;
-        }
-
-        function formatPairs(pairs) {
-          return pairs.map(p =>
-            HUMAN_ROW + p.prompt + '\n' + AGENT_ROW + p.answer + '\n' + FINAL_ROW
-          ).join('\n');
-        }
-
-        const formatAsQa = qaMode || args.includes('--qa');
-        function extractAnswers(pairs) {
-          return pairs.map(p => p.answer);
-        }
-        let output = '';
-        try {
-          const raw = child_process.execFileSync('opencode', ['export', sessionId], { encoding: 'utf8', maxBuffer: 50 * 1024 * 1024 });
-          const jsonStart = raw.indexOf('{');
-          const body = jsonStart >= 0 ? raw.slice(jsonStart) : raw;
-          const exportData = JSON.parse(body);
-          const messages = exportData.messages || [];
-          const pairs = buildPairsFromMessages(messages);
-          const lastN = pairs.slice(-n);
-          output = formatAsQa ? formatPairs(lastN) : extractAnswers(lastN).join('\n');
-        } catch {
-          // export JSON is malformed (opencode bug);
-          // fall back to SQLite
-          const home = process.env.HOME || process.env.USERPROFILE || '';
-          const dbCandidates = [
-            `${home}/.local/share/opencode/opencode.db`,
-            `${home}/Library/Application Support/opencode/opencode.db`,
-            `${home}/.opencode/opencode.db`,
-          ];
-          let dbPath = null;
-          for (const p of dbCandidates) {
-            try { fs.accessSync(p); dbPath = p; break; } catch {}
-          }
-          if (dbPath) {
-            const sql = `SELECT m.data->>'role' as role, group_concat(p.data->>'text', '') as text FROM message m JOIN part p ON p.message_id = m.id WHERE m.session_id = '${sessionId.replace(/'/g, "''")}' AND p.data->>'type' = 'text' AND m.data->>'role' IN ('user','assistant') GROUP BY m.id ORDER BY m.time_created ASC`;
-            const out = child_process.execFileSync('sqlite3', ['-json', dbPath, sql], { encoding: 'utf8', maxBuffer: 50 * 1024 * 1024 });
-            const messages = JSON.parse(out);
-            const pairs = buildPairsFromMessages(messages);
-            const lastN = pairs.slice(-n);
-            output = formatAsQa ? formatPairs(lastN) : extractAnswers(lastN).join('\n');
-          }
-        }
-        if (!output) {
-          console.error(formatAsQa ? 'No complete prompt-answer pairs found in session history.' : 'No assistant answers found in session history.');
-          process.exit(1);
-        }
-        process.stdout.write(output);
-        if (!output.endsWith('\n')) process.stdout.write('\n');
-      } catch (err) {
-        console.error('Error retrieving session history:', err.message);
-        process.exit(1);
-      }
-      return;
-    } else if (args[i] === '--tg') {
-      tgMode = true;
-    } else if (args[i] === '--no-tg') {
-      tgMode = false;
-    } else if (args[i].includes('://')) {
-      serverBase = args[i].replace(/\/+$/, '');
-    } else if (/^\d+$/.test(args[i])) {
-      serverBase = 'http://localhost:' + args[i];
-    } else if (args[i].startsWith('--')) {
-      console.error(`Error: unknown option '${args[i]}'`);
-      console.error(`Usage: agentp [options] [url]`);
-      console.error(`Try 'agentp --help' for more information.`);
-      process.exit(1);
-    } else {
-      console.error(`Error: unexpected argument '${args[i]}'`);
-      process.exit(1);
-    }
-  }
-
-  // Resolve default: --qa → auto-detect, standalone → disabled
-  if (tgMode === null) {
-    tgMode = qaMode ? 'auto' : false;
-  }
-
-  // Pre-send: probe tgagentp gateway if enabled
-  let tgPort = null;
-  if (tgMode) {
-    try {
-      tgPort = fs.readFileSync(TGAGENTP_PORT_FILE, 'utf8').trim();
-      if (!tgPort || !/^\d+$/.test(tgPort)) tgPort = null;
-    } catch {
-      tgPort = null;
-    }
-    if (!tgPort && tgMode === true) {
-      console.error('Error: tgagentp gateway not found. Is tgagentp running?');
-      process.exit(1);
-    }
-    // auto mode: tgPort stays null → silently skip tgagentp
-  }
-
-  const promptText = await readAllStdin();
-
-  // Find most recent session or create one
-  let sessions;
-  try {
-    sessions = await listSessions(serverBase);
-  } catch (err) {
-    console.error('Error connecting to server:', err.message);
-    process.exit(1);
-  }
-
-  let sessionId = null;
-  if (sessions && sessions.length > 0) {
-    const sorted = sessions
-      .filter(s => s.time && s.time.updated)
-      .sort((a, b) => b.time.updated - a.time.updated);
-    if (sorted.length > 0) sessionId = sorted[0].id;
-  }
-
-  if (!sessionId) {
-    try {
-      const session = await createSession(serverBase, 'agentp');
-      sessionId = session.id;
-    } catch (err) {
-      console.error('Error creating session:', err.message);
-      process.exit(1);
-    }
-  }
-
   let answer;
   try {
     answer = await sendToSession(serverBase, sessionId, promptText);
@@ -570,7 +409,12 @@ async function main() {
   }
 }
 
-main().catch((err) => {
-  console.error('Error:', err.message);
-  process.exit(1);
-});
+if (require.main === module) {
+  main().catch((err) => {
+    console.error('Error:', err.message);
+    process.exit(1);
+  });
+}
+
+module.exports = { main, notifyAgentpGateway, readAllStdin };
+

package/bin/ocmux

@@ -22,6 +22,7 @@ const {
   logfileFor,
   URL_RE,
   resurrectServer,
+  getActiveServer,
 } = require('../lib/ocmux');
 
 // ---------------------------------------------------------------------------
@@ -186,6 +187,7 @@ function printHelp() {
   console.error('');
   console.error('Options:');
   console.error('  -l       Long output: append " → <dir>" after the URL (serve/default).');
+  console.error('  --last   Print the URL of the active tmux window (last used server).');
   console.error('  --print-logs  Pass --print-logs to opencode serve (prints server logs to stderr).');
   console.error('  --version  Show version');
   console.error('  -h       Show this help');
@@ -445,12 +447,15 @@ function main() {
   let longMode = false;
   let gitMode = null;
   let printLogs = false;
+  let lastMode = false;
   const positional = [];
   let dirIsForced = false;
 
   for (const arg of process.argv.slice(2)) {
     if (arg === '-l') {
       longMode = true;
+    } else if (arg === '--last') {
+      lastMode = true;
     } else if (arg === '--print-logs') {
       printLogs = true;
     } else if (arg === '--git') {
@@ -516,6 +521,34 @@ function main() {
   if (!targetDir) targetDir = process.cwd();
 
   // Dispatch
+  if (lastMode) {
+    if (gitMode) {
+      console.error("Error: '--last' cannot be combined with '--git' or '--GIT'.");
+      process.exit(1);
+    }
+    if (printLogs) {
+      console.error("Error: '--last' cannot be combined with '--print-logs'.");
+      process.exit(1);
+    }
+    if (subcommand) {
+      console.error(`Error: '--last' cannot be combined with subcommand '${subcommand}'.`);
+      process.exit(1);
+    }
+    if (targetDir !== process.cwd()) {
+      console.error("Error: '--last' does not accept a directory path.");
+      process.exit(1);
+    }
+    ensureSession();
+    const url = getActiveServer();
+    if (!url) {
+      console.error('Error: no active opencode server found in tmux.');
+      console.error("Run 'ocmux serve' to create a server, or switch to an existing one.");
+      process.exit(1);
+    }
+    outputUrl(url, null, longMode);
+    return;
+  }
+
   if (subcommand === 'list') {
     if (gitMode) {
       console.error("Error: '--git' and '--GIT' are only valid with 'serve'.");

package/bin/tgagentp

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 
 const http = require('http');
-const https = require('https');
 const fs = require('fs');
 const path = require('path');
 const { version } = require('../package.json');
@@ -21,6 +20,8 @@ const TGAGENTP_DEBOUNCE_MS = parseInt(process.env.TGAGENTP_DEBOUNCE_MS || '5000'
 const CONNECTIONS_FILE = '/tmp/tgagentp-connections.json';
 const { listServers, activateServer, resurrectServer, statefileFor, readState, tuiPaneId } = require('../lib/ocmux.js');
 const { executeTuiCommand } = require('../lib/tui-cmd.js');
+const { getUpdates, downloadTelegramFile, sendTelegramDocument } = require('../lib/telegram-api.js');
+const { sendLongMessage } = require('../lib/telegram-format.js');
 
 // Persist chat↔server directory mappings across restarts
 function saveConnection(chatId, threadId, dir) {
@@ -144,123 +145,7 @@ function flushRecorded(chatId, threadId) {
 // Telegram Bot API helpers
 // ---------------------------------------------------------------------------
 
-function telegramRequest(token, method, params) {
-  return new Promise((resolve, reject) => {
-    const body = JSON.stringify(params || {});
-    const options = {
-      hostname: 'api.telegram.org',
-      port: 443,
-      path: `/bot${token}/${method}`,
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Content-Length': Buffer.byteLength(body),
-      },
-    };
-    const req = https.request(options, (res) => {
-      let data = '';
-      res.on('data', (chunk) => { data += chunk; });
-      res.on('end', () => {
-        try {
-          resolve(JSON.parse(data));
-        } catch (e) {
-          reject(new Error(`Failed to parse Telegram response: ${data}`));
-        }
-      });
-    });
-    req.on('error', reject);
-    req.write(body);
-    req.end();
-  });
-}
-
-function getUpdates(token, offset, timeout) {
-  return telegramRequest(token, 'getUpdates', {
-    offset,
-    timeout: timeout != null ? timeout : 30,
-    allowed_updates: ['message'],
-  });
-}
-
-function sendTelegramMessage(token, chatId, text, parseMode, replyTo, threadId) {
-  const params = { chat_id: chatId, text };
-  if (parseMode) params.parse_mode = parseMode;
-  if (replyTo) params.reply_to_message_id = replyTo;
-  if (threadId) params.message_thread_id = threadId;
-  return telegramRequest(token, 'sendMessage', params);
-}
-
 // Lightweight Markdown to Telegram HTML conversion.
-function convertMarkdownToHtml(text) {
-  const parts = text.split('```');
-
-  return parts.map((part, i) => {
-    if (i % 2 === 1) {
-      // 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
-        .replace(/&/g, '&amp;')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;') + '</pre>';
-    }
-
-    // Text segment
-
-    // Phase 1: extract table blocks into placeholders
-    const placeholders = [];
-    let processed = '';
-    const lines = part.split('\n');
-    let li = 0;
-    while (li < lines.length) {
-      if (/^\|/.test(lines[li])) {
-        const table = [];
-        while (li < lines.length && /^\|/.test(lines[li])) {
-          table.push(lines[li]);
-          li++;
-        }
-        const hasSep = table.some(l => /^\|[-:| ]+\|$/.test(l));
-        if (table.length >= 2 && hasSep) {
-          const cleaned = table
-            .map(l => l.replace(/^\|/, '').replace(/\|$/, ''))
-            .filter(l => !/^\s*[|:\- ]+\s*$/.test(l));
-          if (cleaned.length > 0) {
-            const escaped = cleaned.map(l =>
-              l.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
-            );
-            const idx = placeholders.length;
-            placeholders.push('<pre>' + escaped.join('\n') + '</pre>');
-            processed += '\0T' + idx + '\0\n';
-            continue;
-          }
-        }
-        for (const l of table) { processed += l + '\n'; }
-      } else {
-        processed += lines[li] + '\n';
-        li++;
-      }
-    }
-
-    // Phase 2: escape entities and apply markdown on non-table text
-    let html = processed
-      .replace(/&/g, '&amp;')
-      .replace(/</g, '&lt;')
-      .replace(/>/g, '&gt;');
-    html = html.replace(/`([^`]+)`/g, '<code>$1</code>');
-    html = html.replace(/^#{1,6}\s+(.+)$/gm, '<b>$1</b>');
-    html = html.replace(/^\s*-{3,}\s*$/gm, '────────────────────');
-    html = html.replace(/\*\*(.+?)\*\*/g, '<b>$1</b>');
-    html = html.replace(/\*(.+?)\*/g, '<i>$1</i>');
-
-    // Phase 3: restore table placeholders
-    for (let j = 0; j < placeholders.length; j++) {
-      html = html.split('\0T' + j + '\0').join(placeholders[j]);
-    }
-
-    return html;
-  }).join('');
-}
-
 // Parse TGAGENTP_ALLOWED_CHAT_IDS env var (comma-separated chat IDs).
 // Returns null when unset (all chats allowed), or an array of IDs to filter.
 function parseAllowlist(raw) {
@@ -269,43 +154,6 @@ function parseAllowlist(raw) {
   return ids.length > 0 ? ids : null;
 }
 
-// Split text into chunks of at most maxLength characters,
-// breaking at newlines when possible.
-function splitMessage(text, maxLength = 4096) {
-  if (text.length <= maxLength) return [text];
-  const chunks = [];
-  let start = 0;
-  while (start < text.length) {
-    let end = Math.min(start + maxLength, text.length);
-    if (end < text.length) {
-      const newlinePos = text.lastIndexOf('\n', end);
-      if (newlinePos > start) {
-        end = newlinePos + 1;
-      }
-    }
-    chunks.push(text.slice(start, end));
-    start = end;
-  }
-  return chunks;
-}
-
-// Send a text message to a Telegram chat, splitting into multiple
-// messages if it exceeds the 4096-character limit.
-// Converts Markdown to Telegram HTML formatting.
-// Splits the raw text first, then converts each chunk independently
-// to avoid broken HTML tags across messages.
-async function sendLongMessage(token, chatIdOrState, text, replyTo, threadId) {
-  // Accept either (token, chatState, ...) or (token, rawChatId, ...)
-  const chatId = typeof chatIdOrState === 'object' && chatIdOrState.chatId != null
-    ? chatIdOrState.chatId : chatIdOrState;
-  const effectiveThreadId = threadId || (typeof chatIdOrState === 'object' ? chatIdOrState.threadId : undefined);
-  const chunks = splitMessage(text);
-  for (let i = 0; i < chunks.length; i++) {
-    const html = convertMarkdownToHtml(chunks[i]);
-    await sendTelegramMessage(token, chatId, html, 'HTML', i === 0 ? replyTo : undefined, effectiveThreadId);
-  }
-}
-
 // Build a quoted reply context from a Telegram reply_to_message.
 // Returns empty string if the message isn't a reply or has no text.
 // Uses a dynamic code-fence length (max consecutive backticks + 1)
@@ -332,24 +180,6 @@ function quoteReply(msg) {
 // 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) {
@@ -1160,69 +990,6 @@ function handleSendFileRequest(req, res, token, serverBaseResolver) {
   });
 }
 
-// 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) {
@@ -1866,7 +1633,8 @@ async function main() {
           sendLongMessage(token, chatState, html, replyTo, threadId).catch(() => {});
           thinkingBuf = '';
         }
-        if (cancelRef.current) { cancelRef.current.destroy(); cancelRef.current = null; }
+        // Keep the SSE listener alive so subsequent permission/question events
+        // that arrive after sendToSession returns are still forwarded to Telegram.
       } else {
         await sendText(url, `[Telegram] ${text}`);
         answer = await listenForFinalAnswer(url, null, cancelRef);
@@ -1924,7 +1692,10 @@ async function main() {
       }
     } finally {
       st.pendingPermission = null;
-      if (st._cancelRef === cancelRef) st._cancelRef = null;
+      // Only clear the reference if the SSE listener was destroyed or finished.
+      // If it is still running, keep the reference so the next message call
+      // can destroy it (lines 1557–1559).
+      if (st._cancelRef === cancelRef && !cancelRef.current) st._cancelRef = null;
       if (st._sessionReq === sessionCancelRef) st._sessionReq = null;
       if (!isCancelled()) {
         getState(url).busy = false;
@@ -2039,8 +1810,24 @@ async function main() {
       }
       st.serverDead = false;
     }
+    const intro = 'The following information is for your awareness. Reply with only "Ack" and do not take any action:';
+    const noteText = intro + '\n\n' + text;
     if (st.busy) {
-      await sendLongMessage(token, chatState, '⏳ Server is busy. Use `/cancel` to cancel or note again later.');
+      // Experimental: try async injection instead of queuing
+      if (st.activeSessionId) {
+        try {
+          log.debug(`  → /note: attempting async injection into session ${st.activeSessionId}`);
+          await sendToSessionAsync(url, st.activeSessionId, noteText, st.activeAgentName);
+          await sendLongMessage(token, chatState, '💉 Note injected into ongoing session.');
+          log.debug(`  → /note: async injection succeeded`);
+          return;
+        } catch (err) {
+          log.debug(`  → /note: async injection failed (${err.message}), falling back to queue`);
+        }
+      }
+      if (!st.messageQueue) st.messageQueue = [];
+      st.messageQueue.push({ text: noteText, replyTo: null });
+      await sendLongMessage(token, chatState, `⏳ Server is busy. Note queued (#${st.messageQueue.length}).`);
       return;
     }
 
@@ -2049,11 +1836,10 @@ async function main() {
     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;
     log.debug(`  → /note: starting background processing (task ${myTaskId})`);
-    processMessageAsync(chatId, intro + '\n\n' + text, url, !!st.activeSessionId, st.activeSessionId, myTaskId, null, chatState.threadId);
+    processMessageAsync(chatId, noteText, url, !!st.activeSessionId, st.activeSessionId, myTaskId, null, chatState.threadId);
   };
 
   const cmds = { ...COMMANDS, status: cmdStatus, cancel: cmdCancel, note: cmdNote };
@@ -2310,7 +2096,25 @@ async function main() {
 
       if (typeof msg.text !== 'string') continue;
 
-      const text = msg.text;
+      let text = msg.text;
+
+      // !! wildcard: replace with the previous user message text
+      if (text.includes('!!')) {
+        const prevMsg = msg.reply_to_message;
+        if (prevMsg && prevMsg.text) {
+          text = text.replace(/!!/g, prevMsg.text);
+        } else {
+          // Fallback: look up the last user message from the ring buffer
+          const ring = getChatState(chatId, threadId).ring;
+          const lastUserMsg = ring.messages.slice().reverse().find(m => m.role === 'user');
+          if (lastUserMsg) {
+            text = text.replace(/!!/g, lastUserMsg.text);
+          } else {
+            await sendLongMessage(token, cs, '⚠️ No previous message found to replace !!');
+            continue;
+          }
+        }
+      }
 
       log.debug(`[chat ${chatId}] ${from}: ${text}`);
       msgLog('in', chatId, from, text);
@@ -2318,6 +2122,42 @@ async function main() {
       // Build reply context if this message is a Telegram reply
       const replyContext = quoteReply(msg);
 
+      // Download on reply: if the user replies to a file message, download it
+      if (msg.reply_to_message && (msg.reply_to_message.document || msg.reply_to_message.photo)) {
+        if (!cs.serverBase) {
+          await sendLongMessage(token, cs, '🔌 Not connected to any server. Cannot download file.');
+        } else {
+          const projectDir = serverDir(cs.serverBase);
+          if (!projectDir) {
+            await sendLongMessage(token, cs, '❌ Could not find project directory for this server.');
+          } else {
+            try {
+              const replyMsg = msg.reply_to_message;
+              let fileId, fileName, fileSize;
+              if (replyMsg.document) {
+                fileId = replyMsg.document.file_id;
+                fileName = replyMsg.document.file_name || 'download.bin';
+                fileSize = replyMsg.document.file_size || 0;
+              } else if (replyMsg.photo) {
+                const largest = replyMsg.photo[replyMsg.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)})` : '';
+              await sendLongMessage(token, cs, `📎 File downloaded: \`${relativePath}\`${sizeStr}`);
+            } catch (err) {
+              log.error(`Download on reply error: ${err.message}`);
+              await sendLongMessage(token, cs, `❌ File download failed: ${err.message}`);
+            }
+          }
+        }
+        continue;
+      }
+
       // Intercept //commands (raw TUI passthrough via tmux send-keys)
       if (text.startsWith('//')) {
         const tuiCmd = text.slice(1);

package/lib/ocmux.js

@@ -92,6 +92,18 @@ function activeWindowIndex() {
   return null;
 }
 
+// Get the URL of the active tmux window (the one currently selected in the Opencode session).
+function getActiveServer() {
+  const idx = activeWindowIndex();
+  if (idx == null) return null;
+  const dir = windowNameByIndex(idx);
+  if (!dir) return null;
+  const sf = statefileFor(dir);
+  if (!fs.existsSync(sf)) return null;
+  const state = readState(sf);
+  return state && state.url ? state.url : null;
+}
+
 function paneCount(windowIndex) {
   const r = _tmux(['list-panes', '-t', `${SESSION}:${windowIndex}`, '-F', '#{pane_id}']);
   if (r.status !== 0) return 0;
@@ -259,6 +271,7 @@ module.exports = {
   paneCount,
   listServers,
   activateServer,
+  getActiveServer,
   hashDir,
   logfileFor,
   sleep,

package/lib/telegram-api.js

@@ -0,0 +1,139 @@
+'use strict';
+
+const https = require('https');
+
+// Make a JSON request to the Telegram Bot API.
+function telegramRequest(token, method, params) {
+  return new Promise((resolve, reject) => {
+    const body = JSON.stringify(params || {});
+    const options = {
+      hostname: 'api.telegram.org',
+      port: 443,
+      path: `/bot${token}/${method}`,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(body),
+      },
+    };
+    const req = https.request(options, (res) => {
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        try {
+          resolve(JSON.parse(data));
+        } catch (e) {
+          reject(new Error(`Failed to parse Telegram response: ${data}`));
+        }
+      });
+    });
+    req.on('error', reject);
+    req.write(body);
+    req.end();
+  });
+}
+
+function getUpdates(token, offset, timeout) {
+  return telegramRequest(token, 'getUpdates', {
+    offset,
+    timeout: timeout != null ? timeout : 30,
+    allowed_updates: ['message'],
+  });
+}
+
+function sendTelegramMessage(token, chatId, text, parseMode, replyTo, threadId) {
+  const params = { chat_id: chatId, text };
+  if (parseMode) params.parse_mode = parseMode;
+  if (replyTo) params.reply_to_message_id = replyTo;
+  if (threadId) params.message_thread_id = threadId;
+  return telegramRequest(token, 'sendMessage', params);
+}
+
+// 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);
+  });
+}
+
+// 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();
+  });
+}
+
+module.exports = {
+  telegramRequest,
+  getUpdates,
+  sendTelegramMessage,
+  downloadTelegramFile,
+  sendTelegramDocument,
+};

package/lib/telegram-format.js

@@ -0,0 +1,117 @@
+'use strict';
+
+const { sendTelegramMessage } = require('./telegram-api.js');
+
+// Lightweight Markdown to Telegram HTML conversion.
+function convertMarkdownToHtml(text) {
+  const parts = text.split('```');
+
+  return parts.map((part, i) => {
+    if (i % 2 === 1) {
+      // 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
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;') + '</pre>';
+    }
+
+    // Text segment
+
+    // Phase 1: extract table blocks into placeholders
+    const placeholders = [];
+    let processed = '';
+    const lines = part.split('\n');
+    let li = 0;
+    while (li < lines.length) {
+      if (/^\|/.test(lines[li])) {
+        const table = [];
+        while (li < lines.length && /^\|/.test(lines[li])) {
+          table.push(lines[li]);
+          li++;
+        }
+        const hasSep = table.some(l => /^\|[-:| ]+\|$/.test(l));
+        if (table.length >= 2 && hasSep) {
+          const cleaned = table
+            .map(l => l.replace(/^\|/, '').replace(/\|$/, ''))
+            .filter(l => !/^\s*[|:\- ]+\s*$/.test(l));
+          if (cleaned.length > 0) {
+            const escaped = cleaned.map(l =>
+              l.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+            );
+            const idx = placeholders.length;
+            placeholders.push('<pre>' + escaped.join('\n') + '</pre>');
+            processed += '\0T' + idx + '\0\n';
+            continue;
+          }
+        }
+        for (const l of table) { processed += l + '\n'; }
+      } else {
+        processed += lines[li] + '\n';
+        li++;
+      }
+    }
+
+    // Phase 2: escape entities and apply markdown on non-table text
+    let html = processed
+      .replace(/&/g, '&amp;')
+      .replace(/</g, '&lt;')
+      .replace(/>/g, '&gt;');
+    html = html.replace(/`([^`]+)`/g, '<code>$1</code>');
+    html = html.replace(/^#{1,6}\s+(.+)$/gm, '<b>$1</b>');
+    html = html.replace(/^\s*-{3,}\s*$/gm, '────────────────────');
+    html = html.replace(/\*\*(.+?)\*\*/g, '<b>$1</b>');
+    html = html.replace(/\*(.+?)\*/g, '<i>$1</i>');
+
+    // Phase 3: restore table placeholders
+    for (let j = 0; j < placeholders.length; j++) {
+      html = html.split('\0T' + j + '\0').join(placeholders[j]);
+    }
+
+    return html;
+  }).join('');
+}
+
+// Split text into chunks of at most maxLength characters,
+// breaking at newlines when possible.
+function splitMessage(text, maxLength = 4096) {
+  if (text.length <= maxLength) return [text];
+  const chunks = [];
+  let start = 0;
+  while (start < text.length) {
+    let end = Math.min(start + maxLength, text.length);
+    if (end < text.length) {
+      const newlinePos = text.lastIndexOf('\n', end);
+      if (newlinePos > start) {
+        end = newlinePos + 1;
+      }
+    }
+    chunks.push(text.slice(start, end));
+    start = end;
+  }
+  return chunks;
+}
+
+// Send a text message to a Telegram chat, splitting into multiple
+// messages if it exceeds the 4096-character limit.
+// Converts Markdown to Telegram HTML formatting.
+// Splits the raw text first, then converts each chunk independently
+// to avoid broken HTML tags across messages.
+async function sendLongMessage(token, chatIdOrState, text, replyTo, threadId) {
+  // Accept either (token, chatState, ...) or (token, rawChatId, ...)
+  const chatId = typeof chatIdOrState === 'object' && chatIdOrState.chatId != null
+    ? chatIdOrState.chatId : chatIdOrState;
+  const effectiveThreadId = threadId || (typeof chatIdOrState === 'object' ? chatIdOrState.threadId : undefined);
+  const chunks = splitMessage(text);
+  for (let i = 0; i < chunks.length; i++) {
+    const html = convertMarkdownToHtml(chunks[i]);
+    await sendTelegramMessage(token, chatId, html, 'HTML', i === 0 ? replyTo : undefined, effectiveThreadId);
+  }
+}
+
+module.exports = {
+  convertMarkdownToHtml,
+  splitMessage,
+  sendLongMessage,
+};

package/package.json

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