@companyhelm/runner 0.2.0 → 0.4.0

package/dist/commands/runner/common.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addRunnerStartOptions = addRunnerStartOptions;
-const global_options_js_1 = require("../global-options.js");
-function addRunnerStartOptions(command) {
-    return command
-        .option("--config-path <path>", global_options_js_1.CONFIG_PATH_OPTION_DESCRIPTION)
-        .option("--server-url <url>", "CompanyHelm gRPC API URL override.")
-        .option("--agent-api-url <url>", "Agent REST API base URL for runtime containers (localhost is rewritten to http://host.docker.internal).")
-        .option("--workspace-path <path>", "Shared host workspace mounted at /workspace (defaults to the current working directory).")
-        .option("--secret <secret>", "Bearer secret used as gRPC Authorization header.")
-        .option("--state-db-path <path>", "State database path override (defaults to state.db under the active config directory).")
-        .option("--log-path <path>", "Daemon log file override.")
-        .option("--use-host-docker-runtime", "Mount host Docker socket into runtime containers instead of creating DinD sidecars.")
-        .option("--use-dedicated-auth", "Preserve existing dedicated Codex auth if already configured; otherwise keep Codex unconfigured on startup.")
-        .option("--use-dedicated-workspaces", "Create per-thread dedicated workspaces under the configured workspaces directory.")
-        .option("--host-docker-path <path>", "Host Docker endpoint when --use-host-docker-runtime is enabled (unix:///<socket-path> or tcp://localhost:<port>).")
-        .option("--thread-git-skills-directory <path>", "Container path where thread git skill repositories are cloned before linking into ~/.codex/skills.")
-        .option("-d, --daemon", "Run in daemon mode and fail fast when no SDK is configured.")
-        .option("--log-level <level>", "Log level (DEBUG, INFO, WARN, ERROR).", "INFO");
-}

package/dist/commands/runner/start.js

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runRunnerStartCommand = runRunnerStartCommand;
-exports.registerRunnerStartCommand = registerRunnerStartCommand;
-const root_js_1 = require("../root.js");
-const common_js_1 = require("./common.js");
-async function runRunnerStartCommand(options) {
-    if (options.daemon && !(0, root_js_1.isInternalDaemonChildProcess)()) {
-        await (0, root_js_1.runDetachedDaemonProcess)(options);
-        return;
-    }
-    try {
-        await (0, root_js_1.runRootCommand)(options, (0, root_js_1.isInternalDaemonChildProcess)()
-            ? {
-                onDaemonReady: () => {
-                    (0, root_js_1.sendDaemonParentMessage)({ type: "daemon-ready" });
-                },
-                onDaemonProgress: (message) => {
-                    (0, root_js_1.sendDaemonParentMessage)({ type: "daemon-progress", message });
-                },
-            }
-            : undefined);
-    }
-    catch (error) {
-        if ((0, root_js_1.isInternalDaemonChildProcess)()) {
-            (0, root_js_1.sendDaemonParentMessage)({ type: "daemon-error", message: (0, root_js_1.toErrorMessage)(error) });
-        }
-        throw error;
-    }
-}
-function registerRunnerStartCommand(runnerCommand) {
-    (0, common_js_1.addRunnerStartOptions)(runnerCommand
-        .command("start")
-        .description("Start the local CompanyHelm runner daemon.")).action(runRunnerStartCommand);
-}

package/dist/commands/runner/stop.js

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runRunnerStopCommand = runRunnerStopCommand;
-exports.registerRunnerStopCommand = registerRunnerStopCommand;
-const config_js_1 = require("../../config.js");
-const daemon_state_js_1 = require("../../state/daemon_state.js");
-const process_js_1 = require("../../utils/process.js");
-const root_js_1 = require("../root.js");
-const RUNNER_STOP_TIMEOUT_MS = 15000;
-async function waitForProcessExit(pid, timeoutMs) {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        if (!(0, process_js_1.isProcessRunning)(pid)) {
-            return true;
-        }
-        await new Promise((resolve) => setTimeout(resolve, 100));
-    }
-    return !(0, process_js_1.isProcessRunning)(pid);
-}
-async function runRunnerStopCommand(options) {
-    const cfg = config_js_1.config.parse({
-        state_db_path: options.stateDbPath,
-    });
-    const state = await (0, daemon_state_js_1.readCurrentDaemonState)(cfg.state_db_path);
-    if (!state?.pid) {
-        console.log("CompanyHelm runner is not running.");
-        return;
-    }
-    if (!(0, process_js_1.isProcessRunning)(state.pid)) {
-        await (0, daemon_state_js_1.clearCurrentDaemonState)(cfg.state_db_path, state.pid);
-        console.log(`CompanyHelm runner was not running. Cleared stale pid ${state.pid}.`);
-        return;
-    }
-    try {
-        process.kill(state.pid, "SIGTERM");
-    }
-    catch (error) {
-        throw new Error(`Failed to stop CompanyHelm runner pid ${state.pid}: ${(0, root_js_1.toErrorMessage)(error)}`);
-    }
-    const stopped = await waitForProcessExit(state.pid, RUNNER_STOP_TIMEOUT_MS);
-    if (!stopped) {
-        throw new Error(`Timed out waiting for CompanyHelm runner pid ${state.pid} to stop.`);
-    }
-    await (0, daemon_state_js_1.clearCurrentDaemonState)(cfg.state_db_path, state.pid);
-    console.log(`CompanyHelm runner stopped (pid ${state.pid}).`);
-}
-function registerRunnerStopCommand(runnerCommand) {
-    runnerCommand
-        .command("stop")
-        .description("Stop the local CompanyHelm runner daemon.")
-        .option("--state-db-path <path>", "State database path override (defaults to state.db under the active config directory).")
-        .action(async (options) => {
-        await runRunnerStopCommand(options);
-    });
-}

package/dist/commands/sdk/codex/auth.js

@@ -1,435 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultUseDedicatedCodexAuthDependencies = exports.defaultEnsureCodexRunnerStartStateDependencies = exports.defaultSetCodexHostAuthDependencies = void 0;
-exports.isErrnoException = isErrnoException;
-exports.buildDockerMissingError = buildDockerMissingError;
-exports.ensureDockerAvailable = ensureDockerAvailable;
-exports.extractCodexDeviceCodeFromOutput = extractCodexDeviceCodeFromOutput;
-exports.listCodexStartupAuthOptions = listCodexStartupAuthOptions;
-exports.setCodexHostAuthInDb = setCodexHostAuthInDb;
-exports.setCodexDedicatedAuthInDb = setCodexDedicatedAuthInDb;
-exports.setCodexApiKeyAuthInDb = setCodexApiKeyAuthInDb;
-exports.setCodexUnconfiguredInDb = setCodexUnconfiguredInDb;
-exports.ensureCodexRunnerStartState = ensureCodexRunnerStartState;
-exports.runSetCodexHostAuth = runSetCodexHostAuth;
-exports.runDedicatedCodexAuth = runDedicatedCodexAuth;
-exports.runCodexApiKeyAuth = runCodexApiKeyAuth;
-exports.runCodexDeviceCodeAuth = runCodexDeviceCodeAuth;
-exports.runUseDedicatedCodexAuth = runUseDedicatedCodexAuth;
-const node_child_process_1 = require("node:child_process");
-const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
-const drizzle_orm_1 = require("drizzle-orm");
-const host_js_1 = require("../../../service/host.js");
-const db_js_1 = require("../../../state/db.js");
-const schema_js_1 = require("../../../state/schema.js");
-const path_js_1 = require("../../../utils/path.js");
-exports.defaultSetCodexHostAuthDependencies = {
-    getHostInfoFn: host_js_1.getHostInfo,
-    initDbFn: db_js_1.initDb,
-};
-exports.defaultEnsureCodexRunnerStartStateDependencies = {
-    ...exports.defaultSetCodexHostAuthDependencies,
-    logInfo: () => undefined,
-    useDedicatedAuth: false,
-};
-exports.defaultUseDedicatedCodexAuthDependencies = {
-    initDbFn: db_js_1.initDb,
-    logInfo: console.log,
-    logSuccess: console.log,
-    spawnCommand: node_child_process_1.spawn,
-    spawnSyncCommand: node_child_process_1.spawnSync,
-};
-function isDedicatedCodexAuthentication(authentication) {
-    return authentication === "dedicated" || authentication === "api-key";
-}
-function resolveContainerPath(pathValue, containerHome) {
-    if (pathValue === "~") {
-        return containerHome;
-    }
-    if (pathValue.startsWith("~/")) {
-        return `${containerHome}${pathValue.slice(1)}`;
-    }
-    return pathValue;
-}
-function shellQuote(value) {
-    return `'${value.replace(/'/g, `'"'"'`)}'`;
-}
-function buildCodexLoginShellCommand(cfg, loginCommand) {
-    const hostInfo = (0, host_js_1.getHostInfo)(cfg.codex.codex_auth_path);
-    const containerAuthPath = resolveContainerPath(cfg.codex.codex_auth_path, cfg.agent_home_directory);
-    return [
-        `AGENT_USER=${shellQuote(cfg.agent_user)}`,
-        `AGENT_HOME=${shellQuote(cfg.agent_home_directory)}`,
-        `AGENT_UID=${shellQuote(String(hostInfo.uid))}`,
-        `AGENT_GID=${shellQuote(String(hostInfo.gid))}`,
-        `CODEX_AUTH_PATH=${shellQuote(containerAuthPath)}`,
-        `CODEX_LOGIN_COMMAND=${shellQuote(`source "$NVM_DIR/nvm.sh"; ${loginCommand}`)}`,
-        'EXISTING_UID_USER=""',
-        'if getent passwd "$AGENT_UID" >/dev/null 2>&1; then',
-        '  EXISTING_UID_USER="$(getent passwd "$AGENT_UID" | cut -d: -f1)"',
-        '  AGENT_USER="$EXISTING_UID_USER"',
-        'fi',
-        'AGENT_GROUP="$AGENT_USER"',
-        'if getent group "$AGENT_GID" >/dev/null 2>&1; then',
-        '  AGENT_GROUP="$(getent group "$AGENT_GID" | cut -d: -f1)"',
-        'elif getent group "$AGENT_USER" >/dev/null 2>&1; then',
-        '  groupmod -g "$AGENT_GID" "$AGENT_USER"',
-        '  AGENT_GROUP="$AGENT_USER"',
-        'else',
-        '  groupadd -g "$AGENT_GID" "$AGENT_USER"',
-        '  AGENT_GROUP="$AGENT_USER"',
-        'fi',
-        'if id -u "$AGENT_USER" >/dev/null 2>&1; then',
-        '  usermod -u "$AGENT_UID" -g "$AGENT_GROUP" -d "$AGENT_HOME" -s /bin/bash "$AGENT_USER" || true',
-        'else',
-        '  useradd -m -d "$AGENT_HOME" -u "$AGENT_UID" -g "$AGENT_GROUP" -s /bin/bash "$AGENT_USER"',
-        'fi',
-        'mkdir -p "$AGENT_HOME" "$(dirname "$CODEX_AUTH_PATH")"',
-        'chown -R "$AGENT_UID:$AGENT_GID" "$AGENT_HOME" "$(dirname "$CODEX_AUTH_PATH")" || true',
-        'export HOME="$AGENT_HOME"',
-        'exec sudo -n -E -H -u "$AGENT_USER" bash -lc "$CODEX_LOGIN_COMMAND"',
-    ].join("\n");
-}
-function isErrnoException(error) {
-    return error instanceof Error && "code" in error;
-}
-function buildDockerMissingError() {
-    return new Error("Docker is not installed or not available on PATH. Install Docker and retry.");
-}
-function readSpawnSyncText(output) {
-    if (typeof output === "string") {
-        return output.trim();
-    }
-    if (Buffer.isBuffer(output)) {
-        return output.toString("utf8").trim();
-    }
-    return "";
-}
-function describeSpawnSyncFailure(command, args, result) {
-    if (isErrnoException(result.error)) {
-        return `${command} ${args.join(" ")} failed to start: ${result.error.message}`;
-    }
-    const parts = [`${command} ${args.join(" ")}`];
-    if (typeof result.status === "number") {
-        parts.push(`exit code ${result.status}`);
-    }
-    if (result.signal) {
-        parts.push(`signal ${result.signal}`);
-    }
-    const stderr = readSpawnSyncText(result.stderr);
-    if (stderr.length > 0) {
-        parts.push(`stderr: ${stderr}`);
-    }
-    const stdout = readSpawnSyncText(result.stdout);
-    if (stdout.length > 0) {
-        parts.push(`stdout: ${stdout}`);
-    }
-    return parts.join(", ");
-}
-function ensureDockerAvailable(spawnSyncCommand) {
-    const result = spawnSyncCommand("docker", ["--version"], { stdio: "ignore" });
-    if (isErrnoException(result.error) && result.error.code === "ENOENT") {
-        throw buildDockerMissingError();
-    }
-}
-function extractCodexDeviceCodeFromOutput(output) {
-    const normalizedOutput = output.replace(/\u001b\[[0-9;]*m/g, "");
-    const match = normalizedOutput.match(/Enter this one-time code[\s\S]*?\n\s*([A-Z0-9]{4,}(?:-[A-Z0-9]{4,})+)\s*(?:\n|$)/i);
-    return match?.[1]?.trim() ?? null;
-}
-async function runContainerizedCodexLogin(cfg, deps, options) {
-    ensureDockerAvailable(deps.spawnSyncCommand);
-    const configDir = (0, path_js_1.expandHome)(cfg.config_directory);
-    if (!(0, node_fs_1.existsSync)(configDir)) {
-        (0, node_fs_1.mkdirSync)(configDir, { recursive: true });
-    }
-    const destPath = (0, node_path_1.join)(configDir, cfg.codex.codex_auth_file_path);
-    const containerAuthPath = resolveContainerPath(cfg.codex.codex_auth_path, cfg.agent_home_directory);
-    let authCopied = false;
-    let combinedOutput = "";
-    let lastCopyFailure = null;
-    await new Promise((resolve, reject) => {
-        let settled = false;
-        let poll;
-        const cleanup = () => {
-            if (poll) {
-                clearInterval(poll);
-            }
-            deps.spawnSyncCommand("docker", ["rm", "-f", options.containerName], { stdio: "ignore" });
-        };
-        const tryCopyAuthFile = () => {
-            const cpArgs = ["cp", `${options.containerName}:${containerAuthPath}`, destPath];
-            const cpResult = deps.spawnSyncCommand("docker", cpArgs, {
-                stdio: ["ignore", "pipe", "pipe"],
-                encoding: "utf8",
-            });
-            if (cpResult.status !== 0) {
-                lastCopyFailure = describeSpawnSyncFailure("docker", cpArgs, cpResult);
-                return false;
-            }
-            authCopied = true;
-            lastCopyFailure = null;
-            cleanup();
-            return true;
-        };
-        const rejectOnce = (error) => {
-            if (settled) {
-                return;
-            }
-            settled = true;
-            cleanup();
-            reject(error);
-        };
-        const resolveOnce = () => {
-            if (settled) {
-                return;
-            }
-            settled = true;
-            cleanup();
-            resolve();
-        };
-        const child = deps.spawnCommand("docker", options.dockerArgs, { stdio: ["ignore", "pipe", "pipe"] });
-        const handleOutput = (chunk) => {
-            const text = chunk.toString("utf8");
-            combinedOutput += text;
-            options.onOutput?.(combinedOutput);
-        };
-        child.stdout.on("data", handleOutput);
-        child.stderr.on("data", handleOutput);
-        child.on("error", (error) => {
-            if (isErrnoException(error) && error.code === "ENOENT") {
-                rejectOnce(buildDockerMissingError());
-                return;
-            }
-            rejectOnce(new Error(`Failed to start Codex login container: ${error.message}`));
-        });
-        poll = setInterval(() => {
-            if (settled) {
-                return;
-            }
-            if (tryCopyAuthFile()) {
-                resolveOnce();
-            }
-        }, 1000);
-        child.on("exit", () => {
-            if (authCopied) {
-                resolveOnce();
-                return;
-            }
-            if (tryCopyAuthFile()) {
-                resolveOnce();
-                return;
-            }
-            const details = [];
-            if (lastCopyFailure) {
-                details.push(`Auth file copy failed from ${containerAuthPath}: ${lastCopyFailure}`);
-            }
-            if (combinedOutput.trim().length > 0) {
-                details.push(`Output: ${combinedOutput.trim()}`);
-            }
-            rejectOnce(new Error(`Codex login failed or was cancelled.${details.length > 0 ? ` ${details.join(" ")}` : ""}`));
-        });
-    });
-    return destPath;
-}
-function listCodexStartupAuthOptions(cfg, getHostInfoFn = host_js_1.getHostInfo) {
-    const options = [
-        {
-            value: "dedicated",
-            label: "Dedicated",
-            hint: "recommended -- runs Codex login inside a container",
-        },
-    ];
-    const hostInfo = getHostInfoFn(cfg.codex.codex_auth_path);
-    if (hostInfo.codexAuthExists) {
-        options.push({
-            value: "host",
-            label: "Host",
-            hint: `reuse existing credentials from ${cfg.codex.codex_auth_path}`,
-        });
-    }
-    return options;
-}
-async function upsertCodexSdkState(db, authentication, status) {
-    const existingSdk = await db.select().from(schema_js_1.agentSdks).where((0, drizzle_orm_1.eq)(schema_js_1.agentSdks.name, "codex")).get();
-    if (existingSdk) {
-        await db
-            .update(schema_js_1.agentSdks)
-            .set({ authentication, status })
-            .where((0, drizzle_orm_1.eq)(schema_js_1.agentSdks.name, "codex"));
-        return;
-    }
-    await db.insert(schema_js_1.agentSdks).values({ name: "codex", authentication, status });
-}
-async function setCodexHostAuthInDb(db) {
-    await upsertCodexSdkState(db, "host", "configured");
-}
-async function setCodexDedicatedAuthInDb(db) {
-    await upsertCodexSdkState(db, "dedicated", "configured");
-}
-async function setCodexApiKeyAuthInDb(db) {
-    await upsertCodexSdkState(db, "api-key", "configured");
-}
-async function setCodexUnconfiguredInDb(db) {
-    await upsertCodexSdkState(db, "unauthenticated", "unconfigured");
-}
-async function ensureCodexRunnerStartState(cfg, overrides = {}) {
-    const deps = {
-        ...exports.defaultEnsureCodexRunnerStartStateDependencies,
-        ...overrides,
-    };
-    const { db, client } = await deps.initDbFn(cfg.state_db_path);
-    try {
-        const existingSdk = await db.select().from(schema_js_1.agentSdks).where((0, drizzle_orm_1.eq)(schema_js_1.agentSdks.name, "codex")).get();
-        const hostInfo = deps.getHostInfoFn(cfg.codex.codex_auth_path);
-        const dedicatedAuthPath = (0, node_path_1.join)((0, path_js_1.expandHome)(cfg.config_directory), cfg.codex.codex_auth_file_path);
-        const dedicatedAuthInfo = deps.getHostInfoFn(dedicatedAuthPath);
-        if (deps.useDedicatedAuth) {
-            if (existingSdk?.status === "configured" &&
-                isDedicatedCodexAuthentication(existingSdk.authentication) &&
-                dedicatedAuthInfo.codexAuthExists) {
-                return;
-            }
-            await setCodexUnconfiguredInDb(db);
-            return;
-        }
-        if (existingSdk?.status === "configured") {
-            if (existingSdk.authentication === "host" && hostInfo.codexAuthExists) {
-                return;
-            }
-            if (isDedicatedCodexAuthentication(existingSdk.authentication) && dedicatedAuthInfo.codexAuthExists) {
-                return;
-            }
-        }
-        if (hostInfo.codexAuthExists) {
-            deps.logInfo(`Detected Codex host auth at ${(0, path_js_1.expandHome)(cfg.codex.codex_auth_path)}; using host auth automatically.`);
-            await setCodexHostAuthInDb(db);
-            return;
-        }
-        await setCodexUnconfiguredInDb(db);
-    }
-    finally {
-        client.close();
-    }
-}
-async function runSetCodexHostAuth(cfg, overrides = {}) {
-    const deps = { ...exports.defaultSetCodexHostAuthDependencies, ...overrides };
-    const authPath = (0, path_js_1.expandHome)(cfg.codex.codex_auth_path);
-    const hostInfo = deps.getHostInfoFn(cfg.codex.codex_auth_path);
-    if (!hostInfo.codexAuthExists) {
-        throw new Error(`Codex host auth file not found at ${authPath}.`);
-    }
-    const { db, client } = await deps.initDbFn(cfg.state_db_path);
-    try {
-        await setCodexHostAuthInDb(db);
-    }
-    finally {
-        client.close();
-    }
-    return authPath;
-}
-async function runDedicatedCodexAuth(cfg, db, deps) {
-    const containerName = `companyhelm-codex-auth-${Date.now()}`;
-    ensureDockerAvailable(deps.spawnSyncCommand);
-    const loginCommand = buildCodexLoginShellCommand(cfg, "codex login --device-auth");
-    deps.logInfo("Starting Codex login inside a container...");
-    deps.logInfo("A browser URL and device code will appear -- open it to complete authentication.");
-    const destPath = await runContainerizedCodexLogin(cfg, deps, {
-        containerName,
-        dockerArgs: [
-            "run",
-            "--name",
-            containerName,
-            "--entrypoint",
-            "bash",
-            cfg.runtime_image,
-            "-lc",
-            loginCommand,
-        ],
-    });
-    await setCodexDedicatedAuthInDb(db);
-    deps.logSuccess(`Codex auth saved to ${destPath}`);
-    return destPath;
-}
-async function runCodexApiKeyAuth(cfg, apiKey, overrides = {}) {
-    const deps = { ...exports.defaultUseDedicatedCodexAuthDependencies, ...overrides };
-    const { db, client } = await deps.initDbFn(cfg.state_db_path);
-    try {
-        deps.logInfo("Starting Codex API key login inside a container...");
-        const containerName = `companyhelm-codex-auth-${Date.now()}`;
-        ensureDockerAvailable(deps.spawnSyncCommand);
-        const loginCommand = buildCodexLoginShellCommand(cfg, 'printf \'%s\\n\' "$CODEX_API_KEY" | codex login --with-api-key');
-        const destPath = await runContainerizedCodexLogin(cfg, deps, {
-            containerName,
-            dockerArgs: [
-                "run",
-                "--name",
-                containerName,
-                "-e",
-                `CODEX_API_KEY=${apiKey}`,
-                "--entrypoint",
-                "bash",
-                cfg.runtime_image,
-                "-lc",
-                loginCommand,
-            ],
-        });
-        await setCodexApiKeyAuthInDb(db);
-        deps.logSuccess(`Codex auth saved to ${destPath}`);
-        return destPath;
-    }
-    finally {
-        client.close();
-    }
-}
-async function runCodexDeviceCodeAuth(cfg, onDeviceCode, overrides = {}) {
-    const deps = { ...exports.defaultUseDedicatedCodexAuthDependencies, ...overrides };
-    const { db, client } = await deps.initDbFn(cfg.state_db_path);
-    try {
-        let emittedDeviceCode = null;
-        let onDeviceCodePromise = Promise.resolve();
-        deps.logInfo("Starting Codex device login inside a container...");
-        const containerName = `companyhelm-codex-auth-${Date.now()}`;
-        ensureDockerAvailable(deps.spawnSyncCommand);
-        const loginCommand = buildCodexLoginShellCommand(cfg, "codex login --device-auth");
-        const destPath = await runContainerizedCodexLogin(cfg, deps, {
-            containerName,
-            dockerArgs: [
-                "run",
-                "--name",
-                containerName,
-                "--entrypoint",
-                "bash",
-                cfg.runtime_image,
-                "-lc",
-                loginCommand,
-            ],
-            onOutput: (output) => {
-                const deviceCode = extractCodexDeviceCodeFromOutput(output);
-                if (!deviceCode || emittedDeviceCode === deviceCode) {
-                    return;
-                }
-                emittedDeviceCode = deviceCode;
-                onDeviceCodePromise = Promise.resolve(onDeviceCode(deviceCode));
-            },
-        });
-        await onDeviceCodePromise;
-        await setCodexDedicatedAuthInDb(db);
-        deps.logSuccess(`Codex auth saved to ${destPath}`);
-        return destPath;
-    }
-    finally {
-        client.close();
-    }
-}
-async function runUseDedicatedCodexAuth(cfg, overrides = {}) {
-    const deps = { ...exports.defaultUseDedicatedCodexAuthDependencies, ...overrides };
-    const { db, client } = await deps.initDbFn(cfg.state_db_path);
-    try {
-        return await runDedicatedCodexAuth(cfg, db, deps);
-    }
-    finally {
-        client.close();
-    }
-}

package/dist/commands/sdk/codex/register-codex-sdk-commands.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerCodexSdkCommands = registerCodexSdkCommands;
-const use_dedicated_auth_js_1 = require("./use-dedicated-auth.js");
-const use_host_auth_js_1 = require("./use-host-auth.js");
-function registerCodexSdkCommands(sdkCommand) {
-    const codexCommand = sdkCommand
-        .command("codex")
-        .description("Manage Codex SDK authentication.");
-    (0, use_host_auth_js_1.registerSdkCodexUseHostAuthCommand)(codexCommand);
-    (0, use_dedicated_auth_js_1.registerSdkCodexUseDedicatedAuthCommand)(codexCommand);
-}

package/dist/commands/sdk/codex/use-dedicated-auth.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runSdkCodexUseDedicatedAuthCommand = runSdkCodexUseDedicatedAuthCommand;
-exports.registerSdkCodexUseDedicatedAuthCommand = registerSdkCodexUseDedicatedAuthCommand;
-const config_js_1 = require("../../../config.js");
-const auth_js_1 = require("./auth.js");
-async function runSdkCodexUseDedicatedAuthCommand(cfg = config_js_1.config.parse({}), overrides = {}) {
-    cfg = config_js_1.config.parse(cfg);
-    const deps = { ...auth_js_1.defaultUseDedicatedCodexAuthDependencies, ...overrides };
-    await (0, auth_js_1.runUseDedicatedCodexAuth)(cfg, deps);
-}
-function registerSdkCodexUseDedicatedAuthCommand(codexCommand) {
-    codexCommand
-        .command("use-dedicated-auth")
-        .description("Configure the Codex SDK to use dedicated authentication.")
-        .action(async () => {
-        await runSdkCodexUseDedicatedAuthCommand();
-    });
-}

package/dist/commands/sdk/codex/use-host-auth.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runSdkCodexUseHostAuthCommand = runSdkCodexUseHostAuthCommand;
-exports.registerSdkCodexUseHostAuthCommand = registerSdkCodexUseHostAuthCommand;
-const config_js_1 = require("../../../config.js");
-const auth_js_1 = require("./auth.js");
-async function runSdkCodexUseHostAuthCommand(cfg = config_js_1.config.parse({}), overrides = {}) {
-    cfg = config_js_1.config.parse(cfg);
-    const deps = { ...auth_js_1.defaultSetCodexHostAuthDependencies, ...overrides };
-    const authPath = await (0, auth_js_1.runSetCodexHostAuth)(cfg, deps);
-    console.log(`Codex SDK configured with host authentication using ${authPath}.`);
-}
-function registerSdkCodexUseHostAuthCommand(codexCommand) {
-    codexCommand
-        .command("use-host-auth")
-        .description("Configure the Codex SDK to use host authentication.")
-        .action(async () => {
-        await runSdkCodexUseHostAuthCommand();
-    });
-}

package/dist/commands/sdk/list.js

@@ -1,76 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runSdkListCommand = runSdkListCommand;
-exports.registerSdkListCommand = registerSdkListCommand;
-const config_js_1 = require("../../config.js");
-const db_js_1 = require("../../state/db.js");
-const schema_js_1 = require("../../state/schema.js");
-function normalizeReasoningLevels(value) {
-    if (Array.isArray(value)) {
-        return value.filter((item) => typeof item === "string");
-    }
-    if (typeof value === "string" && value.trim().length > 0) {
-        try {
-            const parsed = JSON.parse(value);
-            if (Array.isArray(parsed)) {
-                return parsed.filter((item) => typeof item === "string");
-            }
-        }
-        catch {
-            return [];
-        }
-    }
-    return [];
-}
-function formatReasoningLevels(levels) {
-    return levels.length > 0 ? levels.join(", ") : "none";
-}
-async function runSdkListCommand() {
-    const cfg = config_js_1.config.parse({});
-    const { db, client } = await (0, db_js_1.initDb)(cfg.state_db_path);
-    try {
-        const sdks = await db.select().from(schema_js_1.agentSdks).orderBy(schema_js_1.agentSdks.name).all();
-        const models = await db.select().from(schema_js_1.llmModels).orderBy(schema_js_1.llmModels.sdkName, schema_js_1.llmModels.name).all();
-        if (sdks.length === 0) {
-            console.log("No SDKs configured.");
-            console.log("Run `companyhelm-runner` to configure an SDK.");
-            return;
-        }
-        const modelsBySdk = new Map();
-        for (const model of models) {
-            const sdkModels = modelsBySdk.get(model.sdkName) ?? [];
-            sdkModels.push({
-                name: model.name,
-                reasoningLevels: normalizeReasoningLevels(model.reasoningLevels),
-            });
-            modelsBySdk.set(model.sdkName, sdkModels);
-        }
-        sdks.forEach((sdk, index) => {
-            console.log(`SDK: ${sdk.name}`);
-            console.log(`  authentication: ${sdk.authentication}`);
-            const sdkModels = modelsBySdk.get(sdk.name) ?? [];
-            if (sdkModels.length === 0) {
-                console.log("  models: none");
-            }
-            else {
-                console.log("  models:");
-                for (const model of sdkModels) {
-                    console.log(`    - ${model.name}`);
-                    console.log(`      reasoning levels: ${formatReasoningLevels(model.reasoningLevels)}`);
-                }
-            }
-            if (index < sdks.length - 1) {
-                console.log();
-            }
-        });
-    }
-    finally {
-        client.close();
-    }
-}
-function registerSdkListCommand(sdkCommand) {
-    sdkCommand
-        .command("list")
-        .description("List configured SDKs with their available models and reasoning levels.")
-        .action(runSdkListCommand);
-}