openclaw-node-harness 2.0.4 → 2.1.0

package/mission-control/package.json

@@ -9,7 +9,10 @@
     "dev": "next dev",
     "build": "next build",
     "start": "next start",
-    "lint": "eslint"
+    "lint": "eslint",
+    "test": "vitest run src/lib/__tests__/",
+    "test:unit": "vitest run src/lib/__tests__/",
+    "test:watch": "vitest src/lib/__tests__/"
   },
   "dependencies": {
     "@andresaya/edge-tts": "^1.8.0",
@@ -44,6 +47,7 @@
     "eslint": "^9",
     "eslint-config-next": "16.1.6",
     "tailwindcss": "^4.2.1",
-    "typescript": "5.9.3"
+    "typescript": "5.9.3",
+    "vitest": "^4.1.0"
   }
 }

package/mission-control/scripts/gen-chronology.js

@@ -2,8 +2,8 @@ const Database = require('better-sqlite3');
 const path = require('path');
 const fs = require('fs');
 
-const DB_PATH = path.join(__dirname, '..', 'data', 'mission-control.db');
-const db = new Database(DB_PATH);
+const DB_PATH = path.join(__dirname, '..', 'Users', 'moltymac', '.openclaw', 'workspace', 'projects', 'mission-control', 'data', 'mission-control.db');
+const db = new Database('/Users/moltymac/.openclaw/workspace/projects/mission-control/data/mission-control.db');
 
 const rows = db.prepare(`
   SELECT id, title, type, scheduled_date, start_date, end_date, status, description, parent_id
@@ -96,7 +96,7 @@ lines.push('---');
 lines.push(`**Total: ${taskNum} tasks across ${sortedDates.length} days**`);
 
 const output = lines.join('\n');
-const outPath = path.join(__dirname, '..', '..', 'arcane', 'ARCANE_RAPTURE_TASK_CHRONOLOGY.md');
+const outPath = '/Users/moltymac/.openclaw/workspace/projects/arcane/ARCANE_RAPTURE_TASK_CHRONOLOGY.md';
 fs.writeFileSync(outPath, output);
 console.log(`Written to ${outPath}`);
 console.log(`${taskNum} tasks, ${sortedDates.length} dates`);

package/mission-control/scripts/import-pipeline-v2.js

@@ -307,22 +307,6 @@ function main() {
   db.pragma("journal_mode = WAL");
   db.pragma("foreign_keys = ON");
 
-  // Guard: verify MC runtime migrations have run (import needs columns beyond the base drizzle schema)
-  const cols = db.prepare("PRAGMA table_info(tasks)").all().map(c => c.name);
-  const required = ["type", "parent_id", "project", "start_date", "end_date", "color", "description", "scheduled_date", "needs_approval"];
-  const missing = required.filter(c => !cols.includes(c));
-  if (missing.length > 0) {
-    console.error(`DB schema missing columns: ${missing.join(", ")}`);
-    console.error("Start Mission Control first (npm run dev) to run migrations, then re-run this script.");
-    process.exit(1);
-  }
-  // Also ensure dependencies table exists
-  const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='dependencies'").get();
-  if (!tables) {
-    console.error("DB missing 'dependencies' table. Start Mission Control first to run migrations.");
-    process.exit(1);
-  }
-
   const importAll = db.transaction(() => {
     // 1. Clean existing ARCANE pipeline entries
     const importIds = new Set([

package/mission-control/scripts/import-pipeline.js

@@ -70,21 +70,6 @@ function main() {
   db.pragma("journal_mode = WAL");
   db.pragma("foreign_keys = ON");
 
-  // Guard: verify MC runtime migrations have run
-  const cols = db.prepare("PRAGMA table_info(tasks)").all().map(c => c.name);
-  const required = ["type", "parent_id", "project", "start_date", "end_date", "color", "description", "needs_approval"];
-  const missing = required.filter(c => !cols.includes(c));
-  if (missing.length > 0) {
-    console.error(`DB schema missing columns: ${missing.join(", ")}`);
-    console.error("Start Mission Control first (npm run dev) to run migrations, then re-run this script.");
-    process.exit(1);
-  }
-  const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='dependencies'").get();
-  if (!tables) {
-    console.error("DB missing 'dependencies' table. Start Mission Control first to run migrations.");
-    process.exit(1);
-  }
-
   // Wrap everything in a transaction
   const importAll = db.transaction(() => {
     // 1. Clean existing ARCANE pipeline entries (safe re-run)

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

@@ -0,0 +1,117 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getDb } from "@/lib/db";
+import { clusterMembers } from "@/lib/db/schema";
+import { eq, and } from "drizzle-orm";
+
+export const dynamic = "force-dynamic";
+
+/**
+ * POST /api/cowork/clusters/[id]/members
+ *
+ * Add a member to a cluster. 409 if already exists.
+ */
+export async function POST(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id: clusterId } = await params;
+  const { nodeId, role } = await request.json();
+
+  if (!nodeId) {
+    return NextResponse.json({ error: "nodeId required" }, { status: 400 });
+  }
+
+  const db = getDb();
+
+  // Check unique constraint
+  const existing = db
+    .select()
+    .from(clusterMembers)
+    .where(
+      and(
+        eq(clusterMembers.clusterId, clusterId),
+        eq(clusterMembers.nodeId, nodeId)
+      )
+    )
+    .get();
+
+  if (existing) {
+    return NextResponse.json(
+      { error: "Node already in cluster" },
+      { status: 409 }
+    );
+  }
+
+  db.insert(clusterMembers)
+    .values({ clusterId, nodeId, role: role || "worker" })
+    .run();
+
+  return NextResponse.json({ ok: true });
+}
+
+/**
+ * PATCH /api/cowork/clusters/[id]/members
+ *
+ * Update role for a member. Body: { nodeId, role }
+ */
+export async function PATCH(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id: clusterId } = await params;
+  const { nodeId, role } = await request.json();
+
+  if (!nodeId || !role) {
+    return NextResponse.json(
+      { error: "nodeId and role required" },
+      { status: 400 }
+    );
+  }
+
+  const db = getDb();
+
+  db.update(clusterMembers)
+    .set({ role })
+    .where(
+      and(
+        eq(clusterMembers.clusterId, clusterId),
+        eq(clusterMembers.nodeId, nodeId)
+      )
+    )
+    .run();
+
+  return NextResponse.json({ ok: true });
+}
+
+/**
+ * DELETE /api/cowork/clusters/[id]/members?nodeId=X
+ *
+ * Remove a member from a cluster.
+ */
+export async function DELETE(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id: clusterId } = await params;
+  const nodeId = request.nextUrl.searchParams.get("nodeId");
+
+  if (!nodeId) {
+    return NextResponse.json(
+      { error: "nodeId query param required" },
+      { status: 400 }
+    );
+  }
+
+  const db = getDb();
+
+  db.delete(clusterMembers)
+    .where(
+      and(
+        eq(clusterMembers.clusterId, clusterId),
+        eq(clusterMembers.nodeId, nodeId)
+      )
+    )
+    .run();
+
+  return NextResponse.json({ ok: true });
+}

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

@@ -0,0 +1,84 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getDb } from "@/lib/db";
+import { clusters, clusterMembers } from "@/lib/db/schema";
+import { eq, and } from "drizzle-orm";
+
+export const dynamic = "force-dynamic";
+
+/**
+ * GET /api/cowork/clusters/[id]
+ */
+export async function GET(
+  _request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  const db = getDb();
+
+  const cluster = db.select().from(clusters).where(eq(clusters.id, id)).get();
+  if (!cluster) {
+    return NextResponse.json({ error: "Not found" }, { status: 404 });
+  }
+
+  const members = db
+    .select()
+    .from(clusterMembers)
+    .where(eq(clusterMembers.clusterId, id))
+    .all();
+
+  return NextResponse.json({ ...cluster, members });
+}
+
+/**
+ * PATCH /api/cowork/clusters/[id]
+ *
+ * Partial update — only touches fields present in request body.
+ */
+export async function PATCH(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  const body = await request.json();
+  const db = getDb();
+
+  const existing = db.select().from(clusters).where(eq(clusters.id, id)).get();
+  if (!existing) {
+    return NextResponse.json({ error: "Not found" }, { status: 404 });
+  }
+
+  const updates: Record<string, unknown> = { updatedAt: new Date().toISOString() };
+  if (body.name !== undefined) updates.name = body.name;
+  if (body.description !== undefined) updates.description = body.description;
+  if (body.color !== undefined) updates.color = body.color;
+  if (body.defaultMode !== undefined) updates.defaultMode = body.defaultMode;
+  if (body.defaultConvergence !== undefined)
+    updates.defaultConvergence = body.defaultConvergence;
+  if (body.convergenceThreshold !== undefined)
+    updates.convergenceThreshold = body.convergenceThreshold;
+  if (body.maxRounds !== undefined) updates.maxRounds = body.maxRounds;
+
+  db.update(clusters).set(updates).where(eq(clusters.id, id)).run();
+
+  return NextResponse.json({ ok: true });
+}
+
+/**
+ * DELETE /api/cowork/clusters/[id]
+ *
+ * Soft-delete: sets status to "archived".
+ */
+export async function DELETE(
+  _request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  const db = getDb();
+
+  db.update(clusters)
+    .set({ status: "archived", updatedAt: new Date().toISOString() })
+    .where(eq(clusters.id, id))
+    .run();
+
+  return NextResponse.json({ ok: true });
+}

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

@@ -0,0 +1,141 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getDb } from "@/lib/db";
+import { clusters, clusterMembers } from "@/lib/db/schema";
+import { eq } from "drizzle-orm";
+import { getHealthKv, sc } from "@/lib/nats";
+
+export const dynamic = "force-dynamic";
+
+/**
+ * GET /api/cowork/clusters
+ *
+ * List all active clusters with members. Enriches members with live node status.
+ */
+export async function GET() {
+  const db = getDb();
+  const kv = await getHealthKv();
+
+  const allClusters = db
+    .select()
+    .from(clusters)
+    .where(eq(clusters.status, "active"))
+    .all();
+
+  const allMembers = db.select().from(clusterMembers).all();
+
+  // Build node status cache from NATS KV
+  const nodeStatus = new Map<string, string>();
+  if (kv) {
+    const now = Date.now();
+    const nodeIds = [...new Set(allMembers.map((m) => m.nodeId))];
+    for (const nodeId of nodeIds) {
+      try {
+        const entry = await kv.get(nodeId);
+        if (entry && entry.value) {
+          const health = JSON.parse(sc.decode(entry.value));
+          const reportedAt = health.reportedAt
+            ? new Date(health.reportedAt).getTime()
+            : now;
+          const stale = (now - reportedAt) / 1000;
+          nodeStatus.set(
+            nodeId,
+            stale < 45 ? "online" : stale < 120 ? "degraded" : "offline"
+          );
+        } else {
+          nodeStatus.set(nodeId, "offline");
+        }
+      } catch {
+        nodeStatus.set(nodeId, "offline");
+      }
+    }
+  }
+
+  const result = allClusters.map((c) => ({
+    ...c,
+    members: allMembers
+      .filter((m) => m.clusterId === c.id)
+      .map((m) => ({
+        id: m.id,
+        nodeId: m.nodeId,
+        role: m.role,
+        nodeStatus: nodeStatus.get(m.nodeId) ?? "unknown",
+        createdAt: m.createdAt,
+      })),
+  }));
+
+  return NextResponse.json({ clusters: result });
+}
+
+/**
+ * POST /api/cowork/clusters
+ *
+ * Create a new cluster with members.
+ */
+export async function POST(request: NextRequest) {
+  const body = await request.json();
+  const {
+    name,
+    description,
+    color,
+    defaultMode,
+    defaultConvergence,
+    convergenceThreshold,
+    maxRounds,
+    members,
+  } = body;
+
+  if (!name) {
+    return NextResponse.json({ error: "name is required" }, { status: 400 });
+  }
+
+  // Auto-slug from name
+  const id =
+    body.id ||
+    name
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, "-")
+      .replace(/^-|-$/g, "");
+
+  const db = getDb();
+
+  // Check duplicate
+  const existing = db.select().from(clusters).where(eq(clusters.id, id)).get();
+  if (existing) {
+    return NextResponse.json(
+      { error: `Cluster "${id}" already exists` },
+      { status: 409 }
+    );
+  }
+
+  const now = new Date().toISOString();
+
+  db.insert(clusters)
+    .values({
+      id,
+      name,
+      description: description || null,
+      color: color || null,
+      defaultMode: defaultMode || "parallel",
+      defaultConvergence: defaultConvergence || "unanimous",
+      convergenceThreshold: convergenceThreshold ?? 66,
+      maxRounds: maxRounds ?? 5,
+      status: "active",
+      updatedAt: now,
+    })
+    .run();
+
+  // Insert members
+  if (Array.isArray(members)) {
+    for (const m of members) {
+      db.insert(clusterMembers)
+        .values({
+          clusterId: id,
+          nodeId: m.nodeId,
+          role: m.role || "worker",
+        })
+        .run();
+    }
+  }
+
+  return NextResponse.json({ id, name });
+}

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

@@ -0,0 +1,128 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getNats, sc } from "@/lib/nats";
+import { getDb } from "@/lib/db";
+import { tasks, clusterMembers } from "@/lib/db/schema";
+import { eq } from "drizzle-orm";
+import { generateTaskId } from "@/lib/task-id";
+import { statusToKanban } from "@/lib/parsers/task-markdown";
+import { syncTasksToMarkdown } from "@/lib/sync/tasks";
+import { logActivity } from "@/lib/activity";
+
+export const dynamic = "force-dynamic";
+
+/**
+ * POST /api/cowork/dispatch
+ *
+ * Create a Kanban task with collaboration spec. The mesh-bridge picks it up
+ * from active-tasks.md and submits to NATS — no direct NATS call here.
+ *
+ * A wake signal is published to reduce bridge poll latency to ~1s.
+ */
+export async function POST(request: NextRequest) {
+  const body = await request.json();
+  const {
+    title,
+    description,
+    clusterId,
+    nodes: manualNodes,
+    mode = "parallel",
+    convergence = { type: "unanimous" },
+    scopeStrategy = "shared",
+    budgetMinutes = 30,
+    maxRounds = 5,
+    metric,
+    scope = [],
+  } = body;
+
+  if (!title) {
+    return NextResponse.json({ error: "title is required" }, { status: 400 });
+  }
+
+  // Resolve nodes from cluster or manual list
+  const db = getDb();
+  let nodeIds: string[] = [];
+
+  if (clusterId) {
+    const members = db
+      .select()
+      .from(clusterMembers)
+      .where(eq(clusterMembers.clusterId, clusterId))
+      .all();
+    nodeIds = members.map((m) => m.nodeId);
+  }
+
+  if (Array.isArray(manualNodes) && manualNodes.length > 0) {
+    const manualIds = manualNodes.map((n: any) => n.node_id || n.nodeId);
+    nodeIds = [...new Set([...nodeIds, ...manualIds])];
+  }
+
+  if (nodeIds.length < 2) {
+    return NextResponse.json(
+      { error: "Collab requires at least 2 nodes" },
+      { status: 400 }
+    );
+  }
+
+  // Build collaboration spec (bridge reads this from markdown)
+  const collabSpec = {
+    mode,
+    min_nodes: Math.min(nodeIds.length, 2),
+    max_nodes: nodeIds.length,
+    join_window_s: 30,
+    max_rounds: maxRounds,
+    convergence: {
+      type: convergence.type || "unanimous",
+      threshold: (convergence.threshold ?? 66) / 100,
+      metric: convergence.metric || null,
+      min_quorum: Math.min(nodeIds.length, 2),
+    },
+    scope_strategy: scopeStrategy,
+  };
+
+  const now = new Date();
+  const taskId = generateTaskId(db, now);
+
+  try {
+    db.insert(tasks)
+      .values({
+        id: taskId,
+        title,
+        status: "queued",
+        kanbanColumn: statusToKanban("queued"),
+        description: description || null,
+        execution: "mesh",
+        needsApproval: 0,
+        collaboration: JSON.stringify(collabSpec),
+        preferredNodes: JSON.stringify(nodeIds),
+        clusterId: clusterId || null,
+        metric: metric || null,
+        budgetMinutes,
+        scope: Array.isArray(scope) && scope.length ? JSON.stringify(scope) : null,
+        updatedAt: now.toISOString(),
+        createdAt: now.toISOString(),
+      })
+      .run();
+
+    // Sync to markdown so bridge can pick it up
+    syncTasksToMarkdown(db);
+
+    logActivity("task_created", `Collab dispatch: ${title}`, taskId);
+
+    // Wake the bridge for immediate pickup (~1s vs ~15s poll)
+    const nc = await getNats();
+    if (nc) {
+      nc.publish("mesh.bridge.wake", sc.encode(""));
+    }
+
+    return NextResponse.json({
+      taskId,
+      clusterId: clusterId || null,
+      nodesAssigned: nodeIds,
+    });
+  } catch (err) {
+    return NextResponse.json(
+      { error: (err as Error).message },
+      { status: 500 }
+    );
+  }
+}

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

@@ -0,0 +1,65 @@
+import { getNats, sc } from "@/lib/nats";
+
+export const dynamic = "force-dynamic";
+
+/**
+ * SSE endpoint for collab-specific events.
+ * Subscribes to mesh.events.collab.> and forwards to connected browsers.
+ */
+export async function GET() {
+  const nc = await getNats();
+  if (!nc) {
+    return new Response("NATS unavailable", { status: 503 });
+  }
+
+  const sub = nc.subscribe("mesh.events.collab.>");
+  let closed = false;
+
+  const stream = new ReadableStream({
+    async start(controller) {
+      const encoder = new TextEncoder();
+
+      controller.enqueue(encoder.encode(": connected\n\n"));
+
+      const keepalive = setInterval(() => {
+        if (!closed) {
+          try {
+            controller.enqueue(encoder.encode(": keepalive\n\n"));
+          } catch {
+            // controller closed
+          }
+        }
+      }, 30000);
+
+      try {
+        for await (const msg of sub) {
+          if (closed) break;
+          try {
+            const data = sc.decode(msg.data);
+            const eventType = msg.subject.replace("mesh.events.collab.", "");
+            controller.enqueue(
+              encoder.encode(`event: ${eventType}\ndata: ${data}\n\n`)
+            );
+          } catch {
+            // skip malformed
+          }
+        }
+      } finally {
+        clearInterval(keepalive);
+      }
+    },
+    cancel() {
+      closed = true;
+      sub.unsubscribe();
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache, no-transform",
+      Connection: "keep-alive",
+      "X-Accel-Buffering": "no",
+    },
+  });
+}