@tshu-w/pi-agents 0.1.0 → 0.2.0

package/src/workbench.mjs

@@ -6,8 +6,9 @@ import { readFile } from 'node:fs/promises';
 import { createRequire } from 'node:module';
 import { join } from 'node:path';
 import { pathToFileURL } from 'node:url';
+import { styleText } from 'node:util';
 import { setTimeout as delay } from 'node:timers/promises';
-import { attach, listHosts, startHost } from './host/client.mjs';
+import { alive, attach, listHosts, settledHosts, startHost } from './host/client.mjs';
 import { detachKey, detachMatcher } from './host/keys.mjs';
 import { piPackage } from './pi.mjs';
 import { ensureDaemon, sendViaDaemon } from './daemon/client.mjs';
@@ -66,6 +67,8 @@ function age(ms) {
 
 const time = session => Math.max(session.finishedAt ?? 0, Date.parse(session.updatedAt ?? '') || 0);
 const label = session => session.name || session.title || session.id.slice(0, 8);
+// Notices quote the label, since a title can read as part of the notice.
+const named = session => `"${label(session)}"`;
 const COMMANDS = [
   { value: '/resume', label: 'resume', description: 'Open a past Session' },
   { value: '/quit', label: 'quit', description: 'Exit the workbench' },
@@ -73,9 +76,9 @@ const COMMANDS = [
 // Pi's working spinner.
 const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 const GROUPS = [
-  ['attention', 'Needs input', 'Sessions waiting on you or with a finished turn you have not seen land here'],
-  ['working', 'Working', 'Sessions Pi is working on; they keep running after you leave'],
-  ['completed', 'Completed', 'Sessions you have seen wait here'],
+  ['attention', 'Needs attention', 'Sessions with a question for you or a reply you have not read'],
+  ['working', 'Working', 'Sessions still working; they keep running when you close the terminal'],
+  ['completed', 'Completed', 'Sessions with nothing new for you'],
 ];
 
 function stateOf(session) {
@@ -110,6 +113,8 @@ export async function workbench({ pi: executable, paths, sessionDir }) {
   let sessions = [], stream, connected = false, quitting = false;
   // `picked` is the Session last chosen with `@` and its mention; a message starting with the mention goes to it.
   let selectedKey, top = 0, notice, modal, pane, picked, lastCtrlC = 0, finish;
+  // Messages in flight by Session ID; each settles once the daemon has delivered it, waking the Session if needed.
+  const sending = new Map();
 
   /** How `@` refers to a Session: its name when that is one word, otherwise the shortest unique ID prefix. */
   function mention(session) {
@@ -199,8 +204,9 @@ export async function workbench({ pi: executable, paths, sessionDir }) {
     // While the preview is open, the keys are its own: Enter may send a message, so `app.tools.expand` attaches.
     const keys = pane ? [
       hints.keyHint('app.tools.expand', 'attach'),
-      hints.rawKeyHint(`${hints.keyText('tui.altScreen.pageUp')}/${hints.keyText('tui.altScreen.pageDown')}`, 'scroll'),
-      hints.rawKeyHint('esc', 'close'),
+      hints.rawKeyHint(['lineUp', 'halfPageUp', 'pageUp', 'lineDown', 'halfPageDown', 'pageDown']
+        .map(name => hints.keyText(`tui.altScreen.${name}`)).filter(Boolean).join('/'), 'scroll'),
+      hints.rawKeyHint(`${detach}/esc`, 'close'),
     ].join(theme.fg('muted', ' · ')) : [
       hints.rawKeyHint('enter', 'attach'),
       hints.rawKeyHint(detach, 'quit'),
@@ -273,8 +279,8 @@ export async function workbench({ pi: executable, paths, sessionDir }) {
     handleInput(data) {
       // Holding only the preview's mention, the input counts as empty.
       const empty = ['', pane?.mention].includes(editor.getText());
-      // As in a Session, the detach key leaves and everything keeps running.
-      if (isDetach(data)) return void quit();
+      // As in a Session, the detach key leaves and everything keeps running; in the preview, it returns to the list.
+      if (isDetach(data)) return void (pane ? pane.close() : quit());
       if (pane?.handleInput(data, empty)) return;
       if (T.matchesKey(data, 'ctrl+c')) {
         if (!empty) return editor.setText(pane?.mention ?? '');
@@ -283,7 +289,7 @@ export async function workbench({ pi: executable, paths, sessionDir }) {
         return say('Press Ctrl+C again to quit');
       }
       if (T.matchesKey(data, 'ctrl+x')) return interrupt();
-      if (empty && keybindings.matches(data, 'app.session.delete')) return remove(selected()?.session);
+      if (empty && keybindings.matches(data, 'app.session.delete')) return void remove(selected()?.session);
       // The preview's mention stays: an edit that would remove or change it is undone.
       if (pane) {
         const before = editor.getText();
@@ -363,12 +369,15 @@ export async function workbench({ pi: executable, paths, sessionDir }) {
   async function openSession(session) {
     stream?.send({ type: 'show', id: session.id });
     try {
-      const hosted = (await listHosts(paths)).find(host => host.session?.id === session.id);
+      // A message just sent may be waking the Session in a host.
+      await sending.get(session.id);
+      const running = host => host.session?.id === session.id;
+      const hosted = (await settledHosts(paths, running)).find(running);
       if (hosted) return await attachTo(hosted.socket);
       if (session.running || session.status === 'unknown') {
-        return say(`${label(session)} runs outside a host; attach it after it exits.`, 'warning');
+        return say(`${named(session)} runs outside a host; attach it after it exits.`, 'warning');
       }
-      say(`Starting ${label(session)}…`);
+      say(`Starting ${named(session)}…`);
       const socket = await startHost(paths, {
         pi: executable, args: ['--session', session.sessionFile], cwd: session.cwd,
         cols: process.stdout.columns, rows: process.stdout.rows, waitForTerminal: true,
@@ -385,20 +394,32 @@ export async function workbench({ pi: executable, paths, sessionDir }) {
     const session = selected()?.session;
     if (!['working', 'blocked'].includes(session?.status) || !stream) return say('The selected Session is not working.', 'warning');
     stream.send({ type: 'interrupt', id: session.id });
-    say(`Stopping ${label(session)}…`);
+    say(`Stopping ${named(session)}…`);
   }
 
-  /** Removes a Session from the list; `/resume` brings it back. A running Session always stays listed. */
-  function remove(session) {
+  /**
+   * Removes a Session from the list; `/resume` brings it back. An idle Session in a host no terminal
+   * is attached to quits first, as Pi does on SIGTERM; any other running Session always stays listed.
+   */
+  async function remove(session) {
     if (!session || !stream) return;
-    if (session.running || session.status !== 'idle') return say(`Quit ${label(session)} before removing it.`, 'warning');
+    if (session.running) {
+      const host = session.status === 'idle' && (await listHosts(paths)).find(host => host.session?.id === session.id);
+      if (!host || host.attached) return say(`Quit ${named(session)} before removing it.`, 'warning');
+      say(`Quitting ${named(session)}…`);
+      process.kill(host.pid, 'SIGTERM');
+      for (let wait = 0; alive(host.pid); wait += 100) {
+        if (wait >= 5000) return say(`${named(session)} did not quit; attach it to see why.`, 'warning');
+        await delay(100);
+      }
+    } else if (session.status !== 'idle') return say(`Quit ${named(session)} before removing it.`, 'warning');
     stream.send({ type: 'hide', id: session.id });
     if (pane?.session.id === session.id) pane.close();
     const choices = selectable();
     const index = choices.findIndex(row => row.key === session.id);
     selectedKey = (choices[index + 1] ?? choices[index - 1])?.key;
     sessions = sessions.filter(other => other.id !== session.id);
-    say(`Removed ${label(session)}; /resume brings it back.`);
+    say(`Removed ${named(session)}; /resume brings it back.`);
   }
 
   async function preview(session) {
@@ -408,19 +429,25 @@ export async function workbench({ pi: executable, paths, sessionDir }) {
     catch (error) { return say(error.message, 'error'); }
     let body = conversation(messages);
     const border = themes.getEditorTheme().borderColor;
-    let scroll = 0, page = 1, timer;
+    let scroll = 0, page = 1, timer, scrolled, hideBar;
+    // A turn the preview shows counts as seen.
+    const see = () => stream?.send({ type: 'see', id: session.id });
+    see();
     // Pi appends each finished message to the file, so the preview follows the Session as it works.
     const watcher = watch(session.sessionFile, () => {
       clearTimeout(timer);
       timer = setTimeout(async () => {
         try { body = conversation(await branchMessages(session.sessionFile)); }
         catch (error) { return say(error.message, 'error'); }
+        see();
         ui.requestRender();
       }, 100);
     });
     const close = () => {
       watcher.close();
+      see();
       clearTimeout(timer);
+      clearTimeout(hideBar);
       // A draft stays, still addressed to the Session.
       if (editor.getText() === pane?.mention) editor.setText('');
       pane = undefined;
@@ -435,14 +462,23 @@ export async function workbench({ pi: executable, paths, sessionDir }) {
       invalidate() { body.invalidate(); },
       /** A short conversation takes only its own height; a longer one takes `max` lines and scrolls. */
       render(width, max) {
-        const current = sessions.find(other => other.id === session.id) ?? session;
-        const live = ['working', 'blocked', 'unknown'].includes(current.status) ? `  ${icon(current)} ${activity(current)}` : '';
-        const head = truncate(` ${theme.bold(label(session))}  ${theme.fg('dim', session.cwd ?? '')}${live}`, width);
-        const lines = body.render(width);
+        // The selected row and the input's mention name the Session, so the preview needs no title. A blank line
+        // sets it apart from the list.
+        const top = ['', border('─'.repeat(width))];
+        const bar = width > 1 ? settings.getFullscreenScrollbar() : 'hidden';
+        // The conversation starts right below the border.
+        const lines = body.render(bar === 'always' ? width - 1 : width);
+        while (lines.length && !T.stripTerminalSequences(lines[0]).trim()) lines.shift();
         page = Math.max(1, max - 2);
         scroll = Math.min(scroll, Math.max(0, lines.length - page));
-        const end = lines.length - scroll;
-        return [border('─'.repeat(width)), head, ...lines.slice(Math.max(0, end - page), end)];
+        const end = lines.length - scroll, start = Math.max(0, end - page);
+        const shown = lines.slice(start, end);
+        if (bar !== 'always' && !(bar === 'auto' && scrolled && lines.length > page)) return [...top, ...shown];
+        // The scrollbar of Pi's fullscreen transcript, in the last column.
+        const track = shown.length, size = Math.max(Math.min(2, track), Math.min(track, Math.round(track * track / lines.length)));
+        const offset = lines.length === track ? 0 : Math.round(start / (lines.length - track) * (track - size));
+        const cell = row => row >= offset && row < offset + size ? theme.fg('scrollbarThumb', '┃') : theme.fg('scrollbarTrack', '│');
+        return [...top, ...shown.map((line, row) => `${T.truncateToWidth(line, width - 1, '', true)}${cell(row)}`)];
       },
       /** Enter, `↑`/`↓`, and Space act on the preview only while no message is typed. */
       handleInput(data, empty) {
@@ -459,10 +495,17 @@ export async function workbench({ pi: executable, paths, sessionDir }) {
           close();
           return true;
         }
-        const step = empty && T.matchesKey(data, 'up') ? 1 : empty && T.matchesKey(data, 'down') ? -1
-          : keybindings.matches(data, 'tui.altScreen.pageUp') ? page - 1 : keybindings.matches(data, 'tui.altScreen.pageDown') ? 1 - page : 0;
+        // The scroll keys of Pi's fullscreen mode; a step counts lines up from the end.
+        const half = Math.max(1, Math.floor(page / 2));
+        const steps = { lineUp: 1, lineDown: -1, halfPageUp: half, halfPageDown: -half, pageUp: page - 1, pageDown: 1 - page, top: Infinity, bottom: -Infinity };
+        const action = Object.keys(steps).find(name => keybindings.matches(data, `tui.altScreen.${name}`));
+        const step = empty && T.matchesKey(data, 'up') ? 1 : empty && T.matchesKey(data, 'down') ? -1 : action ? steps[action] : 0;
         if (!step) return false;
         scroll = Math.max(0, scroll + step);
+        // As in Pi's `auto` mode, the scrollbar shows while scrolling and for a second after.
+        scrolled = true;
+        clearTimeout(hideBar);
+        hideBar = setTimeout(() => { scrolled = false; ui.requestRender(); }, 1000);
         ui.requestRender();
         return true;
       },
@@ -507,12 +550,16 @@ export async function workbench({ pi: executable, paths, sessionDir }) {
   }
 
   async function send(session, body) {
-    say(`Sending to ${label(session)}…`);
+    say(`Sending to ${named(session)}…`);
     const message = { id: randomUUID(), user: true, recipient: session.id, body };
+    const pending = sendViaDaemon(paths, message, { sessionDir, launch: { command: executable, args: [], env } });
+    const settled = pending.then(() => {}, () => {});
+    sending.set(session.id, settled);
+    void settled.then(() => { if (sending.get(session.id) === settled) sending.delete(session.id); });
     try {
-      const receipt = await sendViaDaemon(paths, message, { sessionDir, launch: { command: executable, args: [], env } });
-      if (receipt?.accepted !== true || receipt.messageId !== message.id) throw new Error(`Invalid acknowledgement from ${label(session)}; it may have received the message.`);
-      say(`Sent to ${label(session)}.`);
+      const receipt = await pending;
+      if (receipt?.accepted !== true || receipt.messageId !== message.id) throw new Error(`Invalid acknowledgement from ${named(session)}; it may have received the message.`);
+      say(`Sent to ${named(session)}.`);
     } catch (error) { say(error.message, 'error'); }
   }
 
@@ -568,7 +615,7 @@ export async function workbench({ pi: executable, paths, sessionDir }) {
     themeSync.disableAutoSync();
     await terminal.drainInput(1000);
     ui.stop();
-    process.stdout.write(`${MAIN_SCREEN}Sessions keep running. To reopen, run pd agents\n`);
+    process.stdout.write(`${MAIN_SCREEN}${styleText('dim', 'Sessions keep running. To reopen:')} pd agents\n`);
     finish();
   }