@webpresso/agent-kit 3.1.25 → 3.1.28

package/dist/esm/cli/commands/dash/plan-once.js

@@ -0,0 +1,224 @@
+import { resolveLaunchPermissionMode } from "#cli/commands/dash/launch-preferences.js";
+import { parseMultiHostPlanProposal, parsePlanOnceDecision, } from "#cli/commands/dash/plan-once-schema.js";
+import { buildDashLaunchCommand, } from "#cli/commands/dash/provider-capabilities.js";
+import { updateDashRun } from "#cli/commands/dash/run-registry.js";
+export { PLAN_ONCE_SCHEMA_VERSION, parseMultiHostPlanProposal, parsePlanOnceDecision, multiHostPlanProposalSchema, planOnceDecisionSchema, } from "#cli/commands/dash/plan-once-schema.js";
+/** Documented fan-out concurrency — sequential because coordinator admits one pending launch. */
+export const PLAN_ONCE_FANOUT_CONCURRENCY = "sequential";
+/** Pure confirm-once / cancel reducer — no registry side effects. */
+export function createPlanOnceSession(plan) {
+    return { status: "proposed", plan };
+}
+export function reducePlanOnceDecision(session, decision) {
+    if (decision.planId !== session.plan.planId) {
+        return { ok: false, error: `Decision planId ${decision.planId} does not match session plan` };
+    }
+    if (session.status !== "proposed") {
+        return {
+            ok: false,
+            error: `Cannot ${decision.kind} plan in status ${session.status} (confirm-once from proposed only)`,
+        };
+    }
+    if (decision.kind === "confirm") {
+        return { ok: true, session: { ...session, status: "confirmed" } };
+    }
+    return { ok: true, session: { ...session, status: "cancelled" } };
+}
+/** Parse decision then reduce — convenience for IPC/menu handlers. */
+export function applyPlanOnceDecision(session, rawDecision) {
+    const parsed = parsePlanOnceDecision(rawDecision);
+    if (!parsed.ok) {
+        return {
+            ok: false,
+            error: parsed.issues.map((i) => i.message).join("; ") || "Invalid plan decision",
+        };
+    }
+    return reducePlanOnceDecision(session, parsed.decision);
+}
+function defaultRegistryPort() {
+    // createRun is intentionally not used by apply — only updateRun for plan labels.
+    // Import createDashRun only when tests inject a full port; production update path:
+    return {
+        createRun: async () => {
+            throw new Error("plan-once apply must not createDashRun; selectAgent/pane-controller owns create");
+        },
+        updateRun: updateDashRun,
+    };
+}
+function defaultDeps(input) {
+    return {
+        launch: input.launch,
+        registry: input.registry ?? defaultRegistryPort(),
+        resolvePermissionMode: input.resolvePermissionMode ?? resolveLaunchPermissionMode,
+        registryCwd: input.registryCwd,
+    };
+}
+export function planOnceRunLabel(planId, host) {
+    const base = host.label?.trim() || host.host;
+    return `plan-once:${planId}:${base}`;
+}
+function outcomeRunId(result) {
+    const outcome = result.outcome;
+    if ("runId" in outcome && typeof outcome.runId === "string" && outcome.runId.length > 0) {
+        return outcome.runId;
+    }
+    return null;
+}
+/**
+ * Apply a confirmed plan: sequential fan-out through launch coordinator.
+ *
+ * Does **not** pre-create registry rows. selectAgent (pane-controller) creates
+ * exactly one dash run per host on newRun. On success, plan-once labels that run.
+ */
+export async function applyConfirmedMultiHostPlan(input) {
+    if (input.session.status !== "confirmed") {
+        return {
+            ok: false,
+            error: `Cannot apply plan in status ${input.session.status} (require confirmed)`,
+        };
+    }
+    const deps = defaultDeps(input);
+    const plan = input.session.plan;
+    const hostResults = [];
+    for (const entry of plan.hosts) {
+        const permissionMode = deps.resolvePermissionMode(entry.extraArgs ?? [], entry.host);
+        const command = buildDashLaunchCommand(entry.host, permissionMode, entry.extraArgs ?? []);
+        const label = planOnceRunLabel(plan.planId, entry);
+        let launchResult;
+        try {
+            // newRun:true without runId — selectAgent owns createDashRun.
+            // prepared:true skips prepare thrash so sequential fan-out does not
+            // contend on coordinator pending Fresh.
+            launchResult = await deps.launch.launch(command, {
+                cwd: entry.workdir,
+                newRun: true,
+                prepared: true,
+                provider: entry.host,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Launch threw";
+            hostResults.push({
+                host: entry.host,
+                workdir: entry.workdir,
+                runId: null,
+                status: "failed",
+                permissionMode,
+                command,
+                error: message,
+            });
+            continue;
+        }
+        if (launchResult.kind === "launched") {
+            const runId = outcomeRunId(launchResult);
+            if (!runId) {
+                hostResults.push({
+                    host: entry.host,
+                    workdir: entry.workdir,
+                    runId: null,
+                    status: "failed",
+                    permissionMode,
+                    command,
+                    error: "selectAgent launched without dash runId (cannot label or attach)",
+                });
+                continue;
+            }
+            // Label the select-created run only — never invent a second registry row.
+            // Do not write runId into providerSessionId (that field is provider session).
+            // tmuxPaneId is already persisted by pane-controller before select returns.
+            try {
+                await deps.registry.updateRun(runId, { label, error: null }, { cwd: deps.registryCwd });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : "Failed to label dash run";
+                hostResults.push({
+                    host: entry.host,
+                    workdir: entry.workdir,
+                    runId,
+                    status: "failed",
+                    permissionMode,
+                    command,
+                    error: message,
+                });
+                continue;
+            }
+            hostResults.push({
+                host: entry.host,
+                workdir: entry.workdir,
+                runId,
+                status: "launched",
+                permissionMode,
+                command,
+                error: null,
+            });
+            continue;
+        }
+        if (launchResult.kind === "discarded") {
+            hostResults.push({
+                host: entry.host,
+                workdir: entry.workdir,
+                runId: null,
+                status: "discarded",
+                permissionMode,
+                command,
+                error: "launch discarded",
+            });
+            continue;
+        }
+        if (launchResult.kind === "pending") {
+            hostResults.push({
+                host: entry.host,
+                workdir: entry.workdir,
+                runId: null,
+                status: "failed",
+                permissionMode,
+                command,
+                error: launchResult.message || "Launch still pending (unexpected in sequential fan-out)",
+            });
+            continue;
+        }
+        // failed — selectAgent/pane-controller already marked its own run failed if created
+        const message = `${launchResult.message}${launchResult.action ? ` · ${launchResult.action}` : ""}`;
+        hostResults.push({
+            host: entry.host,
+            workdir: entry.workdir,
+            runId: null,
+            status: "failed",
+            permissionMode,
+            command,
+            error: message,
+        });
+    }
+    const launchedCount = hostResults.filter((h) => h.status === "launched").length;
+    const failedCount = hostResults.filter((h) => h.status === "failed").length;
+    const discardedCount = hostResults.filter((h) => h.status === "discarded").length;
+    let nextStatus;
+    if (launchedCount === hostResults.length && hostResults.length > 0) {
+        nextStatus = "applied";
+    }
+    else if (launchedCount === 0) {
+        nextStatus = "apply-failed";
+    }
+    else {
+        nextStatus = "apply-partial";
+    }
+    return {
+        ok: true,
+        result: {
+            planId: plan.planId,
+            concurrency: PLAN_ONCE_FANOUT_CONCURRENCY,
+            hosts: hostResults,
+            launchedCount,
+            failedCount,
+            discardedCount,
+        },
+        session: { ...input.session, status: nextStatus },
+    };
+}
+/** Propose → parse helper for callers that only have untrusted JSON. */
+export function proposeMultiHostPlan(raw) {
+    const parsed = parseMultiHostPlanProposal(raw);
+    if (!parsed.ok)
+        return parsed;
+    return { ok: true, session: createPlanOnceSession(parsed.plan) };
+}

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>;