@mndrk/agx 2.0.19 → 2.0.21

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/app/api/tasks/[id]/graph/schedule/route.ts

@@ -0,0 +1,216 @@
+import { NextRequest } from "next/server";
+import { z } from "zod";
+
+import {
+  ErrorResponseSchema,
+  GraphEnvelopeResponseSchema,
+} from "@/src/graph/api-schemas";
+import {
+  jsonWithSchema,
+  normalizeTaskId,
+  parseJsonBody,
+} from "@/src/graph/api-route-utils";
+import { authorizeGraphMutation } from "@/src/graph/middleware/authz";
+import {
+  activateGraphSchedule,
+  deactivateGraphSchedule,
+} from "@/src/graph/scheduler";
+import {
+  getActiveScheduleForRootMessageId,
+  getGraph,
+  updateGraphStructure,
+} from "@/src/graph/store";
+import type { ExecutionGraph } from "@/src/graph/types";
+
+interface RouteParams {
+  params: Promise<{ id: string }>;
+}
+
+const ScheduleRequestSchema = z.object({
+  intervalMs: z.number().int().positive().optional().default(60000),
+  cronExpr: z.string().trim().min(1).optional(),
+  cadence: z.string().trim().min(1).optional(),
+  name: z.string().trim().min(1).optional(),
+  description: z.string().trim().min(1).optional(),
+  resetNodeIds: z.array(z.string().trim().min(1)).optional(),
+  maxRuns: z.number().int().positive().optional(),
+  maxConsecutiveFailures: z.number().int().positive().optional(),
+  activeUntil: z.string().trim().min(1).optional(),
+  rootMessageId: z.string().trim().min(1).optional(),
+  ifMatchGraphVersion: z.number().int().positive().optional(),
+});
+
+function deriveDefaultResetNodeIds(graph: ExecutionGraph): string[] {
+  return Object.entries(graph.nodes)
+    .filter(([, node]) => node.type === "function" || node.type === "conditional")
+    .map(([nodeId]) => nodeId);
+}
+
+function persistGraphSchedule(
+  graph: ExecutionGraph,
+  ifMatchGraphVersion: number,
+): ExecutionGraph | null {
+  updateGraphStructure(
+    graph.id,
+    {
+      mode: graph.mode,
+      nodes: graph.nodes,
+      edges: graph.edges,
+      policy: graph.policy,
+      doneCriteria: graph.doneCriteria,
+      schedule: graph.schedule,
+    },
+    ifMatchGraphVersion,
+  );
+  return getGraph(graph.taskId);
+}
+
+export async function POST(request: NextRequest, { params }: RouteParams) {
+  const { id: rawTaskId } = await params;
+  const taskId = normalizeTaskId(rawTaskId);
+  if (!taskId) {
+    return jsonWithSchema(ErrorResponseSchema, { error: "Invalid task id" }, { status: 400 });
+  }
+
+  const parsedBody = await parseJsonBody(request, ScheduleRequestSchema);
+  if (!parsedBody.ok) {
+    return parsedBody.response;
+  }
+
+  const authz = await authorizeGraphMutation({
+    request,
+    taskId,
+    action: "update",
+  });
+  if (!authz.ok) {
+    return authz.response;
+  }
+
+  const graph = getGraph(taskId);
+  if (!graph) {
+    return jsonWithSchema(ErrorResponseSchema, { error: "Graph not found" }, { status: 404 });
+  }
+
+  const body = parsedBody.data;
+  if (body.rootMessageId) {
+    const active = getActiveScheduleForRootMessageId(body.rootMessageId);
+    if (active && active.graphId !== graph.id) {
+      return jsonWithSchema(
+        ErrorResponseSchema,
+        { error: `An active schedule already exists for rootMessageId "${body.rootMessageId}".` },
+        { status: 409 },
+      );
+    }
+  }
+
+  const resetNodeIds = body.resetNodeIds && body.resetNodeIds.length > 0
+    ? body.resetNodeIds
+    : deriveDefaultResetNodeIds(graph);
+
+  const scheduled = activateGraphSchedule(graph, {
+    intervalMs: body.intervalMs,
+    cronExpr: body.cronExpr,
+    cadence: body.cadence,
+    name: body.name,
+    description: body.description,
+    resetNodeIds,
+    maxRuns: body.maxRuns,
+    maxConsecutiveFailures: body.maxConsecutiveFailures,
+    activeUntil: body.activeUntil,
+    rootMessageId: body.rootMessageId,
+    nowIso: new Date().toISOString(),
+  });
+
+  if (scheduled === graph) {
+    return jsonWithSchema(GraphEnvelopeResponseSchema, { graph });
+  }
+
+  const ifMatch = body.ifMatchGraphVersion ?? graph.graphVersion;
+  const persisted = persistGraphSchedule(scheduled, ifMatch);
+  return jsonWithSchema(GraphEnvelopeResponseSchema, { graph: persisted ?? scheduled });
+}
+
+const PatchScheduleSchema = z.object({
+  action: z.enum(["pause", "resume"]),
+});
+
+export async function PATCH(request: NextRequest, { params }: RouteParams) {
+  const { id: rawTaskId } = await params;
+  const taskId = normalizeTaskId(rawTaskId);
+  if (!taskId) {
+    return jsonWithSchema(ErrorResponseSchema, { error: "Invalid task id" }, { status: 400 });
+  }
+
+  const parsedBody = await parseJsonBody(request, PatchScheduleSchema);
+  if (!parsedBody.ok) {
+    return parsedBody.response;
+  }
+
+  const authz = await authorizeGraphMutation({
+    request,
+    taskId,
+    action: "update",
+  });
+  if (!authz.ok) {
+    return authz.response;
+  }
+
+  const graph = getGraph(taskId);
+  if (!graph) {
+    return jsonWithSchema(ErrorResponseSchema, { error: "Graph not found" }, { status: 404 });
+  }
+
+  if (!graph.schedule) {
+    return jsonWithSchema(ErrorResponseSchema, { error: "No schedule on this graph" }, { status: 400 });
+  }
+
+  const { action } = parsedBody.data;
+  const newState = action === "pause" ? "paused" : "active";
+
+  if (graph.schedule.state === newState) {
+    return jsonWithSchema(GraphEnvelopeResponseSchema, { graph });
+  }
+
+  const updated: ExecutionGraph = {
+    ...graph,
+    schedule: {
+      ...graph.schedule,
+      state: newState as "active" | "paused",
+      // Clear failure count on resume
+      ...(action === "resume" ? { consecutiveFailures: 0 } : {}),
+    },
+  };
+
+  const persisted = persistGraphSchedule(updated, graph.graphVersion);
+  return jsonWithSchema(GraphEnvelopeResponseSchema, { graph: persisted ?? updated });
+}
+
+export async function DELETE(request: NextRequest, { params }: RouteParams) {
+  const { id: rawTaskId } = await params;
+  const taskId = normalizeTaskId(rawTaskId);
+  if (!taskId) {
+    return jsonWithSchema(ErrorResponseSchema, { error: "Invalid task id" }, { status: 400 });
+  }
+
+  const authz = await authorizeGraphMutation({
+    request,
+    taskId,
+    action: "update",
+  });
+  if (!authz.ok) {
+    return authz.response;
+  }
+
+  const graph = getGraph(taskId);
+  if (!graph) {
+    return jsonWithSchema(ErrorResponseSchema, { error: "Graph not found" }, { status: 404 });
+  }
+
+  const deactivated = deactivateGraphSchedule(graph);
+  if (deactivated === graph) {
+    return jsonWithSchema(GraphEnvelopeResponseSchema, { graph });
+  }
+
+  const persisted = persistGraphSchedule(deactivated, graph.graphVersion);
+  return jsonWithSchema(GraphEnvelopeResponseSchema, { graph: persisted ?? deactivated });
+}

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/app/api/threads/route.ts

@@ -0,0 +1,172 @@
+import { NextRequest } from "next/server";
+import { listRootMessages, getWorkspaceNames, updateMessageStatus, getMessageThread } from "@/lib/history-store";
+import type { ThreadStatus } from "@/lib/storage";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+const DEFAULT_LIMIT = 20;
+const MAX_LIMIT = 100;
+
+const VALID_STATUSES = new Set<ThreadStatus>([
+  "thinking",
+  "converged",
+  "resolved",
+  "in-review",
+  "archived",
+  "paused",
+]);
+
+function parseBoundedInt(value: string | null, fallback: number): number {
+  if (!value) return fallback;
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed)) return fallback;
+  return Math.min(Math.max(parsed, 1), MAX_LIMIT);
+}
+
+function formatTimestamp(ts: number): string {
+  return new Date(ts).toISOString().replace("T", " ").slice(0, 19);
+}
+
+function titleFromContent(content: string): string {
+  const plain = content
+    .replace(/\[agx:spawn\]\s*/g, "")
+    .replace(/\s*\[agx:exit:\d+\]\s*/g, "")
+    .replace(/\[reaction[^\]]*\]/g, "")
+    .replace(/\[SKIP\]/g, "")
+    .trim();
+  const firstLine = plain.split("\n")[0] || "(untitled)";
+  return firstLine.length > 80 ? firstLine.slice(0, 77) + "..." : firstLine;
+}
+
+interface ThreadEntry {
+  id: string;
+  threadId: string;
+  title: string;
+  status: string;
+  replyCount: number;
+  createdAt: number;
+  lastActivity: number;
+  outcomeNote: string | null;
+}
+
+interface WorkspaceGroup {
+  name: string;
+  threads: ThreadEntry[];
+}
+
+function groupByWorkspace(threads: ThreadEntry[], workspaceNames: Record<string, string>): Record<string, WorkspaceGroup> {
+  const groups: Record<string, WorkspaceGroup> = {};
+  for (const t of threads) {
+    const key = t.threadId || "(default)";
+    if (!groups[key]) {
+      groups[key] = { name: workspaceNames[key] || key, threads: [] };
+    }
+    groups[key].threads.push(t);
+  }
+  return groups;
+}
+
+function formatMarkdown(threads: ThreadEntry[], workspaceNames: Record<string, string>): string {
+  if (threads.length === 0) return "No threads found.";
+
+  const lines: string[] = [];
+  lines.push(`# Threads (${threads.length})`);
+  lines.push("");
+
+  const groups = groupByWorkspace(threads, workspaceNames);
+  for (const [, group] of Object.entries(groups)) {
+    lines.push(`## ${group.name}`);
+    lines.push("");
+    for (const t of group.threads) {
+      lines.push(`- **${t.title}**`);
+      lines.push(`  id: ${t.id}`);
+      lines.push(`  status: ${t.status}`);
+      lines.push(`  replies: ${t.replyCount}`);
+      lines.push(`  updated: ${formatTimestamp(t.lastActivity)}`);
+      if (t.outcomeNote) lines.push(`  outcome: ${t.outcomeNote}`);
+      lines.push("");
+    }
+  }
+
+  return lines.join("\n");
+}
+
+export async function PATCH(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const { rootMessageId, status, outcomeNote } = body;
+
+    if (!rootMessageId || !status) {
+      return Response.json({ error: "rootMessageId and status are required" }, { status: 400 });
+    }
+
+    if (!VALID_STATUSES.has(status as ThreadStatus)) {
+      return Response.json(
+        { error: `Invalid status. Valid values: ${[...VALID_STATUSES].join(", ")}` },
+        { status: 400 }
+      );
+    }
+
+    const thread = await getMessageThread(rootMessageId);
+    if (!thread) {
+      return Response.json({ error: "Thread not found" }, { status: 404 });
+    }
+
+    await updateMessageStatus(thread.threadId, rootMessageId, status, outcomeNote ?? null);
+
+    return Response.json({ ok: true, rootMessageId, status, outcomeNote: outcomeNote ?? null });
+  } catch (error) {
+    console.error("Error updating thread status:", error);
+    return Response.json({ error: "Failed to update thread status" }, { status: 500 });
+  }
+}
+
+export async function GET(request: NextRequest) {
+  try {
+    const { searchParams } = request.nextUrl;
+    const statusParam = searchParams.get("status")?.trim().toLowerCase();
+    const format = searchParams.get("format")?.trim().toLowerCase();
+
+    const limit = parseBoundedInt(searchParams.get("limit"), DEFAULT_LIMIT);
+    const offset = Math.max(0, Number.parseInt(searchParams.get("offset") ?? "0", 10) || 0);
+
+    if (statusParam && !VALID_STATUSES.has(statusParam as ThreadStatus)) {
+      return Response.json(
+        { error: `Invalid status. Valid values: ${[...VALID_STATUSES].join(", ")}` },
+        { status: 400 }
+      );
+    }
+
+    const { rows, total } = await listRootMessages({
+      status: statusParam || undefined,
+      limit,
+      offset,
+    });
+
+    const threads: ThreadEntry[] = rows.map((r) => ({
+      id: r.id,
+      threadId: r.thread_id,
+      title: titleFromContent(r.content),
+      status: r.thread_status ?? "thinking",
+      replyCount: r.reply_count,
+      createdAt: r.timestamp,
+      lastActivity: r.last_activity,
+      outcomeNote: r.outcome_note,
+    }));
+
+    const workspaceIds = [...new Set(threads.map((t) => t.threadId).filter(Boolean))];
+    const workspaceNames = await getWorkspaceNames(workspaceIds);
+
+    if (format === "json") {
+      return Response.json({ threads: groupByWorkspace(threads, workspaceNames), total, limit, offset });
+    }
+
+    return new Response(formatMarkdown(threads, workspaceNames), {
+      headers: { "Content-Type": "text/markdown; charset=utf-8" },
+    });
+  } catch (error) {
+    console.error("Error fetching threads:", error);
+    return Response.json({ error: "Failed to fetch threads" }, { status: 500 });
+  }
+}

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/app/automations/page.tsx

@@ -0,0 +1,46 @@
+"use client";
+
+import { useState, useEffect } from "react";
+import { WorkspaceSidebar } from "@/components/thread/WorkspaceSidebar";
+import {
+  loadWorkspaceSidebarVisible,
+  persistWorkspaceSidebarVisible,
+} from "@/state/uiSettings";
+import "@/styles/workspaceSidebar.css";
+import AutomationsBoard from "@/components/AutomationsBoard";
+
+export default function AutomationsPage() {
+  const [sidebarVisible, setSidebarVisible] = useState(false);
+
+  useEffect(() => {
+    setSidebarVisible(loadWorkspaceSidebarVisible());
+  }, []);
+
+  const toggleSidebar = () => {
+    setSidebarVisible((prev) => {
+      const next = !prev;
+      persistWorkspaceSidebarVisible(next);
+      return next;
+    });
+  };
+
+  return (
+    <div className="flex h-screen bg-white text-zinc-900">
+      <WorkspaceSidebar
+        threads={[]}
+        activeThreadId={null}
+        isLoading={false}
+        isCreating={false}
+        onSelectThread={() => {}}
+        onCreateThread={() => {}}
+        onRenameThread={() => {}}
+        onDeleteThread={() => {}}
+        visible={sidebarVisible}
+        onToggle={toggleSidebar}
+      />
+      <div className="flex-1 min-w-0 overflow-auto mt-4">
+        <AutomationsBoard />
+      </div>
+    </div>
+  );
+}

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/app/projects/[slug]/layout.tsx

@@ -4,7 +4,7 @@ import { useProjects } from "@/hooks/useProjects";
 import { usePathname, useRouter } from "next/navigation";
 import Link from "next/link";
 import { Suspense, use, useMemo, useState } from "react";
-import { PanelLeftClose, Hash, Minus, Plus, LayoutGrid } from "lucide-react";
+import { PanelLeftClose, Hash, Minus, Plus } from "lucide-react";
 import { useThreadState } from "@/hooks/useThreadState";
 import ProjectModal, { useProjectFormState, createProjectPayload } from "@/components/ProjectModal";
 import "@/styles/workspaceSidebar.css";
@@ -186,25 +186,6 @@ function ProjectLayoutContent({
                         })}
                     </div>
                 </nav>
-                <nav className="workspace-sidebar__section mt-4">
-                    <div className="workspace-sidebar__section-header">
-                        <span className="workspace-sidebar__section-label">
-                            Boards
-                        </span>
-                    </div>
-                    <div className="flex flex-col items-center py-4 px-3 text-center">
-                        <LayoutGrid size={20} className="text-slate-300 mb-1.5" />
-                        <p className="text-xs text-slate-400 mb-2">You have no boards</p>
-                        <Link
-                            href="/projects"
-                            onClick={() => setSidebarOpen(false)}
-                            className="inline-flex items-center gap-1.5 px-3 py-1.5 text-xs font-medium rounded-md bg-indigo-50 text-indigo-600 hover:bg-indigo-100 transition-colors"
-                        >
-                            <Plus size={12} />
-                            Create one
-                        </Link>
-                    </div>
-                </nav>
             </div>
             {/* Discord CTA */}
             <div className="mt-auto p-3">

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/app/projects/[slug]/page.tsx

@@ -10,6 +10,8 @@ import KanbanBoard from "@/components/KanbanBoard";
 import { Task } from "@/components/TaskCard";
 import NowRunningPanel from "@/components/NowRunningPanel";
 import { getCachedGraphSummary, prefetchGraphSummaries } from "@/hooks/useTaskGraphSummary";
+import DaemonBar from "@/components/DaemonBar";
+import { useProcessPolling } from "@/hooks/useProcessPolling";
 
 function fallbackV2Column(task: Task): "INTAKE" | "PROGRESS" | "DONE" {
     if (task.stage === "done" || task.status === "completed") {
@@ -50,6 +52,12 @@ export default function ProjectBoardPage({ params }: { params: Promise<{ slug: s
 
     const currentProject = projects.find((p) => p.slug === slug);
 
+    // Poll active agent processes for this project
+    const { processes: activeProcesses } = useProcessPolling(
+        currentProject ? { workspaceId: currentProject.id } : null,
+        { intervalMs: 3000 }
+    );
+
     // Filter tasks based on search query
     const filteredTasks = useMemo(() => {
         if (!searchQuery.trim()) return tasks;
@@ -214,10 +222,16 @@ export default function ProjectBoardPage({ params }: { params: Promise<{ slug: s
                 <p className="text-xs text-slate-400 px-6 py-1">{migrationNotice}</p>
             )}
 
+            {/* Daemon Status */}
+            <div className="flex-shrink-0 px-3 sm:px-6">
+                <DaemonBar />
+            </div>
+
             {/* Now Running Panel */}
             <div className="flex-shrink-0 px-3 sm:px-6">
                 <NowRunningPanel
                     tasks={filteredTasks}
+                    processes={activeProcesses}
                     onTaskClick={(task) => router.push(`/projects/${slug}/graph/${task.id}`)}
                     onStop={async (taskId) => {
                         await cancelWorkflow({ taskId });

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/app/thread/[id]/page.tsx

@@ -0,0 +1,9 @@
+"use client";
+
+import { use } from "react";
+import { ChatContainer } from "@/components/chat-ui/ChatContainer";
+
+export default function ThreadPage({ params }: { params: Promise<{ id: string }> }) {
+  const { id } = use(params);
+  return <ChatContainer initialRootMessageId={id} />;
+}