@pasko70/pibo 1.8.1 → 1.9.1

package/dist/data/telemetry-writer.js

@@ -0,0 +1,114 @@
+const DEFAULT_FLUSH_INTERVAL_MS = 25;
+const DEFAULT_MAX_PENDING_OPERATIONS = 1_024;
+/**
+ * Gateway-scoped, ordered telemetry writer.
+ *
+ * Normal writes are deferred briefly so telemetry from multiple routed sessions
+ * shares one SQLite transaction. The queue never drops lifecycle events: when
+ * the hard bound is reached, it drains immediately in the caller instead.
+ */
+export class AsyncTelemetryWriter {
+    store;
+    options;
+    flushIntervalMs;
+    maxPendingOperations;
+    pending = [];
+    flushTimer;
+    flushing = false;
+    closed = false;
+    constructor(store, options = {}) {
+        this.store = store;
+        this.options = options;
+        this.flushIntervalMs = nonNegativeFinite(options.flushIntervalMs, DEFAULT_FLUSH_INTERVAL_MS);
+        this.maxPendingOperations = positiveInteger(options.maxPendingOperations, DEFAULT_MAX_PENDING_OPERATIONS);
+    }
+    enqueue(write, onError) {
+        if (this.closed) {
+            this.reportError(new Error("Telemetry writer is closed."), onError);
+            return false;
+        }
+        this.pending.push({ write, onError });
+        if (this.pending.length >= this.maxPendingOperations) {
+            this.flushNow();
+        }
+        else {
+            this.scheduleFlush();
+        }
+        return true;
+    }
+    async flush() {
+        this.flushNow();
+    }
+    async dispose() {
+        if (this.closed)
+            return;
+        this.flushNow();
+        this.closed = true;
+    }
+    scheduleFlush() {
+        if (this.flushTimer)
+            return;
+        this.flushTimer = setTimeout(() => {
+            this.flushTimer = undefined;
+            this.flushNow();
+        }, this.flushIntervalMs);
+        this.flushTimer.unref();
+    }
+    flushNow() {
+        if (this.flushing)
+            return;
+        if (this.flushTimer)
+            clearTimeout(this.flushTimer);
+        this.flushTimer = undefined;
+        this.flushing = true;
+        try {
+            while (this.pending.length > 0) {
+                const batch = this.pending;
+                this.pending = [];
+                try {
+                    this.store.transaction(() => {
+                        for (const operation of batch) {
+                            try {
+                                operation.write();
+                            }
+                            catch (error) {
+                                this.reportError(error, operation.onError);
+                            }
+                        }
+                    });
+                }
+                catch (error) {
+                    for (const operation of batch)
+                        this.reportError(error, operation.onError);
+                }
+            }
+        }
+        finally {
+            this.flushing = false;
+            if (!this.closed && this.pending.length > 0)
+                this.scheduleFlush();
+        }
+    }
+    reportError(error, operationHandler) {
+        try {
+            operationHandler?.(error);
+        }
+        catch {
+            // Telemetry error reporting must not affect runtime work.
+        }
+        if (operationHandler === this.options.onError)
+            return;
+        try {
+            this.options.onError?.(error);
+        }
+        catch {
+            // Telemetry error reporting must not affect runtime work.
+        }
+    }
+}
+function nonNegativeFinite(value, fallback) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : fallback;
+}
+function positiveInteger(value, fallback) {
+    return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : fallback;
+}

package/dist/data/telemetry.js

@@ -8,6 +8,20 @@ export class TelemetryStore {
     constructor(db) {
         this.db = db;
     }
+    transaction(action) {
+        if (this.db.isTransaction)
+            return action();
+        this.db.exec("BEGIN IMMEDIATE");
+        try {
+            const result = action();
+            this.db.exec("COMMIT");
+            return result;
+        }
+        catch (error) {
+            this.db.exec("ROLLBACK");
+            throw error;
+        }
+    }
     listSessions(input = {}) {
         return listTelemetrySessions(this.db, input);
     }

package/dist/gateway/server.js

@@ -2,6 +2,7 @@ import { createServer } from "node:net";
 import { createDefaultPiboPluginRegistry, createPiboProfileFromRegistryOrDefault, resolvePiboProfileNameFromRegistryOrDefault } from "../plugins/builtin.js";
 import { PiboSessionRouter } from "../core/session-router.js";
 import { loadPiboModelDefaults, selectRequestedModelProfile } from "../core/model-defaults.js";
+import { ResourceReaperService } from "../resources/reaper.js";
 import { DEFAULT_GATEWAY_HOST, DEFAULT_GATEWAY_PORT, encodeFrame, errorResponse, isGatewayRequestFrame, isGatewaySubscribeFrame, } from "./protocol.js";
 import { releaseFallbackGatewayPid, releaseGatewayPid, writeFallbackGatewayPid, writeGatewayPid } from "./pidfile.js";
 const DEFAULT_MAX_BACKPRESSURE_FRAMES = 1_000;
@@ -131,6 +132,7 @@ export class PiboGatewayServer {
     closedSlowClients = 0;
     server;
     unsubscribe;
+    resourceReaper;
     constructor(options = {}) {
         this.options = options;
         this.pluginRegistry = options.pluginRegistry ?? createDefaultPiboPluginRegistry();
@@ -159,8 +161,14 @@ export class PiboGatewayServer {
         if (this.options.startChannels !== false) {
             await this.startChannels();
         }
+        if (this.options.resourceReaper) {
+            this.resourceReaper = new ResourceReaperService(this.options.resourceReaper);
+            await this.resourceReaper.start();
+        }
     }
     async stop() {
+        await this.resourceReaper?.stop();
+        this.resourceReaper = undefined;
         await this.stopChannels();
         await this.pluginRegistry.getAuthService()?.stop?.();
         this.unsubscribe?.();
@@ -341,6 +349,11 @@ export class PiboGatewayServer {
         return this.sessionStore;
     }
 }
+export function resolveGatewayResourceReaperOptions(options) {
+    if (options.resourceReaper === false || process.env.PIBO_RESOURCE_REAPER_DISABLED === "1")
+        return false;
+    return options.resourceReaper ?? {};
+}
 export async function runGatewayServer(options = {}) {
     const fallbackMode = process.env.PIBO_FALLBACK_MODE === "1";
     try {
@@ -357,7 +370,7 @@ export async function runGatewayServer(options = {}) {
     const releasePid = fallbackMode ? releaseFallbackGatewayPid : releaseGatewayPid;
     let server;
     try {
-        server = new PiboGatewayServer(options);
+        server = new PiboGatewayServer({ ...options, resourceReaper: resolveGatewayResourceReaperOptions(options) });
         await server.start();
     }
     catch (error) {

package/dist/gateway/web.js

@@ -12,7 +12,7 @@ import { PiboPluginRegistry } from "../plugins/registry.js";
 import { createPiboWebHostPlugin } from "../plugins/web.js";
 import { DEFAULT_WEB_CHANNEL_HOST, DEFAULT_WEB_CHANNEL_PORT } from "../web/channel.js";
 import { loadPiboConfig } from "../config/config.js";
-import { PiboGatewayServer } from "./server.js";
+import { PiboGatewayServer, resolveGatewayResourceReaperOptions } from "./server.js";
 import { releaseFallbackGatewayPid, releaseGatewayPid, writeFallbackGatewayPid, writeGatewayPid } from "./pidfile.js";
 const PUBLIC_WEB_CHANNEL_HOST = "0.0.0.0";
 const LOOPBACK_HOSTS = new Set(["localhost", "127.0.0.1", "::1", "[::1]"]);
@@ -196,6 +196,7 @@ export async function runWebGatewayServer(options = {}) {
         server = new PiboGatewayServer({
             ...resolvedOptions,
             pluginRegistry,
+            resourceReaper: resolveGatewayResourceReaperOptions(resolvedOptions),
         });
         await server.start();
     }

package/dist/plugins/context-files.js

@@ -362,12 +362,13 @@ class ContextFileService {
         const markdown = normalizeMarkdown(body.markdown ?? "");
         const scope = normalizeScope(body.scope);
         const agentProfileName = normalizeAgentProfileName(body.agentProfileName, scope === "agent");
+        const key = uniqueKey(`ctx:${slugSegment(label)}`, new Set(this.list(context).map((file) => file.key)));
         const targetDir = this.resolveManagedDir(scope, agentProfileName);
         const absolutePath = uniquePath(targetDir, managedFileName(label));
         await mkdir(dirname(absolutePath), { recursive: true });
         await writeFile(absolutePath, markdown, "utf8");
         const record = this.store.createFile({
-            key: uniqueKey(`ctx:${slugSegment(label)}`, new Set(this.list(context).map((file) => file.key))),
+            key,
             label,
             managedPath: absolutePath,
             scope,
@@ -398,12 +399,13 @@ class ContextFileService {
         const label = normalizeOptionalLabel(body.label) ?? sourceFile.label ?? sourceKey;
         const scope = normalizeScope(body.scope, "global");
         const agentProfileName = normalizeAgentProfileName(body.agentProfileName, scope === "agent");
+        const key = uniqueKey(`ctx:${slugSegment(label)}`, new Set(this.list(context).map((file) => file.key)));
         const targetDir = this.resolveManagedDir(scope, agentProfileName);
         const absolutePath = uniquePath(targetDir, managedFileName(label));
         await mkdir(dirname(absolutePath), { recursive: true });
         await writeFile(absolutePath, sourceDescriptor.content ?? "", "utf8");
         const record = this.store.createFile({
-            key: uniqueKey(`ctx:${slugSegment(label)}`, new Set(this.list(context).map((file) => file.key))),
+            key,
             label,
             managedPath: absolutePath,
             scope,

package/dist/ralph/store.js

@@ -340,7 +340,7 @@ export class PiboRalphStore {
         const reachedMaxIterations = job.maxIterations !== undefined && completedIterations >= job.maxIterations;
         const shouldDisable = reachedMaxIterations || input.stopAfterRun === true || input.stopEvaluation?.finalAction === 'stop-after-run' || input.stopEvaluation?.finalAction === 'cancel-current-run';
         const state = { ...job.state, runningAt: undefined, completedIterations, lastRunAt: timestamp, lastRunId: input.runId, lastStatus: input.status === 'error' ? 'error' : input.status === 'cancelled' ? 'cancelled' : 'ok', lastError: input.error, lastPiboSessionId: input.piboSessionId ?? job.state.lastPiboSessionId, consecutiveErrors: input.status === 'error' ? (job.state.consecutiveErrors ?? 0) + 1 : 0, conditionStates: input.conditionStates ?? job.state.conditionStates, lastStopEvaluation: input.stopEvaluation ?? job.state.lastStopEvaluation };
-        this.db.prepare('UPDATE pibo_ralph_runs SET status = ?, pibo_session_id = ?, reason = ?, error = ?, completed_at = ?, updated_at = ? WHERE id = ?').run(input.status, input.piboSessionId ?? null, input.reason ?? input.stopEvaluation?.reason ?? null, input.error ?? null, timestamp, timestamp, input.runId);
+        this.db.prepare('UPDATE pibo_ralph_runs SET status = ?, pibo_session_id = COALESCE(?, pibo_session_id), reason = ?, error = ?, completed_at = ?, updated_at = ? WHERE id = ?').run(input.status, input.piboSessionId ?? null, input.reason ?? input.stopEvaluation?.reason ?? null, input.error ?? null, timestamp, timestamp, input.runId);
         this.db.prepare('UPDATE pibo_ralph_jobs SET enabled = ?, state_json = ?, updated_at = ? WHERE id = ?').run(shouldDisable ? 0 : job.enabled ? 1 : 0, JSON.stringify(state), timestamp, job.id);
     }
     appendRunFact(input) {

package/dist/resources/cli.js

@@ -0,0 +1,135 @@
+import { Command } from "commander";
+import { getComputeResourceHealth } from "../compute/resource-health.js";
+import { renderComputeResourceHealthText } from "../compute/cli.js";
+import { applyResourceReapPlan, getActiveResourceLeases, planResourceReap, } from "./lifecycle.js";
+function printJson(value) {
+    console.log(JSON.stringify(value, null, 2));
+}
+function parseNonNegativeNumber(value) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed < 0)
+        throw new Error("Value must be a non-negative number");
+    return parsed;
+}
+function parsePidList(value) {
+    const pids = value.split(",").map((item) => Number.parseInt(item.trim(), 10));
+    if (pids.some((pid) => !Number.isInteger(pid) || pid <= 0))
+        throw new Error("PIDs must be positive integers separated by commas");
+    return [...new Set(pids)];
+}
+export function renderResourceLeasesText(leases) {
+    if (leases.length === 0)
+        return "No active managed browser-pool leases.\nNext: pibo resources status";
+    const lines = ["LEASE_ID\tHOLDER\tWORKER/POOL\tEXPIRY\tSTATE"];
+    for (const lease of leases) {
+        lines.push(`${lease.leaseId}\t${lease.holder ?? "-"}\t${lease.workerId}/${lease.poolId}\t${lease.expiresAt ?? "-"}\t${lease.state}`);
+    }
+    lines.push("Next: pibo resources status");
+    return lines.join("\n");
+}
+export function renderResourceReapText(value) {
+    const applied = "applied" in value;
+    const plan = applied ? value.plan : value;
+    const lines = [
+        `Resource reap ${applied ? "apply" : "dry-run"}: ${plan.browserPools.selected} browser pool(s), ${plan.unmanagedBrowsers.selected} unmanaged browser process group(s), ${plan.staleFiles.selected} stale pid/port file(s), ${plan.compute.summary.selected} compute worker(s) selected`,
+        "BROWSER_ACTION\tWORKER/POOL OR PID/PGID\tREASON",
+    ];
+    for (const item of plan.browserPools.items)
+        lines.push(`${item.action}\t${item.workerId}/${item.poolId}\t${item.reason}`);
+    for (const item of plan.unmanagedBrowsers.items)
+        lines.push(`${item.action}\t${item.pid}/${item.processGroupId}\t${item.reason}`);
+    if (applied) {
+        lines.push(`Reaped browser pools: ${value.browserResults.filter((result) => result.reaped).length}`);
+        lines.push(`Terminated unmanaged browser process groups: ${value.terminatedUnmanagedBrowsers.join(", ") || "none"}`);
+        lines.push(`Removed stale pid/port files: ${value.removedStaleFiles.length}`);
+        lines.push(`Removed compute workers: ${value.removedComputeWorkers.join(", ") || "none"}`);
+    }
+    else {
+        const args = [
+            "pibo resources reap --apply",
+            `--max-age-minutes ${plan.options.maxAgeMinutes}`,
+            `--idle-timeout-minutes ${plan.options.idleTimeoutMinutes}`,
+            `--unmanaged-browser-grace-minutes ${plan.options.unmanagedBrowserGraceMinutes}`,
+        ];
+        if (plan.options.includeDev)
+            args.push("--include-dev");
+        if (plan.options.browserPoolRoot)
+            args.push(`--browser-pool-root ${plan.options.browserPoolRoot}`);
+        if (plan.options.browserUseHome)
+            args.push(`--browser-use-home ${plan.options.browserUseHome}`);
+        lines.push(`Dry-run only. Apply after review with: ${args.join(" ")}`);
+    }
+    lines.push("Worktrees are always preserved.");
+    return lines.join("\n");
+}
+export function serializeResourceStatus(health) {
+    return {
+        ...health,
+        nextCommands: [...new Set([
+                "pibo resources status --json",
+                "pibo resources leases --json",
+                "pibo resources reap --dry-run --json",
+                ...health.nextCommands,
+            ])],
+    };
+}
+export async function runResourcesCli(argv) {
+    const program = new Command();
+    program
+        .name("pibo resources")
+        .description("Inspect and safely reap managed compute and browser resources")
+        .helpOption("-h, --help", "Show help")
+        .showHelpAfterError()
+        .helpCommand("help [command]", "Show help for command")
+        .addHelpText("after", "\nNext:\n  pibo resources status\n  pibo resources leases\n  pibo resources reap --help\n");
+    program
+        .command("status")
+        .alias("doctor")
+        .description("Show read-only aggregate compute and browser health")
+        .option("--browser-pool-root <path>", "Browser pool root directory to scan")
+        .option("--browser-use-home <path>", "Browser-use home directory to scan for stale CDP files")
+        .option("--json", "Print machine-readable resource health")
+        .action(async (options) => {
+        const health = serializeResourceStatus(await getComputeResourceHealth(options));
+        if (options.json)
+            printJson(health);
+        else
+            console.log(renderComputeResourceHealthText(health).replace(/^Compute resource health:/, "Resource status:"));
+    });
+    program
+        .command("leases")
+        .description("List active managed browser-pool leases")
+        .option("--browser-pool-root <path>", "Browser pool root directory to scan")
+        .option("--json", "Print machine-readable leases")
+        .action(async (options) => {
+        const leases = await getActiveResourceLeases(options.browserPoolRoot);
+        if (options.json)
+            printJson({ leases });
+        else
+            console.log(renderResourceLeasesText(leases));
+    });
+    program
+        .command("reap")
+        .description("Preview or apply aggregate browser and compute cleanup")
+        .option("--dry-run", "Preview cleanup without changing resources (default)")
+        .option("--apply", "Apply cleanup after rechecking current resource safety")
+        .option("--include-dev", "Also select eligible dev compute workers")
+        .option("--max-age-minutes <n>", "Select compute workers older than this many minutes", parseNonNegativeNumber, 60)
+        .option("--idle-timeout-minutes <n>", "Select browser pools idle for this many minutes", parseNonNegativeNumber, 10)
+        .option("--unmanaged-browser-grace-minutes <n>", "Select unmanaged Chromium older than this many minutes", parseNonNegativeNumber, 10)
+        .option("--exempt-browser-pids <list>", "Comma-separated browser PIDs or process groups to preserve", parsePidList)
+        .option("--browser-pool-root <path>", "Browser pool root directory to scan")
+        .option("--browser-use-home <path>", "Browser-use home directory to scan for stale CDP files")
+        .option("--json", "Print machine-readable cleanup plan or result")
+        .action(async (options) => {
+        if (options.apply && options.dryRun)
+            throw new Error("Use either --apply or --dry-run, not both");
+        const plan = await planResourceReap(options);
+        const result = options.apply ? await applyResourceReapPlan(plan) : plan;
+        if (options.json)
+            printJson(options.apply ? result : { applied: false, dryRun: true, plan: result });
+        else
+            console.log(renderResourceReapText(result));
+    });
+    await program.parseAsync(argv);
+}