@llblab/pi-actors 0.33.0 → 0.34.0

package/dist/lib/actor-worker.js

@@ -1,134 +0,0 @@
-/**
- * Canonical mailbox-backed actor worker entrypoint logic.
- * Zones: worker demo, mailbox loop recipe runtime
- */
-import { appendFileSync, mkdirSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { appendRoomMessage, ensureRoomMember, readBranchInboxMessages } from "./actor-rooms.js";
-import { handleMailboxLoopOnce, isMailboxLoopStopMessage } from "./mailbox-loop.js";
-export function parseActorWorkerArgs(argv) {
-    const args = {};
-    for (let index = 0; index < argv.length; index += 1) {
-        const token = argv[index];
-        if (!token.startsWith("--"))
-            continue;
-        const key = token.slice(2).replaceAll("-", "_");
-        const next = argv[index + 1];
-        if (!next || next.startsWith("--")) {
-            args[key] = true;
-            continue;
-        }
-        args[key] = next;
-        index += 1;
-    }
-    return args;
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function text(value) {
-    return typeof value === "string" ? value : JSON.stringify(value);
-}
-function enabled(value) {
-    return value !== false && value !== "false" && value !== "0";
-}
-function safeName(value) {
-    return String(value ?? "unknown").replaceAll(/[^A-Za-z0-9_.-]+/g, "_");
-}
-export async function runActorWorker(argv = process.argv.slice(2)) {
-    const args = parseActorWorkerArgs(argv);
-    const stateDir = String(args.state_dir ?? "");
-    const run = String(args.run ?? "");
-    const branch = String(args.branch ?? "worker");
-    const pollMs = Math.max(50, Number(args.poll_ms ?? 1000));
-    const staleClaimMs = Math.max(0, Number(args.stale_claim_ms ?? 0));
-    const artifactDir = String(args.artifact_dir ?? join(stateDir, "worker-artifacts"));
-    const writeArtifacts = enabled(args.write_artifacts ?? true);
-    if (!stateDir || !run) {
-        throw new Error("usage: actor-worker.mjs --state-dir <dir> --run <id> [--branch worker] [--poll-ms 1000]");
-    }
-    const branchAddress = `branch:${run}/${branch}`;
-    const roomAddress = `room:${run}`;
-    const journalPath = join(stateDir, "worker-events.jsonl");
-    const statusPath = join(stateDir, "worker-status.json");
-    if (writeArtifacts)
-        mkdirSync(artifactDir, { recursive: true });
-    function journal(event, data = {}) {
-        appendFileSync(journalPath, `${JSON.stringify({ event, ts: new Date().toISOString(), ...data })}\n`);
-    }
-    function staleClaims() {
-        if (staleClaimMs <= 0)
-            return 0;
-        const cutoff = Date.now() - staleClaimMs;
-        return readBranchInboxMessages(stateDir, run, branchAddress).filter((record) => {
-            if (record.status !== "claimed" || !record.claimed_at)
-                return false;
-            const claimedAt = Date.parse(record.claimed_at);
-            return Number.isFinite(claimedAt) && claimedAt < cutoff;
-        }).length;
-    }
-    function status(state, data = {}) {
-        writeFileSync(statusPath, `${JSON.stringify({ artifact_dir: artifactDir, branch, run, stale_claims: staleClaims(), state, ts: new Date().toISOString(), ...data }, null, 2)}\n`);
-    }
-    function writeResultArtifact(id, result) {
-        if (!writeArtifacts)
-            return undefined;
-        const path = join(artifactDir, `${safeName(id)}.txt`);
-        writeFileSync(path, `${result}\n`);
-        return path;
-    }
-    function room(type, summary, body = {}) {
-        appendRoomMessage(stateDir, "main", {
-            body,
-            from: branchAddress,
-            summary,
-            to: roomAddress,
-            type,
-        });
-    }
-    ensureRoomMember(stateDir, run, "main", branchAddress, { display: branch, role: "worker", status: "present" }, `${branch} joined as mailbox worker`);
-    room("awaiting_assignment", `${branch} awaiting assignment`, { branch });
-    journal("worker.started", { artifact_dir: artifactDir, branch, run, stale_claim_ms: staleClaimMs });
-    status("awaiting_assignment", { handled: 0, stale_claim_ms: staleClaimMs });
-    let handled = 0;
-    let stopping = false;
-    while (!stopping) {
-        const result = await handleMailboxLoopOnce({ address: branchAddress, kind: "branch", run, stateDir }, (message) => {
-            if (isMailboxLoopStopMessage(message)) {
-                stopping = true;
-                room("actor.leave", `${branch} stopping`, { branch, reason: message.type });
-                journal("worker.stopping", { id: message.id, type: message.type });
-                status("stopping", { handled, reason: message.type });
-                return;
-            }
-            room("task.claim", `${branch} claimed ${message.type}`, {
-                branch,
-                id: message.id,
-                type: message.type,
-            });
-            const result = text(message.body);
-            const artifact = writeResultArtifact(message.id, result);
-            handled += 1;
-            room("task.result", `${branch} handled ${message.type}`, {
-                artifact,
-                branch,
-                id: message.id,
-                result,
-                type: message.type,
-            });
-            room("awaiting_assignment", `${branch} awaiting assignment`, { branch });
-            journal("task.handled", { artifact, id: message.id, type: message.type });
-            status("awaiting_assignment", {
-                handled,
-                last_artifact: artifact,
-                last_id: message.id,
-                last_type: message.type,
-                stale_claim_ms: staleClaimMs,
-            });
-        }, { owner: branchAddress });
-        if (!result.handled)
-            await sleep(pollMs);
-    }
-    journal("worker.done", { branch, handled, run });
-    status("done", { handled });
-}

package/dist/lib/async-runner.d.ts

@@ -1,5 +0,0 @@
-/**
- * Detached async-runner entrypoint logic.
- * Zones: async run process, command-template execution telemetry
- */
-export declare function runAsyncRunner(stateDir?: string): Promise<void>;

package/dist/lib/async-runner.js

@@ -1,134 +0,0 @@
-/**
- * Detached async-runner entrypoint logic.
- * Zones: async run process, command-template execution telemetry
- */
-import { appendFileSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { appendRecipeContextToPiArgs } from "./actor-recipe-context.js";
-import { execCommandTemplate } from "./command-templates.js";
-import { executeRegisteredTool } from "./execution.js";
-import { writeJsonAtomic } from "./file-state.js";
-function quoteCommandDetailPart(value) {
-    if (value === "")
-        return "''";
-    if (/^[A-Za-z0-9_/:=.,@%+\-]+$/.test(value))
-        return value;
-    return `'${String(value).replaceAll("'", "'\\''")}'`;
-}
-function formatCommandDetail(command, args) {
-    return [command, ...args].map(quoteCommandDetailPart).join(" ");
-}
-function summarizeCommandDetail(commandDetail) {
-    return commandDetail.length > 160
-        ? `${commandDetail.slice(0, 157)}...`
-        : commandDetail;
-}
-export async function runAsyncRunner(stateDir = process.argv[2]) {
-    if (!stateDir)
-        throw new Error("missing state dir");
-    const runPath = join(stateDir, "run.json");
-    const progressPath = join(stateDir, "progress.json");
-    const resultPath = join(stateDir, "result.json");
-    const eventsPath = join(stateDir, "events.jsonl");
-    const outboxPath = join(stateDir, "outbox.jsonl");
-    const stdoutPath = join(stateDir, "stdout.log");
-    const stderrPath = join(stateDir, "stderr.log");
-    const meta = JSON.parse(readFileSync(runPath, "utf8"));
-    function event(name, data = {}) {
-        appendFileSync(eventsPath, `${JSON.stringify({ event: name, ts: new Date().toISOString(), ...data })}\n`);
-    }
-    function outbox(name, summary, data = {}, delivery = "log", level = "info") {
-        appendFileSync(outboxPath, `${JSON.stringify({ body: data, data, delivery, event: name, from: `run:${meta.run}`, level, summary, to: "coordinator", ts: new Date().toISOString(), type: name })}\n`);
-    }
-    function progress(phase, extra = {}) {
-        writeJsonAtomic(progressPath, {
-            phase,
-            updatedAt: new Date().toISOString(),
-            ...extra,
-        });
-    }
-    let activeSubagents = 0;
-    let completedSubagents = 0;
-    const subagentFailures = [];
-    function getCommandDoneDelivery(result) {
-        return result.code !== 0 || activeSubagents > 0 ? "followup" : "log";
-    }
-    function progressRunning() {
-        progress("running", {
-            activeSubagents,
-            completed: completedSubagents,
-            failures: subagentFailures,
-        });
-    }
-    async function observedExec(command, args, options) {
-        const commandDetail = formatCommandDetail(command, args);
-        const execArgs = appendRecipeContextToPiArgs(command, args, meta.recipe_context_records, options?.actorRecipeContext);
-        activeSubagents += 1;
-        event("command.start", { activeSubagents, command: commandDetail });
-        progressRunning();
-        const result = await execCommandTemplate(command, execArgs, options);
-        activeSubagents = Math.max(0, activeSubagents - 1);
-        completedSubagents += 1;
-        if (result.code !== 0) {
-            subagentFailures.push({
-                code: result.code,
-                command: commandDetail,
-                killed: result.killed,
-            });
-        }
-        event("command.done", {
-            activeSubagents,
-            code: result.code,
-            command: commandDetail,
-            killed: result.killed,
-        });
-        outbox("command.done", `Command ${summarizeCommandDetail(commandDetail)} completed with code ${result.code}`, {
-            activeSubagents,
-            ...(meta.artifacts ? { artifacts: meta.artifacts } : {}),
-            run_files: [stdoutPath, stderrPath, resultPath, eventsPath, outboxPath],
-            code: result.code,
-            command: commandDetail,
-            killed: result.killed,
-        }, getCommandDoneDelivery(result), result.code === 0 ? "info" : "error");
-        progressRunning();
-        return result;
-    }
-    try {
-        event("run.runner.start", { pid: process.pid });
-        progressRunning();
-        const result = await executeRegisteredTool({
-            name: "run_actor",
-            description: "Detached command-template run actor",
-            template: meta.template,
-            args: [],
-            defaults: {},
-        }, meta.values || {}, observedExec, meta.cwd);
-        const text = result.content?.[0]?.text || "";
-        appendFileSync(stdoutPath, text);
-        writeJsonAtomic(resultPath, {
-            code: result.details.code,
-            command: result.details.command,
-            killed: result.details.killed,
-            truncated: result.details.truncated,
-            completedAt: new Date().toISOString(),
-        });
-        progress("done", {
-            completed: 1,
-            failures: result.details.nonCriticalFailures || [],
-        });
-        event("run.done", { code: result.details.code });
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        appendFileSync(stderrPath, `${message}\n`);
-        writeJsonAtomic(resultPath, {
-            code: 1,
-            error: message,
-            killed: false,
-            completedAt: new Date().toISOString(),
-        });
-        progress("failed", { completed: 0, failures: [{ message }] });
-        event("run.failed", { error: message });
-        throw error;
-    }
-}

package/dist/lib/coordinator.d.ts

@@ -1,5 +0,0 @@
-/**
- * Multi-actor coordinator helper entrypoint logic.
- * Zones: swarm coordination, worker pool orchestration
- */
-export declare function runCoordinator(argv?: string[]): Promise<void>;