@aragon-agent/cli 0.6.12 → 0.6.14

package/dist/ui/clipboard-task.d.ts

@@ -0,0 +1,29 @@
+import { type ClipboardOptions, type CopyResult } from './clipboard.js';
+export interface CopyRequest {
+    text: string;
+    lines: number;
+}
+export type CopyRequestResult = CopyResult | {
+    status: 'busy';
+};
+export interface ClipboardState {
+    busy: boolean;
+    cleanupPending: boolean;
+}
+export interface ClipboardCoordinatorOptions {
+    clipboard?: ClipboardOptions;
+    /** Clears the previous Ctrl+C exit preparation for both copy entry points. */
+    onRequest?: () => void;
+    /** A repeated request is consumed; its selection must remain untouched. */
+    onBusy?: (state: ClipboardState) => void;
+    onResult?: (result: CopyResult, request: CopyRequest) => void;
+    onStateChange?: (state: ClipboardState) => void;
+}
+export interface ClipboardCoordinator {
+    requestCopy(request: CopyRequest): Promise<CopyRequestResult>;
+    isBusy(): boolean;
+    isCleanupPending(): boolean;
+    dispose(): void;
+}
+/** Create the App-owned copy port; use its live busy state before taking a selection. */
+export declare function createClipboardCoordinator(options?: ClipboardCoordinatorOptions): ClipboardCoordinator;

package/dist/ui/clipboard-task.js

@@ -0,0 +1,66 @@
+import { startClipboardTask, } from './clipboard.js';
+class SharedClipboardCoordinator {
+    options;
+    busy = false;
+    cleanupPending = false;
+    disposed = false;
+    abort = new AbortController();
+    constructor(options) {
+        this.options = options;
+        options.clipboard?.signal?.addEventListener('abort', this.dispose, { once: true });
+        if (options.clipboard?.signal?.aborted)
+            this.dispose();
+    }
+    isBusy() { return this.busy; }
+    isCleanupPending() { return this.cleanupPending; }
+    state() {
+        return { busy: this.busy, cleanupPending: this.cleanupPending };
+    }
+    notifyState() {
+        if (!this.disposed)
+            this.options.onStateChange?.(this.state());
+    }
+    requestCopy = (request) => {
+        if (this.disposed)
+            return Promise.resolve({ status: 'failed', reason: 'cancelled' });
+        if (this.busy) {
+            this.options.onRequest?.();
+            this.options.onBusy?.(this.state());
+            return Promise.resolve({ status: 'busy' });
+        }
+        // Claim synchronously, before callbacks or Promise work can re-enter this port.
+        this.busy = true;
+        this.options.onRequest?.();
+        this.notifyState();
+        const snapshot = { ...request };
+        const task = startClipboardTask(snapshot.text, {
+            ...this.options.clipboard, signal: this.abort.signal,
+        });
+        const result = task.result.then((value) => {
+            if (!this.disposed) {
+                this.cleanupPending = this.busy && value.status === 'failed';
+                this.notifyState();
+                this.options.onResult?.(value, snapshot);
+            }
+            return value;
+        });
+        // Failure feedback is not a release signal: the old native writer may still live.
+        void task.released.then(() => {
+            this.busy = false;
+            this.cleanupPending = false;
+            this.notifyState();
+        });
+        return result;
+    };
+    dispose = () => {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.options.clipboard?.signal?.removeEventListener('abort', this.dispose);
+        this.abort.abort();
+    };
+}
+/** Create the App-owned copy port; use its live busy state before taking a selection. */
+export function createClipboardCoordinator(options = {}) {
+    return new SharedClipboardCoordinator(options);
+}

package/dist/ui/clipboard.d.ts

@@ -1,52 +1,31 @@
-/**
- * Clipboard (tui-selection-and-scroll-follow §4.4.5) — the SINGLE clipboard path
- * for the package. `/copy` and the selection release both come through here.
- *
- * Two mechanisms, both attempted, and the return value names the better one so
- * the toast can say what was SENT rather than claiming a success neither one can
- * confirm:
- *
- *  1. **OSC 52.** It reaches the clipboard of the machine the USER is sitting
- *     at, which is the only correct target over SSH, and it is the only mechanism
- *     that works with no helper binary installed. `/copy` gained SSH support the
- *     moment it moved onto this module.
- *  2. **The platform binary** (`clip` / `pbcopy` / `xclip`), moved here unchanged
- *     from `commands/builtins.ts`, for the local case and for terminals that
- *     ignore OSC 52 (tmux without `set -g set-clipboard on`, R-7).
- *
- * IT TAKES A WRITE *DOOR*, NOT A STREAM, and that is P1-6 rather than taste. In
- * full-screen mode stdout is a `Proxy` in front of the frame differ; an
- * unrecognised chunk there takes `passThrough(true)`, which increments
- * `fallbacks` and — on the first one — raises `onFirstFallback`, wired to
- * `console.warn(FRAME_FALLBACK_NOTICE)`. Sending OSC 52 through the proxy would
- * therefore print a diagnostic at a user who did nothing wrong the first time
- * they copied anything, and would permanently corrupt a counter documented to
- * mean "something wrote to stdout behind Ink's back". The caller supplies
- * `writeForeign` instead, and this module cannot pick the wrong door.
- */
-export type CopyVia = 'osc52' | 'native' | 'none';
-/**
- * Ceiling on an OSC 52 payload, in bytes of the ORIGINAL text.
- *
- * xterm's default limit is around 100 000 BASE64 characters and tmux / screen
- * are stricter, so 56 000 source bytes (~74 700 base64) stays inside all three
- * with room to spare. Past it the sequence is skipped rather than truncated: a
- * terminal that drops an over-long OSC 52 leaves the clipboard holding whatever
- * was there before, and half a selection is worse than none.
- */
+export type CopyFailureReason = 'empty' | 'unavailable' | 'write' | 'timeout' | 'too-large' | 'cancelled';
+export type CopyResult = {
+    status: 'confirmed';
+    via: 'native';
+} | {
+    status: 'sent';
+    via: 'osc52';
+    fallbackReason?: CopyFailureReason;
+} | {
+    status: 'failed';
+    reason: CopyFailureReason;
+};
+export interface ClipboardOptions {
+    /** Frame differ's foreign-write door, never the intercepted stdout stream. */
+    write?: (chunk: string) => void;
+    remote?: boolean;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+export interface ClipboardTask {
+    result: Promise<CopyResult>;
+    /** Resolves only after no writer can change the clipboard again. */
+    released: Promise<void>;
+}
 export declare const MAX_OSC52_BYTES = 56000;
-/** `\x1b]52;c;<base64>\x07` — `c` is the CLIPBOARD selection, not PRIMARY. */
+/** Encode the full clipboard selection as UTF-8, without truncating its payload. */
 export declare function osc52(text: string): string;
-/**
- * Put `text` on the clipboard and report the best mechanism that was reached.
- *
- * `write` is the foreign-write door (see the module header). Omit it and OSC 52
- * is skipped entirely, which is the correct behaviour for a caller that has no
- * terminal to write to.
- *
- * NEITHER MECHANISM IS DETECTABLE. `spawn` returning without throwing does not
- * mean `xclip` exists, and an OSC 52 sequence a terminal ignores is
- * indistinguishable from one it honours. The return value therefore names what
- * was ATTEMPTED, and every caller's user-facing text is worded accordingly.
- */
-export declare function copyText(text: string, write?: (chunk: string) => void): CopyVia;
+/** Start a copy without rejecting; result and writer release are separate signals. */
+export declare function startClipboardTask(text: string, options?: ClipboardOptions): ClipboardTask;
+/** Promise convenience wrapper; interactive callers must use the shared coordinator. */
+export declare function copyText(text: string, options?: ClipboardOptions): Promise<CopyResult>;

package/dist/ui/clipboard.js

@@ -1,91 +1,157 @@
-/**
- * Clipboard (tui-selection-and-scroll-follow §4.4.5) — the SINGLE clipboard path
- * for the package. `/copy` and the selection release both come through here.
- *
- * Two mechanisms, both attempted, and the return value names the better one so
- * the toast can say what was SENT rather than claiming a success neither one can
- * confirm:
- *
- *  1. **OSC 52.** It reaches the clipboard of the machine the USER is sitting
- *     at, which is the only correct target over SSH, and it is the only mechanism
- *     that works with no helper binary installed. `/copy` gained SSH support the
- *     moment it moved onto this module.
- *  2. **The platform binary** (`clip` / `pbcopy` / `xclip`), moved here unchanged
- *     from `commands/builtins.ts`, for the local case and for terminals that
- *     ignore OSC 52 (tmux without `set -g set-clipboard on`, R-7).
- *
- * IT TAKES A WRITE *DOOR*, NOT A STREAM, and that is P1-6 rather than taste. In
- * full-screen mode stdout is a `Proxy` in front of the frame differ; an
- * unrecognised chunk there takes `passThrough(true)`, which increments
- * `fallbacks` and — on the first one — raises `onFirstFallback`, wired to
- * `console.warn(FRAME_FALLBACK_NOTICE)`. Sending OSC 52 through the proxy would
- * therefore print a diagnostic at a user who did nothing wrong the first time
- * they copied anything, and would permanently corrupt a counter documented to
- * mean "something wrote to stdout behind Ink's back". The caller supplies
- * `writeForeign` instead, and this module cannot pick the wrong door.
- */
+/** The only clipboard writer. Interaction callers share clipboard-task's coordinator. */
 import { spawn } from 'node:child_process';
 import process from 'node:process';
-/**
- * Ceiling on an OSC 52 payload, in bytes of the ORIGINAL text.
- *
- * xterm's default limit is around 100 000 BASE64 characters and tmux / screen
- * are stricter, so 56 000 source bytes (~74 700 base64) stays inside all three
- * with room to spare. Past it the sequence is skipped rather than truncated: a
- * terminal that drops an over-long OSC 52 leaves the clipboard holding whatever
- * was there before, and half a selection is worse than none.
- */
 export const MAX_OSC52_BYTES = 56_000;
-/** `\x1b]52;c;<base64>\x07` — `c` is the CLIPBOARD selection, not PRIMARY. */
+const CLEANUP_GRACE_MS = 500;
+// clip.exe preserves a supplied BOM and guesses BOM-less UTF-16 incorrectly for
+// short CJK text. Decode stdin explicitly; never interpolate clipboard content.
+const WINDOWS_CLIPBOARD_COMMAND = "$ErrorActionPreference='Stop'; "
+    + '$reader=[IO.StreamReader]::new([Console]::OpenStandardInput(),'
+    + '[Text.UTF8Encoding]::new($false),$false); Set-Clipboard -Value $reader.ReadToEnd()';
+/** Encode the full clipboard selection as UTF-8, without truncating its payload. */
 export function osc52(text) {
-    return `\x1b]52;c;${Buffer.from(text, 'utf-8').toString('base64')}\x07`;
+    return `\x1b]52;c;${Buffer.from(text, 'utf8').toString('base64')}\x07`;
 }
-/** Best-effort clipboard copy via the platform's clipboard CLI. */
-function copyNative(text) {
-    const cmd = process.platform === 'win32'
-        ? { file: 'clip', args: [] }
-        : process.platform === 'darwin'
-            ? { file: 'pbcopy', args: [] }
-            : { file: 'xclip', args: ['-selection', 'clipboard'] };
+function sendOsc52(text, options, fallbackReason) {
+    if (options.signal?.aborted)
+        return { status: 'failed', reason: 'cancelled' };
+    if (Buffer.byteLength(text, 'utf8') > MAX_OSC52_BYTES) {
+        return { status: 'failed', reason: 'too-large' };
+    }
+    if (!options.write)
+        return { status: 'failed', reason: fallbackReason ?? 'unavailable' };
     try {
-        const child = spawn(cmd.file, cmd.args, { stdio: ['pipe', 'ignore', 'ignore'] });
-        child.on('error', () => {
-            /* swallow — clipboard is best-effort, and a missing xclip is ordinary */
-        });
-        child.stdin?.end(text);
-        return true;
+        options.write(osc52(text));
+        return { status: 'sent', via: 'osc52', ...(fallbackReason ? { fallbackReason } : {}) };
     }
     catch {
-        return false;
+        return { status: 'failed', reason: 'write' };
     }
 }
-/**
- * Put `text` on the clipboard and report the best mechanism that was reached.
- *
- * `write` is the foreign-write door (see the module header). Omit it and OSC 52
- * is skipped entirely, which is the correct behaviour for a caller that has no
- * terminal to write to.
- *
- * NEITHER MECHANISM IS DETECTABLE. `spawn` returning without throwing does not
- * mean `xclip` exists, and an OSC 52 sequence a terminal ignores is
- * indistinguishable from one it honours. The return value therefore names what
- * was ATTEMPTED, and every caller's user-facing text is worded accordingly.
- */
-export function copyText(text, write) {
-    if (text.length === 0)
-        return 'none';
-    let sentOsc52 = false;
-    if (write && Buffer.byteLength(text, 'utf-8') <= MAX_OSC52_BYTES) {
+function settledTask(result) {
+    return { result: Promise.resolve(result), released: Promise.resolve() };
+}
+function spawnNative() {
+    const windows = process.platform === 'win32';
+    const file = windows ? 'powershell.exe' : process.platform === 'darwin' ? 'pbcopy' : 'xclip';
+    const args = windows
+        ? ['-NoProfile', '-NonInteractive', '-STA', '-Command', WINDOWS_CLIPBOARD_COMMAND]
+        : file === 'xclip' ? ['-selection', 'clipboard'] : [];
+    return spawn(file, args, {
+        stdio: ['pipe', 'ignore', 'ignore'], shell: false, windowsHide: true,
+    });
+}
+/** Owns a writer through close, even when its user-facing result timed out earlier. */
+class NativeClipboardTask {
+    child;
+    text;
+    options;
+    result;
+    released;
+    resolveResult;
+    resolveReleased;
+    settled = false;
+    closed = false;
+    stopping = false;
+    failure;
+    timer;
+    cleanupTimer;
+    constructor(child, text, options) {
+        this.child = child;
+        this.text = text;
+        this.options = options;
+        this.result = new Promise((resolve) => { this.resolveResult = resolve; });
+        this.released = new Promise((resolve) => { this.resolveReleased = resolve; });
+        child.on('error', this.onError);
+        child.once('close', this.onClose);
+        child.stdin?.on('error', this.onStdinError);
+        options.signal?.addEventListener('abort', this.onAbort, { once: true });
+        this.timer = setTimeout(() => this.stop('timeout'), options.timeoutMs ?? 1500);
+        if (options.signal?.aborted) {
+            this.onAbort();
+            return;
+        }
+        if (!child.stdin) {
+            this.stop('write');
+            return;
+        }
         try {
-            write(osc52(text));
-            sentOsc52 = true;
+            child.stdin.end(Buffer.from(text, 'utf8'));
         }
         catch {
-            // A closed or broken stdout must never turn a copy into a crash.
+            this.stop('write');
         }
     }
-    const sentNative = copyNative(text);
-    if (sentOsc52)
-        return 'osc52';
-    return sentNative ? 'native' : 'none';
+    settle(result) {
+        if (this.settled)
+            return;
+        this.settled = true;
+        clearTimeout(this.timer);
+        clearTimeout(this.cleanupTimer);
+        this.resolveResult(result);
+    }
+    stop(reason) {
+        if (this.closed || this.stopping)
+            return;
+        this.stopping = true;
+        this.failure = reason;
+        clearTimeout(this.timer);
+        // No fallback before close: even a successful kill request is not proof of exit.
+        if (!this.settled) {
+            this.cleanupTimer = setTimeout(() => {
+                this.settle({ status: 'failed', reason });
+            }, CLEANUP_GRACE_MS);
+        }
+        try {
+            this.child.stdin?.destroy();
+        }
+        catch { /* Keep error listeners until close. */ }
+        try {
+            this.child.kill();
+        }
+        catch { /* A failed kill must not release the writer lock. */ }
+    }
+    onAbort = () => {
+        this.settle({ status: 'failed', reason: 'cancelled' });
+        this.stop('cancelled');
+    };
+    onError = () => { this.stop('unavailable'); };
+    onStdinError = () => { this.stop('write'); };
+    onClose = (code) => {
+        this.closed = true;
+        clearTimeout(this.timer);
+        clearTimeout(this.cleanupTimer);
+        this.options.signal?.removeEventListener('abort', this.onAbort);
+        if (!this.settled) {
+            const result = code === 0 && !this.failure
+                ? { status: 'confirmed', via: 'native' }
+                : sendOsc52(this.text, this.options, this.failure ?? 'write');
+            this.settle(result);
+        }
+        this.child.removeListener('error', this.onError);
+        this.child.stdin?.removeListener('error', this.onStdinError);
+        this.resolveReleased();
+    };
+}
+/** Start a copy without rejecting; result and writer release are separate signals. */
+export function startClipboardTask(text, options = {}) {
+    if (options.signal?.aborted)
+        return settledTask({ status: 'failed', reason: 'cancelled' });
+    if (text.length === 0)
+        return settledTask({ status: 'failed', reason: 'empty' });
+    const remote = options.remote ?? Boolean(process.env.SSH_CONNECTION || process.env.SSH_TTY);
+    if (remote)
+        return settledTask(sendOsc52(text, options));
+    let child;
+    try {
+        child = spawnNative();
+    }
+    catch {
+        return settledTask(sendOsc52(text, options, 'unavailable'));
+    }
+    return new NativeClipboardTask(child, text, options);
+}
+/** Promise convenience wrapper; interactive callers must use the shared coordinator. */
+export function copyText(text, options = {}) {
+    return startClipboardTask(text, options).result;
 }

package/dist/ui/color-runtime.d.ts

@@ -0,0 +1,5 @@
+import type { TermCapabilities } from './capabilities.js';
+/** Highlight cache entries must not cross color preferences between sessions. */
+export declare function syntaxColorLevel(): number;
+/** Apply session colors without changing environment inherited by agent tools. */
+export declare function useTuiColors(level: TermCapabilities['colorLevel']): () => void;

package/dist/ui/color-runtime.js

@@ -0,0 +1,29 @@
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+import chalk from 'chalk';
+const require = createRequire(import.meta.url);
+/** Resolve the actual dependency instance even when npm nests its Chalk. */
+async function dependencyChalk(packageName) {
+    const dependency = createRequire(require.resolve(packageName));
+    return (await import(pathToFileURL(dependency.resolve('chalk')).href)).default;
+}
+const [inkChalk, highlightChalk] = await Promise.all([
+    dependencyChalk('ink'), dependencyChalk('cli-highlight'),
+]);
+/** Highlight cache entries must not cross color preferences between sessions. */
+export function syntaxColorLevel() { return highlightChalk.level; }
+/** Apply session colors without changing environment inherited by agent tools. */
+export function useTuiColors(level) {
+    const renderers = new Set([chalk, inkChalk, highlightChalk]);
+    const previous = new Map([...renderers].map(renderer => [renderer, renderer.level]));
+    for (const renderer of renderers)
+        renderer.level = level;
+    let restored = false;
+    return () => {
+        if (restored)
+            return;
+        restored = true;
+        for (const [renderer, original] of previous)
+            renderer.level = original;
+    };
+}

package/dist/ui/composer-limits.d.ts

@@ -22,10 +22,9 @@ export declare const USER_ENTRY_MAX_ROWS = 40;
 /**
  * Ceiling on the composer's DRAFT rows at a given terminal height.
  *
- * Non-decreasing in `terminalRows`. Returning `Infinity` reduces the whole
- * height-bound layer to the rung below it (section 12, S4), which is what makes
- * that stage revertible on its own.
+ * Non-decreasing in `terminalRows`, with one quarter of the terminal available
+ * to the draft and an absolute six-row ceiling shared by rendering and budgets.
  */
 export declare function draftMaxRows(terminalRows: number): number;
-/** The terminal height at which `draftMaxRows` steps from 3 to 6. Pinned by test. */
+/** Compatibility export for the shared hint visibility threshold. */
 export declare const DRAFT_MAX_ROWS_HINT_TIER = 20;

package/dist/ui/composer-limits.js

@@ -33,18 +33,13 @@ const DRAFT_TIER_MIN_ROWS = 20;
 /**
  * Ceiling on the composer's DRAFT rows at a given terminal height.
  *
- * Non-decreasing in `terminalRows`. Returning `Infinity` reduces the whole
- * height-bound layer to the rung below it (section 12, S4), which is what makes
- * that stage revertible on its own.
+ * Non-decreasing in `terminalRows`, with one quarter of the terminal available
+ * to the draft and an absolute six-row ceiling shared by rendering and budgets.
  */
 export function draftMaxRows(terminalRows) {
     if (!Number.isFinite(terminalRows))
         return 3;
-    if (terminalRows >= 30)
-        return 10;
-    if (terminalRows >= DRAFT_TIER_MIN_ROWS)
-        return 6;
-    return 3;
+    return Math.max(1, Math.min(6, Math.floor(terminalRows / 4)));
 }
-/** The terminal height at which `draftMaxRows` steps from 3 to 6. Pinned by test. */
+/** Compatibility export for the shared hint visibility threshold. */
 export const DRAFT_MAX_ROWS_HINT_TIER = DRAFT_TIER_MIN_ROWS;

package/dist/ui/composer-rows.d.ts

@@ -44,7 +44,7 @@ export interface ComposerLayoutInput {
     readonly maxRows: number;
     readonly active: boolean;
 }
-/** Total display width of a run, using the same table the layout used. */
+/** Width of a displayed run, measured by complete graphemes. */
 export declare function displayWidth(text: string): number;
 /**
  * Wrap `buffer` into rows, locate the caret, and select a window of at most