@a5c-ai/genty-runtime 5.1.1-staging.0007199a1cb2

package/dist/backgroundProcessRegistry.js

@@ -0,0 +1,427 @@
+"use strict";
+/**
+ * Background process lifecycle management for the bash agentic tool (GAP-TOOLS-036).
+ *
+ * Tracks child processes spawned with `run_in_background: true`, collects
+ * stdout/stderr, fires completion callbacks, and enforces a concurrency limit.
+ */
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackgroundProcessRegistry = void 0;
+const childProcess = __importStar(require("node:child_process"));
+const ulid_1 = require("./utils/ulid");
+const execution_1 = require("./execution");
+const shellInvocation_1 = require("./shellInvocation");
+// ---------------------------------------------------------------------------
+// Registry
+// ---------------------------------------------------------------------------
+const DEFAULT_MAX_CONCURRENT = 16;
+const DEFAULT_TERMINATION_GRACE_MS = 3_000;
+const TERMINAL_STATUSES = new Set([
+    "completed",
+    "exited",
+    "cancelled",
+    "killed",
+    "timed_out",
+    "skipped",
+    "failed",
+]);
+class BackgroundProcessRegistry {
+    processes = new Map();
+    maxConcurrent;
+    spawnFn;
+    processKillFn;
+    platform;
+    constructor(options) {
+        this.maxConcurrent = options?.maxConcurrent ?? DEFAULT_MAX_CONCURRENT;
+        this.spawnFn = options?.spawnFn ?? childProcess.spawn;
+        this.processKillFn = options?.processKillFn ?? process.kill;
+        this.platform = options?.platform ?? process.platform;
+    }
+    /**
+     * Spawn a command in the background and begin tracking it.
+     * Returns a snapshot of the initial record.
+     */
+    spawn(opts) {
+        (0, execution_1.validateFilesystemPolicy)(opts.cwd, opts.executionPolicy);
+        const dependsOn = [...(opts.dependsOn ?? [])];
+        validateDependencies(dependsOn);
+        for (const dependencyId of dependsOn) {
+            const dependency = this.processes.get(dependencyId);
+            if (!dependency) {
+                throw new Error(`Unknown background process dependency "${dependencyId}"`);
+            }
+        }
+        const runningCount = [...this.processes.values()].filter((p) => p.status === "running" || p.status === "paused").length;
+        if (runningCount >= this.maxConcurrent && dependsOn.length === 0) {
+            throw new Error(`Max concurrent background processes limit reached (${this.maxConcurrent}). ` +
+                `Cancel or wait for existing processes before spawning new ones.`);
+        }
+        const backgroundTaskId = (0, ulid_1.nextUlid)();
+        const startMs = Date.now();
+        const resources = (0, execution_1.normalizeResourceLimits)(opts.executionPolicy);
+        const tracked = {
+            backgroundTaskId,
+            pid: -1,
+            command: opts.command,
+            description: opts.description,
+            startedAt: new Date(startMs).toISOString(),
+            startMs,
+            status: dependsOn.length === 0 ? "running" : "queued",
+            exitCode: null,
+            stdout: createRetainedStream(),
+            stderr: createRetainedStream(),
+            durationMs: null,
+            maxOutputBytes: resources.maxOutputBytes,
+            opts,
+            dependsOn,
+            hookErrors: [],
+            onComplete: opts.onComplete,
+        };
+        this.processes.set(backgroundTaskId, tracked);
+        this.runHook(tracked, "preSpawn");
+        if (tracked.status === "failed") {
+            tracked.durationMs = Date.now() - tracked.startMs;
+            return this.snapshot(tracked);
+        }
+        if (dependsOn.length === 0) {
+            this.startTrackedProcess(tracked);
+        }
+        else {
+            this.resolveQueuedProcess(tracked);
+        }
+        return this.snapshot(tracked);
+    }
+    startTrackedProcess(tracked) {
+        if (tracked.status !== "queued" && tracked.status !== "running") {
+            return;
+        }
+        const runningCount = [...this.processes.values()].filter((p) => p !== tracked && (p.status === "running" || p.status === "paused")).length;
+        if (runningCount >= this.maxConcurrent) {
+            tracked.status = "queued";
+            return;
+        }
+        const opts = tracked.opts;
+        const shellInvocation = (0, shellInvocation_1.buildShellInvocation)(opts.command);
+        const child = this.spawnFn(shellInvocation.command, shellInvocation.args, {
+            cwd: opts.cwd,
+            env: (0, execution_1.resolveExecutionEnvironment)(opts.env, opts.executionPolicy),
+            shell: false,
+            windowsHide: true,
+            stdio: ["ignore", "pipe", "pipe"],
+            detached: opts.terminateProcessGroup === true && this.platform !== "win32",
+        });
+        tracked.child = child;
+        tracked.pid = child.pid ?? -1;
+        tracked.status = "running";
+        child.stdout?.on("data", (chunk) => {
+            appendCapped(tracked.stdout, chunk, tracked.maxOutputBytes);
+        });
+        child.stderr?.on("data", (chunk) => {
+            appendCapped(tracked.stderr, chunk, tracked.maxOutputBytes);
+        });
+        const resources = (0, execution_1.normalizeResourceLimits)(opts.executionPolicy);
+        if (resources.timeoutMs !== undefined) {
+            tracked.timeout = setTimeout(() => {
+                if (tracked.status === "running" || tracked.status === "paused") {
+                    this.terminate(tracked, "timed_out");
+                }
+            }, resources.timeoutMs);
+        }
+        child.on("close", (code) => {
+            if (tracked.timeout)
+                clearTimeout(tracked.timeout);
+            if (tracked.terminationTimer)
+                clearTimeout(tracked.terminationTimer);
+            if (tracked.status === "running" || tracked.status === "paused") {
+                tracked.status = code === 0 ? "completed" : "exited";
+            }
+            tracked.exitCode = code ?? 1;
+            tracked.durationMs = Date.now() - tracked.startMs;
+            this.runHook(tracked, "postDestroy");
+            if (tracked.onComplete) {
+                try {
+                    tracked.onComplete(this.completionEvent(tracked));
+                }
+                catch {
+                    // Fire-and-forget — callback errors must not crash.
+                }
+            }
+            this.resolveDependents(tracked.backgroundTaskId);
+        });
+        child.on("error", () => {
+            if (tracked.timeout)
+                clearTimeout(tracked.timeout);
+            if (tracked.terminationTimer)
+                clearTimeout(tracked.terminationTimer);
+            if (tracked.status === "running" || tracked.status === "paused") {
+                tracked.status = "exited";
+            }
+            tracked.exitCode = 1;
+            tracked.durationMs = Date.now() - tracked.startMs;
+            this.runHook(tracked, "postDestroy");
+            this.resolveDependents(tracked.backgroundTaskId);
+        });
+        this.runHook(tracked, "postSpawn");
+    }
+    /** Get a snapshot of a tracked process by ID, or undefined. */
+    get(backgroundTaskId) {
+        const tracked = this.processes.get(backgroundTaskId);
+        if (!tracked)
+            return undefined;
+        return this.snapshot(tracked);
+    }
+    /** List snapshots of all tracked processes. */
+    list() {
+        return [...this.processes.values()].map((t) => this.snapshot(t));
+    }
+    /** Cancel (SIGTERM) a running process. Returns true if found and killed. */
+    cancel(backgroundTaskId) {
+        const tracked = this.processes.get(backgroundTaskId);
+        if (!tracked)
+            return false;
+        if (isTerminal(tracked.status))
+            return true;
+        this.terminate(tracked, "cancelled");
+        return true;
+    }
+    /** Kill all running processes. */
+    killAll() {
+        for (const tracked of this.processes.values()) {
+            if (!isTerminal(tracked.status)) {
+                this.terminate(tracked, "killed");
+            }
+        }
+    }
+    /** Kill all processes and clear tracking state. */
+    dispose() {
+        this.killAll();
+        this.processes.clear();
+    }
+    pause(backgroundTaskId) {
+        const tracked = this.processes.get(backgroundTaskId);
+        if (!tracked || tracked.status !== "running" || !this.canSignal(tracked)) {
+            return false;
+        }
+        if (!this.sendSignal(tracked, "SIGSTOP")) {
+            return false;
+        }
+        tracked.status = "paused";
+        return true;
+    }
+    resume(backgroundTaskId) {
+        const tracked = this.processes.get(backgroundTaskId);
+        if (!tracked || tracked.status !== "paused" || !this.canSignal(tracked)) {
+            return false;
+        }
+        if (!this.sendSignal(tracked, "SIGCONT")) {
+            return false;
+        }
+        tracked.status = "running";
+        return true;
+    }
+    // -------------------------------------------------------------------------
+    // Internals
+    // -------------------------------------------------------------------------
+    snapshot(t) {
+        const stdoutTruncated = t.stdout.droppedBytes > 0;
+        const stderrTruncated = t.stderr.droppedBytes > 0;
+        return {
+            backgroundTaskId: t.backgroundTaskId,
+            pid: t.pid,
+            command: t.command,
+            description: t.description,
+            startedAt: t.startedAt,
+            status: t.status,
+            exitCode: t.exitCode,
+            stdout: Buffer.concat(t.stdout.chunks).toString("utf8"),
+            stderr: Buffer.concat(t.stderr.chunks).toString("utf8"),
+            stdoutTruncated: stdoutTruncated || undefined,
+            stderrTruncated: stderrTruncated || undefined,
+            stdoutRetainedBytes: t.stdout.retainedBytes,
+            stderrRetainedBytes: t.stderr.retainedBytes,
+            stdoutDroppedBytes: t.stdout.droppedBytes,
+            stderrDroppedBytes: t.stderr.droppedBytes,
+            dependsOn: t.dependsOn.length > 0 ? [...t.dependsOn] : undefined,
+            dependencyFailure: t.dependencyFailure,
+            hookErrors: t.hookErrors.length > 0 ? [...t.hookErrors] : undefined,
+            durationMs: t.durationMs,
+        };
+    }
+    completionEvent(t) {
+        return {
+            ...this.snapshot(t),
+            exitCode: t.exitCode ?? 1,
+            durationMs: t.durationMs ?? Date.now() - t.startMs,
+        };
+    }
+    terminate(tracked, intent) {
+        if (tracked.terminating || isTerminal(tracked.status)) {
+            return;
+        }
+        const wasPaused = tracked.status === "paused";
+        tracked.terminating = true;
+        tracked.terminalIntent = intent;
+        tracked.status = intent;
+        tracked.durationMs = Date.now() - tracked.startMs;
+        if (intent === "timed_out") {
+            this.runHook(tracked, "onTimeout");
+        }
+        this.runHook(tracked, "preDestroy");
+        if (wasPaused) {
+            this.sendSignal(tracked, "SIGCONT");
+        }
+        this.sendSignal(tracked, "SIGTERM");
+        tracked.terminationTimer = setTimeout(() => {
+            if (this.isStillRunning(tracked)) {
+                this.sendSignal(tracked, "SIGKILL");
+            }
+        }, tracked.opts.terminationGraceMs ?? DEFAULT_TERMINATION_GRACE_MS);
+    }
+    canSignal(tracked) {
+        return this.platform !== "win32" && tracked.pid > 0 && tracked.child !== undefined;
+    }
+    sendSignal(tracked, signal) {
+        if (!tracked.child || tracked.pid <= 0) {
+            return false;
+        }
+        try {
+            if (this.shouldSignalProcessGroup(tracked)) {
+                this.processKillFn(-tracked.pid, signal);
+            }
+            else if (this.processKillFn !== process.kill) {
+                this.processKillFn(tracked.pid, signal);
+            }
+            else {
+                tracked.child.kill(signal);
+            }
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    shouldSignalProcessGroup(tracked) {
+        return tracked.opts.terminateProcessGroup === true
+            && this.platform !== "win32"
+            && tracked.pid > 0;
+    }
+    isStillRunning(tracked) {
+        const child = tracked.child;
+        if (!child)
+            return false;
+        return child.exitCode === null && child.killed !== true;
+    }
+    resolveDependents(backgroundTaskId) {
+        for (const candidate of this.processes.values()) {
+            if (candidate.status !== "queued" || !candidate.dependsOn.includes(backgroundTaskId)) {
+                continue;
+            }
+            this.resolveQueuedProcess(candidate);
+        }
+    }
+    resolveQueuedProcess(tracked) {
+        const dependencies = tracked.dependsOn.map((id) => this.processes.get(id));
+        const failed = dependencies.find((dependency) => dependency && dependency.status !== "completed");
+        if (failed && isTerminal(failed.status)) {
+            tracked.status = "skipped";
+            tracked.dependencyFailure = failed.backgroundTaskId;
+            tracked.durationMs = Date.now() - tracked.startMs;
+            this.resolveDependents(tracked.backgroundTaskId);
+            return;
+        }
+        if (dependencies.every((dependency) => dependency?.status === "completed")) {
+            this.startTrackedProcess(tracked);
+        }
+    }
+    runHook(tracked, hook) {
+        const fn = tracked.opts.hooks?.[hook];
+        if (!fn)
+            return;
+        try {
+            const result = fn(this.snapshot(tracked));
+            if (result != null && typeof result.then === "function") {
+                tracked.hookErrors.push({
+                    hook,
+                    message: "Async lifecycle hooks are not supported by synchronous spawn",
+                });
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            tracked.hookErrors.push({ hook, message });
+            if (hook === "preSpawn") {
+                tracked.status = "failed";
+            }
+        }
+    }
+}
+exports.BackgroundProcessRegistry = BackgroundProcessRegistry;
+function createRetainedStream() {
+    return {
+        chunks: [],
+        retainedBytes: 0,
+        droppedBytes: 0,
+    };
+}
+function appendCapped(stream, chunk, maxBytes) {
+    if (maxBytes === undefined) {
+        stream.chunks.push(chunk);
+        stream.retainedBytes += chunk.byteLength;
+        return;
+    }
+    const remaining = maxBytes - stream.retainedBytes;
+    if (remaining <= 0) {
+        stream.droppedBytes += chunk.byteLength;
+        return;
+    }
+    if (chunk.byteLength <= remaining) {
+        stream.chunks.push(chunk);
+        stream.retainedBytes += chunk.byteLength;
+        return;
+    }
+    stream.chunks.push(chunk.subarray(0, remaining));
+    stream.retainedBytes += remaining;
+    stream.droppedBytes += chunk.byteLength - remaining;
+}
+function validateDependencies(dependsOn) {
+    const unique = new Set(dependsOn);
+    if (unique.size !== dependsOn.length) {
+        throw new Error("Background process dependency cycle or duplicate dependency detected");
+    }
+}
+function isTerminal(status) {
+    return TERMINAL_STATUSES.has(status);
+}

package/dist/cost/claudeCodeParser.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Claude Code JSONL session file parser for cost data collection.
+ *
+ * Parses Claude Code session JSONL files (main session and subagent files)
+ * to extract token usage data and compute costs. Each assistant message with
+ * a `usage` block becomes a {@link CostEventData} entry.
+ *
+ * JSONL format (one JSON object per line):
+ * ```json
+ * {
+ *   "type": "assistant",
+ *   "message": {
+ *     "model": "claude-opus-4-6",
+ *     "usage": {
+ *       "input_tokens": 3,
+ *       "cache_creation_input_tokens": 26928,
+ *       "cache_read_input_tokens": 0,
+ *       "cache_creation": { "ephemeral_5m_input_tokens": 0, "ephemeral_1h_input_tokens": 26928 },
+ *       "output_tokens": 28,
+ *       "service_tier": "standard"
+ *     }
+ *   },
+ *   "timestamp": "2026-04-05T..."
+ * }
+ * ```
+ */
+import type { CostEventData, ModelCostStats } from "./types";
+/**
+ * Parse a single Claude Code session JSONL file into cost events.
+ *
+ * Reads the file, splits by newline, and for each line that represents an
+ * assistant message with usage data, extracts token counts and computes
+ * the USD cost using the extended pricing model.
+ *
+ * @param sessionJsonlPath - Absolute path to the `.jsonl` file.
+ * @returns Array of cost events extracted from assistant messages.
+ */
+export declare function parseClaudeCodeSession(sessionJsonlPath: string): Promise<CostEventData[]>;
+/**
+ * Parse a Claude Code session JSONL file and all associated subagent files.
+ *
+ * Subagent files live at `<sessionDir>/subagents/agent-*.jsonl` where
+ * `<sessionDir>` is derived by stripping the `.jsonl` extension from the
+ * main session file path.
+ *
+ * @param sessionJsonlPath - Absolute path to the main session `.jsonl` file.
+ * @returns Merged array of cost events from the main session and all subagents.
+ */
+export declare function parseClaudeCodeSessionWithSubagents(sessionJsonlPath: string): Promise<CostEventData[]>;
+/** Aggregated usage summary returned by {@link aggregateUsageData}. */
+export interface AggregatedUsage {
+    /** Total number of cost events. */
+    eventCount: number;
+    /** Total base input tokens across all events. */
+    totalInputTokens: number;
+    /** Total output tokens across all events. */
+    totalOutputTokens: number;
+    /** Total cache-creation tokens (top-level) across all events. */
+    totalCacheCreationTokens: number;
+    /** Total cache-read tokens across all events. */
+    totalCacheReadTokens: number;
+    /** Total 5-minute cache-creation tokens. */
+    totalCacheCreation5mTokens: number;
+    /** Total 1-hour cache-creation tokens. */
+    totalCacheCreation1hTokens: number;
+    /** Total computed cost in USD. */
+    totalCostUsd: number;
+    /** Per-model breakdown of usage statistics. */
+    byModel: Record<string, ModelCostStats>;
+}
+/**
+ * Aggregate usage data across an array of cost events.
+ *
+ * Sums token counts and costs, producing both overall totals and a
+ * per-model breakdown.
+ *
+ * @param events - Array of cost events (e.g. from {@link parseClaudeCodeSessionWithSubagents}).
+ * @returns Aggregated usage summary with per-model breakdown.
+ */
+export declare function aggregateUsageData(events: CostEventData[]): AggregatedUsage;
+//# sourceMappingURL=claudeCodeParser.d.ts.map

package/dist/cost/claudeCodeParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claudeCodeParser.d.ts","sourceRoot":"","sources":["../../src/cost/claudeCodeParser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAqC7D;;;;;;;;;GASG;AACH,wBAAsB,sBAAsB,CAC1C,gBAAgB,EAAE,MAAM,GACvB,OAAO,CAAC,aAAa,EAAE,CAAC,CA+D1B;AAMD;;;;;;;;;GASG;AACH,wBAAsB,mCAAmC,CACvD,gBAAgB,EAAE,MAAM,GACvB,OAAO,CAAC,aAAa,EAAE,CAAC,CA+B1B;AAMD,uEAAuE;AACvE,MAAM,WAAW,eAAe;IAC9B,mCAAmC;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,iDAAiD;IACjD,gBAAgB,EAAE,MAAM,CAAC;IACzB,6CAA6C;IAC7C,iBAAiB,EAAE,MAAM,CAAC;IAC1B,iEAAiE;IACjE,wBAAwB,EAAE,MAAM,CAAC;IACjC,iDAAiD;IACjD,oBAAoB,EAAE,MAAM,CAAC;IAC7B,4CAA4C;IAC5C,0BAA0B,EAAE,MAAM,CAAC;IACnC,0CAA0C;IAC1C,0BAA0B,EAAE,MAAM,CAAC;IACnC,kCAAkC;IAClC,YAAY,EAAE,MAAM,CAAC;IACrB,+CAA+C;IAC/C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;CACzC;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,eAAe,CAqD3E"}