@companyhelm/runner 0.0.19 → 0.0.22

package/dist/commands/logs.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runRunnerLogsCommand = runRunnerLogsCommand;
+exports.registerLogsCommand = registerLogsCommand;
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const promises_2 = require("node:timers/promises");
+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");
+class RunnerLogsCommand {
+    constructor(dependencies = {}) {
+        this.fileExistsFn = dependencies.fileExistsFn ?? defaultFileExists;
+        this.openFileFn = dependencies.openFileFn ?? defaultOpenFile;
+        this.pollIntervalMs = dependencies.pollIntervalMs ?? 100;
+        this.readCurrentDaemonStateFn = dependencies.readCurrentDaemonStateFn ?? daemon_state_js_1.readCurrentDaemonState;
+        this.readFileFn = dependencies.readFileFn ?? defaultReadFile;
+        this.signal = dependencies.signal;
+        this.stdout = dependencies.stdout ?? process.stdout;
+    }
+    async run(options) {
+        const cfg = config_js_1.config.parse({
+            state_db_path: options.stateDbPath,
+        });
+        const logPath = await this.resolveLogPath(cfg.state_db_path);
+        if (!(await this.fileExistsFn(logPath))) {
+            this.stdout.write(`CompanyHelm runner log file not found at ${logPath}.\n`);
+            return;
+        }
+        if (!options.live) {
+            this.stdout.write(await this.readFileFn(logPath));
+            return;
+        }
+        await this.followLogFile(logPath);
+    }
+    async resolveLogPath(stateDbPath) {
+        const state = await this.readCurrentDaemonStateFn(stateDbPath);
+        return state?.logPath ?? (0, daemon_js_1.resolveDaemonLogPath)(stateDbPath);
+    }
+    async followLogFile(logPath) {
+        const fileHandle = await this.openFileFn(logPath);
+        try {
+            let offset = await this.writeAvailableContents(fileHandle, 0);
+            while (!this.signal?.aborted) {
+                try {
+                    await (0, promises_2.setTimeout)(this.pollIntervalMs, undefined, this.signal ? { signal: this.signal } : undefined);
+                }
+                catch (error) {
+                    if (isAbortError(error)) {
+                        return;
+                    }
+                    throw error;
+                }
+                offset = await this.writeAvailableContents(fileHandle, offset);
+            }
+        }
+        finally {
+            await fileHandle.close();
+        }
+    }
+    async writeAvailableContents(fileHandle, offset) {
+        const stats = await fileHandle.stat();
+        let nextOffset = offset;
+        if (stats.size < nextOffset) {
+            nextOffset = 0;
+        }
+        const unreadBytes = stats.size - nextOffset;
+        if (unreadBytes <= 0) {
+            return nextOffset;
+        }
+        const buffer = Buffer.alloc(unreadBytes);
+        const { bytesRead } = await fileHandle.read(buffer, 0, unreadBytes, nextOffset);
+        if (bytesRead > 0) {
+            this.stdout.write(buffer.subarray(0, bytesRead));
+        }
+        return nextOffset + bytesRead;
+    }
+}
+function isAbortError(error) {
+    return error instanceof Error && error.name === "AbortError";
+}
+async function defaultFileExists(filePath) {
+    try {
+        await (0, promises_1.access)(filePath, node_fs_1.constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function defaultOpenFile(filePath) {
+    return await (0, promises_1.open)(filePath, "r");
+}
+async function defaultReadFile(filePath) {
+    return await (0, promises_1.readFile)(filePath, "utf8");
+}
+async function runRunnerLogsCommand(options, dependencies) {
+    await new RunnerLogsCommand(dependencies).run(options);
+}
+function registerLogsCommand(program) {
+    program
+        .command("logs")
+        .description("Print the local CompanyHelm daemon log output.")
+        .option("--live", "Keep streaming appended daemon log output.")
+        .option("--state-db-path <path>", "State database path override (defaults to state.db under the active config directory).")
+        .action(async (options) => {
+        await runRunnerLogsCommand(options);
+    });
+}

package/dist/commands/register-commands.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerCommands = registerCommands;
 const common_js_1 = require("./runner/common.js");
+const logs_js_1 = require("./logs.js");
 const register_runner_commands_js_1 = require("./runner/register-runner-commands.js");
 const start_js_1 = require("./runner/start.js");
 const shell_js_1 = require("./shell.js");
@@ -14,6 +15,7 @@ function registerCommands(program) {
         .description("Alias for starting the local CompanyHelm runner.")).action(start_js_1.runRunnerStartCommand);
     (0, register_runner_commands_js_1.registerRunnerCommands)(program);
     (0, status_js_1.registerStatusCommand)(program);
+    (0, logs_js_1.registerLogsCommand)(program);
     (0, register_thread_commands_js_1.registerThreadCommands)(program);
     (0, shell_js_1.registerShellCommand)(program);
     (0, register_sdk_commands_js_1.registerSdkCommands)(program);

package/dist/commands/root.js

@@ -340,7 +340,10 @@ function isNoActiveTurnSteerError(error) {
     return /no active turn to steer/i.test(toErrorMessage(error));
 }
 function isNoRunningTurnInterruptError(error) {
-    return /no running turn to interrupt/i.test(toErrorMessage(error));
+    const message = toErrorMessage(error);
+    return /no running turn to interrupt/i.test(message)
+        || /thread .* is not running/i.test(message)
+        || /thread .* already stopped/i.test(message);
 }
 function isTurnCompletionTimeoutError(error) {
     return /timed out waiting for completion of turn/i.test(toErrorMessage(error));
@@ -1649,6 +1652,9 @@ async function resolveThreadAuthMode(cfg) {
         if (!codexSdk) {
             throw new Error("Codex SDK is not configured.");
         }
+        if (codexSdk.authentication === "api-key") {
+            return "dedicated";
+        }
         if (codexSdk.authentication !== "host" && codexSdk.authentication !== "dedicated") {
             throw new Error(`Unsupported Codex authentication mode '${codexSdk.authentication}' for thread creation.`);
         }
@@ -1957,7 +1963,7 @@ async function reportNoRunningInterruptAsReady(cfg, commandChannel, request, thr
         await sendTurnExecutionUpdate(commandChannel, request.threadId, threadState.currentSdkTurnId, protos_1.TurnStatus.COMPLETED);
     }
     await sendThreadUpdate(commandChannel, request.threadId, protos_1.ThreadStatus.READY);
-    logger.info(logMessage);
+    logger.warn(logMessage);
 }
 async function handleInterruptTurnRequest(cfg, commandChannel, request, logger) {
     let threadState;

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

@@ -40,6 +40,9 @@ exports.defaultUseDedicatedCodexAuthDependencies = {
     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;
@@ -279,14 +282,26 @@ async function ensureCodexRunnerStartState(cfg, 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?.authentication === "dedicated" && existingSdk.status === "configured") {
+            if (existingSdk?.status === "configured" &&
+                isDedicatedCodexAuthentication(existingSdk.authentication) &&
+                dedicatedAuthInfo.codexAuthExists) {
                 return;
             }
             await setCodexUnconfiguredInDb(db);
             return;
         }
-        const hostInfo = deps.getHostInfoFn(cfg.codex.codex_auth_path);
+        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);

package/dist/commands/shell.js

@@ -51,16 +51,6 @@ const terminal_js_1 = require("../utils/terminal.js");
 const path_js_1 = require("../utils/path.js");
 const NON_OVERRIDABLE_DAEMON_OPTION_NAMES = new Set(["daemon", "serverUrl", "secret", "help"]);
 const SHELL_PROMPT = "companyhelm db> ";
-const SHELL_HELP_TEXT = [
-    "Available commands:",
-    "  help                 Show this help.",
-    "  list threads         List full thread rows from the state DB.",
-    "  thread status <id>   Show the full thread row for one thread.",
-    "  list containers      List thread container fields from the state DB.",
-    "  thread docker <id>   Docker exec bash into the selected thread runtime container.",
-    "  show daemon          Show the daemon_state row from the state DB.",
-    "  exit                 Exit the shell.",
-].join("\n");
 function resolveDaemonOptionValue(option, values) {
     const explicit = values[option.name];
     if (explicit !== undefined) {
@@ -115,6 +105,64 @@ function buildShellDaemonOverrideArgs(options, values) {
     }
     return args;
 }
+const SHELL_TABLES = [
+    {
+        key: "threads",
+        label: "Threads",
+        menuLabel: "List threads",
+        menuHint: "Full rows from the threads table",
+        commandAliases: ["threads", "thread"],
+        loadRows: async (db) => (await db.select().from(schema_js_1.threads).orderBy(schema_js_1.threads.id).all()),
+    },
+    {
+        key: "agent-sdks",
+        label: "Agent SDKs",
+        menuLabel: "List SDKs",
+        menuHint: "Full rows from the agent_sdks table",
+        commandAliases: ["sdks", "sdk", "agent-sdks"],
+        loadRows: async (db) => (await db.select().from(schema_js_1.agentSdks).orderBy(schema_js_1.agentSdks.name).all()),
+    },
+    {
+        key: "llm-models",
+        label: "LLM models",
+        menuLabel: "List models",
+        menuHint: "Full rows from the llm_models table",
+        commandAliases: ["models", "model", "llm-models"],
+        loadRows: async (db) => (await db.select().from(schema_js_1.llmModels).orderBy(schema_js_1.llmModels.sdkName, schema_js_1.llmModels.name).all()),
+    },
+    {
+        key: "thread-user-message-request-store",
+        label: "Thread user message request store",
+        menuLabel: "List requests",
+        menuHint: "Full rows from the thread_user_message_request_store table",
+        commandAliases: ["requests", "request", "message-requests", "user-message-requests"],
+        loadRows: async (db) => (await db.select().from(schema_js_1.threadUserMessageRequestStore).orderBy(schema_js_1.threadUserMessageRequestStore.id).all()),
+    },
+    {
+        key: "daemon-state",
+        label: "Daemon state table",
+        menuLabel: "List daemon rows",
+        menuHint: "Full rows from the daemon_state table",
+        commandAliases: ["daemon", "daemons", "daemon-state"],
+        loadRows: async (db) => (await db.select().from(schema_js_1.daemonState).orderBy(schema_js_1.daemonState.id).all()),
+    },
+];
+const SHELL_TABLE_BY_KEY = new Map(SHELL_TABLES.map((table) => [table.key, table]));
+const SHELL_TABLE_BY_ALIAS = new Map(SHELL_TABLES.flatMap((table) => table.commandAliases.map((alias) => [alias, table])));
+const SHELL_HELP_TEXT = [
+    "Available commands:",
+    "  help                 Show this help.",
+    "  list threads         List full thread rows from the threads table.",
+    "  list sdks            List full rows from the agent_sdks table.",
+    "  list models          List full rows from the llm_models table.",
+    "  list requests        List full rows from the thread_user_message_request_store table.",
+    "  list daemon          List full rows from the daemon_state table.",
+    "  thread status <id>   Show the full thread row for one thread.",
+    "  list containers      List thread container fields from the state DB.",
+    "  thread docker <id>   Docker exec bash into the selected thread runtime container.",
+    "  show daemon          Show the daemon_state row from the state DB.",
+    "  exit                 Exit the shell.",
+].join("\n");
 function jsonReplacer(_key, value) {
     return typeof value === "bigint" ? value.toString() : value;
 }
@@ -137,6 +185,9 @@ function printRow(label, row) {
     console.log(JSON.stringify(row, jsonReplacer, 2));
     console.log();
 }
+function resolveShellTableByAlias(alias) {
+    return SHELL_TABLE_BY_ALIAS.get(alias.toLowerCase());
+}
 function parseShellCommand(input) {
     const trimmed = input.trim();
     if (!trimmed) {
@@ -150,7 +201,16 @@ function parseShellCommand(input) {
             case "?":
                 return { type: "help" };
             case "threads":
-                return { type: "list-threads" };
+                return { type: "list-table", tableKey: "threads" };
+            case "sdks":
+            case "sdk":
+                return { type: "list-table", tableKey: "agent-sdks" };
+            case "models":
+            case "model":
+                return { type: "list-table", tableKey: "llm-models" };
+            case "requests":
+            case "request":
+                return { type: "list-table", tableKey: "thread-user-message-request-store" };
             case "containers":
                 return { type: "list-containers" };
             case "daemon":
@@ -163,12 +223,15 @@ function parseShellCommand(input) {
         }
     }
     if (normalized.length === 2) {
-        if (normalized[0] === "list" && normalized[1] === "threads") {
-            return { type: "list-threads" };
-        }
         if (normalized[0] === "list" && normalized[1] === "containers") {
             return { type: "list-containers" };
         }
+        if (normalized[0] === "list") {
+            const table = resolveShellTableByAlias(normalized[1]);
+            if (table) {
+                return { type: "list-table", tableKey: table.key };
+            }
+        }
         if (normalized[0] === "show" && normalized[1] === "daemon") {
             return { type: "show-daemon" };
         }
@@ -215,7 +278,7 @@ async function promptShellAction() {
     const action = await p.select({
         message: "Choose shell action",
         options: [
-            { value: "list-threads", label: "List threads" },
+            { value: "list-table", label: "Inspect runner tables", hint: "Threads, SDKs, models, requests, daemon state" },
             { value: "thread-status", label: "Thread status" },
             { value: "list-containers", label: "List containers" },
             { value: "thread-docker-shell", label: "Thread docker shell (bash)" },
@@ -226,6 +289,17 @@ async function promptShellAction() {
     });
     return p.isCancel(action) ? null : action;
 }
+async function promptShellTable() {
+    const selection = await p.select({
+        message: "Choose table to list",
+        options: SHELL_TABLES.map((table) => ({
+            value: table.key,
+            label: table.menuLabel,
+            hint: table.menuHint,
+        })),
+    });
+    return p.isCancel(selection) ? null : selection;
+}
 async function runClackShell(db, stateDbPath) {
     p.intro(`CompanyHelm DB shell\n${(0, path_js_1.expandHome)(stateDbPath)}`);
     try {
@@ -240,9 +314,14 @@ async function runClackShell(db, stateDbPath) {
                     case "help":
                         console.log(SHELL_HELP_TEXT);
                         break;
-                    case "list-threads":
-                        await runParsedShellCommand(db, { type: "list-threads" });
+                    case "list-table": {
+                        const tableKey = await promptShellTable();
+                        if (!tableKey) {
+                            break;
+                        }
+                        await runParsedShellCommand(db, { type: "list-table", tableKey });
                         break;
+                    }
                     case "thread-status": {
                         const threadId = await selectThreadId(db, "Select thread");
                         if (!threadId) {
@@ -284,9 +363,14 @@ async function runParsedShellCommand(db, command) {
         case "help":
             console.log(SHELL_HELP_TEXT);
             return false;
-        case "list-threads": {
-            const rows = await db.select().from(schema_js_1.threads).orderBy(schema_js_1.threads.id).all();
-            printRows("Threads", rows);
+        case "list-table": {
+            const table = SHELL_TABLE_BY_KEY.get(command.tableKey);
+            if (!table) {
+                console.log(`Unknown table key: ${command.tableKey}`);
+                return false;
+            }
+            const rows = await table.loadRows(db);
+            printRows(table.label, rows);
             return false;
         }
         case "thread-status": {

package/dist/service/docker/app_server_container.js

@@ -219,7 +219,7 @@ class AppServerContainerService {
         const hostAuthPath = (0, path_js_1.expandHome)(cfg.codex.codex_auth_path);
         const hostDedicatedAuthPath = `${(0, path_js_1.expandHome)(cfg.config_directory)}/${cfg.codex.codex_auth_file_path}`;
         const mountArgs = [];
-        if (codexAuthMode === "dedicated") {
+        if (codexAuthMode === "dedicated" || codexAuthMode === "api-key") {
             if (!(0, host_js_1.getHostInfo)(hostDedicatedAuthPath).codexAuthExists) {
                 throw new Error(`Dedicated Codex auth file was not found at ${hostDedicatedAuthPath}`);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@companyhelm/runner",
-  "version": "0.0.19",
+  "version": "0.0.22",
   "description": "Run the CompanyHelm runner in fully isolated Docker sandboxes.",
   "license": "MIT",
   "repository": {