@webpresso/agent-kit 3.1.26 → 3.1.30

package/dist/esm/cli/commands/dash/tui/native-host.js

@@ -0,0 +1,256 @@
+// Domain host for the native Ratatui shell: maps AppViewModel ↔ IPC and keys → reduceTuiKey.
+import { spawn } from "node:child_process";
+import { emitDashE2eState } from "#cli/commands/dash/e2e-state.js";
+import { buildRows } from "#cli/commands/dash/menu-state.js";
+import { filterPaletteCommands, groupPaletteCommands } from "#cli/commands/dash/tui/palette.js";
+import { reduceTuiKey } from "#cli/commands/dash/tui/state.js";
+import { decodeIpcFrames, encodeIpcFrame, parseClientMessage, } from "#cli/commands/dash/tui/ipc-protocol.js";
+import { sanitizeTuiText } from "#cli/commands/dash/tui/sanitize.js";
+function hostAvailabilityNote(agentKey, availability) {
+    const row = availability.find((item) => item.id === agentKey);
+    if (!row || row.available)
+        return null;
+    return row.reason ?? "unavailable";
+}
+export function projectNativeViewModel(state, input) {
+    const rows = buildRows(state.agents, state.menu.expandedAgent);
+    const menuLines = rows.map((row) => {
+        const mark = row.key === state.menu.selectedKey ? "▸" : " ";
+        const note = row.kind === "agent" ? hostAvailabilityNote(row.agentKey, state.hostAvailability) : null;
+        const label = note ? `${row.label} · ${note}` : row.label;
+        return sanitizeTuiText(`${mark} ${label}`);
+    });
+    let overlayKind = state.overlay.kind;
+    let overlayLines = [];
+    if (state.overlay.kind === "palette") {
+        const matches = filterPaletteCommands(state.overlay.query);
+        const groups = groupPaletteCommands(matches);
+        overlayLines = [sanitizeTuiText(`query: ${state.overlay.query || "…"}`)];
+        for (const group of groups) {
+            overlayLines.push(sanitizeTuiText(`— ${group.category}`));
+            for (const [index, command] of group.commands.entries()) {
+                // Approximate global cursor: mark the selected match row.
+                const globalIndex = matches.indexOf(command);
+                const mark = globalIndex === state.overlay.cursor ? "▸" : " ";
+                overlayLines.push(sanitizeTuiText(`${mark} ${command.title} · ${command.keys}`));
+                void index;
+            }
+        }
+        if (matches.length === 0) {
+            overlayLines.push("(no matches)");
+        }
+    }
+    else if (state.overlay.kind === "help") {
+        overlayLines = [
+            "^p palette",
+            "^o mode",
+            "^s sessions",
+            "^x help",
+            "j/k move · h/l fold · g/G jump",
+            "q quit",
+        ];
+    }
+    else if (state.overlay.kind === "wizard") {
+        overlayLines = state.overlay.lines.map((line) => sanitizeTuiText(line));
+    }
+    else if (state.overlay.kind === "browser") {
+        overlayLines = state.overlay.lines.map((line) => sanitizeTuiText(line));
+    }
+    else if (state.overlay.kind === "lifecycle") {
+        overlayLines = [
+            sanitizeTuiText(`target ${state.overlay.target}`),
+            "d detach · s stop · f force-kill · a archive",
+            "Backspace delete · y confirm · Esc cancel",
+        ];
+    }
+    return {
+        repoLabel: sanitizeTuiText(input.repoLabel),
+        width: input.width,
+        height: input.height,
+        permissionMode: state.permissionMode,
+        hostAvailability: state.hostAvailability.map((h) => ({
+            id: h.id,
+            available: h.available,
+            ...(h.reason ? { reason: sanitizeTuiText(h.reason) } : {}),
+        })),
+        status: state.status ? sanitizeTuiText(state.status) : null,
+        warnings: state.warnings.map((w) => sanitizeTuiText(w)),
+        menuLines,
+        overlayKind,
+        overlayLines,
+        paletteQuery: state.overlay.kind === "palette" ? state.overlay.query : null,
+    };
+}
+export function clientMessageToParsedKey(message) {
+    switch (message.kind) {
+        case "char":
+            return message.value ? { kind: "char", value: message.value } : null;
+        case "up":
+        case "down":
+        case "left":
+        case "right":
+        case "enter":
+        case "escape":
+        case "tab":
+        case "backspace":
+            return { kind: message.kind };
+        case "ctrl":
+            return message.value ? { kind: "ctrl", value: message.value } : null;
+        default:
+            return null;
+    }
+}
+/**
+ * Drive pure TUI state from a native binary over length-prefixed JSON frames.
+ * State is owned by the caller (runtime) so launch/HUD/browser updates paint.
+ */
+export async function runNativeTuiHost(input) {
+    const spawnFn = input.spawnImpl ?? spawn;
+    const child = spawnFn(input.binaryPath, [], {
+        stdio: ["pipe", "pipe", "inherit"],
+    });
+    if (!child.stdin || !child.stdout) {
+        throw new Error("native shell spawn did not provide stdio pipes");
+    }
+    let stdinBuf = Buffer.alloc(0);
+    let width = 80;
+    let height = 24;
+    const childStdin = child.stdin;
+    const childStdout = child.stdout;
+    const pushView = () => {
+        if (!childStdin.writable)
+            return;
+        const view = projectNativeViewModel(input.getState(), {
+            repoLabel: input.repoLabel,
+            width,
+            height,
+        });
+        childStdin.write(encodeIpcFrame({ type: "view", view }));
+    };
+    input.onBridge?.({ pushView });
+    childStdin.write(encodeIpcFrame({ type: "hello", schemaVersion: 1 }));
+    pushView();
+    /**
+     * Handshake hang detection: fail closed if the shell never greets.
+     * After ready, probe process liveness so a zombie/stuck native binary
+     * cannot pin the domain host forever (runtime falls back to pure-ANSI).
+     */
+    const HANDSHAKE_MS = 30_000;
+    const LIVENESS_MS = 5_000;
+    return await new Promise((resolve) => {
+        let settled = false;
+        let handshakeDone = false;
+        let handshakeTimer = setTimeout(() => {
+            if (handshakeDone || settled)
+                return;
+            input.handlers.onQuit();
+            child.kill("SIGTERM");
+            setTimeout(() => child.kill("SIGKILL"), 2_000);
+            finish(1);
+        }, HANDSHAKE_MS);
+        let livenessTimer;
+        const finish = (code) => {
+            if (settled)
+                return;
+            settled = true;
+            if (handshakeTimer)
+                clearTimeout(handshakeTimer);
+            if (livenessTimer)
+                clearInterval(livenessTimer);
+            resolve(code);
+        };
+        const armLiveness = () => {
+            if (livenessTimer)
+                return;
+            livenessTimer = setInterval(() => {
+                if (settled)
+                    return;
+                // exitCode set when the process has already exited without us finishing.
+                if (child.exitCode !== null || child.signalCode !== null) {
+                    finish(child.exitCode ?? 1);
+                    return;
+                }
+                const pid = child.pid;
+                if (pid === undefined) {
+                    finish(1);
+                    return;
+                }
+                try {
+                    process.kill(pid, 0);
+                }
+                catch {
+                    finish(1);
+                }
+            }, LIVENESS_MS);
+        };
+        childStdout.on("data", (chunk) => {
+            stdinBuf = Buffer.concat([stdinBuf, chunk]);
+            let decoded;
+            try {
+                decoded = decodeIpcFrames(stdinBuf);
+            }
+            catch {
+                // Drop a corrupted frame prefix rather than crashing the domain host.
+                // Keep a bounded tail so a subsequent well-formed frame can resync.
+                stdinBuf = stdinBuf.length > 64 * 1024 ? stdinBuf.subarray(-4096) : Buffer.alloc(0);
+                return;
+            }
+            stdinBuf = Buffer.from(decoded.rest);
+            for (const raw of decoded.messages) {
+                let msg;
+                try {
+                    msg = parseClientMessage(raw);
+                }
+                catch {
+                    continue;
+                }
+                if (msg.type === "hello" || msg.type === "ready") {
+                    handshakeDone = true;
+                    if (handshakeTimer)
+                        clearTimeout(handshakeTimer);
+                    armLiveness();
+                    pushView();
+                    continue;
+                }
+                if (msg.type === "resize") {
+                    width = msg.width;
+                    height = msg.height;
+                    pushView();
+                    continue;
+                }
+                if (msg.type === "key") {
+                    const key = clientMessageToParsedKey(msg);
+                    if (!key)
+                        continue;
+                    const result = reduceTuiKey(input.getState(), key);
+                    input.setState(result.state);
+                    // Match pure-ANSI path: selection transitions ride the E2E channel so
+                    // CI tmux harness can assert menu navigation without screen scrapes.
+                    if (result.state.menu.selectedKey) {
+                        emitDashE2eState({ kind: "selection", row: result.state.menu.selectedKey });
+                    }
+                    for (const effect of result.effects) {
+                        void input.handlers.onEffect(effect);
+                        if (effect.kind === "quit") {
+                            input.handlers.onQuit();
+                            child.kill("SIGTERM");
+                            setTimeout(() => child.kill("SIGKILL"), 2_000);
+                            finish(0);
+                            return;
+                        }
+                    }
+                    if (result.state.quit) {
+                        input.handlers.onQuit();
+                        child.kill("SIGTERM");
+                        setTimeout(() => child.kill("SIGKILL"), 2_000);
+                        finish(0);
+                        return;
+                    }
+                    pushView();
+                }
+            }
+        });
+        child.on("exit", (code) => finish(code ?? 0));
+        child.on("error", () => finish(1));
+    });
+}

package/dist/esm/cli/commands/dash/tui/native-path.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Env contract:
+ * - `WP_DASH_NATIVE=0|false|off` → force pure-ANSI
+ * - `WP_DASH_NATIVE=1|true|on` → prefer native when binary present
+ * - unset → prefer native when binary present (cutover default)
+ * - `WP_DASH_TUI_BIN` → absolute path override
+ * - `WP_DASH_FORCE_ANSI=1` → runtime force pure-ANSI even if a binary resolves
+ */
+export declare function shouldPreferNativeDashTui(env?: NodeJS.ProcessEnv): boolean;
+export declare function resolveNativeDashTuiBinary(env?: NodeJS.ProcessEnv, candidates?: readonly string[]): string | null;
+export declare function defaultBinaryCandidates(cwd?: string): readonly string[];

package/dist/esm/cli/commands/dash/tui/native-path.js

@@ -0,0 +1,41 @@
+// Resolve the optional native wp-dash-tui binary for the control-plane shell.
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { findPackageAsset } from "#utils/package-assets.js";
+/**
+ * Env contract:
+ * - `WP_DASH_NATIVE=0|false|off` → force pure-ANSI
+ * - `WP_DASH_NATIVE=1|true|on` → prefer native when binary present
+ * - unset → prefer native when binary present (cutover default)
+ * - `WP_DASH_TUI_BIN` → absolute path override
+ * - `WP_DASH_FORCE_ANSI=1` → runtime force pure-ANSI even if a binary resolves
+ */
+export function shouldPreferNativeDashTui(env = process.env) {
+    const flag = env["WP_DASH_NATIVE"]?.trim().toLowerCase();
+    if (flag === "0" || flag === "false" || flag === "off" || flag === "no") {
+        return false;
+    }
+    return true;
+}
+export function resolveNativeDashTuiBinary(env = process.env, candidates = defaultBinaryCandidates()) {
+    const override = env["WP_DASH_TUI_BIN"]?.trim();
+    if (override && existsSync(override))
+        return override;
+    for (const candidate of candidates) {
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+export function defaultBinaryCandidates(cwd = process.cwd()) {
+    const fromPackage = [
+        findPackageAsset("native/dash-tui/target/release/wp-dash-tui", { cwd }),
+        findPackageAsset("native/dash-tui/target/debug/wp-dash-tui", { cwd }),
+    ].filter((path) => path !== null);
+    return [
+        join(cwd, "native/dash-tui/target/release/wp-dash-tui"),
+        join(cwd, "native/dash-tui/target/debug/wp-dash-tui"),
+        ...fromPackage,
+        join(cwd, "bin/wp-dash-tui"),
+    ];
+}

package/dist/esm/cli/commands/dash/tui/palette.d.ts

@@ -1,4 +1,4 @@
-export type PaletteCommandId = "palette.open" | "host.new.claude" | "host.new.codex" | "host.new.grok" | "host.new.opencode" | "sessions.focus" | "wizard.open" | "blueprints.open" | "fleet.open" | "permission.toggle" | "help.open" | "app.quit";
+export type PaletteCommandId = "palette.open" | "host.new.claude" | "host.new.codex" | "host.new.grok" | "host.new.opencode" | "sessions.focus" | "wizard.open" | "blueprints.open" | "fleet.open" | "merge.status" | "chat.mode.toggle" | "chat.mode.open" | "chat.mode.send" | "permission.toggle" | "help.open" | "app.quit";
 export type PaletteCategory = "Host" | "Session" | "Navigate" | "System";
 export type PaletteCommand = {
     readonly id: PaletteCommandId;

package/dist/esm/cli/commands/dash/tui/palette.js

@@ -37,6 +37,20 @@ const STATIC_PALETTE_COMMANDS = [
         keys: "f",
         keywords: ["fleet", "watch", "status"],
     },
+    {
+        id: "merge.status",
+        title: "Plan-once merge status matrix",
+        category: "Navigate",
+        keys: "m",
+        keywords: ["merge", "plan-once", "multi-host", "rollup", "status", "matrix"],
+    },
+    {
+        id: "chat.mode.toggle",
+        title: "Toggle host-pane / integrated chat",
+        category: "Session",
+        keys: "c",
+        keywords: ["chat", "acp", "integrated", "host-pane", "mode", "pane"],
+    },
     {
         id: "permission.toggle",
         title: "Toggle permission mode (safe / always-approve)",