npm - @companyhelm/runner - Versions diffs - 0.0.12 → 0.0.13 - Mend

@companyhelm/runner 0.0.12 → 0.0.13

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (486) hide show

package/dist/commands/startup.js ADDED Viewed

@@ -0,0 +1,137 @@
+"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_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 refresh_models_js_1 = require("../service/sdk/refresh_models.js");
+const terminal_js_1 = require("../utils/terminal.js");
+const auth_js_1 = require("./sdk/codex/auth.js");
+function banner() {
+    console.log();
+    console.log(figlet_1.default.textSync("CompanyHelm", { font: "Small" }));
+    console.log();
+}
+const defaultStartupDependencies = {
+    getHostInfoFn: auth_js_1.defaultSetCodexHostAuthDependencies.getHostInfoFn,
+    initDbFn: db_js_1.initDb,
+    promptApi: p,
+    refreshSdkModelsFn: refresh_models_js_1.refreshSdkModels,
+    spawnCommand: node_child_process_1.spawn,
+    spawnSyncCommand: node_child_process_1.spawnSync,
+};
+function exitStartup(code) {
+    (0, terminal_js_1.restoreInteractiveTerminalState)();
+    process.exit(code);
+}
+async function refreshCodexModelsInStartup(deps) {
+    (0, auth_js_1.ensureDockerAvailable)(deps.spawnSyncCommand);
+    const spinner = deps.promptApi.spinner();
+    const seenStatusMessages = new Set();
+    spinner.start("Preparing Codex runtime image and refreshing model catalog via app-server");
+    const results = await deps.refreshSdkModelsFn({
+        sdk: "codex",
+        imageStatusReporter: (message) => {
+            if (seenStatusMessages.has(message)) {
+                return;
+            }
+            seenStatusMessages.add(message);
+            deps.promptApi.log.info(message);
+        },
+    });
+    const count = results[0]?.modelCount ?? 0;
+    spinner.stop(`Codex model catalog refreshed (${count} models).`);
+}
+async function selectStartupAuthMode(options, deps) {
+    if (options.length === 1) {
+        return options[0].value;
+    }
+    const authMode = await deps.promptApi.select({
+        message: "How would you like to authenticate Codex?",
+        options,
+    });
+    if (deps.promptApi.isCancel(authMode)) {
+        deps.promptApi.cancel("Setup cancelled.");
+        exitStartup(0);
+    }
+    return authMode;
+}
+async function startup(cfg = config_js_1.config.parse({}), overrides = {}) {
+    const deps = { ...defaultStartupDependencies, ...overrides };
+    banner();
+    const s = deps.promptApi.spinner();
+    s.start("Initializing state database");
+    const { db } = await deps.initDbFn(cfg.state_db_path);
+    s.stop("State database ready.");
+    const sdks = await db.select().from(schema_js_1.agentSdks).all();
+    if (sdks.length > 0) {
+        deps.promptApi.log.success(`Agent SDK configured: ${sdks.map((sdk) => sdk.name).join(", ")}`);
+        return;
+    }
+    deps.promptApi.intro("No agent SDK configured. Let's set up Codex authentication.");
+    const options = (0, auth_js_1.listCodexStartupAuthOptions)(cfg, deps.getHostInfoFn);
+    try {
+        const authMode = await selectStartupAuthMode(options, deps);
+        if (authMode === "host") {
+            await (0, auth_js_1.setCodexHostAuthInDb)(db);
+            await refreshCodexModelsInStartup(deps);
+            deps.promptApi.outro("Codex SDK configured with host authentication.");
+            return;
+        }
+        await (0, auth_js_1.runDedicatedCodexAuth)(cfg, db, {
+            logInfo: deps.promptApi.log.info,
+            logSuccess: deps.promptApi.log.success,
+            spawnCommand: deps.spawnCommand,
+            spawnSyncCommand: deps.spawnSyncCommand,
+        });
+        await refreshCodexModelsInStartup(deps);
+        deps.promptApi.outro("Codex login successful!");
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Codex setup failed.";
+        deps.promptApi.cancel(message);
+        exitStartup(1);
+    }
+    finally {
+        (0, terminal_js_1.restoreInteractiveTerminalState)();
+    }
+}

package/dist/commands/status.js ADDED Viewed

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerStatusCommand = registerStatusCommand;
+const node_path_1 = require("node:path");
+const config_js_1 = require("../config.js");
+const daemon_state_js_1 = require("../state/daemon_state.js");
+const daemon_js_1 = require("../utils/daemon.js");
+const process_js_1 = require("../utils/process.js");
+function registerStatusCommand(program) {
+    program
+        .command("status")
+        .description("Show whether the local CompanyHelm daemon is running.")
+        .option("--state-db-path <path>", "State database path override (defaults to state.db under the active config directory).")
+        .action(async (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);
+        const running = state?.pid != null && (0, process_js_1.isProcessRunning)(state.pid);
+        const logPath = state?.logPath ?? (0, daemon_js_1.resolveDaemonLogPath)(cfg.state_db_path);
+        const logDirectory = state?.logPath ? (0, node_path_1.dirname)(state.logPath) : (0, daemon_js_1.resolveDaemonLogDirectory)(cfg.state_db_path);
+        console.log(`Daemon: ${running ? "running" : "not running"}`);
+        if (state?.pid != null) {
+            console.log(`PID: ${running ? state.pid : `${state.pid} (stale)`}`);
+        }
+        else {
+            console.log("PID: none");
+        }
+        console.log(`Log directory: ${logDirectory}`);
+        console.log(`Log file: ${logPath}`);
+    });
+}

package/dist/commands/thread/docker.js ADDED Viewed

@@ -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/list.js ADDED Viewed

@@ -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 ADDED Viewed

@@ -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.js ADDED Viewed

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = exports.codexConfig = exports.DEFAULT_CONFIG_DIRECTORY = exports.CONFIG_PATH_ENV = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const zod_1 = require("zod");
+const path_js_1 = require("./utils/path.js");
+exports.CONFIG_PATH_ENV = "COMPANYHELM_CONFIG_PATH";
+exports.DEFAULT_CONFIG_DIRECTORY = "~/.config/companyhelm";
+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()}`;
+function resolveConfigRelativePath(configDirectory, pathValue) {
+    if ((0, node_path_1.isAbsolute)((0, path_js_1.expandHome)(pathValue))) {
+        return pathValue;
+    }
+    return (0, node_path_1.join)(configDirectory, pathValue);
+}
+function resolveConfigDirectoryDefault() {
+    const envValue = process.env[exports.CONFIG_PATH_ENV]?.trim();
+    if (envValue && envValue.length > 0) {
+        return envValue;
+    }
+    return exports.DEFAULT_CONFIG_DIRECTORY;
+}
+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(resolveConfigDirectoryDefault),
+    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, relative to the config directory.")
+        .default("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({})),
+}).transform((value) => ({
+    ...value,
+    state_db_path: resolveConfigRelativePath(value.config_directory, value.state_db_path),
+}));