@companyhelm/runner 0.0.21 → 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));
@@ -1960,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/package.json

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