@mclawnet/swarm 0.1.0

package/dist/swarm-coordinator.js

@@ -0,0 +1,637 @@
+import { loadRole, buildRolePrompt } from "./roles/role-loader.js";
+import { LocalMessageRouter } from "./message-router.js";
+import { parseSwarmActions, parsePlanFromText } from "./action-parser.js";
+import { buildMemorySection } from "@mclawnet/memory";
+import { saveSwarmSnapshot, deleteSwarmSnapshot, appendMessageLog } from "./persistence.js";
+import { createLogger } from "@mclawnet/logger";
+const log = createLogger({ module: "swarm" });
+const QUEEN_CHECK_INTERVAL_MS = 300_000; // 5min when workers active
+const QUEEN_CHECK_IDLE_INTERVAL_MS = 300_000; // 5min when all roles idle
+/**
+ * SwarmCoordinator — orchestrates multi-role Claude CLI swarms.
+ *
+ * Composes (not replaces) SessionAdapter. Each role instance is a separate
+ * session in SessionAdapter. Communication between roles goes through
+ * MessageRouter (currently LocalMessageRouter using stdin/stdout).
+ */
+export class SwarmCoordinator {
+    sessionAdapter;
+    hub;
+    swarms = new Map();
+    constructor(sessionAdapter, hub) {
+        this.sessionAdapter = sessionAdapter;
+        this.hub = hub;
+    }
+    // ── Public API ──────────────────────────────────────────────────────
+    /** Create a new swarm and spawn initial roles. */
+    async create(swarmSessionId, options) {
+        if (this.swarms.has(swarmSessionId)) {
+            throw new Error(`Swarm ${swarmSessionId} already exists`);
+        }
+        const router = new LocalMessageRouter(this.sessionAdapter);
+        const swarm = {
+            id: swarmSessionId,
+            hubSessionId: swarmSessionId,
+            workDir: options.workDir,
+            roles: new Map(),
+            plan: null,
+            nextInstanceSeq: new Map(),
+            idleCheckCount: 0,
+            maxIdleChecks: 10,
+            isPaused: false,
+            status: "creating",
+            planStatus: "none",
+        };
+        // Attach the router to the swarm for internal access
+        swarm._router = router;
+        this.swarms.set(swarmSessionId, swarm);
+        // Spawn all initial roles
+        for (const roleSpec of options.roles) {
+            const count = roleSpec.count ?? 1;
+            for (let i = 0; i < count; i++) {
+                await this.spawnRole(swarmSessionId, roleSpec.roleName, router, undefined, roleSpec.customPrompt, roleSpec.customDefinition);
+            }
+        }
+        // Start Queen periodic check
+        this.startQueenCheck(swarmSessionId);
+        // Mark swarm as running after all roles spawned
+        swarm.status = "running";
+        // If there's an initial task, send it to Queen
+        if (options.task) {
+            const queen = this.findQueen(swarm);
+            if (queen) {
+                router.send(queen.instanceId, {
+                    from: "user",
+                    type: "task",
+                    data: options.task,
+                    timestamp: Date.now(),
+                });
+            }
+        }
+        log.info({ swarmId: swarmSessionId, roleCount: swarm.roles.size }, "swarm created");
+        // Persistence: save initial snapshot
+        saveSwarmSnapshot(swarm);
+    }
+    /** Handle user message directed at the swarm. */
+    async handleUserMessage(swarmSessionId, content, targetInstance) {
+        const swarm = this.swarms.get(swarmSessionId);
+        if (!swarm) {
+            log.error({ swarmId: swarmSessionId }, "handleUserMessage: swarm not found");
+            return;
+        }
+        const router = swarm._router;
+        const message = {
+            from: "user",
+            type: "task",
+            data: content,
+            timestamp: Date.now(),
+        };
+        // Auto-resume if paused
+        if (swarm.status === "paused") {
+            swarm.status = "running";
+            swarm.isPaused = false;
+            swarm.idleCheckCount = 0;
+            this.startQueenCheck(swarmSessionId);
+            log.info({ swarmId: swarmSessionId }, "swarm resumed");
+        }
+        if (targetInstance) {
+            // Directed at a specific instance
+            router.send(targetInstance, message);
+            appendMessageLog(swarmSessionId, { type: "user_message", from: "user", to: targetInstance, data: content, timestamp: Date.now() });
+        }
+        else {
+            // Default: send to Queen
+            const queen = this.findQueen(swarm);
+            if (queen) {
+                router.send(queen.instanceId, message);
+            }
+            else {
+                // No queen — broadcast to all
+                router.broadcast(message);
+            }
+        }
+    }
+    /**
+     * Handle output from a role's Claude CLI process.
+     * Called by the onOutput callback wired in start.ts.
+     *
+     * Returns true if the sessionId belongs to a swarm role.
+     */
+    handleRoleOutput(roleSessionId, data) {
+        const { swarm, role } = this.findByRoleSessionId(roleSessionId);
+        if (!swarm || !role)
+            return false;
+        const router = swarm._router;
+        // Extract text content from the streaming event
+        const text = extractTextFromEvent(data);
+        // Parse swarm action blocks
+        if (text) {
+            // Log when assistant event contains meaningful text (not every streaming chunk)
+            if (text.includes("```swarm")) {
+                log.info({ instanceId: role.instanceId, textLen: text.length }, "assistant output contains swarm block");
+            }
+            // For queen: parse plan BEFORE executing actions, so review can gate task assignment
+            if (role.definition.type === "queen") {
+                const hasPlanKeyword = text.includes('"plan"');
+                if (hasPlanKeyword) {
+                    log.info({ instanceId: role.instanceId, textLen: text.length, hasPlanKeyword }, "queen output contains plan keyword, attempting parse");
+                }
+                const plan = parsePlanFromText(text);
+                if (plan) {
+                    swarm.plan = plan;
+                    swarm.planStatus = "draft";
+                    saveSwarmSnapshot(swarm);
+                    this.sendStatusUpdate(swarm);
+                    log.info({ swarmId: swarm.id, instanceId: role.instanceId }, "plan updated (draft)");
+                    this.requestPlanReview(swarm, plan);
+                }
+                else if (hasPlanKeyword) {
+                    log.warn({ instanceId: role.instanceId, textSnippet: text.substring(0, 500) }, "queen output has plan keyword but parsePlanFromText returned null");
+                }
+            }
+            const { actions } = parseSwarmActions(text);
+            if (text.includes("```swarm") && actions.length === 0) {
+                log.warn({ instanceId: role.instanceId, textSnippet: text.substring(0, 500) }, "swarm block found but parse failed");
+            }
+            for (const action of actions) {
+                this.executeAction(swarm, role, router, action);
+            }
+        }
+        // Forward full output to Hub for UI display + DB storage
+        this.hub.send({
+            type: "swarm.output",
+            sessionId: swarm.hubSessionId,
+            instanceId: role.instanceId,
+            roleName: role.roleName,
+            data,
+        });
+        return true;
+    }
+    /**
+     * Handle turn completion from a role's Claude CLI process.
+     * Returns true if the sessionId belongs to a swarm role.
+     */
+    handleRoleTurnComplete(roleSessionId, info) {
+        const { swarm, role } = this.findByRoleSessionId(roleSessionId);
+        if (!swarm || !role)
+            return false;
+        // Update role status
+        role.status = "idle";
+        // Forward to Hub
+        this.hub.send({
+            type: "swarm.turn_complete",
+            sessionId: swarm.hubSessionId,
+            instanceId: role.instanceId,
+            roleName: role.roleName,
+            cost: info.cost,
+            duration: info.duration,
+        });
+        return true;
+    }
+    /** Spawn a new role instance in a swarm. */
+    async spawnRole(swarmId, roleName, router, taskPrompt, customPrompt, customDefinition) {
+        const swarm = this.swarms.get(swarmId);
+        if (!swarm)
+            throw new Error(`Swarm ${swarmId} not found`);
+        // Use custom definition directly when provided; otherwise load from disk
+        let definition;
+        if (customDefinition) {
+            definition = {
+                name: customDefinition.name,
+                shortName: customDefinition.shortName,
+                type: "worker",
+                description: customDefinition.description,
+                capabilities: customDefinition.capabilities,
+                color: customDefinition.color,
+                promptBody: customDefinition.promptBody,
+            };
+        }
+        else {
+            definition = loadRole(roleName);
+        }
+        // If a custom prompt was provided, override the definition's promptBody
+        if (customPrompt) {
+            definition.promptBody = customPrompt;
+        }
+        const seq = swarm.nextInstanceSeq.get(roleName) ?? 0;
+        swarm.nextInstanceSeq.set(roleName, seq + 1);
+        const instanceId = `${definition.shortName}-${seq}`;
+        const roleSessionId = `${swarmId}::${instanceId}`;
+        const roleInstance = {
+            instanceId,
+            roleName,
+            definition,
+            roleSessionId,
+            status: "spawning",
+            currentTask: taskPrompt,
+        };
+        swarm.roles.set(instanceId, roleInstance);
+        // Build role list for prompt
+        const roleList = this.buildRoleListString(swarm);
+        const systemPrompt = buildRolePrompt(definition, instanceId, roleList);
+        const memorySection = buildMemorySection(swarm.workDir, roleName);
+        const fullPrompt = memorySection ? `${memorySection}\n\n${systemPrompt}` : systemPrompt;
+        // Spawn Claude CLI process via SessionAdapter
+        await this.sessionAdapter.createSession({
+            sessionId: roleSessionId,
+            workDir: swarm.workDir,
+            systemPrompt: fullPrompt,
+        });
+        roleInstance.status = "active";
+        // Persistence: save snapshot after role spawned
+        saveSwarmSnapshot(swarm);
+        // Register in router
+        const r = router ?? swarm._router;
+        r.register(instanceId, { kind: "local", roleSessionId });
+        // Send swarm status update to Hub
+        this.sendStatusUpdate(swarm);
+        log.info({ swarmId, instanceId, roleName }, "role spawned");
+        return roleInstance;
+    }
+    /** Stop a role instance. */
+    async stopRole(swarmId, instanceId) {
+        const swarm = this.swarms.get(swarmId);
+        if (!swarm)
+            return;
+        const role = swarm.roles.get(instanceId);
+        if (!role)
+            return;
+        role.status = "stopped";
+        const router = swarm._router;
+        router.unregister(instanceId);
+        await this.sessionAdapter.closeSession(role.roleSessionId);
+        swarm.roles.delete(instanceId);
+        // Persistence: save snapshot after role stopped
+        saveSwarmSnapshot(swarm);
+        this.sendStatusUpdate(swarm);
+        log.info({ swarmId, instanceId }, "role stopped");
+    }
+    /** Destroy an entire swarm. */
+    async destroy(swarmId) {
+        const swarm = this.swarms.get(swarmId);
+        if (!swarm)
+            return;
+        if (swarm.checkTimer)
+            clearTimeout(swarm.checkTimer);
+        for (const role of swarm.roles.values()) {
+            await this.sessionAdapter.closeSession(role.roleSessionId).catch(() => { });
+        }
+        this.swarms.delete(swarmId);
+        // Persistence: remove snapshot
+        deleteSwarmSnapshot(swarmId);
+        log.info({ swarmId }, "swarm destroyed");
+    }
+    /** Check if a session ID belongs to any swarm. */
+    isSwarmSession(sessionId) {
+        return sessionId.includes("::");
+    }
+    /** Check if a hub session ID is a swarm. */
+    hasSwarm(swarmSessionId) {
+        return this.swarms.has(swarmSessionId);
+    }
+    /** Get a swarm instance by hub session ID. */
+    getSwarm(swarmSessionId) {
+        return this.swarms.get(swarmSessionId);
+    }
+    /** Mark a swarm as completed. Releases all resources — closes sessions, deletes snapshot, removes from memory. */
+    async complete(swarmId) {
+        const swarm = this.swarms.get(swarmId);
+        if (!swarm)
+            return;
+        swarm.status = "completed";
+        this.sendStatusUpdate(swarm);
+        // Release all resources
+        if (swarm.checkTimer) {
+            clearTimeout(swarm.checkTimer);
+            swarm.checkTimer = undefined;
+        }
+        for (const role of swarm.roles.values()) {
+            await this.sessionAdapter.closeSession(role.roleSessionId).catch(() => { });
+        }
+        this.swarms.delete(swarmId);
+        deleteSwarmSnapshot(swarmId);
+        log.info({ swarmId }, "swarm completed — all resources released");
+    }
+    /** Mark a swarm as failed. Releases all resources — closes sessions, deletes snapshot, removes from memory. */
+    async fail(swarmId) {
+        const swarm = this.swarms.get(swarmId);
+        if (!swarm)
+            return;
+        swarm.status = "failed";
+        this.sendStatusUpdate(swarm);
+        // Release all resources
+        if (swarm.checkTimer) {
+            clearTimeout(swarm.checkTimer);
+            swarm.checkTimer = undefined;
+        }
+        for (const role of swarm.roles.values()) {
+            await this.sessionAdapter.closeSession(role.roleSessionId).catch(() => { });
+        }
+        this.swarms.delete(swarmId);
+        deleteSwarmSnapshot(swarmId);
+        log.info({ swarmId }, "swarm failed — all resources released");
+    }
+    // ── Private helpers ─────────────────────────────────────────────────
+    findQueen(swarm) {
+        for (const role of swarm.roles.values()) {
+            if (role.definition.type === "queen" && role.status !== "stopped")
+                return role;
+        }
+        return undefined;
+    }
+    findReviewer(swarm) {
+        for (const role of swarm.roles.values()) {
+            if (role.roleName === "reviewer" && role.status !== "stopped")
+                return role;
+        }
+        return undefined;
+    }
+    /** Send plan to reviewer for review. Auto-approves if no reviewer available. */
+    requestPlanReview(swarm, plan) {
+        const reviewer = this.findReviewer(swarm);
+        if (!reviewer) {
+            // No reviewer — auto-approve
+            swarm.planStatus = "approved";
+            saveSwarmSnapshot(swarm);
+            this.sendStatusUpdate(swarm);
+            log.info({ swarmId: swarm.id }, "plan auto-approved (no reviewer)");
+            return;
+        }
+        swarm.planStatus = "reviewing";
+        saveSwarmSnapshot(swarm);
+        this.sendStatusUpdate(swarm);
+        const router = swarm._router;
+        const planJson = JSON.stringify(plan, null, 2);
+        router.send(reviewer.instanceId, {
+            from: "system",
+            type: "plan_review",
+            data: `[系统] 请审查以下执行计划，评估其可行性和风险。
+
+审查要点：
+1. 任务拆解是否合理？是否有遗漏的步骤？
+2. 依赖关系是否正确？是否可以更多并行？
+3. 角色分配是否合适？
+4. 是否存在明显的风险或失败点？
+
+计划内容：
+\`\`\`json
+${planJson}
+\`\`\`
+
+审查完成后，请用 report action 回复（taskId="plan_review"）：
+- 如果批准：status="completed"，output 中包含 "approved" 和你的审查意见
+- 如果拒绝：status="failed"，output 中说明拒绝原因和改进建议`,
+            taskId: "plan_review",
+            timestamp: Date.now(),
+        });
+        log.info({ swarmId: swarm.id, reviewer: reviewer.instanceId }, "plan sent to reviewer");
+    }
+    /** Handle plan review result from reviewer. */
+    handlePlanReviewResult(swarm, fromRole, action) {
+        const router = swarm._router;
+        const queen = this.findQueen(swarm);
+        if (action.status === "completed" && action.output?.toLowerCase().includes("approved")) {
+            swarm.planStatus = "approved";
+            saveSwarmSnapshot(swarm);
+            this.sendStatusUpdate(swarm);
+            log.info({ swarmId: swarm.id, reviewer: fromRole.instanceId }, "plan approved by reviewer");
+            // Notify queen to start task assignment
+            if (queen) {
+                router.send(queen.instanceId, {
+                    from: "system",
+                    type: "plan_approved",
+                    data: `[系统] 你的执行计划已通过审查。审查意见：${action.output}\n\n请开始按计划分配任务。`,
+                    timestamp: Date.now(),
+                });
+            }
+        }
+        else {
+            swarm.planStatus = "rejected";
+            saveSwarmSnapshot(swarm);
+            this.sendStatusUpdate(swarm);
+            log.info({ swarmId: swarm.id, reviewer: fromRole.instanceId }, "plan rejected by reviewer");
+            // Notify queen to revise the plan
+            if (queen) {
+                router.send(queen.instanceId, {
+                    from: "system",
+                    type: "plan_rejected",
+                    data: `[系统] 你的执行计划未通过审查，请根据反馈修改。\n\n审查反馈：${action.output ?? "未提供具体原因"}`,
+                    timestamp: Date.now(),
+                });
+            }
+        }
+    }
+    findByRoleSessionId(roleSessionId) {
+        // roleSessionId format: "{swarmId}::{instanceId}"
+        const sep = roleSessionId.indexOf("::");
+        if (sep === -1)
+            return {};
+        const swarmId = roleSessionId.slice(0, sep);
+        const instanceId = roleSessionId.slice(sep + 2);
+        const swarm = this.swarms.get(swarmId);
+        if (!swarm)
+            return {};
+        const role = swarm.roles.get(instanceId);
+        return { swarm, role };
+    }
+    executeAction(swarm, fromRole, router, action) {
+        log.info({ swarmId: swarm.id, from: fromRole.instanceId, action: action.action }, "executing action");
+        switch (action.action) {
+            case "send": {
+                // Gate: queen cannot send task to workers while plan is under review
+                if (fromRole.definition.type === "queen" &&
+                    action.type === "task" &&
+                    (swarm.planStatus === "draft" || swarm.planStatus === "reviewing")) {
+                    log.info({ swarmId: swarm.id, to: action.to, planStatus: swarm.planStatus }, "queen task send blocked: plan under review");
+                    const router2 = swarm._router;
+                    router2.send(fromRole.instanceId, {
+                        from: "system",
+                        type: "system",
+                        data: `[系统] 任务分配被拦截。当前计划状态为「${swarm.planStatus}」，请等待审查完成后再分配任务。`,
+                        timestamp: Date.now(),
+                    });
+                    break;
+                }
+                const msg = {
+                    from: fromRole.instanceId,
+                    type: action.type,
+                    data: action.data,
+                    taskId: action.taskId,
+                    timestamp: Date.now(),
+                };
+                router.send(action.to, msg);
+                appendMessageLog(swarm.id, { type: "action", action: "send", from: fromRole.instanceId, to: action.to, data: action.data, timestamp: Date.now() });
+                break;
+            }
+            case "report": {
+                // Update role status
+                if (action.status === "completed" || action.status === "failed") {
+                    fromRole.currentTask = undefined;
+                }
+                // Check for plan review result
+                if (action.taskId === "plan_review") {
+                    this.handlePlanReviewResult(swarm, fromRole, action);
+                    break;
+                }
+                // Notify queen about the report (so she can coordinate next steps)
+                const queen = this.findQueen(swarm);
+                if (queen && queen.instanceId !== fromRole.instanceId) {
+                    const reportMsg = {
+                        from: fromRole.instanceId,
+                        type: "report",
+                        data: `[${action.status}] ${action.output ?? "任务状态更新"}`,
+                        taskId: action.taskId,
+                        timestamp: Date.now(),
+                    };
+                    router.send(queen.instanceId, reportMsg);
+                    appendMessageLog(swarm.id, { type: "action", action: "report", from: fromRole.instanceId, to: queen.instanceId, status: action.status, data: action.output, timestamp: Date.now() });
+                    log.info({ swarmId: swarm.id, from: fromRole.instanceId, status: action.status, taskId: action.taskId }, "report forwarded to queen");
+                }
+                // Queen reporting completed/failed = swarm lifecycle transition
+                if (fromRole.definition.type === "queen") {
+                    if (action.status === "completed") {
+                        this.complete(swarm.id).catch((err) => {
+                            log.error({ err, swarmId: swarm.id }, "failed to complete swarm");
+                        });
+                    }
+                    else if (action.status === "failed") {
+                        this.fail(swarm.id).catch((err) => {
+                            log.error({ err, swarmId: swarm.id }, "failed to mark swarm as failed");
+                        });
+                    }
+                }
+                // Forward status to Hub
+                this.sendStatusUpdate(swarm);
+                break;
+            }
+            case "broadcast": {
+                const msg = {
+                    from: fromRole.instanceId,
+                    type: "broadcast",
+                    data: action.data,
+                    timestamp: Date.now(),
+                };
+                router.broadcast(msg, fromRole.instanceId);
+                break;
+            }
+            case "spawn_role": {
+                // Only queen can spawn roles
+                if (fromRole.definition.type === "queen") {
+                    this.spawnRole(swarm.id, action.roleName, router, action.task).catch((err) => {
+                        log.error({ err, roleName: action.roleName }, "failed to spawn role");
+                    });
+                }
+                break;
+            }
+            case "stop_role": {
+                // Only queen can stop roles
+                if (fromRole.definition.type === "queen") {
+                    this.stopRole(swarm.id, action.instanceId).catch((err) => {
+                        log.error({ err, instanceId: action.instanceId }, "failed to stop role");
+                    });
+                }
+                break;
+            }
+        }
+    }
+    startQueenCheck(swarmId) {
+        const swarm = this.swarms.get(swarmId);
+        if (!swarm)
+            return;
+        const tick = () => {
+            // Stop ticking if swarm is no longer active
+            if (swarm.status === "completed" || swarm.status === "failed" || swarm.status === "paused") {
+                return;
+            }
+            const queen = this.findQueen(swarm);
+            if (!queen || queen.status === "stopped")
+                return;
+            const router = swarm._router;
+            // Adaptive interval: slow down when only queen is left or all roles idle
+            const activeWorkers = [...swarm.roles.values()].filter((r) => r.definition.type !== "queen" && r.status === "active");
+            // Track consecutive idle checks
+            if (activeWorkers.length > 0) {
+                swarm.idleCheckCount = 0;
+            }
+            else {
+                swarm.idleCheckCount++;
+            }
+            // Auto-pause if idle too long
+            if (swarm.idleCheckCount >= swarm.maxIdleChecks) {
+                swarm.isPaused = true;
+                swarm.status = "paused";
+                saveSwarmSnapshot(swarm);
+                this.sendStatusUpdate(swarm);
+                router.send(queen.instanceId, {
+                    from: "system",
+                    type: "system",
+                    data: `[系统] 蜂群已自动暂停。连续${swarm.maxIdleChecks}次巡查发现所有成员空闲，已暂停任务释放资源。用户可以resume恢复。`,
+                    timestamp: Date.now(),
+                });
+                log.info({ swarmId, idleChecks: swarm.maxIdleChecks }, "swarm auto-paused");
+                return; // Don't schedule next tick
+            }
+            const statusJson = JSON.stringify(this.buildStatusPayload(swarm), null, 2);
+            router.send(queen.instanceId, {
+                from: "system",
+                type: "system",
+                data: `[系统] 定时巡查触发。请查看当前蜂群状态，判断是否需要采取行动。\n\n当前蜂群成员及状态：\n${statusJson}`,
+                timestamp: Date.now(),
+            });
+            const nextInterval = activeWorkers.length > 0
+                ? QUEEN_CHECK_INTERVAL_MS
+                : QUEEN_CHECK_IDLE_INTERVAL_MS;
+            swarm.checkTimer = setTimeout(tick, nextInterval);
+        };
+        swarm.checkTimer = setTimeout(tick, QUEEN_CHECK_INTERVAL_MS);
+    }
+    buildRoleListString(swarm) {
+        const lines = [];
+        for (const role of swarm.roles.values()) {
+            lines.push(`- ${role.instanceId} (${role.roleName}, ${role.definition.type}, status: ${role.status})`);
+        }
+        return lines.join("\n") || "(尚无成员)";
+    }
+    buildStatusPayload(swarm) {
+        return {
+            swarmStatus: swarm.status,
+            planStatus: swarm.planStatus,
+            roles: [...swarm.roles.values()].map((r) => ({
+                instanceId: r.instanceId,
+                roleName: r.roleName,
+                type: r.definition.type,
+                status: r.status,
+                currentTask: r.currentTask,
+                color: r.definition.color,
+            })),
+            plan: swarm.plan,
+        };
+    }
+    sendStatusUpdate(swarm) {
+        const payload = this.buildStatusPayload(swarm);
+        this.hub.send({
+            type: "swarm.status",
+            sessionId: swarm.hubSessionId,
+            swarmStatus: payload.swarmStatus,
+            planStatus: payload.planStatus,
+            roles: payload.roles,
+            plan: payload.plan,
+        });
+    }
+}
+// ── Helpers ──────────────────────────────────────────────────────────
+/** Extract text content from a Claude stream-json event. */
+function extractTextFromEvent(data) {
+    if (!data || typeof data !== "object")
+        return null;
+    const event = data;
+    if (event.type !== "assistant" || !event.message?.content)
+        return null;
+    let text = "";
+    for (const block of event.message.content) {
+        if (block.type === "text")
+            text += block.text;
+    }
+    return text || null;
+}
+//# sourceMappingURL=swarm-coordinator.js.map