@companyhelm/runner 0.0.12 → 0.0.13

package/dist/utils/async_queue.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncQueue = void 0;
+class AsyncQueue {
+    constructor() {
+        this.items = [];
+        this.waiters = [];
+        this.error = null;
+        this.closed = false;
+    }
+    push(item) {
+        if (this.closed || this.error) {
+            return;
+        }
+        const waiter = this.waiters.shift();
+        if (waiter) {
+            waiter.resolve(item);
+            return;
+        }
+        this.items.push(item);
+    }
+    async pop() {
+        if (this.items.length > 0) {
+            return this.items.shift() ?? null;
+        }
+        if (this.error) {
+            throw this.error;
+        }
+        if (this.closed) {
+            return null;
+        }
+        return new Promise((resolve, reject) => {
+            this.waiters.push({ resolve, reject });
+        });
+    }
+    async popWithTimeout(timeoutMs) {
+        if (timeoutMs <= 0) {
+            if (this.items.length > 0) {
+                return this.items.shift() ?? null;
+            }
+            if (this.error) {
+                throw this.error;
+            }
+            return null;
+        }
+        if (this.items.length > 0) {
+            return this.items.shift() ?? null;
+        }
+        if (this.error) {
+            throw this.error;
+        }
+        if (this.closed) {
+            return null;
+        }
+        return new Promise((resolve, reject) => {
+            let timeoutHandle = null;
+            const waiter = {
+                resolve: (value) => {
+                    if (timeoutHandle) {
+                        clearTimeout(timeoutHandle);
+                    }
+                    resolve(value);
+                },
+                reject: (reason) => {
+                    if (timeoutHandle) {
+                        clearTimeout(timeoutHandle);
+                    }
+                    reject(reason);
+                },
+            };
+            timeoutHandle = setTimeout(() => {
+                const waiterIndex = this.waiters.indexOf(waiter);
+                if (waiterIndex >= 0) {
+                    this.waiters.splice(waiterIndex, 1);
+                }
+                resolve(null);
+            }, timeoutMs);
+            this.waiters.push(waiter);
+        });
+    }
+    fail(error) {
+        if (this.closed || this.error) {
+            return;
+        }
+        this.error = error;
+        while (this.waiters.length > 0) {
+            const waiter = this.waiters.shift();
+            waiter?.reject(error);
+        }
+    }
+    close() {
+        if (this.closed || this.error) {
+            return;
+        }
+        this.closed = true;
+        while (this.waiters.length > 0) {
+            const waiter = this.waiters.shift();
+            waiter?.resolve(null);
+        }
+    }
+}
+exports.AsyncQueue = AsyncQueue;

package/dist/utils/daemon.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DAEMON_LOG_PATH_ENV = exports.DAEMON_CHILD_ENV = void 0;
+exports.resolveDaemonLogPath = resolveDaemonLogPath;
+exports.resolveDaemonLogDirectory = resolveDaemonLogDirectory;
+const node_path_1 = require("node:path");
+const path_js_1 = require("./path.js");
+exports.DAEMON_CHILD_ENV = "COMPANYHELM_DAEMON_CHILD";
+exports.DAEMON_LOG_PATH_ENV = "COMPANYHELM_DAEMON_LOG_PATH";
+function resolveDaemonLogPath(stateDbPath) {
+    return (0, node_path_1.join)((0, node_path_1.dirname)((0, path_js_1.expandHome)(stateDbPath)), "daemon.log");
+}
+function resolveDaemonLogDirectory(stateDbPath) {
+    return (0, node_path_1.dirname)(resolveDaemonLogPath(stateDbPath));
+}

package/dist/utils/logger.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseLogLevel = parseLogLevel;
+exports.createLogger = createLogger;
+const pino_1 = __importDefault(require("pino"));
+const pino_pretty_1 = __importDefault(require("pino-pretty"));
+const LOG_LEVELS = {
+    DEBUG: 10,
+    INFO: 20,
+    WARN: 30,
+    ERROR: 40,
+};
+const PINO_LOG_LEVELS = {
+    DEBUG: "debug",
+    INFO: "info",
+    WARN: "warn",
+    ERROR: "error",
+};
+function parseLogLevel(value) {
+    const normalized = (value ?? "INFO").trim().toUpperCase();
+    if (normalized === "DEBUG" || normalized === "INFO" || normalized === "WARN" || normalized === "ERROR") {
+        return normalized;
+    }
+    throw new Error(`Invalid log level '${value}'. Expected one of: DEBUG, INFO, WARN, ERROR.`);
+}
+function createConsoleLogger(level) {
+    const threshold = LOG_LEVELS[level];
+    const shouldLog = (logLevel) => LOG_LEVELS[logLevel] >= threshold;
+    const formatMessage = (logLevel, message) => {
+        const now = new Date();
+        const pad2 = (value) => String(value).padStart(2, "0");
+        const pad3 = (value) => String(value).padStart(3, "0");
+        const timestamp = `${now.getFullYear()}-${pad2(now.getMonth() + 1)}-${pad2(now.getDate())} ` +
+            `${pad2(now.getHours())}:${pad2(now.getMinutes())}:${pad2(now.getSeconds())}.${pad3(now.getMilliseconds())}`;
+        return `[${timestamp}] ${logLevel}: ${message}`;
+    };
+    return {
+        level,
+        debug(message) {
+            if (shouldLog("DEBUG")) {
+                console.debug(formatMessage("DEBUG", message));
+            }
+        },
+        info(message) {
+            if (shouldLog("INFO")) {
+                console.info(formatMessage("INFO", message));
+            }
+        },
+        warn(message) {
+            if (shouldLog("WARN")) {
+                console.warn(formatMessage("WARN", message));
+            }
+        },
+        error(message) {
+            if (shouldLog("ERROR")) {
+                console.error(formatMessage("ERROR", message));
+            }
+        },
+    };
+}
+function createDaemonLogger(level) {
+    const pinoLogger = (0, pino_1.default)({
+        level: PINO_LOG_LEVELS[level],
+    }, (0, pino_pretty_1.default)({
+        colorize: process.stdout.isTTY,
+        ignore: "pid,hostname",
+        singleLine: true,
+        sync: true,
+        translateTime: "SYS:yyyy-mm-dd HH:MM:ss.l",
+    }));
+    return {
+        level,
+        debug(message) {
+            pinoLogger.debug(message);
+        },
+        info(message) {
+            pinoLogger.info(message);
+        },
+        warn(message) {
+            pinoLogger.warn(message);
+        },
+        error(message) {
+            pinoLogger.error(message);
+        },
+    };
+}
+function createLogger(levelInput, options) {
+    const level = parseLogLevel(levelInput);
+    if (options?.daemonMode) {
+        return createDaemonLogger(level);
+    }
+    return createConsoleLogger(level);
+}

package/dist/utils/path.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expandHome = expandHome;
+const node_os_1 = require("node:os");
+function expandHome(p) {
+    if (p.startsWith("~/")) {
+        return p.replace("~", (0, node_os_1.homedir)());
+    }
+    return p;
+}

package/dist/utils/process.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseProcStatState = parseProcStatState;
+exports.isZombieProcessState = isZombieProcessState;
+exports.isProcessRunning = isProcessRunning;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+function parseProcStatState(statLine) {
+    const trimmed = statLine.trim();
+    if (trimmed.length === 0) {
+        return null;
+    }
+    const closingParenIndex = trimmed.lastIndexOf(")");
+    if (closingParenIndex < 0) {
+        return null;
+    }
+    const suffix = trimmed.slice(closingParenIndex + 1).trim();
+    if (suffix.length === 0) {
+        return null;
+    }
+    const state = suffix[0]?.trim();
+    return state && state.length > 0 ? state : null;
+}
+function isZombieProcessState(state) {
+    return state === "Z";
+}
+function readProcessState(pid) {
+    if (process.platform === "linux") {
+        try {
+            return parseProcStatState((0, node_fs_1.readFileSync)(`/proc/${pid}/stat`, "utf8"));
+        }
+        catch (error) {
+            const code = typeof error === "object" && error && "code" in error ? error.code : undefined;
+            if (code === "ENOENT") {
+                return null;
+            }
+            return undefined;
+        }
+    }
+    if (process.platform === "darwin" || process.platform === "freebsd" || process.platform === "openbsd" || process.platform === "sunos") {
+        try {
+            const status = (0, node_child_process_1.execFileSync)("ps", ["-o", "stat=", "-p", String(pid)], { encoding: "utf8" }).trim();
+            if (!status) {
+                return null;
+            }
+            return status[0] ?? null;
+        }
+        catch (error) {
+            const status = typeof error === "object" && error && "status" in error ? error.status : undefined;
+            if (status === 1) {
+                return null;
+            }
+            return undefined;
+        }
+    }
+    return undefined;
+}
+function isProcessRunning(pid) {
+    if (!Number.isInteger(pid) || pid <= 0) {
+        return false;
+    }
+    try {
+        process.kill(pid, 0);
+        const state = readProcessState(pid);
+        if (state === null) {
+            return false;
+        }
+        if (isZombieProcessState(state)) {
+            return false;
+        }
+        return true;
+    }
+    catch (error) {
+        const code = typeof error === "object" && error && "code" in error ? error.code : undefined;
+        if (code === "EPERM") {
+            return true;
+        }
+        if (code === "ESRCH") {
+            return false;
+        }
+        throw error;
+    }
+}

package/dist/utils/terminal.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.containsCtrlCInterruptInput = containsCtrlCInterruptInput;
+exports.restoreInteractiveTerminalState = restoreInteractiveTerminalState;
+const CTRL_C_ETX = "\u0003";
+const CTRL_C_CSI_U_PATTERN = /\u001b\[99;5(?::\d+)?u/;
+const CTRL_C_MODIFY_OTHER_KEYS_PATTERN = /\u001b\[27;5;99~/;
+const RESTORE_KEYBOARD_PROTOCOL_SEQUENCE = "\u001b[<u";
+const SHOW_CURSOR_SEQUENCE = "\u001b[?25h";
+function containsCtrlCInterruptInput(input) {
+    return input.includes(CTRL_C_ETX) ||
+        CTRL_C_CSI_U_PATTERN.test(input) ||
+        CTRL_C_MODIFY_OTHER_KEYS_PATTERN.test(input);
+}
+function restoreInteractiveTerminalState(stdin = process.stdin, stdout = process.stdout) {
+    try {
+        if (stdin.isTTY && typeof stdin.setRawMode === "function") {
+            stdin.setRawMode(false);
+        }
+    }
+    catch {
+        // Best-effort prompt cleanup.
+    }
+    try {
+        if (stdout.isTTY) {
+            // Restore normal keyboard reporting if a prompt enabled kitty/xterm CSI-u handling.
+            stdout.write(RESTORE_KEYBOARD_PROTOCOL_SEQUENCE);
+            stdout.write(SHOW_CURSOR_SEQUENCE);
+        }
+    }
+    catch {
+        // Best-effort prompt cleanup.
+    }
+}

package/package.json

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