@zq-silk/yui 0.2.0 → 0.4.2

package/dist/cli/roleWizard.js

@@ -1,4 +1,5 @@
 import { renderTable } from "../output/table.js";
+import { selectAgentEffort, selectAgentModelAndEffort } from "./agentConfigurationPicker.js";
 const TEXT_COLUMN = { header: "Selection", minWidth: 12, maxWidth: 34 };
 export async function resolveRoleWizardArguments(commandArgs, ports, io) {
     const args = [...commandArgs];
@@ -18,6 +19,17 @@ export async function resolveRoleWizardArguments(commandArgs, ports, io) {
     }
     return { kind: "unchanged", args };
 }
+export async function resolveGlobalRoleAgentConfigurationArguments(roleName, agentId, ports, io) {
+    const args = ["role", "update", roleName];
+    if (!io.interactive || io.json)
+        return { kind: "unchanged", args };
+    const role = asRole(await ports.call("role.show", { name: roleName }));
+    const binding = role?.agentBindings[agentId];
+    if (role === undefined || binding === undefined) {
+        return { kind: "cancelled", args };
+    }
+    return updateAgentBindingSettings(args, role, binding, ports, io);
+}
 function isGlobalRoleAdd(args) {
     return args[0] === "role" && args[1] === "add";
 }
@@ -146,7 +158,7 @@ async function configureRoleCreation(args, agent, ports, io, taskRole) {
         return { kind: "cancelled", args };
     return section === "role"
         ? configureNewRoleField(args, agent, ports, io, taskRole)
-        : configureNewAgentField(args, agent, io);
+        : configureNewAgentField(args, agent, ports, io);
 }
 async function configureNewRoleField(args, agent, ports, io, taskRole) {
     const field = await choose("Role settings", [
@@ -175,16 +187,49 @@ async function configureNewRoleField(args, agent, ports, io, taskRole) {
     void agent;
     return setProfileField(args, field, io);
 }
-async function configureNewAgentField(args, agent, io) {
-    const fields = agentFields({
+async function configureNewAgentField(args, agent, ports, io) {
+    const binding = {
         agentId: agent.id,
         adapterId: agent.adapterId,
-        config: { adapterId: agent.adapterId }
-    });
+        config: {
+            adapterId: agent.adapterId,
+            permission: { strategy: "bypass" }
+        }
+    };
+    const resolved = await loadAgentCatalog(ports, binding);
+    const fields = agentFields(binding, resolved?.catalog);
     const field = await choose(`Agent settings: ${agent.id}`, fields.map((candidate) => ({ value: candidate.value, cells: [candidate.label, "CLI default"] })), [TEXT_COLUMN, { header: "Current", minWidth: 12, maxWidth: 24 }], io, undefined, "field");
     const selected = fields.find((candidate) => candidate.value === field);
     if (selected === undefined)
         return { kind: "cancelled", args };
+    if (selected.value === "model") {
+        if (resolved === undefined)
+            return { kind: "cancelled", args };
+        const selection = await selectAgentModelAndEffort(resolved, io, {});
+        return selection.kind === "cancelled"
+            ? { kind: "cancelled", args }
+            : { kind: "resolved", args: appendModelEffortPatch(args, selection, false) };
+    }
+    if (selected.value === "effort") {
+        if (resolved === undefined)
+            return { kind: "cancelled", args };
+        const selection = await selectAgentEffort(resolved, io, {});
+        return selection.kind === "cancelled"
+            ? { kind: "cancelled", args }
+            : {
+                kind: "resolved",
+                args: selection.effort === undefined ? args : [...args, "--effort", selection.effort]
+            };
+    }
+    if (selected.value === "permission-strategy") {
+        const strategy = await promptAgentFieldValue(selected, io);
+        if (strategy === undefined || strategy.length === 0)
+            return { kind: "cancelled", args };
+        const permissionArgs = await configuredPermissionArgs(binding, resolved?.catalog, strategy, io);
+        return permissionArgs === undefined
+            ? { kind: "cancelled", args }
+            : { kind: "resolved", args: [...args, ...permissionArgs] };
+    }
     const value = await promptAgentFieldValue(selected, io);
     return value === undefined
         ? { kind: "cancelled", args }
@@ -211,7 +256,7 @@ async function updateRole(args, role, ports, io, taskRole) {
         return { kind: "cancelled", args };
     return section === "role"
         ? updateRoleSettings(args, role, ports, io, taskRole)
-        : updateAgentSettings(args, role, io);
+        : updateAgentSettings(args, role, ports, io);
 }
 async function settingsSection(title, io, taskRole) {
     return choose(title, [
@@ -281,7 +326,7 @@ async function setProfileField(args, field, io) {
         args: [...args, ...values.flatMap((entry) => [options.set, entry])]
     };
 }
-async function updateAgentSettings(args, role, io) {
+async function updateAgentSettings(args, role, ports, io) {
     const bindings = Object.values(role.agentBindings);
     const selectedId = await choose("Select Role Agent binding", bindings.map((binding) => ({
         value: binding.agentId,
@@ -296,7 +341,11 @@ async function updateAgentSettings(args, role, io) {
     const binding = role.agentBindings[selectedId];
     if (binding === undefined)
         return { kind: "cancelled", args };
-    const fields = agentFields(binding);
+    return updateAgentBindingSettings(args, role, binding, ports, io);
+}
+async function updateAgentBindingSettings(args, role, binding, ports, io) {
+    const resolved = await loadAgentCatalog(ports, binding, role.workspace);
+    const fields = agentFields(binding, resolved?.catalog);
     const field = await choose(`Agent settings: ${binding.agentId}`, [
         ...fields.map((candidate) => ({
             value: candidate.value,
@@ -315,6 +364,51 @@ async function updateAgentSettings(args, role, io) {
     const selectedField = fields.find((candidate) => candidate.value === field);
     if (selectedField === undefined)
         return { kind: "cancelled", args };
+    if (selectedField.value === "model") {
+        if (resolved === undefined)
+            return { kind: "cancelled", args };
+        const selection = await selectAgentModelAndEffort(resolved, io, {
+            currentModel: stringField(binding.config, "model"),
+            currentEffort: stringField(binding.config, "effort")
+        });
+        return selection.kind === "cancelled"
+            ? { kind: "cancelled", args }
+            : {
+                kind: "resolved",
+                args: appendModelEffortPatch([...args, "--agent", binding.agentId], selection, true)
+            };
+    }
+    if (selectedField.value === "effort") {
+        if (resolved === undefined)
+            return { kind: "cancelled", args };
+        const selection = await selectAgentEffort(resolved, io, {
+            model: stringField(binding.config, "model"),
+            currentEffort: stringField(binding.config, "effort")
+        });
+        if (selection.kind === "cancelled")
+            return { kind: "cancelled", args };
+        return {
+            kind: "resolved",
+            args: [
+                ...args,
+                "--agent", binding.agentId,
+                ...(selection.effort === undefined
+                    ? ["--clear-effort"] : ["--effort", selection.effort])
+            ]
+        };
+    }
+    if (selectedField.value === "permission-strategy") {
+        const strategy = await promptAgentFieldValue(selectedField, io);
+        if (strategy === undefined || strategy.length === 0)
+            return { kind: "cancelled", args };
+        const permissionArgs = await configuredPermissionArgs(binding, resolved?.catalog, strategy, io);
+        if (permissionArgs === undefined)
+            return { kind: "cancelled", args };
+        return {
+            kind: "resolved",
+            args: [...args, "--agent", binding.agentId, ...permissionArgs]
+        };
+    }
     const action = await choose(`Update ${selectedField.label}`, [
         { value: "keep", cells: ["Keep current", selectedField.current] },
         { value: "clear", cells: ["Use CLI default", "Remove override"] },
@@ -325,7 +419,7 @@ async function updateAgentSettings(args, role, io) {
     if (action === "clear") {
         return {
             kind: "resolved",
-            args: [...args, "--agent", binding.agentId, selectedField.clear]
+            args: [...args, "--agent", binding.agentId, ...selectedField.clear]
         };
     }
     const value = await promptAgentFieldValue(selectedField, io);
@@ -336,31 +430,101 @@ async function updateAgentSettings(args, role, io) {
         args: [...args, "--agent", binding.agentId, selectedField.set, value]
     };
 }
-function agentFields(binding) {
+function agentFields(binding, catalog) {
     const config = binding.config;
     const permission = entity(config.permission) ?? {};
     return [
-        agentField("model", "Model", config.model, "--model", "--clear-model"),
-        agentField("effort", "Effort", config.effort, "--effort", "--clear-effort"),
-        ...(binding.adapterId === "codex" ? [
-            agentField("sandbox", "Sandbox", permission.sandbox, "--sandbox", "--clear-sandbox", [
+        agentField("model", "Model", config.model, "--model", ["--clear-model"]),
+        agentField("effort", "Effort", config.effort, "--effort", ["--clear-effort"]),
+        agentField("permission-strategy", "Permission strategy", permission.strategy, "--permission-strategy", ["--permission-strategy", "default"], catalogChoices(catalog, "permission.strategy", ["default", "bypass", "configured"])),
+        ...(binding.adapterId === "codex" && permission.strategy === "configured" ? [
+            agentField("sandbox", "Sandbox", permission.sandbox, "--sandbox", ["--permission-strategy", "default"], catalogChoices(catalog, "permission.sandbox", [
                 "read-only", "workspace-write", "danger-full-access"
-            ]),
-            agentField("approval", "Approval", permission.approval, "--approval", "--clear-approval", [
+            ])),
+            agentField("approval", "Approval", permission.approval, "--approval", ["--permission-strategy", "default"], catalogChoices(catalog, "permission.approval", [
                 "untrusted", "on-request", "never"
-            ]),
-            agentField("search", "Web search", config.search, "--search", "--clear-search", [
-                "true"
+            ]))
+        ] : []),
+        ...(binding.adapterId === "codex" ? [
+            agentField("search", "Web search", config.search, "--search", ["--clear-search"], [
+                ...catalogChoices(catalog, "search", ["true"])
             ])
         ] : []),
-        ...(binding.adapterId === "claude" ? [
-            agentField("permission-mode", "Permission mode", permission.mode, "--permission-mode", "--clear-permission-mode")
+        ...(binding.adapterId === "claude" && permission.strategy === "configured" ? [
+            agentField("permission-mode", "Permission mode", permission.mode, "--permission-mode", ["--permission-strategy", "default"], catalogChoices(catalog, "permission.mode"))
         ] : [])
     ];
 }
+async function loadAgentCatalog(ports, binding, cwd) {
+    const value = await ports.call("agent.capabilities", {
+        agentId: binding.agentId,
+        config: binding.config,
+        ...(cwd === undefined ? {} : { cwd })
+    });
+    const input = entity(value);
+    return input !== undefined
+        && (input.source === "live" || input.source === "cache" || input.source === "fallback")
+        && entity(input.catalog) !== undefined
+        ? value
+        : undefined;
+}
+function catalogChoices(catalog, key, fallback = []) {
+    const field = catalog?.fields.find((candidate) => candidate.key === key);
+    return field === undefined ? [...fallback] : field.choices.map(({ value }) => value);
+}
+function appendModelEffortPatch(args, selection, update) {
+    return [
+        ...args,
+        ...(selection.model === undefined
+            ? update ? ["--clear-model"] : []
+            : ["--model", selection.model]),
+        ...(selection.effort === undefined
+            ? update ? ["--clear-effort"] : []
+            : ["--effort", selection.effort])
+    ];
+}
 function agentField(value, label, current, set, clear, choices) {
     return { value, label, current: display(current), set, clear, ...(choices === undefined ? {} : { choices }) };
 }
+async function configuredPermissionArgs(binding, catalog, strategy, io) {
+    if (strategy !== "configured")
+        return ["--permission-strategy", strategy];
+    if (binding.adapterId === "codex") {
+        const field = await choose("Native permission option", [
+            { value: "sandbox", cells: ["Sandbox"] },
+            { value: "approval", cells: ["Approval"] }
+        ], [TEXT_COLUMN], io, "sandbox", "option");
+        if (field === undefined)
+            return undefined;
+        const option = field === "sandbox" ? "--sandbox" : "--approval";
+        const value = await promptAgentFieldValue(agentField(field, field === "sandbox" ? "Sandbox" : "Approval", undefined, option, ["--permission-strategy", "default"], field === "sandbox"
+            ? catalogChoices(catalog, "permission.sandbox", [
+                "read-only", "workspace-write", "danger-full-access"
+            ])
+            : catalogChoices(catalog, "permission.approval", [
+                "untrusted", "on-request", "never"
+            ])), io);
+        return value === undefined
+            ? undefined
+            : ["--permission-strategy", "configured", option, value];
+    }
+    const field = await choose("Native permission option", [
+        { value: "mode", cells: ["Permission mode"] },
+        { value: "allowed", cells: ["Allowed tool"] },
+        { value: "disallowed", cells: ["Disallowed tool"] }
+    ], [TEXT_COLUMN], io, "mode", "option");
+    if (field === undefined)
+        return undefined;
+    const option = field === "mode"
+        ? "--permission-mode"
+        : field === "allowed" ? "--allowed-tool" : "--disallowed-tool";
+    const value = field === "mode"
+        ? await promptAgentFieldValue(agentField("permission-mode", "Permission mode", undefined, option, ["--permission-strategy", "default"], catalogChoices(catalog, "permission.mode")), io)
+        : (await io.question(`${field === "allowed" ? "Allowed" : "Disallowed"} tool: `))?.trim();
+    return value === undefined || value.length === 0
+        ? undefined
+        : ["--permission-strategy", "configured", option, value];
+}
 async function promptAgentFieldValue(field, io) {
     return field.choices === undefined
         ? (await io.question(`${field.label}: `))?.trim()

package/dist/cli/updateCommand.js

@@ -1,22 +1,65 @@
-import { spawnSync } from "node:child_process";
-import { runtimeError } from "../errors/cliError.js";
+import { resolveYuiHome } from "../storage/taskStore.js";
+import { createUpdatePorts } from "./updatePorts.js";
+import { runUpdate } from "./updateOrchestrator.js";
 /**
- * Update the published global package. This intentionally remains an exact,
- * shell-free npm invocation. In particular, yui-dev updates the published
- * Yui installation; it never rewrites the current checkout.
+ * Run `yui update` as a side-by-side, recoverable orchestration.
+ *
+ * The new package is staged beside the live install and used to run a read-only
+ * preflight against the target Home. Current/compatible-old storage promotes the
+ * binary through the exact Controller handoff without a Home switch; only a
+ * migration-required verdict enters the offline backup/switch path. On failure
+ * it reports the precise phase and recovery boundary. See
+ * {@link runUpdate} for the exact, narrowed rollback boundary (this release does
+ * not introduce a versioned binary pointer, so it does not claim binary+Home
+ * dual-resource atomicity).
+ *
+ * Returns a process exit code: 0 on success or already-current, 5 on abort.
  */
-export function runUpdateCommand(spawn = spawnSync) {
-    const result = spawn("npm", ["install", "--global", "@zq-silk/yui@latest"], {
-        cwd: process.cwd(),
-        env: process.env,
-        shell: false,
-        stdio: "inherit"
-    });
-    if (result.error !== undefined) {
-        throw runtimeError(`Failed to start npm: ${result.error.message}`);
-    }
-    if (result.status === null) {
-        throw runtimeError(`npm update terminated${result.signal === null ? "" : ` by ${result.signal}`}.`);
-    }
-    return result.status;
+export function runUpdateCommand(environment = process.env, spawn, write = (text) => process.stdout.write(text), ports) {
+    const home = resolveYuiHome(environment);
+    const resolvedPorts = ports ?? createUpdatePorts(environment, spawn);
+    const result = runUpdate(resolvedPorts, { home });
+    write(`${renderUpdateResult(result)}\n`);
+    // Both an abort and an ambiguous result are non-success exits; ambiguous is
+    // distinct (manual verification required), so it gets its own exit code.
+    if (result.outcome === "aborted")
+        return 5;
+    if (result.outcome === "ambiguous")
+        return 6;
+    return 0;
+}
+/** Render an {@link UpdateResult} as concise, CLI-style text. */
+export function renderUpdateResult(result) {
+    const rendered = (() => {
+        switch (result.outcome) {
+            case "already-current":
+                return "Yui is already up to date; nothing to install.";
+            case "updated":
+                return result.storageBackupPath === undefined
+                    ? result.path === "compatible-fast"
+                        ? `Updated Yui to ${result.version} via the compatible fast path; the Home was not migrated.`
+                        : `Updated Yui to ${result.version}; storage was already current.`
+                    : `Updated Yui to ${result.version}. Storage was migrated; original Home backed up at `
+                        + `${result.storageBackupPath}.`;
+            case "aborted":
+                return [
+                    `Update aborted during ${result.phase}: ${result.message}`,
+                    result.recoverable
+                        ? "The current install and Home remain usable."
+                        : result.phase === "activate-binary" && result.storageBackupPath === undefined
+                            ? "The Home was not migrated, but binary health is unknown; do not assume the current install is usable."
+                            : "Manual recovery is required (see below).",
+                    `Action: ${result.action}`
+                ].join("\n");
+            case "ambiguous":
+                return [
+                    `Update result is UNKNOWN after ${result.phase}: ${result.message}`,
+                    "Manual verification is required — do NOT assume the update succeeded or was a no-op.",
+                    `Action: ${result.action}`
+                ].join("\n");
+        }
+    })();
+    return result.cleanupWarning === undefined
+        ? rendered
+        : `${rendered}\nWarning: ${result.cleanupWarning}`;
 }