@zq-silk/yui 0.2.0 → 0.4.2

package/dist/executor/agentAdapter.js

@@ -3,11 +3,19 @@ import { realpathSync, statSync } from "node:fs";
 import { isAbsolute, resolve } from "node:path";
 import { supportedAgentAdapterIds } from "../agent/adapterCatalog.js";
 import { ownedArgumentsForAdapter, validateAgentAdvancedArguments, validateAgentBaseArguments } from "../agent/argumentPolicy.js";
+import { writeTextFileAtomically } from "../storage/durableFile.js";
+import { inspectCodexDeveloperInstructions } from "./codexConfigConflict.js";
+import { discoverClaudeConfiguration, discoverCodexConfiguration } from "./agentConfigurationProbe.js";
+import { preInputReadinessCapability } from "../lifecycle/providerLifecycleMapping.js";
 const SANDBOXES = ["read-only", "workspace-write", "danger-full-access"];
 const APPROVALS = ["untrusted", "on-request", "never"];
 const PROBE_TIMEOUT_MS = 2_000;
 const PROBE_MAX_BYTES = 1024 * 1024;
+const CODEX_TESTED_THROUGH_VERSION = "0.145.0";
 class BaseAdapter {
+    launchContextArgs(_input) {
+        return [];
+    }
     validateConfig(input) {
         if (input.agent.adapterId !== this.id || input.config.adapterId !== this.id) {
             throw new Error(`Agent adapter identity mismatch: expected ${this.id}.`);
@@ -19,7 +27,12 @@ class BaseAdapter {
         this.validateConfig(input);
         const config = this.canonicalizeConfig(input.config);
         return {
-            argv: [...input.agent.baseArgs, ...this.structuredArgs(config), ...(config.advanced?.rawArgs ?? [])],
+            argv: [
+                ...input.agent.baseArgs,
+                ...this.structuredArgs(config),
+                ...this.launchContextArgs(input),
+                ...(config.advanced?.rawArgs ?? [])
+            ],
             sessionStrategy: this.capabilities.nativeSessionDiscovery === "runtime"
                 ? "runtime-discovery"
                 : "preallocated"
@@ -40,7 +53,15 @@ class CodexAdapter extends BaseAdapter {
     id = "codex";
     label = "Codex";
     supportedVersion = "0.144.1";
-    capabilities = { recover: true, interrupt: true, nativeSessionDiscovery: "runtime" };
+    capabilities = {
+        recover: true,
+        interrupt: true,
+        nativeSessionDiscovery: "runtime",
+        preInputReadiness: preInputReadinessCapability("codex")
+    };
+    discoverConfiguration(input) {
+        return discoverCodexConfiguration(input);
+    }
     validateStructured(config) {
         exact(config, ["adapterId", "model", "effort", "permission", "search", "profile",
             "additionalDirectories", "advanced"], "Codex Agent config");
@@ -53,33 +74,85 @@ class CodexAdapter extends BaseAdapter {
             throw new Error("Codex search must be boolean.");
         }
         validatePaths(config.additionalDirectories, "Codex additional directory");
-        if (config.permission !== undefined) {
-            exact(config.permission, ["sandbox", "approval"], "Codex permission config");
-            if (config.permission.sandbox !== undefined && !SANDBOXES.includes(config.permission.sandbox)) {
+        if (config.permission === undefined) {
+            throw new Error("Codex permission strategy is required.");
+        }
+        if (config.permission.strategy === "configured") {
+            exact(config.permission, ["strategy", "sandbox", "approval"], "Codex permission config");
+            if (config.permission.sandbox !== undefined
+                && !SANDBOXES.includes(config.permission.sandbox)) {
                 throw new Error("Codex sandbox is invalid.");
             }
-            if (config.permission.approval !== undefined && !APPROVALS.includes(config.permission.approval)) {
+            if (config.permission.approval !== undefined
+                && !APPROVALS.includes(config.permission.approval)) {
                 throw new Error("Codex approval is invalid.");
             }
+            requireConfiguredPermissionOption(config.permission, "Codex");
+        }
+        else {
+            exact(config.permission, ["strategy"], "Codex permission config");
+            validateSimplePermissionStrategy(config.permission.strategy, "Codex permission strategy");
         }
         advanced(this.id, config.advanced);
     }
     structuredArgs(config) {
         return [
-            // Yui launches Codex in a detached tmux window and waits for the
-            // composer before delivering work.  The startup updater is itself an
-            // interactive prompt, so leaving it enabled can consume the first
-            // automated delivery as an update-menu answer.
+            // Yui launches Codex in a detached tmux window. Disable the startup
+            // updater so an unrelated native prompt cannot consume managed input.
             "--config", "check_for_update_on_startup=false",
             ...(config.model === undefined ? [] : ["--model", config.model]),
             ...(config.effort === undefined ? [] : ["--config", `model_reasoning_effort=\"${config.effort}\"`]),
-            ...(config.permission?.sandbox === undefined ? [] : ["--sandbox", config.permission.sandbox]),
-            ...(config.permission?.approval === undefined ? [] : ["--ask-for-approval", config.permission.approval]),
+            ...(config.permission.strategy === "bypass"
+                ? ["--dangerously-bypass-approvals-and-sandbox"]
+                : config.permission.strategy === "configured"
+                    ? [
+                        ...(config.permission.sandbox === undefined
+                            ? [] : ["--sandbox", config.permission.sandbox]),
+                        ...(config.permission.approval === undefined
+                            ? [] : ["--ask-for-approval", config.permission.approval])
+                    ]
+                    : []),
             ...(config.search === true ? ["--search"] : []),
             ...(config.profile === undefined ? [] : ["--profile", config.profile]),
             ...(config.additionalDirectories ?? []).flatMap((path) => ["--add-dir", path])
         ];
     }
+    launchContextArgs(input) {
+        // Yui has already scoped and authorized this exact workspace. Declare that
+        // invocation-local trust explicitly so Codex does not place its interactive
+        // directory trust prompt in front of the managed first input. This does not
+        // mutate the user's Codex config or trust any parent/sibling directory.
+        const workspaceTrust = [
+            "--config",
+            `projects={${JSON.stringify(resolve(input.workspace))}={trust_level="trusted"}}`
+        ];
+        const instructions = [
+            input.developerInstructions,
+            ...(input.skills === undefined || input.skills.length === 0
+                ? []
+                : [
+                    "Yui Role Skills are available at the paths below. Before performing work governed by one, read and follow its SKILL.md on demand; do not treat this list as a user message.",
+                    ...input.skills.map((skill) => `- ${skill.id}: ${skill.path}/SKILL.md`)
+                ])
+        ].filter((value) => value !== undefined && value.trim().length > 0);
+        if (instructions.length === 0)
+            return workspaceTrust;
+        const nativeInstructions = input.codexDeveloperInstructions
+            ?? inspectCodexDeveloperInstructions({
+                workspace: input.workspace,
+                profile: input.config.profile,
+                trustWorkspace: true
+            });
+        if (nativeInstructions.status === "configured") {
+            throw new Error("Codex developer_instructions is already configured by "
+                + `${nativeInstructions.source}; Yui refuses to replace native developer instructions.`);
+        }
+        return [
+            ...workspaceTrust,
+            "--config",
+            `developer_instructions=${tomlString(instructions.join("\n"))}`
+        ];
+    }
     compileResume(input) {
         const launch = this.compileNew(input);
         return { ...launch, argv: [...launch.argv, "resume", nativeId(input.nativeSessionId)] };
@@ -89,7 +162,15 @@ class ClaudeAdapter extends BaseAdapter {
     id = "claude";
     label = "Claude";
     supportedVersion = "2.1.207";
-    capabilities = { recover: true, interrupt: true, nativeSessionDiscovery: "preallocated" };
+    capabilities = {
+        recover: true,
+        interrupt: true,
+        nativeSessionDiscovery: "preallocated",
+        preInputReadiness: preInputReadinessCapability("claude")
+    };
+    discoverConfiguration(input) {
+        return discoverClaudeConfiguration(input);
+    }
     validateStructured(config) {
         exact(config, ["adapterId", "model", "effort", "permission", "additionalDirectories",
             "settingsFile", "settingsSources", "advanced"], "Claude Agent config");
@@ -104,16 +185,23 @@ class ClaudeAdapter extends BaseAdapter {
         if (config.settingsSources !== undefined && new Set(config.settingsSources).size !== config.settingsSources.length) {
             throw new Error("Claude settings sources contain duplicates.");
         }
-        if (config.permission !== undefined) {
-            exact(config.permission, ["mode", "allowedTools", "disallowedTools"], "Claude permission config");
+        if (config.permission === undefined) {
+            throw new Error("Claude permission strategy is required.");
+        }
+        if (config.permission.strategy === "configured") {
+            exact(config.permission, ["strategy", "mode", "allowedTools", "disallowedTools"], "Claude permission config");
             optionalText(config.permission.mode, "Claude permission mode");
             optionalTexts(config.permission.allowedTools, "Claude allowed tool");
             optionalTexts(config.permission.disallowedTools, "Claude disallowed tool");
-            for (const tool of [...(config.permission.allowedTools ?? []), ...(config.permission.disallowedTools ?? [])]) {
-                if (/(?:api[-_]?key|token|secret|password|credential|authorization|Bearer\s+\S+|sk-[\w-]{8,})/i.test(tool)) {
-                    throw new Error("Claude tool expressions cannot contain secret-bearing literals.");
-                }
+            if (config.permission.allowedTools?.length === 0
+                || config.permission.disallowedTools?.length === 0) {
+                throw new Error("Claude configured tool lists must not be empty.");
             }
+            requireConfiguredPermissionOption(config.permission, "Claude");
+        }
+        else {
+            exact(config.permission, ["strategy"], "Claude permission config");
+            validateSimplePermissionStrategy(config.permission.strategy, "Claude permission strategy");
         }
         advanced(this.id, config.advanced);
     }
@@ -121,22 +209,72 @@ class ClaudeAdapter extends BaseAdapter {
         return [
             ...(config.model === undefined ? [] : ["--model", config.model]),
             ...(config.effort === undefined ? [] : ["--effort", config.effort]),
-            ...(config.permission?.mode === undefined ? [] : ["--permission-mode", config.permission.mode]),
-            ...(config.permission?.allowedTools === undefined ? [] : ["--allowed-tools", ...config.permission.allowedTools]),
-            ...(config.permission?.disallowedTools === undefined ? [] : ["--disallowed-tools", ...config.permission.disallowedTools]),
+            ...(config.permission.strategy === "bypass"
+                ? ["--dangerously-skip-permissions"]
+                : config.permission.strategy === "configured"
+                    && config.permission.mode !== undefined
+                    ? ["--permission-mode", config.permission.mode]
+                    : []),
+            ...(config.permission.strategy !== "configured"
+                || config.permission.allowedTools === undefined
+                ? [] : ["--allowed-tools", ...config.permission.allowedTools]),
+            ...(config.permission.strategy !== "configured"
+                || config.permission.disallowedTools === undefined
+                ? [] : ["--disallowed-tools", ...config.permission.disallowedTools]),
             ...(config.additionalDirectories ?? []).flatMap((path) => ["--add-dir", path]),
             ...(config.settingsFile === undefined ? [] : ["--settings", config.settingsFile]),
             ...(config.settingsSources === undefined ? [] : ["--setting-sources", config.settingsSources.join(",")])
         ];
     }
+    compileNew(input) {
+        const launch = super.compileNew(input);
+        return input.sessionTitle === undefined
+            ? launch
+            : {
+                ...launch,
+                argv: [...launch.argv, "--name", sessionTitle(input.sessionTitle)]
+            };
+    }
+    launchContextArgs(input) {
+        const sections = [
+            input.developerInstructions,
+            ...(input.skills ?? []).map((skill) => [
+                `# Yui Skill: ${skill.id}`,
+                skill.content
+            ].join("\n\n"))
+        ].filter((value) => value !== undefined && value.trim().length > 0);
+        if (sections.length === 0)
+            return [];
+        const context = sections.join("\n\n");
+        if (input.managedContextFile === undefined) {
+            throw new Error("Claude session context requires a managed context file under YUI_HOME.");
+        }
+        writeTextFileAtomically(input.managedContextFile, context);
+        return ["--append-system-prompt-file", input.managedContextFile];
+    }
     compileResume(input) {
-        const launch = this.compileNew(input);
+        const launch = super.compileNew(input);
         return { ...launch, argv: [...launch.argv, "--resume", nativeId(input.nativeSessionId)] };
     }
 }
 const ADAPTERS = {
     codex: new CodexAdapter(), claude: new ClaudeAdapter()
 };
+function tomlString(value) {
+    if (value.includes("\0"))
+        throw new Error("Agent launch context cannot contain NUL bytes.");
+    return JSON.stringify(value);
+}
+function sessionTitle(value) {
+    if (typeof value !== "string" || value.includes("\0")) {
+        throw new Error("Agent session title is invalid.");
+    }
+    const normalized = value.trim();
+    if (normalized.length === 0 || normalized.length > 1_024) {
+        throw new Error("Agent session title is invalid.");
+    }
+    return normalized;
+}
 export { supportedAgentAdapterIds };
 export function findAgentAdapter(id) {
     return id === "codex" || id === "claude" ? ADAPTERS[id] : null;
@@ -171,24 +309,53 @@ export function inspectAgentCapabilities(agent, optionsOrNow = {}) {
             reason: "Agent version probe did not return a semantic version.", probedAt: at
         }, baseline(agent.adapterId), at);
     }
-    const supported = supports(version, adapter.supportedVersion);
+    const supported = supports(version, adapter);
     let fields = baseline(agent.adapterId);
-    const warnings = supported ? [] : [`Installed version ${version} is not supported by adapter ${adapter.id}.`];
-    if (supported) {
-        const help = run(agent.command, ["--help"]);
-        if (failed(help) === undefined)
-            fields = fromHelp(agent.adapterId, output(help.stdout, help.stderr));
+    const warnings = [];
+    if (!supported) {
+        return snapshot(agent, adapter, {
+            status: "unsupported-version", command: agent.command, version,
+            reason: adapter.id === "codex"
+                ? `Minimum supported version is ${adapter.supportedVersion}.`
+                : `Supported version line starts at ${adapter.supportedVersion}.`,
+            probedAt: at
+        }, fields, at, [`Installed version ${version} is not supported by adapter ${adapter.id}.`]);
+    }
+    const help = run(agent.command, ["--help"]);
+    const helpFailure = failed(help);
+    if (adapter.id === "codex" && helpFailure !== undefined) {
+        return snapshot(agent, adapter, {
+            status: "probe-failed", command: agent.command, version,
+            reason: `Required Codex capability probe failed: ${helpFailure}`, probedAt: at
+        }, fields, at);
+    }
+    if (helpFailure === undefined) {
+        const helpOutput = output(help.stdout, help.stderr);
+        fields = fromHelp(agent.adapterId, helpOutput);
+        if (adapter.id === "codex") {
+            const missing = missingCodexCapabilities(helpOutput);
+            if (missing.length > 0) {
+                return snapshot(agent, adapter, {
+                    status: "unsupported-version", command: agent.command, version,
+                    reason: `Codex CLI is missing required capabilities: ${missing.join(", ")}.`,
+                    probedAt: at
+                }, fields, at);
+            }
+            if (compareVersions(version, CODEX_TESTED_THROUGH_VERSION) > 0) {
+                warnings.push(`Installed Codex version ${version} is newer than the latest tested version `
+                    + `${CODEX_TESTED_THROUGH_VERSION}; required capabilities were detected.`);
+            }
+        }
     }
     return snapshot(agent, adapter, {
-        status: supported ? "installed" : "unsupported-version", command: agent.command, version,
-        ...(supported ? {} : { reason: `Supported version line starts at ${adapter.supportedVersion}.` }),
-        probedAt: at
+        status: "installed", command: agent.command, version, probedAt: at
     }, fields, at, warnings);
 }
 function baseline(id) {
     if (id === "codex")
         return [
             field("model", "enum", "degraded", true), field("effort", "enum", "unavailable", true),
+            field("permission.strategy", "enum", "available", false, ["default", "bypass", "configured"]),
             field("permission.sandbox", "enum", "available", false, SANDBOXES),
             field("permission.approval", "enum", "available", false, APPROVALS),
             field("profile", "string", "available", true), field("search", "boolean", "available", false, ["true"]),
@@ -196,7 +363,9 @@ function baseline(id) {
         ];
     return [
         field("model", "enum", "degraded", true, ["fable", "opus", "sonnet"]),
-        field("effort", "enum", "unavailable", true), field("permission.mode", "enum", "unavailable", true),
+        field("effort", "enum", "unavailable", true),
+        field("permission.strategy", "enum", "available", false, ["default", "bypass", "configured"]),
+        field("permission.mode", "enum", "unavailable", true),
         field("permission.allowedTools", "string-list", "available", true),
         field("permission.disallowedTools", "string-list", "available", true),
         field("additionalDirectories", "path-list", "available", true), field("settingsFile", "path", "available", true),
@@ -206,15 +375,25 @@ function baseline(id) {
 function fromHelp(id, help) {
     const fields = baseline(id);
     const replacements = id === "codex"
-        ? [choiceField("permission.sandbox", help, "--sandbox", SANDBOXES),
+        ? [permissionStrategyField(help, "--dangerously-bypass-approvals-and-sandbox"),
+            choiceField("permission.sandbox", help, "--sandbox", SANDBOXES),
             choiceField("permission.approval", help, "--ask-for-approval", APPROVALS)]
         : [choiceField("model", help, "--model", ["fable", "opus", "sonnet"], true),
             choiceField("effort", help, "--effort", [], true),
+            permissionStrategyField(help, "--dangerously-skip-permissions"),
             choiceField("permission.mode", help, "--permission-mode", [], true),
             choiceField("settingsSources", help, "--setting-sources", ["user", "project", "local"])];
     const byKey = new Map(replacements.map((value) => [value.key, value]));
     return fields.map((value) => byKey.get(value.key) ?? value);
 }
+function permissionStrategyField(help, bypassFlag) {
+    const choices = [
+        "default",
+        ...(help.includes(bypassFlag) ? ["bypass"] : []),
+        "configured"
+    ];
+    return field("permission.strategy", "enum", choices.includes("bypass") ? "available" : "degraded", false, choices);
+}
 function choiceField(key, help, flag, fallback, custom = false) {
     const choices = helpChoices(help, flag);
     return field(key, key === "settingsSources" ? "string-list" : "enum", choices.length > 0 ? "available" : fallback.length > 0 ? "degraded" : "unavailable", custom, choices.length > 0 ? choices : fallback);
@@ -238,7 +417,7 @@ function helpChoices(help, flag) {
 function snapshot(agent, adapter, installation, fields, at, warnings = []) {
     return { schemaVersion: 1, agentId: agent.id, adapterId: agent.adapterId, installation,
         lifecycle: { start: true, resume: true, nativeSessionDiscovery: adapter.capabilities.nativeSessionDiscovery,
-            interrupt: true }, fields, warnings, refreshedAt: at };
+            interrupt: true, preInputReadiness: adapter.capabilities.preInputReadiness }, fields, warnings, refreshedAt: at };
 }
 function runProbe(command, args) {
     const result = spawnSync(command, [...args], { encoding: "utf8", shell: false, timeout: PROBE_TIMEOUT_MS,
@@ -258,25 +437,61 @@ function output(stdout, stderr) {
         throw new Error("Agent probe output exceeded 1 MiB.");
     return value;
 }
-function supports(version, baseline) {
-    const left = version.split(".").map(Number), right = baseline.split(".").map(Number);
+function supports(version, adapter) {
+    if (adapter.id === "codex")
+        return compareVersions(version, adapter.supportedVersion) >= 0;
+    const left = version.split(".").map(Number), right = adapter.supportedVersion.split(".").map(Number);
     return left[0] === right[0] && left[1] === right[1] && left[2] >= right[2];
 }
+function compareVersions(leftVersion, rightVersion) {
+    const left = leftVersion.split(".").map(Number);
+    const right = rightVersion.split(".").map(Number);
+    for (let index = 0; index < 3; index += 1) {
+        const difference = (left[index] ?? 0) - (right[index] ?? 0);
+        if (difference !== 0)
+            return difference;
+    }
+    return 0;
+}
+function missingCodexCapabilities(help) {
+    const required = [
+        [/(?:^|\s)--config(?:\s|[=<,]|$)/m, "--config"],
+        [/^\s*resume(?:\s|$)/m, "resume"]
+    ];
+    return required.flatMap(([pattern, label]) => pattern.test(help) ? [] : [label]);
+}
 function cloneConfig(config, paths) {
     const advancedConfig = config.advanced?.rawArgs === undefined ? config.advanced : { rawArgs: [...config.advanced.rawArgs] };
     if (config.adapterId === "codex")
         return { ...config,
-            ...(config.permission === undefined ? {} : { permission: { ...config.permission } }),
+            permission: { ...config.permission },
             ...(paths === undefined ? {} : { additionalDirectories: [...paths] }),
             ...(advancedConfig === undefined ? {} : { advanced: advancedConfig }) };
     return { ...config,
-        ...(config.permission === undefined ? {} : { permission: { ...config.permission,
+        permission: config.permission.strategy === "configured"
+            ? { ...config.permission,
                 ...(config.permission.allowedTools === undefined ? {} : { allowedTools: [...config.permission.allowedTools] }),
-                ...(config.permission.disallowedTools === undefined ? {} : { disallowedTools: [...config.permission.disallowedTools] }) } }),
+                ...(config.permission.disallowedTools === undefined ? {} : { disallowedTools: [...config.permission.disallowedTools] }) }
+            : { ...config.permission },
         ...(paths === undefined ? {} : { additionalDirectories: [...paths] }),
         ...(config.settingsSources === undefined ? {} : { settingsSources: [...config.settingsSources] }),
         ...(advancedConfig === undefined ? {} : { advanced: advancedConfig }) };
 }
+export function defaultRoleAgentConfig(adapterId) {
+    return adapterId === "codex"
+        ? { adapterId: "codex", permission: { strategy: "bypass" } }
+        : { adapterId: "claude", permission: { strategy: "bypass" } };
+}
+function validateSimplePermissionStrategy(value, label) {
+    if (value !== "default" && value !== "bypass") {
+        throw new Error(`${label} is invalid.`);
+    }
+}
+function requireConfiguredPermissionOption(permission, provider) {
+    if (Object.keys(permission).every((key) => key === "strategy")) {
+        throw new Error(`${provider} configured permission requires at least one provider-native option.`);
+    }
+}
 function advanced(id, value) {
     if (value === undefined)
         return;