codedeck 0.6.0 → 0.7.1

package/dist/cli/commands/setup.js

@@ -9,7 +9,11 @@ import { getCliName } from "../cli-name.js";
 import { getRegistry } from "../../drivers/registry.js";
 import { ROLES } from "../../core/roles.js";
 import { getPaths } from "../../config/paths.js";
-import { BALANCED_PRESET, baseConfig, DISPATCHER_PRESET, EXPLORER_PRESET, getProfileSnapshot, ORCHESTRATOR_PRESETS, createSetupConfigStore, DEFAULT_CONFIG, extractProfileSnapshot, isOrchestratorMode, loadConfig, orchestratorModeLabel, parseProfileName, resolveEffectiveConfig, resolveOrchestratorMode, saveConfig, serializeConfig, } from "../../config/config.js";
+import { buildSetupPlan, diffConfig, SetupUsageError, validateBindings, } from "../../config/setup.js";
+import { BALANCED_PRESET, DISPATCHER_PRESET, EXPLORER_PRESET, ORCHESTRATOR_PRESETS, createSetupConfigStore, DEFAULT_CONFIG, isOrchestratorMode, loadConfig, orchestratorModeLabel, resolveOrchestratorMode, saveConfig, serializeConfig, } from "../../config/config.js";
+import { parseOptionalWebPort } from "../../web/server.js";
+import { launchWebPage } from "../web-launch.js";
+export { diffConfig, SetupUsageError };
 const ORCHESTRATOR_SCREEN_ROLE = "orchestrator-mode";
 const ORCHESTRATOR_PICKER_GROUP = "orchestrator";
 const PARALLELISM_NONE = "none";
@@ -320,16 +324,8 @@ export function needsModelSetup(config, isTTY = isInteractiveTerminal()) {
         return false;
     // `agents` is what setup writes now. A config carrying only the older
     // per-harness `models` has never answered the per-role question, so it still
-    // counts as unset. The active profile answers too: its agents are the ones
-    // a launch would use.
-    if (config == null)
-        return true;
-    try {
-        return resolveEffectiveConfig(config).agents == null;
-    }
-    catch {
-        return config.agents == null;
-    }
+    // counts as unset.
+    return config?.agents == null;
 }
 /**
  * The catalog of every installed harness, flattened into one list.
@@ -476,7 +472,7 @@ function watchResize(listener) {
 }
 export async function runModelSetupWizard(options = {}) {
     const loaded = options.config ?? loadConfig();
-    const { profile, config } = resolveSetupTarget(loaded, options.profile);
+    const config = loaded;
     if (!(options.isTTY ?? isInteractiveTerminal()))
         return config;
     const output = options.output ?? process.stdout;
@@ -571,22 +567,22 @@ export async function runModelSetupWizard(options = {}) {
             return config;
         }
     }
-    const updatedConfig = { ...config, agents };
+    const selections = { agents };
     if (orchestrator !== undefined)
-        updatedConfig.orchestrator = orchestrator;
+        selections.orchestrator = orchestrator;
     const sandboxSelection = answeredResults.find((result) => result.role === SANDBOX_SCREEN_ROLE);
     if (sandboxSelection?.kind === "picked") {
         if (sandboxSelection.id === SANDBOX_OFF || sandboxSelection.id === SANDBOX_ON) {
-            updatedConfig.defaultSandbox = sandboxSelection.id;
+            selections.sandbox = sandboxSelection.id;
         }
     }
     const autocompactSelection = answeredResults.find((result) => result.role === AUTOCOMPACT_SCREEN_ROLE);
     if (autocompactSelection?.kind === "picked") {
         if (autocompactSelection.id === AUTOCOMPACT_ON) {
-            updatedConfig.autocompact = { ...config.autocompact, enabled: true };
+            selections.autocompact = { enabled: true };
         }
         else if (autocompactSelection.id === AUTOCOMPACT_OFF && config.autocompact !== undefined) {
-            updatedConfig.autocompact = { ...config.autocompact, enabled: false };
+            selections.autocompact = { enabled: false };
         }
     }
     // Per-role effort answers arrive as followups of their role screen, in the
@@ -601,16 +597,10 @@ export async function runModelSetupWizard(options = {}) {
             agents[target] = { ...agents[target], effort: result.id };
         }
     }
-    updatedConfig.agents = { ...agents };
-    const toSave = profile === undefined
-        ? updatedConfig
-        : {
-            ...loaded,
-            profiles: { ...loaded.profiles, [profile]: extractProfileSnapshot(updatedConfig) },
-        };
+    const { proposedConfig: updatedConfig } = buildSetupPlan(loaded, selections);
     let saved = false;
     try {
-        (options.save ?? saveConfig)(toSave);
+        (options.save ?? saveConfig)(updatedConfig);
         saved = true;
     }
     catch (error) {
@@ -631,32 +621,6 @@ export async function runModelSetupWizard(options = {}) {
     output.write(`\n  saved: ${summary}${modeSummary}\n\n`);
     return updatedConfig;
 }
-export class SetupUsageError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "SetupUsageError";
-    }
-}
-function resolveSetupTarget(loaded, explicitProfile) {
-    const isExplicit = explicitProfile !== undefined;
-    const profile = isExplicit
-        ? parseProfileName(explicitProfile)
-        : loaded.activeProfile === undefined || loaded.activeProfile.trim() === ""
-            ? undefined
-            : parseProfileName(loaded.activeProfile);
-    const snapshot = profile === undefined ? undefined : getProfileSnapshot(loaded, profile);
-    if (!isExplicit && profile !== undefined && snapshot === undefined) {
-        throw new SetupUsageError(`Active profile "${profile}" does not exist. Choose an existing profile with "codedeck profile use <name>" or pass --profile <name>.`);
-    }
-    return {
-        ...(profile === undefined ? {} : { profile }),
-        config: profile === undefined
-            ? loaded
-            : snapshot === undefined
-                ? { ...baseConfig(loaded), agents: {} }
-                : { ...baseConfig(loaded), ...snapshot },
-    };
-}
 function invalidBindMessage(value) {
     return `Invalid --bind "${value}": expected role=harness:model[:effort] (role: general|orchestrator|reviewer|auditor; harness: claude|codex|opencode|omp; model: non-empty and without whitespace, control characters or '='; effort: ${REASONING_EFFORTS.join("|")})`;
 }
@@ -703,34 +667,34 @@ export function parseSetupArgs(args) {
     let refresh = false;
     let nonInteractive = false;
     let dryRun = false;
-    let profile;
+    let tui = false;
+    let noOpen = false;
+    let port;
     for (let index = 0; index < args.length; index += 1) {
         const arg = args[index];
         if (arg === "--refresh") {
             refresh = true;
             continue;
         }
-        if (arg === "--profile") {
+        if (arg === "--tui") {
+            tui = true;
+            continue;
+        }
+        if (arg === "--no-open") {
+            noOpen = true;
+            continue;
+        }
+        if (arg === "--port") {
             const value = args[index + 1];
             if (value === undefined || isSetupFlag(value)) {
-                return parseError('Option "--profile" expects a name.', json);
+                return parseError('Option "--port" expects a port.', json);
             }
+            port = value;
             index += 1;
-            try {
-                profile = parseProfileName(value);
-            }
-            catch (error) {
-                return parseError(error instanceof Error ? error.message : String(error), json);
-            }
             continue;
         }
-        if (arg.startsWith("--profile=")) {
-            try {
-                profile = parseProfileName(arg.slice("--profile=".length));
-            }
-            catch (error) {
-                return parseError(error instanceof Error ? error.message : String(error), json);
-            }
+        if (arg.startsWith("--port=")) {
+            port = arg.slice("--port=".length);
             continue;
         }
         if (arg === "--non-interactive") {
@@ -771,6 +735,12 @@ export function parseSetupArgs(args) {
             return parseError(`Unknown option "${arg}".`, json);
         return parseError(`Unexpected argument "${arg}".`, json);
     }
+    const batch = nonInteractive || json || dryRun || binds.length > 0;
+    if (tui && batch)
+        return parseError('Option "--tui" cannot be used with batch setup flags.', json);
+    if (port !== undefined && (json || dryRun || nonInteractive)) {
+        return parseError('Option "--port" cannot be used with --json, --dry-run, or --non-interactive.', json);
+    }
     return {
         ok: true,
         options: {
@@ -778,9 +748,11 @@ export function parseSetupArgs(args) {
             nonInteractive,
             json,
             dryRun,
+            tui,
+            noOpen,
+            ...(port === undefined ? {} : { port }),
             binds,
-            batch: nonInteractive || json || dryRun || binds.length > 0,
-            ...(profile === undefined ? {} : { profile }),
+            batch,
         },
     };
 }
@@ -815,202 +787,6 @@ function emptyEnvelope(message, code, path) {
         resultado: { status: "error", code, saved: false, message },
     };
 }
-function jsonObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function jsonValue(value) {
-    if (value === undefined)
-        return null;
-    if (Array.isArray(value))
-        return value.map(jsonValue);
-    if (jsonObject(value)) {
-        return Object.fromEntries(Object.keys(value).sort((left, right) => left.localeCompare(right)).map((key) => [key, jsonValue(value[key])]));
-    }
-    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null) {
-        return value;
-    }
-    return null;
-}
-function jsonEqual(left, right) {
-    return JSON.stringify(jsonValue(left)) === JSON.stringify(jsonValue(right));
-}
-function pointerPart(value) {
-    return value.replaceAll("~", "~0").replaceAll("/", "~1");
-}
-function diffAt(output, pathValue, beforePresent, before, afterPresent, after, expandObjectChildren = false) {
-    const beforeObject = beforePresent && jsonObject(before) ? before : undefined;
-    const afterObject = afterPresent && jsonObject(after) ? after : undefined;
-    if (beforeObject !== undefined && afterObject !== undefined) {
-        const keys = [...new Set([...Object.keys(beforeObject), ...Object.keys(afterObject)])].sort((left, right) => left.localeCompare(right));
-        if (keys.length === 0)
-            return;
-        for (const key of keys) {
-            diffAt(output, `${pathValue}/${pointerPart(key)}`, Object.hasOwn(beforeObject, key), beforeObject[key], Object.hasOwn(afterObject, key), afterObject[key]);
-        }
-        return;
-    }
-    if (!beforePresent && afterObject !== undefined) {
-        if (expandObjectChildren) {
-            const keys = Object.keys(afterObject).sort((left, right) => left.localeCompare(right));
-            if (keys.length === 0) {
-                output.push({
-                    path: pathValue,
-                    beforePresent: false,
-                    before: null,
-                    afterPresent: true,
-                    after: jsonValue(afterObject),
-                });
-                return;
-            }
-            for (const key of keys) {
-                const value = afterObject[key];
-                const childPath = `${pathValue}/${pointerPart(key)}`;
-                if (jsonObject(value)) {
-                    output.push({
-                        path: childPath,
-                        beforePresent: false,
-                        before: null,
-                        afterPresent: true,
-                        after: jsonValue(value),
-                    });
-                }
-                else {
-                    diffAt(output, childPath, false, undefined, true, value);
-                }
-            }
-            return;
-        }
-        output.push({
-            path: pathValue,
-            beforePresent: false,
-            before: null,
-            afterPresent: true,
-            after: jsonValue(afterObject),
-        });
-        return;
-    }
-    if (beforeObject !== undefined && !afterPresent) {
-        if (expandObjectChildren) {
-            const keys = Object.keys(beforeObject).sort((left, right) => left.localeCompare(right));
-            if (keys.length === 0) {
-                output.push({
-                    path: pathValue,
-                    beforePresent: true,
-                    before: jsonValue(beforeObject),
-                    afterPresent: false,
-                    after: null,
-                });
-                return;
-            }
-            for (const key of keys) {
-                const value = beforeObject[key];
-                const childPath = `${pathValue}/${pointerPart(key)}`;
-                if (jsonObject(value)) {
-                    output.push({
-                        path: childPath,
-                        beforePresent: true,
-                        before: jsonValue(value),
-                        afterPresent: false,
-                        after: null,
-                    });
-                }
-                else {
-                    diffAt(output, childPath, true, value, false, undefined);
-                }
-            }
-            return;
-        }
-        output.push({
-            path: pathValue,
-            beforePresent: true,
-            before: jsonValue(beforeObject),
-            afterPresent: false,
-            after: null,
-        });
-        return;
-    }
-    if (beforePresent === afterPresent && (!beforePresent || jsonEqual(before, after)))
-        return;
-    output.push({
-        path: pathValue,
-        beforePresent,
-        before: jsonValue(before),
-        afterPresent,
-        after: jsonValue(after),
-    });
-}
-export function diffConfig(before, after) {
-    const output = [];
-    const beforeObject = jsonObject(before) ? before : {};
-    const afterObject = jsonObject(after) ? after : {};
-    const keys = [...new Set([...Object.keys(beforeObject), ...Object.keys(afterObject)])].sort((left, right) => left.localeCompare(right));
-    for (const key of keys) {
-        diffAt(output, `/${pointerPart(key)}`, Object.hasOwn(beforeObject, key), beforeObject[key], Object.hasOwn(afterObject, key), afterObject[key], true);
-    }
-    return output.sort((left, right) => left.path.localeCompare(right.path));
-}
-function catalogContains(catalog, model) {
-    return catalog.providers.some((provider) => provider.models.some((candidate) => candidate.id === model || (candidate.aliases !== undefined && candidate.aliases.some((alias) => alias === model))));
-}
-function validateBindings(bindings, catalog) {
-    const byAgent = new Map(catalog.models.map((item) => [item.agent, item]));
-    const entries = bindings.map(({ role, binding }) => {
-        const found = byAgent.get(binding.harness);
-        if (found?.available === false) {
-            return {
-                role,
-                harness: binding.harness,
-                model: binding.model,
-                status: "harness-unavailable",
-                message: `Cannot apply binding for role "${role}": harness "${binding.harness}" is unavailable.`,
-            };
-        }
-        if (catalog.status === "unavailable" || found === undefined) {
-            return {
-                role,
-                harness: binding.harness,
-                model: binding.model,
-                status: "unverified",
-                message: `Cannot validate model "${binding.model}" for harness "${binding.harness}": catalog unavailable.`,
-            };
-        }
-        if (catalog.status === "offline" && !catalogContains(found, binding.model)) {
-            return {
-                role,
-                harness: binding.harness,
-                model: binding.model,
-                status: "unverified",
-                message: `Cannot validate model "${binding.model}" for harness "${binding.harness}": the catalog is stale. Re-run with --refresh.`,
-            };
-        }
-        if (!catalogContains(found, binding.model)) {
-            return {
-                role,
-                harness: binding.harness,
-                model: binding.model,
-                status: "unknown-model",
-                message: `Model "${binding.model}" is not in the ${binding.harness} catalog for role "${role}".`,
-            };
-        }
-        return { role, harness: binding.harness, model: binding.model, status: "accepted", message: "" };
-    });
-    const failed = entries.find((entry) => entry.status !== "accepted");
-    const code = failed === undefined
-        ? undefined
-        : failed.status === "harness-unavailable"
-            ? 11
-            : failed.status === "unknown-model"
-                ? 12
-                : 13;
-    let message = null;
-    if (catalog.status === "offline") {
-        message = failed?.status === "unverified" ? failed.message : "Catalog is stale; using offline cache.";
-    }
-    else if (catalog.status === "unavailable") {
-        message = failed?.message ?? "Catalog unavailable.";
-    }
-    return { entries, code, message };
-}
 function catalogValidation(catalog, message) {
     if (catalog === undefined)
         return notNeededCatalog();
@@ -1063,38 +839,23 @@ export async function runSetupBatch(options, dependencies = {}) {
         return errorResult(read, null, notNeededCatalog(), [], [], read.readError ? 15 : 14, message);
     }
     const current = { ...DEFAULT_CONFIG, ...(read.config ?? {}) };
-    let profile;
-    let target;
-    try {
-        const resolved = resolveSetupTarget(current, options.profile);
-        profile = resolved.profile;
-        target = resolved.config;
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        writeLine(stderr, message);
-        return errorResult(read, null, notNeededCatalog(), [], [], 14, message);
-    }
     const lastByRole = new Map();
     options.binds.forEach((binding, index) => lastByRole.set(binding.role, index));
     const winning = options.binds.filter((binding, index) => lastByRole.get(binding.role) === index);
-    const existingAgents = jsonObject(target.agents) ? target.agents : {};
-    const updatedAgents = {
-        ...existingAgents,
-        ...Object.fromEntries(winning.map(({ role, binding }) => [role, binding])),
-    };
-    const proposed = options.binds.length === 0
-        ? { ...current }
-        : profile === undefined
-            ? { ...current, agents: updatedAgents }
-            : {
-                ...current,
-                profiles: {
-                    ...current.profiles,
-                    [profile]: { ...extractProfileSnapshot(target), agents: updatedAgents },
-                },
-            };
-    const changes = diffConfig(current, proposed);
+    let proposed;
+    let changes;
+    if (winning.length === 0) {
+        proposed = { ...current };
+        changes = diffConfig(current, proposed);
+    }
+    else {
+        const agents = {};
+        for (const { role, binding } of winning)
+            agents[role] = binding;
+        const plan = buildSetupPlan(current, { agents });
+        proposed = plan.proposedConfig;
+        changes = plan.diff;
+    }
     let catalog;
     let bindingValidations = [];
     let catalogMessage = null;
@@ -1189,9 +950,8 @@ export async function runSetupBatch(options, dependencies = {}) {
         };
     }
     const message = "Configuration saved.";
-    const summarized = profile === undefined ? proposed : (proposed.profiles?.[profile] ?? proposed);
     if (!options.json) {
-        writeLine(stderr, profile === undefined ? `saved: ${configSummary(summarized)}` : `saved profile "${profile}": ${configSummary(summarized)}`);
+        writeLine(stderr, `saved: ${configSummary(proposed)}`);
     }
     return {
         code: 0,
@@ -1202,14 +962,18 @@ function commandTokens(opts, command) {
     const tokens = [];
     if (opts.refresh)
         tokens.push("--refresh");
+    if (opts.tui)
+        tokens.push("--tui");
+    if (opts.open === false)
+        tokens.push("--no-open");
+    if (typeof opts.port === "string")
+        tokens.push("--port", opts.port);
     if (opts.nonInteractive)
         tokens.push("--non-interactive");
     if (opts.json)
         tokens.push("--json");
     if (opts.dryRun)
         tokens.push("--dry-run");
-    if (typeof opts.profile === "string")
-        tokens.push("--profile", opts.profile);
     const binds = Array.isArray(opts.bind) ? opts.bind : opts.bind === undefined ? [] : [opts.bind];
     for (const bind of binds) {
         tokens.push("--bind");
@@ -1231,28 +995,44 @@ export async function executeSetupAction(args, dependencies = {}) {
     }
     const tty = dependencies.isTTY ?? Boolean(input.isTTY && stdout.isTTY);
     if (!parsed.options.batch) {
-        if (!tty) {
-            const message = `${getCliName()} setup needs a terminal on both stdin and stdout.`;
-            writeError(message);
-            return { code: 1 };
+        if (parsed.options.tui) {
+            if (!tty) {
+                writeError(`${getCliName()} setup needs a terminal on both stdin and stdout.`);
+                return { code: 1 };
+            }
+            try {
+                await (dependencies.runWizard ?? runModelSetupWizard)({
+                    registry: dependencies.registry,
+                    input: dependencies.input,
+                    output: dependencies.stdout,
+                    refresh: parsed.options.refresh,
+                    discoverModels: dependencies.wizardDiscoverModels,
+                    save: dependencies.saveConfig,
+                    isTTY: tty,
+                });
+            }
+            catch (error) {
+                writeError(error instanceof Error ? error.message : String(error));
+                return { code: 1 };
+            }
+            return { code: 0 };
         }
+        let port;
         try {
-            await runModelSetupWizard({
-                registry: dependencies.registry,
-                input: dependencies.input,
-                output: dependencies.stdout,
-                refresh: parsed.options.refresh,
-                discoverModels: dependencies.wizardDiscoverModels,
-                save: dependencies.saveConfig,
-                isTTY: tty,
-                ...(parsed.options.profile === undefined ? {} : { profile: parsed.options.profile }),
-            });
+            port = parseOptionalWebPort(parsed.options.port);
         }
         catch (error) {
             writeError(error instanceof Error ? error.message : String(error));
             return { code: 1 };
         }
-        return { code: 0 };
+        const code = await (dependencies.launch ?? launchWebPage)({
+            path: "/setup",
+            query: parsed.options.refresh ? { refresh: "1" } : {},
+            title: "CodeDeck setup",
+            port,
+            open: !parsed.options.noOpen,
+        }, { error: writeError });
+        return { code: code === 0 ? 0 : 1 };
     }
     const result = await runSetupBatch(parsed.options, dependencies);
     if (parsed.options.json)
@@ -1266,10 +1046,12 @@ export function registerSetupCommand(program, dependencies = {}) {
         .allowUnknownOption(true)
         .allowExcessArguments(true)
         .option("--refresh", "ignore the cached catalog and rediscover")
+        .option("--tui", "use the frozen terminal setup wizard")
+        .option("--port <n>", "port for a new console (default: web.port from config, else 7777)")
+        .option("--no-open", "print the setup URL without opening a browser")
         .option("--non-interactive", "run setup without the picker")
         .option("--json", "output one machine-readable envelope")
         .option("--dry-run", "show the proposed config without writing it")
-        .option("--profile <name>", "edit a saved profile instead of the active setup")
         .option("--bind [binding]", "bind a role to a harness and model", (value, previous = []) => [...previous, value], [])
         .action(async (opts, command) => {
         const result = await executeSetupAction(commandTokens(opts, command), dependencies);