@llblab/pi-actors 0.23.0 → 0.24.1

package/dist/lib/async-runner.js

@@ -0,0 +1,134 @@
+/**
+ * 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/async-runs.js

@@ -12,6 +12,7 @@ import { basename, dirname, extname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { substituteCommandTemplateToken } from "./command-templates.js";
 import { writeJsonAtomic } from "./file-state.js";
+import { readJsonFileResilient, readJsonlFileResilient } from "./state-readers.js";
 import * as Paths from "./paths.js";
 import * as RecipeReferences from "./recipe-references.js";
 import * as RecipeUsage from "./recipe-usage.js";
@@ -189,12 +190,7 @@ function resolveStartParams(params) {
     };
 }
 function readJson(path) {
-    try {
-        return JSON.parse(readFileSync(path, "utf8"));
-    }
-    catch {
-        return undefined;
-    }
+    return readJsonFileResilient(path, undefined).value;
 }
 function isAlive(pid) {
     try {
@@ -232,20 +228,12 @@ function tailLines(path, lines) {
     return content ? content.split("\n") : [];
 }
 function getInterruptedRunStatus(stateDir) {
-    const events = tailFile(join(stateDir, "events.jsonl"), 200);
-    if (!events)
-        return undefined;
-    for (const line of events.split("\n").reverse()) {
-        try {
-            const event = JSON.parse(line);
-            if (event.event === "run.kill")
-                return "killed";
-            if (event.event === "run.cancel")
-                return "cancelled";
-        }
-        catch {
-            // Ignore malformed event lines.
-        }
+    const events = readJsonlFileResilient(join(stateDir, "events.jsonl")).records.slice(-200);
+    for (const event of events.reverse()) {
+        if (event.event === "run.kill")
+            return "killed";
+        if (event.event === "run.cancel")
+            return "cancelled";
     }
     return undefined;
 }
@@ -655,14 +643,7 @@ function parseRunInboxLine(line) {
     }
 }
 function readRunInboxMessagesFromStateDir(stateDir) {
-    const file = runInboxFile(stateDir);
-    if (!existsSync(file))
-        return [];
-    return readFileSync(file, "utf8")
-        .split("\n")
-        .filter((line) => line.trim())
-        .map(parseRunInboxLine)
-        .filter((message) => Boolean(message));
+    return readJsonlFileResilient(runInboxFile(stateDir)).records;
 }
 function writeRunInboxMessages(stateDir, messages) {
     writeFileSync(runInboxFile(stateDir), messages.length

package/dist/lib/conformance.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Internal conformance runner logic.
+ * Zones: CI/release validation, protocol regression suite selection
+ */
+export declare const conformanceSuites: string[];
+export interface ConformanceReport {
+    code: number;
+    output: string;
+    summary: string;
+    suites: number;
+}
+export declare function runConformance(cwd?: URL): ConformanceReport;

package/dist/lib/conformance.js

@@ -0,0 +1,28 @@
+/**
+ * Internal conformance runner logic.
+ * Zones: CI/release validation, protocol regression suite selection
+ */
+import { spawnSync } from "node:child_process";
+export const conformanceSuites = [
+    "tests/protocol-examples.test.ts",
+    "tests/recipe-discovery.test.ts",
+    "tests/registry.test.ts",
+    "tests/runtime-registry.test.ts",
+    "tests/async-runs.test.ts",
+    "tests/actor-rooms.test.ts",
+    "tests/tools.test.ts",
+];
+export function runConformance(cwd = new URL("..", import.meta.url)) {
+    const result = spawnSync(process.execPath, ["--experimental-strip-types", "--test", ...conformanceSuites], { cwd, encoding: "utf8", stdio: "pipe" });
+    const output = `${result.stdout ?? ""}${result.stderr ?? ""}`;
+    const summary = output
+        .split("\n")
+        .filter((line) => /^ℹ (tests|pass|fail|cancelled|skipped|todo|duration_ms) /.test(line))
+        .join("\n");
+    return {
+        code: result.status ?? 1,
+        output,
+        summary,
+        suites: conformanceSuites.length,
+    };
+}

package/dist/lib/coordinator.d.ts

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