@companyhelm/runner 0.0.12 → 0.0.13

package/dist/service/docker/dind.js

@@ -0,0 +1,114 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DinDService = void 0;
+const dockerode_1 = __importDefault(require("dockerode"));
+const DIND_IMAGE = "docker:dind-rootless";
+const DIND_PORT = 2375;
+const READY_TIMEOUT_MS = 30000;
+const READY_POLL_MS = 500;
+class DinDService {
+    constructor(docker) {
+        this.container = null;
+        this._endpoint = null;
+        this.docker = docker ?? new dockerode_1.default();
+    }
+    async start() {
+        if (this.container) {
+            throw new Error("DinD service is already running");
+        }
+        const uid = process.getuid?.();
+        if (uid === undefined) {
+            throw new Error("Cannot determine current UID (not supported on this platform)");
+        }
+        await this.pullImage();
+        const container = await this.docker.createContainer({
+            Image: DIND_IMAGE,
+            User: String(uid),
+            Env: [
+                // Disable TLS so the inner daemon listens on plain 2375.
+                "DOCKER_TLS_CERTDIR=",
+            ],
+            ExposedPorts: { [`${DIND_PORT}/tcp`]: {} },
+            HostConfig: {
+                Privileged: true,
+                PublishAllPorts: true,
+            },
+        });
+        await container.start();
+        this.container = container;
+        const info = await container.inspect();
+        const bindings = info.NetworkSettings.Ports[`${DIND_PORT}/tcp`];
+        if (!bindings?.[0]) {
+            await this.stop();
+            throw new Error("DinD container started but port was not bound");
+        }
+        this._endpoint = {
+            host: "127.0.0.1",
+            port: parseInt(bindings[0].HostPort, 10),
+        };
+        await this.waitForReady();
+    }
+    async stop() {
+        if (!this.container)
+            return;
+        const c = this.container;
+        this.container = null;
+        this._endpoint = null;
+        try {
+            await c.stop();
+        }
+        catch {
+            // already stopped
+        }
+        try {
+            await c.remove({ force: true });
+        }
+        catch {
+            // already removed
+        }
+    }
+    getEndpoint() {
+        if (!this._endpoint) {
+            throw new Error("DinD service is not running");
+        }
+        return this._endpoint;
+    }
+    getContainer() {
+        if (!this.container) {
+            throw new Error("DinD service is not running");
+        }
+        return this.container;
+    }
+    async pullImage() {
+        try {
+            await this.docker.getImage(DIND_IMAGE).inspect();
+            return; // already present
+        }
+        catch {
+            // not found – pull it
+        }
+        const stream = await this.docker.pull(DIND_IMAGE);
+        await new Promise((resolve, reject) => {
+            this.docker.modem.followProgress(stream, (err) => (err ? reject(err) : resolve()));
+        });
+    }
+    async waitForReady() {
+        const { host, port } = this.getEndpoint();
+        const inner = new dockerode_1.default({ host, port });
+        const deadline = Date.now() + READY_TIMEOUT_MS;
+        while (Date.now() < deadline) {
+            try {
+                await inner.ping();
+                return;
+            }
+            catch {
+                await new Promise((r) => setTimeout(r, READY_POLL_MS));
+            }
+        }
+        throw new Error(`DinD daemon did not become ready within ${READY_TIMEOUT_MS}ms`);
+    }
+}
+exports.DinDService = DinDService;

package/dist/service/docker/runtime_app_server_exec.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeContainerAppServerTransport = void 0;
+const node_child_process_1 = require("node:child_process");
+const async_queue_js_1 = require("../../utils/async_queue.js");
+const runtime_shell_js_1 = require("../runtime_shell.js");
+const DEFAULT_APP_SERVER_COMMAND = (0, runtime_shell_js_1.buildCodexAppServerCommand)();
+const PROCESS_EXIT_TIMEOUT_MS = 5000;
+class RuntimeContainerAppServerTransport {
+    constructor(runtimeContainerName, appServerCommand = DEFAULT_APP_SERVER_COMMAND, environment = {}) {
+        this.runtimeContainerName = runtimeContainerName;
+        this.appServerCommand = appServerCommand;
+        this.environment = environment;
+        this.messageQueue = new async_queue_js_1.AsyncQueue();
+        this.child = null;
+        this.running = false;
+    }
+    async start() {
+        if (this.running) {
+            throw new Error("Runtime app-server transport is already running.");
+        }
+        const environmentArgs = Object.entries(this.environment).flatMap(([key, value]) => ["-e", `${key}=${value}`]);
+        const child = (0, node_child_process_1.spawn)("docker", ["exec", "-i", ...environmentArgs, this.runtimeContainerName, "bash", "-lc", this.appServerCommand], { stdio: ["pipe", "pipe", "pipe"] });
+        child.stdout.on("data", (chunk) => {
+            this.messageQueue.push({ type: "stdout", payload: chunk });
+        });
+        child.stderr.on("data", (chunk) => {
+            this.messageQueue.push({ type: "stderr", payload: chunk.toString("utf8") });
+        });
+        child.on("error", (error) => {
+            this.messageQueue.push({ type: "error", reason: `docker exec error: ${error.message}` });
+            this.running = false;
+            this.messageQueue.close();
+        });
+        child.on("exit", (code, signal) => {
+            this.running = false;
+            this.messageQueue.push({
+                type: "error",
+                reason: `docker exec exited (${code !== null ? `code ${code}` : `signal ${signal ?? "unknown"}`})`,
+            });
+            this.messageQueue.close();
+        });
+        this.child = child;
+        this.running = true;
+    }
+    async stop() {
+        this.running = false;
+        this.messageQueue.close();
+        const child = this.child;
+        this.child = null;
+        if (!child) {
+            return;
+        }
+        const waitForExit = (timeoutMs) => Promise.race([
+            new Promise((resolveExit) => {
+                child.once("exit", () => resolveExit(true));
+            }),
+            new Promise((resolveExit) => {
+                setTimeout(() => resolveExit(false), timeoutMs);
+            }),
+        ]);
+        // Close stdin first so app-server can flush and exit cleanly.
+        if (child.stdin && !child.stdin.destroyed && child.stdin.writable) {
+            child.stdin.end();
+        }
+        let exited = await waitForExit(PROCESS_EXIT_TIMEOUT_MS);
+        if (exited) {
+            return;
+        }
+        if (!child.killed) {
+            child.kill("SIGTERM");
+        }
+        exited = await waitForExit(PROCESS_EXIT_TIMEOUT_MS);
+        if (exited) {
+            return;
+        }
+        if (!exited && !child.killed) {
+            child.kill("SIGKILL");
+        }
+    }
+    async sendRaw(payload) {
+        if (!this.running || !this.child || !this.child.stdin) {
+            throw new Error("Runtime app-server transport is not running.");
+        }
+        this.child.stdin.write(payload);
+    }
+    async *receiveOutput() {
+        while (true) {
+            const event = await this.messageQueue.pop();
+            if (!event) {
+                return;
+            }
+            yield event;
+        }
+    }
+}
+exports.RuntimeContainerAppServerTransport = RuntimeContainerAppServerTransport;

package/dist/service/host.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHostInfo = getHostInfo;
+const node_os_1 = require("node:os");
+const node_fs_1 = require("node:fs");
+const path_js_1 = require("../utils/path.js");
+function getHostInfo(codexAuthPath) {
+    const info = (0, node_os_1.userInfo)();
+    return {
+        uid: info.uid,
+        gid: info.gid,
+        home: (0, node_os_1.homedir)(),
+        codexAuthExists: (0, node_fs_1.existsSync)((0, path_js_1.expandHome)(codexAuthPath)),
+    };
+}

package/dist/service/runtime_bashrc.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderRuntimeBashrc = renderRuntimeBashrc;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const RUNTIME_BASHRC_TEMPLATE_PATH = "templates/runtime_bashrc.j2";
+function resolveTemplatePath() {
+    const distRelativePath = (0, node_path_1.join)(__dirname, "..", RUNTIME_BASHRC_TEMPLATE_PATH);
+    if ((0, node_fs_1.existsSync)(distRelativePath)) {
+        return distRelativePath;
+    }
+    const sourceRelativePath = (0, node_path_1.join)(__dirname, "..", "..", "src", RUNTIME_BASHRC_TEMPLATE_PATH);
+    if ((0, node_fs_1.existsSync)(sourceRelativePath)) {
+        return sourceRelativePath;
+    }
+    throw new Error(`Runtime bashrc template was not found at ${distRelativePath} or ${sourceRelativePath}`);
+}
+function renderJinjaTemplate(template, context) {
+    return template.replace(/{{\s*([a-zA-Z0-9_]+)\s*}}/g, (_match, key) => {
+        const value = context[key];
+        if (value === undefined) {
+            throw new Error(`Missing template value for key '${key}'`);
+        }
+        return value;
+    });
+}
+function renderRuntimeBashrc(homeDirectory) {
+    const fallbackTemplate = `# CompanyHelm runtime shell initialization.
+# This file is generated by companyhelm-runner when a thread runtime starts.
+
+if [ -z "\${NVM_DIR:-}" ] || [ ! -s "$NVM_DIR/nvm.sh" ]; then
+  for candidate in "/usr/local/nvm" "$HOME/.nvm" "/opt/nvm" "/root/.nvm"; do
+    if [ -s "$candidate/nvm.sh" ]; then
+      export NVM_DIR="$candidate"
+      break
+    fi
+  done
+fi
+
+if [ -n "\${NVM_DIR:-}" ] && [ -s "$NVM_DIR/nvm.sh" ]; then
+  . "$NVM_DIR/nvm.sh"
+  nvm use --silent default >/dev/null 2>&1 || true
+  if [ -s "$NVM_DIR/bash_completion" ]; then
+    . "$NVM_DIR/bash_completion"
+  fi
+fi
+`;
+    try {
+        const template = (0, node_fs_1.readFileSync)(resolveTemplatePath(), "utf8");
+        return renderJinjaTemplate(template, {
+            home_directory: homeDirectory,
+        }).trimEnd() + "\n";
+    }
+    catch {
+        return fallbackTemplate.trimEnd() + "\n";
+    }
+}

package/dist/service/runtime_shell.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildNvmCodexBootstrapScript = buildNvmCodexBootstrapScript;
+exports.buildCodexAppServerCommand = buildCodexAppServerCommand;
+function shellQuote(value) {
+    return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+const CODEX_APP_SERVER_STDIN_LISTEN_FLAG = "--listen stdio://";
+const CODEX_YOLO_FLAG = "--dangerously-bypass-approvals-and-sandbox";
+function buildNvmCodexBootstrapScript(homeDirectory) {
+    const lines = [
+        "set -euo pipefail",
+    ];
+    if (homeDirectory) {
+        lines.push(`export HOME=${shellQuote(homeDirectory)}`);
+    }
+    lines.push('if [ -z "${NVM_DIR:-}" ] || [ ! -s "$NVM_DIR/nvm.sh" ]; then', '  for candidate in "/usr/local/nvm" "$HOME/.nvm" "/opt/nvm" "/root/.nvm"; do', '    if [ -s "$candidate/nvm.sh" ]; then', '      export NVM_DIR="$candidate"', "      break", "    fi", "  done", "fi", 'if [ -z "${NVM_DIR:-}" ] || [ ! -s "$NVM_DIR/nvm.sh" ]; then', '  echo "nvm is not configured: unable to locate nvm.sh." >&2', "  exit 1", "fi", '. "$NVM_DIR/nvm.sh"', 'nvm use --silent default >/dev/null 2>&1 || true', 'if ! command -v codex >/dev/null 2>&1; then', '  echo "codex command is not available after sourcing nvm." >&2', "  exit 1", "fi");
+    return lines.join("\n");
+}
+function buildCodexAppServerCommand(homeDirectory) {
+    const bootstrap = buildNvmCodexBootstrapScript(homeDirectory);
+    return `${bootstrap}\ncodex ${CODEX_YOLO_FLAG} app-server ${CODEX_APP_SERVER_STDIN_LISTEN_FLAG}`;
+}

package/dist/service/sdk/refresh_models.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatSdkModelRefreshFailure = formatSdkModelRefreshFailure;
+exports.refreshSdkModels = refreshSdkModels;
+const drizzle_orm_1 = require("drizzle-orm");
+const config_js_1 = require("../../config.js");
+const db_js_1 = require("../../state/db.js");
+const schema_js_1 = require("../../state/schema.js");
+const app_server_js_1 = require("../app_server.js");
+const app_server_container_js_1 = require("../docker/app_server_container.js");
+function toErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function formatSdkModelRefreshFailure(sdk, error) {
+    return (`Failed to refresh ${sdk} models from the local Codex app-server: ${toErrorMessage(error)}. ` +
+        "Verify the runner image can start Codex app-server with valid auth, then retry.");
+}
+async function fetchCodexModelsFromAppServer(clientName, logger, imageStatusReporter) {
+    const transport = new app_server_container_js_1.AppServerContainerService({ imageStatusReporter });
+    const appServer = new app_server_js_1.AppServerService(transport, clientName, logger);
+    await appServer.start();
+    const models = [];
+    let nextCursor = null;
+    try {
+        while (true) {
+            const result = await appServer.listModels(nextCursor, 100);
+            models.push(...result.data);
+            if (!result.nextCursor) {
+                break;
+            }
+            nextCursor = result.nextCursor;
+        }
+    }
+    finally {
+        await appServer.stop();
+    }
+    return models;
+}
+async function refreshCodexModels(cfg, logger, imageStatusReporter) {
+    const models = await fetchCodexModelsFromAppServer(cfg.codex.app_server_client_name, logger, imageStatusReporter);
+    const { db, client } = await (0, db_js_1.initDb)(cfg.state_db_path);
+    try {
+        await db.delete(schema_js_1.llmModels).where((0, drizzle_orm_1.eq)(schema_js_1.llmModels.sdkName, "codex"));
+        if (models.length > 0) {
+            await db.insert(schema_js_1.llmModels).values(models.map((model) => ({
+                name: model.model,
+                sdkName: "codex",
+                reasoningLevels: model.supportedReasoningEfforts.map((effort) => effort.reasoningEffort),
+            })));
+        }
+    }
+    finally {
+        client.close();
+    }
+    return models.length;
+}
+async function refreshSdkModels(options) {
+    const cfg = config_js_1.config.parse({});
+    const { db, client } = await (0, db_js_1.initDb)(cfg.state_db_path);
+    let selectedSdks = [];
+    try {
+        if (options?.sdk) {
+            const configured = await db.select().from(schema_js_1.agentSdks).where((0, drizzle_orm_1.eq)(schema_js_1.agentSdks.name, options.sdk)).get();
+            if (!configured) {
+                throw new Error(`SDK '${options.sdk}' is not configured.`);
+            }
+            selectedSdks = [configured];
+        }
+        else {
+            selectedSdks = await db.select().from(schema_js_1.agentSdks).all();
+        }
+    }
+    finally {
+        client.close();
+    }
+    if (selectedSdks.length === 0) {
+        throw new Error("No SDKs are configured.");
+    }
+    const results = [];
+    for (const sdk of selectedSdks) {
+        if (!sdk.authentication || sdk.authentication === "unauthenticated") {
+            throw new Error(`SDK '${sdk.name}' is missing authentication.`);
+        }
+        if (sdk.name !== "codex") {
+            throw new Error(`SDK '${sdk.name}' is not supported by model refresh yet.`);
+        }
+        const modelCount = await refreshCodexModels(cfg, options?.logger, options?.imageStatusReporter);
+        results.push({ sdk: sdk.name, modelCount });
+    }
+    return results;
+}