agentp 0.11.2 → 0.11.4

package/bin/agentp

@@ -77,6 +77,8 @@ async function main() {
   let serverBase = 'http://localhost:4096';
   let qaMode = false;
   let flushMode = false;
+  let sessionName = null;
+  let newSession = false;
   // tgMode: false = disabled, 'auto' = auto-detect, true = explicit --tg
   let tgMode = null;
 
@@ -97,6 +99,8 @@ async function main() {
       console.error('  --no-tg     Do not forward to Telegram');
       console.error('  --flush     Flush tgagentp\'s recorded buffer without prepending it to output');
       console.error('  --getLast   Retrieve last N assistant answers (or QA pairs with --qa) from session history');
+      console.error('  --session   Target a specific session by name (creates it if not found with --new)');
+      console.error('  --new       Create a new session with the given title (requires --session)');
       console.error('  --help      Show this help message');
       console.error('');
       console.error('By default, --qa auto-detects tgagentp; standalone mode implies --no-tg.');
@@ -109,6 +113,10 @@ async function main() {
       console.error('--flush clears the tgagentp recorded buffer and also prevents the prepended');
       console.error('context from appearing in --qa output. Use it when you want fresh context.');
       console.error('');
+      console.error('--session <name> targets a specific session by exact or partial name match.');
+      console.error('If the session does not exist, agentp errors (use --new to create it).');
+      console.error('--new creates a new session with the given title (does not match existing sessions).');
+      console.error('');
       console.error('Arguments:');
       console.error('  url        OpenCode server URL or port number (default: 4096)');
       console.error('             Examples: 4096, http://localhost:4096, http://192.168.1.50:4096');
@@ -119,6 +127,8 @@ async function main() {
       console.error('Examples:');
       console.error('  printf "Summarize this file" | agentp');
       console.error('  cat prompt.txt | agentp $(ocmux)            # talk to current project\'s server');
+      console.error('  cat prompt.txt | agentp --session "My Task" $(ocmux)');
+      console.error('  cat prompt.txt | agentp --session "New Task" --new $(ocmux)');
       console.error('  # Vim/Neovim filter, preserving prompt + answer:');
       console.error("  :'<,'>!agentp --qa $(ocmux)");
       console.error('  # Retrieve last 3 assistant answers:');
@@ -130,6 +140,15 @@ async function main() {
       qaMode = true;
     } else if (args[i] === '--flush') {
       flushMode = true;
+    } else if (args[i] === '--session') {
+      i++;
+      sessionName = args[i];
+      if (!sessionName) {
+        console.error('Error: --session requires a session name');
+        process.exit(1);
+      }
+    } else if (args[i] === '--new') {
+      newSession = true;
     } else if (args[i] === '--getLast') {
       i++;
       const nStr = args[i];
@@ -137,6 +156,213 @@ async function main() {
         console.error('Error: --getLast requires a number (e.g. --getLast 5)');
         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 || s.time.created))
+          .sort((a, b) => {
+            const aTime = (a.time && a.time.updated) || (a.time && a.time.created) || 0;
+            const bTime = (b.time && b.time.updated) || (b.time && b.time.created) || 0;
+            return bTime - aTime;
+          });
+        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 (sessionName) {
+    // Find session by name
+    const matches = sessions.filter(s => {
+      const title = s.title || s.slug || s.id;
+      return title.toLowerCase() === sessionName.toLowerCase();
+    });
+    if (matches.length === 0) {
+      // Try partial match
+      const partial = sessions.filter(s => {
+        const title = s.title || s.slug || s.id;
+        return title.toLowerCase().includes(sessionName.toLowerCase());
+      });
+      if (partial.length === 1) {
+        sessionId = partial[0].id;
+      } else if (partial.length > 1) {
+        console.error(`Error: multiple sessions match "${sessionName}":`);
+        partial.forEach(s => console.error(`  - ${s.title || s.slug || s.id}`));
+        process.exit(1);
+      } else if (newSession) {
+        // Create new session
+        try {
+          const session = await createSession(serverBase, sessionName);
+          sessionId = session.id;
+          await selectSession(serverBase, sessionId);
+        } catch (err) {
+          console.error('Error creating session:', err.message);
+          process.exit(1);
+        }
+      } else {
+        console.error(`Error: no session found matching "${sessionName}"`);
+        console.error('Use --new to create a new session with this name');
+        process.exit(1);
+      }
+    } else {
+      sessionId = matches[0].id;
+    }
+  } else if (sessions && sessions.length > 0) {
+    const sorted = sessions
+      .filter(s => s.time && (s.time.updated || s.time.created))
+      .sort((a, b) => {
+        const aTime = (a.time && a.time.updated) || (a.time && a.time.created) || 0;
+        const bTime = (b.time && b.time.updated) || (b.time && b.time.created) || 0;
+        return bTime - aTime;
+      });
+    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);
+  } catch (err) {
+    console.error('Error sending prompt:', err.message);
+    process.exit(1);
+  }
       const n = parseInt(nStr, 10);
       try {
         const sessions = await listSessions(serverBase);

package/bin/tgagentp

@@ -310,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 '';
@@ -326,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
 // ---------------------------------------------------------------------------
@@ -604,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:';
@@ -809,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, "'") + '`');
     });
 
@@ -938,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;
@@ -948,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}`);
       }
@@ -1017,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) {
@@ -2001,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';
@@ -2027,6 +2230,88 @@ 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);
 

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.11.2
+**Version:** 0.11.4
 
 Fields:
 - `"bin"` — registers `agentp`, `ocmux`, `tgagentp`

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/package.json

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