@webpresso/agent-kit 3.1.26 → 3.1.30

package/dist/esm/cli/commands/dash/tui/chat-mode.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Control-plane interaction mode + per-host ACP capability matrix.
+ * Pure — no I/O. Missing ACP never silently omits a host.
+ */
+import { type DashProvider } from "#cli/commands/dash/provider-capabilities.js";
+export declare const CONTROL_PLANE_CHAT_MODES: readonly ["host-pane", "integrated-chat"];
+export type ControlPlaneChatMode = (typeof CONTROL_PLANE_CHAT_MODES)[number];
+export declare const DEFAULT_CONTROL_PLANE_CHAT_MODE: ControlPlaneChatMode;
+export type HostAcpCapability = {
+    readonly host: DashProvider;
+    /** True when integrated-chat transport can open for this host (hermetic or real). */
+    readonly acpAvailable: boolean;
+    /**
+     * When acpAvailable is false, honest degrade reason (required).
+     * When true, optional note about transport class.
+     */
+    readonly reason: string;
+    /** Transport class for docs/tests — hermetic fake, headless, or acp. */
+    readonly transport: "hermetic" | "headless" | "acp" | "unavailable";
+};
+/**
+ * Explicit matrix for every control-plane host. Never omit a host.
+ * MVP: Codex is hermetic-chat capable for CI; others degrade with reasons.
+ */
+export declare const HOST_ACP_CAPABILITIES: readonly HostAcpCapability[];
+export declare function hostAcpCapability(host: DashProvider): HostAcpCapability;
+/** Every host has an entry — used by tests to lock non-silent-omit. */
+export declare function projectHostAcpMatrix(): readonly HostAcpCapability[];
+export declare function isControlPlaneChatMode(value: string): value is ControlPlaneChatMode;
+export declare function formatChatModePill(mode: ControlPlaneChatMode): string;
+export declare function toggleControlPlaneChatMode(mode: ControlPlaneChatMode): ControlPlaneChatMode;
+/**
+ * Pure mode transition. Integrated-chat requires an explicit host that is ACP-capable
+ * when opening chat; switching back to host-pane always succeeds.
+ */
+export declare function reduceChatModeSwitch(input: {
+    readonly mode: ControlPlaneChatMode;
+    readonly target: ControlPlaneChatMode;
+    readonly host?: DashProvider | null;
+}): {
+    readonly ok: true;
+    readonly mode: ControlPlaneChatMode;
+} | {
+    readonly ok: false;
+    readonly error: string;
+    readonly mode: ControlPlaneChatMode;
+};

package/dist/esm/cli/commands/dash/tui/chat-mode.js

@@ -0,0 +1,98 @@
+/**
+ * Control-plane interaction mode + per-host ACP capability matrix.
+ * Pure — no I/O. Missing ACP never silently omits a host.
+ */
+import { DASH_PROVIDERS } from "#cli/commands/dash/provider-capabilities.js";
+export const CONTROL_PLANE_CHAT_MODES = ["host-pane", "integrated-chat"];
+export const DEFAULT_CONTROL_PLANE_CHAT_MODE = "host-pane";
+/**
+ * Explicit matrix for every control-plane host. Never omit a host.
+ * MVP: Codex is hermetic-chat capable for CI; others degrade with reasons.
+ */
+export const HOST_ACP_CAPABILITIES = DASH_PROVIDERS.map((host) => {
+    if (host === "codex") {
+        return {
+            host,
+            acpAvailable: true,
+            reason: "Hermetic integrated-chat adapter (MVP); real ACP optional later",
+            transport: "hermetic",
+        };
+    }
+    if (host === "claude") {
+        return {
+            host,
+            acpAvailable: false,
+            reason: "Claude ACP not wired in dash yet — use host-pane",
+            transport: "unavailable",
+        };
+    }
+    if (host === "grok") {
+        return {
+            host,
+            acpAvailable: false,
+            reason: "Grok ACP/headless chat not wired in dash yet — use host-pane",
+            transport: "unavailable",
+        };
+    }
+    return {
+        host,
+        acpAvailable: false,
+        reason: "OpenCode ACP not wired in dash yet — use host-pane",
+        transport: "unavailable",
+    };
+});
+export function hostAcpCapability(host) {
+    const row = HOST_ACP_CAPABILITIES.find((item) => item.host === host);
+    if (!row) {
+        // Should be unreachable — matrix covers DASH_PROVIDERS SSOT.
+        return {
+            host,
+            acpAvailable: false,
+            reason: `No ACP capability entry for ${host}`,
+            transport: "unavailable",
+        };
+    }
+    return row;
+}
+/** Every host has an entry — used by tests to lock non-silent-omit. */
+export function projectHostAcpMatrix() {
+    return HOST_ACP_CAPABILITIES;
+}
+export function isControlPlaneChatMode(value) {
+    return CONTROL_PLANE_CHAT_MODES.includes(value);
+}
+export function formatChatModePill(mode) {
+    return mode === "integrated-chat" ? "[chat]" : "[pane]";
+}
+export function toggleControlPlaneChatMode(mode) {
+    return mode === "host-pane" ? "integrated-chat" : "host-pane";
+}
+/**
+ * Pure mode transition. Integrated-chat requires an explicit host that is ACP-capable
+ * when opening chat; switching back to host-pane always succeeds.
+ */
+export function reduceChatModeSwitch(input) {
+    if (input.target === input.mode) {
+        return { ok: true, mode: input.mode };
+    }
+    if (input.target === "host-pane") {
+        return { ok: true, mode: "host-pane" };
+    }
+    // target integrated-chat
+    if (!input.host) {
+        return {
+            ok: false,
+            error: "Select a host session before switching to integrated chat",
+            mode: input.mode,
+        };
+    }
+    const cap = hostAcpCapability(input.host);
+    if (!cap.acpAvailable) {
+        return {
+            ok: false,
+            error: cap.reason,
+            mode: input.mode,
+        };
+    }
+    return { ok: true, mode: "integrated-chat" };
+}

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

@@ -3,6 +3,7 @@ import { type MenuState } from "#cli/commands/dash/menu-state.js";
 import { type PaletteCommand } from "#cli/commands/dash/tui/palette.js";
 import { type HostAvailability } from "#cli/commands/dash/tui/hosts.js";
 import type { DashPermissionMode } from "#cli/commands/dash/provider-capabilities.js";
+import { type ControlPlaneChatMode } from "#cli/commands/dash/tui/chat-mode.js";
 export type TuiOverlay = {
     readonly kind: "none";
 } | {
@@ -28,6 +29,8 @@ export type AppViewModel = {
     readonly width: number;
     readonly height: number;
     readonly permissionMode: DashPermissionMode;
+    /** host-pane (default) vs integrated-chat ACP surface */
+    readonly chatMode: ControlPlaneChatMode;
     readonly agents: readonly AgentEntry[];
     readonly menu: MenuState;
     readonly hostAvailability: readonly HostAvailability[];

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

@@ -5,6 +5,7 @@ import { buildRows } from "#cli/commands/dash/menu-state.js";
 import { footerHintsFor, helpEntriesFor } from "#cli/commands/dash/keymap.js";
 import { filterPaletteCommands } from "#cli/commands/dash/tui/palette.js";
 import { HOST_CAPABILITIES } from "#cli/commands/dash/tui/hosts.js";
+import { DEFAULT_CONTROL_PLANE_CHAT_MODE, formatChatModePill, } from "#cli/commands/dash/tui/chat-mode.js";
 import { sanitizeTuiText } from "#cli/commands/dash/tui/sanitize.js";
 function padLine(text, width) {
     return fitDashText(text, width).padEnd(Math.max(0, width)).slice(0, Math.max(0, width));
@@ -68,7 +69,8 @@ export function browserFrameChromeRows(input) {
 export function renderFrame(view) {
     const width = Math.max(24, Math.min(view.width, 120));
     const lines = [];
-    const title = ` wp dash · ${view.repoLabel} · ${formatModePill(view.permissionMode)} `;
+    const chatMode = view.chatMode ?? DEFAULT_CONTROL_PLANE_CHAT_MODE;
+    const title = ` wp dash · ${view.repoLabel} · ${formatModePill(view.permissionMode)} · ${formatChatModePill(chatMode)} `;
     lines.push(padLine(title, width));
     lines.push(hrule(width));
     if (view.ultragoalLine)

package/dist/esm/cli/commands/dash/tui/ipc-protocol.d.ts

@@ -0,0 +1,87 @@
+import { z } from "zod";
+export declare const DASH_TUI_IPC_SCHEMA_VERSION: 1;
+/** Keys that must never appear in IPC payloads (secret / env leakage). */
+export declare const FORBIDDEN_IPC_KEYS: readonly ["env", "argv", "secret", "secrets", "password", "token", "authorization", "apiKey", "api_key"];
+export declare const dashTuiViewModelSchema: z.ZodObject<{
+    repoLabel: z.ZodString;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    permissionMode: z.ZodEnum<{
+        dangerous: "dangerous";
+        safe: "safe";
+    }>;
+    hostAvailability: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        available: z.ZodBoolean;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    status: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    warnings: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    menuLines: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    overlayKind: z.ZodDefault<z.ZodString>;
+    overlayLines: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    paletteQuery: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export type DashTuiViewModel = z.infer<typeof dashTuiViewModelSchema>;
+export declare const dashTuiClientKeySchema: z.ZodObject<{
+    type: z.ZodLiteral<"key">;
+    kind: z.ZodString;
+    value: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const dashTuiClientMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"hello">;
+    schemaVersion: z.ZodLiteral<1>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"ready">;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"key">;
+    kind: z.ZodString;
+    value: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"resize">;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+}, z.core.$strict>], "type">;
+export type DashTuiClientMessage = z.infer<typeof dashTuiClientMessageSchema>;
+export declare const dashTuiServerMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"hello">;
+    schemaVersion: z.ZodLiteral<1>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"view">;
+    view: z.ZodObject<{
+        repoLabel: z.ZodString;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        permissionMode: z.ZodEnum<{
+            dangerous: "dangerous";
+            safe: "safe";
+        }>;
+        hostAvailability: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            available: z.ZodBoolean;
+            reason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        status: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        warnings: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        menuLines: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        overlayKind: z.ZodDefault<z.ZodString>;
+        overlayLines: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        paletteQuery: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"quit">;
+}, z.core.$strict>], "type">;
+export type DashTuiServerMessage = z.infer<typeof dashTuiServerMessageSchema>;
+export declare function assertNoForbiddenIpcKeys(value: unknown, path?: string): void;
+/** Encode one length-prefixed JSON frame (u32 little-endian length + UTF-8 body). */
+export declare function encodeIpcFrame(message: unknown): Buffer;
+/**
+ * Decode complete frames from a byte buffer. Returns messages and any incomplete tail.
+ */
+export declare function decodeIpcFrames(buffer: Buffer): {
+    readonly messages: readonly unknown[];
+    readonly rest: Buffer;
+};
+export declare function parseClientMessage(raw: unknown): DashTuiClientMessage;
+export declare function parseServerMessage(raw: unknown): DashTuiServerMessage;
+export declare function encodeServerView(view: DashTuiViewModel): Buffer;

package/dist/esm/cli/commands/dash/tui/ipc-protocol.js

@@ -0,0 +1,128 @@
+// Length-prefixed JSON-RPC-over-stdio framing for the native dash shell.
+// schemaVersion 1 — keep in sync with native/dash-tui.
+import { z } from "zod";
+export const DASH_TUI_IPC_SCHEMA_VERSION = 1;
+/** Keys that must never appear in IPC payloads (secret / env leakage). */
+export const FORBIDDEN_IPC_KEYS = [
+    "env",
+    "argv",
+    "secret",
+    "secrets",
+    "password",
+    "token",
+    "authorization",
+    "apiKey",
+    "api_key",
+];
+const hostAvailabilitySchema = z
+    .object({
+    id: z.string().min(1),
+    available: z.boolean(),
+    reason: z.string().optional(),
+})
+    .strict();
+export const dashTuiViewModelSchema = z
+    .object({
+    repoLabel: z.string(),
+    width: z.number().int().positive(),
+    height: z.number().int().positive(),
+    permissionMode: z.enum(["safe", "dangerous"]),
+    hostAvailability: z.array(hostAvailabilitySchema).default([]),
+    status: z.string().nullable().optional(),
+    warnings: z.array(z.string()).default([]),
+    menuLines: z.array(z.string()).default([]),
+    overlayKind: z.string().default("none"),
+    overlayLines: z.array(z.string()).default([]),
+    paletteQuery: z.string().nullable().optional(),
+})
+    .strict();
+export const dashTuiClientKeySchema = z
+    .object({
+    type: z.literal("key"),
+    kind: z.string().min(1),
+    value: z.string().optional(),
+})
+    .strict();
+export const dashTuiClientMessageSchema = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("hello"), schemaVersion: z.literal(1) }).strict(),
+    z.object({ type: z.literal("ready") }).strict(),
+    dashTuiClientKeySchema,
+    z
+        .object({
+        type: z.literal("resize"),
+        width: z.number().int().positive(),
+        height: z.number().int().positive(),
+    })
+        .strict(),
+]);
+export const dashTuiServerMessageSchema = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("hello"), schemaVersion: z.literal(1) }).strict(),
+    z.object({ type: z.literal("view"), view: dashTuiViewModelSchema }).strict(),
+    z.object({ type: z.literal("quit") }).strict(),
+]);
+export function assertNoForbiddenIpcKeys(value, path = "$") {
+    if (value === null || value === undefined)
+        return;
+    if (Array.isArray(value)) {
+        value.forEach((item, index) => assertNoForbiddenIpcKeys(item, `${path}[${index}]`));
+        return;
+    }
+    if (typeof value !== "object")
+        return;
+    for (const [key, child] of Object.entries(value)) {
+        const lower = key.toLowerCase();
+        if (FORBIDDEN_IPC_KEYS.some((forbidden) => lower === forbidden.toLowerCase() || lower.includes(forbidden.toLowerCase()))) {
+            throw new Error(`Forbidden IPC key at ${path}.${key}`);
+        }
+        assertNoForbiddenIpcKeys(child, `${path}.${key}`);
+    }
+}
+/** Encode one length-prefixed JSON frame (u32 little-endian length + UTF-8 body). */
+export function encodeIpcFrame(message) {
+    assertNoForbiddenIpcKeys(message);
+    const body = Buffer.from(JSON.stringify(message), "utf8");
+    const header = Buffer.alloc(4);
+    header.writeUInt32LE(body.length, 0);
+    return Buffer.concat([header, body]);
+}
+/**
+ * Decode complete frames from a byte buffer. Returns messages and any incomplete tail.
+ */
+export function decodeIpcFrames(buffer) {
+    const messages = [];
+    let offset = 0;
+    while (offset + 4 <= buffer.length) {
+        const len = buffer.readUInt32LE(offset);
+        if (len > 8 * 1024 * 1024) {
+            // Unrecoverable length claim — caller should drop/resync the stream.
+            throw new Error(`IPC frame too large: ${len}`);
+        }
+        if (offset + 4 + len > buffer.length)
+            break;
+        const body = buffer.subarray(offset + 4, offset + 4 + len);
+        offset += 4 + len;
+        try {
+            messages.push(JSON.parse(body.toString("utf8")));
+        }
+        catch {
+            // Skip one corrupt payload; continue scanning subsequent frames.
+            continue;
+        }
+    }
+    return { messages, rest: buffer.subarray(offset) };
+}
+export function parseClientMessage(raw) {
+    assertNoForbiddenIpcKeys(raw);
+    return dashTuiClientMessageSchema.parse(raw);
+}
+export function parseServerMessage(raw) {
+    assertNoForbiddenIpcKeys(raw);
+    return dashTuiServerMessageSchema.parse(raw);
+}
+export function encodeServerView(view) {
+    const message = {
+        type: "view",
+        view: dashTuiViewModelSchema.parse(view),
+    };
+    return encodeIpcFrame(message);
+}

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

@@ -0,0 +1,34 @@
+import { spawn } from "node:child_process";
+import { type TuiAppState, type TuiEffect } from "#cli/commands/dash/tui/state.js";
+import { type DashTuiViewModel } from "#cli/commands/dash/tui/ipc-protocol.js";
+import type { ParsedKey } from "#cli/commands/dash/tui/keys.js";
+export declare function projectNativeViewModel(state: TuiAppState, input: {
+    readonly repoLabel: string;
+    readonly width: number;
+    readonly height: number;
+}): DashTuiViewModel;
+export declare function clientMessageToParsedKey(message: {
+    readonly kind: string;
+    readonly value?: string;
+}): ParsedKey | null;
+export type NativeHostHandlers = {
+    readonly onEffect: (effect: TuiEffect) => void | Promise<void>;
+    readonly onQuit: () => void;
+};
+/** Bridge so the domain runtime can push async state into the native shell. */
+export type NativeHostBridge = {
+    readonly pushView: () => void;
+};
+/**
+ * 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 declare function runNativeTuiHost(input: {
+    readonly binaryPath: string;
+    readonly repoLabel: string;
+    readonly getState: () => TuiAppState;
+    readonly setState: (next: TuiAppState) => void;
+    readonly handlers: NativeHostHandlers;
+    readonly onBridge?: (bridge: NativeHostBridge) => void;
+    readonly spawnImpl?: typeof spawn;
+}): Promise<number>;