@madebywild/agent-harness-framework 1.3.1 → 1.5.0

package/dist/cli/adapters/interactive.js

@@ -1,9 +1,47 @@
-import { cancel, confirm, intro, isCancel, outro, select, text } from "@clack/prompts";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Spinner, TextInput } from "@inkjs/ui";
 import { providerIdSchema } from "@madebywild/agent-harness-manifest";
-import ora from "ora";
+import { Box, render, Static, Text, useApp, useInput } from "ink";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { resolveHarnessPaths } from "../../paths.js";
 import { listBuiltinPresets, summarizePreset } from "../../presets.js";
 import { CLI_ENTITY_TYPES } from "../../types.js";
+import { exists } from "../../utils.js";
+import { runDoctor } from "../../versioning/doctor.js";
 import { getCommandDefinition } from "../command-registry.js";
+import { renderTextOutput } from "../renderers/text.js";
+import { AutocompleteSelect } from "./autocomplete-select.js";
+import { ToggleConfirm } from "./toggle-confirm.js";
+export async function detectWorkspaceStatus(cwd) {
+    const paths = resolveHarnessPaths(cwd);
+    const [dirExists, manifestExists] = await Promise.all([exists(paths.agentsDir), exists(paths.manifestFile)]);
+    if (!dirExists || !manifestExists) {
+        return { state: "missing" };
+    }
+    try {
+        const doctor = await runDoctor(paths);
+        if (!doctor.healthy) {
+            return { state: "unhealthy", diagnostics: doctor.diagnostics };
+        }
+        return { state: "healthy" };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            state: "unhealthy",
+            diagnostics: [
+                {
+                    code: "INTERACTIVE_WORKSPACE_STATUS_CHECK_FAILED",
+                    severity: "error",
+                    message: `Failed to determine workspace health: ${message}`,
+                },
+            ],
+        };
+    }
+}
+// ---------------------------------------------------------------------------
+// Command list shown in the main selector
+// ---------------------------------------------------------------------------
 const INTERACTIVE_COMMAND_IDS = [
     "init",
     "provider.enable",
@@ -31,485 +69,865 @@ const INTERACTIVE_COMMAND_IDS = [
     "plan",
     "apply",
 ];
-function toErrorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-function getSelectedValue(value) {
-    if (isCancel(value)) {
-        return null;
+const COMMAND_OPTIONS = [
+    ...INTERACTIVE_COMMAND_IDS.map((id) => ({
+        label: getCommandDefinition(id).interactiveLabel ?? getCommandDefinition(id).description,
+        value: id,
+    })),
+    { label: "Exit", value: "exit" },
+];
+// ---------------------------------------------------------------------------
+// Build the prompt list for each command
+// ---------------------------------------------------------------------------
+function buildPromptsForCommand(commandId, presets) {
+    const providers = providerIdSchema.options.map((p) => ({
+        label: p,
+        value: p,
+    }));
+    const entityTypes = CLI_ENTITY_TYPES.map((t) => ({ label: t, value: t }));
+    switch (commandId) {
+        case "init":
+            return [
+                {
+                    id: "force",
+                    type: "confirm",
+                    message: "Overwrite existing .harness workspace if present?",
+                    initial: false,
+                },
+                {
+                    id: "preset",
+                    type: "select",
+                    message: "Select a preset to apply during init",
+                    options: [
+                        { value: "", label: "Skip preset" },
+                        ...presets.map((p) => ({
+                            value: p.id,
+                            label: `${p.name} (${p.id})`,
+                        })),
+                    ],
+                },
+                // delegate prompt inserted dynamically when preset === "delegate"
+            ];
+        case "provider.enable":
+        case "provider.disable":
+            return [
+                {
+                    id: "provider",
+                    type: "select",
+                    message: "Select provider",
+                    options: providers,
+                },
+            ];
+        case "registry.add":
+            return [
+                { id: "name", type: "text", message: "Registry name", required: true },
+                { id: "gitUrl", type: "text", message: "Git URL", required: true },
+                {
+                    id: "ref",
+                    type: "text",
+                    message: "Git ref (default: main)",
+                    required: false,
+                },
+                {
+                    id: "root",
+                    type: "text",
+                    message: "Registry root path",
+                    required: false,
+                },
+                {
+                    id: "tokenEnv",
+                    type: "text",
+                    message: "Token env var",
+                    required: false,
+                },
+            ];
+        case "registry.remove":
+        case "registry.default.set":
+            return [{ id: "name", type: "text", message: "Registry name", required: true }];
+        case "registry.pull":
+            return [
+                {
+                    id: "entityType",
+                    type: "select",
+                    message: "Entity type filter",
+                    options: [{ value: "", label: "All entity types" }, ...entityTypes],
+                },
+                {
+                    id: "id",
+                    type: "text",
+                    message: "Entity id filter",
+                    required: false,
+                },
+                {
+                    id: "registry",
+                    type: "text",
+                    message: "Registry filter",
+                    required: false,
+                },
+                {
+                    id: "force",
+                    type: "confirm",
+                    message: "Overwrite locally modified imported sources?",
+                    initial: false,
+                },
+            ];
+        case "preset.list":
+            return [
+                {
+                    id: "registry",
+                    type: "text",
+                    message: "Registry id",
+                    required: false,
+                },
+            ];
+        case "preset.describe":
+        case "preset.apply":
+            return [
+                { id: "presetId", type: "text", message: "Preset id", required: true },
+                {
+                    id: "registry",
+                    type: "text",
+                    message: "Registry id",
+                    required: false,
+                },
+            ];
+        case "add.prompt":
+            return [
+                {
+                    id: "registry",
+                    type: "text",
+                    message: "Registry id",
+                    required: false,
+                },
+            ];
+        case "add.skill":
+            return [
+                { id: "skillId", type: "text", message: "Skill id", required: true },
+                {
+                    id: "registry",
+                    type: "text",
+                    message: "Registry id",
+                    required: false,
+                },
+            ];
+        case "add.mcp":
+            return [
+                {
+                    id: "configId",
+                    type: "text",
+                    message: "MCP config id",
+                    required: true,
+                },
+                {
+                    id: "registry",
+                    type: "text",
+                    message: "Registry id",
+                    required: false,
+                },
+            ];
+        case "add.subagent":
+            return [
+                {
+                    id: "subagentId",
+                    type: "text",
+                    message: "Subagent id",
+                    required: true,
+                },
+                {
+                    id: "registry",
+                    type: "text",
+                    message: "Registry id",
+                    required: false,
+                },
+            ];
+        case "add.hook":
+            return [
+                { id: "hookId", type: "text", message: "Hook id", required: true },
+                {
+                    id: "registry",
+                    type: "text",
+                    message: "Registry id",
+                    required: false,
+                },
+            ];
+        case "add.settings":
+            return [
+                {
+                    id: "provider",
+                    type: "select",
+                    message: "Provider",
+                    options: providers,
+                },
+                {
+                    id: "registry",
+                    type: "text",
+                    message: "Registry id",
+                    required: false,
+                },
+            ];
+        case "add.command":
+            return [
+                {
+                    id: "commandId",
+                    type: "text",
+                    message: "Command id",
+                    required: true,
+                },
+                {
+                    id: "registry",
+                    type: "text",
+                    message: "Registry id",
+                    required: false,
+                },
+            ];
+        case "remove":
+            return [
+                {
+                    id: "entityType",
+                    type: "select",
+                    message: "Entity type",
+                    options: entityTypes,
+                },
+                { id: "id", type: "text", message: "Entity id", required: true },
+                {
+                    id: "deleteSource",
+                    type: "confirm",
+                    message: "Delete source files too?",
+                    initial: true,
+                },
+            ];
+        case "migrate":
+            return [
+                {
+                    id: "dryRun",
+                    type: "confirm",
+                    message: "Run as dry-run only?",
+                    initial: false,
+                },
+            ];
+        default:
+            return [];
     }
-    return value;
 }
-async function promptOptionalText(message) {
-    const value = await text({
-        message,
-        placeholder: "optional",
-    });
-    const resolved = getSelectedValue(value);
-    if (resolved === null) {
-        return null;
-    }
-    if (typeof resolved !== "string") {
+// ---------------------------------------------------------------------------
+// Build CommandInput from collected values
+// ---------------------------------------------------------------------------
+function buildCommandInput(commandId, values) {
+    const str = (k) => {
+        const v = values[k];
+        if (typeof v === "string") {
+            const t = v.trim();
+            return t.length > 0 ? t : undefined;
+        }
         return undefined;
-    }
-    const trimmed = resolved.trim();
-    return trimmed.length > 0 ? trimmed : undefined;
-}
-async function promptRequiredText(message) {
-    const value = await text({
-        message,
-        validate: (entry) => (!entry || entry.trim().length === 0 ? "This value is required" : undefined),
-    });
-    const resolved = getSelectedValue(value);
-    if (resolved === null) {
-        return null;
-    }
-    return String(resolved);
-}
-async function promptCommandInput(command) {
-    switch (command) {
-        case "init": {
-            const force = await confirm({
-                message: "Overwrite existing .harness workspace if present?",
-                initialValue: false,
-            });
-            const resolvedForce = getSelectedValue(force);
-            if (resolvedForce === null) {
-                return null;
-            }
-            const presets = (await listBuiltinPresets()).map((preset) => summarizePreset(preset));
-            const preset = await select({
-                message: "Select a preset to apply during init",
-                options: [
-                    { value: "", label: "Skip preset" },
-                    ...presets.map((entry) => ({
-                        value: entry.id,
-                        label: `${entry.name} (${entry.id})`,
-                    })),
-                ],
-            });
-            const resolvedPreset = getSelectedValue(preset);
-            if (resolvedPreset === null) {
-                return null;
-            }
-            let delegate;
-            if (String(resolvedPreset) === "delegate") {
-                const delegateProvider = await select({
-                    message: "Select the provider CLI to delegate prompt authoring to",
-                    options: providerIdSchema.options.map((entry) => ({
-                        value: entry,
-                        label: entry,
-                    })),
-                });
-                const resolvedDelegateProvider = getSelectedValue(delegateProvider);
-                if (resolvedDelegateProvider === null) {
-                    return null;
-                }
-                delegate = String(resolvedDelegateProvider);
-            }
+    };
+    const bool = (k, fallback = false) => {
+        const v = values[k];
+        return typeof v === "boolean" ? v : fallback;
+    };
+    switch (commandId) {
+        case "init":
             return {
-                command,
+                command: commandId,
                 options: {
-                    force: Boolean(resolvedForce),
-                    preset: String(resolvedPreset) || undefined,
-                    delegate,
+                    force: bool("force"),
+                    preset: str("preset"),
+                    delegate: str("delegate"),
                 },
             };
-        }
         case "provider.enable":
-        case "provider.disable": {
-            const provider = await select({
-                message: "Select provider",
-                options: providerIdSchema.options.map((entry) => ({
-                    value: entry,
-                    label: entry,
-                })),
-            });
-            const resolvedProvider = getSelectedValue(provider);
-            if (resolvedProvider === null) {
-                return null;
-            }
-            return {
-                command,
-                args: {
-                    provider: String(resolvedProvider),
-                },
-            };
-        }
-        case "registry.add": {
-            const name = await promptRequiredText("Registry name");
-            if (name === null) {
-                return null;
-            }
-            const gitUrl = await promptRequiredText("Git URL");
-            if (gitUrl === null) {
-                return null;
-            }
-            const ref = await promptOptionalText("Git ref (default: main)");
-            if (ref === null) {
-                return null;
-            }
-            const root = await promptOptionalText("Registry root path");
-            if (root === null) {
-                return null;
-            }
-            const tokenEnv = await promptOptionalText("Token env var");
-            if (tokenEnv === null) {
-                return null;
-            }
+        case "provider.disable":
+            return { command: commandId, args: { provider: str("provider") } };
+        case "registry.add":
             return {
-                command,
-                args: {
-                    name,
-                },
+                command: commandId,
+                args: { name: str("name") },
                 options: {
-                    gitUrl,
-                    ref,
-                    root,
-                    tokenEnv,
+                    gitUrl: str("gitUrl"),
+                    ref: str("ref"),
+                    root: str("root"),
+                    tokenEnv: str("tokenEnv"),
                 },
             };
-        }
         case "registry.remove":
-        case "registry.default.set": {
-            const name = await promptRequiredText("Registry name");
-            if (name === null) {
-                return null;
-            }
+        case "registry.default.set":
+            return { command: commandId, args: { name: str("name") } };
+        case "registry.pull":
             return {
-                command,
-                args: {
-                    name,
-                },
+                command: commandId,
+                args: { entityType: str("entityType"), id: str("id") },
+                options: { registry: str("registry"), force: bool("force") },
             };
-        }
-        case "registry.pull": {
-            const entityType = await select({
-                message: "Entity type filter",
-                options: [
-                    { value: "", label: "All entity types" },
-                    ...CLI_ENTITY_TYPES.map((entry) => ({ value: entry, label: entry })),
-                ],
-            });
-            const resolvedEntityType = getSelectedValue(entityType);
-            if (resolvedEntityType === null) {
-                return null;
-            }
-            const id = await promptOptionalText("Entity id filter");
-            if (id === null) {
-                return null;
-            }
-            const registry = await promptOptionalText("Registry filter");
-            if (registry === null) {
-                return null;
-            }
-            const force = await confirm({
-                message: "Overwrite locally modified imported sources?",
-                initialValue: false,
-            });
-            const resolvedForce = getSelectedValue(force);
-            if (resolvedForce === null) {
-                return null;
-            }
+        case "preset.list":
+            return { command: commandId, options: { registry: str("registry") } };
+        case "preset.describe":
+        case "preset.apply":
             return {
-                command,
-                args: {
-                    entityType: String(resolvedEntityType) || undefined,
-                    id,
-                },
-                options: {
-                    registry,
-                    force: Boolean(resolvedForce),
-                },
+                command: commandId,
+                args: { presetId: str("presetId") },
+                options: { registry: str("registry") },
             };
-        }
-        case "preset.list": {
-            const registry = await promptOptionalText("Registry id");
-            if (registry === null) {
-                return null;
-            }
+        case "add.prompt":
+            return { command: commandId, options: { registry: str("registry") } };
+        case "add.skill":
             return {
-                command,
-                options: {
-                    registry,
-                },
+                command: commandId,
+                args: { skillId: str("skillId") },
+                options: { registry: str("registry") },
             };
-        }
-        case "preset.describe":
-        case "preset.apply": {
-            const presetId = await promptRequiredText("Preset id");
-            if (presetId === null) {
-                return null;
-            }
-            const registry = await promptOptionalText("Registry id");
-            if (registry === null) {
-                return null;
-            }
+        case "add.mcp":
             return {
-                command,
-                args: {
-                    presetId,
-                },
-                options: {
-                    registry,
-                },
+                command: commandId,
+                args: { configId: str("configId") },
+                options: { registry: str("registry") },
             };
-        }
-        case "add.prompt": {
-            const registry = await promptOptionalText("Registry id");
-            if (registry === null) {
-                return null;
-            }
+        case "add.subagent":
             return {
-                command,
-                options: {
-                    registry,
-                },
+                command: commandId,
+                args: { subagentId: str("subagentId") },
+                options: { registry: str("registry") },
             };
-        }
-        case "add.skill": {
-            const skillId = await promptRequiredText("Skill id");
-            if (skillId === null) {
-                return null;
-            }
-            const registry = await promptOptionalText("Registry id");
-            if (registry === null) {
-                return null;
-            }
+        case "add.hook":
             return {
-                command,
-                args: {
-                    skillId,
-                },
-                options: {
-                    registry,
-                },
+                command: commandId,
+                args: { hookId: str("hookId") },
+                options: { registry: str("registry") },
             };
-        }
-        case "add.mcp": {
-            const configId = await promptRequiredText("MCP config id");
-            if (configId === null) {
-                return null;
-            }
-            const registry = await promptOptionalText("Registry id");
-            if (registry === null) {
-                return null;
-            }
+        case "add.settings":
             return {
-                command,
-                args: {
-                    configId,
-                },
-                options: {
-                    registry,
-                },
+                command: commandId,
+                args: { provider: str("provider") },
+                options: { registry: str("registry") },
             };
-        }
-        case "add.subagent": {
-            const subagentId = await promptRequiredText("Subagent id");
-            if (subagentId === null) {
-                return null;
-            }
-            const registry = await promptOptionalText("Registry id");
-            if (registry === null) {
-                return null;
-            }
+        case "add.command":
             return {
-                command,
-                args: {
-                    subagentId,
-                },
-                options: {
-                    registry,
-                },
+                command: commandId,
+                args: { commandId: str("commandId") },
+                options: { registry: str("registry") },
             };
-        }
-        case "add.hook": {
-            const hookId = await promptRequiredText("Hook id");
-            if (hookId === null) {
-                return null;
-            }
-            const registry = await promptOptionalText("Registry id");
-            if (registry === null) {
-                return null;
-            }
+        case "remove":
             return {
-                command,
-                args: {
-                    hookId,
-                },
-                options: {
-                    registry,
-                },
+                command: commandId,
+                args: { entityType: str("entityType"), id: str("id") },
+                options: { deleteSource: bool("deleteSource", true) },
             };
-        }
-        case "add.settings": {
-            const provider = await select({
-                message: "Provider",
-                options: providerIdSchema.options.map((entry) => ({
-                    value: entry,
-                    label: entry,
-                })),
-            });
-            const resolvedProvider = getSelectedValue(provider);
-            if (resolvedProvider === null) {
-                return null;
-            }
-            const registry = await promptOptionalText("Registry id");
-            if (registry === null) {
-                return null;
-            }
+        case "migrate":
             return {
-                command,
-                args: {
-                    provider: String(resolvedProvider),
-                },
-                options: {
-                    registry,
-                },
+                command: commandId,
+                options: { to: "latest", dryRun: bool("dryRun") },
             };
+        default:
+            return { command: commandId };
+    }
+}
+function initialStepFromStatus(status) {
+    if (!status || status.state === "healthy")
+        return { type: "select-command" };
+    if (status.state === "missing")
+        return { type: "onboarding" };
+    return { type: "workspace-warning", diagnostics: status.diagnostics };
+}
+export function App({ api, presets, workspaceStatus, onExit }) {
+    const { exit } = useApp();
+    const [step, setStep] = useState(() => initialStepFromStatus(workspaceStatus));
+    const [pastLines, setPastLines] = useState([{ id: 0, text: "Harness interactive mode" }]);
+    const nextLineId = useRef(1);
+    const [exitCode, setExitCode] = useState(0);
+    const addPastLine = useCallback((text) => {
+        const id = nextLineId.current++;
+        setPastLines((prev) => [...prev, { id, text }]);
+    }, []);
+    // FIX 2: Transition out of prompt-input when all prompts are answered via useEffect,
+    // not during render. Renders must be pure — no state updates allowed.
+    useEffect(() => {
+        if (step.type !== "prompt-input")
+            return;
+        const { commandId, collector } = step;
+        if (collector.prompts[collector.index])
+            return;
+        const input = buildCommandInput(commandId, collector.values);
+        setStep(getCommandDefinition(commandId).mutatesWorkspace
+            ? { type: "confirm-run", commandId, input }
+            : { type: "running", commandId, input });
+    }, [step]);
+    useEffect(() => {
+        if (step.type === "done") {
+            onExit(exitCode);
+            exit();
         }
-        case "add.command": {
-            const commandId = await promptRequiredText("Command id");
-            if (commandId === null) {
-                return null;
-            }
-            const registry = await promptOptionalText("Registry id");
-            if (registry === null) {
-                return null;
-            }
-            return {
-                command,
-                args: {
+    }, [step, exitCode, exit, onExit]);
+    const renderCurrentStep = () => {
+        if (step.type === "onboarding") {
+            return (_jsx(OnboardingWizard, { api: api, presets: presets, onComplete: () => {
+                    addPastLine("Onboarding complete.");
+                    setStep({ type: "select-command" });
+                } }));
+        }
+        if (step.type === "workspace-warning") {
+            return (_jsx(WorkspaceWarningStep, { diagnostics: step.diagnostics, api: api, onDismiss: () => setStep({ type: "select-command" }) }));
+        }
+        if (step.type === "select-command") {
+            return (_jsx(Box, { marginTop: 1, children: _jsx(AutocompleteSelect, { label: "Command", options: COMMAND_OPTIONS, onChange: (value) => {
+                        if (value === "exit") {
+                            addPastLine("Interactive session ended.");
+                            setStep({ type: "done" });
+                            return;
+                        }
+                        const commandId = value;
+                        const prompts = buildPromptsForCommand(commandId, presets);
+                        setStep({
+                            type: "prompt-input",
+                            commandId,
+                            collector: { prompts, values: {}, index: 0 },
+                        });
+                    } }, "select-command") }));
+        }
+        if (step.type === "prompt-input") {
+            const { commandId, collector } = step;
+            const prompt = collector.prompts[collector.index];
+            // Effect above handles the transition when prompts are exhausted
+            if (!prompt)
+                return null;
+            const advanceWith = (value) => {
+                const newValues = { ...collector.values, [prompt.id]: value };
+                let newPrompts = collector.prompts;
+                // Dynamically inject delegate-provider prompt when "delegate" preset is selected
+                if (commandId === "init" && prompt.id === "preset" && value === "delegate") {
+                    const delegatePrompt = {
+                        id: "delegate",
+                        type: "select",
+                        message: "Select the provider CLI to delegate prompt authoring to",
+                        options: providerIdSchema.options.map((p) => ({
+                            label: p,
+                            value: p,
+                        })),
+                    };
+                    newPrompts = [
+                        ...collector.prompts.slice(0, collector.index + 1),
+                        delegatePrompt,
+                        ...collector.prompts.slice(collector.index + 1),
+                    ];
+                }
+                setStep({
+                    type: "prompt-input",
                     commandId,
-                },
-                options: {
-                    registry,
-                },
+                    collector: {
+                        prompts: newPrompts,
+                        values: newValues,
+                        index: collector.index + 1,
+                    },
+                });
             };
-        }
-        case "remove": {
-            const entityType = await select({
-                message: "Entity type",
-                options: CLI_ENTITY_TYPES.map((entry) => ({
-                    value: entry,
-                    label: entry,
-                })),
-            });
-            const resolvedEntityType = getSelectedValue(entityType);
-            if (resolvedEntityType === null) {
-                return null;
+            const cancelPrompt = () => {
+                addPastLine("Cancelled command input.");
+                setStep({ type: "select-command" });
+            };
+            if (prompt.type === "text") {
+                return (_jsx(TextPrompt, { message: prompt.message, required: prompt.required, onSubmit: advanceWith, onCancel: cancelPrompt }, `${commandId}-${collector.index}`));
             }
-            const id = await promptRequiredText("Entity id");
-            if (id === null) {
-                return null;
+            if (prompt.type === "confirm") {
+                return (_jsx(ToggleConfirm, { message: prompt.message, defaultValue: prompt.initial, onSubmit: advanceWith, onEscape: cancelPrompt }));
             }
-            const deleteSource = await confirm({
-                message: "Delete source files too?",
-                initialValue: true,
-            });
-            const resolvedDeleteSource = getSelectedValue(deleteSource);
-            if (resolvedDeleteSource === null) {
-                return null;
+            if (prompt.type === "select") {
+                return (_jsx(Box, { marginTop: 1, children: _jsx(AutocompleteSelect, { label: prompt.message, options: prompt.options, onChange: (value) => advanceWith(value), onCancel: cancelPrompt }, `${commandId}-${collector.index}`) }));
             }
-            return {
-                command,
-                args: {
-                    entityType: String(resolvedEntityType),
-                    id,
-                },
-                options: {
-                    deleteSource: Boolean(resolvedDeleteSource),
-                },
-            };
         }
-        case "migrate": {
-            const dryRun = await confirm({
-                message: "Run as dry-run only?",
-                initialValue: false,
-            });
-            const resolvedDryRun = getSelectedValue(dryRun);
-            if (resolvedDryRun === null) {
-                return null;
-            }
-            return {
-                command,
-                options: {
-                    to: "latest",
-                    dryRun: Boolean(resolvedDryRun),
-                },
-            };
+        if (step.type === "confirm-run") {
+            const { commandId, input } = step;
+            const label = getCommandDefinition(commandId).interactiveLabel ?? commandId;
+            return (_jsx(ToggleConfirm, { message: `Run '${label}' now?`, defaultValue: true, onSubmit: (confirmed) => {
+                    if (confirmed) {
+                        setStep({ type: "running", commandId, input });
+                    }
+                    else {
+                        addPastLine("Cancelled command execution.");
+                        setStep({ type: "select-command" });
+                    }
+                } }));
         }
-        default:
-            return { command };
-    }
+        if (step.type === "show-output") {
+            return (_jsx(OutputStep, { label: step.label, lines: step.lines, isError: step.isError, onDismiss: () => setStep({ type: "select-command" }) }));
+        }
+        if (step.type === "running") {
+            const { commandId, input } = step;
+            const label = getCommandDefinition(commandId).interactiveLabel ?? commandId;
+            return (_jsx(RunningStep, { label: label, input: input, api: api, onDone: (output, code) => {
+                    if (code !== 0)
+                        setExitCode(code);
+                    const lines = [];
+                    renderTextOutput(output, (line) => lines.push(line));
+                    setStep({ type: "show-output", label, lines, isError: code !== 0 });
+                }, onError: (message) => {
+                    setExitCode(1);
+                    setStep({
+                        type: "show-output",
+                        label,
+                        lines: [`Error: ${message}`],
+                        isError: true,
+                    });
+                } }));
+        }
+        return null;
+    };
+    // FIX 1: A single Static at the root — never unmounts, never re-renders old items.
+    // Step-specific content renders below it.
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: pastLines, children: (line) => _jsx(Text, { children: line.text }, line.id) }), renderCurrentStep()] }));
 }
-function requiresConfirmation(command) {
-    return getCommandDefinition(command).mutatesWorkspace;
+function TextPrompt({ message, required, onSubmit, onCancel }) {
+    const [error, setError] = useState(false);
+    useInput((_input, key) => {
+        if (key.escape)
+            onCancel();
+        else if (error && !key.return)
+            setError(false);
+    });
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { children: [_jsxs(Text, { dimColor: true, children: [message, ": "] }), _jsx(TextInput, { placeholder: required ? "" : "optional", onSubmit: (value) => {
+                            if (required && value.trim().length === 0) {
+                                setError(true);
+                                return;
+                            }
+                            onSubmit(value);
+                        } })] }), error && _jsx(Text, { color: "red", children: "  This value is required" })] }));
 }
-export async function runInteractiveAdapter(context, api) {
-    intro("Harness interactive mode");
-    let exitCode = 0;
-    while (true) {
-        const commandOptions = [
-            ...INTERACTIVE_COMMAND_IDS.map((id) => ({
-                value: id,
-                label: getCommandDefinition(id).interactiveLabel ?? getCommandDefinition(id).description,
-            })),
-            {
-                value: "exit",
-                label: "Exit",
-            },
-        ];
-        // @clack/prompts distributes the generic over the union, requiring a type assertion here
-        const command = await select({
-            message: "Select a command",
-            options: commandOptions,
+function OutputStep({ label, lines, isError, onDismiss }) {
+    useInput((_input, key) => {
+        if (key.return)
+            onDismiss();
+    });
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, color: isError ? "red" : "green", children: isError ? `✗ ${label}` : `✓ ${label}` }), _jsx(Box, { flexDirection: "column", marginLeft: 2, marginTop: 1, children: _jsx(Text, { children: lines.join("\n") }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press Enter to continue..." }) })] }));
+}
+function RunningStep({ label, input, api, onDone, onError }) {
+    const callbacks = useRef({ onDone, onError });
+    callbacks.current = { onDone, onError };
+    useEffect(() => {
+        api
+            .execute(input)
+            .then((output) => {
+            callbacks.current.onDone(output, output.exitCode);
+        })
+            .catch((err) => {
+            callbacks.current.onError(err instanceof Error ? err.message : String(err));
         });
-        const resolvedCommand = getSelectedValue(command);
-        if (resolvedCommand === null || resolvedCommand === "exit") {
-            break;
+    }, [api, input]);
+    return (_jsx(Box, { marginTop: 1, children: _jsx(Spinner, { label: `Running ${label}...` }) }));
+}
+// ---------------------------------------------------------------------------
+// OnboardingWizard — full guided setup for new workspaces
+// ---------------------------------------------------------------------------
+const HARNESS_LOGO = `   __ __
+  / // /__ ________  ___ ___ ___
+ / _  / _ \`/ __/ _ \\/ -_|_-<(_-<
+/_//_/\\_,_/_/ /_//_/\\__/___/___/`;
+const HARNESS_TAGLINE = "Configure your AI coding agents from a single source of truth.";
+function OnboardingWizard({ api, presets, onComplete }) {
+    const [subStep, setSubStep] = useState({
+        type: "welcome",
+    });
+    const [revealIndex, setRevealIndex] = useState(0);
+    const [animationDone, setAnimationDone] = useState(false);
+    const summaryRef = useRef([]);
+    const runningRef = useRef(false);
+    const fullText = `${HARNESS_LOGO}\n\n  ${HARNESS_TAGLINE}`;
+    // Animated typing effect for welcome screen
+    useEffect(() => {
+        if (subStep.type !== "welcome")
+            return;
+        if (revealIndex >= fullText.length) {
+            setAnimationDone(true);
+            return;
         }
-        const parsedCommand = String(resolvedCommand);
-        const input = await promptCommandInput(parsedCommand);
-        if (input === null) {
-            cancel("Cancelled command input.");
-            continue;
+        const timer = setTimeout(() => setRevealIndex((i) => i + 1), revealIndex === 0 ? 100 : 8);
+        return () => clearTimeout(timer);
+    }, [subStep.type, revealIndex, fullText.length]);
+    useInput((_input, key) => {
+        if (subStep.type === "welcome" && key.return) {
+            if (!animationDone) {
+                setRevealIndex(fullText.length);
+                setAnimationDone(true);
+            }
+            else {
+                setSubStep({ type: "preset" });
+            }
         }
-        if (requiresConfirmation(parsedCommand)) {
-            const shouldRun = await confirm({
-                message: `Run '${getCommandDefinition(parsedCommand).interactiveLabel ?? parsedCommand}' now?`,
-                initialValue: true,
+    });
+    // Single effect for all async onboarding actions, guarded by ref.
+    // Uses else-if so only one branch can fire per render cycle.
+    useEffect(() => {
+        if (runningRef.current)
+            return;
+        if (subStep.type === "running-init") {
+            runningRef.current = true;
+            api
+                .execute({
+                command: "init",
+                options: {
+                    force: false,
+                    preset: subStep.preset,
+                    delegate: subStep.delegate,
+                },
+            })
+                .then((output) => {
+                if (output.exitCode !== 0) {
+                    const lines = [];
+                    renderTextOutput(output, (line) => lines.push(line));
+                    setSubStep({
+                        type: "init-error",
+                        message: lines.join("\n"),
+                        preset: subStep.preset,
+                        delegate: subStep.delegate,
+                    });
+                    return;
+                }
+                summaryRef.current.push("Initialized .harness/ workspace");
+                if (subStep.preset)
+                    summaryRef.current.push(`Applied preset: ${subStep.preset}`);
+                setSubStep({ type: "providers", selected: [] });
+            })
+                .catch((err) => {
+                setSubStep({
+                    type: "init-error",
+                    message: err instanceof Error ? err.message : String(err),
+                    preset: subStep.preset,
+                    delegate: subStep.delegate,
+                });
+            })
+                .finally(() => {
+                runningRef.current = false;
             });
-            const resolvedShouldRun = getSelectedValue(shouldRun);
-            if (resolvedShouldRun === null) {
-                cancel("Cancelled command execution.");
-                continue;
-            }
-            if (!resolvedShouldRun) {
-                continue;
-            }
         }
-        const startedAt = context.now();
-        const spinner = ora({
-            text: `Running ${getCommandDefinition(parsedCommand).interactiveLabel ?? parsedCommand}...`,
-        }).start();
-        try {
-            const output = await api.execute(input);
-            const durationMs = context.now() - startedAt;
-            spinner.succeed("Done.");
-            api.renderOutput(output, durationMs, false);
-            if (output.exitCode !== 0) {
-                exitCode = output.exitCode;
-            }
+        else if (subStep.type === "running-providers") {
+            runningRef.current = true;
+            const { selected } = subStep;
+            (async () => {
+                for (const provider of selected) {
+                    await api.execute({ command: "provider.enable", args: { provider } });
+                }
+                summaryRef.current.push(`Enabled provider(s): ${selected.join(", ")}`);
+                setSubStep({ type: "add-prompt" });
+            })()
+                .catch((err) => {
+                summaryRef.current.push(`Warning: provider enablement failed (${err instanceof Error ? err.message : String(err)})`);
+                setSubStep({ type: "add-prompt" });
+            })
+                .finally(() => {
+                runningRef.current = false;
+            });
         }
-        catch (error) {
-            spinner.fail("Command failed.");
-            context.stderr(`Error: ${toErrorMessage(error)}`);
-            exitCode = 1;
+        else if (subStep.type === "running-add-prompt") {
+            runningRef.current = true;
+            api
+                .execute({ command: "add.prompt" })
+                .then(() => {
+                summaryRef.current.push("Added system prompt entity");
+                setSubStep({ type: "running-apply" });
+            })
+                .catch((err) => {
+                summaryRef.current.push(`Warning: failed to add prompt (${err instanceof Error ? err.message : String(err)})`);
+                setSubStep({ type: "running-apply" });
+            })
+                .finally(() => {
+                runningRef.current = false;
+            });
         }
+        else if (subStep.type === "running-apply") {
+            runningRef.current = true;
+            api
+                .execute({ command: "apply" })
+                .then(() => {
+                summaryRef.current.push("Applied workspace (generated provider artifacts)");
+                setSubStep({ type: "complete", summary: summaryRef.current });
+            })
+                .catch((err) => {
+                summaryRef.current.push(`Warning: apply failed (${err instanceof Error ? err.message : String(err)})`);
+                setSubStep({ type: "complete", summary: summaryRef.current });
+            })
+                .finally(() => {
+                runningRef.current = false;
+            });
+        }
+    }, [subStep, api]);
+    if (subStep.type === "welcome") {
+        return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: "cyan", children: fullText.slice(0, revealIndex) }), animationDone && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press Enter to get started..." }) }))] }));
+    }
+    if (subStep.type === "preset") {
+        const presetOptions = [
+            { value: "", label: "Skip preset" },
+            ...presets.map((p) => ({ value: p.id, label: `${p.name} (${p.id})` })),
+        ];
+        return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, children: "Step 1/4 \u2014 Choose a preset" }), _jsx(Box, { marginTop: 1, children: _jsx(AutocompleteSelect, { label: "Preset", options: presetOptions, onChange: (value) => {
+                            if (value === "delegate") {
+                                setSubStep({ type: "delegate-provider" });
+                            }
+                            else {
+                                setSubStep({
+                                    type: "running-init",
+                                    preset: value || undefined,
+                                });
+                            }
+                        } }, "onboarding-preset") })] }));
+    }
+    if (subStep.type === "delegate-provider") {
+        const providers = providerIdSchema.options.map((p) => ({
+            label: p,
+            value: p,
+        }));
+        return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, children: "Step 1/4 \u2014 Select delegate provider" }), _jsx(Box, { marginTop: 1, children: _jsx(AutocompleteSelect, { label: "Provider", options: providers, onChange: (value) => {
+                            setSubStep({
+                                type: "running-init",
+                                preset: "delegate",
+                                delegate: value,
+                            });
+                        } }, "onboarding-delegate") })] }));
+    }
+    if (subStep.type === "running-init") {
+        return (_jsx(Box, { marginTop: 1, children: _jsx(Spinner, { label: "Initializing workspace..." }) }));
+    }
+    if (subStep.type === "init-error") {
+        return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, color: "red", children: "Initialization failed" }), _jsx(Box, { marginLeft: 2, marginTop: 1, children: _jsx(Text, { children: subStep.message }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Please resolve the issue and try again." }) }), _jsx(Box, { marginTop: 1, children: _jsx(AutocompleteSelect, { label: "Action", options: [
+                            { label: "Retry initialization", value: "retry" },
+                            { label: "Back", value: "back" },
+                            { label: "Continue to main menu", value: "continue" },
+                        ], onChange: (value) => {
+                            if (value === "retry") {
+                                setSubStep({
+                                    type: "running-init",
+                                    preset: subStep.preset,
+                                    delegate: subStep.delegate,
+                                });
+                                return;
+                            }
+                            if (value === "back") {
+                                if (subStep.preset === "delegate") {
+                                    setSubStep({ type: "delegate-provider" });
+                                }
+                                else {
+                                    setSubStep({ type: "preset" });
+                                }
+                                return;
+                            }
+                            onComplete();
+                        } }, "onboarding-init-error-action") })] }));
+    }
+    if (subStep.type === "providers") {
+        const remaining = providerIdSchema.options
+            .filter((p) => !subStep.selected.includes(p))
+            .map((p) => ({ label: p, value: p }));
+        const doneLabel = subStep.selected.length === 0 ? "Skip (enable later)" : `Done (${subStep.selected.join(", ")})`;
+        return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, children: "Step 2/4 \u2014 Enable providers" }), subStep.selected.length > 0 && _jsxs(Text, { dimColor: true, children: ["Selected: ", subStep.selected.join(", ")] }), _jsx(Box, { marginTop: 1, children: _jsx(AutocompleteSelect, { label: "Provider", options: [{ label: doneLabel, value: "" }, ...remaining], onChange: (value) => {
+                            if (!value) {
+                                if (subStep.selected.length === 0) {
+                                    setSubStep({ type: "add-prompt" });
+                                }
+                                else {
+                                    setSubStep({
+                                        type: "running-providers",
+                                        selected: subStep.selected,
+                                    });
+                                }
+                            }
+                            else {
+                                setSubStep({
+                                    type: "providers",
+                                    selected: [...subStep.selected, value],
+                                });
+                            }
+                        } }, `onboarding-providers-${subStep.selected.length}`) })] }));
     }
-    outro("Interactive session ended.");
-    return { exitCode };
+    if (subStep.type === "running-providers") {
+        return (_jsx(Box, { marginTop: 1, children: _jsx(Spinner, { label: `Enabling provider(s): ${subStep.selected.join(", ")}...` }) }));
+    }
+    if (subStep.type === "add-prompt") {
+        return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, children: "Step 3/4 \u2014 System prompt" }), _jsx(ToggleConfirm, { message: "Add a system prompt entity?", defaultValue: true, onSubmit: (yes) => {
+                        if (yes) {
+                            setSubStep({ type: "running-add-prompt" });
+                        }
+                        else {
+                            setSubStep({ type: "running-apply" });
+                        }
+                    } })] }));
+    }
+    if (subStep.type === "running-add-prompt") {
+        return (_jsx(Box, { marginTop: 1, children: _jsx(Spinner, { label: "Adding system prompt..." }) }));
+    }
+    if (subStep.type === "running-apply") {
+        return (_jsx(Box, { marginTop: 1, children: _jsx(Spinner, { label: "Step 4/4 \u2014 Applying workspace..." }) }));
+    }
+    if (subStep.type === "complete") {
+        return _jsx(OnboardingComplete, { summary: subStep.summary, onDismiss: onComplete });
+    }
+    return null;
+}
+function OnboardingComplete({ summary, onDismiss }) {
+    useInput((_input, key) => {
+        if (key.return)
+            onDismiss();
+    });
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, color: "green", children: "Setup complete!" }), summary.length > 0 && (_jsx(Box, { flexDirection: "column", marginLeft: 2, marginTop: 1, children: summary.map((line, i) => (
+                // biome-ignore lint/suspicious/noArrayIndexKey: static list, never reordered
+                _jsxs(Text, { dimColor: true, children: ["- ", line] }, i))) })), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press Enter to continue to the main menu..." }) })] }));
+}
+function WorkspaceWarningStep({ diagnostics, api, onDismiss }) {
+    const [running, setRunning] = useState(false);
+    const [output, setOutput] = useState(null);
+    const runningRef = useRef(false);
+    useEffect(() => {
+        if (!running || runningRef.current)
+            return;
+        runningRef.current = true;
+        api
+            .execute({ command: "doctor" })
+            .then((result) => {
+            const lines = [];
+            renderTextOutput(result, (line) => lines.push(line));
+            setOutput({ lines, isError: result.exitCode !== 0 });
+        })
+            .catch((err) => {
+            setOutput({
+                lines: [err instanceof Error ? err.message : String(err)],
+                isError: true,
+            });
+        })
+            .finally(() => {
+            runningRef.current = false;
+            setRunning(false);
+        });
+    }, [running, api]);
+    useInput((_input, key) => {
+        if (output && key.return)
+            onDismiss();
+    });
+    if (running) {
+        return (_jsx(Box, { marginTop: 1, children: _jsx(Spinner, { label: "Running doctor..." }) }));
+    }
+    if (output) {
+        return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, color: output.isError ? "red" : "green", children: output.isError ? "✗ Doctor" : "✓ Doctor" }), _jsx(Box, { flexDirection: "column", marginLeft: 2, marginTop: 1, children: _jsx(Text, { children: output.lines.join("\n") }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press Enter to continue..." }) })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, color: "yellow", children: "Workspace issues detected" }), _jsx(Box, { flexDirection: "column", marginLeft: 2, marginTop: 1, children: diagnostics.map((d) => (_jsxs(Text, { children: [_jsxs(Text, { color: "yellow", children: ["[", d.severity, "]"] }), " ", d.code, ": ", d.message] }, d.code))) }), _jsx(Box, { marginTop: 1, children: _jsx(AutocompleteSelect, { label: "Action", options: [
+                        { label: "Run doctor", value: "doctor" },
+                        { label: "Continue to menu", value: "continue" },
+                    ], onChange: (value) => {
+                        if (value === "doctor") {
+                            setRunning(true);
+                        }
+                        else {
+                            onDismiss();
+                        }
+                    } }, "workspace-warning") })] }));
+}
+// ---------------------------------------------------------------------------
+// Exported entry point
+// ---------------------------------------------------------------------------
+export async function runInteractiveAdapter(api, options) {
+    const cwd = options?.cwd ?? process.cwd();
+    const [presets, workspaceStatus] = await Promise.all([
+        listBuiltinPresets().then((ps) => ps.map(summarizePreset)),
+        detectWorkspaceStatus(cwd),
+    ]);
+    let resolvedExitCode = 0;
+    const { waitUntilExit } = render(_jsx(App, { api: api, presets: presets, workspaceStatus: workspaceStatus, onExit: (code) => {
+            resolvedExitCode = code;
+        } }), { exitOnCtrlC: true });
+    await waitUntilExit();
+    return { exitCode: resolvedExitCode };
 }
 //# sourceMappingURL=interactive.js.map