@aragon-agent/cli 0.6.2 → 0.6.4

package/dist/tools/proc-tools.d.ts

@@ -0,0 +1,25 @@
+/**
+ * `bash_output` and `bash_kill` — the model's two handles on a supervised
+ * service (background-service-supervision §5.1).
+ *
+ * REGISTERED THROUGH A FACTORY OPTION, NEVER APPENDED AFTER THE FACT
+ * (`tools/index.ts::procTools`). `tools.test.ts::C7` asserts `HOST_TOOL_NAMES`
+ * equals what `createBuiltinTools` PRODUCES, so appending these in
+ * `AgentController` after the factory returned would turn that test red with a
+ * message about two lists of names that says nothing about background services —
+ * the trap `teamTools` and `todoTools` each record in capitals.
+ *
+ * NEITHER JOINS `MUTATING_TOOLS` (P2-5). `bash_output` is a read. `bash_kill`
+ * stops something THIS SESSION STARTED and is showing on screen, and the plan
+ * gate already refuses it in plan mode; putting a `--confirm` modal between the
+ * user and stopping their own runaway server is the wrong trade. `bash` itself
+ * stays in `MUTATING_TOOLS` unchanged, including when `background: true` — the
+ * command is still arbitrary.
+ */
+import { type AgentTool } from '@aragon-agent/core';
+import type { ProcSupervisorPort } from '../proc/types.js';
+export interface ProcToolDeps {
+    supervisor: ProcSupervisorPort;
+}
+export declare function makeBashOutput(deps: ProcToolDeps): AgentTool;
+export declare function makeBashKill(deps: ProcToolDeps): AgentTool;

package/dist/tools/proc-tools.js

@@ -0,0 +1,102 @@
+/**
+ * `bash_output` and `bash_kill` — the model's two handles on a supervised
+ * service (background-service-supervision §5.1).
+ *
+ * REGISTERED THROUGH A FACTORY OPTION, NEVER APPENDED AFTER THE FACT
+ * (`tools/index.ts::procTools`). `tools.test.ts::C7` asserts `HOST_TOOL_NAMES`
+ * equals what `createBuiltinTools` PRODUCES, so appending these in
+ * `AgentController` after the factory returned would turn that test red with a
+ * message about two lists of names that says nothing about background services —
+ * the trap `teamTools` and `todoTools` each record in capitals.
+ *
+ * NEITHER JOINS `MUTATING_TOOLS` (P2-5). `bash_output` is a read. `bash_kill`
+ * stops something THIS SESSION STARTED and is showing on screen, and the plan
+ * gate already refuses it in plan mode; putting a `--confirm` modal between the
+ * user and stopping their own runaway server is the wrong trade. `bash` itself
+ * stays in `MUTATING_TOOLS` unchanged, including when `background: true` — the
+ * command is still arbitrary.
+ */
+import { defineTool, errorResult, textResult } from '@aragon-agent/core';
+import { PROC_LIMITS } from '../proc/limits.js';
+/** One line of status, shared by both tools so the two can never disagree. */
+function statusLine(service) {
+    const bits = [`service ${service.id}  ${service.status}`];
+    if (service.url)
+        bits.push(service.url);
+    if (service.exitCode !== null)
+        bits.push(`exit code ${service.exitCode}`);
+    else if (service.signal)
+        bits.push(`signal ${service.signal}`);
+    if (service.killIncomplete)
+        bits.push('(may have left a detached child)');
+    return `${bits.join('  ')}\n$ ${service.command}`;
+}
+export function makeBashOutput(deps) {
+    return defineTool({
+        name: 'bash_output',
+        label: 'Service log',
+        description: 'Read a background service log tail and its current status. Pass the ' +
+            '`since` cursor returned by a previous call to read only what is new. ' +
+            'Use this to verify a service actually started, and to read a build or ' +
+            'test watcher as it runs.',
+        parameters: {
+            type: 'object',
+            properties: {
+                service: { type: 'string', description: 'The service id, e.g. "s1".' },
+                since: {
+                    type: 'number',
+                    description: 'Cursor from a previous call; omit to read the whole tail.',
+                },
+            },
+            required: ['service'],
+        },
+        async execute(_id, rawParams) {
+            const params = rawParams;
+            const service = deps.supervisor.get(params.service);
+            if (!service) {
+                return errorResult(`No service "${params.service}". Start one with bash({ command, background: true }).`);
+            }
+            const page = deps.supervisor.read(params.service, params.since);
+            const lines = [statusLine(service)];
+            if (page?.truncated) {
+                lines.push(`[note] older rows were dropped - the tail keeps the last ` +
+                    `${PROC_LIMITS.serviceTailRows} rows.`);
+            }
+            if (!page || page.rows.length === 0) {
+                lines.push('(no new output)');
+            }
+            else {
+                lines.push(...page.rows);
+            }
+            lines.push(`[cursor ${page?.cursor ?? service.rowsSeen}]`);
+            return textResult(lines.join('\n'));
+        },
+    });
+}
+export function makeBashKill(deps) {
+    return defineTool({
+        name: 'bash_kill',
+        label: 'Stop service',
+        description: 'Stop a background service by id, or every service with "all". Stop the ' +
+            'services you started once you are finished with them, unless the user ' +
+            'asked for them to stay up.',
+        parameters: {
+            type: 'object',
+            properties: {
+                service: { type: 'string', description: 'The service id, or "all".' },
+            },
+            required: ['service'],
+        },
+        async execute(_id, rawParams) {
+            const params = rawParams;
+            if (params.service !== 'all' && !deps.supervisor.get(params.service)) {
+                return errorResult(`No service "${params.service}".`);
+            }
+            const stopped = await deps.supervisor.stop(params.service);
+            if (stopped.length === 0)
+                return textResult('Nothing to stop.');
+            const lines = stopped.map((s) => statusLine(s));
+            return textResult(`Stopped ${stopped.length} service${stopped.length === 1 ? '' : 's'}.\n${lines.join('\n')}`);
+        },
+    });
+}

package/dist/ui/ActivityLine.d.ts

@@ -74,7 +74,25 @@ export interface ActivityLineProps {
      * not calm, it is wrong.
      */
     runningTool?: string;
+    /**
+     * A context compaction is in flight (context-auto-compaction §6.1).
+     *
+     * HIGHEST PRECEDENCE IN THE LABEL LADDER, above `runningTool` and above the
+     * rotating phrase. Compaction happens BEFORE `turn_start`, i.e. at a moment
+     * when `status` is `'running'` but no tool is in flight — precisely the window
+     * in which the phrase rotation would say something false, and it can last
+     * tens of seconds. `runningTool` already established the principle one step
+     * back: a UI that says "Pondering" while `npm test` runs is not calm, it is
+     * wrong, and one that says it while a 30 k-token summarization runs is the same
+     * error.
+     *
+     * STILL NO SECOND SPINNER. `single-spinner-while-running`'s D-1 stands: this
+     * row owns the only animation while it is mounted, and the compaction card
+     * follows `FastCard` in taking a `reducedMotion` that `App` has already
+     * widened.
+     */
+    compacting?: boolean;
     theme: Theme;
     caps: TermCapabilities;
 }
-export declare function ActivityLine({ startedAt, elapsedMs, reducedMotion, runningTool, theme, caps, }: ActivityLineProps): React.ReactElement;
+export declare function ActivityLine({ startedAt, elapsedMs, reducedMotion, runningTool, compacting, theme, caps, }: ActivityLineProps): React.ReactElement;

package/dist/ui/ActivityLine.js

@@ -21,7 +21,7 @@ import { pickActivityPhrase } from './activity-phrases.js';
 export function liveSpinner(reducedMotion, caps) {
     return caps.unicode && !reducedMotion ? _jsx(Spinner, { type: "dots" }) : null;
 }
-export function ActivityLine({ startedAt, elapsedMs, reducedMotion, runningTool, theme, caps, }) {
+export function ActivityLine({ startedAt, elapsedMs, reducedMotion, runningTool, compacting, theme, caps, }) {
     const glyphs = pickGlyphs(caps);
     // PURE AND DERIVED FROM `(startedAt, now)`, so the sequence does not need to
     // keep rotating underneath the tool label: when the tool settles the phrase
@@ -31,7 +31,15 @@ export function ActivityLine({ startedAt, elapsedMs, reducedMotion, runningTool,
     // SECOND registry of tool names, and `toolGlyph` is already the one place that
     // knows them. Everything round 1 legislated for this row survives — one row,
     // no digits, no `esc abort`, no width ladder, ASCII only.
-    const label = runningTool ? `Running ${runningTool}` : `${phrase}${glyphs.ellipsis}`;
+    // THREE RUNGS, MOST SPECIFIC FIRST. `Compacting context` outranks a tool name
+    // because compaction can be the only thing happening, and it outranks the
+    // phrase for the reason `runningTool` does. ASCII only, and the ellipsis comes
+    // from `pickGlyphs` like every other one on this row.
+    const label = compacting
+        ? `Compacting context${glyphs.ellipsis}`
+        : runningTool
+            ? `Running ${runningTool}`
+            : `${phrase}${glyphs.ellipsis}`;
     // The IDENTICAL branch `Transcript.tsx` uses for the assistant role marker, and
     // it must stay identical: braille dots are both an animation AND a Unicode-only
     // glyph, so reduced motion and an ASCII terminal fall back to the same marker.

package/dist/ui/App.d.ts

@@ -10,7 +10,9 @@ import type { ConfirmRequest } from '../tools/index.js';
 import { type Overlay, type ToastLevel } from '../agent/reducer.js';
 import type { UpdateBridge } from '../update/types.js';
 import { type RenderMode } from './layout/frame.js';
-import type { MouseSource } from '../input/stdin-mouse-filter.js';
+import type { MouseSource } from '../input/stdin-filter.js';
+import type { PasteBridge } from '../input/limits.js';
+import type { SelectionBridge } from './selection/selection-controller.js';
 import type { HumanInputBridge } from '../tools/human-input.js';
 export interface ConfirmBridge {
     handler: ((req: ConfirmRequest) => Promise<boolean>) | null;
@@ -72,5 +74,63 @@ export interface AppProps {
      * 'off'`, on a non-TTY, in CI, and in every test that does not exercise it.
      */
     updateBridge?: UpdateBridge;
+    /**
+     * The stdin filter's channel for a refused paste (tui-paste-handling section
+     * 5.1.2 / I-15).
+     *
+     * A BRIDGE for the reason `updateBridge` above is one: the filter is built in
+     * `cli.tsx` BEFORE `render()`, so it has no `dispatch`. Its only other outlet
+     * is the logger, and a limit that writes only to a log file is
+     * indistinguishable — from the user's chair — from a paste that silently did
+     * nothing, which is what D-11 exists to rule out. Absent under `--no-paste`,
+     * on a non-TTY, and in every test that does not exercise it.
+     */
+    pasteBridge?: PasteBridge;
+    /**
+     * The terminal-facing services `cli.tsx` owns and this component cannot build
+     * (tui-selection-and-scroll-follow §4.4).
+     *
+     * ONE PROP RATHER THAN FOUR, and every FIELD of it is independently optional,
+     * so `--no-mouse`, `--no-diff-render` and inline mode each drop exactly the
+     * services they do not have. Absent altogether on a non-TTY and in every test
+     * that does not exercise selection, which is what keeps those trees
+     * byte-identical.
+     */
+    terminal?: TerminalBridge;
+}
+/**
+ * Terminal-level services, almost all of which exist only in a full-screen TTY
+ * session — `writeForeign` is the exception, because `/copy` is available in
+ * inline mode too and OSC 52 is what makes it work over SSH (§4.4.5).
+ *
+ * `selection` is a LATE-BOUND BRIDGE for the reason `updateBridge` above is one:
+ * the controller is constructed before `render()` and must not hold React state,
+ * while the toast sink and the redraw nonce only exist once this component has
+ * mounted. The effect below assigns both and clears them on unmount.
+ */
+export interface TerminalBridge {
+    /** Whether drag-select is on for this session (`mouseSelect` + a filter). */
+    mouseSelect: boolean;
+    /** Release the mouse to the terminal, or take it back (`/mouse`, G3). */
+    setMouseCapture?: (on: boolean) => void;
+    /** Whether the mouse is captured right now — read at command time. */
+    isMouseCaptured?: () => boolean;
+    /**
+     * Write bytes that are ours but are not a frame (OSC 52).
+     *
+     * IT MUST NOT BE `stdout.write` WITH THE DIFFER IN FRONT OF STDOUT (P1-6):
+     * that goes through the frame-writer proxy, which does not recognise an OSC 52
+     * chunk, counts it as a foreign write and prints `FRAME_FALLBACK_NOTICE` at
+     * the user the first time they copy anything. Without a differ — inline mode,
+     * `--no-diff-render` — stdout IS the real stream and `cli.tsx` supplies a
+     * direct write instead.
+     *
+     * Absent only when there is no terminal to accept it at all. It is never a
+     * function that writes nowhere: `copyText` reports `'osc52'` whenever its door
+     * took the text, so a no-op door would make the toast name a mechanism that
+     * was never attempted.
+     */
+    writeForeign?: (text: string) => void;
+    selection?: SelectionBridge;
 }
-export declare function App({ controller, version, mode, initialOverlay, initialPrompt, confirmBridge, humanInputBridge, mouseSource, vtInputWarning, updateBridge, }: AppProps): React.ReactElement;
+export declare function App({ controller, version, mode, initialOverlay, initialPrompt, confirmBridge, humanInputBridge, mouseSource, vtInputWarning, updateBridge, pasteBridge, terminal, }: AppProps): React.ReactElement;