agentp 0.11.5 → 0.11.7

package/README.md

@@ -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:

package/bin/ocmux

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

package/bin/tgagentp

@@ -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) {
@@ -362,8 +383,30 @@ 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;
+    }
     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`, or just `/help`.');
     return;
   }
   await sendLongMessage(token, chatState,
@@ -390,7 +433,11 @@ 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' +
+    '`/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>`.');
 }
 
@@ -1059,6 +1106,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 +1120,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 +1363,133 @@ 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}`);
+}
+
 const COMMANDS = {
   'help': cmdHelp,
   'servers': cmdServers,
@@ -1327,6 +1509,8 @@ const COMMANDS = {
   'reject': cmdReject,
   'always': cmdAlways,
   'answer': cmdAnswer,
+  'serve': cmdServe,
+  'new': cmdNew,
 };
 
 // --------------------------------------------------------------------------
@@ -1335,7 +1519,7 @@ const COMMANDS = {
 
 const serverState = {};
 function getState(url) {
-  return serverState[url] = serverState[url] || { busy: false, serverDead: false, pendingResponse: null, activeSessionId: null, activeSessionName: null, activeAgentName: null, taskId: 0, pendingPermission: null, pendingQuestion: null, thinkingEnabled: false, messageQueue: [] };
+  return serverState[url] = serverState[url] || { busy: false, serverDead: false, pendingResponse: null, activeSessionId: null, activeSessionName: null, activeAgentName: null, taskId: 0, pendingPermission: null, pendingQuestion: null, thinkingEnabled: false, _thinkingBuf: '', messageQueue: [] };
 }
 
 function sessionLabel(st) {
@@ -1563,7 +1747,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 +1756,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 +1813,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._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.
@@ -1691,6 +1876,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
@@ -1813,6 +1999,18 @@ async function main() {
     const intro = 'The following information is for your awareness. Reply with only "Ack" and do not take any action:';
     const noteText = intro + '\n\n' + text;
     if (st.busy) {
+      // Experimental: try async injection instead of queuing
+      if (st.activeSessionId) {
+        try {
+          log.debug(`  → /note: attempting async injection into session ${st.activeSessionId}`);
+          await sendToSessionAsync(url, st.activeSessionId, noteText, st.activeAgentName);
+          await sendLongMessage(token, chatState, '💉 Note injected into ongoing session.');
+          log.debug(`  → /note: async injection succeeded`);
+          return;
+        } catch (err) {
+          log.debug(`  → /note: async injection failed (${err.message}), falling back to queue`);
+        }
+      }
       if (!st.messageQueue) st.messageQueue = [];
       st.messageQueue.push({ text: noteText, replyTo: null });
       await sendLongMessage(token, chatState, `⏳ Server is busy. Note queued (#${st.messageQueue.length}).`);
@@ -2084,7 +2282,25 @@ async function main() {
 
       if (typeof msg.text !== 'string') continue;
 
-      const text = msg.text;
+      let text = msg.text;
+
+      // !! wildcard: replace with the previous user message text
+      if (text.includes('!!')) {
+        const prevMsg = msg.reply_to_message;
+        if (prevMsg && prevMsg.text) {
+          text = text.replace(/!!/g, prevMsg.text);
+        } else {
+          // Fallback: look up the last user message from the ring buffer
+          const ring = getChatState(chatId, threadId).ring;
+          const lastUserMsg = ring.messages.slice().reverse().find(m => m.role === 'user');
+          if (lastUserMsg) {
+            text = text.replace(/!!/g, lastUserMsg.text);
+          } else {
+            await sendLongMessage(token, cs, '⚠️ No previous message found to replace !!');
+            continue;
+          }
+        }
+      }
 
       log.debug(`[chat ${chatId}] ${from}: ${text}`);
       msgLog('in', chatId, from, text);
@@ -2092,6 +2308,42 @@ async function main() {
       // Build reply context if this message is a Telegram reply
       const replyContext = quoteReply(msg);
 
+      // Download on reply: if the user replies to a file message, download it
+      if (msg.reply_to_message && (msg.reply_to_message.document || msg.reply_to_message.photo)) {
+        if (!cs.serverBase) {
+          await sendLongMessage(token, cs, '🔌 Not connected to any server. Cannot download file.');
+        } else {
+          const projectDir = serverDir(cs.serverBase);
+          if (!projectDir) {
+            await sendLongMessage(token, cs, '❌ Could not find project directory for this server.');
+          } else {
+            try {
+              const replyMsg = msg.reply_to_message;
+              let fileId, fileName, fileSize;
+              if (replyMsg.document) {
+                fileId = replyMsg.document.file_id;
+                fileName = replyMsg.document.file_name || 'download.bin';
+                fileSize = replyMsg.document.file_size || 0;
+              } else if (replyMsg.photo) {
+                const largest = replyMsg.photo[replyMsg.photo.length - 1];
+                fileId = largest.file_id;
+                fileName = 'photo.jpg';
+                fileSize = largest.file_size || 0;
+              }
+              const fileData = await downloadTelegramFile(token, fileId);
+              ensureSharedDir(projectDir);
+              const relativePath = saveUploadedFile(projectDir, fileName, fileData);
+              const sizeStr = fileSize > 0 ? ` (${formatFileSize(fileSize)})` : '';
+              await sendLongMessage(token, cs, `📎 File downloaded: \`${relativePath}\`${sizeStr}`);
+            } catch (err) {
+              log.error(`Download on reply error: ${err.message}`);
+              await sendLongMessage(token, cs, `❌ File download failed: ${err.message}`);
+            }
+          }
+        }
+        continue;
+      }
+
       // Intercept //commands (raw TUI passthrough via tmux send-keys)
       if (text.startsWith('//')) {
         const tuiCmd = text.slice(1);
@@ -2140,8 +2392,8 @@ 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.');
@@ -2155,7 +2407,7 @@ async function main() {
           }
         } 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`);
         }
         continue;
       }

package/lib/ocmux.js

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

package/package.json

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