@companyhelm/runner 0.0.12 → 0.0.13

package/dist/commands/runner/common.js

@@ -0,0 +1,18 @@
+"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 gRPC API URL for companyhelm-agent in runtime containers (localhost is rewritten to http://host.docker.internal).")
+        .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("--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/register-runner-commands.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerRunnerCommands = registerRunnerCommands;
+const start_js_1 = require("./start.js");
+const stop_js_1 = require("./stop.js");
+function registerRunnerCommands(program) {
+    const runnerCommand = program
+        .command("runner")
+        .description("Manage the local CompanyHelm runner daemon.");
+    (0, start_js_1.registerRunnerStartCommand)(runnerCommand);
+    (0, stop_js_1.registerRunnerStopCommand)(runnerCommand);
+}

package/dist/commands/runner/start.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerRunnerStartCommand = registerRunnerStartCommand;
+const root_js_1 = require("../root.js");
+const common_js_1 = require("./common.js");
+function registerRunnerStartCommand(runnerCommand) {
+    (0, common_js_1.addRunnerStartOptions)(runnerCommand
+        .command("start")
+        .description("Start the local CompanyHelm runner daemon.")).action(async (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" });
+                    },
+                }
+                : 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;
+        }
+    });
+}

package/dist/commands/runner/stop.js

@@ -0,0 +1,55 @@
+"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

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultUseDedicatedCodexAuthDependencies = exports.defaultSetCodexHostAuthDependencies = void 0;
+exports.isErrnoException = isErrnoException;
+exports.buildDockerMissingError = buildDockerMissingError;
+exports.ensureDockerAvailable = ensureDockerAvailable;
+exports.listCodexStartupAuthOptions = listCodexStartupAuthOptions;
+exports.setCodexHostAuthInDb = setCodexHostAuthInDb;
+exports.setCodexDedicatedAuthInDb = setCodexDedicatedAuthInDb;
+exports.runSetCodexHostAuth = runSetCodexHostAuth;
+exports.runDedicatedCodexAuth = runDedicatedCodexAuth;
+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.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 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 ensureDockerAvailable(spawnSyncCommand) {
+    const result = spawnSyncCommand("docker", ["--version"], { stdio: "ignore" });
+    if (isErrnoException(result.error) && result.error.code === "ENOENT") {
+        throw buildDockerMissingError();
+    }
+}
+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 setCodexHostAuthInDb(db) {
+    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: "host" })
+            .where((0, drizzle_orm_1.eq)(schema_js_1.agentSdks.name, "codex"));
+        return;
+    }
+    await db.insert(schema_js_1.agentSdks).values({ name: "codex", authentication: "host" });
+}
+async function setCodexDedicatedAuthInDb(db) {
+    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: "dedicated" })
+            .where((0, drizzle_orm_1.eq)(schema_js_1.agentSdks.name, "codex"));
+        return;
+    }
+    await db.insert(schema_js_1.agentSdks).values({ name: "codex", authentication: "dedicated" });
+}
+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) {
+    ensureDockerAvailable(deps.spawnSyncCommand);
+    const port = cfg.codex.codex_auth_port;
+    const socatPort = port + 1;
+    const containerName = `companyhelm-codex-auth-${Date.now()}`;
+    deps.logInfo("Starting Codex login inside a container...");
+    deps.logInfo("A browser URL will appear -- open it to complete authentication.");
+    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);
+    let authCopied = false;
+    await new Promise((resolve, reject) => {
+        let settled = false;
+        let poll;
+        const rejectOnce = (error) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            if (poll) {
+                clearInterval(poll);
+            }
+            deps.spawnSyncCommand("docker", ["rm", "-f", containerName], { stdio: "ignore" });
+            reject(error);
+        };
+        const resolveOnce = () => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            if (poll) {
+                clearInterval(poll);
+            }
+            resolve();
+        };
+        const child = deps.spawnCommand("docker", [
+            "run",
+            "-it",
+            "--name",
+            containerName,
+            "-p",
+            `${port}:${socatPort}`,
+            "--entrypoint",
+            "bash",
+            cfg.runtime_image,
+            "-c",
+            `source "$NVM_DIR/nvm.sh"; socat TCP-LISTEN:${socatPort},fork,bind=0.0.0.0,reuseaddr TCP:127.0.0.1:${port} 2>/dev/null & codex`,
+        ], { stdio: "inherit" });
+        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;
+            }
+            const check = deps.spawnSyncCommand("docker", ["exec", containerName, "sh", "-c", `test -f ${cfg.codex.codex_auth_path}`], {
+                stdio: "ignore",
+            });
+            if (check.status === 0) {
+                const resolveResult = deps.spawnSyncCommand("docker", ["exec", containerName, "sh", "-c", `echo ${cfg.codex.codex_auth_path}`], {
+                    encoding: "utf-8",
+                });
+                const containerAuthAbsPath = resolveResult.stdout.trim();
+                const cpResult = deps.spawnSyncCommand("docker", ["cp", `${containerName}:${containerAuthAbsPath}`, destPath], {
+                    stdio: "ignore",
+                });
+                if (cpResult.status !== 0) {
+                    rejectOnce(new Error("Failed to extract auth file from container."));
+                    return;
+                }
+                authCopied = true;
+                deps.spawnSyncCommand("docker", ["rm", "-f", containerName], { stdio: "ignore" });
+                resolveOnce();
+            }
+        }, 1000);
+        child.on("exit", () => {
+            if (!authCopied) {
+                rejectOnce(new Error("Codex login failed or was cancelled."));
+            }
+        });
+    });
+    await setCodexDedicatedAuthInDb(db);
+    deps.logSuccess(`Codex auth saved to ${destPath}`);
+    return destPath;
+}
+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

@@ -0,0 +1,12 @@
+"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

@@ -0,0 +1,18 @@
+"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 = {}) {
+    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

@@ -0,0 +1,19 @@
+"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 = {}) {
+    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

@@ -0,0 +1,76 @@
+"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);
+}

package/dist/commands/sdk/refresh-models.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSdkRefreshModelsCommand = runSdkRefreshModelsCommand;
+exports.registerSdkRefreshModelsCommand = registerSdkRefreshModelsCommand;
+const refresh_models_js_1 = require("../../service/sdk/refresh_models.js");
+async function runSdkRefreshModelsCommand(options) {
+    let results;
+    try {
+        results = await (0, refresh_models_js_1.refreshSdkModels)({ sdk: options.sdk });
+    }
+    catch (error) {
+        const sdkName = options.sdk ?? "configured";
+        throw new Error((0, refresh_models_js_1.formatSdkModelRefreshFailure)(sdkName, error));
+    }
+    for (const result of results) {
+        console.log(`Refreshed ${result.modelCount} models for SDK '${result.sdk}'.`);
+    }
+}
+function registerSdkRefreshModelsCommand(sdkCommand) {
+    sdkCommand
+        .command("refresh-models")
+        .description("Refresh model catalog from app-server and store it in the local database.")
+        .option("--sdk <name>", "Refresh only the specified SDK.")
+        .action(runSdkRefreshModelsCommand);
+}

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSdkCommands = registerSdkCommands;
+const register_codex_sdk_commands_js_1 = require("./codex/register-codex-sdk-commands.js");
+const list_js_1 = require("./list.js");
+const refresh_models_js_1 = require("./refresh-models.js");
+function registerSdkCommands(program) {
+    const sdkCommand = program
+        .command("sdk")
+        .description("Manage configured SDKs and their model capabilities.");
+    (0, list_js_1.registerSdkListCommand)(sdkCommand);
+    (0, refresh_models_js_1.registerSdkRefreshModelsCommand)(sdkCommand);
+    (0, register_codex_sdk_commands_js_1.registerCodexSdkCommands)(sdkCommand);
+}

package/dist/commands/shell.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getShellConfigurableDaemonOptions = getShellConfigurableDaemonOptions;
+exports.buildShellDaemonOverrideArgs = buildShellDaemonOverrideArgs;
+exports.runShellCommand = runShellCommand;
+exports.registerShellCommand = registerShellCommand;
+const config_js_1 = require("../config.js");
+const db_js_1 = require("../state/db.js");
+const schema_js_1 = require("../state/schema.js");
+const common_js_1 = require("./runner/common.js");
+const NON_OVERRIDABLE_DAEMON_OPTION_NAMES = new Set(["daemon", "serverUrl", "secret", "help"]);
+function resolveDaemonOptionValue(option, values) {
+    const explicit = values[option.name];
+    if (explicit !== undefined) {
+        return explicit;
+    }
+    if (option.defaultValue !== undefined) {
+        return option.defaultValue;
+    }
+    if (!option.takesValue) {
+        return option.negate ? true : false;
+    }
+    return undefined;
+}
+function getShellConfigurableDaemonOptions(program) {
+    const runnerStartCommand = (0, common_js_1.addRunnerStartOptions)(program.createCommand("start"));
+    return runnerStartCommand.options
+        .filter((option) => {
+        if (!option.long || option.hidden) {
+            return false;
+        }
+        return !NON_OVERRIDABLE_DAEMON_OPTION_NAMES.has(option.attributeName());
+    })
+        .map((option) => ({
+        name: option.attributeName(),
+        longFlag: option.long,
+        description: option.description || "",
+        takesValue: option.required || option.optional,
+        negate: option.negate,
+        defaultValue: option.defaultValue,
+    }));
+}
+function buildShellDaemonOverrideArgs(options, values) {
+    const args = [];
+    for (const option of options) {
+        const value = resolveDaemonOptionValue(option, values);
+        if (option.takesValue) {
+            if (value !== undefined && value !== null && String(value).trim().length > 0) {
+                args.push(option.longFlag, String(value));
+            }
+            continue;
+        }
+        const enabled = Boolean(value);
+        if (option.negate) {
+            if (!enabled) {
+                args.push(option.longFlag);
+            }
+            continue;
+        }
+        if (enabled) {
+            args.push(option.longFlag);
+        }
+    }
+    return args;
+}
+async function assertConfiguredSdks(cfg) {
+    const { db, client } = await (0, db_js_1.initDb)(cfg.state_db_path);
+    try {
+        const configuredSdks = await db.select().from(schema_js_1.agentSdks).all();
+        if (configuredSdks.length === 0) {
+            throw new Error("No SDKs configured. Daemon mode requires at least one configured SDK.");
+        }
+    }
+    finally {
+        client.close();
+    }
+}
+async function runShellCommand(_program) {
+    const cfg = config_js_1.config.parse({});
+    await assertConfiguredSdks(cfg);
+    throw new Error("Interactive shell is no longer supported. Use the daemon mode entrypoint.");
+}
+function registerShellCommand(program) {
+    program
+        .command("shell")
+        .description("Start an interactive protobuf shell against a local companyhelm-runner daemon process.")
+        .action(async () => {
+        await runShellCommand(program);
+    });
+}