@aragon-agent/cli 0.6.3 → 0.6.7

package/dist/ui/transcript-text.js

@@ -6,7 +6,7 @@
  * transcript in the terminal's native scrollback, and replaying there would
  * simply print everything twice.
  */
-import { formatCost, formatDuration, formatTokens } from '../agent/usage.js';
+import { formatCost, formatDuration, formatTokens, promptTokensOf } from '../agent/usage.js';
 import { formatRetryLine } from '../agent/retry-view.js';
 const DEFAULT_MAX_ENTRIES = 200;
 const CONTINUATION_INDENT = '  ';
@@ -51,6 +51,34 @@ function safeParse(raw) {
         return null;
     }
 }
+/**
+ * The replay's glyph for a service, MIRRORING `ServiceCard::serviceGlyph`.
+ *
+ * The two ladders have to agree, and the cheap-looking shortcut here — "ready or
+ * running is a tick, everything else is an error" — disagrees on the two states
+ * a user reaches ON PURPOSE: a service they stopped with `Ctrl+C`, and one that
+ * exited cleanly. Marking either as a failure in the record the user is left
+ * with after the alternate screen is torn down is a lie about their own action.
+ *
+ * Duplicated rather than imported, as every other case in this file duplicates
+ * its card's ladder: this module is deliberately free of React and ink, and
+ * `serviceGlyph` lives in a `.tsx`.
+ */
+function serviceTextGlyph(status, exitCode, glyphs) {
+    switch (status) {
+        case 'ready':
+            return glyphs.toolDone;
+        case 'running':
+            return glyphs.toolRunning;
+        case 'starting':
+        case 'stopped':
+            return glyphs.toolPending;
+        case 'exited':
+            return exitCode === 0 ? glyphs.toolDone : glyphs.toolError;
+        default:
+            return glyphs.toolError;
+    }
+}
 function renderEntry(entry, glyphs) {
     switch (entry.kind) {
         case 'user':
@@ -134,6 +162,27 @@ function renderEntry(entry, glyphs) {
                 ...entry.summary.split('\n').map((l) => `${TOOL_INDENT}${CONTINUATION_INDENT}${l}`),
             ];
         }
+        case 'service': {
+            // A service the agent started is real work with a real outcome, and an
+            // exported transcript that omitted it would be unaccountable for both —
+            // the argument the `team`, `retry`, `fast` and `compaction` cases above
+            // each make in their own words. It matters more here than for any of them:
+            // this replay is the user's ONLY record once the alternate screen is torn
+            // down (`cli.tsx`'s exit snapshot), and a service card dropped from it
+            // takes the URL the agent reported with it. This file's
+            // `default: return []` means the addition is a CHOICE rather than a
+            // compile requirement, which is exactly why it is easy to leave out
+            // (P0-3).
+            const glyph = serviceTextGlyph(entry.status, entry.exitCode, glyphs);
+            const where = entry.url ? ` ${entry.url}` : '';
+            const code = entry.exitCode === null || entry.exitCode === undefined
+                ? ''
+                : ` (exit code ${entry.exitCode})`;
+            return [
+                `${TOOL_INDENT}${glyph} service ${entry.serviceId} ${entry.command} ` +
+                    `${entry.status}${where}${code}`.trimEnd(),
+            ];
+        }
         case 'notice': {
             const glyph = entry.level === 'error'
                 ? glyphs.error
@@ -150,7 +199,11 @@ function renderEntry(entry, glyphs) {
 export function renderTranscriptText(entries, opts) {
     const turns = entries.filter((e) => e.kind === 'user').length;
     const g = opts.glyphs;
-    const tokens = `${formatTokens(opts.usageTotal.inputTokens)}${g.arrowUp} ${formatTokens(opts.usageTotal.outputTokens)}${g.arrowDown}`;
+    // THE SAME PROMPT-SIDE TOTAL THE STATUS BAR SHOWS (context-usage-gauge-accuracy
+    // §3.6). This line is what a user compares against the bar they were watching a
+    // second earlier, so a different unit here would look like the exit summary
+    // losing tokens.
+    const tokens = `${formatTokens(promptTokensOf(opts.usageTotal))}${g.arrowUp} ${formatTokens(opts.usageTotal.outputTokens)}${g.arrowDown}`;
     const summary = [
         'aragon',
         `${opts.provider}:${opts.model}`,

package/dist/ui/use-wheel-routing.d.ts

@@ -20,7 +20,7 @@
  * the wheel spins: one gesture, one `setState`, one render.
  */
 import type { Overlay } from '../agent/reducer.js';
-import type { MouseSource } from '../input/stdin-mouse-filter.js';
+import type { MouseSource } from '../input/stdin-filter.js';
 import type { ScrollIntent } from './layout/scroll.js';
 /**
  * Rows a PgUp/PgDn — and a Shift+wheel notch — moves inside a controlled

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aragon-agent/cli",
-  "version": "0.6.3",
+  "version": "0.6.7",
   "description": "AragonAgent CLI — a Claude-Code / Codex-style interactive terminal UI (TUI) on top of the @aragon-agent/core engine. Installable and runnable via npm / npx.",
   "license": "MIT",
   "author": "AragonAgent contributors",
@@ -56,7 +56,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@aragon-agent/core": "^0.2.15",
+    "@aragon-agent/core": "^0.2.19",
     "chalk": "^5.6.2",
     "cli-highlight": "^2.0.0",
     "commander": "^12.1.0",

package/dist/input/stdin-mouse-filter.d.ts

@@ -1,47 +0,0 @@
-/**
- * Stdin mouse filter (mouse-wheel-region-routing §4.2 / §5.2).
- *
- * WHY A WRAPPER AND NOT A SECOND LISTENER. Ink 5.2.1 owns stdin in a way that
- * forbids a second reader: `components/App.js` calls `setEncoding('utf8')`,
- * `ref()`, `setRawMode(true)`, subscribes to `'readable'` and drains with
- * `read()`. Attaching our own `'data'` listener to the same `process.stdin`
- * would switch the stream into flowing mode and RACE Ink's `read()` for chunks
- * — some keystrokes would reach Ink, some would not, non-deterministically
- * (D-3). So the filter REPLACES the stream Ink is given: it reads the real
- * stdin, strips every mouse report, and writes the remainder into a
- * `PassThrough` that carries the surface Ink requires.
- *
- * ORDERING IS AN INVARIANT, NOT A CONVENTION (I-8). The caller must build this
- * filter BEFORE anything writes `\x1b[?1000h`. Reporting enabled while Ink
- * still holds the raw stream does not degrade the feature — it types
- * `[<0;12;5M` into the user's message on every click, which is strictly worse
- * than the bug this feature fixes. `cli.tsx::runInteractive` is the only caller
- * and passes `filter !== null` to `enterAltScreen`.
- */
-import { type MouseEvent } from './mouse-events.js';
-export interface MouseSource {
-    /**
-     * Returns an unsubscribe function. Multiple subscribers are allowed — the
-     * wheel router and (since tui-selection-and-scroll-follow) the selection
-     * controller both take this one channel, and each ignores the kinds it does
-     * not own.
-     */
-    subscribe(listener: (event: MouseEvent) => void): () => void;
-}
-export interface MouseFilter {
-    /** Hand this to Ink: `render(<App/>, { stdin: filter.stdin })`. */
-    readonly stdin: NodeJS.ReadStream;
-    readonly source: MouseSource;
-    /** Idempotent. Detaches from the real stdin and clears the flush timer (I-7). */
-    dispose(): void;
-}
-export declare function createMouseFilter(real: NodeJS.ReadStream): MouseFilter;
-/**
- * Build a filter, or `null` if construction throws.
- *
- * The `null` return is the whole point (P0-1): `enterAltScreen` derives whether
- * to enable mouse reporting from `filter !== null`, so a construction failure
- * degrades to "the wheel is inert" — a supported, tested rung of the fail-safe
- * ladder — rather than leaving reporting on with no filter in front of Ink.
- */
-export declare function tryCreateMouseFilter(real: NodeJS.ReadStream, onError?: (reason: string) => void): MouseFilter | null;

package/dist/input/stdin-mouse-filter.js

@@ -1,153 +0,0 @@
-/**
- * Stdin mouse filter (mouse-wheel-region-routing §4.2 / §5.2).
- *
- * WHY A WRAPPER AND NOT A SECOND LISTENER. Ink 5.2.1 owns stdin in a way that
- * forbids a second reader: `components/App.js` calls `setEncoding('utf8')`,
- * `ref()`, `setRawMode(true)`, subscribes to `'readable'` and drains with
- * `read()`. Attaching our own `'data'` listener to the same `process.stdin`
- * would switch the stream into flowing mode and RACE Ink's `read()` for chunks
- * — some keystrokes would reach Ink, some would not, non-deterministically
- * (D-3). So the filter REPLACES the stream Ink is given: it reads the real
- * stdin, strips every mouse report, and writes the remainder into a
- * `PassThrough` that carries the surface Ink requires.
- *
- * ORDERING IS AN INVARIANT, NOT A CONVENTION (I-8). The caller must build this
- * filter BEFORE anything writes `\x1b[?1000h`. Reporting enabled while Ink
- * still holds the raw stream does not degrade the feature — it types
- * `[<0;12;5M` into the user's message on every click, which is strictly worse
- * than the bug this feature fixes. `cli.tsx::runInteractive` is the only caller
- * and passes `filter !== null` to `enterAltScreen`.
- */
-import { PassThrough } from 'node:stream';
-import { splitMouseEvents } from './mouse-events.js';
-/**
- * How long a possible-prefix tail is held before being flushed as text.
- *
- * This is what stops a lone `\x1b` — the Esc key, which aborts a run — from
- * being held hostage waiting for a `[` that will never arrive. Worst-case Esc
- * latency becomes 12 ms, and only for the keystroke that is literally a bare
- * ESC; every other key resolves `isMousePrefix` to false immediately.
- */
-const PENDING_FLUSH_MS = 12;
-/** Assign a method onto the PassThrough without widening its public type. */
-function define(target, name, value) {
-    Object.defineProperty(target, name, { value, writable: true, configurable: true });
-}
-export function createMouseFilter(real) {
-    const wrapper = new PassThrough();
-    const listeners = new Set();
-    let pending = '';
-    let flushTimer = null;
-    let disposed = false;
-    // --- The surface Ink reads off the stream it is handed. ------------------
-    // `isRawModeSupported()` reads `props.stdin.isTTY` (App.js:34), so this has
-    // to be a DELEGATING GETTER rather than a snapshot: a stdin that is not a TTY
-    // must still report so through the wrapper, or Ink throws instead of falling
-    // back.
-    Object.defineProperty(wrapper, 'isTTY', {
-        get: () => real.isTTY,
-        configurable: true,
-    });
-    define(wrapper, 'setRawMode', (mode) => {
-        real.setRawMode?.(mode);
-        return wrapper;
-    });
-    define(wrapper, 'ref', () => {
-        real.ref?.();
-        return wrapper;
-    });
-    define(wrapper, 'unref', () => {
-        real.unref?.();
-        return wrapper;
-    });
-    const emit = (event) => {
-        for (const listener of [...listeners])
-            listener(event);
-    };
-    const clearFlushTimer = () => {
-        if (!flushTimer)
-            return;
-        clearTimeout(flushTimer);
-        flushTimer = null;
-    };
-    const flushPending = () => {
-        clearFlushTimer();
-        if (pending.length === 0 || disposed)
-            return;
-        const text = pending;
-        pending = '';
-        wrapper.write(text);
-    };
-    const onData = (chunk) => {
-        if (disposed)
-            return;
-        clearFlushTimer();
-        const decoded = typeof chunk === 'string' ? chunk : chunk.toString('utf8');
-        const split = splitMouseEvents(pending + decoded);
-        pending = split.pending;
-        if (split.text.length > 0)
-            wrapper.write(split.text);
-        for (const event of split.events)
-            emit(event);
-        if (pending.length > 0) {
-            // `.unref()` so a held tail can never keep the process alive on its own.
-            flushTimer = setTimeout(flushPending, PENDING_FLUSH_MS);
-            flushTimer.unref?.();
-        }
-    };
-    // P2-7: a closed stdin must still terminate Ink's reader, or it waits forever
-    // on a stream that will never produce another byte.
-    const onEnd = () => {
-        flushPending();
-        if (!wrapper.writableEnded)
-            wrapper.end();
-    };
-    // `setEncoding('utf8')` on the REAL stream so Node's StringDecoder handles
-    // multi-byte boundaries for us — the parser works on characters, and a UTF-8
-    // sequence split across two chunks would otherwise become two mojibake
-    // characters before it ever reached `splitMouseEvents`.
-    real.setEncoding?.('utf8');
-    real.on('data', onData);
-    real.once('end', onEnd);
-    real.once('close', onEnd);
-    return {
-        stdin: wrapper,
-        source: {
-            subscribe(listener) {
-                listeners.add(listener);
-                return () => listeners.delete(listener);
-            },
-        },
-        dispose() {
-            if (disposed)
-                return;
-            disposed = true;
-            clearFlushTimer();
-            real.removeListener('data', onData);
-            real.removeListener('end', onEnd);
-            real.removeListener('close', onEnd);
-            listeners.clear();
-            // I-7: a live `'data'` listener on stdin keeps the event loop alive, and
-            // `aragon` would hang on exit instead of returning to the shell.
-            real.pause?.();
-            real.unref?.();
-        },
-    };
-}
-/**
- * Build a filter, or `null` if construction throws.
- *
- * The `null` return is the whole point (P0-1): `enterAltScreen` derives whether
- * to enable mouse reporting from `filter !== null`, so a construction failure
- * degrades to "the wheel is inert" — a supported, tested rung of the fail-safe
- * ladder — rather than leaving reporting on with no filter in front of Ink.
- */
-export function tryCreateMouseFilter(real, onError) {
-    try {
-        return createMouseFilter(real);
-    }
-    catch (err) {
-        onError?.(err instanceof Error ? err.message : String(err));
-        return null;
-    }
-}