@pasko70/pibo 1.9.8 → 1.9.9

package/dist/resources/cli.js

@@ -1,135 +0,0 @@
-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);
-}

package/dist/resources/lifecycle.js

@@ -1,353 +0,0 @@
-import { execFile } from "node:child_process";
-import { existsSync } from "node:fs";
-import { readdir, readFile, rm } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { promisify } from "node:util";
-import { applyComputeWorkerReapPlan, buildComputeWorkerReapPlan, planReapWorkers, } from "../compute/docker.js";
-import { defaultBrowserPoolRoot, defaultBrowserUseHome, getComputeResourceHealth, parseProcessList, } from "../compute/resource-health.js";
-import { loadBrowserPoolState, reapIdleBrowserPool, } from "../tools/browser-pool.js";
-const execFileAsync = promisify(execFile);
-export async function collectManagedBrowserPools(rootDir) {
-    const records = [];
-    for (const statePath of await findStateFiles(rootDir)) {
-        const raw = await readFile(statePath, "utf8").catch(() => undefined);
-        if (!raw)
-            continue;
-        let parsed;
-        try {
-            parsed = JSON.parse(raw);
-        }
-        catch {
-            continue;
-        }
-        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
-            continue;
-        const candidate = parsed;
-        if (typeof candidate.workerId !== "string" || typeof candidate.poolId !== "string")
-            continue;
-        const identity = {
-            workerId: candidate.workerId,
-            poolId: candidate.poolId,
-            maxBrowserProcesses: typeof candidate.maxBrowserProcesses === "number" ? candidate.maxBrowserProcesses : 1,
-        };
-        const state = await loadBrowserPoolState(statePath, { ...identity, onMalformed: "throw" }).catch(() => undefined);
-        if (!state)
-            continue;
-        records.push({ statePath, lockPath: join(dirname(statePath), "state.lock"), state });
-    }
-    return records;
-}
-export function listActiveResourceLeases(records) {
-    return records
-        .filter(({ state }) => Boolean(state.activeLeaseId))
-        .map(({ state }) => ({
-        leaseId: state.activeLeaseId,
-        holder: state.holder,
-        workerId: state.workerId,
-        poolId: state.poolId,
-        expiresAt: state.idleExpiresAt,
-        state: state.state,
-    }))
-        .sort((a, b) => a.leaseId.localeCompare(b.leaseId));
-}
-export async function getActiveResourceLeases(browserPoolRoot = defaultBrowserPoolRoot()) {
-    return listActiveResourceLeases(await collectManagedBrowserPools(browserPoolRoot));
-}
-export async function planResourceReap(options = {}) {
-    const now = options.now ?? new Date();
-    const resolved = resolveReapOptions(options);
-    const [records, staleFiles, compute, health] = await Promise.all([
-        collectManagedBrowserPools(resolved.browserPoolRoot),
-        planStaleCdpFiles(resolved.browserUseHome),
-        planComputeReapSafely({ includeDev: resolved.includeDev, maxAgeMinutes: resolved.maxAgeMinutes, now }),
-        getComputeResourceHealth({ now, browserPoolRoot: resolved.browserPoolRoot, browserUseHome: resolved.browserUseHome }),
-    ]);
-    const unmanagedBrowsers = buildUnmanagedBrowserPlanItems(health.browserProcesses.unassignedMainProcessDetails, resolved.unmanagedBrowserGraceMinutes, new Set(resolved.exemptBrowserPids));
-    return buildResourceReapPlan({ now, options: resolved, records, staleFiles, unmanagedBrowsers, compute });
-}
-export function buildResourceReapPlan(input) {
-    const browserItems = input.records.map((record) => buildBrowserReapPlanItem(record, input.now, input.options.idleTimeoutMinutes));
-    const unmanagedBrowsers = input.unmanagedBrowsers ?? [];
-    return {
-        createdAt: input.now.toISOString(),
-        dryRun: true,
-        options: input.options,
-        browserPools: {
-            items: browserItems,
-            selected: browserItems.filter((item) => item.action === "reap").length,
-            skipped: browserItems.filter((item) => item.action === "skip").length,
-        },
-        staleFiles: { items: input.staleFiles, selected: input.staleFiles.length },
-        unmanagedBrowsers: {
-            items: unmanagedBrowsers,
-            selected: unmanagedBrowsers.filter((item) => item.action === "terminate").length,
-            skipped: unmanagedBrowsers.filter((item) => item.action === "skip").length,
-        },
-        compute: input.compute,
-        worktreesPreserved: true,
-    };
-}
-export async function applyResourceReapPlan(plan, dependencies = {}) {
-    const replan = dependencies.plan ?? planResourceReap;
-    const confirmed = await replan({ ...plan.options, now: new Date() });
-    const reapBrowserPool = dependencies.reapBrowserPool ?? reapIdleBrowserPool;
-    const browserResults = [];
-    for (const item of confirmed.browserPools.items) {
-        if (item.action !== "reap")
-            continue;
-        browserResults.push(await reapBrowserPool({ statePath: item.statePath, lockPath: item.lockPath }, { workerId: item.workerId, poolId: item.poolId }, { idleTimeoutMs: confirmed.options.idleTimeoutMinutes * 60_000 }));
-    }
-    const terminateUnmanagedBrowser = dependencies.terminateUnmanagedBrowser ?? terminateUnmanagedBrowserProcessGroup;
-    const terminatedUnmanagedBrowsers = [];
-    for (const item of confirmed.unmanagedBrowsers.items) {
-        if (item.action !== "terminate")
-            continue;
-        if (await terminateUnmanagedBrowser(item))
-            terminatedUnmanagedBrowsers.push(item.pid);
-    }
-    const removedStaleFiles = await applyStaleCdpFilePlan(confirmed.staleFiles.items, dependencies.isPidAlive);
-    const removedComputeWorkers = await (dependencies.applyCompute ?? applyComputeWorkerReapPlan)(confirmed.compute);
-    return {
-        applied: true,
-        plan: confirmed,
-        browserResults,
-        terminatedUnmanagedBrowsers,
-        removedStaleFiles,
-        removedComputeWorkers,
-        worktreesPreserved: true,
-    };
-}
-function resolveReapOptions(options) {
-    return {
-        includeDev: options.includeDev === true,
-        maxAgeMinutes: options.maxAgeMinutes ?? 60,
-        idleTimeoutMinutes: options.idleTimeoutMinutes ?? 10,
-        unmanagedBrowserGraceMinutes: options.unmanagedBrowserGraceMinutes ?? 10,
-        browserPoolRoot: options.browserPoolRoot ?? defaultBrowserPoolRoot(),
-        browserUseHome: options.browserUseHome ?? defaultBrowserUseHome(),
-        exemptBrowserPids: options.exemptBrowserPids ?? readExemptBrowserPids(),
-    };
-}
-export function buildUnmanagedBrowserPlanItems(processes, graceMinutes, exemptPids = new Set()) {
-    const graceSeconds = graceMinutes * 60;
-    return processes.map((process) => {
-        let action = "terminate";
-        let reason = "unmanaged Chromium main process has no managed browser-pool lease";
-        if (process.pid <= 1 || process.pgid <= 1) {
-            action = "skip";
-            reason = "unsafe pid or process group";
-        }
-        else if (exemptPids.has(process.pid) || exemptPids.has(process.pgid)) {
-            action = "skip";
-            reason = "explicitly exempted pid or process group";
-        }
-        else if (process.elapsedSeconds !== undefined && process.elapsedSeconds < graceSeconds) {
-            action = "skip";
-            reason = `process age ${process.elapsedSeconds}s is within ${graceSeconds}s grace period`;
-        }
-        return {
-            pid: process.pid,
-            ppid: process.ppid,
-            processGroupId: process.pgid,
-            commandName: process.commandName,
-            userDataDir: process.userDataDir,
-            elapsedSeconds: process.elapsedSeconds,
-            action,
-            reason,
-            processGroup: true,
-        };
-    });
-}
-async function terminateUnmanagedBrowserProcessGroup(item) {
-    if (!defaultIsPidAlive(item.pid))
-        return false;
-    const [processInfo, ownProcessGroupId] = await Promise.all([inspectProcess(item.pid), readProcessGroupId(process.pid)]);
-    if (!processInfo || !processInfo.isChromium || !processInfo.isMainProcess || processInfo.pgid !== item.processGroupId)
-        return false;
-    if (ownProcessGroupId !== undefined && ownProcessGroupId === item.processGroupId)
-        return false;
-    try {
-        process.kill(-item.processGroupId, "SIGTERM");
-    }
-    catch (error) {
-        if (!(error instanceof Error && "code" in error && error.code === "ESRCH"))
-            throw error;
-        return false;
-    }
-    await new Promise((resolve) => setTimeout(resolve, 500));
-    if (defaultIsPidAlive(item.pid)) {
-        try {
-            process.kill(-item.processGroupId, "SIGKILL");
-        }
-        catch (error) {
-            if (!(error instanceof Error && "code" in error && error.code === "ESRCH"))
-                throw error;
-        }
-    }
-    return !defaultIsPidAlive(item.pid);
-}
-async function inspectProcess(pid) {
-    try {
-        const { stdout } = await execFileAsync("ps", ["-o", "pid=,ppid=,pgid=,comm=,args=", "-p", String(pid)]);
-        return parseProcessList(stdout).find((item) => item.pid === pid);
-    }
-    catch {
-        return undefined;
-    }
-}
-async function readProcessGroupId(pid) {
-    try {
-        const { stdout } = await execFileAsync("ps", ["-o", "pgid=", "-p", String(pid)]);
-        const value = Number.parseInt(stdout.trim(), 10);
-        return Number.isInteger(value) && value > 0 ? value : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function readExemptBrowserPids() {
-    return (process.env.PIBO_RESOURCE_REAPER_EXEMPT_BROWSER_PIDS ?? "")
-        .split(",")
-        .map((value) => Number.parseInt(value.trim(), 10))
-        .filter((value) => Number.isInteger(value) && value > 0);
-}
-function buildBrowserReapPlanItem(record, now, idleTimeoutMinutes) {
-    const { state } = record;
-    let action = "skip";
-    let reason = "not idle long enough";
-    if (state.activeLeaseId || (state.activeLeaseCount ?? 0) > 0 || state.state === "leased") {
-        reason = state.activeLeaseId ? `active lease ${state.activeLeaseId}` : "active leases";
-    }
-    else if (state.state === "empty" || (!state.pid && !state.cdpUrl && !state.userDataDir)) {
-        reason = "no recorded browser";
-    }
-    else if (state.state === "stale" || state.state === "dirty") {
-        action = "reap";
-        reason = `pool state is ${state.state}`;
-    }
-    else if (hasExpired(state.idleExpiresAt, now)) {
-        action = "reap";
-        reason = `idle expiry ${state.idleExpiresAt} has passed`;
-    }
-    else if (isOlderThan(state.lastUsedAt, now, idleTimeoutMinutes * 60_000)) {
-        action = "reap";
-        reason = `last used at ${state.lastUsedAt} exceeds idle timeout`;
-    }
-    return {
-        workerId: state.workerId,
-        poolId: state.poolId,
-        statePath: record.statePath,
-        lockPath: record.lockPath,
-        action,
-        reason,
-        preservesWorktree: true,
-    };
-}
-async function planComputeReapSafely(options) {
-    try {
-        return await planReapWorkers(options);
-    }
-    catch (error) {
-        if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
-            throw error;
-        const plan = buildComputeWorkerReapPlan([], options);
-        plan.nextCommands = ["Docker CLI is unavailable in this runtime; browser and stale-file cleanup remain active."];
-        return plan;
-    }
-}
-async function planStaleCdpFiles(browserUseHome, isPidAlive = defaultIsPidAlive) {
-    const stateDir = join(browserUseHome, "pibo-cdp");
-    let files;
-    try {
-        files = await readdir(stateDir);
-    }
-    catch {
-        return [];
-    }
-    const items = [];
-    for (const file of files) {
-        if (file.endsWith(".pid")) {
-            const path = join(stateDir, file);
-            const pid = await readPid(path);
-            if (pid === undefined || !isPidAlive(pid))
-                items.push({ path, kind: "pid", action: "remove", reason: pid === undefined ? "invalid pid file" : `pid ${pid} is not alive` });
-        }
-        else if (file.endsWith(".port")) {
-            const pidPath = join(stateDir, `${file.slice(0, -5)}.pid`);
-            if (!existsSync(pidPath))
-                items.push({ path: join(stateDir, file), kind: "port", action: "remove", reason: "matching pid file is missing" });
-        }
-    }
-    return items;
-}
-async function applyStaleCdpFilePlan(items, isPidAlive = defaultIsPidAlive) {
-    const removed = [];
-    for (const item of items) {
-        if (item.kind === "pid") {
-            const pid = await readPid(item.path);
-            if (pid !== undefined && isPidAlive(pid))
-                continue;
-            await rm(item.path, { force: true });
-            removed.push(item.path);
-            const portPath = `${item.path.slice(0, -4)}.port`;
-            if (existsSync(portPath)) {
-                await rm(portPath, { force: true });
-                removed.push(portPath);
-            }
-            continue;
-        }
-        const pidPath = `${item.path.slice(0, -5)}.pid`;
-        if (existsSync(pidPath))
-            continue;
-        await rm(item.path, { force: true });
-        removed.push(item.path);
-    }
-    return removed;
-}
-async function findStateFiles(rootDir) {
-    const found = [];
-    async function walk(dir) {
-        let entries;
-        try {
-            entries = await readdir(dir, { withFileTypes: true });
-        }
-        catch {
-            return;
-        }
-        for (const entry of entries) {
-            const path = join(dir, entry.name);
-            if (entry.isDirectory())
-                await walk(path);
-            else if (entry.isFile() && entry.name === "state.json")
-                found.push(path);
-        }
-    }
-    await walk(rootDir);
-    return found;
-}
-async function readPid(path) {
-    const text = await readFile(path, "utf8").catch(() => "");
-    const pid = Number.parseInt(text.trim(), 10);
-    return Number.isInteger(pid) && pid > 0 ? pid : undefined;
-}
-function hasExpired(value, now) {
-    if (!value)
-        return false;
-    const timestamp = Date.parse(value);
-    return !Number.isNaN(timestamp) && timestamp <= now.getTime();
-}
-function isOlderThan(value, now, ageMs) {
-    if (!value)
-        return false;
-    const timestamp = Date.parse(value);
-    return !Number.isNaN(timestamp) && timestamp + ageMs <= now.getTime();
-}
-function defaultIsPidAlive(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (error) {
-        return error instanceof Error && "code" in error && error.code === "EPERM";
-    }
-}

package/dist/resources/reaper-state.js

@@ -1,94 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { mkdir, open, readFile, rename, rm, writeFile } from "node:fs/promises";
-import { dirname } from "node:path";
-import { piboHomePath } from "../core/pibo-home.js";
-export function defaultResourceReaperStatePath() {
-    return process.env.PIBO_RESOURCE_REAPER_STATE_PATH || piboHomePath("resource-reaper-state.json");
-}
-export async function writeResourceReaperState(path, state) {
-    await mkdir(dirname(path), { recursive: true });
-    const temporaryPath = `${path}.${process.pid}.tmp`;
-    await writeFile(temporaryPath, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 });
-    await rename(temporaryPath, path);
-}
-export async function claimResourceReaperOwnership(lockPath, pid = process.pid, isPidAlive = defaultIsPidAlive) {
-    await mkdir(dirname(lockPath), { recursive: true });
-    try {
-        const handle = await open(lockPath, "wx", 0o600);
-        await handle.writeFile(`${pid}\n`);
-        await handle.close();
-        return true;
-    }
-    catch (error) {
-        if (!(error instanceof Error && "code" in error && error.code === "EEXIST"))
-            throw error;
-    }
-    const owner = Number.parseInt((await readFile(lockPath, "utf8").catch(() => "")).trim(), 10);
-    if (Number.isInteger(owner) && owner > 0 && isPidAlive(owner))
-        return false;
-    await rm(lockPath, { force: true });
-    try {
-        const handle = await open(lockPath, "wx", 0o600);
-        await handle.writeFile(`${pid}\n`);
-        await handle.close();
-        return true;
-    }
-    catch (error) {
-        if (error instanceof Error && "code" in error && error.code === "EEXIST")
-            return false;
-        throw error;
-    }
-}
-export async function releaseResourceReaperOwnership(lockPath, pid = process.pid) {
-    const owner = Number.parseInt((await readFile(lockPath, "utf8").catch(() => "")).trim(), 10);
-    if (owner === pid)
-        await rm(lockPath, { force: true });
-}
-export function readResourceReaperTimerStatus(path = defaultResourceReaperStatePath(), isPidAlive = defaultIsPidAlive) {
-    if (!existsSync(path)) {
-        return {
-            status: "missing",
-            details: "No automatic resource reaper state was found.",
-            nextCommands: ["pibo resources status --json", "pibo resources reap --dry-run --json"],
-        };
-    }
-    try {
-        const state = JSON.parse(readFileSync(path, "utf8"));
-        if (state.status !== "running" || !Number.isInteger(state.pid) || state.pid <= 0 || !isPidAlive(state.pid)) {
-            return {
-                status: "unknown",
-                details: `Resource reaper state exists but its owner is not running (${path}).`,
-                lastRunAt: state.lastRunAt,
-                nextRunAt: state.nextRunAt,
-                lastResult: state.lastResult,
-                lastError: state.lastError,
-                nextCommands: ["pibo resources status --json", "pibo resources reap --dry-run --json"],
-            };
-        }
-        return {
-            status: "configured",
-            details: `Automatic resource reaper is running every ${state.intervalMs} ms (pid ${state.pid}).`,
-            lastRunAt: state.lastRunAt,
-            nextRunAt: state.nextRunAt,
-            lastResult: state.lastResult,
-            lastError: state.lastError,
-            nextCommands: ["pibo resources status --json", "pibo resources reap --dry-run --json"],
-        };
-    }
-    catch (error) {
-        return {
-            status: "unknown",
-            details: `Resource reaper state could not be read: ${error instanceof Error ? error.message : String(error)}`,
-            nextCommands: ["pibo resources status --json", "pibo resources reap --dry-run --json"],
-        };
-    }
-}
-function defaultIsPidAlive(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (error) {
-        return error instanceof Error && "code" in error && error.code === "EPERM";
-    }
-}