agentp 1.14.0 → 2.0.0

package/bin/agentp

@@ -13,9 +13,14 @@ const {
   sendToSessionAsync,
   listSessions,
   createSession,
+  createSessionWithModel,
   getSession,
   selectSession,
+  sortSessionsByRecency,
+  interruptSession,
 } = require('../lib/opencode');
+const projectState = require('../lib/project-state');
+const ocmuxLib = require('../lib/ocmux');
 
 const TGAGENTP_PORT_FILE = '/tmp/tgagentp-port';
 
@@ -169,6 +174,7 @@ function parseDeferredTicketInput(text) {
     defer: typeof data.defer === 'number' && data.defer > 0 ? data.defer : 0,
     server: typeof data.server === 'string' ? data.server : null,
     sessionId: typeof data.sessionId === 'string' ? data.sessionId : null,
+    cancelled: data.cancelled === true,
     followupText,
   };
 }
@@ -189,18 +195,51 @@ function formatTicket(ticket, elapsed, compact) {
   if (ticket.sessionId) fields.sessionId = ticket.sessionId;
   if (elapsed !== undefined) fields.elapsed = elapsed;
   if (ticket.defer > 0) fields.defer = ticket.defer;
+  // Always present so it can be flipped to true and piped back to cancel.
+  fields.cancelled = ticket.cancelled === true;
   return 'agentp_ticket ' + (compact ? JSON.stringify(fields) : JSON.stringify(fields, null, 2));
 }
 
-async function resolveTargetSession(serverBase, sessionName, newSession) {
+// Cancel a deferred ticket: interrupt the session (ESC-equivalent) and discard
+// the ticket. Prints a message and exits 0.
+async function cancelTicket(ticket) {
+  let interrupted = false;
+  if (ticket.server && ticket.sessionId) {
+    interrupted = await interruptSession(ticket.server, ticket.sessionId);
+  }
+  try { fs.unlinkSync(ticket.path); } catch {}
+  try { fs.unlinkSync(ticket.path + '.lock'); } catch {}
+  removeQueuedFollowups(ticket.path);
+  process.stdout.write(`\n🚫 Prompt cancelled${interrupted ? '' : ' (or already finished)'}.\n`);
+  process.exit(0);
+}
+
+// Print a deferred ticket (with elapsed) and exit — used for the interrupt path.
+function printTicketAndExit(ticket, onlineTicket) {
+  const elapsed = ticket && ticket.ctime
+    ? Math.max(0, Math.floor((Date.now() - Date.parse(ticket.ctime)) / 1000))
+    : 0;
+  process.stdout.write(formatTicket(ticket, elapsed, onlineTicket) + '\n');
+  process.exit(0);
+}
+
+async function resolveTargetSession(serverBase, sessionName, newSession, opts = {}) {
+  // opts: { directory, preferredSession } — v2 project/session resolution from
+  // the nearest .ocmux.json. `directory` scopes the listing to the project;
+  // `preferredSession` is a stored session ID validated against that listing.
+  const directory = opts.directory || undefined;
+  const preferredSession = opts.preferredSession || null;
+
   let sessions;
   try {
-    sessions = await listSessions(serverBase);
+    sessions = await listSessions(serverBase, directory);
   } catch (err) {
     throw new Error(`Error connecting to server: ${err.message}`);
   }
 
   if (sessionName) {
+    const byId = sessions.find(s => String(s.id) === sessionName);
+    if (byId) return byId.id;
     const matches = sessions.filter(s => {
       const title = s.title || s.slug || s.id;
       return title.toLowerCase() === sessionName.toLowerCase();
@@ -214,7 +253,7 @@ async function resolveTargetSession(serverBase, sessionName, newSession) {
       if (partial.length > 1) throw new Error(`Error: multiple sessions match "${sessionName}"`);
       if (!newSession) throw new Error(`Error: no session found matching "${sessionName}"`);
       try {
-        const session = await createSession(serverBase, sessionName);
+        const session = await createSessionWithModel(serverBase, sessionName, directory, sessions);
         await selectSession(serverBase, session.id);
         return session.id;
       } catch (err) {
@@ -224,19 +263,18 @@ async function resolveTargetSession(serverBase, sessionName, newSession) {
     return matches[0].id;
   }
 
+  // Prefer the session recorded in .ocmux.json when it still exists.
+  if (preferredSession && sessions.some(s => String(s.id) === String(preferredSession))) {
+    return preferredSession;
+  }
+
   if (sessions && sessions.length > 0) {
-    const sorted = sessions
-      .filter(s => s.time && (s.time.updated || s.time.created))
-      .sort((a, b) => {
-        const aTime = (a.time && a.time.updated) || (a.time && a.time.created) || 0;
-        const bTime = (b.time && b.time.updated) || (b.time && b.time.created) || 0;
-        return bTime - aTime;
-      });
+    const sorted = sortSessionsByRecency(sessions).filter(s => s.id);
     if (sorted.length > 0) return sorted[0].id;
   }
 
   try {
-    const session = await createSession(serverBase, 'agentp');
+    const session = await createSessionWithModel(serverBase, 'agentp', directory, sessions);
     return session.id;
   } catch (err) {
     throw new Error(`Error creating session: ${err.message}`);
@@ -273,6 +311,41 @@ function sleepMs(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+// Wait indefinitely for a deferred result. Resolves with `{ result }` once the
+// answer is ready, or `{ interrupted: true }` if SIGINT is received while
+// waiting (any detached child keeps running). The caller decides how to react
+// to the interrupt (normally print a ticket and exit).
+function waitForDeferredResultForever(filePath) {
+  return new Promise((resolve) => {
+    let timer = null;
+    let done = false;
+
+    const finish = (value) => {
+      if (done) return;
+      done = true;
+      if (timer) clearTimeout(timer);
+      process.removeListener('SIGINT', onSigint);
+      resolve(value);
+    };
+
+    function onSigint() {
+      finish({ interrupted: true });
+    }
+
+    const poll = () => {
+      const result = readDeferredResult(filePath);
+      if (result !== null) {
+        finish({ result });
+        return;
+      }
+      timer = setTimeout(poll, DEFER_POLL_MS);
+    };
+
+    process.on('SIGINT', onSigint);
+    poll();
+  });
+}
+
 function appendUnusedFollowup(result, followupText) {
   if (!followupText) return result;
   return result + (result.endsWith('\n') ? '' : '\n') + followupText;
@@ -313,10 +386,58 @@ function injectQueuedFollowups(result, followups) {
   return before + (before.endsWith('\n') ? '' : '\n') + addition + after;
 }
 
-function formatDeferredResult(filePath, result, qaMode, unusedFollowupText) {
+function formatDeferredResult(filePath, result, qaMode, unusedFollowupText, header) {
   const followups = qaMode ? readQueuedFollowups(filePath) : [];
   const output = qaMode ? injectQueuedFollowups(result, followups) : result;
-  return appendUnusedFollowup(output, unusedFollowupText);
+  // The stored answer (produced by the detached child) may already carry the
+  // project/session header — don't prepend it a second time on retrieval.
+  const withHeader = qaMode && header && !carriesHeader(output) ? header + output : output;
+  return appendUnusedFollowup(withHeader, unusedFollowupText);
+}
+
+// Does the text already begin with the 📂 / 💬 header lines?
+function carriesHeader(text) {
+  return /^(?:\u{1F4C2}|\u{1F4AC})/u.test(String(text || '').trimStart());
+}
+
+// Output a ready deferred result, clean up its temp files, and exit 0.
+function outputReadyResult(filePath, result, qaMode, unusedFollowupText, header) {
+  try {
+    fs.unlinkSync(filePath);
+  } catch (err) {
+    process.stdout.write(`Error reading deferred file: ${err.message}\n`);
+    process.exit(1);
+  }
+  try { fs.unlinkSync(filePath + '.lock'); } catch {}
+  process.stdout.write(formatDeferredResult(filePath, result, qaMode, unusedFollowupText, header));
+  removeQueuedFollowups(filePath);
+  process.exit(0);
+}
+
+// Structured header (project path + session id/title) prepended to --qa output,
+// so a piped answer is self-describing about where it came from.
+async function buildSessionHeader(server, sessionId) {
+  let title = sessionId;
+  let dir = '';
+  try {
+    const s = await getSession(server, sessionId);
+    if (s && (s.title || s.id)) title = s.title || s.id;
+    if (s && s.location && s.location.directory) dir = s.location.directory;
+  } catch {
+    // keep the plain id form
+  }
+  let out = '';
+  if (dir) out += `📂 ${dir}\n`;
+  out += `💬 ${title} [${sessionId}]\n`;
+  return out;
+}
+
+// Header for deferred-ticket retrieval (ticket carries server + sessionId).
+async function ticketHeader(ticket, qaMode) {
+  if (qaMode && ticket && ticket.server && ticket.sessionId) {
+    try { return await buildSessionHeader(ticket.server, ticket.sessionId); } catch {}
+  }
+  return '';
 }
 
 async function readAllStdin() {
@@ -333,12 +454,68 @@ const HUMAN_ROW = '👤: —————————————————\n'
 const AGENT_ROW = '🤖: —————————————————\n'
 const FINAL_ROW = '    —————————————————\n';
 
+// Write the prompt to a temp file, lock the output file, and spawn a detached
+// `--defer-child` process that runs the prompt and writes the answer. Returns
+// the ticket describing this deferred run.
+function spawnDeferredChild({ promptText, serverBase, sessionName, newSession, qaMode, tgMode, flushMode, targetSessionId, deferSeconds }) {
+  const tempPath = generateTempFilename();
+  const promptTempPath = tempPath + '.prompt';
+
+  fs.writeFileSync(promptTempPath, promptText);
+  fs.writeFileSync(tempPath, '');
+  lockFile(tempPath);
+
+  const ticket = {
+    ctime: new Date().toISOString(),
+    path: tempPath,
+    defer: deferSeconds || 0,
+    server: serverBase,
+    sessionId: targetSessionId,
+    cancelled: false,
+  };
+
+  const childArgs = [
+    __filename,
+    '--defer-child',
+    '--prompt-file', promptTempPath,
+    '--output-file', tempPath,
+  ];
+  if (qaMode) childArgs.push('--qa');
+  if (tgMode === true) childArgs.push('--tg');
+  if (tgMode === false) childArgs.push('--no-tg');
+  if (flushMode) childArgs.push('--flush');
+  if (sessionName) {
+    childArgs.push('--session', sessionName);
+    if (newSession) childArgs.push('--new');
+  }
+  childArgs.push('--resolved-session-id', targetSessionId);
+  childArgs.push(serverBase);
+
+  const child = child_process.spawn(process.execPath, childArgs, {
+    detached: true,
+    stdio: 'ignore',
+  });
+  child.unref();
+
+  return ticket;
+}
+
 async function main() {
   let serverBase = 'http://localhost:4096';
   let qaMode = false;
   let flushMode = false;
   let deferMode = false;
   let deferSeconds = 0;
+  // Project context from the nearest .ocmux.json (v2 model): project directory,
+  // stored session ID, and cached server URL. All null when no state file
+  // applies, in which case agentp keeps its legacy (unscoped) behavior.
+  const ctx = projectState.resolveContext();
+  const projectDir = ctx.directory;
+  const stateSession = ctx.session;
+  // Adopt the project's cached server (from .ocmux.json) unless an explicit
+  // server/port is given later in the argument loop (--getLast runs mid-loop,
+  // so adoption must happen before it).
+  if (ctx.server) serverBase = ctx.server;
   let deferChildMode = false;
   let onlineTicket = false;
   let promptFile = null;
@@ -373,6 +550,7 @@ async function main() {
       console.error('  --getLast   Retrieve last N assistant answers (or QA pairs with --qa) from session history');
       console.error('  --session   Target a specific session by name (creates it if not found with --new)');
       console.error('  --new       Create a new session with the given title (requires --session)');
+      console.error('  --server    OpenCode server URL (overrides .ocmux.json); e.g. http://host:4096');
       console.error('  --help      Show this help message');
       console.error('');
       console.error('By default, --qa auto-detects tgagentp; standalone mode implies --no-tg.');
@@ -391,8 +569,9 @@ async function main() {
       console.error('');
       console.error('Arguments:');
       console.error('  url        OpenCode server URL or port number (default: 4096)');
-      console.error('             Examples: 4096, http://localhost:4096, http://192.168.1.50:4096');
-      console.error('             Tip: $(ocmux) expands to the URL of the current project\'s server.');
+      console.error('             Example: 4096, http://localhost:4096, http://192.168.1.50:4096');
+      console.error('             Omit it to resolve from the nearest .ocmux.json');
+      console.error('             (its directory selects the project, its session id the target).');
       console.error('');
       console.error('See also: tgagentp -- Telegram bridge (tgagentp --help), ocmux -- manage OpenCode tmux sessions (ocmux --help)');
       console.error('');
@@ -456,18 +635,12 @@ async function main() {
       }
       const n = parseInt(nStr, 10);
       try {
-        const sessions = await listSessions(serverBase);
+        const sessions = await listSessions(serverBase, projectDir || undefined);
         if (!sessions || sessions.length === 0) {
           console.error('No sessions found.');
           process.exit(1);
         }
-        const sorted = sessions
-          .filter(s => s.time && (s.time.updated || s.time.created))
-          .sort((a, b) => {
-            const aTime = (a.time && a.time.updated) || (a.time && a.time.created) || 0;
-            const bTime = (b.time && b.time.updated) || (b.time && b.time.created) || 0;
-            return bTime - aTime;
-          });
+        const sorted = sortSessionsByRecency(sessions);
         const sessionId = sorted[0].id;
 
         function buildPairsFromMessages(messages) {
@@ -548,6 +721,13 @@ async function main() {
       tgMode = true;
     } else if (args[i] === '--no-tg') {
       tgMode = false;
+    } else if (args[i] === '--server') {
+      i++;
+      if (!args[i]) {
+        console.error("Error: '--server' requires a URL (e.g. http://host:4096)");
+        process.exit(1);
+      }
+      serverBase = args[i].replace(/\/+$/, '');
     } else if (args[i].includes('://')) {
       serverBase = args[i].replace(/\/+$/, '');
     } else if (/^\d+$/.test(args[i])) {
@@ -563,6 +743,8 @@ async function main() {
     }
   }
 
+  const preferredSession = (sessionName || newSession || resolvedSessionId) ? null : stateSession;
+
   // Resolve default: --qa → auto-detect, standalone → disabled
   if (tgMode === null) {
     tgMode = qaMode ? 'auto' : false;
@@ -596,6 +778,10 @@ async function main() {
       // ignored; the ticket's own "defer" timeout is used instead (default 0).
       const deferredPath = ticket.path;
 
+      if (ticket.cancelled) {
+        await cancelTicket(ticket);
+      }
+
       if (!fs.existsSync(deferredPath)) {
         process.stdout.write(`Error: deferred file not found: ${deferredPath}\n`);
         process.exit(1);
@@ -614,7 +800,7 @@ async function main() {
           process.exit(1);
         }
         try { fs.unlinkSync(deferredPath + '.lock'); } catch {}
-        process.stdout.write(formatDeferredResult(deferredPath, result, qaMode, ticket.followupText));
+        process.stdout.write(formatDeferredResult(deferredPath, result, qaMode, ticket.followupText, await ticketHeader(ticket, qaMode)));
         removeQueuedFollowups(deferredPath);
         process.exit(0);
       }
@@ -643,7 +829,7 @@ async function main() {
             process.exit(1);
           }
           try { fs.unlinkSync(deferredPath + '.lock'); } catch {}
-          process.stdout.write(formatDeferredResult(deferredPath, result, qaMode, ''));
+          process.stdout.write(formatDeferredResult(deferredPath, result, qaMode, '', await ticketHeader(ticket, qaMode)));
           removeQueuedFollowups(deferredPath);
           process.exit(0);
         }
@@ -658,70 +844,41 @@ async function main() {
     }
 
     // This is a regular prompt — create deferred execution
-    const tempPath = generateTempFilename();
-    const promptTempPath = tempPath + '.prompt';
-
     let targetSessionId;
     try {
-      targetSessionId = await resolveTargetSession(serverBase, sessionName, newSession);
+      targetSessionId = await resolveTargetSession(serverBase, sessionName, newSession, {
+        directory: projectDir,
+        preferredSession,
+      });
     } catch (err) {
       console.error(err.message);
       process.exit(1);
     }
 
-    // Write prompt to temp file for child process
-    fs.writeFileSync(promptTempPath, promptText);
-
-    // Create and lock the output file
-    fs.writeFileSync(tempPath, '');
-    lockFile(tempPath);
-
-    const newTicket = {
-      ctime: new Date().toISOString(),
-      path: tempPath,
-      defer: deferSeconds,
-      server: serverBase,
-      sessionId: targetSessionId,
-    };
-
-    // Spawn detached child process
-    const childArgs = [
-      __filename,
-      '--defer-child',
-      '--prompt-file', promptTempPath,
-      '--output-file', tempPath,
-    ];
-
-    // Pass through other flags
-    if (qaMode) childArgs.push('--qa');
-    if (tgMode === true) childArgs.push('--tg');
-    if (tgMode === false) childArgs.push('--no-tg');
-    if (flushMode) childArgs.push('--flush');
-    if (sessionName) {
-      childArgs.push('--session', sessionName);
-      if (newSession) childArgs.push('--new');
-    }
-    childArgs.push('--resolved-session-id', targetSessionId);
-    childArgs.push(serverBase);
-
-    const child = child_process.spawn(process.execPath, childArgs, {
-      detached: true,
-      stdio: 'ignore',
+    const newTicket = spawnDeferredChild({
+      promptText,
+      serverBase,
+      sessionName,
+      newSession,
+      qaMode,
+      tgMode,
+      flushMode,
+      targetSessionId,
+      deferSeconds,
     });
-    child.unref();
 
     // If a timeout was given, block until the answer arrives or the timeout
     // expires. Return the response when it arrives; otherwise print a ticket.
     if (deferSeconds > 0) {
-      const result = await waitForDeferredResult(tempPath, deferSeconds * 1000);
+      const result = await waitForDeferredResult(newTicket.path, deferSeconds * 1000);
       if (result !== null) {
         try {
-          fs.unlinkSync(tempPath);
+          fs.unlinkSync(newTicket.path);
         } catch (err) {
           process.stdout.write(`Error reading deferred file: ${err.message}\n`);
           process.exit(1);
         }
-        try { fs.unlinkSync(tempPath + '.lock'); } catch {}
+        try { fs.unlinkSync(newTicket.path + '.lock'); } catch {}
         process.stdout.write(result);
         process.exit(0);
       }
@@ -732,6 +889,93 @@ async function main() {
     process.exit(0);
   }
 
+  // Normal (non-deferred, non-child) mode: wait for the answer, but run it in a
+  // detached child so a Ctrl+C can hand the in-flight response off as a ticket.
+  if (!deferChildMode) {
+    const ticket = parseDeferredTicketInput(promptText);
+
+    if (ticket) {
+      // Recognize a deferred ticket: wait indefinitely for the answer, and
+      // re-print the ticket only if the user interrupts with Ctrl+C.
+      const deferredPath = ticket.path;
+
+      if (ticket.cancelled) {
+        await cancelTicket(ticket);
+      }
+
+      if (!fs.existsSync(deferredPath)) {
+        process.stdout.write(`Error: deferred file not found: ${deferredPath}\n`);
+        process.exit(1);
+      }
+
+      let unusedFollowup = ticket.followupText || '';
+
+      // If the answer is already ready, return it immediately.
+      let result = ticket.followupText ? readDeferredResult(deferredPath) : null;
+      if (result !== null) {
+        outputReadyResult(deferredPath, result, qaMode, unusedFollowup, await ticketHeader(ticket, qaMode));
+      }
+
+      // Queue any follow-up text to the original session (same as --defer).
+      if (ticket.followupText) {
+        if (!ticket.server || !ticket.sessionId) {
+          process.stdout.write('Error: deferred ticket does not include server/sessionId; cannot queue follow-up text. Re-submit only the ticket to check the result.\n');
+          process.exit(1);
+        }
+        try {
+          await sendToSessionAsync(ticket.server, ticket.sessionId, ticket.followupText);
+          appendQueuedFollowup(deferredPath, ticket.followupText);
+          unusedFollowup = '';  // follow-up already queued; don't echo it again
+        } catch (err) {
+          process.stdout.write(`Error queueing follow-up prompt: ${err.message}\n`);
+          process.exit(1);
+        }
+      }
+
+      const wait = await waitForDeferredResultForever(deferredPath);
+      if (wait.interrupted) printTicketAndExit(ticket, onlineTicket);
+      outputReadyResult(deferredPath, wait.result, qaMode, unusedFollowup, await ticketHeader(ticket, qaMode));
+    }
+
+    // Regular prompt: submit via a detached child and wait for the answer.
+    let targetSessionId;
+    try {
+      targetSessionId = await resolveTargetSession(serverBase, sessionName, newSession, {
+        directory: projectDir,
+        preferredSession,
+      });
+    } catch (err) {
+      console.error(err.message);
+      process.exit(1);
+    }
+
+    const newTicket = spawnDeferredChild({
+      promptText,
+      serverBase,
+      sessionName,
+      newSession,
+      qaMode,
+      tgMode,
+      flushMode,
+      targetSessionId,
+      deferSeconds: 0,
+    });
+
+    const wait = await waitForDeferredResultForever(newTicket.path);
+    if (wait.interrupted) printTicketAndExit(newTicket, onlineTicket);
+
+    // Answer ready — output it and clean up.
+    try {
+      fs.unlinkSync(newTicket.path);
+    } catch (err) {
+      process.stdout.write(`Error reading deferred file: ${err.message}\n`);
+      process.exit(1);
+    }
+    try { fs.unlinkSync(newTicket.path + '.lock'); } catch {}
+    process.stdout.write(wait.result);
+    process.exit(0);
+  }
+
   // Handle --defer-child mode (child process)
   let actualPromptText = promptText;
   if (deferChildMode && promptFile) {
@@ -749,11 +993,27 @@ async function main() {
   // Wrap main processing in try-catch for deferChildMode to write errors to output file
   let tgError = null;
   async function runMain() {
-    const sessionId = resolvedSessionId || await resolveTargetSession(serverBase, sessionName, newSession);
+    const sessionId = resolvedSessionId || await resolveTargetSession(serverBase, sessionName, newSession, {
+      directory: projectDir,
+      preferredSession,
+    });
+
+    // v2: focus the target project's TUI window so the user sees the prompt
+    // stream, and prepend the session's annotation (if any) to the prompt.
+    let prompt = actualPromptText;
+    try {
+      if (ctx && ctx.statefile) {
+        const ann = projectState.readAnnotations(ctx.statefile)[sessionId];
+        if (ann) prompt = ann + '\n\n' + actualPromptText;
+      }
+      if (projectDir) ocmuxLib.focusWindowByDir(projectDir);
+    } catch {
+      // tmux focus is best-effort; never fail the prompt because of it
+    }
 
     let answer;
     try {
-      answer = await sendToSession(serverBase, sessionId, actualPromptText);
+      answer = await sendToSession(serverBase, sessionId, prompt);
     } catch (err) {
       throw new Error(`Error sending prompt: ${err.message}`);
     }
@@ -761,7 +1021,9 @@ async function main() {
     // Build the message to send to Telegram (QA pair with rulers)
     let tgMessage = answer;
     if (qaMode) {
-      tgMessage = HUMAN_ROW + actualPromptText + AGENT_ROW + answer;
+      let header = '';
+      try { header = await buildSessionHeader(serverBase, sessionId); } catch {}
+      tgMessage = header + HUMAN_ROW + actualPromptText + AGENT_ROW + answer;
       if (!answer.endsWith('\n')) tgMessage += '\n';
       tgMessage += FINAL_ROW;
     }
@@ -843,4 +1105,4 @@ if (require.main === module) {
   });
 }
 
-module.exports = { main, notifyAgentpGateway, readAllStdin, parseDeferredTicket, parseDeferredTicketInput, formatTicket, waitForDeferredResult };
+module.exports = { main, notifyAgentpGateway, readAllStdin, parseDeferredTicket, parseDeferredTicketInput, formatTicket, waitForDeferredResult, waitForDeferredResultForever };