openclaw-node-harness 2.0.0

package/mission-control/src/app/api/mesh/nodes/route.ts

@@ -0,0 +1,221 @@
+import { NextResponse } from "next/server";
+import { getHealthKv, sc } from "@/lib/nats";
+import { getDb, getRawDb } from "@/lib/db";
+import { tasks } from "@/lib/db/schema";
+import { eq } from "drizzle-orm";
+
+export const dynamic = "force-dynamic";
+
+// ── Types ────────────────────────────────────────────────────────────────
+
+interface NodeHealth {
+  nodeId: string;
+  platform: string;
+  role: string;
+  tailscaleIp: string;
+  diskPercent: number;
+  mem: { total: number; free: number };
+  uptimeSeconds: number;
+  services: Array<{ name: string; status: string; pid?: number }>;
+  agent: {
+    status: string;
+    currentTask: string | null;
+    llm: string | null;
+    model: string | null;
+    budgetRemainingSeconds?: number;
+  };
+  capabilities: string[];
+  stats: {
+    tasksToday: number;
+    successRate: number;
+    tokenSpendTodayUsd: number;
+  };
+  // Timestamp set by the node when it wrote this health blob
+  reportedAt?: string;
+}
+
+interface MeshNode {
+  nodeId: string;
+  status: "online" | "degraded" | "offline";
+  health: NodeHealth | null;
+  activeTasks: Array<{
+    id: string;
+    title: string;
+    status: string;
+    meshTaskId: string | null;
+  }>;
+  lastSeen: string | null;
+  staleSeconds: number | null;
+}
+
+// ── Local Cache ──────────────────────────────────────────────────────────
+// Survives NATS blips. If KV read fails, we serve stale data with a
+// staleness indicator rather than flipping nodes to "offline".
+
+interface CachedNode {
+  health: NodeHealth;
+  fetchedAt: number; // Date.now() when we last got fresh data
+}
+
+const nodeCache = new Map<string, CachedNode>();
+
+// Thresholds for staleness (in seconds)
+const STALE_DEGRADED = 45; // >45s since last health report → degraded
+const STALE_OFFLINE = 120; // >120s → offline (matches KV TTL)
+
+// Known nodes — extend this list or discover from KV keys
+const KNOWN_NODES = [
+  "moltymacs-virtual-machine-local",
+  "calos-vmware-virtual-platform",
+];
+
+// ── Route Handler ────────────────────────────────────────────────────────
+
+/**
+ * GET /api/mesh/nodes
+ *
+ * Architecture (v2 — KV-based, no request-reply):
+ *
+ *   Each node runs a health publisher (every 15s):
+ *     gatherHealth() → NATS KV put("MESH_NODE_HEALTH", nodeId, JSON)
+ *
+ *   This route just reads from the KV bucket:
+ *     KV get(nodeId) → parse JSON → check reportedAt timestamp → derive status
+ *
+ *   No synchronous round-trips to nodes. No timeout races. No flickering.
+ */
+export async function GET() {
+  const kv = await getHealthKv();
+  const db = getDb();
+  const now = Date.now();
+
+  const nodes: MeshNode[] = [];
+
+  for (const nodeId of KNOWN_NODES) {
+    let health: NodeHealth | null = null;
+    let staleSeconds: number | null = null;
+
+    // ── Try reading from KV ────────────────────────────────────────────
+    if (kv) {
+      try {
+        const entry = await kv.get(nodeId);
+        if (entry && entry.value) {
+          health = JSON.parse(sc.decode(entry.value));
+          if (health) {
+            // Update local cache with fresh data
+            nodeCache.set(nodeId, { health, fetchedAt: now });
+          }
+        }
+      } catch {
+        // KV read failed — fall through to cache
+      }
+    }
+
+    // ── Fall back to local cache if KV missed ──────────────────────────
+    if (!health) {
+      const cached = nodeCache.get(nodeId);
+      if (cached) {
+        health = cached.health;
+      }
+    }
+
+    // ── Derive status from staleness ───────────────────────────────────
+    let status: "online" | "degraded" | "offline" = "offline";
+    let lastSeen: string | null = null;
+
+    if (health) {
+      // Use the node's self-reported timestamp if available,
+      // otherwise use when we last fetched it
+      const reportedAt = health.reportedAt
+        ? new Date(health.reportedAt).getTime()
+        : nodeCache.get(nodeId)?.fetchedAt ?? now;
+
+      staleSeconds = Math.round((now - reportedAt) / 1000);
+      lastSeen = new Date(reportedAt).toISOString();
+
+      if (staleSeconds < STALE_DEGRADED) {
+        // Fresh data — check for service-level degradation
+        const hasDownService = health.services.some(
+          (s) => s.status === "down" || s.status === "error"
+        );
+        const highDisk = health.diskPercent > 85;
+        status = hasDownService || highDisk ? "degraded" : "online";
+      } else if (staleSeconds < STALE_OFFLINE) {
+        // Stale but within TTL — degraded, show last-known data
+        status = "degraded";
+      } else {
+        // Truly stale — offline, but still show last-known health
+        status = "offline";
+      }
+    }
+
+    // ── Get active mesh tasks assigned to this node from DB ────────────
+    let activeTasks: Array<{
+      id: string;
+      title: string;
+      status: string;
+      meshTaskId: string | null;
+    }> = [];
+
+    try {
+      activeTasks = db
+        .select({
+          id: tasks.id,
+          title: tasks.title,
+          status: tasks.status,
+          meshTaskId: tasks.meshTaskId,
+        })
+        .from(tasks)
+        .where(eq(tasks.meshNode, nodeId))
+        .all()
+        .filter((t) => t.status === "running" || t.status === "submitted");
+    } catch {
+      // meshNode column may not exist yet (pre-Phase-A migration)
+    }
+
+    nodes.push({
+      nodeId,
+      status,
+      health,
+      activeTasks,
+      lastSeen,
+      staleSeconds,
+    });
+  }
+
+  // ── Token usage stats (optional table) ─────────────────────────────
+  const raw = getRawDb();
+  let tokenStats: Record<
+    string,
+    { tasks: number; cost: number; success: number; total: number }
+  > = {};
+  try {
+    const today = new Date().toISOString().slice(0, 10);
+    const rows = raw
+      .prepare(
+        `
+      SELECT node_id, COUNT(*) as task_count, SUM(cost_usd) as total_cost
+      FROM token_usage
+      WHERE timestamp >= ?
+      GROUP BY node_id
+    `
+      )
+      .all(`${today}T00:00:00`) as Array<{
+      node_id: string;
+      task_count: number;
+      total_cost: number;
+    }>;
+    for (const row of rows) {
+      tokenStats[row.node_id] = {
+        tasks: row.task_count,
+        cost: row.total_cost || 0,
+        success: 0,
+        total: row.task_count,
+      };
+    }
+  } catch {
+    // token_usage table may not exist yet
+  }
+
+  return NextResponse.json({ nodes, tokenStats });
+}

package/mission-control/src/app/api/mesh/tokens/route.ts

@@ -0,0 +1,133 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getRawDb } from "@/lib/db";
+
+export const dynamic = "force-dynamic";
+
+/**
+ * GET /api/mesh/tokens?period=today|week|month
+ * Returns token usage summary with breakdowns by model and node.
+ */
+export async function GET(req: NextRequest) {
+  const period = req.nextUrl.searchParams.get("period") || "today";
+  const raw = getRawDb();
+
+  const now = new Date();
+  let since: string;
+  switch (period) {
+    case "week": {
+      const d = new Date(now);
+      d.setDate(d.getDate() - 7);
+      since = d.toISOString();
+      break;
+    }
+    case "month": {
+      const d = new Date(now);
+      d.setMonth(d.getMonth() - 1);
+      since = d.toISOString();
+      break;
+    }
+    default: // today
+      since = `${now.toISOString().slice(0, 10)}T00:00:00`;
+      break;
+  }
+
+  try {
+    // Totals
+    const totals = raw
+      .prepare(
+        `SELECT
+          COUNT(*) as task_count,
+          COALESCE(SUM(input_tokens), 0) as total_input,
+          COALESCE(SUM(output_tokens), 0) as total_output,
+          COALESCE(SUM(cost_usd), 0) as total_cost
+        FROM token_usage
+        WHERE timestamp >= ?`
+      )
+      .get(since) as {
+      task_count: number;
+      total_input: number;
+      total_output: number;
+      total_cost: number;
+    };
+
+    // By model
+    const byModel = raw
+      .prepare(
+        `SELECT model, SUM(cost_usd) as cost, COUNT(*) as count
+        FROM token_usage
+        WHERE timestamp >= ?
+        GROUP BY model
+        ORDER BY cost DESC`
+      )
+      .all(since) as Array<{ model: string; cost: number; count: number }>;
+
+    // By node
+    const byNode = raw
+      .prepare(
+        `SELECT node_id, SUM(cost_usd) as cost, COUNT(*) as count
+        FROM token_usage
+        WHERE timestamp >= ? AND node_id IS NOT NULL
+        GROUP BY node_id
+        ORDER BY cost DESC`
+      )
+      .all(since) as Array<{ node_id: string; cost: number; count: number }>;
+
+    // Recent entries
+    const recent = raw
+      .prepare(
+        `SELECT * FROM token_usage
+        WHERE timestamp >= ?
+        ORDER BY timestamp DESC
+        LIMIT 50`
+      )
+      .all(since);
+
+    return NextResponse.json({
+      totalCost: totals.total_cost,
+      totalInputTokens: totals.total_input,
+      totalOutputTokens: totals.total_output,
+      taskCount: totals.task_count,
+      byModel,
+      byNode,
+      recent,
+    });
+  } catch {
+    // Table may not exist yet
+    return NextResponse.json({
+      totalCost: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      taskCount: 0,
+      byModel: [],
+      byNode: [],
+      recent: [],
+    });
+  }
+}
+
+/**
+ * POST /api/mesh/tokens — record a token usage entry
+ * Body: { task_id, node_id, model, input_tokens, output_tokens, cost_usd }
+ */
+export async function POST(req: NextRequest) {
+  const body = await req.json();
+  const raw = getRawDb();
+
+  const { task_id, node_id, model, input_tokens, output_tokens, cost_usd } = body;
+
+  if (!model || input_tokens == null || output_tokens == null || cost_usd == null) {
+    return NextResponse.json(
+      { error: "Missing required fields: model, input_tokens, output_tokens, cost_usd" },
+      { status: 400 }
+    );
+  }
+
+  raw
+    .prepare(
+      `INSERT INTO token_usage (task_id, node_id, model, input_tokens, output_tokens, cost_usd)
+      VALUES (?, ?, ?, ?, ?, ?)`
+    )
+    .run(task_id || null, node_id || null, model, input_tokens, output_tokens, cost_usd);
+
+  return NextResponse.json({ ok: true });
+}

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

@@ -0,0 +1,102 @@
+import { NextRequest, NextResponse } from "next/server";
+import { eq } from "drizzle-orm";
+import { getDb, getRawDb } from "@/lib/db";
+import { tasks } from "@/lib/db/schema";
+import { syncTasksToMarkdown } from "@/lib/sync/tasks";
+import { logActivity } from "@/lib/activity";
+
+/**
+ * GET /api/projects
+ * List all project-type tasks with child counts.
+ */
+export async function GET() {
+  try {
+    const db = getDb();
+    const raw = getRawDb();
+
+    const projects = db
+      .select()
+      .from(tasks)
+      .where(eq(tasks.type, "project"))
+      .orderBy(tasks.sortOrder, tasks.title)
+      .all();
+
+    // Get child counts per project via raw SQL for efficiency
+    const counts = raw
+      .prepare(
+        `SELECT parent_id, COUNT(*) as count FROM tasks
+         WHERE parent_id IS NOT NULL
+         GROUP BY parent_id`
+      )
+      .all() as { parent_id: string; count: number }[];
+
+    const countMap = new Map(counts.map((c) => [c.parent_id, c.count]));
+
+    const result = projects.map((p) => ({
+      ...p,
+      childCount: countMap.get(p.id) ?? 0,
+    }));
+
+    return NextResponse.json(result);
+  } catch (err) {
+    console.error("GET /api/projects error:", err);
+    return NextResponse.json(
+      { error: "Failed to fetch projects" },
+      { status: 500 }
+    );
+  }
+}
+
+/**
+ * POST /api/projects
+ * Create a new project. Body: { id, title, description?, color?, start_date?, end_date? }
+ */
+export async function POST(request: NextRequest) {
+  try {
+    const db = getDb();
+    const body = await request.json();
+
+    if (!body.id || !body.title) {
+      return NextResponse.json(
+        { error: "id and title are required" },
+        { status: 400 }
+      );
+    }
+
+    const now = new Date().toISOString();
+
+    db.insert(tasks)
+      .values({
+        id: body.id,
+        title: body.title,
+        status: body.status || "queued",
+        kanbanColumn: "backlog",
+        type: "project",
+        description: body.description || null,
+        color: body.color || null,
+        startDate: body.start_date || null,
+        endDate: body.end_date || null,
+        owner: body.owner || null,
+        updatedAt: now,
+        createdAt: now,
+      })
+      .run();
+
+    syncTasksToMarkdown(db);
+    logActivity("task_created", `Created project: ${body.title}`, body.id);
+
+    const created = db
+      .select()
+      .from(tasks)
+      .where(eq(tasks.id, body.id))
+      .get();
+
+    return NextResponse.json(created, { status: 201 });
+  } catch (err) {
+    console.error("POST /api/projects error:", err);
+    return NextResponse.json(
+      { error: "Failed to create project" },
+      { status: 500 }
+    );
+  }
+}

package/mission-control/src/app/api/resolve-path/route.ts

@@ -0,0 +1,92 @@
+import { NextRequest, NextResponse } from "next/server";
+import fs from "fs";
+import path from "path";
+import { WORKSPACE_ROOT } from "@/lib/config";
+
+const HOME = process.env.HOME || "/Users/moltymac";
+
+const SEARCH_DIRS = [
+  WORKSPACE_ROOT,
+  path.join(HOME, "Desktop"),
+  path.join(HOME, "Downloads"),
+  path.join(HOME, "Documents"),
+  path.join(HOME, "Pictures"),
+];
+
+const MAX_DEPTH = 5;
+
+/**
+ * Normalize a string for fuzzy filename matching:
+ * - NFC Unicode normalization (macOS APFS uses NFD, browsers send NFC)
+ * - Replace curly quotes with straight quotes (macOS uses curly, browsers normalize to straight)
+ */
+function normalizeForMatch(s: string): string {
+  return s
+    .normalize("NFC")
+    .replace(/[\u2018\u2019]/g, "'")
+    .replace(/[\u201C\u201D]/g, '"');
+}
+
+/**
+ * Recursively search for a file by basename using Node fs (preserves Unicode normalization).
+ */
+function findFile(dir: string, target: string, depth: number): string | null {
+  if (depth <= 0) return null;
+  const normTarget = normalizeForMatch(target);
+  let entries: fs.Dirent[];
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  for (const entry of entries) {
+    if (entry.isFile()) {
+      if (entry.name === target || normalizeForMatch(entry.name) === normTarget) {
+        return path.join(dir, entry.name);
+      }
+    }
+  }
+  // Recurse into subdirectories
+  for (const entry of entries) {
+    if (entry.isDirectory() && !entry.name.startsWith(".")) {
+      const found = findFile(path.join(dir, entry.name), target, depth - 1);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+
+/**
+ * POST /api/resolve-path
+ * Given a basename (filename), search workspace + home dirs to find the full path.
+ * Uses Node fs directly to preserve Unicode normalization (macOS NFD/NFC).
+ * Body: { name: "somefile.md" }
+ * Returns: { path: "/full/path/to/somefile.md" } or { path: null }
+ */
+export async function POST(request: NextRequest) {
+  try {
+    const { name } = await request.json();
+
+    if (!name || typeof name !== "string") {
+      return NextResponse.json({ error: "name is required" }, { status: 400 });
+    }
+
+    // Sanitize: strip path separators to prevent traversal
+    const basename = name.replace(/[/\\]/g, "").trim();
+    if (!basename) {
+      return NextResponse.json({ path: null });
+    }
+
+    for (const dir of SEARCH_DIRS) {
+      const found = findFile(dir, basename, MAX_DEPTH);
+      if (found) {
+        return NextResponse.json({ path: found });
+      }
+    }
+
+    return NextResponse.json({ path: null });
+  } catch (err) {
+    console.error("POST /api/resolve-path error:", err);
+    return NextResponse.json({ error: "Failed to resolve path" }, { status: 500 });
+  }
+}

package/mission-control/src/app/api/scheduler/tick/route.ts

@@ -0,0 +1,38 @@
+import { NextResponse } from "next/server";
+import { schedulerTick } from "@/lib/scheduler";
+
+/**
+ * POST /api/scheduler/tick
+ * Triggers a scheduler evaluation cycle.
+ * Called by: SWR polling, heartbeat system, or manual trigger.
+ * Idempotent — safe to call frequently.
+ */
+export async function POST() {
+  try {
+    const result = schedulerTick();
+    return NextResponse.json(result);
+  } catch (err) {
+    console.error("POST /api/scheduler/tick error:", err);
+    return NextResponse.json(
+      { error: "Scheduler tick failed" },
+      { status: 500 }
+    );
+  }
+}
+
+/**
+ * GET /api/scheduler/tick
+ * Same as POST — allows easy triggering from browser or curl.
+ */
+export async function GET() {
+  try {
+    const result = schedulerTick();
+    return NextResponse.json(result);
+  } catch (err) {
+    console.error("GET /api/scheduler/tick error:", err);
+    return NextResponse.json(
+      { error: "Scheduler tick failed" },
+      { status: 500 }
+    );
+  }
+}

package/mission-control/src/app/api/scheduler/waves/route.ts

@@ -0,0 +1,54 @@
+import { NextResponse } from "next/server";
+import { eq, and, or } from "drizzle-orm";
+import { getDb } from "@/lib/db";
+import { tasks, dependencies } from "@/lib/db/schema";
+import { computeWaves } from "@/lib/scheduler";
+
+/**
+ * GET /api/scheduler/waves
+ * Returns the current wave structure without dispatching.
+ * Useful for visualization and debugging.
+ */
+export async function GET() {
+  const db = getDb();
+
+  const dispatchable = db
+    .select()
+    .from(tasks)
+    .where(
+      and(
+        eq(tasks.needsApproval, 0),
+        or(
+          eq(tasks.status, "ready"),
+          and(eq(tasks.status, "queued"), eq(tasks.triggerKind, "none"))
+        )
+      )
+    )
+    .all();
+
+  const allDeps = db.select().from(dependencies).all();
+  const depTargetMap = new Map<string, string[]>();
+  for (const dep of allDeps) {
+    const existing = depTargetMap.get(dep.targetId) || [];
+    existing.push(dep.sourceId);
+    depTargetMap.set(dep.targetId, existing);
+  }
+  const taskStatusLookup = new Map(
+    db
+      .select({ id: tasks.id, status: tasks.status })
+      .from(tasks)
+      .all()
+      .map((t) => [t.id, t.status] as const)
+  );
+
+  const waves = computeWaves(
+    dispatchable.map((t) => t.id),
+    depTargetMap,
+    taskStatusLookup
+  );
+
+  return NextResponse.json({
+    waves,
+    totalDispatchable: dispatchable.length,
+  });
+}