openclaw-node-harness 2.0.4 → 2.1.0

package/mission-control/src/app/api/cowork/intervene/route.ts

@@ -0,0 +1,259 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getNats, getCollabKv, sc } from "@/lib/nats";
+import { eq } from "drizzle-orm";
+import { getDb } from "@/lib/db";
+import { tasks } from "@/lib/db/schema";
+import { syncTasksToMarkdown } from "@/lib/sync/tasks";
+
+export const dynamic = "force-dynamic";
+
+/**
+ * POST /api/cowork/intervene
+ *
+ * Operator interventions on collab sessions.
+ * Actions: abort, force_converge, remove_node
+ */
+export async function POST(request: NextRequest) {
+  const nc = await getNats();
+  if (!nc) {
+    return NextResponse.json({ error: "NATS unavailable" }, { status: 503 });
+  }
+
+  const kv = await getCollabKv();
+  if (!kv) {
+    return NextResponse.json(
+      { error: "Collab KV unavailable" },
+      { status: 503 }
+    );
+  }
+
+  const { action, sessionId, nodeId } = await request.json();
+
+  if (!sessionId) {
+    return NextResponse.json(
+      { error: "sessionId required" },
+      { status: 400 }
+    );
+  }
+
+  // Read current session
+  let session: any;
+  try {
+    const entry = await kv.get(sessionId);
+    if (!entry || !entry.value) {
+      return NextResponse.json(
+        { error: "Session not found" },
+        { status: 404 }
+      );
+    }
+    session = JSON.parse(sc.decode(entry.value));
+  } catch (err) {
+    return NextResponse.json(
+      { error: (err as Error).message },
+      { status: 500 }
+    );
+  }
+
+  const now = new Date().toISOString();
+  const audit = (event: string, detail?: string) => {
+    if (!session.audit_log) session.audit_log = [];
+    session.audit_log.push({ ts: now, event, detail, source: "mission-control" });
+  };
+
+  try {
+    switch (action) {
+      case "abort": {
+        session.status = "aborted";
+        session.completed_at = now;
+        audit("manual_abort");
+
+        await kv.put(sessionId, sc.encode(JSON.stringify(session)));
+
+        // Cancel parent task via daemon RPC
+        try {
+          await nc.request(
+            "mesh.tasks.cancel",
+            sc.encode(JSON.stringify({ task_id: session.task_id })),
+            { timeout: 5000 }
+          );
+        } catch {
+          // Daemon may be down — KV is already updated
+        }
+
+        // Notify subscribers
+        nc.publish(
+          "mesh.events.collab.aborted",
+          sc.encode(
+            JSON.stringify({
+              session_id: sessionId,
+              task_id: session.task_id,
+            })
+          )
+        );
+
+        // Update Kanban for immediate feedback
+        try {
+          const db = getDb();
+          db.update(tasks)
+            .set({ status: "cancelled", kanbanColumn: "done", updatedAt: now })
+            .where(eq(tasks.id, session.task_id))
+            .run();
+          syncTasksToMarkdown(db);
+        } catch { /* best-effort */ }
+
+        return NextResponse.json({ ok: true, action: "aborted" });
+      }
+
+      case "force_converge": {
+        // Inject synthetic reflections for nodes that haven't submitted
+        const currentRound =
+          session.rounds?.[session.rounds.length - 1];
+        if (currentRound) {
+          const submittedNodes = new Set(
+            (currentRound.reflections || []).map((r: any) => r.node_id)
+          );
+          const activeNodes = (session.nodes || []).filter(
+            (n: any) => n.status !== "dead"
+          );
+
+          for (const node of activeNodes) {
+            if (!submittedNodes.has(node.node_id)) {
+              if (!currentRound.reflections) currentRound.reflections = [];
+              currentRound.reflections.push({
+                node_id: node.node_id,
+                summary: "Synthetic reflection (force-converged by operator)",
+                learnings: "",
+                artifacts: [],
+                confidence: 0.5,
+                vote: "converged",
+                synthetic: true,
+                submitted_at: now,
+              });
+            }
+          }
+          currentRound.completed_at = now;
+        }
+
+        session.status = "converged";
+        audit("force_converge");
+
+        // Order matters: KV first, then event, then complete parent task.
+        // If mesh.tasks.complete fires before KV is updated, the task closes
+        // but the session shows as still active in the UI until next SWR poll.
+        await kv.put(sessionId, sc.encode(JSON.stringify(session)));
+
+        nc.publish(
+          "mesh.events.collab.converged",
+          sc.encode(
+            JSON.stringify({
+              session_id: sessionId,
+              task_id: session.task_id,
+              forced: true,
+            })
+          )
+        );
+
+        // Complete parent task via daemon RPC — critical fix:
+        // without this, daemon's in-memory task stays running forever
+        try {
+          await nc.request(
+            "mesh.tasks.complete",
+            sc.encode(
+              JSON.stringify({
+                task_id: session.task_id,
+                result: {
+                  success: true,
+                  summary: "Force-converged by operator via Mission Control",
+                  forced: true,
+                },
+              })
+            ),
+            { timeout: 5000 }
+          );
+        } catch {
+          // Daemon may be down — session is at least marked converged in KV
+        }
+
+        // Update Kanban for immediate feedback
+        try {
+          const db = getDb();
+          db.update(tasks)
+            .set({ status: "done", kanbanColumn: "done", updatedAt: now })
+            .where(eq(tasks.id, session.task_id))
+            .run();
+          syncTasksToMarkdown(db);
+        } catch { /* best-effort */ }
+
+        return NextResponse.json({ ok: true, action: "force_converged" });
+      }
+
+      case "remove_node": {
+        if (!nodeId) {
+          return NextResponse.json(
+            { error: "nodeId required for remove_node" },
+            { status: 400 }
+          );
+        }
+
+        // Use daemon RPC so it updates both KV and in-memory state atomically
+        // This avoids stale quorum in the daemon's evaluateRound()
+        try {
+          await nc.request(
+            "mesh.collab.leave",
+            sc.encode(
+              JSON.stringify({
+                session_id: sessionId,
+                node_id: nodeId,
+              })
+            ),
+            { timeout: 5000 }
+          );
+        } catch {
+          // Fallback: direct KV write if daemon doesn't handle leave RPC
+          const node = (session.nodes || []).find(
+            (n: any) => n.node_id === nodeId
+          );
+          if (node) {
+            node.status = "dead";
+            audit("node_removed", nodeId);
+            await kv.put(sessionId, sc.encode(JSON.stringify(session)));
+          }
+        }
+
+        // Notify the node to stop
+        nc.publish(
+          `mesh.agent.${nodeId}.stall`,
+          sc.encode(
+            JSON.stringify({
+              task_id: session.task_id,
+              reason: "Removed by operator",
+            })
+          )
+        );
+
+        nc.publish(
+          "mesh.events.collab.node_removed",
+          sc.encode(
+            JSON.stringify({
+              session_id: sessionId,
+              node_id: nodeId,
+            })
+          )
+        );
+
+        return NextResponse.json({ ok: true, action: "node_removed", nodeId });
+      }
+
+      default:
+        return NextResponse.json(
+          { error: `Unknown action: ${action}` },
+          { status: 400 }
+        );
+    }
+  } catch (err) {
+    return NextResponse.json(
+      { error: (err as Error).message },
+      { status: 500 }
+    );
+  }
+}

package/mission-control/src/app/api/cowork/sessions/[id]/route.ts

@@ -0,0 +1,37 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getCollabKv, sc } from "@/lib/nats";
+
+export const dynamic = "force-dynamic";
+
+/**
+ * GET /api/cowork/sessions/[id]
+ *
+ * Single session detail from NATS MESH_COLLAB KV.
+ */
+export async function GET(
+  _request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  const kv = await getCollabKv();
+  if (!kv) {
+    return NextResponse.json({ error: "NATS unavailable" }, { status: 503 });
+  }
+
+  try {
+    const entry = await kv.get(id);
+    if (!entry || !entry.value) {
+      return NextResponse.json(
+        { error: "Session not found" },
+        { status: 404 }
+      );
+    }
+    const session = JSON.parse(sc.decode(entry.value));
+    return NextResponse.json(session);
+  } catch (err) {
+    return NextResponse.json(
+      { error: (err as Error).message },
+      { status: 500 }
+    );
+  }
+}

package/mission-control/src/app/api/cowork/sessions/route.ts

@@ -0,0 +1,64 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getCollabKv, sc } from "@/lib/nats";
+
+export const dynamic = "force-dynamic";
+
+/**
+ * GET /api/cowork/sessions
+ *
+ * Read all collab sessions from NATS MESH_COLLAB KV.
+ * Optional ?status= filter (e.g., "active", "recruiting", "completed").
+ * Returns { sessions[], natsAvailable }.
+ */
+export async function GET(request: NextRequest) {
+  const kv = await getCollabKv();
+  if (!kv) {
+    return NextResponse.json({ sessions: [], natsAvailable: false });
+  }
+
+  // Supports single status (?status=active) or comma-separated (?status=active,recruiting)
+  const statusParam = request.nextUrl.searchParams.get("status");
+  const statusFilter = statusParam ? new Set(statusParam.split(",")) : null;
+
+  const sessions: unknown[] = [];
+  try {
+    const keys: string[] = [];
+    const keyIter = await kv.keys();
+    for await (const key of keyIter) keys.push(key);
+
+    for (const key of keys) {
+      try {
+        const entry = await kv.get(key);
+        if (!entry || !entry.value) continue;
+        const session = JSON.parse(sc.decode(entry.value));
+        if (statusFilter && !statusFilter.has(session.status)) continue;
+        sessions.push(session);
+      } catch {
+        // Skip malformed entries
+      }
+    }
+  } catch (err) {
+    console.error("[cowork/sessions] KV scan error:", (err as Error).message);
+  }
+
+  // Sort: active/recruiting first, then by created_at desc
+  const statusOrder: Record<string, number> = {
+    active: 0,
+    recruiting: 1,
+    converged: 2,
+    completed: 3,
+    aborted: 4,
+  };
+
+  sessions.sort((a: any, b: any) => {
+    const aOrder = statusOrder[a.status] ?? 5;
+    const bOrder = statusOrder[b.status] ?? 5;
+    if (aOrder !== bOrder) return aOrder - bOrder;
+    return (
+      new Date(b.created_at || 0).getTime() -
+      new Date(a.created_at || 0).getTime()
+    );
+  });
+
+  return NextResponse.json({ sessions, natsAvailable: true });
+}

package/mission-control/src/app/api/diagnostics/route.ts

@@ -0,0 +1,97 @@
+import { NextResponse } from "next/server";
+import { getRawDb } from "@/lib/db";
+import { getNats } from "@/lib/nats";
+import fs from "fs";
+import { ACTIVE_TASKS_MD, WORKSPACE_ROOT } from "@/lib/config";
+import { parseTasksMarkdown, serializeTasksMarkdown } from "@/lib/parsers/task-markdown";
+
+export const dynamic = "force-dynamic";
+
+export async function GET() {
+  const raw = getRawDb();
+
+  // Task stats
+  const tasksByStatus = raw
+    .prepare("SELECT status, COUNT(*) as count FROM tasks GROUP BY status ORDER BY count DESC")
+    .all() as Array<{ status: string; count: number }>;
+
+  const tasksByType = raw
+    .prepare("SELECT type, COUNT(*) as count FROM tasks GROUP BY type ORDER BY count DESC")
+    .all() as Array<{ type: string; count: number }>;
+
+  const tasksByKanban = raw
+    .prepare("SELECT kanban_column, COUNT(*) as count FROM tasks GROUP BY kanban_column ORDER BY count DESC")
+    .all() as Array<{ kanban_column: string; count: number }>;
+
+  const totalTasks = raw.prepare("SELECT COUNT(*) as count FROM tasks").get() as { count: number };
+
+  // Memory stats
+  const memoryDocCount = (raw.prepare("SELECT COUNT(*) as count FROM memory_docs").get() as { count: number }).count;
+  const memoryItemCount = (raw.prepare("SELECT COUNT(*) as count FROM memory_items WHERE status = 'active'").get() as { count: number }).count;
+  const entityCount = (raw.prepare("SELECT COUNT(*) as count FROM memory_entities").get() as { count: number }).count;
+  const relationCount = (raw.prepare("SELECT COUNT(*) as count FROM memory_relations WHERE valid_to IS NULL").get() as { count: number }).count;
+
+  // Cluster stats
+  const clusterCount = (raw.prepare("SELECT COUNT(*) as count FROM clusters WHERE status = 'active'").get() as { count: number }).count;
+  const clusterMemberCount = (raw.prepare("SELECT COUNT(*) as count FROM cluster_members").get() as { count: number }).count;
+
+  // Sync health
+  let syncHealth: { exists: boolean; taskCount: number; roundTripOk: boolean; diffLines: number } = {
+    exists: false,
+    taskCount: 0,
+    roundTripOk: false,
+    diffLines: 0,
+  };
+
+  if (fs.existsSync(ACTIVE_TASKS_MD)) {
+    const content = fs.readFileSync(ACTIVE_TASKS_MD, "utf-8");
+    const parsed = parseTasksMarkdown(content);
+    const reserialized = serializeTasksMarkdown(parsed);
+    const reparsed = parseTasksMarkdown(reserialized);
+
+    // Compare field-by-field (ignoring whitespace differences in serialization)
+    const roundTripOk = parsed.length === reparsed.length &&
+      parsed.every((t, i) => t.id === reparsed[i].id && t.title === reparsed[i].title && t.status === reparsed[i].status);
+
+    syncHealth = {
+      exists: true,
+      taskCount: parsed.length,
+      roundTripOk,
+      diffLines: Math.abs(content.split("\n").length - reserialized.split("\n").length),
+    };
+  }
+
+  // NATS status
+  let natsStatus = "unavailable";
+  try {
+    const nc = await getNats();
+    natsStatus = nc ? "connected" : "unavailable";
+  } catch {
+    natsStatus = "error";
+  }
+
+  // Workspace
+  const workspaceExists = fs.existsSync(WORKSPACE_ROOT);
+
+  return NextResponse.json({
+    tasks: {
+      total: totalTasks.count,
+      byStatus: tasksByStatus,
+      byType: tasksByType,
+      byKanban: tasksByKanban,
+    },
+    memory: {
+      docs: memoryDocCount,
+      items: memoryItemCount,
+      entities: entityCount,
+      relations: relationCount,
+    },
+    cowork: {
+      clusters: clusterCount,
+      members: clusterMemberCount,
+    },
+    sync: syncHealth,
+    nats: natsStatus,
+    workspace: workspaceExists,
+  });
+}