openclaw-swarm-layer 0.1.0

package/dist/src/runtime/bridge-openclaw-subagent-adapter.js

@@ -0,0 +1,149 @@
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import { formatBridgeFailure } from "./bridge-errors.js";
+export const SUBAGENT_BRIDGE_REPLACEMENT_BOUNDARY = {
+    currentImplementation: "bridge-openclaw-subagent-adapter -> openclaw-exec-bridge patched helpers",
+    targetImplementation: "public subagent spawn helper from top-level plugin-sdk export",
+    publicExport: "spawnSubagentDirect",
+};
+function resolveBridgeScriptPath() {
+    const currentFile = fileURLToPath(import.meta.url);
+    let cursor = path.dirname(currentFile);
+    while (true) {
+        const packageJson = path.join(cursor, "package.json");
+        if (path.basename(cursor) === "openclaw-swarm-layer") {
+            break;
+        }
+        const parent = path.dirname(cursor);
+        if (parent === cursor) {
+            throw new Error("Unable to resolve swarm-layer project root for subagent bridge script");
+        }
+        cursor = parent;
+    }
+    return path.join(cursor, "scripts", "openclaw-exec-bridge.mjs");
+}
+function resolveTsxLoaderPath() {
+    const currentFile = fileURLToPath(import.meta.url);
+    let cursor = path.dirname(currentFile);
+    while (true) {
+        const candidate = path.join(cursor, "node_modules", "tsx", "dist", "loader.mjs");
+        if (path.basename(cursor) === "openclaw-swarm-layer") {
+            return candidate;
+        }
+        const parent = path.dirname(cursor);
+        if (parent === cursor) {
+            throw new Error("Unable to resolve tsx loader for subagent bridge");
+        }
+        cursor = parent;
+    }
+}
+async function runBridgeCommandDirect(argv, options) {
+    const { spawn } = await import("node:child_process");
+    return await new Promise((resolve, reject) => {
+        const child = spawn(argv[0], argv.slice(1), {
+            cwd: options.cwd,
+            stdio: ["pipe", "pipe", "pipe"],
+            env: process.env,
+        });
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        const timer = setTimeout(() => child.kill("SIGTERM"), options.timeoutMs);
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on("error", (error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            reject(error);
+        });
+        child.on("close", (code) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve({ code: code ?? 1, stdout, stderr });
+        });
+        child.stdin.write(options.input);
+        child.stdin.end();
+    });
+}
+export class BridgeOpenClawSubagentAdapter {
+    config;
+    nodePath;
+    bridgeScriptPath;
+    tsxLoaderPath;
+    commandRunner;
+    constructor(config, nodePath = config.bridge.nodePath ?? process.execPath, bridgeScriptPath = resolveBridgeScriptPath(), tsxLoaderPath = resolveTsxLoaderPath(), commandRunner = runBridgeCommandDirect) {
+        this.config = config;
+        this.nodePath = nodePath;
+        this.bridgeScriptPath = bridgeScriptPath;
+        this.tsxLoaderPath = tsxLoaderPath;
+        this.commandRunner = commandRunner;
+    }
+    async spawnSubagent(params) {
+        const result = await this.commandRunner([this.nodePath, "--import", this.tsxLoaderPath, this.bridgeScriptPath, "subagent-spawn"], {
+            timeoutMs: 120_000,
+            cwd: path.dirname(this.bridgeScriptPath),
+            input: JSON.stringify({
+                bridge: {
+                    openclawRoot: this.config.bridge.openclawRoot,
+                    versionAllow: this.config.bridge.versionAllow,
+                },
+                params,
+            }),
+        });
+        if (result.code !== 0) {
+            throw new Error(formatBridgeFailure("subagent-spawn", result.stderr.trim() || result.stdout.trim() || "unknown error"));
+        }
+        const parsed = JSON.parse(result.stdout);
+        return parsed.result;
+    }
+    async getSubagentRunStatus(childSessionKey) {
+        const result = await this.commandRunner([this.nodePath, "--import", this.tsxLoaderPath, this.bridgeScriptPath, "subagent-status"], {
+            timeoutMs: 120_000,
+            cwd: path.dirname(this.bridgeScriptPath),
+            input: JSON.stringify({
+                bridge: {
+                    openclawRoot: this.config.bridge.openclawRoot,
+                    versionAllow: this.config.bridge.versionAllow,
+                },
+                params: { childSessionKey },
+            }),
+        });
+        if (result.code !== 0) {
+            throw new Error(formatBridgeFailure("subagent-status", result.stderr.trim() || result.stdout.trim() || "unknown error"));
+        }
+        const parsed = JSON.parse(result.stdout);
+        return parsed.result;
+    }
+    async killSubagentRun(childSessionKey, reason) {
+        const result = await this.commandRunner([this.nodePath, "--import", this.tsxLoaderPath, this.bridgeScriptPath, "subagent-kill"], {
+            timeoutMs: 120_000,
+            cwd: path.dirname(this.bridgeScriptPath),
+            input: JSON.stringify({
+                bridge: {
+                    openclawRoot: this.config.bridge.openclawRoot,
+                    versionAllow: this.config.bridge.versionAllow,
+                },
+                params: { childSessionKey, reason },
+            }),
+        });
+        if (result.code !== 0) {
+            throw new Error(formatBridgeFailure("subagent-kill", result.stderr.trim() || result.stdout.trim() || "unknown error"));
+        }
+        const parsed = JSON.parse(result.stdout);
+        return parsed.result;
+    }
+}
+export function createBridgeSubagentAdapter(config) {
+    if (!config.bridge.enabled) {
+        return null;
+    }
+    return new BridgeOpenClawSubagentAdapter(config);
+}

package/dist/src/runtime/manual-runner.d.ts

@@ -0,0 +1,9 @@
+import { WorkspaceManager } from "../workspace/workspace-manager.js";
+import type { TaskRunner, RunnerPlanInput, RunnerPlan, RunnerRunInput, RunnerRunResult } from "./task-runner.js";
+export declare class ManualRunner implements TaskRunner {
+    private readonly workspaceManager;
+    readonly kind: "manual";
+    constructor(workspaceManager?: WorkspaceManager);
+    plan(input: RunnerPlanInput): Promise<RunnerPlan>;
+    run(input: RunnerRunInput): Promise<RunnerRunResult>;
+}

package/dist/src/runtime/manual-runner.js

@@ -0,0 +1,53 @@
+import { WorkspaceManager } from "../workspace/workspace-manager.js";
+function timestamp() {
+    return new Date().toISOString();
+}
+function nextAttempt(taskId, runIds) {
+    return runIds.filter((runId) => runId.startsWith(`${taskId}-run-`)).length + 1;
+}
+export class ManualRunner {
+    workspaceManager;
+    kind = "manual";
+    constructor(workspaceManager = new WorkspaceManager()) {
+        this.workspaceManager = workspaceManager;
+    }
+    async plan(input) {
+        const workspace = await this.workspaceManager.resolveWorkspace(input.projectRoot, input.task);
+        return {
+            runnable: true,
+            summary: `manual runner would use ${workspace.mode} workspace at ${workspace.workspacePath}`,
+            workspacePath: workspace.workspacePath,
+            nextStatus: input.task.review.required ? "review_required" : "done",
+        };
+    }
+    async run(input) {
+        const plan = await this.plan({ ...input, dryRun: false });
+        const runId = `${input.task.taskId}-run-${nextAttempt(input.task.taskId, input.workflow.tasks.flatMap((task) => (task.taskId === input.task.taskId ? [task.taskId] : [])))}`;
+        return {
+            accepted: true,
+            nextTaskStatus: plan.nextStatus,
+            runRecord: {
+                runId,
+                taskId: input.task.taskId,
+                attempt: 1,
+                status: "completed",
+                runner: { type: "manual" },
+                workspacePath: plan.workspacePath,
+                startedAt: timestamp(),
+                endedAt: timestamp(),
+                promptSummary: input.task.description,
+                resultSummary: input.task.review.required
+                    ? "manual runner recorded task for review"
+                    : "manual runner recorded task as complete",
+                artifacts: [],
+                sessionRef: {
+                    runtime: "manual",
+                },
+                events: [
+                    { at: timestamp(), type: "planned" },
+                    { at: timestamp(), type: "completed" },
+                ],
+            },
+        };
+    }
+}

package/dist/src/runtime/openclaw-exec-bridge.d.ts

@@ -0,0 +1,211 @@
+type BridgeCommand = "doctor" | "acp-spawn" | "acp-status" | "acp-cancel" | "acp-close" | "subagent-spawn" | "subagent-status" | "subagent-kill";
+type BridgeInput = {
+    bridge?: {
+        nodePath?: string;
+        openclawRoot?: string;
+        versionAllow?: string[];
+    };
+    params?: Record<string, unknown>;
+};
+export type BridgeDoctorResult = {
+    ok: boolean;
+    severity: "healthy" | "warning" | "blocked";
+    openclawRoot: string;
+    version?: string;
+    compatibility: {
+        strategy?: "internal-bundle";
+        testedAt?: string;
+        supportedRunners: string[];
+        replacementCandidates: string[];
+        notes: string[];
+    };
+    publicApi: {
+        acpControlPlaneExport: boolean;
+        subagentSpawnExport: boolean;
+        readyReplacementPoints: string[];
+    };
+    replacementPlan: Array<{
+        runner: "acp" | "subagent";
+        publicExport: string;
+        available: boolean;
+        status: "ready" | "blocked";
+        currentImplementation: string;
+        targetImplementation: string;
+        affectedModules: string[];
+        nextStep: string;
+    }>;
+    migrationChecklist: string[];
+    checks: {
+        versionMapped: boolean;
+        versionAllowed: boolean;
+        internalModuleResolved: boolean;
+        acpBackendHealthy: boolean;
+        subagentPatchable: boolean;
+    };
+    blockers: string[];
+    warnings: string[];
+    risks: string[];
+    remediation: string[];
+    nextAction: string;
+};
+export declare function deriveDoctorRemediation(report: Omit<BridgeDoctorResult, "remediation" | "nextAction" | "severity">): string[];
+export declare function deriveDoctorSeverity(report: Omit<BridgeDoctorResult, "severity" | "nextAction">): BridgeDoctorResult["severity"];
+export declare function deriveDoctorNextAction(report: Omit<BridgeDoctorResult, "nextAction">): string;
+export declare function dedupeStrings(values: string[]): string[];
+export declare function waitForAcpBackendHealthy(getBackend: () => {
+    healthy?: () => boolean;
+} | null, backendId: string, timeoutMs?: number, intervalMs?: number): Promise<void>;
+export declare function runBridgeCommand(command: BridgeCommand, input: BridgeInput): Promise<{
+    ok: boolean;
+    version: string;
+    result: BridgeDoctorResult;
+} | {
+    ok: boolean;
+    version: string;
+    result: {
+        childSessionKey: unknown;
+        runId: unknown;
+        mode: {};
+        acceptedAt: string;
+        note: unknown;
+        state?: undefined;
+        checkedAt?: undefined;
+        message?: undefined;
+        outputText?: undefined;
+        killedAt?: undefined;
+        sessionKey?: undefined;
+        backend?: undefined;
+        backendSessionId?: undefined;
+        agentSessionId?: undefined;
+        cancelledAt?: undefined;
+        closedAt?: undefined;
+    };
+} | {
+    ok: boolean;
+    version: string;
+    result: {
+        childSessionKey: string;
+        runId: string | undefined;
+        state: "failed" | "running" | "completed" | "cancelled";
+        checkedAt: string;
+        message: string | undefined;
+        outputText: string | undefined;
+        mode?: undefined;
+        acceptedAt?: undefined;
+        note?: undefined;
+        killedAt?: undefined;
+        sessionKey?: undefined;
+        backend?: undefined;
+        backendSessionId?: undefined;
+        agentSessionId?: undefined;
+        cancelledAt?: undefined;
+        closedAt?: undefined;
+    };
+} | {
+    ok: boolean;
+    version: string;
+    result: {
+        childSessionKey: string;
+        killedAt: string;
+        message: string;
+        runId?: undefined;
+        mode?: undefined;
+        acceptedAt?: undefined;
+        note?: undefined;
+        state?: undefined;
+        checkedAt?: undefined;
+        outputText?: undefined;
+        sessionKey?: undefined;
+        backend?: undefined;
+        backendSessionId?: undefined;
+        agentSessionId?: undefined;
+        cancelledAt?: undefined;
+        closedAt?: undefined;
+    };
+} | {
+    ok: boolean;
+    version: string;
+    result: {
+        sessionKey: string;
+        backend: any;
+        backendSessionId: any;
+        agentSessionId: any;
+        acceptedAt: string;
+        childSessionKey?: undefined;
+        runId?: undefined;
+        mode?: undefined;
+        note?: undefined;
+        state?: undefined;
+        checkedAt?: undefined;
+        message?: undefined;
+        outputText?: undefined;
+        killedAt?: undefined;
+        cancelledAt?: undefined;
+        closedAt?: undefined;
+    };
+} | {
+    ok: boolean;
+    version: string;
+    result: {
+        sessionKey: string;
+        state: "failed" | "running" | "completed";
+        backend: any;
+        backendSessionId: any;
+        agentSessionId: any;
+        checkedAt: string;
+        message: any;
+        childSessionKey?: undefined;
+        runId?: undefined;
+        mode?: undefined;
+        acceptedAt?: undefined;
+        note?: undefined;
+        outputText?: undefined;
+        killedAt?: undefined;
+        cancelledAt?: undefined;
+        closedAt?: undefined;
+    };
+} | {
+    ok: boolean;
+    version: string;
+    result: {
+        sessionKey: string;
+        cancelledAt: string;
+        message: string | undefined;
+        childSessionKey?: undefined;
+        runId?: undefined;
+        mode?: undefined;
+        acceptedAt?: undefined;
+        note?: undefined;
+        state?: undefined;
+        checkedAt?: undefined;
+        outputText?: undefined;
+        killedAt?: undefined;
+        backend?: undefined;
+        backendSessionId?: undefined;
+        agentSessionId?: undefined;
+        closedAt?: undefined;
+    };
+} | {
+    ok: boolean;
+    version: string;
+    result: {
+        sessionKey: string;
+        closedAt: string;
+        message: any;
+        childSessionKey?: undefined;
+        runId?: undefined;
+        mode?: undefined;
+        acceptedAt?: undefined;
+        note?: undefined;
+        state?: undefined;
+        checkedAt?: undefined;
+        outputText?: undefined;
+        killedAt?: undefined;
+        backend?: undefined;
+        backendSessionId?: undefined;
+        agentSessionId?: undefined;
+        cancelledAt?: undefined;
+    };
+}>;
+export declare function main(argv: string[]): Promise<number>;
+export {};