agentp 0.4.0 → 0.5.0

package/bin/tgagentp

@@ -0,0 +1,899 @@
+#!/usr/bin/env node
+
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+const { version } = require('../package.json');
+const { sendText, listenForFinalAnswer, listSessions, createSession, updateSession, selectSession, sendToSession, listAgents, listProviders } = require('../lib/opencode.js');
+
+const STARTUP_CHAT_FILE = '/tmp/tgagentp-startup-chat';
+const { listServers, activateServer } = require('../lib/ocmux.js');
+
+// ---------------------------------------------------------------------------
+// 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) {
+  const params = { chat_id: chatId, text };
+  if (parseMode) params.parse_mode = parseMode;
+  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) {
+  if (!raw || !raw.trim()) return null;
+  const ids = raw.split(',').map(s => s.trim()).filter(Boolean);
+  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, chatId, text) {
+  const chunks = splitMessage(text);
+  for (const chunk of chunks) {
+    const html = convertMarkdownToHtml(chunk);
+    await sendTelegramMessage(token, chatId, html, 'HTML');
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Telegram command handlers
+// ---------------------------------------------------------------------------
+
+async function cmdHelp(token, chatId, args) {
+  if (args.length > 0) {
+    const topic = args[0].toLowerCase();
+    if (topic === 'servers') {
+      await sendLongMessage(token, chatId,
+        '`/servers` — list all opencode servers (ocmux sessions)\n' +
+        '`/servers switch <name>` — switch target server\n\n' +
+        '`<name>` can be a full path or basename of the project directory.');
+      return;
+    }
+    if (topic === 'sessions') {
+      await sendLongMessage(token, chatId,
+        '`/sessions` — list active sessions (numbered, newest first, max 50)\n' +
+        '`/sessions switch <number-or-name>` — send messages to a specific session\n' +
+        '`/sessions new [name]` — create a new session\n' +
+        '`/sessions rename <name>` — rename the active session\n\n' +
+        'Switch by number (from the list) or by case-insensitive partial name match.\n' +
+        'Use `/sessions` to find session numbers.');
+      return;
+    }
+    if (topic === 'shutdown') {
+      await sendLongMessage(token, chatId,
+        '`/shutdown` — stop tgagentp process\n\n' +
+        'Only available when tgagentp is started with `--dev` flag.\n' +
+        'Useful when running tgagentp in a restart loop:\n' +
+        '`while true; do tgagentp --dev; done`');
+      return;
+    }
+    if (topic === 'agents') {
+      await sendLongMessage(token, chatId,
+        '`/agents` — list all available agents (name, mode, assigned model, description).\n' +
+        '`/agents switch <name>` — switch the active agent. Subsequent messages will use this agent.\n\n' +
+        'Agent switching requires an active session (`/sessions switch` or `/sessions new`).');
+      return;
+    }
+    if (topic === 'session') {
+      await sendLongMessage(token, chatId,
+        '`/session` is an alias for `/sessions`.\n\n' +
+        '`/sessions` — list active sessions\n' +
+        '`/sessions switch <number-or-name>` — switch to a session\n' +
+        '`/sessions new [name]` — create a new session\n' +
+        '`/sessions rename <name>` — rename the active session');
+      return;
+    }
+    if (topic === 'models') {
+      await sendLongMessage(token, chatId,
+        '`/models` — list all providers and their models.\n' +
+        'Shows provider name, connection status, default model, and up to 5 models per provider\n' +
+        'with status, context limit, and input/output costs.');
+      return;
+    }
+    await sendLongMessage(token, chatId,
+      'Unknown topic. Try `/help servers`, `/help sessions`, `/help session`, `/help agents`, `/help models`, or just `/help`.');
+    return;
+  }
+  await sendLongMessage(token, chatId,
+    '`/help` — show this message\n' +
+    '`/help <topic>` — detailed help\n' +
+    '`/status` — show current server and session\n' +
+    '`/cancel` — cancel the running prompt\n' +
+    '`/servers` — list running opencode servers\n' +
+    '`/servers switch <name>` — switch to a different server\n' +
+    '`/sessions` — list/create/switch/rename sessions\n' +
+    '`/sessions switch <number-or-name>` — switch to a session\n' +
+    '`/sessions new [name]` — create a new session\n' +
+    '`/sessions rename <name>` — rename the active session\n' +
+    '`/session` — alias for `/sessions`\n' +
+    '`/agents` — list available agents\n' +
+    '`/agents switch <name>` — switch active agent\n' +
+    '`/models` — list providers and models\n' +
+    '`/shutdown` — stop tgagentp (only with `--dev` flag)\n\n' +
+    'Everything else is forwarded to the active server as `[Telegram] <text>`.');
+}
+
+async function cmdServers(token, chatId, args, setServer) {
+  if (args.length > 0 && args[0].toLowerCase() === 'switch') {
+    if (args.length < 2) {
+      await sendLongMessage(token, chatId,
+        'Usage: `/servers switch <name>`\n' +
+        '`<name>` can be a full directory path or a basename.');
+      return;
+    }
+    const name = args.slice(1).join(' ');
+    const servers = listServers();
+    if (servers.length === 0) {
+      await sendLongMessage(token, chatId, 'No servers running.');
+      return;
+    }
+    let matches = servers.filter(s => s.dir === name);
+    if (matches.length === 0) {
+      matches = servers.filter(s => path.basename(s.dir) === name);
+    }
+    if (matches.length === 0) {
+      matches = servers.filter(s => s.dir.includes(name) || path.basename(s.dir).includes(name));
+    }
+    if (matches.length === 0) {
+      await sendLongMessage(token, chatId, `No server found matching "${name}".`);
+      return;
+    }
+    if (matches.length > 1) {
+      const list = matches.map(s => `  ${s.url} → ${s.dir}`).join('\n');
+      await sendLongMessage(token, chatId,
+        `Multiple matches for "${name}":\n${list}\n\nPlease be more specific.`);
+      return;
+    }
+    const target = matches[0];
+    const pending = setServer(target.url);
+    activateServer(target.dir, target.index, target.url);
+    let msg = `Switched to server: ${target.url} → ${target.dir}`;
+    if (pending && pending.trim()) {
+      await sendLongMessage(token, chatId, msg);
+      await sendLongMessage(token, chatId, pending.trim());
+    } else {
+      await sendLongMessage(token, chatId, msg);
+    }
+    return;
+  }
+
+  // Default: list servers
+  const servers = listServers();
+  if (servers.length === 0) {
+    await sendLongMessage(token, chatId, 'No servers running.');
+    return;
+  }
+  const lines = servers.map(s => `  ${s.url} → ${s.dir} (${s.status})`);
+  await sendLongMessage(token, chatId, 'Active servers:\n' + lines.join('\n'));
+}
+
+function sessionName(s) {
+  return s.title || s.slug || s.id;
+}
+
+function normalizeUrl(url) {
+  return url.replace(/\/+$/, '').replace(/^http:\/\/127\.0\.0\.1:/, 'http://localhost:');
+}
+
+function serverDir(serverUrl) {
+  const servers = listServers();
+  const normalized = normalizeUrl(serverUrl);
+  const found = servers.find(s => normalizeUrl(s.url) === normalized);
+  return found ? found.dir : null;
+}
+
+// Sort by time.updated descending, limit to N.
+function sortedSessions(sessions, limit) {
+  return sessions
+    .filter(s => s.time && s.time.updated)
+    .sort((a, b) => b.time.updated - a.time.updated)
+    .slice(0, limit || 50);
+}
+
+async function cmdSessions(token, chatId, args, setServer, setActiveSession, server) {
+  if (args.length > 0) {
+    const sub = args[0].toLowerCase();
+
+    if (sub === 'new') {
+      const title = args.slice(1).join(' ') || undefined;
+      try {
+        const session = await createSession(server, title);
+        const name = session.title || session.slug || session.id;
+        setActiveSession(session.id);
+        selectSession(server, session.id);
+        await sendLongMessage(token, chatId,
+          `Created session: \`${name}\`\nIt is now the active session.`);
+      } catch (err) {
+        await sendLongMessage(token, chatId, `Error creating session: ${err.message}`);
+      }
+      return;
+    }
+
+    if (sub === 'rename') {
+      if (args.length < 2) {
+        await sendLongMessage(token, chatId, 'Usage: `/sessions rename <name>`');
+        return;
+      }
+      const st = getState(server);
+      if (!st.activeSessionId) {
+        await sendLongMessage(token, chatId, 'No active session. Use `/sessions switch` or `/sessions new` first.');
+        return;
+      }
+      const newTitle = args.slice(1).join(' ');
+      try {
+        const session = await updateSession(server, st.activeSessionId, newTitle);
+        const name = session.title || session.slug || session.id;
+        await sendLongMessage(token, chatId,
+          `Renamed session to: \`${name}\``);
+      } catch (err) {
+        await sendLongMessage(token, chatId, `Error renaming session: ${err.message}`);
+      }
+      return;
+    }
+
+    if (sub === 'switch') {
+      if (args.length < 2) {
+        await sendLongMessage(token, chatId,
+          'Usage: `/sessions switch <number-or-name>`\n' +
+          'Use `/sessions` to see numbered list. You can switch by number or by name (case-insensitive partial match).');
+        return;
+      }
+      const query = args.slice(1).join(' ');
+      try {
+        const projectDir = serverDir(server);
+        const sessions = await listSessions(server, projectDir);
+        const activeId = getState(server).activeSessionId;
+        const filtered = sessions.filter(s =>
+          (s.agent || s.directory || s.id === activeId) && (!projectDir || s.directory === projectDir));
+        const sorted = sortedSessions(filtered, 50);
+
+        // Try by position number first
+        const num = parseInt(query, 10);
+        if (/^\d+$/.test(query) && num >= 1 && num <= sorted.length) {
+          const target = sorted[num - 1];
+          setActiveSession(target.id);
+          selectSession(server, target.id);
+          await sendLongMessage(token, chatId,
+            `Switched to session #${num}: \`${sessionName(target)}\`\nSubsequent messages will be sent to this session.`);
+          return;
+        }
+
+        // Try by name (case-insensitive partial match)
+        const q = query.toLowerCase();
+        const matches = sorted.filter(s => sessionName(s).toLowerCase().includes(q));
+        if (matches.length === 0) {
+          await sendLongMessage(token, chatId,
+            `No session matching "${query}". Use /sessions to list active sessions.`);
+          return;
+        }
+        if (matches.length > 1) {
+          const list = matches.map(s => `  \`${sessionName(s)}\``).join('\n');
+          await sendLongMessage(token, chatId,
+            `Multiple matches for "${query}":\n${list}\n\nPlease be more specific or use a number.`);
+          return;
+        }
+        const target = matches[0];
+        setActiveSession(target.id);
+        selectSession(server, target.id);
+        await sendLongMessage(token, chatId,
+          `Switched to session: \`${sessionName(target)}\`\nSubsequent messages will be sent to this session.`);
+      } catch (err) {
+        await sendLongMessage(token, chatId, `Error switching session: ${err.message}`);
+      }
+      return;
+    }
+
+    // Unknown subcommand
+    await sendLongMessage(token, chatId,
+      `Unknown subcommand: /sessions ${sub}\n\n` +
+      'Usage:\n' +
+      '  `/sessions` — list sessions\n' +
+      '  `/sessions switch <number-or-name>` — switch to a session\n' +
+      '  `/sessions new [name]` — create a new session\n' +
+      '  `/sessions rename <name>` — rename the active session');
+    return;
+  }
+
+  // Default: list sessions
+  try {
+    const projectDir = serverDir(server);
+    const sessions = await listSessions(server, projectDir);
+    if (!sessions || sessions.length === 0) {
+      await sendLongMessage(token, chatId, 'No active sessions.');
+      return;
+    }
+
+    // Show user sessions (have agent or directory) and always include the active session
+    const activeId = getState(server).activeSessionId;
+    const filtered = sessions.filter(s =>
+      (s.agent || s.directory || s.id === activeId) && (!projectDir || s.directory === projectDir));
+    const sorted = sortedSessions(filtered, 50);
+    if (sorted.length === 0) {
+      await sendLongMessage(token, chatId, 'No active sessions.');
+      return;
+    }
+
+    // Build lines with date headings and time labels
+    const now = new Date();
+    const todayStr = now.toLocaleDateString();
+    const oneWeekAgo = new Date(now);
+    oneWeekAgo.setDate(oneWeekAgo.getDate() - 7);
+
+    const lines = [];
+    let currentHeading = null;
+
+    sorted.forEach((s, idx) => {
+      const created = new Date(s.time.updated);
+      const isToday = created.toLocaleDateString() === todayStr;
+      const isRecent = created >= oneWeekAgo;
+
+      let heading;
+      if (isToday) {
+        heading = '**Today**';
+      } else if (isRecent) {
+        heading = '**' + created.toLocaleDateString(undefined, { weekday: 'short', month: 'short', day: 'numeric' }) + '**';
+      } else {
+        heading = '**' + created.getFullYear() + '-' + String(created.getMonth() + 1).padStart(2, '0') + '**';
+      }
+      if (heading !== currentHeading) {
+        lines.push('');
+        lines.push(heading);
+        currentHeading = heading;
+      }
+
+      const hh = String(created.getHours()).padStart(2, '0');
+      const mm = String(created.getMinutes()).padStart(2, '0');
+      const timeLabel = isRecent
+        ? `[${hh}:${mm}]`
+        : `[${String(created.getDate()).padStart(2, '0')}/${String(created.getMonth() + 1).padStart(2, '0')} - ${hh}:${mm}]`;
+
+      const name = sessionName(s);
+      const pos = idx + 1;
+      const bullet = s.id === activeId ? '▶ ' : ' · ';
+      lines.push('`' + bullet + pos + ' ' + timeLabel + ' – ' + name.replace(/`/g, "'") + '`');
+    });
+
+    await sendLongMessage(token, chatId, 'Sessions:\n' + lines.join('\n'));
+  } catch (err) {
+    await sendLongMessage(token, chatId, `Error listing sessions: ${err.message}`);
+  }
+}
+
+async function cmdAgents(token, chatId, args, setServer, setActiveSession, server) {
+  if (args.length > 0 && args[0].toLowerCase() === 'switch') {
+    if (args.length < 2) {
+      await sendLongMessage(token, chatId,
+        'Usage: `/agents switch <name>`\n' +
+        'Use `/agents` to list available agents.');
+      return;
+    }
+    const name = args.slice(1).join(' ');
+    try {
+      const agents = await listAgents(server);
+      if (!agents || agents.length === 0) {
+        await sendLongMessage(token, chatId, 'No agents available.');
+        return;
+      }
+      let matches = agents.filter(a => a.name === name);
+      if (matches.length === 0) {
+        matches = agents.filter(a => a.name.toLowerCase().includes(name.toLowerCase()));
+      }
+      if (matches.length === 0) {
+        await sendLongMessage(token, chatId, `No agent matching "${name}".`);
+        return;
+      }
+      if (matches.length > 1) {
+        const list = matches.map(a => `  \`${a.name}\``).join('\n');
+        await sendLongMessage(token, chatId,
+          `Multiple matches for "${name}":\n${list}\n\nPlease be more specific.`);
+        return;
+      }
+      const target = matches[0];
+      getState(server).activeAgentName = target.name;
+      const mode = target.mode === 'primary' ? '' : ` (${target.mode})`;
+      const model = target.model ? ` — \`${target.model.providerID}/${target.model.modelID}\`` : '';
+      await sendLongMessage(token, chatId,
+        `Switched to agent: **${target.name}**${mode}${model}\nSubsequent messages will use this agent.`);
+    } catch (err) {
+      await sendLongMessage(token, chatId, `Error switching agent: ${err.message}`);
+    }
+    return;
+  }
+
+  try {
+    const agents = await listAgents(server);
+    if (!agents || agents.length === 0) {
+      await sendLongMessage(token, chatId, 'No agents available.');
+      return;
+    }
+    const lines = agents.map(a => {
+      const mode = a.mode === 'primary' ? '' : ` (${a.mode})`;
+      const model = a.model ? ` — \`${a.model.providerID}/${a.model.modelID}\`` : '';
+      const desc = a.description ? `. ${a.description}` : '';
+      return '**' + a.name + '**' + mode + model + desc;
+    });
+    await sendLongMessage(token, chatId, 'Agents:\n' + lines.join('\n'));
+  } catch (err) {
+    await sendLongMessage(token, chatId, `Error listing agents: ${err.message}`);
+  }
+}
+
+async function cmdModels(token, chatId, args, setServer, setActiveSession, server) {
+  try {
+    const result = await listProviders(server);
+    const all = result.all || [];
+    const connectedIds = result.connected || [];
+
+    const filtered = all.filter(p => connectedIds.includes(p.id));
+    if (filtered.length === 0) {
+      await sendLongMessage(token, chatId, 'No connected providers.');
+      return;
+    }
+
+    const lines = [];
+
+    for (const provider of filtered) {
+      lines.push('');
+      lines.push('**' + provider.name + '** ✅');
+
+      const modelEntries = Object.entries(provider.models || {});
+      if (modelEntries.length === 0) continue;
+
+      const shown = modelEntries.slice(0, 5);
+      for (const [id, model] of shown) {
+        const ctx = model.limit ? Math.round(model.limit.context / 1000) + 'K' : '';
+        const cost = model.cost ? ` $${model.cost.input}/${model.cost.output}` : '';
+        lines.push('  `' + id + '`' + (ctx ? ' ' + ctx : '') + cost);
+      }
+      if (modelEntries.length > 5) {
+        lines.push('  *…and ' + (modelEntries.length - 5) + ' more*');
+      }
+    }
+
+    await sendLongMessage(token, chatId, 'Connected providers:\n' + lines.join('\n'));
+  } catch (err) {
+    await sendLongMessage(token, chatId, `Error listing models: ${err.message}`);
+  }
+}
+
+const COMMANDS = {
+  'help': cmdHelp,
+  'servers': cmdServers,
+  'sessions': cmdSessions,
+  'session': cmdSessions,
+  'agents': cmdAgents,
+  'models': cmdModels,
+};
+
+// --------------------------------------------------------------------------
+// Module-level state
+// ---------------------------------------------------------------------------
+
+const serverState = {};
+function getState(url) {
+  return serverState[url] = serverState[url] || { busy: false, pendingResponse: null, activeSessionId: null, activeAgentName: null, taskId: 0 };
+}
+
+// --------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+async function main() {
+  let serverBase = 'http://localhost:4096';
+
+  let DEV_MODE = false;
+
+  const args = process.argv.slice(2);
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--version') {
+      console.log(version);
+      process.exit(0);
+    } else if (args[i] === '--dev') {
+      DEV_MODE = true;
+    } else if (args[i] === '--help') {
+      console.error('Usage: tgagentp [options] [url]');
+      console.error('');
+      console.error('Bridge a Telegram bot chat with an OpenCode TUI session.');
+      console.error('Incoming Telegram messages are forwarded to OpenCode; answers are sent back to the chat.');
+      console.error('');
+      console.error('Options:');
+      console.error('  --dev      Enable development mode (adds /shutdown command)');
+      console.error('  --version  Show version');
+      console.error('  --help     Show this help message');
+      console.error('');
+      console.error('Arguments:');
+      console.error('  url        OpenCode TUI server URL or port number (default: 4096)');
+      console.error('             Examples: 4096, http://localhost:4096, http://192.168.1.50:4096');
+      console.error('');
+      console.error('Environment variables:');
+      console.error('  TELEGRAM_BOT_TOKEN         Telegram bot token (required)');
+      console.error('  OPENCODE_SERVER_PASSWORD    OpenCode server password (optional)');
+      console.error('  OPENCODE_SERVER_USERNAME    OpenCode server username (optional, default: opencode)');
+      console.error('  TGAGENTP_ALLOWED_CHAT_IDS   Comma-separated Telegram chat IDs (optional)');
+      console.error('                               Example: "123456,-789012"');
+      console.error('');
+      console.error('See also: agentp, ocmux');
+      console.error('');
+      console.error('Examples:');
+      console.error('  export TELEGRAM_BOT_TOKEN="your-bot-token"');
+      console.error('  tgagentp');
+      console.error('  tgagentp 4096');
+      console.error('  tgagentp http://192.168.1.50:4096');
+      process.exit(0);
+    } else if (args[i].includes('://')) {
+      serverBase = args[i].replace(/\/+$/, '');
+    } else if (/^\d+$/.test(args[i])) {
+      serverBase = 'http://localhost:' + args[i];
+    }
+  }
+
+  const token = process.env.TELEGRAM_BOT_TOKEN;
+  if (!token) {
+    console.error('Error: TELEGRAM_BOT_TOKEN environment variable is not set.');
+    console.error('Create a bot with @BotFather on Telegram and export the token before running tgagentp.');
+    process.exit(1);
+  }
+
+  process.stderr.write(`tgagentp v${version} started. OpenCode server: ${serverBase}\n`);
+
+  if (!process.env.OPENCODE_SERVER_PASSWORD) {
+    process.stderr.write('🔓 ⚠️  Server is not password-protected! Set OPENCODE_SERVER_PASSWORD for better security.\n');
+  }
+
+  const allowedChatIds = parseAllowlist(process.env.TGAGENTP_ALLOWED_CHAT_IDS);
+  if (allowedChatIds) {
+    process.stderr.write(`Chat allowlist: ${allowedChatIds.length} chat(s) configured\n`);
+  } else {
+    process.stderr.write('Chat allowlist: not configured (all chats accepted)\n');
+  }
+
+  let lockedChatId = null;
+
+  process.stderr.write('Waiting for Telegram messages... (Ctrl+C to stop)\n');
+
+  getState(serverBase);
+
+  const setServer = (url) => {
+    serverBase = url;
+    getState(url);
+    process.stderr.write(`Switched to server: ${url}\n`);
+    const p = getState(url).pendingResponse;
+    if (p) {
+      getState(url).pendingResponse = null;
+      return p;
+    }
+    return null;
+  };
+
+  const setActiveSession = (id) => {
+    getState(serverBase).activeSessionId = id;
+    process.stderr.write(`Switched to session: ${id}\n`);
+  };
+
+  async function processMessageAsync(chatId, text, url, useSession, sessionId, myTaskId) {
+    const st = getState(url);
+    const isCancelled = () => getState(url).taskId !== myTaskId;
+    const cancelRef = { current: null };
+    st._cancelRef = cancelRef;
+    try {
+      let answer;
+      if (useSession) {
+        answer = await sendToSession(url, sessionId, `[Telegram] ${text}`, st.activeAgentName);
+      } else {
+        await sendText(url, `[Telegram] ${text}`);
+        answer = await listenForFinalAnswer(url, null, cancelRef);
+      }
+      if (isCancelled()) {
+        process.stderr.write(`  → cancelled, discarding response from ${url}\n`);
+        return;
+      }
+      if (url === serverBase) {
+        if (answer && answer.trim()) {
+          await sendLongMessage(token, chatId, answer.trim());
+        }
+      } else {
+        getState(url).pendingResponse = answer;
+        await sendLongMessage(token, chatId, `✅ Server \`${url}\` finished processing. Switch back to see the response.`);
+      }
+    } catch (err) {
+      if (isCancelled()) {
+        process.stderr.write(`  → cancelled, ignoring error from ${url}: ${err.message}\n`);
+        return;
+      }
+      process.stderr.write(`Error processing message (${url}): ${err.message}\n`);
+      if (url === serverBase) {
+        try { await sendLongMessage(token, chatId, `Error: ${err.message}`); } catch (_) {}
+      }
+    } finally {
+      if (st._cancelRef === cancelRef) st._cancelRef = null;
+      if (!isCancelled()) {
+        getState(url).busy = false;
+      }
+    }
+  }
+
+  const cmdCancel = async (token, chatId) => {
+    const st = getState(serverBase);
+    if (!st.busy) {
+      await sendLongMessage(token, chatId, 'Nothing to cancel.');
+      return;
+    }
+    st.taskId++;
+    st.busy = false;
+    // Abort the SSE stream so the server stops processing
+    if (st._cancelRef && st._cancelRef.current) {
+      st._cancelRef.current.destroy();
+      st._cancelRef.current = null;
+    }
+    await sendLongMessage(token, chatId, '✅ Cancelled.');
+    process.stderr.write(`  → /cancel on ${serverBase}\n`);
+  }
+
+  const cmdStatus = async (token, chatId) => {
+    const st = getState(serverBase);
+    const busyInfo = st.busy ? '⏳ busy' : '✅ idle';
+    const dir = serverDir(serverBase);
+    const lines = ['**Server:**'];
+    if (dir) lines.push('  • **Path:** `' + dir + '`');
+    lines.push('  • **URL:** `' + serverBase + '`');
+    lines.push('  • **Status:** ' + busyInfo);
+    lines.push('**Session:** ' + (st.activeSessionId ? '`' + st.activeSessionId + '`' : '*none (TUI+SSE)*'));
+    lines.push('**Agent:** ' + (st.activeAgentName ? '`' + st.activeAgentName + '`' : '*default*'));
+    await sendLongMessage(token, chatId, lines.join('\n'));
+  };
+
+  const cmdShutdown = async (token, chatId) => {
+    await sendLongMessage(token, chatId, '👋 Shutting down...');
+    try {
+      fs.writeFileSync(STARTUP_CHAT_FILE, String(chatId));
+    } catch (_) {}
+    try { await getUpdates(token, offset, 1); } catch (_) {}
+    process.stderr.write('/shutdown received, exiting...\n');
+    process.exit(0);
+  };
+
+  const cmds = { ...COMMANDS, status: cmdStatus, cancel: cmdCancel };
+  if (DEV_MODE) cmds.shutdown = cmdShutdown;
+
+  let offset = 0;
+
+  // Startup greeting to last-known chat
+  const savedChatId = (() => { try { return fs.readFileSync(STARTUP_CHAT_FILE, 'utf8').trim(); } catch { return null; } })();
+  if (savedChatId) {
+    const dir = serverDir(serverBase);
+    const lines = ['✅ Bot started.', '**Server:**'];
+    if (dir) lines.push('  • **Path:** `' + dir + '`');
+    lines.push('  • **URL:** `' + serverBase + '`');
+    lines.push('  • **Status:** ✅ idle');
+    lines.push('**Session:** *none (TUI+SSE)*');
+    try { await sendLongMessage(token, savedChatId, lines.join('\n')); } catch (_) {}
+    try { fs.unlinkSync(STARTUP_CHAT_FILE); } catch (_) {}
+  }
+
+  // Poll for updates and forward each text message to OpenCode, sending the answer back.
+  while (true) {
+    let result;
+    try {
+      result = await getUpdates(token, offset, 30);
+    } catch (err) {
+      process.stderr.write(`Polling error: ${err.message}\n`);
+      await new Promise((r) => setTimeout(r, 5000));
+      continue;
+    }
+
+    if (!result.ok) {
+      process.stderr.write(`Telegram API error: ${result.description || JSON.stringify(result)}\n`);
+      await new Promise((r) => setTimeout(r, 5000));
+      continue;
+    }
+
+    for (const update of result.result) {
+      offset = update.update_id + 1;
+
+      const msg = update.message;
+      if (!msg || typeof msg.text !== 'string') {
+        // Ignore non-text messages (photos, stickers, etc.)
+        continue;
+      }
+
+      const chatId = String(msg.chat.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';
+
+      // Enforce chat allowlist if configured
+      if (allowedChatIds && !allowedChatIds.includes(chatId)) {
+        process.stderr.write(`[chat ${chatId}] ${from}: blocked (not in allowlist)\n`);
+        continue;
+      }
+
+      // Lock to the first chat that connects (single-user guard)
+      if (lockedChatId === null) {
+        lockedChatId = chatId;
+        process.stderr.write(`[chat ${chatId}] ${from}: locked to this chat\n`);
+      } else if (lockedChatId !== chatId) {
+        process.stderr.write(`[chat ${chatId}] ${from}: blocked (locked to ${lockedChatId})\n`);
+        continue;
+      }
+
+      process.stderr.write(`[chat ${chatId}] ${from}: ${text}\n`);
+      try { fs.writeFileSync(STARTUP_CHAT_FILE, String(chatId)); } catch (_) {}
+
+      // Intercept /commands
+      if (text.startsWith('/')) {
+        const parts = text.slice(1).split(' ');
+        const cmd = parts[0].toLowerCase();
+        const cmdArgs = parts.slice(1);
+        const handler = cmds[cmd];
+        if (handler) {
+          try {
+            await handler(token, chatId, cmdArgs, setServer, setActiveSession, serverBase);
+          } catch (err) {
+            process.stderr.write(`Error handling /${cmd}: ${err.message}\n`);
+            try { await sendLongMessage(token, chatId, `Error: ${err.message}`); } catch (_) {}
+          }
+        } else {
+          await sendLongMessage(token, chatId,
+            `Unknown command: /${cmd}\n\nAvailable commands: /help, /status, /servers, /sessions, /agents, /models`);
+        }
+        continue;
+      }
+
+      // Non-command message — process in background
+      const st = getState(serverBase);
+      if (st.busy) {
+        await sendLongMessage(token, chatId, '⏳ Server is busy processing a previous message. Please wait for it to finish, or use /cancel to cancel it.');
+        continue;
+      }
+      st.busy = true;
+      const myTaskId = ++st.taskId;
+      process.stderr.write(`  → started background processing (task ${myTaskId})\n`);
+      processMessageAsync(chatId, text, serverBase, !!st.activeSessionId, st.activeSessionId, myTaskId);
+    }
+  }
+}
+
+process.on('SIGINT', () => {
+  process.stderr.write('\ntgagentp stopped.\n');
+  process.exit(0);
+});
+
+main().catch((err) => {
+  console.error('Error:', err.message);
+  process.exit(1);
+});