agentp 0.11.6 → 0.11.8

package/README.md

@@ -7,9 +7,9 @@
 
 This package provides three CLI tools:
 
-- **`agentp`** — pipes prompt text into a running OpenCode TUI session and streams the assistant final answer back to stdout
+- **`agentp`** — pipes prompt text into a running OpenCode server and streams the assistant final answer back to stdout
 - **`ocmux`** — manages OpenCode server + TUI sessions in tmux (create, switch, kill, list)
-- **`tgagentp`** — bridges a Telegram bot chat with all running OpenCode TUI sessions (receives messages from Telegram, routes them to the active server, sends answers back). Supports slash commands for multi-server management, session switching, agent/model listing, and remote restart.
+- **`tgagentp`** — bridges a Telegram bot chat with all running OpenCode servers (receives messages from Telegram, routes them to the active server, sends answers back). Supports slash commands for multi-server management, session switching, agent/model listing, including file sharing from the chat.
 
 It is designed for prompt-driven workflows where you want to do things like:
 
@@ -18,6 +18,10 @@ It is designed for prompt-driven workflows where you want to do things like:
 - capture output in files or pipe to other tools
 - **drive prompts directly from editors** like Vim/Neovim
 
+## Author's note
+
+These tools are built for my own daily workflow. They are heavily AI-assisted — including the tests — and I review things before shipping, but the real test is using them every day. Bugs happen; I value a working feature more than a flawless one. MIT license, no warranty. Issues, suggestions, and PRs are welcome.
+
 ## Install
 
 From npm:
@@ -57,6 +61,8 @@ Options:
 - `--no-tg`: do not forward to Telegram
 - `--flush`: flush tgagentp's recorded buffer without prepending it to output
 - `--getLast <n>`: retrieve last n assistant answers from session history
+- `--session <name>`: target a specific session by name (exact or partial match)
+- `--new`: create a new session with the given title (requires `--session`)
 - `--version`: show version
 - `--help`: show help message
 
@@ -146,8 +152,6 @@ Useful to grab recent answers without sending a new prompt.
 
 ## ocmux
 
-## ocmux
-
 Manage OpenCode server + TUI in tmux for project directories.
 
 ```bash
@@ -231,6 +235,8 @@ 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> [--force]` | Switch active server; matches by full path, basename, or substring; `--force` takes over from another chat |
+| `/serve <path>` | Start a server in an existing directory under `TGAGENTP_ROOT` |
+| `/new <path>` | Create a directory, init git, and start a server under `TGAGENTP_ROOT` |
 | `/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) |
@@ -247,6 +253,7 @@ Non-text Telegram updates (photos, stickers, etc.) are silently ignored.
 | `/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) |
+| `/markdown` | Send the original markdown of the last response as a `.md` file; reply to a message to get that specific response |
 | `/shutdown [force\|clear]` | (requires `--dev`) Stop tgagentp; `clear` also wipes saved connections |
 
 #### TUI Command Passthrough
@@ -324,6 +331,7 @@ Chat-to-server directory mappings are saved to `/tmp/tgagentp-connections.json`
 | `TGAGENTP_ALLOWED_CHAT_IDS` | Optional. Comma-separated Telegram chat IDs that are allowed to use the bot. |
 | `TGAGENTP_PORT` | Optional. Agentp gateway listen port (default: `0` = random). |
 | `TGAGENTP_DEBOUNCE_MS` | Optional. Debounce interval for queued-message notifications (default: `5000`). |
+| `TGAGENTP_ROOT` | Optional. Root directory for `/serve` and `/new` commands (must be writable). |
 
 ## License
 

package/bin/tgagentp

@@ -22,6 +22,27 @@ const { listServers, activateServer, resurrectServer, statefileFor, readState, t
 const { executeTuiCommand } = require('../lib/tui-cmd.js');
 const { getUpdates, downloadTelegramFile, sendTelegramDocument } = require('../lib/telegram-api.js');
 const { sendLongMessage } = require('../lib/telegram-format.js');
+const { spawnSync } = require('child_process');
+
+const TGAGENTP_ROOT = process.env.TGAGENTP_ROOT;
+let tgagentpRootValid = false;
+if (TGAGENTP_ROOT) {
+  try {
+    const stats = fs.statSync(TGAGENTP_ROOT);
+    if (!stats.isDirectory()) {
+      log.error(`TGAGENTP_ROOT is not a directory: ${TGAGENTP_ROOT} — /serve and /new disabled`);
+    } else {
+      try {
+        fs.accessSync(TGAGENTP_ROOT, fs.constants.W_OK);
+        tgagentpRootValid = true;
+      } catch {
+        log.error(`TGAGENTP_ROOT is not writable: ${TGAGENTP_ROOT} — /serve and /new disabled`);
+      }
+    }
+  } catch {
+    log.error(`TGAGENTP_ROOT does not exist: ${TGAGENTP_ROOT} — /serve and /new disabled`);
+  }
+}
 
 // Persist chat↔server directory mappings across restarts
 function saveConnection(chatId, threadId, dir) {
@@ -141,6 +162,33 @@ function flushRecorded(chatId, threadId) {
   return msgs;
 }
 
+// Ring buffer of recent responses keyed by Telegram message ID.
+// Stored per chatId+threadId for /markdown command lookups.
+const responseHistory = {}; // convKey → [{ messageId, text }]
+
+function recordResponseMessage(chatId, threadId, messageIds, text) {
+  const key = convKey(chatId, threadId);
+  if (!responseHistory[key]) responseHistory[key] = [];
+  responseHistory[key].push({ messageIds, text });
+  if (responseHistory[key].length > 20) responseHistory[key].shift();
+}
+
+function getResponseByMessageId(chatId, threadId, messageId) {
+  const key = convKey(chatId, threadId);
+  const list = responseHistory[key] || [];
+  return list.find(e => e.messageIds.includes(messageId));
+}
+
+function getRecentResponse(chatId, threadId, index) {
+  const key = convKey(chatId, threadId);
+  const list = responseHistory[key] || [];
+  if (list.length === 0) return null;
+  // index 1 = most recent, 2 = second most recent, etc.
+  const idx = list.length - (index || 1);
+  if (idx < 0 || idx >= list.length) return null;
+  return list[idx];
+}
+
 // ---------------------------------------------------------------------------
 // Telegram Bot API helpers
 // ---------------------------------------------------------------------------
@@ -158,7 +206,7 @@ function parseAllowlist(raw) {
 // 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');
+const { formatFileSize } = require('../lib/file-share.js');
 
 function quoteReply(msg) {
   const rm = msg.reply_to_message;
@@ -181,7 +229,7 @@ function quoteReply(msg) {
 // ---------------------------------------------------------------------------
 
 // Handle an uploaded file from Telegram.
-// Downloads the file, saves it, and returns a notification message.
+// Returns a notification message with fileId so the agent can download it on demand.
 async function handleFileUpload(token, msg, projectDir) {
   const doc = msg.document;
   const photo = msg.photo;
@@ -196,18 +244,15 @@ async function handleFileUpload(token, msg, projectDir) {
     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}`;
+  return `📎 File uploaded: \`${fileName}\`${sizeStr}\n` +
+    `Use \`[Telegram]{"command":"download","fileId":"${fileId}","path":"<destination>"}\` to save it.`;
 }
 
 // ---------------------------------------------------------------------------
@@ -362,8 +407,37 @@ async function cmdHelp(token, chatId, args, chatState) {
         'Max 100 messages / 100KB. Oldest messages are dropped first.');
       return;
     }
+    if (topic === 'serve') {
+      const hint = TGAGENTP_ROOT ? '' :
+        '\nℹ️  Currently disabled. Set the `TGAGENTP_ROOT` environment variable to a writable directory to enable `/serve` and `/new`.';
+      await sendLongMessage(token, chatState,
+        '`/serve <path>` ─ start a server in an existing directory\n\n' +
+        'The path is relative to `TGAGENTP_ROOT`.\n' +
+        'Example: `/serve projects/my-app`\n\n' +
+        'Requires the `TGAGENTP_ROOT` environment variable to be set to a writable directory.' +
+        hint);
+      return;
+    }
+    if (topic === 'new') {
+      const hint = TGAGENTP_ROOT ? '' :
+        '\nℹ️  Currently disabled. Set the `TGAGENTP_ROOT` environment variable to a writable directory to enable `/serve` and `/new`.';
+      await sendLongMessage(token, chatState,
+        '`/new <path>` ─ create a directory, initialize git, and start a server\n\n' +
+        'The path is relative to `TGAGENTP_ROOT`.\n' +
+        'Example: `/new projects/my-app`\n\n' +
+        'Requires the `TGAGENTP_ROOT` environment variable to be set to a writable directory.' +
+        hint);
+      return;
+    }
+    if (topic === 'markdown') {
+      await sendLongMessage(token, chatState,
+        '`/markdown` ─ send the original markdown of the most recent response as a `.md` file\n\n' +
+        'Reply to any message and use `/markdown` to get the original markdown of the response that generated that message ' +
+        '(works even if the response was split into multiple Telegram messages).');
+      return;
+    }
     await sendLongMessage(token, chatState,
-      'Unknown topic. Try `/help servers`, `/help sessions`, `/help agents`, `/help models`, `/help allow`, `/help think`, `/help record`, `/help queue`, `/help flush`, `/help note`, `/help comment`, `/help disconnect`, or just `/help`.');
+      'Unknown topic. Try `/help servers`, `/help sessions`, `/help agents`, `/help models`, `/help allow`, `/help think`, `/help record`, `/help queue`, `/help flush`, `/help note`, `/help comment`, `/help disconnect`, `/help serve`, `/help new`, `/help markdown`, or just `/help`.');
     return;
   }
   await sendLongMessage(token, chatState,
@@ -390,7 +464,12 @@ async function cmdHelp(token, chatId, args, chatState) {
     '`/comment <text>` ─ save a comment in the chat (not forwarded to the agent)\n' +
     '`/disconnect` ─ disconnect this chat from its server\n' +
     '`/allow` / `/reject` / `/always` ─ respond to permission requests\n' +
-    '`/shutdown` ─ stop tgagentp (only with `--dev` flag)\n\n' +
+    '`/markdown` ─ send the original markdown of the last response as a `.md` file\n' +
+    '`/shutdown` ─ stop tgagentp (only with `--dev` flag)\n' +
+    (tgagentpRootValid
+      ? '`/serve <path>` ─ start a server in an existing directory\n' +
+        '`/new <path>` ─ create a directory, init git, and start a server\n\n'
+      : 'ℹ️  Set `TGAGENTP_ROOT` to a writable directory to enable `/serve` and `/new`.\n\n') +
     'Everything else is forwarded to the active server as `[Telegram] <text>`.');
 }
 
@@ -510,6 +589,7 @@ function sessionName(s) {
 }
 
 function normalizeUrl(url) {
+  if (!url) return url;
   return url.replace(/\/+$/, '').replace(/^http:\/\/127\.0\.0\.1:/, 'http://localhost:');
 }
 
@@ -553,7 +633,7 @@ async function cmdSessions(token, chatId, args, chatState, setServerForChat, set
       try {
         const session = await createSession(server, title);
         const name = session.title || session.slug || session.id;
-        setActiveSessionForChat(chatState, session.id);
+        setActiveSessionForChat(chatState, session.id, name);
         selectSession(server, session.id);
         await sendLongMessage(token, chatState,
           `Created session: \`${name}\`\nIt is now the active session.`);
@@ -605,7 +685,7 @@ async function cmdSessions(token, chatId, args, chatState, setServerForChat, set
         const num = parseInt(query, 10);
         if (/^\d+$/.test(query) && num >= 1 && num <= sorted.length) {
           const target = sorted[num - 1];
-          setActiveSessionForChat(chatId, target.id);
+          setActiveSessionForChat(chatState, target.id, sessionName(target));
           selectSession(server, target.id);
           await sendLongMessage(token, chatState,
             `Switched to session #${num}: \`${sessionName(target)}\`\nSubsequent messages will be sent to this session.`);
@@ -627,7 +707,7 @@ async function cmdSessions(token, chatId, args, chatState, setServerForChat, set
           return;
         }
         const target = matches[0];
-        setActiveSessionForChat(chatId, target.id);
+        setActiveSessionForChat(chatState, target.id);
         selectSession(server, target.id);
         await sendLongMessage(token, chatState,
           `Switched to session: \`${sessionName(target)}\`\nSubsequent messages will be sent to this session.`);
@@ -657,10 +737,13 @@ async function cmdSessions(token, chatId, args, chatState, setServerForChat, set
       return;
     }
 
-    // Show user sessions (have agent or directory) and always include the active session
+    // Show primary-agent sessions and always include the active session
+    const agents = await listAgents(server).catch(() => []);
+    const primaryAgents = new Set(agents.filter(a => a.mode === 'primary').map(a => a.name));
+    const hasPrimaryAgent = (s) => s.agent && primaryAgents.has(s.agent);
     const activeId = getState(server).activeSessionId;
     const filtered = sessions.filter(s =>
-      (s.agent || s.directory || s.id === activeId) && (!projectDir || s.directory === projectDir));
+      (hasPrimaryAgent(s) || s.id === activeId) && (!projectDir || s.directory === projectDir));
     const sorted = sortedSessions(filtered, 50);
     if (sorted.length === 0) {
       await sendLongMessage(token, chatState, 'No active sessions.');
@@ -844,8 +927,6 @@ function startAgentpGateway(token, serverBaseResolver) {
         }
         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');
@@ -897,7 +978,9 @@ function handleSendRequest(req, res, token, serverBaseResolver) {
       const activeUrl = normalizeUrl(serverBaseResolver());
 
       if (targetUrl === activeUrl) {
-        sendLongMessage(token, owningChatId, text.trim()).catch(() => {});
+        processTelegramCommands(text, server, token, owningChatId).then((cleaned) => {
+          if (cleaned) sendLongMessage(token, owningChatId, cleaned).catch(() => {});
+        });
       } else {
         if (!agentpQueues[server]) {
           agentpQueues[server] = { messages: [], notifyTimer: null, notified: false };
@@ -922,72 +1005,122 @@ function handleSendRequest(req, res, token, serverBaseResolver) {
   });
 }
 
-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;
-      }
+// Scan response text for [Telegram]{...} structured messages, process them,
+// and return the text with those lines removed (or replaced, for help commands).
+// Supported commands:
+//   "upload"  — send a file to the Telegram chat.
+//               Format: [Telegram]{"command":"upload","path":"<rel-path>","msg":"<caption>"}
+//   "download" — save a Telegram file to the project directory.
+//                Format: [Telegram]{"command":"download","fileId":"<id>","path":"<rel-path>"}
+//   "help"    — get help about available commands.
+//               Format: [Telegram]{"command":"help","topic":"<upload|download|help>"}
+// The [Telegram]{...} must be the only content on its line.
+
+// Parse a single [Telegram]{...} line. Returns { payload } or null.
+function parseTelegramLine(line) {
+  const m = line.match(/^\[Telegram\](\{.*\})\s*$/);
+  if (!m) return null;
+  let payload;
+  try { payload = JSON.parse(m[1]); } catch { return null; }
+  if (!payload || typeof payload !== 'object') return null;
+  return payload;
+}
 
-      // Find the chat that owns this server
-      const targetUrl = normalizeUrl(server);
-      const owningChatId = Object.entries(serverOwners).find(([url]) => normalizeUrl(url) === targetUrl)?.[1];
+const TELEGRAM_COMMANDS_HELP = {
+  all: 'Available commands:\n\n' +
+    '• upload — send a file to Telegram.\n' +
+    '  [Telegram]{"command":"upload","path":"<relative-path>","msg":"<optional caption>"}\n\n' +
+    '• download — save a file from Telegram to the project.\n' +
+    '  [Telegram]{"command":"download","fileId":"<telegram-file-id>","path":"<relative-destination>"}\n\n' +
+    '• help — show this help or details for a specific command.\n' +
+    '  [Telegram]{"command":"help","topic":"<command>"}',
+  upload: 'Upload a file to the Telegram chat.\n\n' +
+    'Format: [Telegram]{"command":"upload","path":"<relative-path>","msg":"<optional caption>"}\n\n' +
+    '- path: file path relative to the project root (required)\n' +
+    '- msg:  optional caption sent with the file',
+  download: 'Download a file the user uploaded to Telegram.\n\n' +
+    'Format: [Telegram]{"command":"download","fileId":"<telegram-file-id>","path":"<relative-destination>"}\n\n' +
+    '- fileId: the Telegram file identifier (provided when the user uploads a file)\n' +
+    '- path:   destination path relative to the project root (required)',
+  help: 'Get help about Telegram commands.\n\n' +
+    'Format: [Telegram]{"command":"help","topic":"<command>"}\n\n' +
+    '- topic: one of "upload", "download", "help". Omit for general help.',
+};
 
-      if (!owningChatId) {
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ sent: false, reason: 'no owner' }));
-        return;
-      }
+function getHelpText(topic) {
+  if (topic && TELEGRAM_COMMANDS_HELP[topic]) return TELEGRAM_COMMANDS_HELP[topic];
+  return TELEGRAM_COMMANDS_HELP.all;
+}
 
-      // 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;
+async function processTelegramCommands(text, server, token, chatState) {
+  if (!text) return text;
+  const lines = text.split('\n');
+  const toStrip = new Set();
+  const filesSent = [];
+  const dir = serverDir(server);
+
+  for (let i = 0; i < lines.length; i++) {
+    const payload = parseTelegramLine(lines[i]);
+    if (!payload) continue;
+
+    if (payload.command === 'upload' && payload.path) {
+      toStrip.add(i);
+      const resolved = dir ? path.resolve(dir, payload.path) : path.resolve(payload.path);
+      if (dir && !resolved.startsWith(dir + path.sep)) {
+        log.error(`processTelegramCommands: path outside project rejected: ${payload.path}`);
+        continue;
       }
-      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;
+      try {
+        if (!fs.existsSync(resolved)) {
+          log.error(`processTelegramCommands: file not found: ${resolved}`);
+          continue;
+        }
+        const fileData = fs.readFileSync(resolved);
+        const fileName = path.basename(resolved);
+        const caption = typeof payload.msg === 'string' ? payload.msg : undefined;
+        await sendTelegramDocument(token, chatState, fileData, fileName, caption);
+        filesSent.push(fileName);
+      } catch (err) {
+        log.error(`processTelegramCommands: failed to send file ${resolved}: ${err.message}`);
+      }
+    } else if (payload.command === 'download' && payload.fileId && payload.path) {
+      toStrip.add(i);
+      const resolved = dir ? path.resolve(dir, payload.path) : path.resolve(payload.path);
+      if (dir && !resolved.startsWith(dir + path.sep)) {
+        log.error(`processTelegramCommands: download path outside project rejected: ${payload.path}`);
+        continue;
       }
+      try {
+        const fileData = await downloadTelegramFile(token, payload.fileId);
+        fs.mkdirSync(path.dirname(resolved), { recursive: true });
+        fs.writeFileSync(resolved, fileData);
+        filesSent.push(path.basename(resolved));
+      } catch (err) {
+        log.error(`processTelegramCommands: failed to download file: ${err.message}`);
+      }
+    } else if (payload.command === 'help') {
+      toStrip.add(i);
+      const topic = typeof payload.topic === 'string' ? payload.topic : undefined;
+      const st = getState(server);
+      if (st.activeSessionId) {
+        sendToSession(server, st.activeSessionId, getHelpText(topic)).catch(() => {});
+      }
+    } else {
+      toStrip.add(i); // unrecognized command — strip silently
+    }
+  }
 
-      const fileData = fs.readFileSync(fullPath);
-      const fileName = path.basename(fullPath);
+  if (toStrip.size === 0) return text;
 
-      // 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');
-    }
-  });
+  if (filesSent.length > 0) {
+    log.info(`processTelegramCommands: processed ${filesSent.length} file(s): ${filesSent.join(', ')}`);
+  }
+
+  const out = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (!toStrip.has(i)) out.push(lines[i]);
+  }
+  return out.join('\n').replace(/\n{3,}/g, '\n\n').trim();
 }
 
 async function cmdAllow(token, chatId, args, chatState, setServerForChat, setActiveSessionForChat) {
@@ -1059,6 +1192,7 @@ async function cmdAnswer(token, chatId, args, chatState, setServerForChat, setAc
 async function cmdThink(token, chatId, args, chatState, setServerForChat, setActiveSessionForChat) {
   const st = getState(chatState.serverBase);
   const sub = args && args.length > 0 ? args[0].toLowerCase() : 'switch';
+  const wasOn = st.thinkingEnabled;
   if (sub === 'on') {
     st.thinkingEnabled = true;
     await sendLongMessage(token, chatState, '💭 Thinking messages **on** (forwarded to chat).');
@@ -1072,6 +1206,13 @@ async function cmdThink(token, chatId, args, chatState, setServerForChat, setAct
   } else {
     await sendLongMessage(token, chatState, 'Usage: `/think [on|off|switch]` (default: switch).');
   }
+  // When toggled on, flush any thinking text already buffered by the current request
+  if (!wasOn && st.thinkingEnabled && st._thinkingBuf) {
+    const buf = st._thinkingBuf;
+    st._thinkingBuf = '';
+    const html = '💭 ' + buf.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+    sendLongMessage(token, chatState, html, null, chatState.threadId).catch(() => {});
+  }
 }
 
 async function cmdQueue(token, chatId, args, chatState, setServerForChat, setActiveSessionForChat, replyTo) {
@@ -1308,6 +1449,153 @@ async function cmdDisconnect(token, chatId, args, chatState) {
   log.info(`[chat ${chatId}] Disconnected from server: ${url}`);
 }
 
+async function cmdServe(token, chatId, args, chatState, setServerForChat, setActiveSessionForChat) {
+  if (!tgagentpRootValid) {
+    const msg = TGAGENTP_ROOT
+      ? '❌ `TGAGENTP_ROOT` is not a valid writable directory.\nCheck the logs for details.'
+      : '❌ `TGAGENTP_ROOT` environment variable is not set.\nSet it to a writable directory to enable `/serve` and `/new` commands.';
+    await sendLongMessage(token, chatState, msg);
+    return;
+  }
+  const relPath = args.join(' ').trim();
+  if (!relPath) {
+    await sendLongMessage(token, chatState,
+      'Usage: `/serve <path>`\n\n' +
+      'Run `ocmux serve` on a directory under `TGAGENTP_ROOT`.\n' +
+      'The path is relative to the root directory.');
+    return;
+  }
+  const targetDir = path.resolve(TGAGENTP_ROOT, relPath);
+  if (!targetDir.startsWith(TGAGENTP_ROOT)) {
+    await sendLongMessage(token, chatState,
+      '❌ Path must be within `TGAGENTP_ROOT`.\n' +
+      `Requested: \`${relPath}\``);
+    return;
+  }
+  try {
+    const stats = fs.statSync(targetDir);
+    if (!stats.isDirectory()) {
+      await sendLongMessage(token, chatState,
+        `❌ Not a directory: \`${relPath}\``);
+      return;
+    }
+  } catch {
+    await sendLongMessage(token, chatState,
+      `❌ Directory does not exist: \`${relPath}\``);
+    return;
+  }
+  const sf = statefileFor(targetDir);
+  if (fs.existsSync(sf)) {
+    await sendLongMessage(token, chatState,
+      `⚠️ Server already exists for \`${relPath}\`.\n` +
+      'Use `/servers switch <name>` to connect to it.');
+    return;
+  }
+  await sendLongMessage(token, chatState,
+    `🚀 Starting server for \`${relPath}\`...`);
+  const result = spawnSync('ocmux', ['serve', targetDir], { encoding: 'utf8', timeout: 15000 });
+  if (result.status !== 0) {
+    const err = result.stderr || result.stdout || 'unknown error';
+    await sendLongMessage(token, chatState,
+      `❌ Failed to start server:\n\`\`\`\n${err}\n\`\`\``);
+    return;
+  }
+  const url = (result.stdout || '').trim();
+  if (!url) {
+    await sendLongMessage(token, chatState,
+      '❌ Server started but did not return a URL.');
+    return;
+  }
+  await setServerForChat(chatState, url);
+  await sendLongMessage(token, chatState,
+    `✅ Server started.\nURL: \`${url}\`\nDir: \`${targetDir}\``);
+  log.info(`[chat ${chatId}] Served ${targetDir} → ${url}`);
+}
+
+async function cmdNew(token, chatId, args, chatState, setServerForChat, setActiveSessionForChat) {
+  if (!tgagentpRootValid) {
+    const msg = TGAGENTP_ROOT
+      ? '❌ `TGAGENTP_ROOT` is not a valid writable directory.\nCheck the logs for details.'
+      : '❌ `TGAGENTP_ROOT` environment variable is not set.\nSet it to a writable directory to enable `/serve` and `/new` commands.';
+    await sendLongMessage(token, chatState, msg);
+    return;
+  }
+  const relPath = args.join(' ').trim();
+  if (!relPath) {
+    await sendLongMessage(token, chatState,
+      'Usage: `/new <path>`\n\n' +
+      'Create a new directory under `TGAGENTP_ROOT`, initialize git, and start a server.\n' +
+      'The path is relative to the root directory.');
+    return;
+  }
+  const targetDir = path.resolve(TGAGENTP_ROOT, relPath);
+  if (!targetDir.startsWith(TGAGENTP_ROOT)) {
+    await sendLongMessage(token, chatState,
+      '❌ Path must be within `TGAGENTP_ROOT`.\n' +
+      `Requested: \`${relPath}\``);
+    return;
+  }
+  if (fs.existsSync(targetDir)) {
+    await sendLongMessage(token, chatState,
+      `❌ Directory already exists: \`${relPath}\`.\n` +
+      'Use `/serve` to start a server in an existing directory.');
+    return;
+  }
+  try {
+    fs.mkdirSync(targetDir, { recursive: true });
+  } catch (err) {
+    await sendLongMessage(token, chatState,
+      `❌ Failed to create directory: ${err.message}`);
+    return;
+  }
+  const gitResult = spawnSync('git', ['init'], { cwd: targetDir, encoding: 'utf8', timeout: 10000 });
+  if (gitResult.status !== 0) {
+    const err = gitResult.stderr || gitResult.stdout || 'unknown error';
+    await sendLongMessage(token, chatState,
+      `❌ Failed to initialize git:\n\`\`\`\n${err}\n\`\`\``);
+    return;
+  }
+  await sendLongMessage(token, chatState,
+    `🚀 Starting server for \`${relPath}\`...`);
+  const result = spawnSync('ocmux', ['serve', targetDir], { encoding: 'utf8', timeout: 15000 });
+  if (result.status !== 0) {
+    const err = result.stderr || result.stdout || 'unknown error';
+    await sendLongMessage(token, chatState,
+      `❌ Failed to start server:\n\`\`\`\n${err}\n\`\`\``);
+    return;
+  }
+  const url = (result.stdout || '').trim();
+  if (!url) {
+    await sendLongMessage(token, chatState,
+      '❌ Server started but did not return a URL.');
+    return;
+  }
+  await setServerForChat(chatState, url);
+  await sendLongMessage(token, chatState,
+    `✅ Directory created and server started.\nURL: \`${url}\`\nDir: \`${targetDir}\``);
+  log.info(`[chat ${chatId}] Created ${targetDir} → ${url}`);
+}
+
+async function cmdMarkdown(token, chatId, args, chatState, setServerForChat, setActiveSessionForChat, replyTo, replyToMsgId) {
+  let entry = null;
+  if (replyToMsgId) {
+    entry = getResponseByMessageId(chatId, chatState.threadId, replyToMsgId);
+    if (!entry) {
+      await sendLongMessage(token, chatState, '❌ Could not find the original response for this message. It may be too old or was not sent by tgagentp.');
+      return;
+    }
+  } else {
+    entry = getRecentResponse(chatId, chatState.threadId, 1);
+    if (!entry) {
+      await sendLongMessage(token, chatState, '❌ No recent responses available. Send a message to the agent first.');
+      return;
+    }
+  }
+  const fileData = Buffer.from(entry.text, 'utf8');
+  const fileName = 'response-' + Date.now() + '.md';
+  await sendTelegramDocument(token, chatState, fileData, fileName, 'Original markdown response');
+}
+
 const COMMANDS = {
   'help': cmdHelp,
   'servers': cmdServers,
@@ -1327,6 +1615,9 @@ const COMMANDS = {
   'reject': cmdReject,
   'always': cmdAlways,
   'answer': cmdAnswer,
+  'serve': cmdServe,
+  'new': cmdNew,
+  'markdown': cmdMarkdown,
 };
 
 // --------------------------------------------------------------------------
@@ -1335,7 +1626,8 @@ 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, pendingQuestion: null, thinkingEnabled: false, messageQueue: [] };
+  const key = normalizeUrl(url);
+  return serverState[key] = serverState[key] || { busy: false, serverDead: false, pendingResponse: null, activeSessionId: null, activeSessionName: null, activeAgentName: null, taskId: 0, pendingPermission: null, pendingQuestion: null, thinkingEnabled: false, _thinkingBuf: '', messageQueue: [] };
 }
 
 function sessionLabel(st) {
@@ -1497,6 +1789,9 @@ async function main() {
     serverOwners[url] = { chatId: cs.chatId, threadId: cs.threadId };
     getState(url);
 
+    // Send Telegram bridge awareness note to the new session
+    sendGreeting(cs).catch(() => {});
+
     // Auto-activate tmux window for this server
     const servers = listServers();
     const normalized = normalizeUrl(url);
@@ -1533,12 +1828,48 @@ async function main() {
     return null;
   };
 
-  const setActiveSessionForChat = (chatState, id) => {
+  const setActiveSessionForChat = (chatState, id, name) => {
     const server = chatState.serverBase;
+    const prevId = getState(server).activeSessionId;
     getState(server).activeSessionId = id;
-    log.info(`[chat ${chatState.chatId}] Switched to session: ${id}`);
+    if (name) getState(server).activeSessionName = name;
+    log.info(`[chat ${chatState.chatId}] Switched to session: ${name || id}`);
+    if (id !== prevId) sendGreeting(chatState);
   };
 
+  const TELEGRAM_GREETING_BODY = (sessionName) =>
+    '[Telegram] The following information is for your awareness. Reply with only "Ack" and do not take any action:\n\n' +
+    'Your responses are being relayed through a Telegram bridge ' +
+    '(current session: ' + sessionName + ').\n' +
+    'The user sees your messages and can reply from there. ' +
+    'Their messages appear here prefixed with [Telegram].\n\n' +
+    'You can use these structured commands in your own response text ' +
+    '(on their own line, with no other content on that line). ' +
+    'Do NOT use CLI tools to generate them — just include them directly in your response:\n\n' +
+    'To send a file to the user:\n' +
+    '[Telegram]{"command":"upload","path":"<relative-path>","msg":"<optional caption>"}\n\n' +
+    'To download a file the user sent:\n' +
+    '[Telegram]{"command":"download","fileId":"<id>","path":"<relative-destination>"}\n\n' +
+    'For more details about a command:\n' +
+    '[Telegram]{"command":"help","topic":"<upload|download|help>"}';
+
+  async function sendGreeting(chatState) {
+    const st = getState(chatState.serverBase);
+    if (!st.activeSessionId) {
+      try {
+        const discovered = await discoverActiveSession(chatState.serverBase);
+        if (discovered) { st.activeSessionId = discovered.id; st.activeSessionName = discovered.name; }
+      } catch {}
+    }
+    if (!st.activeSessionId) return;
+    const greeting = TELEGRAM_GREETING_BODY(st.activeSessionName || st.activeSessionId);
+    try {
+      await sendToSession(chatState.serverBase, st.activeSessionId, greeting);
+    } catch (err) {
+      log.debug(`sendGreeting error: ${err.message}`);
+    }
+  }
+
   // Start agentp gateway (tiny HTTP server for agentp --tg)
   const serverBaseResolver = () => {
     const entries = Object.entries(serverOwners);
@@ -1563,7 +1894,6 @@ async function main() {
       let answer;
       if (useSession) {
         const notifiedPerms = new Set();
-        let thinkingBuf = '';
         let sseConnected;
         const onConnected = Promise.race([
           new Promise((resolve) => { sseConnected = resolve; }),
@@ -1573,14 +1903,16 @@ async function main() {
           onText: null,
           onConnected: sseConnected,
           onThinking: (chunk) => {
-            if (!getState(url).thinkingEnabled) { thinkingBuf = ''; return; }
-            thinkingBuf += chunk;
-            if (thinkingBuf.length >= 50 || chunk.endsWith('\n')) {
-              const html = '💭 ' + thinkingBuf.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+            const st2 = getState(url);
+            st2._thinkingBuf += chunk;
+            if (!st2.thinkingEnabled) return;
+            const buf = st2._thinkingBuf;
+            if (buf.length >= 50 || chunk.endsWith('\n')) {
+              st2._thinkingBuf = '';
+              const html = '💭 ' + buf.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
               sendLongMessage(token, chatState, html, replyTo, threadId)
                 .then(() => {})
                 .catch(() => {});
-              thinkingBuf = '';
             }
           },
           onPermission: (perm) => {
@@ -1628,10 +1960,10 @@ async function main() {
         }, cancelRef).catch(() => {});
         await onConnected;
         answer = await sendToSession(url, sessionId, `[Telegram] ${text}`, st.activeAgentName, sessionCancelRef);
-        if (thinkingBuf) {
-          const html = '💭 ' + thinkingBuf.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+        if (st.thinkingEnabled && st._thinkingBuf) {
+          const html = '💭 ' + st._thinkingBuf.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
           sendLongMessage(token, chatState, html, replyTo, threadId).catch(() => {});
-          thinkingBuf = '';
+          st._thinkingBuf = '';
         }
         // Keep the SSE listener alive so subsequent permission/question events
         // that arrive after sendToSession returns are still forwarded to Telegram.
@@ -1649,9 +1981,13 @@ async function main() {
       if (url === chatServer) {
         if (answer && answer.trim()) {
           const trimmed = answer.trim();
-          msgLog('out', chatId, '', trimmed);
-          await sendLongMessage(token, chatState, trimmed, replyTo, threadId);
-          bufferMessage(chatId, threadId, 'assistant', trimmed);
+          const cleaned = await processTelegramCommands(trimmed, url, token, chatState);
+          msgLog('out', chatId, '', cleaned);
+          if (cleaned) {
+            const msgIds = await sendLongMessage(token, chatState, cleaned, replyTo, threadId);
+            if (msgIds && msgIds.length > 0) recordResponseMessage(chatId, threadId, msgIds, cleaned);
+            bufferMessage(chatId, threadId, 'assistant', cleaned);
+          }
         }
       } else {
         getState(url).pendingResponse = answer;
@@ -1691,6 +2027,7 @@ async function main() {
         try { await sendLongMessage(token, chatState, msg, replyTo, threadId); } catch (_) {}
       }
     } finally {
+      st._thinkingBuf = '';
       st.pendingPermission = 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
@@ -2029,21 +2366,6 @@ async function main() {
         }
         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]`);
@@ -2144,11 +2466,16 @@ async function main() {
                 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}`);
+              const notification = `📎 File available: \`${fileName}\`${sizeStr}\n` +
+                `Use \`[Telegram]{"command":"download","fileId":"${fileId}","path":"<destination>"}\` to save it.`;
+              await sendLongMessage(token, cs, notification);
+              // Also send the notification to the agent's session so it knows the fileId
+              const st = getState(cs.serverBase);
+              if (st.activeSessionId) {
+                sendToSession(cs.serverBase, st.activeSessionId,
+                  '[Telegram] ' + notification).catch(() => {});
+              }
             } catch (err) {
               log.error(`Download on reply error: ${err.message}`);
               await sendLongMessage(token, cs, `❌ File download failed: ${err.message}`);
@@ -2186,7 +2513,12 @@ async function main() {
         try {
           const answer = await executeTuiCommand(paneId, cs.serverBase, tuiCmd);
           if (answer && answer.trim()) {
-            await sendLongMessage(token, cs, answer.trim());
+            const cleaned = await processTelegramCommands(answer.trim(), cs.serverBase, token, cs);
+            if (cleaned) {
+              await sendLongMessage(token, cs, cleaned);
+            } else {
+              await sendLongMessage(token, cs, `✅ \`${tuiCmd}\` submitted.`);
+            }
           } else {
             await sendLongMessage(token, cs, `✅ \`${tuiCmd}\` submitted.`);
           }
@@ -2206,22 +2538,23 @@ async function main() {
         const cmdArgs = parts.slice(1);
         const handler = cmds[cmd];
         if (handler) {
-          // Disconnected guard: only /help, /servers, /force-switch, /start, /comment, and /shutdown work without a server
-          if (!cs.serverBase && cmd !== 'help' && cmd !== 'servers' && cmd !== 'force-switch' && cmd !== 'start' && cmd !== 'comment' && cmd !== 'shutdown') {
+          // Disconnected guard: only /help, /servers, /force-switch, /start, /comment, /shutdown, /serve, and /new work without a server
+          if (!cs.serverBase && cmd !== 'help' && cmd !== 'servers' && cmd !== 'force-switch' && cmd !== 'start' && cmd !== 'comment' && cmd !== 'shutdown' && cmd !== 'serve' && cmd !== 'new') {
             await sendLongMessage(token, cs,
               '🔌 Not connected to any server.\n\n' +
               'Use `/servers` to see available servers and `/servers switch <name>` to connect.');
             continue;
           }
           try {
-            await handler(token, chatId, cmdArgs, cs, setServerForChat, setActiveSessionForChat);
+            const replyToMsgId = msg.reply_to_message ? msg.reply_to_message.message_id : 0;
+            await handler(token, chatId, cmdArgs, cs, setServerForChat, setActiveSessionForChat, replyTo, replyToMsgId);
           } catch (err) {
             log.error(`Error handling /${cmd}: ${err.message}`);
             try { await sendLongMessage(token, cs, `Error: ${err.message}`); } catch (_) {}
           }
         } else {
           await sendLongMessage(token, cs,
-            `Unknown command: /${cmd}\n\nAvailable commands: /help, /status, /servers, /sessions, /agents, /models, /think, /record, /queue, /flush, /note, /comment, /disconnect`);
+            `Unknown command: /${cmd}\n\nAvailable commands: /help, /status, /servers, /sessions, /agents, /models, /think, /record, /queue, /flush, /note, /comment, /disconnect, /serve, /new, /markdown`);
         }
         continue;
       }
@@ -2290,7 +2623,11 @@ process.on('SIGINT', () => {
   process.exit(0);
 });
 
-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 = { processTelegramCommands, parseTelegramLine, getHelpText, normalizeUrl };

package/lib/telegram-format.js

@@ -104,10 +104,13 @@ async function sendLongMessage(token, chatIdOrState, text, replyTo, threadId) {
     ? chatIdOrState.chatId : chatIdOrState;
   const effectiveThreadId = threadId || (typeof chatIdOrState === 'object' ? chatIdOrState.threadId : undefined);
   const chunks = splitMessage(text);
+  let msgIds = [];
   for (let i = 0; i < chunks.length; i++) {
     const html = convertMarkdownToHtml(chunks[i]);
-    await sendTelegramMessage(token, chatId, html, 'HTML', i === 0 ? replyTo : undefined, effectiveThreadId);
+    const result = await sendTelegramMessage(token, chatId, html, 'HTML', i === 0 ? replyTo : undefined, effectiveThreadId);
+    if (result && result.result) msgIds.push(result.result.message_id);
   }
+  return msgIds;
 }
 
 module.exports = {

package/package.json

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