@companyhelm/cli 0.0.2

package/dist/commands/sdk/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSdkCommands = registerSdkCommands;
+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);
+}

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` 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,18 @@
+"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) {
+    const results = await (0, refresh_models_js_1.refreshSdkModels)({ sdk: options.sdk });
+    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,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSdkCommands = registerSdkCommands;
+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);
+}

package/dist/commands/shell.js

@@ -0,0 +1,88 @@
+"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 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) {
+    return program.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 daemon process.")
+        .action(async () => {
+        await runShellCommand(program);
+    });
+}

package/dist/commands/startup.js

@@ -0,0 +1,185 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startup = startup;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_child_process_1 = require("node:child_process");
+const p = __importStar(require("@clack/prompts"));
+const figlet_1 = __importDefault(require("figlet"));
+const config_js_1 = require("../config.js");
+const db_js_1 = require("../state/db.js");
+const schema_js_1 = require("../state/schema.js");
+const host_js_1 = require("../service/host.js");
+const refresh_models_js_1 = require("../service/sdk/refresh_models.js");
+const path_js_1 = require("../utils/path.js");
+function banner() {
+    console.log();
+    console.log(figlet_1.default.textSync("CompanyHelm", { font: "Small" }));
+    console.log();
+}
+async function refreshCodexModelsInStartup() {
+    const spinner = p.spinner();
+    const seenStatusMessages = new Set();
+    spinner.start("Preparing Codex runtime image and refreshing model catalog via app-server");
+    const results = await (0, refresh_models_js_1.refreshSdkModels)({
+        sdk: "codex",
+        imageStatusReporter: (message) => {
+            if (seenStatusMessages.has(message)) {
+                return;
+            }
+            seenStatusMessages.add(message);
+            p.log.info(message);
+        },
+    });
+    const count = results[0]?.modelCount ?? 0;
+    spinner.stop(`Codex model catalog refreshed (${count} models).`);
+}
+async function dedicatedAuth(cfg, db) {
+    const port = cfg.codex.codex_auth_port;
+    const socatPort = port + 1;
+    const containerName = `companyhelm-codex-auth-${Date.now()}`;
+    p.log.info("Starting Codex login inside a container...");
+    p.log.info("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);
+    const child = (0, node_child_process_1.spawn)("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" });
+    let authCopied = false;
+    await new Promise((resolve, reject) => {
+        const poll = setInterval(() => {
+            const check = (0, node_child_process_1.spawnSync)("docker", ["exec", containerName, "sh", "-c", `test -f ${cfg.codex.codex_auth_path}`], {
+                stdio: "ignore",
+            });
+            if (check.status === 0) {
+                clearInterval(poll);
+                const resolveResult = (0, node_child_process_1.spawnSync)("docker", ["exec", containerName, "sh", "-c", `echo ${cfg.codex.codex_auth_path}`], {
+                    encoding: "utf-8",
+                });
+                const containerAuthAbsPath = resolveResult.stdout.trim();
+                const cpResult = (0, node_child_process_1.spawnSync)("docker", ["cp", `${containerName}:${containerAuthAbsPath}`, destPath], {
+                    stdio: "ignore",
+                });
+                if (cpResult.status !== 0) {
+                    (0, node_child_process_1.spawnSync)("docker", ["rm", "-f", containerName], { stdio: "ignore" });
+                    reject(new Error("Failed to extract auth file from container."));
+                    return;
+                }
+                authCopied = true;
+                (0, node_child_process_1.spawnSync)("docker", ["rm", "-f", containerName], { stdio: "ignore" });
+                resolve();
+            }
+        }, 1000);
+        child.on("exit", () => {
+            clearInterval(poll);
+            if (!authCopied) {
+                (0, node_child_process_1.spawnSync)("docker", ["rm", "-f", containerName], { stdio: "ignore" });
+                reject(new Error("Codex login failed or was cancelled."));
+            }
+        });
+    });
+    await db.insert(schema_js_1.agentSdks).values({ name: "codex", authentication: "dedicated" });
+    p.log.success(`Codex auth saved to ${destPath}`);
+}
+async function startup() {
+    banner();
+    const cfg = config_js_1.config.parse({});
+    const s = p.spinner();
+    s.start("Initializing state database");
+    const { db } = await (0, db_js_1.initDb)(cfg.state_db_path);
+    s.stop("State database ready.");
+    const sdks = await db.select().from(schema_js_1.agentSdks).all();
+    if (sdks.length > 0) {
+        p.log.success(`Agent SDK configured: ${sdks.map((sdk) => sdk.name).join(", ")}`);
+        return;
+    }
+    p.intro("No agent SDK configured. Let's set up Codex authentication.");
+    const hostInfo = (0, host_js_1.getHostInfo)(cfg.codex.codex_auth_path);
+    const options = [
+        {
+            value: "dedicated",
+            label: "Dedicated",
+            hint: "recommended -- runs Codex login inside a container",
+        },
+    ];
+    if (hostInfo.codexAuthExists) {
+        options.push({
+            value: "host",
+            label: "Host",
+            hint: `reuse existing credentials from ${cfg.codex.codex_auth_path}`,
+        });
+    }
+    const authMode = await p.select({
+        message: "How would you like to authenticate Codex?",
+        options,
+    });
+    if (p.isCancel(authMode)) {
+        p.cancel("Setup cancelled.");
+        process.exit(0);
+    }
+    try {
+        if (authMode === "host") {
+            await db.insert(schema_js_1.agentSdks).values({ name: "codex", authentication: "host" });
+            await refreshCodexModelsInStartup();
+            p.outro("Codex SDK configured with host authentication.");
+            return;
+        }
+        await dedicatedAuth(cfg, db);
+        await refreshCodexModelsInStartup();
+        p.outro("Codex login successful!");
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Codex setup failed.";
+        p.cancel(message);
+        process.exit(1);
+    }
+}

package/dist/commands/thread/docker.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runThreadDockerCommand = runThreadDockerCommand;
+exports.registerThreadDockerCommand = registerThreadDockerCommand;
+const node_child_process_1 = require("node:child_process");
+const drizzle_orm_1 = require("drizzle-orm");
+const config_js_1 = require("../../config.js");
+const runtime_shell_js_1 = require("../../service/runtime_shell.js");
+const thread_runtime_js_1 = require("../../service/thread_runtime.js");
+const db_js_1 = require("../../state/db.js");
+const schema_js_1 = require("../../state/schema.js");
+function resolveExecStatus(result) {
+    if (result.error) {
+        throw result.error;
+    }
+    if (result.signal) {
+        throw new Error(`docker exec exited due to signal '${result.signal}'.`);
+    }
+    const status = result.status ?? 1;
+    if (status !== 0) {
+        throw new Error(`docker exec exited with status ${status}.`);
+    }
+    throw new Error("docker exec exited unexpectedly.");
+}
+function buildDockerShellCommand(homeDirectory) {
+    return `${(0, runtime_shell_js_1.buildNvmCodexBootstrapScript)(homeDirectory)}\nexec bash`;
+}
+async function runThreadDockerCommand(options) {
+    const cfg = config_js_1.config.parse({});
+    const { db, client } = await (0, db_js_1.initDb)(cfg.state_db_path);
+    let threadState;
+    try {
+        threadState = await db
+            .select()
+            .from(schema_js_1.threads)
+            .where((0, drizzle_orm_1.eq)(schema_js_1.threads.id, options.threadId))
+            .get();
+    }
+    finally {
+        client.close();
+    }
+    if (!threadState) {
+        throw new Error(`Thread '${options.threadId}' was not found.`);
+    }
+    await (0, thread_runtime_js_1.ensureThreadRuntimeReady)({
+        dindContainer: threadState.dindContainer,
+        runtimeContainer: threadState.runtimeContainer,
+        gitUserName: cfg.git_user_name,
+        gitUserEmail: cfg.git_user_email,
+        user: {
+            uid: threadState.uid,
+            gid: threadState.gid,
+            agentUser: cfg.agent_user,
+            agentHomeDirectory: threadState.homeDirectory,
+        },
+    });
+    const result = (0, node_child_process_1.spawnSync)("docker", [
+        "exec",
+        "-it",
+        threadState.runtimeContainer,
+        "bash",
+        "-lc",
+        buildDockerShellCommand(threadState.homeDirectory),
+    ], {
+        stdio: "inherit",
+    });
+    if (result.status !== 0 || result.signal || result.error) {
+        resolveExecStatus(result);
+    }
+}
+function registerThreadDockerCommand(threadCommand) {
+    threadCommand
+        .command("docker")
+        .description("Start the thread containers when needed, then open an interactive bash session in the runtime container.")
+        .requiredOption("--thread-id <id>", "Thread id to open in Docker.")
+        .action(runThreadDockerCommand);
+}

package/dist/commands/thread/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerThreadCommands = registerThreadCommands;
+const docker_js_1 = require("./docker.js");
+const list_js_1 = require("./list.js");
+function registerThreadCommands(program) {
+    const threadCommand = program
+        .command("thread")
+        .description("Manage threads stored in the local state database.");
+    (0, list_js_1.registerThreadListCommand)(threadCommand);
+    (0, docker_js_1.registerThreadDockerCommand)(threadCommand);
+}

package/dist/commands/thread/list.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runThreadListCommand = runThreadListCommand;
+exports.registerThreadListCommand = registerThreadListCommand;
+const config_js_1 = require("../../config.js");
+const db_js_1 = require("../../state/db.js");
+const schema_js_1 = require("../../state/schema.js");
+async function runThreadListCommand() {
+    const cfg = config_js_1.config.parse({});
+    const { db, client } = await (0, db_js_1.initDb)(cfg.state_db_path);
+    try {
+        const rows = await db
+            .select()
+            .from(schema_js_1.threads)
+            .orderBy(schema_js_1.threads.id)
+            .all();
+        if (rows.length === 0) {
+            console.log("No threads found.");
+            return;
+        }
+        console.log("Threads:");
+        for (const row of rows) {
+            const dindLabel = row.dindContainer && row.dindContainer.trim().length > 0 ? row.dindContainer : "(none)";
+            console.log(`- id: ${row.id}, status: ${row.status}, model: ${row.model}, ` +
+                `reasoning: ${row.reasoningLevel}, runtime: ${row.runtimeContainer}, dind: ${dindLabel}`);
+        }
+    }
+    finally {
+        client.close();
+    }
+}
+function registerThreadListCommand(threadCommand) {
+    threadCommand
+        .command("list")
+        .description("List threads from the local state database.")
+        .action(runThreadListCommand);
+}

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerThreadCommands = registerThreadCommands;
+const docker_js_1 = require("./docker.js");
+const list_js_1 = require("./list.js");
+function registerThreadCommands(program) {
+    const threadCommand = program
+        .command("thread")
+        .description("Manage threads stored in the local state database.");
+    (0, list_js_1.registerThreadListCommand)(threadCommand);
+    (0, docker_js_1.registerThreadDockerCommand)(threadCommand);
+}

package/dist/config/local.js

@@ -0,0 +1 @@
+"use strict";

package/dist/config/schema.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const zod_1 = require("zod");
+const schema = zod_1.z.object({
+    agent_home: zod_1.z.string().describe("The home directory for the agent.").default("/home/agent"),
+});
+exports.default = schema;

package/dist/config.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = exports.codexConfig = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const zod_1 = require("zod");
+const DEFAULT_RUNTIME_IMAGE_REPOSITORY = "companyhelm/runner";
+const FALLBACK_RUNTIME_IMAGE_VERSION = "latest";
+function loadRuntimeImageVersion() {
+    try {
+        const version = (0, node_fs_1.readFileSync)((0, node_path_1.join)(__dirname, "..", "RUNTIME_IMAGE_VERSION"), "utf8").trim();
+        if (version.length > 0) {
+            return version;
+        }
+    }
+    catch {
+        // Fall back when running from source without packaged assets.
+    }
+    return FALLBACK_RUNTIME_IMAGE_VERSION;
+}
+const DEFAULT_RUNTIME_IMAGE = `${DEFAULT_RUNTIME_IMAGE_REPOSITORY}:${loadRuntimeImageVersion()}`;
+exports.codexConfig = zod_1.z.object({
+    codex_auth_file_path: zod_1.z.string()
+        .describe("The path to the Codex authentication file on the host, relative to config_directory.")
+        .default("codex-auth.json"),
+    codex_auth_path: zod_1.z.string()
+        .describe("The path to the Codex auth file. Used on both host and inside the container.")
+        .default("~/.codex/auth.json"),
+    codex_auth_port: zod_1.z.number()
+        .describe("The port used by Codex OAuth callback during dedicated auth.")
+        .default(1455),
+    app_server_client_name: zod_1.z.string()
+        .describe("Client name reported to Codex app-server during initialize.")
+        .default("cli"),
+});
+exports.config = zod_1.z.object({
+    config_directory: zod_1.z.string()
+        .describe("The directory where the config files are stored.")
+        .default("~/.config/companyhelm"),
+    workspaces_directory: zod_1.z.string()
+        .describe("The directory where thread workspaces are stored, relative to config_directory when not absolute.")
+        .default("workspaces"),
+    state_db_path: zod_1.z.string()
+        .describe("The path to the state database.")
+        .default("~/.local/share/companyhelm/state.db"),
+    companyhelm_api_url: zod_1.z.string()
+        .describe("CompanyHelm control plane gRPC endpoint URL.")
+        .default("https://api.companyhelm.com:50051"),
+    agent_api_url: zod_1.z.string()
+        .describe("CompanyHelm AgentTaskService gRPC endpoint URL used by companyhelm-agent inside runtime threads.")
+        .default("https://api.companyhelm.com:50052"),
+    // Max outbound gRPC client messages to hold while the command channel is disconnected.
+    client_message_buffer_limit: zod_1.z.number()
+        .int()
+        .positive()
+        .describe("Maximum number of outbound client messages buffered during command channel disconnects.")
+        .default(10000),
+    runtime_image: zod_1.z.string()
+        .describe("The name of the runtime image.")
+        .default(DEFAULT_RUNTIME_IMAGE),
+    dind_image: zod_1.z.string()
+        .describe("The name of the DIND image.")
+        .default("docker:29-dind-rootless"),
+    use_host_docker_runtime: zod_1.z.boolean()
+        .describe("When true, mount host Docker socket into runtime containers instead of creating DinD sidecars.")
+        .default(false),
+    host_docker_path: zod_1.z.string()
+        .describe("Host Docker endpoint when use_host_docker_runtime is enabled. Supported: unix:///<socket-path> or tcp://localhost:<port>.")
+        .default("unix:///var/run/docker.sock"),
+    thread_git_skills_directory: zod_1.z.string()
+        .describe("Container directory where thread git skill repositories are cloned.")
+        .default("/skills"),
+    agent_user: zod_1.z.string()
+        .describe("The user for the agent.")
+        .default("agent"),
+    agent_home_directory: zod_1.z.string()
+        .describe("The home directory for the agent.")
+        .default("/home/agent"),
+    git_user_name: zod_1.z.string()
+        .describe("Default git author name used when runtime repositories are missing user.name.")
+        .default("agent"),
+    git_user_email: zod_1.z.string()
+        .describe("Default git author email used when runtime repositories are missing user.email.")
+        .default("agent@companyhelm.com"),
+    codex: exports.codexConfig.default(() => exports.codexConfig.parse({})),
+});

package/dist/generated/codex-app-server/AbsolutePathBuf.js

@@ -0,0 +1,3 @@
+"use strict";
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/generated/codex-app-server/AddConversationListenerParams.js

@@ -0,0 +1,3 @@
+"use strict";
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/generated/codex-app-server/AddConversationSubscriptionResponse.js

@@ -0,0 +1,3 @@
+"use strict";
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/generated/codex-app-server/AgentMessageContent.js

@@ -0,0 +1,3 @@
+"use strict";
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/generated/codex-app-server/AgentMessageContentDeltaEvent.js

@@ -0,0 +1,3 @@
+"use strict";
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/generated/codex-app-server/AgentMessageDeltaEvent.js

@@ -0,0 +1,3 @@
+"use strict";
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+Object.defineProperty(exports, "__esModule", { value: true });