@mndrk/agx 2.0.18 → 2.0.20

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/app/api/agent-specs/pull/route.ts

@@ -0,0 +1,38 @@
+import { NextRequest } from "next/server";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+const AGX_API_URL = process.env.AGX_API_URL || "http://localhost:8080";
+
+/** GET /api/agent-specs/pull?code=XXXXXX — pull agent spec from agx-api */
+export async function GET(request: NextRequest) {
+  try {
+    const code = request.nextUrl.searchParams.get("code");
+    if (!code) {
+      return Response.json({ error: "code required" }, { status: 400 });
+    }
+
+    const res = await fetch(`${AGX_API_URL}/api/v1/agent/specs/pull?code=${encodeURIComponent(code)}`);
+
+    if (!res.ok) {
+      if (res.status === 404) {
+        return Response.json({ error: "Code not found or expired" }, { status: 404 });
+      }
+      const err = await res.text();
+      return Response.json({ error: `agx-api error: ${err}` }, { status: res.status });
+    }
+
+    const data = await res.json();
+    // data.payload is the AgentBundle JSON string — parse it
+    const bundle = typeof data.payload === "string" ? JSON.parse(data.payload) : data.payload;
+    return Response.json({
+      bundle,
+      expires_at: data.expires_at,
+      created_at: data.created_at,
+    });
+  } catch (error) {
+    console.error("Error pulling agent spec:", error);
+    return Response.json({ error: "Failed to pull" }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,76 @@
+import { NextRequest } from "next/server";
+import { loadParticipants } from "@/lib/participants-store";
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+const AGX_API_URL = process.env.AGX_API_URL || "http://localhost:8080";
+const AGENTS_DIR = join(homedir(), ".agx", "agents");
+
+function readSelfMd(agentId: string): string | null {
+  const selfPath = join(AGENTS_DIR, agentId, "self.md");
+  if (!existsSync(selfPath)) return null;
+  const raw = readFileSync(selfPath, "utf-8");
+  const match = raw.match(/^---[\s\S]*?---\s*\n?([\s\S]*)$/);
+  return match ? match[1].trim() : raw.trim();
+}
+
+/** POST /api/agent-specs — push agent(s) to agx-api, get share code */
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const agentIds: string[] = Array.isArray(body.agentIds) ? body.agentIds : [];
+    const includeSelf: boolean = body.includeSelf !== false;
+
+    if (agentIds.length === 0) {
+      return Response.json({ error: "No agents selected" }, { status: 400 });
+    }
+
+    const allParticipants = loadParticipants();
+    const selected = allParticipants.filter((p) => agentIds.includes(p.id));
+
+    const agents = selected.map((p) => ({
+      id: p.id,
+      name: p.name,
+      provider: p.provider,
+      model: p.model,
+      color: p.color,
+      identity: p.identity || null,
+      identityFile: p.identityFile || null,
+      skills: p.skills || [],
+      variables: p.variables || {},
+      self: includeSelf ? readSelfMd(p.id) : null,
+    }));
+
+    const payload = JSON.stringify({
+      version: 1,
+      exportedAt: new Date().toISOString(),
+      agents,
+      teams: [],
+    });
+
+    // Push to agx-api
+    const res = await fetch(`${AGX_API_URL}/api/v1/agent/specs`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-User-ID": body.userId || "anonymous",
+      },
+      body: JSON.stringify({ payload }),
+    });
+
+    if (!res.ok) {
+      const err = await res.text();
+      return Response.json({ error: `agx-api error: ${err}` }, { status: res.status });
+    }
+
+    const data = await res.json();
+    return Response.json(data);
+  } catch (error) {
+    console.error("Error sharing agent spec:", error);
+    return Response.json({ error: "Failed to share" }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,172 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { z } from 'zod';
+import { toCronExpr } from '@/src/graph/nl-schedule';
+import {
+  createGraph,
+  getGraph,
+} from '@/src/graph/store';
+import { activateGraphSchedule, type CreateGraphScheduleInput } from '@/src/graph/scheduler';
+import type { ExecutionGraph, FunctionNode } from '@/src/graph/types';
+import { createThreadMonitorSchedule } from '@/src/graph/schedule';
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+const CreateAutomationSchema = z.object({
+  /** Human-readable name for the automation */
+  name: z.string().trim().min(1),
+  /** Optional description */
+  description: z.string().trim().min(1).optional(),
+  /** Schedule cadence: cron expression or natural language (e.g. "every 2 hours") */
+  cadence: z.string().trim().min(1),
+  /** Optional: attach to existing task ID */
+  taskId: z.string().trim().min(1).optional(),
+  /** Optional: shell command to run on each tick */
+  command: z.string().trim().min(1).optional(),
+  /** Max number of runs */
+  maxRuns: z.number().int().positive().optional(),
+  /** Auto-pause after N consecutive failures */
+  maxConsecutiveFailures: z.number().int().positive().optional(),
+});
+
+/**
+ * POST /api/automations/create
+ *
+ * Create a new automation from natural language or cron expression.
+ * If no taskId is provided, creates a new minimal graph.
+ */
+export async function POST(request: NextRequest) {
+  try {
+    const rawBody = await request.json().catch(() => ({}));
+    const parsed = CreateAutomationSchema.safeParse(rawBody);
+    if (!parsed.success) {
+      return NextResponse.json(
+        { error: 'Invalid request', issues: parsed.error.issues },
+        { status: 400 },
+      );
+    }
+
+    const body = parsed.data;
+
+    // Parse cadence
+    const cronResult = toCronExpr(body.cadence);
+    if (!cronResult) {
+      return NextResponse.json(
+        { error: `Could not parse cadence: "${body.cadence}". Use a cron expression or natural language like "every 2 hours".` },
+        { status: 400 },
+      );
+    }
+
+    // If attaching to existing task
+    if (body.taskId) {
+      const graph = getGraph(body.taskId);
+      if (!graph) {
+        return NextResponse.json({ error: 'Task not found' }, { status: 404 });
+      }
+
+      const input: CreateGraphScheduleInput = {
+        intervalMs: 60_000, // fallback, cron takes precedence
+        cronExpr: cronResult.cronExpr,
+        cadence: cronResult.cadence,
+        name: body.name,
+        description: body.description,
+        resetNodeIds: Object.entries(graph.nodes)
+          .filter(([, n]) => n.type === 'function' || n.type === 'conditional')
+          .map(([id]) => id),
+        maxRuns: body.maxRuns,
+        maxConsecutiveFailures: body.maxConsecutiveFailures,
+      };
+
+      const scheduled = activateGraphSchedule(graph, input);
+      const { updateGraphStructure } = await import('@/src/graph/store');
+      updateGraphStructure(scheduled.id, {
+        mode: scheduled.mode,
+        nodes: scheduled.nodes,
+        edges: scheduled.edges,
+        policy: scheduled.policy,
+        doneCriteria: scheduled.doneCriteria,
+        schedule: scheduled.schedule,
+      }, graph.graphVersion);
+
+      const fresh = getGraph(body.taskId);
+      return NextResponse.json({
+        success: true,
+        taskId: body.taskId,
+        graphId: fresh?.id ?? scheduled.id,
+        schedule: fresh?.schedule ?? scheduled.schedule,
+      });
+    }
+
+    // Create a new minimal graph with a single function node
+    const now = new Date().toISOString();
+    const graphId = `auto-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const taskId = graphId;
+
+    const commandNode: FunctionNode = {
+      type: 'function',
+      status: 'pending',
+      deps: [],
+      kind: 'bash',
+      title: body.name,
+      command: body.command ?? 'echo "Automation tick"',
+    };
+
+    const resetNodeIds = ['run'];
+    const graph: ExecutionGraph = {
+      id: graphId,
+      taskId,
+      graphVersion: 1,
+      mode: 'SIMPLE',
+      nodes: {
+        run: commandNode,
+      },
+      edges: [],
+      policy: {
+        replanBudgetRemaining: 0,
+        replanBudgetInitial: 0,
+        verifyBudgetRemaining: 0,
+        verifyBudgetInitial: 0,
+        maxConcurrentAutoChecks: 0,
+        immutableRequiredGates: false,
+        maxConcurrent: 1,
+        priorityMode: 'fifo',
+        nodeTimeoutMs: 30_000,
+        graphTimeoutMs: 60_000,
+      },
+      doneCriteria: {
+        allRequiredGatesPassed: true,
+        noRunnableOrPendingWork: true,
+      },
+      schedule: {
+        ...createThreadMonitorSchedule(resetNodeIds, 60_000),
+        cronExpr: cronResult.cronExpr,
+        cadence: cronResult.cadence,
+        name: body.name,
+        description: body.description,
+        maxConsecutiveFailures: body.maxConsecutiveFailures,
+        consecutiveFailures: 0,
+        maxRuns: body.maxRuns,
+      },
+      versionHistory: [],
+      createdAt: now,
+      updatedAt: now,
+    };
+
+    createGraph(graph);
+
+    return NextResponse.json({
+      success: true,
+      created: true,
+      taskId,
+      graphId,
+      schedule: graph.schedule,
+      parsedCron: cronResult,
+    });
+  } catch (error) {
+    console.error('Create automation error:', error);
+    return NextResponse.json(
+      { error: 'Failed to create automation', message: error instanceof Error ? error.message : String(error) },
+      { status: 500 },
+    );
+  }
+}

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

@@ -0,0 +1,71 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getSQLiteDb } from '@/lib/sqlite-query-adapter';
+import type { GraphSchedule } from '@/src/graph/types';
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+interface ScheduleRow {
+  task_id: string;
+  id: string;
+  schedule: string;
+  execution_state: string;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface AutomationItem {
+  taskId: string;
+  graphId: string;
+  schedule: GraphSchedule;
+  executionState: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+/**
+ * GET /api/automations
+ * Lists all graphs that have schedules (active, paused, or stopped).
+ */
+export async function GET(request: NextRequest) {
+  try {
+    const stateFilter = request.nextUrl.searchParams.get('state');
+    const db = getSQLiteDb();
+
+    let query = `
+      SELECT task_id, id, schedule, execution_state, created_at, updated_at
+      FROM execution_graphs
+      WHERE schedule IS NOT NULL
+    `;
+    const params: string[] = [];
+
+    if (stateFilter) {
+      query += ` AND json_extract(schedule, '$.state') = ?`;
+      params.push(stateFilter);
+    }
+
+    query += ` ORDER BY updated_at DESC`;
+
+    const rows = db.prepare(query).all(...params) as ScheduleRow[];
+
+    const automations: AutomationItem[] = rows.map((row) => ({
+      taskId: row.task_id,
+      graphId: row.id,
+      schedule: JSON.parse(row.schedule) as GraphSchedule,
+      executionState: row.execution_state,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+    }));
+
+    return NextResponse.json({
+      count: automations.length,
+      automations,
+    });
+  } catch (error) {
+    console.error('Failed to list automations:', error);
+    return NextResponse.json(
+      { error: 'Failed to list automations', message: error instanceof Error ? error.message : String(error) },
+      { status: 500 },
+    );
+  }
+}

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

@@ -1,9 +1,16 @@
 import { NextRequest } from "next/server";
 import { loadParticipants } from "@/lib/participants-store";
-import { createMultiplexedStream } from "@/lib/stream-multiplexer";
+import {
+  createMultiplexedStream,
+  type StreamProjectContext,
+  type StreamProjectDetail,
+} from "@/lib/stream-multiplexer";
 import { loadHistory, saveMessages, sweepStaleWorkingReactions } from "@/lib/history-store";
 import { finalizeAttachments } from "@/lib/attachment-store";
 import { getSQLiteDb } from "@/lib/sqlite-query-adapter";
+import { db } from "@/lib/db-instance";
+import { LOCAL_USER } from "@/lib/auth-mode";
+import { deactivateSchedulesByRootMessageId } from "@/src/graph/store";
 import type { GroupMessage, Participant } from "@/lib/types";
 
 export const runtime = "nodejs";
@@ -17,11 +24,15 @@ interface ChatRequestBody {
   rootMessageId?: unknown;
   attachmentIds?: unknown;
   activeParticipantIds?: unknown;
+  projectSlug?: unknown;
+  role?: unknown;
+  agent?: unknown;
 }
 
 const MAX_HISTORY_CHARS = 200_000;
 const SUMMARY_MARKER = "<!-- thread-summary -->";
 const CHAT_MENTION_PATTERN = /@([A-Za-z0-9_-]+)/g;
+const PROJECT_MENTION_PATTERN = /@~project:([a-z0-9][a-z0-9-]*)/gi;
 
 type ParticipantNameMap = Record<string, { name: string }>;
 
@@ -200,6 +211,7 @@ function findReferencedRootIds(
   const referencedIds = new Set<string>();
   for (const token of mentionTokens) {
     if (participantTokens.has(token)) continue;
+    if (token.startsWith("project-")) continue;
     const rootId = lookup.get(token);
     if (rootId) {
       referencedIds.add(rootId);
@@ -256,6 +268,94 @@ function toActiveParticipantIds(input: unknown): string[] {
   return ids;
 }
 
+function normalizeProjectSlug(input: unknown): string {
+  if (typeof input !== "string") return "";
+  return input.trim().toLowerCase();
+}
+
+function findProjectMentionSlugs(prompt: string): string[] {
+  const slugs = new Set<string>();
+  for (const match of prompt.matchAll(PROJECT_MENTION_PATTERN)) {
+    const slug = normalizeProjectSlug(match[1]);
+    if (slug) slugs.add(slug);
+  }
+  return Array.from(slugs);
+}
+
+function toStreamProjectDetail(project: {
+  id: string;
+  slug: string;
+  name: string;
+  description?: string | null;
+  ci_cd_info?: string | null;
+  workflow_id?: string | null;
+  repos?: Array<{ name: string; path?: string | null; notes?: string | null }>;
+}): StreamProjectDetail {
+  return {
+    id: project.id,
+    slug: project.slug,
+    name: project.name,
+    description: project.description ?? null,
+    ciCdInfo: project.ci_cd_info ?? null,
+    workflowId: project.workflow_id ?? null,
+    repos: (project.repos ?? []).map((repo) => ({
+      name: repo.name,
+      path: repo.path ?? null,
+      notes: repo.notes ?? null,
+    })),
+  };
+}
+
+async function resolveProjectContext(
+  scopedProjectSlug: string,
+  mentionedProjectSlugs: string[]
+): Promise<StreamProjectContext | undefined> {
+  const slugsToFetch = new Set<string>();
+  if (scopedProjectSlug) slugsToFetch.add(scopedProjectSlug);
+  for (const slug of mentionedProjectSlugs) {
+    if (slug) slugsToFetch.add(slug);
+  }
+  if (slugsToFetch.size === 0) return undefined;
+
+  const rows = await Promise.all(
+    Array.from(slugsToFetch).map(async (slug) => {
+      try {
+        const project = await db.getProjectWithRepos(slug, LOCAL_USER.id);
+        return [slug, project] as const;
+      } catch (error) {
+        console.warn("Failed to load project context", { slug, error });
+        return [slug, null] as const;
+      }
+    })
+  );
+
+  const bySlug = new Map<string, NonNullable<(typeof rows)[number][1]>>();
+  for (const [slug, row] of rows) {
+    if (row) bySlug.set(slug, row);
+  }
+
+  const activeProject = scopedProjectSlug ? bySlug.get(scopedProjectSlug) : undefined;
+  const mentionedProjects = mentionedProjectSlugs
+    .map((slug) => bySlug.get(slug))
+    .filter((project): project is NonNullable<typeof project> => Boolean(project))
+    .map((project) => toStreamProjectDetail(project));
+
+  if (!activeProject && mentionedProjects.length === 0) {
+    return undefined;
+  }
+
+  return {
+    activeProject: activeProject
+      ? {
+          id: activeProject.id,
+          slug: activeProject.slug,
+          name: activeProject.name,
+        }
+      : undefined,
+    mentionedProjects: mentionedProjects.length > 0 ? mentionedProjects : undefined,
+  };
+}
+
 export async function POST(request: NextRequest) {
   const body = (await request.json().catch(() => ({}))) as ChatRequestBody;
   const prompt =
@@ -266,6 +366,7 @@ export async function POST(request: NextRequest) {
     typeof body.threadId === "string"
       ? body.threadId.trim()
       : "";
+  const scopedProjectSlug = normalizeProjectSlug(body.projectSlug);
 
   if (!threadId) {
     return new Response(JSON.stringify({ error: "threadId is required" }), {
@@ -281,6 +382,11 @@ export async function POST(request: NextRequest) {
     });
   }
 
+  const projectContext = await resolveProjectContext(
+    scopedProjectSlug,
+    findProjectMentionSlugs(prompt)
+  );
+
   const participantLibrary = loadParticipants();
   const hasActiveFilter = Array.isArray(body.activeParticipantIds);
   const requestedActiveIds = toActiveParticipantIds(body.activeParticipantIds);
@@ -320,7 +426,7 @@ export async function POST(request: NextRequest) {
     typeof body.userMessageId === "string"
       ? body.userMessageId.trim()
       : "";
-  const userMessageId = rawUserMessageId || `user-${now}`;
+  const userMessageId = rawUserMessageId || crypto.randomUUID();
   const explicitRootMessageId =
     typeof body.rootMessageId === "string"
       ? body.rootMessageId.trim() || null
@@ -357,10 +463,24 @@ export async function POST(request: NextRequest) {
 
   // Save user message — main chat messages are roots (depth 0, no rootMessageId),
   // thread replies reference their root.
+  const requestedRole = body.role === "agent" ? "assistant" : "user";
+  const requestedAgent =
+    requestedRole === "assistant" && typeof body.agent === "string"
+      ? body.agent.trim() || null
+      : null;
+  // Resolve agent participantId: match by slug/id against the participant library.
+  const resolvedParticipantId =
+    requestedRole === "assistant"
+      ? (requestedAgent
+          ? (participantLibrary.find(
+              (p) => p.id === requestedAgent || p.name.toLowerCase() === requestedAgent.toLowerCase()
+            )?.id ?? requestedAgent)
+          : allParticipants[0]?.id ?? null)
+      : null;
   const userMessage: GroupMessage = {
     id: userMessageId,
-    role: "user",
-    participantId: null,
+    role: requestedRole,
+    participantId: resolvedParticipantId,
     content: prompt,
     timestamp: now,
     rootMessageId: explicitRootMessageId,
@@ -369,6 +489,18 @@ export async function POST(request: NextRequest) {
   };
   await saveMessages(threadId, [userMessage]);
 
+  // Only deactivate ship mode when the USER sends a message, not agent-role steering
+  if (explicitRootMessageId && requestedRole === "user") {
+    try {
+      deactivateSchedulesByRootMessageId(explicitRootMessageId);
+    } catch (error) {
+      console.warn("Failed to deactivate autonomous schedule on user composer message", {
+        rootMessageId: explicitRootMessageId,
+        error,
+      });
+    }
+  }
+
   // Finalize attachments if provided
   const rawAttachmentIds = Array.isArray(body.attachmentIds) ? body.attachmentIds.filter((id): id is string => typeof id === "string") : [];
   let attachmentContext = "";
@@ -408,24 +540,35 @@ export async function POST(request: NextRequest) {
       content: m.content,
     }));
 
-  const stream = createMultiplexedStream({
+  // Fire-and-forget: kick off the multiplexer in the background.
+  // Messages and reactions are persisted to DB by the multiplexer;
+  // the client polls /api/history?since= to pick them up.
+  const streamPromise = createMultiplexedStream({
     threadId,
     allParticipants,
     mentioned,
     initialParallelIds: parallelMentioned,
     prompt: fullPrompt,
-    signal: request.signal,
+    projectContext,
+    signal: undefined,
     maxRounds,
     recentHistory: recentTargetableMessages,
     currentUserMessageId: userMessageId,
     rootMessageId: agentRootMessageId,
   });
 
-  return new Response(stream, {
-    headers: {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache",
-      Connection: "keep-alive",
-    },
-  });
+  // Drain the stream in the background so it runs to completion
+  void (async () => {
+    try {
+      const reader = streamPromise.getReader();
+      while (true) {
+        const { done } = await reader.read();
+        if (done) break;
+      }
+    } catch (err) {
+      console.error("[chat] background stream error:", err);
+    }
+  })();
+
+  return Response.json({ ok: true, userMessageId });
 }

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

@@ -0,0 +1,86 @@
+import { NextResponse } from "next/server";
+import { MAX_WORKERS, assertWorkerCount } from "@/lib/limits";
+import { getAll } from "@/lib/agent-process-registry";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+/**
+ * In-memory daemon state. This lives in the Next.js server process
+ * which IS the single coordinator (see docs/LIMITS.md).
+ */
+interface DaemonState {
+  running: boolean;
+  targetWorkers: number;
+  startedAt: string | null;
+}
+
+const state: DaemonState = {
+  running: false,
+  targetWorkers: 0,
+  startedAt: null,
+};
+
+/** Count processes currently running or spawning */
+function activeWorkerCount(): number {
+  return getAll().filter(
+    (p) => p.state === "running" || p.state === "spawning"
+  ).length;
+}
+
+/**
+ * GET /api/daemon — Check daemon status
+ */
+export async function GET() {
+  const active = activeWorkerCount();
+  return NextResponse.json({
+    running: state.running,
+    targetWorkers: state.targetWorkers,
+    activeWorkers: active,
+    maxWorkers: MAX_WORKERS,
+    startedAt: state.startedAt,
+  });
+}
+
+/**
+ * POST /api/daemon — Start or reconfigure the daemon
+ * Body: { workers: number } | { action: "stop" }
+ */
+export async function POST(req: Request) {
+  const body = await req.json();
+
+  // Stop action
+  if (body.action === "stop") {
+    state.running = false;
+    state.targetWorkers = 0;
+    state.startedAt = null;
+    return NextResponse.json({ running: false, targetWorkers: 0 });
+  }
+
+  // Start / reconfigure
+  const workers = typeof body.workers === "number" ? body.workers : 1;
+
+  try {
+    assertWorkerCount(workers);
+  } catch (err) {
+    return NextResponse.json(
+      { error: (err as Error).message },
+      { status: 400 }
+    );
+  }
+
+  const wasRunning = state.running;
+  state.running = true;
+  state.targetWorkers = workers;
+  if (!wasRunning) {
+    state.startedAt = new Date().toISOString();
+  }
+
+  return NextResponse.json({
+    running: true,
+    targetWorkers: state.targetWorkers,
+    activeWorkers: activeWorkerCount(),
+    maxWorkers: MAX_WORKERS,
+    startedAt: state.startedAt,
+  });
+}