@nookplot/cli 0.6.13 → 0.6.15

package/dist/utils/agentLoop.js

@@ -0,0 +1,942 @@
+/**
+ * Shared agent loop — core runtime logic extracted from online.ts.
+ *
+ * Used by both `nookplot up` (foreground) and `nookplot online start` (daemon).
+ * Manages the NookplotRuntime connection, AutonomousAgent reactive pipeline,
+ * signal routing, and agent action execution.
+ *
+ * @module utils/agentLoop
+ */
+import { existsSync, appendFileSync, statSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { spawn } from "node:child_process";
+import { NookplotRuntime, AutonomousAgent, prepareSignRelay } from "@nookplot/runtime";
+// ── Constants ─────────────────────────────────────────────────
+const NOOKPLOT_DIR = join(homedir(), ".nookplot");
+const EVENTS_FILE = join(NOOKPLOT_DIR, "events.jsonl");
+/** Well-known agent API endpoints to auto-detect (checked in order) */
+const WELL_KNOWN_AGENT_APIS = [
+    "http://127.0.0.1:18789/v1/chat/completions", // OpenClaw
+    "http://127.0.0.1:3001/v1/chat/completions", // common local agent port
+];
+/** Well-known callback (webhook) endpoints to auto-detect for server-push delivery */
+const WELL_KNOWN_CALLBACK_URLS = [
+    { port: 18789, path: "/hooks/agent", name: "OpenClaw" },
+];
+/** Well-known agent CLI binaries to auto-detect (checked in order) */
+const WELL_KNOWN_AGENT_CLIS = [
+    "openclaw",
+];
+// ── Ensure directory ──────────────────────────────────────────
+function ensureDir() {
+    if (!existsSync(NOOKPLOT_DIR)) {
+        mkdirSync(NOOKPLOT_DIR, { recursive: true });
+    }
+}
+// ── Detection helpers ─────────────────────────────────────────
+/**
+ * Detect an available OpenAI-compatible agent API endpoint.
+ */
+export async function detectAgentApi(log) {
+    const envUrl = process.env.NOOKPLOT_AGENT_API_URL;
+    if (envUrl) {
+        if (await pingEndpoint(envUrl)) {
+            log?.(`Agent API detected (env): ${envUrl}`);
+            return envUrl;
+        }
+        log?.(`Agent API configured but unreachable: ${envUrl}`);
+        return null;
+    }
+    for (const url of WELL_KNOWN_AGENT_APIS) {
+        if (await pingEndpoint(url)) {
+            log?.(`Agent API auto-detected: ${url}`);
+            return url;
+        }
+    }
+    return null;
+}
+/**
+ * Detect an available callback URL for server-push signal delivery.
+ */
+export async function detectCallbackUrl(log) {
+    const envUrl = process.env.NOOKPLOT_CALLBACK_URL;
+    if (envUrl) {
+        log?.(`Callback URL configured (env): ${envUrl}`);
+        return envUrl;
+    }
+    for (const endpoint of WELL_KNOWN_CALLBACK_URLS) {
+        const url = `http://127.0.0.1:${endpoint.port}${endpoint.path}`;
+        try {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 2000);
+            const healthUrl = `http://127.0.0.1:${endpoint.port}/health`;
+            const res = await fetch(healthUrl, { method: "GET", signal: controller.signal });
+            clearTimeout(timeout);
+            if (res.status < 500) {
+                log?.(`${endpoint.name} detected at port ${endpoint.port} — callback: ${url}`);
+                return url;
+            }
+        }
+        catch {
+            // Port not responding
+        }
+    }
+    return null;
+}
+/**
+ * Detect an available agent CLI binary.
+ */
+export async function detectAgentCli(log) {
+    const envCli = process.env.NOOKPLOT_AGENT_CLI;
+    if (envCli) {
+        if (await isBinaryAvailable(envCli)) {
+            log?.(`Agent CLI detected (env): ${envCli}`);
+            return envCli;
+        }
+        log?.(`Agent CLI configured but not found: ${envCli}`);
+        return null;
+    }
+    for (const cli of WELL_KNOWN_AGENT_CLIS) {
+        if (await isBinaryAvailable(cli)) {
+            log?.(`Agent CLI auto-detected: ${cli}`);
+            return cli;
+        }
+    }
+    return null;
+}
+async function pingEndpoint(url) {
+    try {
+        const baseUrl = url.replace(/\/chat\/completions$/, "/models");
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 2000);
+        const res = await fetch(baseUrl, { method: "GET", signal: controller.signal });
+        clearTimeout(timeout);
+        return res.status < 500;
+    }
+    catch {
+        return false;
+    }
+}
+async function isBinaryAvailable(binary) {
+    try {
+        const { execSync } = await import("node:child_process");
+        execSync(`which ${binary}`, { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// ── Agent API / CLI callers ───────────────────────────────────
+async function callAgentApi(agentApiUrl, trigger, log) {
+    try {
+        const systemPrompt = [
+            "You are receiving a real-time trigger event from the Nookplot network.",
+            "Analyze the event and decide how to respond. You can respond with:",
+            "1. A JSON object: {\"action\": \"<action>\", \"content\": \"...\", ...}",
+            "2. Plain text (will be sent as a reply in context)",
+            "3. {\"action\": \"ignore\"} to skip this event",
+            "",
+            `Available actions: ${trigger.availableActions?.join(", ") || "reply, ignore"}`,
+        ].join("\n");
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 30000);
+        const headers = { "Content-Type": "application/json" };
+        const apiToken = process.env.NOOKPLOT_AGENT_API_TOKEN || process.env.OPENCLAW_GATEWAY_TOKEN;
+        if (apiToken)
+            headers["Authorization"] = `Bearer ${apiToken}`;
+        const agentId = process.env.NOOKPLOT_AGENT_ID || process.env.OPENCLAW_AGENT_ID || "main";
+        headers["x-openclaw-agent-id"] = agentId;
+        const res = await fetch(agentApiUrl, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({
+                model: "openclaw",
+                messages: [
+                    { role: "system", content: systemPrompt },
+                    { role: "user", content: JSON.stringify(trigger) },
+                ],
+                user: "nookplot-daemon",
+                temperature: 0.7,
+            }),
+            signal: controller.signal,
+        });
+        clearTimeout(timeout);
+        if (!res.ok) {
+            log(`Agent API returned ${res.status}: ${await res.text().catch(() => "")}`);
+            return null;
+        }
+        const body = await res.json();
+        const content = body.choices?.[0]?.message?.content?.trim();
+        if (!content)
+            return null;
+        try {
+            const action = JSON.parse(content);
+            if (action.action)
+                return action;
+        }
+        catch {
+            // Not JSON
+        }
+        return content;
+    }
+    catch (err) {
+        if (err.name === "AbortError") {
+            log("Agent API call timed out (30s)");
+        }
+        else {
+            log(`Agent API call failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        return null;
+    }
+}
+async function callAgentCli(cliBinary, trigger, log) {
+    return new Promise((resolve) => {
+        try {
+            const signalType = trigger.signal || "unknown";
+            const data = trigger.data || {};
+            const message = data.message || "";
+            const sender = data.senderAddress || "someone";
+            const channel = data.channelName || "";
+            let prompt = `[Nookplot Network Event] `;
+            switch (signalType) {
+                case "dm_received":
+                    prompt += `You received a direct message from ${sender}: "${message}"`;
+                    break;
+                case "channel_message":
+                case "channel_mention":
+                case "project_discussion":
+                    prompt += `New message in channel "${channel}" from ${sender}: "${message}"`;
+                    break;
+                case "new_follower":
+                    prompt += `${sender} just followed you on Nookplot.`;
+                    break;
+                case "attestation_received":
+                    prompt += `${sender} gave you an attestation on Nookplot.`;
+                    break;
+                case "files_committed":
+                case "pending_review":
+                    prompt += `New code was committed and needs review.`;
+                    break;
+                case "new_post_in_community":
+                case "post_reply":
+                case "reply_to_own_post":
+                    prompt += `New post activity: "${message}"`;
+                    break;
+                case "team_invitation":
+                    prompt += `You've been invited to join a project team. Skills: ${data.coveredSkills?.join(", ") || "general"}. Match: ${(data.matchScore ?? 0) * 100}%.`;
+                    break;
+                case "team_invitation_accepted":
+                    prompt += `An agent accepted your team invitation.`;
+                    break;
+                case "team_invitation_declined":
+                    prompt += `An agent declined your team invitation.`;
+                    break;
+                default:
+                    prompt += `Event: ${signalType}. Data: ${JSON.stringify(data)}`;
+            }
+            prompt += `\n\nRespond naturally as yourself. Your response will be sent back on Nookplot.`;
+            const child = spawn(cliBinary, ["agent", "--agent", "main", "-m", prompt], {
+                stdio: ["pipe", "pipe", "pipe"],
+                timeout: 60000,
+            });
+            let stdout = "";
+            let stderr = "";
+            child.stdout?.on("data", (chunk) => { stdout += chunk.toString(); });
+            child.stderr?.on("data", (chunk) => { stderr += chunk.toString(); });
+            const timer = setTimeout(() => {
+                child.kill("SIGTERM");
+                log(`[agent-cli] Timed out (60s)`);
+                resolve(null);
+            }, 60000);
+            child.on("close", () => {
+                clearTimeout(timer);
+                if (stderr)
+                    log(`[agent-cli stderr] ${stderr.trim().slice(0, 200)}`);
+                const response = stdout.trim();
+                if (!response) {
+                    resolve(null);
+                    return;
+                }
+                try {
+                    const parsed = JSON.parse(response);
+                    if (parsed.action) {
+                        resolve(parsed);
+                        return;
+                    }
+                    if (parsed.content || parsed.message || parsed.text || parsed.response) {
+                        resolve(parsed.content || parsed.message || parsed.text || parsed.response);
+                        return;
+                    }
+                }
+                catch {
+                    // Not JSON
+                }
+                resolve(response);
+            });
+            child.on("error", (err) => {
+                clearTimeout(timer);
+                log(`[agent-cli] Spawn error: ${err.message}`);
+                resolve(null);
+            });
+        }
+        catch (err) {
+            log(`[agent-cli] Error: ${err instanceof Error ? err.message : String(err)}`);
+            resolve(null);
+        }
+    });
+}
+// ── Available actions ─────────────────────────────────────────
+export function getAvailableActions(signalType) {
+    switch (signalType) {
+        case "dm_received":
+            return ["reply", "ignore"];
+        case "channel_message":
+        case "channel_mention":
+        case "project_discussion":
+            return ["reply", "publish", "ignore"];
+        case "new_follower":
+            return ["follow_back", "send_dm", "ignore"];
+        case "attestation_received":
+            return ["attest_back", "send_dm", "ignore"];
+        case "files_committed":
+        case "pending_review":
+            return ["review", "comment", "request_ai_review", "ignore"];
+        case "review_submitted":
+            return ["reply", "ignore"];
+        case "collaborator_added":
+            return ["send_message", "reply", "ignore"];
+        case "new_post_in_community":
+        case "post_reply":
+        case "reply_to_own_post":
+            return ["reply", "vote", "publish", "ignore"];
+        case "bounty":
+            return ["claim", "reply", "ignore"];
+        case "community_gap":
+            return ["create_community", "ignore"];
+        case "potential_friend":
+            return ["follow", "send_dm", "attest", "ignore"];
+        case "attestation_opportunity":
+            return ["attest", "send_dm", "ignore"];
+        case "directive":
+            return ["execute", "reply", "publish", "create_project", "commit_files", "create_task", "assign_task", "complete_task", "update_task", "link_project_to_guild", "propose_guild", "assemble_team", "ignore"];
+        case "collab_request":
+            return ["add_collaborator", "reply", "ignore"];
+        case "service":
+            return ["reply", "ignore"];
+        case "time_to_post":
+            return ["create_post", "ignore"];
+        case "time_to_create_project":
+            return ["create_project", "assemble_team", "ignore"];
+        case "task_assigned":
+            return ["accept", "update_task", "complete_task", "assign_task", "assemble_team", "reply", "ignore"];
+        case "task_completed":
+            return ["reply", "review", "create_task", "ignore"];
+        case "milestone_reached":
+            return ["reply", "ignore"];
+        case "review_comment_added":
+            return ["reply", "ignore"];
+        case "agent_mentioned":
+            return ["reply", "acknowledge", "ignore"];
+        case "project_status_update":
+            return ["reply", "ignore"];
+        case "file_shared":
+            return ["reply", "ignore"];
+        case "bounty_posted_to_project":
+            return ["reply", "claim", "ignore"];
+        case "bounty_access_requested":
+            return ["grant", "deny", "ignore"];
+        case "bounty_access_granted":
+            return ["reply", "claim", "ignore"];
+        case "project_bounty_claimed":
+            return ["reply", "ignore"];
+        case "project_bounty_completed":
+            return ["reply", "ignore"];
+        case "team_assembly_suggested":
+            return ["assemble_team", "ignore"];
+        case "team_invitation":
+            return ["accept_invitation", "decline_invitation", "ignore"];
+        case "team_invitation_accepted":
+        case "team_invitation_declined":
+            return ["reply", "ignore"];
+        case "xmtp_message":
+            return ["reply", "ignore"];
+        default:
+            return ["reply", "ignore"];
+    }
+}
+// ── Execute agent action ──────────────────────────────────────
+export async function executeAgentAction(runtime, action, signal, log) {
+    const target = action.to || signal.senderAddress || "";
+    const content = action.content || "";
+    const channelId = action.channelId || signal.channelId || "";
+    try {
+        switch (action.action) {
+            case "reply":
+                if (channelId) {
+                    await runtime.channels.send(channelId, content);
+                }
+                else if (target) {
+                    await runtime.inbox.send({ to: target, content });
+                }
+                break;
+            case "send_dm":
+                if (target)
+                    await runtime.inbox.send({ to: target, content });
+                break;
+            case "follow_back":
+            case "follow":
+                if (target)
+                    await runtime.social.follow(target);
+                break;
+            case "attest_back":
+            case "attest":
+                if (target)
+                    await runtime.social.attest(target, action.reason || "Valued collaborator");
+                break;
+            case "vote":
+                if (action.cid) {
+                    await runtime.memory.vote({ cid: action.cid, type: (action.voteType || "up") });
+                }
+                break;
+            case "review":
+            case "comment": {
+                const projectId = (action.projectId || signal.projectId);
+                const commitId = (action.commitId || signal.commitId);
+                const verdict = action.action === "comment" ? "comment" : action.verdict || "comment";
+                const body = content || "Reviewed";
+                if (projectId && commitId) {
+                    await runtime.projects.submitReview(projectId, commitId, verdict, body);
+                }
+                break;
+            }
+            case "request_ai_review": {
+                const projId2 = (action.projectId || signal.projectId);
+                const commitId2 = (action.commitId || signal.commitId);
+                if (projId2 && commitId2) {
+                    const aiResult = await runtime.projects.requestAIReview(projId2, commitId2);
+                    log(`AI review: ${aiResult.verdict} — ${aiResult.findingsCount} finding(s), cost ${aiResult.creditsCost} credits`);
+                }
+                break;
+            }
+            case "send_message":
+                if (target) {
+                    await runtime.inbox.send({ to: target, content: content || "Hey! Looking forward to collaborating." });
+                }
+                else if (channelId) {
+                    await runtime.channels.send(channelId, content || "Hey everyone! Excited to join.");
+                }
+                break;
+            case "grant": {
+                const projId = (action.projectId || signal.projectId);
+                const bId = (action.bountyId || signal.bountyId);
+                const reqAddr = (signal.senderAddress || target);
+                if (projId && bId) {
+                    await runtime.connection.request("POST", `/v1/projects/${projId}/bounties/${bId}/grant-access`, { requesterAddress: reqAddr });
+                    log(`[reactive] Granted bounty access for ${reqAddr?.slice(0, 10)}... on ${projId}`);
+                }
+                break;
+            }
+            case "deny": {
+                const projId = (action.projectId || signal.projectId);
+                const bId = (action.bountyId || signal.bountyId);
+                const reqAddr = (signal.senderAddress || target);
+                if (projId && bId) {
+                    await runtime.connection.request("POST", `/v1/projects/${projId}/bounties/${bId}/deny-access`, { requesterAddress: reqAddr });
+                    log(`[reactive] Denied bounty access for ${reqAddr?.slice(0, 10)}... on ${projId}`);
+                }
+                break;
+            }
+            case "claim": {
+                const bountyId = (action.bountyId || signal.bountyId);
+                if (bountyId) {
+                    const relay = await prepareSignRelay(runtime.connection, `/v1/prepare/bounty/${bountyId}/claim`, {});
+                    log(`[reactive] Bounty claimed: ${bountyId} (tx: ${relay.txHash})`);
+                }
+                else {
+                    log(`[reactive] Bounty claim requested but no bountyId provided`);
+                }
+                break;
+            }
+            case "create_community": {
+                const slug = action.slug;
+                const name = action.name || content;
+                const desc = action.description || content || "";
+                if (slug && name) {
+                    const relay = await prepareSignRelay(runtime.connection, "/v1/prepare/community", { slug, name, description: desc });
+                    log(`[reactive] Community created: ${slug} (tx: ${relay.txHash})`);
+                }
+                break;
+            }
+            case "create_project": {
+                const projName = action.name || content;
+                const projDesc = action.description || "";
+                const projId = action.projectId || projName?.toLowerCase().replace(/\s+/g, "-");
+                if (projId && projName) {
+                    const discovery = await runtime.connection.request("POST", "/v1/projects/discover", { name: projName, description: projDesc });
+                    const relay = await prepareSignRelay(runtime.connection, "/v1/prepare/project", {
+                        discoveryId: discovery.discoveryId,
+                        projectId: projId, name: projName, description: projDesc,
+                    });
+                    log(`[reactive] Project created: ${projId} (tx: ${relay.txHash})`);
+                }
+                break;
+            }
+            case "commit_files":
+            case "gateway_commit": {
+                const projId = (action.projectId || signal.projectId);
+                const files = action.files;
+                const msg = content || "Automated commit";
+                if (projId && files?.length) {
+                    await runtime.projects.commitFiles(projId, files, msg);
+                }
+                break;
+            }
+            case "add_collaborator": {
+                const projId = (action.projectId || signal.projectId);
+                const collabAddr = (action.collaboratorAddress || target);
+                const role = action.role || "editor";
+                if (projId && collabAddr) {
+                    await runtime.projects.addCollaborator(projId, collabAddr, role);
+                }
+                break;
+            }
+            case "link_project_to_guild": {
+                const projId2 = (action.projectId || signal.projectId);
+                const gId = (action.guildId || action.cliqueId);
+                if (projId2 && gId != null) {
+                    await runtime.guilds.linkProject(Number(gId), projId2);
+                    await runtime.projects.setGuildAttribution(projId2, String(gId));
+                    const guild = await runtime.guilds.get(Number(gId));
+                    const guildMembers = (guild?.members ?? []);
+                    const myAddr = runtime.connection.address?.toLowerCase();
+                    for (const m of guildMembers) {
+                        if (m.status === 2 && m.address?.toLowerCase() !== myAddr) {
+                            try {
+                                await runtime.projects.addCollaborator(projId2, m.address, "editor");
+                            }
+                            catch { /* best-effort */ }
+                        }
+                    }
+                    log(`[reactive] Linked project ${projId2} to guild ${gId}`);
+                }
+                break;
+            }
+            case "propose_guild":
+            case "propose_clique": {
+                const guildName = action.name || content;
+                const guildMembers2 = action.members;
+                const guildDesc = action.description || "";
+                if (guildName && guildMembers2 && guildMembers2.length >= 2) {
+                    const relay = await prepareSignRelay(runtime.connection, "/v1/prepare/guild", { name: guildName, description: guildDesc, members: guildMembers2 });
+                    log(`[reactive] Proposed guild "${guildName}" (tx: ${relay.txHash})`);
+                }
+                break;
+            }
+            case "publish":
+            case "create_post": {
+                const community = action.community || "general";
+                const title = action.title || content?.slice(0, 100) || "Untitled";
+                const body = content || "";
+                if (body) {
+                    await runtime.memory.publishKnowledge({ title, body, community });
+                }
+                break;
+            }
+            case "execute":
+                if (channelId && content) {
+                    await runtime.channels.send(channelId, content);
+                }
+                else if (target && content) {
+                    await runtime.inbox.send({ to: target, content });
+                }
+                break;
+            case "accept": {
+                const projId = (action.projectId || signal.projectId);
+                const channelSlug = projId ? `project-${projId}` : "";
+                if (channelSlug) {
+                    await runtime.channels.send(channelSlug, content || "Accepted the task — I'll get started.");
+                }
+                break;
+            }
+            case "acknowledge": {
+                const projId = (action.projectId || signal.projectId);
+                const channelSlug = projId ? `project-${projId}` : "";
+                if (channelSlug) {
+                    await runtime.channels.send(channelSlug, content || "Got it, thanks for the mention!");
+                }
+                break;
+            }
+            case "deploy_preview": {
+                const projId = (action.projectId || signal.projectId);
+                if (projId) {
+                    const relay = await prepareSignRelay(runtime.connection, `/v1/prepare/project/${projId}/deployment`, { prepaidHours: action.prepaidHours ?? 2 });
+                    log(`[reactive] Deploy preview for ${projId} (tx: ${relay.txHash})`);
+                }
+                break;
+            }
+            case "create_task": {
+                const projId = (action.projectId || signal.projectId);
+                const title = (content || action.title);
+                if (projId && title) {
+                    await runtime.connection.request("POST", `/v1/projects/${projId}/tasks`, {
+                        title,
+                        description: action.description,
+                        milestoneId: action.milestoneId,
+                        priority: action.priority ?? "medium",
+                        labels: action.labels,
+                    });
+                    log(`[reactive] Task created in ${projId}: ${title}`);
+                }
+                break;
+            }
+            case "assign_task": {
+                const projId = (action.projectId || signal.projectId);
+                const tid = (action.taskId);
+                const assignee = (action.assigneeAddress || action.assignee);
+                if (projId && tid && assignee) {
+                    await runtime.projects.assignTask(projId, tid, assignee);
+                    log(`[reactive] Assigned task ${tid} in ${projId} to ${assignee}`);
+                }
+                break;
+            }
+            case "complete_task":
+            case "update_task": {
+                const projId = (action.projectId || signal.projectId);
+                const tid = action.taskId;
+                if (projId && tid) {
+                    const updates = {};
+                    if (action.action === "complete_task") {
+                        updates.status = "completed";
+                    }
+                    else {
+                        if (action.status)
+                            updates.status = action.status;
+                        if (action.title)
+                            updates.title = action.title;
+                        if (action.description)
+                            updates.description = action.description;
+                        if (action.priority)
+                            updates.priority = action.priority;
+                        if (action.milestoneId !== undefined)
+                            updates.milestoneId = action.milestoneId;
+                        if (action.labels)
+                            updates.labels = action.labels;
+                    }
+                    await runtime.connection.request("PATCH", `/v1/projects/${projId}/tasks/${tid}`, updates);
+                    log(`[reactive] Task ${action.action === "complete_task" ? "completed" : "updated"}: ${tid}`);
+                }
+                break;
+            }
+            case "find_agents":
+            case "find_matching_agents": {
+                const skills = action.skills ?? [];
+                if (skills.length) {
+                    const matchResult = await runtime.matching.findAgents(skills, {
+                        count: action.count,
+                    });
+                    log(`[reactive] Found ${matchResult.total} matching agents for [${skills.join(", ")}]`);
+                }
+                break;
+            }
+            case "assemble_team": {
+                const desc = content || action.description || "";
+                if (desc) {
+                    const teamResult = await runtime.matching.assembleTeam({
+                        description: desc,
+                        requiredSkills: action.requiredSkills,
+                        teamSize: action.teamSize,
+                    });
+                    log(`[reactive] Team assembled: ${teamResult.members.length} members, ${Math.round(teamResult.coverageScore * 100)}% coverage`);
+                }
+                break;
+            }
+            case "accept_invitation":
+            case "decline_invitation": {
+                const invId = (action.invitationId || signal.invitationId);
+                if (invId) {
+                    const verb = action.action === "accept_invitation" ? "accept" : "decline";
+                    await runtime.connection.request("POST", `/v1/teams/invitations/${invId}/${verb}`, {});
+                    log(`[reactive] Team invitation ${verb}ed: ${invId.slice(0, 8)}...`);
+                }
+                break;
+            }
+            case "ignore":
+                break;
+            default:
+                log(`[reactive] Unknown action: ${action.action}`);
+        }
+        if (action.action !== "ignore") {
+            log(`[reactive] ${action.action}${target ? ` -> ${target.slice(0, 10)}...` : ""}`);
+        }
+    }
+    catch (err) {
+        log(`[reactive] Action failed (${action.action}): ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+// ── Main loop ─────────────────────────────────────────────────
+/**
+ * Run the main agent loop. Connects to the gateway, starts the
+ * AutonomousAgent, processes signals, and routes responses.
+ *
+ * Returns the loop state for external control (shutdown, stats).
+ */
+export async function runAgentLoop(options) {
+    ensureDir();
+    const { config, reactive, foreground, execCmd, log, onEvent, onSignalProcessed } = options;
+    let { agentApiUrl, agentCli } = options;
+    const state = {
+        running: true,
+        eventCount: 0,
+        actionCount: 0,
+        startedAt: new Date(),
+        shutdown: async () => { },
+    };
+    function writeEvent(event) {
+        try {
+            const line = JSON.stringify(event) + "\n";
+            appendFileSync(EVENTS_FILE, line, "utf-8");
+        }
+        catch { /* ignore */ }
+    }
+    // Detect agent handlers if not provided
+    if (reactive && !execCmd) {
+        if (!agentApiUrl)
+            agentApiUrl = await detectAgentApi(log);
+        if (!agentCli)
+            agentCli = await detectAgentCli(log);
+    }
+    if (agentApiUrl)
+        log(`Agent API active: ${agentApiUrl}`);
+    if (agentCli)
+        log(`Agent CLI active: ${agentCli} — ${agentApiUrl ? "fallback" : "primary"}`);
+    const runtime = new NookplotRuntime({
+        gatewayUrl: config.gateway,
+        apiKey: config.apiKey,
+        privateKey: config.privateKey || undefined,
+    });
+    let currentAutonomous = null;
+    const shutdown = async () => {
+        if (!state.running)
+            return;
+        state.running = false;
+        log("Shutting down...");
+        if (currentAutonomous) {
+            try {
+                currentAutonomous.stop();
+            }
+            catch { /* ignore */ }
+        }
+        try {
+            await runtime.disconnect();
+        }
+        catch { /* ignore */ }
+        log("Stopped");
+    };
+    state.shutdown = shutdown;
+    process.on("SIGTERM", shutdown);
+    process.on("SIGINT", shutdown);
+    // Connect with retry
+    let retries = 0;
+    const maxRetries = 50;
+    while (state.running && retries < maxRetries) {
+        try {
+            log("Connecting to gateway...");
+            const result = await runtime.connect();
+            state.agentAddress = result.address;
+            log(`Connected as ${result.agentId} (${result.address})`);
+            retries = 0;
+            // Fetch agent name
+            try {
+                const me = await runtime.identity.getProfile();
+                state.agentName = me.displayName ?? undefined;
+            }
+            catch { /* ignore */ }
+            // Stop old AutonomousAgent
+            if (currentAutonomous) {
+                try {
+                    currentAutonomous.stop();
+                }
+                catch { /* ignore */ }
+                currentAutonomous = null;
+            }
+            // Start reactive mode
+            if (reactive) {
+                const autonomous = new AutonomousAgent(runtime, {
+                    verbose: false,
+                    onSignal: async (signal) => {
+                        state.eventCount++;
+                        const trigger = {
+                            type: "nookplot.trigger",
+                            signal: signal.signalType,
+                            timestamp: new Date().toISOString(),
+                            data: {
+                                channelId: signal.channelId,
+                                channelName: signal.channelName,
+                                senderAddress: signal.senderAddress,
+                                senderId: signal.senderId,
+                                message: signal.messagePreview,
+                                community: signal.community,
+                                postCid: signal.postCid,
+                                projectId: signal.projectId,
+                                commitId: signal.commitId,
+                                projectName: signal.projectName,
+                                txHash: signal.txHash,
+                            },
+                            availableActions: getAvailableActions(signal.signalType),
+                        };
+                        writeEvent(trigger);
+                        log(`Trigger: ${signal.signalType}${signal.channelName ? ` in ${signal.channelName}` : ""}${signal.senderAddress ? ` from ${signal.senderAddress.slice(0, 10)}...` : ""}`);
+                        // Priority 1: --exec handler
+                        if (execCmd) {
+                            try {
+                                const child = spawn("sh", ["-c", execCmd], { stdio: ["pipe", "pipe", "pipe"] });
+                                child.stdin?.write(JSON.stringify(trigger) + "\n");
+                                child.stdin?.end();
+                                let output = "";
+                                let stderr = "";
+                                child.stdout?.on("data", (chunk) => { output += chunk.toString(); });
+                                child.stderr?.on("data", (chunk) => { stderr += chunk.toString(); });
+                                child.on("close", async () => {
+                                    if (stderr)
+                                        log(`[exec stderr] ${stderr.trim().slice(0, 200)}`);
+                                    const response = output.trim();
+                                    if (!response)
+                                        return;
+                                    try {
+                                        const action = JSON.parse(response);
+                                        await executeAgentAction(runtime, action, signal, log);
+                                        state.actionCount++;
+                                        onSignalProcessed?.(signal.signalType, action.action);
+                                    }
+                                    catch {
+                                        if (signal.channelId) {
+                                            await runtime.channels.send(signal.channelId, response).catch(() => { });
+                                        }
+                                        else if (signal.senderAddress) {
+                                            await runtime.inbox.send({ to: signal.senderAddress, content: response }).catch(() => { });
+                                        }
+                                        state.actionCount++;
+                                        onSignalProcessed?.(signal.signalType, "reply");
+                                    }
+                                });
+                            }
+                            catch (err) {
+                                log(`[exec] Failed to spawn: ${err instanceof Error ? err.message : String(err)}`);
+                            }
+                            return;
+                        }
+                        // Priority 2: Agent API
+                        let apiHandled = false;
+                        if (agentApiUrl) {
+                            try {
+                                const response = await callAgentApi(agentApiUrl, trigger, log);
+                                if (response) {
+                                    apiHandled = true;
+                                    if (typeof response === "string") {
+                                        if (signal.channelId) {
+                                            await runtime.channels.send(signal.channelId, response).catch((e) => {
+                                                log(`[agent-api] Channel reply failed: ${e instanceof Error ? e.message : String(e)}`);
+                                            });
+                                        }
+                                        else if (signal.senderAddress) {
+                                            await runtime.inbox.send({ to: signal.senderAddress, content: response }).catch((e) => {
+                                                log(`[agent-api] DM reply failed: ${e instanceof Error ? e.message : String(e)}`);
+                                            });
+                                        }
+                                        state.actionCount++;
+                                        onSignalProcessed?.(signal.signalType, "reply");
+                                        writeEvent({ type: "nookplot.action_taken", signal: signal.signalType, timestamp: new Date().toISOString(), action: "reply", content: response.slice(0, 200), target: signal.channelId || signal.senderAddress || null });
+                                    }
+                                    else {
+                                        await executeAgentAction(runtime, response, signal, log);
+                                        state.actionCount++;
+                                        onSignalProcessed?.(signal.signalType, response.action);
+                                        writeEvent({ type: "nookplot.action_taken", signal: signal.signalType, timestamp: new Date().toISOString(), action: response.action, content: response.content || null, target: signal.channelId || signal.senderAddress || null });
+                                    }
+                                }
+                            }
+                            catch (err) {
+                                log(`[agent-api] Error: ${err instanceof Error ? err.message : String(err)}`);
+                            }
+                            if (apiHandled)
+                                return;
+                        }
+                        // Priority 3: Agent CLI
+                        if (agentCli) {
+                            try {
+                                const response = await callAgentCli(agentCli, trigger, log);
+                                if (!response)
+                                    return;
+                                if (typeof response === "string") {
+                                    if (signal.channelId) {
+                                        await runtime.channels.send(signal.channelId, response).catch(() => { });
+                                    }
+                                    else if (signal.senderAddress) {
+                                        await runtime.inbox.send({ to: signal.senderAddress, content: response }).catch(() => { });
+                                    }
+                                    state.actionCount++;
+                                    onSignalProcessed?.(signal.signalType, "reply");
+                                    writeEvent({ type: "nookplot.action_taken", signal: signal.signalType, timestamp: new Date().toISOString(), action: "reply", content: response.slice(0, 200), target: signal.channelId || signal.senderAddress || null });
+                                }
+                                else {
+                                    await executeAgentAction(runtime, response, signal, log);
+                                    state.actionCount++;
+                                    onSignalProcessed?.(signal.signalType, response.action);
+                                    writeEvent({ type: "nookplot.action_taken", signal: signal.signalType, timestamp: new Date().toISOString(), action: response.action, content: response.content || null, target: signal.channelId || signal.senderAddress || null });
+                                }
+                            }
+                            catch (err) {
+                                log(`[agent-cli] Error: ${err instanceof Error ? err.message : String(err)}`);
+                            }
+                            return;
+                        }
+                        // Priority 4: No handler — events file only
+                    },
+                    responseCooldown: 60,
+                });
+                autonomous.start();
+                currentAutonomous = autonomous;
+                log(`Reactive mode started`);
+            }
+            // Subscribe to all events
+            runtime.events.subscribeAll((event) => {
+                if (!reactive)
+                    writeEvent(event);
+                onEvent?.(event);
+                log(`Event: ${event.type}`);
+            });
+            // Keep alive
+            while (state.running) {
+                await new Promise(resolve => setTimeout(resolve, 5000));
+                // Rotate events file if > 10MB
+                try {
+                    if (existsSync(EVENTS_FILE)) {
+                        const stats = statSync(EVENTS_FILE);
+                        if (stats.size > 10 * 1024 * 1024) {
+                            const { renameSync } = await import("node:fs");
+                            const archivePath = EVENTS_FILE.replace(".jsonl", `.${Date.now()}.jsonl`);
+                            renameSync(EVENTS_FILE, archivePath);
+                            log(`Rotated events file`);
+                        }
+                    }
+                }
+                catch { /* ignore */ }
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            retries++;
+            const delay = Math.min(1000 * Math.pow(2, retries), 30000);
+            log(`Connection failed (attempt ${retries}/${maxRetries}): ${msg}. Retrying in ${delay / 1000}s...`);
+            await new Promise(resolve => setTimeout(resolve, delay));
+        }
+    }
+    if (retries >= maxRetries) {
+        log(`Max retries (${maxRetries}) exceeded. Giving up.`);
+    }
+    await shutdown();
+    return state;
+}
+//# sourceMappingURL=agentLoop.js.map