openclaw-node-harness 2.0.0

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

@@ -0,0 +1,266 @@
+import { NextRequest, NextResponse } from "next/server";
+import { eq, or } from "drizzle-orm";
+import { getDb } from "@/lib/db";
+import { tasks, dependencies } from "@/lib/db/schema";
+import { statusToKanban, kanbanToStatus } from "@/lib/parsers/task-markdown";
+import { syncTasksToMarkdown } from "@/lib/sync/tasks";
+import { logActivity } from "@/lib/activity";
+import { gatewayNotify } from "@/lib/gateway-notify";
+
+/**
+ * Push a notification message to the OpenClaw TUI via gateway chat.send + abort.
+ * Fire-and-forget — does not block the API response.
+ */
+function notifyAgent(text: string) {
+  gatewayNotify(text).catch((err) => {
+    console.error("MC gateway notify failed:", err);
+  });
+}
+
+/**
+ * DELETE /api/tasks/[id]
+ * Delete a task (and its children) by ID.
+ */
+export async function DELETE(
+  _request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  try {
+    const { id } = await params;
+    const db = getDb();
+
+    const existing = db
+      .select()
+      .from(tasks)
+      .where(eq(tasks.id, id))
+      .get();
+
+    if (!existing) {
+      return NextResponse.json(
+        { error: `Task not found: ${id}` },
+        { status: 404 }
+      );
+    }
+
+    // Recursively collect all descendant IDs (handles project → phase → task)
+    const idsToDelete: string[] = [];
+    function collectDescendants(parentId: string) {
+      const children = db
+        .select({ id: tasks.id })
+        .from(tasks)
+        .where(eq(tasks.parentId, parentId))
+        .all();
+      for (const child of children) {
+        collectDescendants(child.id); // depth-first: grandchildren first
+        idsToDelete.push(child.id);
+      }
+    }
+    collectDescendants(id);
+    idsToDelete.push(id); // add the root task last
+
+    // Delete all collected tasks + their dependency edges
+    for (const delId of idsToDelete) {
+      db.delete(dependencies)
+        .where(or(eq(dependencies.sourceId, delId), eq(dependencies.targetId, delId)))
+        .run();
+      db.delete(tasks).where(eq(tasks.id, delId)).run();
+    }
+
+    syncTasksToMarkdown(db);
+    logActivity("task_deleted", `Deleted: ${existing.title}`, id);
+
+    return NextResponse.json({ ok: true });
+  } catch (err) {
+    console.error("DELETE /api/tasks/[id] error:", err);
+    return NextResponse.json(
+      { error: "Failed to delete task" },
+      { status: 500 }
+    );
+  }
+}
+
+/**
+ * PATCH /api/tasks/[id]
+ * Update a task by ID. Body: partial task fields.
+ * Updates in DB, then syncs to markdown.
+ */
+export async function PATCH(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  try {
+    const { id } = await params;
+    const db = getDb();
+
+    // Verify the task exists
+    const existing = db
+      .select()
+      .from(tasks)
+      .where(eq(tasks.id, id))
+      .get();
+
+    if (!existing) {
+      return NextResponse.json(
+        { error: `Task not found: ${id}` },
+        { status: 404 }
+      );
+    }
+
+    const body = await request.json();
+    const now = new Date().toISOString();
+
+    // Build the update set from provided fields
+    const update: Record<string, unknown> = { updatedAt: now };
+
+    if (body.title !== undefined) {
+      update.title = body.title;
+    }
+    if (body.status !== undefined) {
+      update.status = body.status;
+      update.kanbanColumn = statusToKanban(body.status);
+    }
+    if (body.kanban_column !== undefined) {
+      update.kanbanColumn = body.kanban_column;
+      if (body.status === undefined) {
+        update.status = kanbanToStatus(body.kanban_column);
+      }
+    } else if (body.kanbanColumn !== undefined) {
+      update.kanbanColumn = body.kanbanColumn;
+      if (body.status === undefined) {
+        update.status = kanbanToStatus(body.kanbanColumn);
+      }
+    }
+    if (body.owner !== undefined) {
+      update.owner = body.owner || null;
+    }
+    if (body.success_criteria !== undefined) {
+      update.successCriteria = body.success_criteria
+        ? JSON.stringify(body.success_criteria)
+        : null;
+    }
+    if (body.artifacts !== undefined) {
+      update.artifacts = body.artifacts
+        ? JSON.stringify(body.artifacts)
+        : null;
+    }
+    if (body.next_action !== undefined) {
+      update.nextAction = body.next_action || null;
+    }
+    if (body.sort_order !== undefined) {
+      update.sortOrder = body.sort_order;
+    }
+    if (body.scheduled_date !== undefined) {
+      update.scheduledDate = body.scheduled_date || null;
+    }
+    if (body.project !== undefined) {
+      update.project = body.project || null;
+    }
+    if (body.type !== undefined) {
+      update.type = body.type;
+    }
+    if (body.parent_id !== undefined) {
+      update.parentId = body.parent_id || null;
+    }
+    if (body.start_date !== undefined) {
+      update.startDate = body.start_date || null;
+    }
+    if (body.end_date !== undefined) {
+      update.endDate = body.end_date || null;
+    }
+    if (body.color !== undefined) {
+      update.color = body.color || null;
+    }
+    if (body.description !== undefined) {
+      update.description = body.description || null;
+    }
+    if (body.needs_approval !== undefined) {
+      update.needsApproval = body.needs_approval ? 1 : 0;
+    }
+    if (body.trigger_kind !== undefined) {
+      update.triggerKind = body.trigger_kind;
+    }
+    if (body.trigger_at !== undefined) {
+      update.triggerAt = body.trigger_at || null;
+    }
+    if (body.trigger_cron !== undefined) {
+      update.triggerCron = body.trigger_cron || null;
+    }
+    if (body.trigger_tz !== undefined) {
+      update.triggerTz = body.trigger_tz || null;
+    }
+    if (body.is_recurring !== undefined) {
+      update.isRecurring = body.is_recurring ? 1 : 0;
+    }
+    if (body.capacity_class !== undefined) {
+      update.capacityClass = body.capacity_class;
+    }
+    if (body.auto_priority !== undefined) {
+      update.autoPriority = body.auto_priority;
+    }
+    if (body.show_in_calendar !== undefined) {
+      update.showInCalendar = body.show_in_calendar ? 1 : 0;
+    }
+    if (body.acknowledged_at !== undefined) {
+      update.acknowledgedAt = body.acknowledged_at || null;
+    }
+
+    // Auto-set owner when task moves to running manually (no explicit owner change)
+    const effectiveStatus = (update.status as string) ?? existing.status;
+    if (effectiveStatus === "running" && body.owner === undefined && !existing.owner) {
+      update.owner = "Gui";
+    }
+
+    db.update(tasks).set(update).where(eq(tasks.id, id)).run();
+
+    // Sync back to markdown
+    syncTasksToMarkdown(db);
+
+    // Log activity
+    const movedTo = body.kanban_column || body.kanbanColumn;
+    const parts: string[] = [];
+    if (movedTo) parts.push(`moved to ${movedTo}`);
+    if (body.status === "done") parts.push("completed");
+    else if (body.status) parts.push(`status → ${body.status}`);
+    if (body.title) parts.push(`renamed to "${body.title}"`);
+    const desc = parts.length > 0 ? parts.join(", ") : "updated";
+    logActivity(
+      body.status === "done" ? "task_completed" : movedTo ? "task_moved" : "task_updated",
+      `${existing.title}: ${desc}`,
+      id
+    );
+
+    // Push notification to TUI only for Daedalus autostart tasks
+    if (movedTo || body.status) {
+      const effectiveOwner = (update.owner as string) ?? existing.owner;
+      const effectiveApproval = (update.needsApproval as number) ?? existing.needsApproval;
+      const isDaedalus = effectiveOwner === "Daedalus";
+      const isAutostart = effectiveApproval === 0;
+
+      if (isDaedalus && isAutostart) {
+        const fromCol = existing.kanbanColumn || existing.status;
+        const toCol = movedTo || body.status;
+        notifyAgent(`MC-Kanban: "${existing.title}" has been moved from ${fromCol} to ${toCol}`);
+      }
+    }
+
+    const updated = db
+      .select()
+      .from(tasks)
+      .where(eq(tasks.id, id))
+      .get();
+
+    return NextResponse.json({
+      ...updated,
+      successCriteria: updated?.successCriteria
+        ? JSON.parse(updated.successCriteria)
+        : [],
+      artifacts: updated?.artifacts ? JSON.parse(updated.artifacts) : [],
+    });
+  } catch (err) {
+    console.error("PATCH /api/tasks/[id] error:", err);
+    return NextResponse.json(
+      { error: "Failed to update task" },
+      { status: 500 }
+    );
+  }
+}

package/mission-control/src/app/api/tasks/[id]/tree/route.ts

@@ -0,0 +1,94 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getRawDb } from "@/lib/db";
+
+interface TreeRow {
+  id: string;
+  title: string;
+  status: string;
+  kanban_column: string;
+  owner: string | null;
+  type: string | null;
+  parent_id: string | null;
+  start_date: string | null;
+  end_date: string | null;
+  color: string | null;
+  description: string | null;
+  sort_order: number | null;
+  scheduled_date: string | null;
+  project: string | null;
+  next_action: string | null;
+  updated_at: string;
+  created_at: string;
+}
+
+/**
+ * GET /api/tasks/[id]/tree
+ * Returns the full recursive subtree for a project/pipeline/phase.
+ * Uses SQLite recursive CTE for efficient traversal.
+ */
+export async function GET(
+  _request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  try {
+    const { id } = await params;
+    const raw = getRawDb();
+
+    const rows = raw
+      .prepare(
+        `WITH RECURSIVE tree AS (
+          SELECT * FROM tasks WHERE id = ?
+          UNION ALL
+          SELECT t.* FROM tasks t JOIN tree ON t.parent_id = tree.id
+        )
+        SELECT * FROM tree ORDER BY
+          CASE type
+            WHEN 'project' THEN 0
+            WHEN 'pipeline' THEN 1
+            WHEN 'phase' THEN 2
+            ELSE 3
+          END,
+          sort_order,
+          scheduled_date,
+          start_date,
+          id`
+      )
+      .all(id) as TreeRow[];
+
+    if (rows.length === 0) {
+      return NextResponse.json(
+        { error: `Task not found: ${id}` },
+        { status: 404 }
+      );
+    }
+
+    // Convert snake_case to camelCase for frontend consistency
+    const result = rows.map((r) => ({
+      id: r.id,
+      title: r.title,
+      status: r.status,
+      kanbanColumn: r.kanban_column,
+      owner: r.owner,
+      type: r.type,
+      parentId: r.parent_id,
+      startDate: r.start_date,
+      endDate: r.end_date,
+      color: r.color,
+      description: r.description,
+      sortOrder: r.sort_order,
+      scheduledDate: r.scheduled_date,
+      project: r.project,
+      nextAction: r.next_action,
+      updatedAt: r.updated_at,
+      createdAt: r.created_at,
+    }));
+
+    return NextResponse.json(result);
+  } catch (err) {
+    console.error("GET /api/tasks/[id]/tree error:", err);
+    return NextResponse.json(
+      { error: "Failed to fetch tree" },
+      { status: 500 }
+    );
+  }
+}

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

@@ -0,0 +1,253 @@
+import { NextRequest, NextResponse } from "next/server";
+import { eq, and } from "drizzle-orm";
+import fs from "fs";
+import { getDb } from "@/lib/db";
+import { tasks } from "@/lib/db/schema";
+import { statusToKanban } from "@/lib/parsers/task-markdown";
+import { syncTasksFromMarkdownIfChanged, syncTasksToMarkdown } from "@/lib/sync/tasks";
+import { logActivity } from "@/lib/activity";
+import { schedulerTick } from "@/lib/scheduler";
+import { WORKSPACE_ROOT } from "@/lib/config";
+import path from "path";
+
+/**
+ * Parse .companion-state.md to extract current active task.
+ * Returns a synthetic task object if there's active work, null otherwise.
+ */
+function readCompanionState(): { title: string; nextAction: string } | null {
+  const statePath = path.join(WORKSPACE_ROOT, ".companion-state.md");
+  if (!fs.existsSync(statePath)) return null;
+
+  const content = fs.readFileSync(statePath, "utf-8");
+
+  // Extract Active Task section
+  const activeMatch = content.match(new RegExp("## Active Task\\n(.+?)(?:\\n##|\\n*$)", "s"));
+  if (!activeMatch) return null;
+
+  const activeText = activeMatch[1].trim();
+  // Only treat as idle if the ENTIRE text is an idle phrase (not a substring match)
+  if (!activeText || /^(standing by|awaiting instructions|idle|none)\.?$/im.test(activeText)) {
+    return null;
+  }
+
+  // Extract Next Steps section
+  const nextMatch = content.match(/## Next Steps\n([\s\S]+?)(?:\n##|\n*$)/);
+  const nextText = nextMatch
+    ? nextMatch[1]
+        .split("\n")
+        .filter((l) => l.startsWith("- "))
+        .map((l) => l.slice(2))
+        .join("; ")
+    : "";
+
+  return { title: activeText, nextAction: nextText };
+}
+
+/**
+ * GET /api/tasks
+ * List all tasks. Always re-syncs from active-tasks.md for fresh state.
+ * Also injects a live "current session" task from .companion-state.md.
+ * Optional query params: ?status=X&column=X
+ */
+export async function GET(request: NextRequest) {
+  try {
+    const db = getDb();
+
+    // Only re-sync from markdown if the file was modified externally
+    syncTasksFromMarkdownIfChanged(db);
+
+    // Inject live session task from companion state
+    const liveWork = readCompanionState();
+    const liveTaskId = "__LIVE_SESSION__";
+
+    if (liveWork) {
+      db.insert(tasks)
+        .values({
+          id: liveTaskId,
+          title: liveWork.title,
+          status: "running",
+          kanbanColumn: "in_progress",
+          owner: "daedalus",
+          nextAction: liveWork.nextAction || null,
+          updatedAt: new Date().toISOString(),
+          createdAt: new Date().toISOString(),
+          sortOrder: -1,
+          successCriteria: null,
+          artifacts: null,
+        })
+        .onConflictDoUpdate({
+          target: tasks.id,
+          set: {
+            title: liveWork.title,
+            status: "running",
+            kanbanColumn: "in_progress",
+            nextAction: liveWork.nextAction || null,
+            updatedAt: new Date().toISOString(),
+          },
+        })
+        .run();
+    } else {
+      // No active work — remove the live task if it exists
+      db.delete(tasks).where(eq(tasks.id, liveTaskId)).run();
+    }
+
+    const { searchParams } = request.nextUrl;
+    const statusFilter = searchParams.get("status");
+    const columnFilter = searchParams.get("column");
+
+    const conditions = [];
+    if (statusFilter) {
+      conditions.push(eq(tasks.status, statusFilter));
+    }
+    if (columnFilter) {
+      conditions.push(eq(tasks.kanbanColumn, columnFilter));
+    }
+
+    let rows;
+    if (conditions.length > 0) {
+      rows = db
+        .select()
+        .from(tasks)
+        .where(conditions.length === 1 ? conditions[0] : and(...conditions))
+        .orderBy(tasks.sortOrder, tasks.id)
+        .all();
+    } else {
+      rows = db
+        .select()
+        .from(tasks)
+        .orderBy(tasks.sortOrder, tasks.id)
+        .all();
+    }
+
+    // Parse JSON fields for the response
+    const result = rows.map((t) => ({
+      ...t,
+      successCriteria: t.successCriteria ? JSON.parse(t.successCriteria) : [],
+      artifacts: t.artifacts ? JSON.parse(t.artifacts) : [],
+    }));
+
+    return NextResponse.json(result);
+  } catch (err) {
+    console.error("GET /api/tasks error:", err);
+    return NextResponse.json(
+      { error: "Failed to fetch tasks" },
+      { status: 500 }
+    );
+  }
+}
+
+/**
+ * POST /api/tasks
+ * Create a new task. Body: { title, status?, owner?, success_criteria?, artifacts?, next_action? }
+ * Auto-generates task_id as T-YYYYMMDD-NNN, writes to DB, then syncs to markdown.
+ */
+export async function POST(request: NextRequest) {
+  try {
+    const db = getDb();
+    const body = await request.json();
+
+    if (!body.title || typeof body.title !== "string") {
+      return NextResponse.json(
+        { error: "title is required and must be a string" },
+        { status: 400 }
+      );
+    }
+
+    const status = body.status || "not started";
+    const now = new Date();
+    // Allow custom IDs for projects/pipelines/phases; auto-generate for tasks
+    const taskId = body.id || generateTaskId(db, now);
+
+    db.insert(tasks)
+      .values({
+        id: taskId,
+        title: body.title,
+        status,
+        kanbanColumn: statusToKanban(status),
+        owner: body.owner || null,
+        successCriteria: body.success_criteria
+          ? JSON.stringify(body.success_criteria)
+          : null,
+        artifacts: body.artifacts ? JSON.stringify(body.artifacts) : null,
+        nextAction: body.next_action || null,
+        scheduledDate: body.scheduled_date || null,
+        project: body.project || null,
+        type: body.type || "task",
+        parentId: body.parent_id || null,
+        startDate: body.start_date || null,
+        endDate: body.end_date || null,
+        color: body.color || null,
+        description: body.description || null,
+        needsApproval: body.needs_approval !== undefined ? (body.needs_approval ? 1 : 0) : 1,
+        triggerKind: body.trigger_kind || "none",
+        triggerAt: body.trigger_at || null,
+        triggerCron: body.trigger_cron || null,
+        triggerTz: body.trigger_tz || "America/Montreal",
+        isRecurring: body.is_recurring ? 1 : 0,
+        capacityClass: body.capacity_class || "normal",
+        autoPriority: body.auto_priority || 0,
+        updatedAt: now.toISOString(),
+        createdAt: now.toISOString(),
+      })
+      .run();
+
+    // Sync DB state back to markdown
+    syncTasksToMarkdown(db);
+
+    // Log activity
+    logActivity("task_created", `Created: ${body.title}`, taskId);
+
+    // Immediately run scheduler tick so auto-start tasks dispatch without waiting for poll
+    schedulerTick();
+
+    const created = db
+      .select()
+      .from(tasks)
+      .where(eq(tasks.id, taskId))
+      .get();
+
+    return NextResponse.json(
+      {
+        ...created,
+        successCriteria: created?.successCriteria
+          ? JSON.parse(created.successCriteria)
+          : [],
+        artifacts: created?.artifacts ? JSON.parse(created.artifacts) : [],
+      },
+      { status: 201 }
+    );
+  } catch (err) {
+    console.error("POST /api/tasks error:", err);
+    return NextResponse.json(
+      { error: "Failed to create task" },
+      { status: 500 }
+    );
+  }
+}
+
+/**
+ * Generate a task ID in the format T-YYYYMMDD-NNN.
+ * NNN is a zero-padded sequence number based on existing tasks for that date.
+ */
+function generateTaskId(db: ReturnType<typeof getDb>, date: Date): string {
+  const dateStr =
+    date.getFullYear().toString() +
+    (date.getMonth() + 1).toString().padStart(2, "0") +
+    date.getDate().toString().padStart(2, "0");
+
+  const prefix = `T-${dateStr}-`;
+
+  // Find highest existing sequence number for this date prefix
+  const existing = db
+    .select({ id: tasks.id })
+    .from(tasks)
+    .all()
+    .filter((t) => t.id.startsWith(prefix))
+    .map((t) => {
+      const seq = parseInt(t.id.slice(prefix.length), 10);
+      return isNaN(seq) ? 0 : seq;
+    });
+
+  const nextSeq = existing.length > 0 ? Math.max(...existing) + 1 : 1;
+  return `${prefix}${nextSeq.toString().padStart(3, "0")}`;
+}

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

@@ -0,0 +1,47 @@
+import { NextRequest, NextResponse } from "next/server";
+import { synthesizeWithFallback } from "@/lib/tts";
+
+export const runtime = "nodejs";
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+
+    if (!body.text || typeof body.text !== "string") {
+      return NextResponse.json({ error: "text is required" }, { status: 400 });
+    }
+
+    const text = body.text.slice(0, 4000);
+    const provider = body.provider === "edge" ? "edge" : "google";
+
+    const result = await synthesizeWithFallback(
+      {
+        text,
+        voice: body.voice,
+        rate: body.rate,
+        pitch: body.pitch,
+        tone: body.tone,
+      },
+      provider as "google" | "edge"
+    );
+
+    // Convert Buffer to Uint8Array for NextResponse compatibility
+    const audioBytes = new Uint8Array(result.audio);
+    const headers: Record<string, string> = {
+      "Content-Type": result.contentType,
+      "Content-Length": String(result.audio.length),
+      "X-TTS-Requested": provider,
+      "X-TTS-Provider": result.actualProvider,
+    };
+    if (result.fallbackReason) {
+      headers["X-TTS-Fallback-Reason"] = result.fallbackReason.slice(0, 200);
+    }
+    return new NextResponse(audioBytes, { status: 200, headers });
+  } catch (err) {
+    console.error("POST /api/tts error:", err);
+    return NextResponse.json(
+      { error: "TTS synthesis failed" },
+      { status: 500 }
+    );
+  }
+}