@zq-silk/yui 0.0.0

package/dist/doctor/doctor.js

@@ -0,0 +1,229 @@
+import { accessSync, constants, existsSync, lstatSync } from "node:fs";
+import { join } from "node:path";
+import { configuredAgentToDefinition } from "../agent/agent.js";
+import { inspectAgentCapabilities } from "../executor/agentAdapter.js";
+import { usageError } from "../errors/cliError.js";
+import { defaultTableWidth, renderTable } from "../output/table.js";
+import { FileTaskStore, resolveYuiHome, STORAGE_STATE_FILE } from "../storage/taskStore.js";
+import { inspectStorageSchema } from "../storage/storageSchema.js";
+import { CommandExecutionError } from "../tmux/commandExecutor.js";
+/** Runs the read-only FileTaskStore diagnostics used by `yui doctor`. */
+export function runDoctorCommand(args, env, executor) {
+    if (args.length !== 0)
+        throw usageError("Doctor usage: yui doctor");
+    return renderDoctor(getDoctorChecks(env, executor));
+}
+export function getDoctorChecks(env, executor) {
+    const home = resolveYuiHome(env);
+    const homeCheck = checkHome(home);
+    const schema = readSchema(home);
+    const schemaCheck = checkSchema(schema);
+    const storage = inspectState(home, homeCheck, schema);
+    return [
+        homeCheck,
+        schemaCheck,
+        storage.check,
+        checkExecutable("git", env.YUI_GIT_BIN ?? "git", ["--version"], executor),
+        checkExecutable("tmux", env.YUI_TMUX_BIN ?? "tmux", ["-V"], executor),
+        ...storage.agents.flatMap((agent) => checkAgent(agent, executor))
+    ];
+}
+export function renderDoctor(checks) {
+    return `Yui doctor\n${renderTable("Checks", [
+        { header: "Check", minWidth: 8, maxWidth: 28 },
+        { header: "Status", minWidth: 7, maxWidth: 11 },
+        { header: "Detail", minWidth: 12, maxWidth: 88 }
+    ], checks.map((check) => [check.name, check.status, check.detail]), defaultTableWidth())}\n`;
+}
+function checkHome(home) {
+    try {
+        const metadata = lstatSync(home);
+        if (!metadata.isDirectory() || metadata.isSymbolicLink()) {
+            return {
+                name: "yui home",
+                status: "invalid",
+                detail: "YUI_HOME must be a real directory."
+            };
+        }
+        accessSync(home, constants.R_OK);
+        return { name: "yui home", status: "ok", detail: home };
+    }
+    catch (error) {
+        if (systemCode(error) === "ENOENT") {
+            return { name: "yui home", status: "missing", detail: "run yui setup" };
+        }
+        return { name: "yui home", status: "invalid", detail: errorMessage(error) };
+    }
+}
+function readSchema(home) {
+    try {
+        return inspectStorageSchema(home);
+    }
+    catch (error) {
+        return { status: "read-error", detail: errorMessage(error) };
+    }
+}
+function checkSchema(state) {
+    switch (state.status) {
+        case "uninitialized":
+            return { name: "storage schema", status: "missing", detail: "run yui setup" };
+        case "current":
+            return {
+                name: "storage schema",
+                status: "ok",
+                detail: `current=${state.currentVersion} latest=${state.latestVersion}`
+            };
+        case "unsupported":
+            return {
+                name: "storage schema",
+                status: "unsupported",
+                detail: `current=${state.currentVersion} latest=${state.latestVersion} direction=${state.direction}`
+            };
+        case "invalid":
+            return { name: "storage schema", status: "invalid", detail: state.detail };
+        case "read-error":
+            return { name: "storage schema", status: "invalid", detail: state.detail };
+    }
+}
+function inspectState(home, homeCheck, schema) {
+    if (homeCheck.status !== "ok") {
+        return blockedStorage(homeCheck.status, homeCheck.detail);
+    }
+    if (schema.status === "uninitialized") {
+        return blockedStorage("missing", "run yui setup");
+    }
+    if (schema.status === "unsupported") {
+        return blockedStorage("unsupported", `current=${schema.currentVersion} latest=${schema.latestVersion}`);
+    }
+    if (schema.status === "invalid")
+        return blockedStorage("invalid", schema.detail);
+    if (schema.status === "read-error")
+        return blockedStorage("invalid", schema.detail);
+    const statePath = join(home, STORAGE_STATE_FILE);
+    if (!existsSync(statePath))
+        return blockedStorage("missing", "run yui setup");
+    try {
+        const metadata = lstatSync(statePath);
+        if (!metadata.isFile() || metadata.isSymbolicLink()) {
+            return blockedStorage("invalid", `${STORAGE_STATE_FILE} must be a regular file.`);
+        }
+        accessSync(statePath, constants.R_OK);
+        const store = new FileTaskStore(home);
+        const config = store.getConfig();
+        const agents = store.listConfiguredAgents();
+        const tasks = store.listTasks();
+        const globalRoles = store.listGlobalRoles();
+        const roleCount = tasks.reduce((count, task) => count + store.listRoles(task.id).length, 0);
+        return {
+            check: {
+                name: "storage state",
+                status: "ok",
+                detail: `readable agents=${agents.length} tasks=${tasks.length} roles=${roleCount} globalRoles=${globalRoles.length} defaultAgent=${config.defaultAgent ?? "none"}`
+            },
+            agents
+        };
+    }
+    catch (error) {
+        return blockedStorage("invalid", errorMessage(error));
+    }
+}
+function blockedStorage(status, detail) {
+    return {
+        check: { name: "storage state", status, detail },
+        agents: []
+    };
+}
+function checkExecutable(name, command, args, executor) {
+    try {
+        const output = firstLine(executor.run(command, args));
+        return {
+            name,
+            status: "ok",
+            detail: output.length === 0 ? command : `${command}: ${output}`
+        };
+    }
+    catch (error) {
+        return {
+            name,
+            status: isMissingCommand(error) ? "missing" : "invalid",
+            detail: `${command}: ${commandFailure(error)}`
+        };
+    }
+}
+function checkAgent(agent, executor) {
+    let snapshot;
+    try {
+        snapshot = inspectAgentCapabilities(configuredAgentToDefinition(agent), {
+            run: (command, args) => runAgentProbe(executor, command, args)
+        });
+    }
+    catch (error) {
+        return [{
+                name: `agent:${agent.id}`,
+                status: "invalid",
+                detail: `${agent.command}: ${errorMessage(error)}`
+            }];
+    }
+    const installation = snapshot.installation;
+    const status = installation.status === "installed"
+        ? "ok"
+        : installation.status === "missing"
+            ? "missing"
+            : installation.status === "unsupported-version" ? "unsupported" : "invalid";
+    const commandDetail = [
+        `command=${installation.command}`,
+        `adapter=${snapshot.adapterId}`,
+        ...(installation.version === undefined ? [] : [`version=${installation.version}`]),
+        ...(installation.reason === undefined ? [] : [`reason=${installation.reason}`])
+    ].join(" ");
+    const available = snapshot.fields.filter((field) => field.status === "available").length;
+    const degraded = snapshot.fields.filter((field) => field.status === "degraded").length;
+    const unavailable = snapshot.fields.filter((field) => field.status === "unavailable").length;
+    return [
+        { name: `agent:${agent.id}:command`, status, detail: commandDetail },
+        {
+            name: `agent:${agent.id}:capability`,
+            status,
+            detail: `start resume interrupt nativeSession=${snapshot.lifecycle.nativeSessionDiscovery} fields=${available}/${degraded}/${unavailable}`
+        }
+    ];
+}
+function runAgentProbe(executor, command, args) {
+    try {
+        return { status: 0, stdout: executor.run(command, [...args]), stderr: "" };
+    }
+    catch (error) {
+        const missing = isMissingCommand(error);
+        const probeError = Object.assign(new Error(errorMessage(error)), {
+            ...(missing ? { code: "ENOENT" } : {})
+        });
+        return {
+            status: error instanceof CommandExecutionError ? error.exitStatus ?? null : null,
+            stdout: "",
+            stderr: error instanceof CommandExecutionError ? error.stderr : "",
+            error: probeError
+        };
+    }
+}
+function isMissingCommand(error) {
+    return error instanceof CommandExecutionError
+        ? error.code === "COMMAND_NOT_FOUND"
+        : systemCode(error) === "ENOENT";
+}
+function commandFailure(error) {
+    if (error instanceof CommandExecutionError) {
+        return error.stderr.trim() || error.message;
+    }
+    return errorMessage(error);
+}
+function firstLine(output) {
+    return output.trim().split(/\r?\n/, 1)[0] ?? "";
+}
+function systemCode(error) {
+    return error instanceof Error && "code" in error && typeof error.code === "string"
+        ? error.code
+        : undefined;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/errors/cliError.js

@@ -0,0 +1,38 @@
+const EXIT_CODES = {
+    USAGE_ERROR: 2,
+    TASK_NOT_FOUND: 3,
+    ROLE_NOT_FOUND: 3,
+    AGENT_NOT_FOUND: 3,
+    DATA_ERROR: 4,
+    RUNTIME_ERROR: 5
+};
+export class CliError extends Error {
+    code;
+    helpText;
+    exitCode;
+    constructor(code, message, helpText) {
+        super(message);
+        this.code = code;
+        this.helpText = helpText;
+        this.name = "CliError";
+        this.exitCode = EXIT_CODES[code];
+    }
+}
+export function usageError(message, helpText) {
+    return new CliError("USAGE_ERROR", message, helpText);
+}
+export function taskNotFound(id) {
+    return new CliError("TASK_NOT_FOUND", `Task not found: ${id}`);
+}
+export function roleNotFound(name) {
+    return new CliError("ROLE_NOT_FOUND", `Role not found: ${name}`);
+}
+export function agentNotFound(id) {
+    return new CliError("AGENT_NOT_FOUND", `Agent not found: ${id}`);
+}
+export function dataError(message) {
+    return new CliError("DATA_ERROR", message);
+}
+export function runtimeError(message) {
+    return new CliError("RUNTIME_ERROR", message);
+}

package/dist/event/taskEvent.js

@@ -0,0 +1,44 @@
+export function createTaskEvent(id, type, payload, now) {
+    return {
+        schemaVersion: 1,
+        id: requireText(id, "Task event id"),
+        type: requireText(type, "Task event type"),
+        payload: normalizePayload(payload),
+        createdAt: now.toISOString()
+    };
+}
+/**
+ * Builds the next Event history without mutating or replacing an existing entry.
+ * Persistence adapters should enforce the same unique-id rule when appending.
+ */
+export function appendTaskEvent(history, event) {
+    if (history.some((existing) => existing.id === event.id)) {
+        throw new Error(`Task event already exists: ${event.id}.`);
+    }
+    return [...history, { ...event, payload: { ...event.payload } }];
+}
+function normalizePayload(payload) {
+    const normalized = {};
+    for (const [key, value] of Object.entries(payload)) {
+        const normalizedKey = requireText(key, "Task event payload key");
+        if (["__proto__", "prototype", "constructor"].includes(normalizedKey)) {
+            throw new Error(`Task event payload key is invalid: ${normalizedKey}.`);
+        }
+        if (Object.hasOwn(normalized, normalizedKey)) {
+            throw new Error(`Task event payload key is duplicated: ${normalizedKey}.`);
+        }
+        if (typeof value !== "string" || value.includes("\0")) {
+            throw new Error(`Task event payload value is invalid: ${normalizedKey}.`);
+        }
+        normalized[normalizedKey] = value;
+    }
+    return normalized;
+}
+function requireText(value, label) {
+    if (typeof value !== "string" || value.includes("\0"))
+        throw new Error(`${label} is invalid.`);
+    const normalized = value.trim();
+    if (normalized.length === 0)
+        throw new Error(`${label} is required.`);
+    return normalized;
+}

package/dist/executor/agentAdapter.js

@@ -0,0 +1,338 @@
+import { spawnSync } from "node:child_process";
+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";
+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;
+class BaseAdapter {
+    validateConfig(input) {
+        if (input.agent.adapterId !== this.id || input.config.adapterId !== this.id) {
+            throw new Error(`Agent adapter identity mismatch: expected ${this.id}.`);
+        }
+        validateAgentBaseArguments(this.id, input.agent.baseArgs);
+        this.validateStructured(input.config);
+    }
+    compileNew(input) {
+        this.validateConfig(input);
+        const config = this.canonicalizeConfig(input.config);
+        return {
+            argv: [...input.agent.baseArgs, ...this.structuredArgs(config), ...(config.advanced?.rawArgs ?? [])],
+            sessionStrategy: this.capabilities.nativeSessionDiscovery === "runtime"
+                ? "runtime-discovery"
+                : "preallocated"
+        };
+    }
+    canonicalizeConfig(config) {
+        this.validateStructured(config);
+        const directories = config.additionalDirectories === undefined
+            ? undefined
+            : canonicalDirectories(config.additionalDirectories);
+        return cloneConfig(config, directories);
+    }
+    reservedArguments() {
+        return ownedArgumentsForAdapter(this.id);
+    }
+}
+class CodexAdapter extends BaseAdapter {
+    id = "codex";
+    label = "Codex";
+    supportedVersion = "0.144.1";
+    capabilities = { recover: true, interrupt: true, nativeSessionDiscovery: "runtime" };
+    validateStructured(config) {
+        exact(config, ["adapterId", "model", "effort", "permission", "search", "profile",
+            "additionalDirectories", "advanced"], "Codex Agent config");
+        if (config.adapterId !== "codex")
+            throw new Error("Codex Agent config adapter is invalid.");
+        optionalText(config.model, "Codex model");
+        optionalText(config.effort, "Codex effort");
+        optionalText(config.profile, "Codex profile");
+        if (config.search !== undefined && typeof config.search !== "boolean") {
+            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)) {
+                throw new Error("Codex sandbox is invalid.");
+            }
+            if (config.permission.approval !== undefined && !APPROVALS.includes(config.permission.approval)) {
+                throw new Error("Codex approval is invalid.");
+            }
+        }
+        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.
+            "--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.search === true ? ["--search"] : []),
+            ...(config.profile === undefined ? [] : ["--profile", config.profile]),
+            ...(config.additionalDirectories ?? []).flatMap((path) => ["--add-dir", path])
+        ];
+    }
+    compileResume(input) {
+        const launch = this.compileNew(input);
+        return { ...launch, argv: [...launch.argv, "resume", nativeId(input.nativeSessionId)] };
+    }
+}
+class ClaudeAdapter extends BaseAdapter {
+    id = "claude";
+    label = "Claude";
+    supportedVersion = "2.1.207";
+    capabilities = { recover: true, interrupt: true, nativeSessionDiscovery: "preallocated" };
+    validateStructured(config) {
+        exact(config, ["adapterId", "model", "effort", "permission", "additionalDirectories",
+            "settingsFile", "settingsSources", "advanced"], "Claude Agent config");
+        if (config.adapterId !== "claude")
+            throw new Error("Claude Agent config adapter is invalid.");
+        optionalText(config.model, "Claude model");
+        optionalText(config.effort, "Claude effort");
+        validatePaths(config.additionalDirectories, "Claude additional directory");
+        if (config.settingsFile !== undefined)
+            absolutePath(config.settingsFile, "Claude settings file");
+        optionalTexts(config.settingsSources, "Claude settings source");
+        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");
+            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.");
+                }
+            }
+        }
+        advanced(this.id, config.advanced);
+    }
+    structuredArgs(config) {
+        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.additionalDirectories ?? []).flatMap((path) => ["--add-dir", path]),
+            ...(config.settingsFile === undefined ? [] : ["--settings", config.settingsFile]),
+            ...(config.settingsSources === undefined ? [] : ["--setting-sources", config.settingsSources.join(",")])
+        ];
+    }
+    compileResume(input) {
+        const launch = this.compileNew(input);
+        return { ...launch, argv: [...launch.argv, "--resume", nativeId(input.nativeSessionId)] };
+    }
+}
+const ADAPTERS = {
+    codex: new CodexAdapter(), claude: new ClaudeAdapter()
+};
+export { supportedAgentAdapterIds };
+export function findAgentAdapter(id) {
+    return id === "codex" || id === "claude" ? ADAPTERS[id] : null;
+}
+export function resolveAgentAdapter(id) {
+    const adapter = findAgentAdapter(id);
+    if (adapter === null)
+        throw new Error(`Agent adapter is unsupported: ${id}.`);
+    return adapter;
+}
+export function inspectAgentCapabilities(agent, optionsOrNow = {}) {
+    const options = optionsOrNow instanceof Date ? { now: optionsOrNow } : optionsOrNow;
+    const now = options.now ?? new Date();
+    const run = options.run ?? runProbe;
+    const at = now.toISOString();
+    const adapter = resolveAgentAdapter(agent.adapterId);
+    validateAgentBaseArguments(agent.adapterId, agent.baseArgs);
+    const versionRun = run(agent.command, ["--version"]);
+    const failure = failed(versionRun);
+    if (failure !== undefined) {
+        const missing = versionRun.error?.code === "ENOENT";
+        return snapshot(agent, adapter, {
+            status: missing ? "missing" : "probe-failed", command: agent.command,
+            reason: missing ? "Agent command was not found." : failure, probedAt: at
+        }, baseline(agent.adapterId), at);
+    }
+    const version = /(?:^|\D)(\d+\.\d+\.\d+)(?:\D|$)/m
+        .exec(output(versionRun.stdout, versionRun.stderr))?.[1];
+    if (version === undefined) {
+        return snapshot(agent, adapter, {
+            status: "probe-failed", command: agent.command,
+            reason: "Agent version probe did not return a semantic version.", probedAt: at
+        }, baseline(agent.adapterId), at);
+    }
+    const supported = supports(version, adapter.supportedVersion);
+    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));
+    }
+    return snapshot(agent, adapter, {
+        status: supported ? "installed" : "unsupported-version", command: agent.command, version,
+        ...(supported ? {} : { reason: `Supported version line starts at ${adapter.supportedVersion}.` }),
+        probedAt: at
+    }, fields, at, warnings);
+}
+function baseline(id) {
+    if (id === "codex")
+        return [
+            field("model", "enum", "degraded", true), field("effort", "enum", "unavailable", true),
+            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"]),
+            field("additionalDirectories", "path-list", "available", true)
+        ];
+    return [
+        field("model", "enum", "degraded", true, ["fable", "opus", "sonnet"]),
+        field("effort", "enum", "unavailable", true), 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),
+        field("settingsSources", "string-list", "degraded", false, ["user", "project", "local"])
+    ];
+}
+function fromHelp(id, help) {
+    const fields = baseline(id);
+    const replacements = id === "codex"
+        ? [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),
+            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 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);
+}
+function field(key, kind, status, allowCustom, choices) {
+    return { key, kind, status, allowCustom, ...(choices === undefined ? {} : { choices: [...choices] }) };
+}
+function helpChoices(help, flag) {
+    const lines = help.replace(/\r\n/g, "\n").split("\n");
+    const start = lines.findIndex((line) => line.includes(flag));
+    if (start < 0)
+        return [];
+    let end = start + 1;
+    while (end < lines.length && !/^\s{2,}(?:-[A-Za-z](?:,\s*)?|--)[\w-]/.test(lines[end]))
+        end += 1;
+    const body = /(?:\[possible values:\s*([^\]]+)\]|\(choices:\s*([^)]*)\)|\(([^)]*)\))/i
+        .exec(lines.slice(start, end).join("\n"));
+    return [...new Set((body?.[1] ?? body?.[2] ?? body?.[3] ?? "").replace(/["']/g, "").split(",")
+            .map((value) => value.trim().replace(/\.$/, "")).filter((value) => /^[\w.+-]+$/.test(value)))];
+}
+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 };
+}
+function runProbe(command, args) {
+    const result = spawnSync(command, [...args], { encoding: "utf8", shell: false, timeout: PROBE_TIMEOUT_MS,
+        maxBuffer: PROBE_MAX_BYTES, stdio: ["ignore", "pipe", "pipe"] });
+    return { status: result.status, stdout: String(result.stdout ?? ""), stderr: String(result.stderr ?? ""),
+        ...(result.error === undefined ? {} : { error: result.error }) };
+}
+function failed(result) {
+    if (result.error !== undefined)
+        return result.error.code === "ETIMEDOUT"
+            ? `Agent probe timed out after ${PROBE_TIMEOUT_MS} ms.` : "Agent probe failed to start.";
+    return result.status === 0 ? undefined : `Agent probe exited with status ${result.status ?? "unknown"}.`;
+}
+function output(stdout, stderr) {
+    const value = `${stdout}\n${stderr}`;
+    if (Buffer.byteLength(value, "utf8") > PROBE_MAX_BYTES)
+        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);
+    return left[0] === right[0] && left[1] === right[1] && left[2] >= right[2];
+}
+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 } }),
+            ...(paths === undefined ? {} : { additionalDirectories: [...paths] }),
+            ...(advancedConfig === undefined ? {} : { advanced: advancedConfig }) };
+    return { ...config,
+        ...(config.permission === undefined ? {} : { permission: { ...config.permission,
+                ...(config.permission.allowedTools === undefined ? {} : { allowedTools: [...config.permission.allowedTools] }),
+                ...(config.permission.disallowedTools === undefined ? {} : { disallowedTools: [...config.permission.disallowedTools] }) } }),
+        ...(paths === undefined ? {} : { additionalDirectories: [...paths] }),
+        ...(config.settingsSources === undefined ? {} : { settingsSources: [...config.settingsSources] }),
+        ...(advancedConfig === undefined ? {} : { advanced: advancedConfig }) };
+}
+function advanced(id, value) {
+    if (value === undefined)
+        return;
+    exact(value, ["rawArgs"], "Advanced Agent config");
+    validateAgentAdvancedArguments(id, value.rawArgs ?? []);
+}
+function validatePaths(values, label) {
+    optionalTexts(values, label);
+    for (const value of values ?? [])
+        absolutePath(value, label);
+}
+function canonicalDirectories(values) {
+    return [...new Set(values.map((value) => {
+            absolutePath(value, "Additional directory");
+            let path;
+            try {
+                path = realpathSync(value);
+            }
+            catch {
+                throw new Error("Additional directory does not exist or cannot be resolved.");
+            }
+            if (!statSync(path).isDirectory())
+                throw new Error("Additional directory is not a directory.");
+            return path;
+        }))].sort();
+}
+function absolutePath(value, label) {
+    text(value, label);
+    if (!isAbsolute(value) || resolve(value) !== value || /[\r\n\0{}]/.test(value)) {
+        throw new Error(`${label} must be an absolute canonical path.`);
+    }
+}
+function optionalText(value, label) {
+    if (value !== undefined)
+        text(value, label);
+}
+function optionalTexts(values, label) {
+    if (values === undefined)
+        return;
+    if (!Array.isArray(values))
+        throw new Error(`${label} list must be an array.`);
+    values.forEach((value) => text(value, label));
+}
+function text(value, label) {
+    if (typeof value !== "string" || value.trim().length === 0 || value.includes("\0")) {
+        throw new Error(`${label} must be a non-empty string.`);
+    }
+}
+function exact(value, keys, label) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)
+        || Object.keys(value).some((key) => !keys.includes(key)))
+        throw new Error(`${label} contains an unsupported field.`);
+}
+function nativeId(value) {
+    text(value, "Native session id");
+    if (value.trim() !== value)
+        throw new Error("Native session id must not contain surrounding whitespace.");
+    return value;
+}