@mndrk/agx 2.0.41 → 2.0.44

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

@@ -130,8 +130,8 @@ export async function POST(request: NextRequest) {
         immutableRequiredGates: false,
         maxConcurrent: 1,
         priorityMode: 'fifo',
-        nodeTimeoutMs: 30_000,
-        graphTimeoutMs: 60_000,
+        nodeTimeoutMs: 5 * 60_000,
+        graphTimeoutMs: 10 * 60_000,
       },
       doneCriteria: {
         allRequiredGatesPassed: true,

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

@@ -1,5 +1,11 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { getSQLiteDb } from '@/lib/sqlite-query-adapter';
+import {
+  automationRecordToGraphSchedule,
+  getAutomationRepository,
+  isAutomationDualReadEnabled,
+  isAutomationFrontmatterEnabled,
+} from '@/src/automations';
 import type { GraphSchedule } from '@/src/graph/types';
 
 export const runtime = 'nodejs';
@@ -31,31 +37,72 @@ export async function GET(request: NextRequest) {
   try {
     const stateFilter = request.nextUrl.searchParams.get('state');
     const db = getSQLiteDb();
-
-    let query = `
+    const rows = db.prepare(`
       SELECT task_id, id, schedule, execution_state, created_at, updated_at
       FROM execution_graphs
       WHERE schedule IS NOT NULL
-    `;
-    const params: string[] = [];
+      ORDER BY updated_at DESC
+    `).all() as unknown as ScheduleRow[];
+
+    const rowByGraphId = new Map(rows.map((row) => [row.id, row]));
+    const automationsByGraphId = new Map<string, AutomationItem>();
+
+    if (isAutomationFrontmatterEnabled()) {
+      for (const record of getAutomationRepository().listVisibleAutomations({
+        targetType: 'execution_graph',
+        ...(stateFilter ? { state: stateFilter as GraphSchedule['state'] } : {}),
+      })) {
+        if (record.definition.target.type !== 'execution_graph') {
+          continue;
+        }
 
-    if (stateFilter) {
-      query += ` AND json_extract(schedule, '$.state') = ?`;
-      params.push(stateFilter);
+        const graphId = record.definition.target.graphId ?? record.definition.id;
+        const legacyRow = rowByGraphId.get(graphId);
+        const taskId = record.definition.target.taskId ?? legacyRow?.task_id ?? graphId;
+        automationsByGraphId.set(graphId, {
+          taskId,
+          graphId,
+          schedule: automationRecordToGraphSchedule(record, legacyRow ? JSON.parse(legacyRow.schedule) as GraphSchedule : undefined),
+          executionState: legacyRow?.execution_state ?? 'ready',
+          createdAt: record.definition.createdAt ?? legacyRow?.created_at ?? record.runtimeState.updatedAt,
+          updatedAt: record.runtimeState.updatedAt,
+        });
+      }
+
+      if (!isAutomationDualReadEnabled()) {
+        const automations = [...automationsByGraphId.values()].sort((left, right) => (
+          Date.parse(right.updatedAt) - Date.parse(left.updatedAt)
+        ));
+        return NextResponse.json({
+          count: automations.length,
+          automations,
+        });
+      }
     }
 
-    query += ` ORDER BY updated_at DESC`;
+    for (const row of rows) {
+      if (automationsByGraphId.has(row.id)) {
+        continue;
+      }
+
+      const schedule = JSON.parse(row.schedule) as GraphSchedule;
+      if (stateFilter && schedule.state !== stateFilter) {
+        continue;
+      }
 
-    const rows = db.prepare(query).all(...params) as unknown as ScheduleRow[];
+      automationsByGraphId.set(row.id, {
+        taskId: row.task_id,
+        graphId: row.id,
+        schedule,
+        executionState: row.execution_state,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+      });
+    }
 
-    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,
-    }));
+    const automations = [...automationsByGraphId.values()].sort((left, right) => (
+      Date.parse(right.updatedAt) - Date.parse(left.updatedAt)
+    ));
 
     return NextResponse.json({
       count: automations.length,

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

@@ -1,5 +1,10 @@
 import { NextRequest } from "next/server";
 import { type StreamProjectContext, type StreamProjectDetail } from "@/lib/stream-multiplexer";
+import {
+  mergeComposerRouting,
+  normalizeComposerRouting,
+  orderParticipantIds,
+} from "@/lib/chat/composer-routing";
 import { loadDbParticipants } from "@/lib/agent-participants";
 import { createChatRun, loadHistory, saveMessages, sweepStaleWorkingReactions } from "@/lib/history-store";
 import { finalizeAttachments } from "@/lib/attachment-store";
@@ -31,6 +36,7 @@ interface ChatRequestBody {
   promptPrefix?: unknown;
   role?: unknown;
   agent?: unknown;
+  routing?: unknown;
 }
 
 const MAX_HISTORY_CHARS = 200_000;
@@ -468,8 +474,12 @@ export async function POST(request: NextRequest) {
   }
 
   const participantLibrary = await loadDbParticipants();
+  const routing = normalizeComposerRouting(body.routing);
   const hasActiveFilter = Array.isArray(body.activeParticipantIds);
-  const requestedActiveIds = toActiveParticipantIds(body.activeParticipantIds);
+  const requestedActiveIds = orderParticipantIds(
+    toActiveParticipantIds(body.activeParticipantIds),
+    routing.pinnedParticipantId
+  );
   const activeIdSet = hasActiveFilter ? new Set(requestedActiveIds) : null;
 
   const filteredParticipants =
@@ -485,16 +495,32 @@ export async function POST(request: NextRequest) {
 
   // @Name resolves against the full library (lets users wake an inactive agent).
   // @all only expands to the active participants — not the full library.
-  const { mentioned, parallel: parallelMentioned } = detectPromptMentions(prompt, participantLibrary, baseParticipants);
+  const {
+    mentioned,
+    parallel: parallelMentioned,
+  } = mergeComposerRouting(
+    detectPromptMentions(prompt, participantLibrary, baseParticipants),
+    routing
+  );
 
   const selectedIds = new Set(baseParticipants.map((participant) => participant.id));
   for (const id of mentioned) selectedIds.add(id);
 
+  const prioritizedActiveIds =
+    routing.mentionedParticipantIds.length > 0
+      ? [
+          ...routing.mentionedParticipantIds,
+          ...requestedActiveIds.filter(
+            (participantId) => !routing.mentionedParticipantIds.includes(participantId)
+          ),
+        ]
+      : requestedActiveIds;
+
   // Preserve activeParticipantIds order so the first (primary) agent in the
   // sidebar becomes allParticipants[0] — the default responder when no agent
   // is explicitly mentioned.
   const allParticipantsUnsorted = participantLibrary.filter((participant) => selectedIds.has(participant.id));
-  const orderIndex = new Map(requestedActiveIds.map((id, i) => [id, i]));
+  const orderIndex = new Map(prioritizedActiveIds.map((id, i) => [id, i]));
   const allParticipants = allParticipantsUnsorted.sort((a, b) => {
     const ai = orderIndex.get(a.id) ?? Number.MAX_SAFE_INTEGER;
     const bi = orderIndex.get(b.id) ?? Number.MAX_SAFE_INTEGER;

package/cloud-runtime/standalone/app/api/linear/auth/route.ts

@@ -0,0 +1,14 @@
+import { NextRequest, NextResponse } from "next/server";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+export async function GET(req: NextRequest) {
+  // Redirect to agx-web which owns the Linear OAuth credentials
+  const url = new URL(req.url);
+  const localPort = url.port || "3000";
+
+  return NextResponse.redirect(
+    `https://www.runagx.com/integrations/linear/auth?port=${localPort}`,
+  );
+}

package/cloud-runtime/standalone/app/api/linear/callback/route.ts

@@ -0,0 +1,43 @@
+import { NextRequest, NextResponse } from "next/server";
+import { saveLinearToken } from "@/lib/linear-client";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+export async function GET(req: NextRequest) {
+  const code = req.nextUrl.searchParams.get("code");
+  if (!code) {
+    return NextResponse.redirect("/?linear=error");
+  }
+
+  const clientId = process.env.LINEAR_CLIENT_ID;
+  const clientSecret = process.env.LINEAR_CLIENT_SECRET;
+  const redirectUri = `${process.env.NEXT_PUBLIC_APP_URL ?? "http://localhost:3000"}/api/linear/callback`;
+
+  const tokenRes = await fetch("https://api.linear.app/oauth/token", {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      grant_type: "authorization_code",
+      code,
+      client_id: clientId!,
+      client_secret: clientSecret!,
+      redirect_uri: redirectUri,
+    }),
+  });
+
+  if (!tokenRes.ok) {
+    return NextResponse.redirect("/?linear=error");
+  }
+
+  const data = await tokenRes.json();
+  saveLinearToken({
+    accessToken: data.access_token,
+    expiresAt: data.expires_in
+      ? Date.now() + data.expires_in * 1000
+      : undefined,
+  });
+
+  // Redirect back to the Linear tab
+  return NextResponse.redirect("/?linear=connected");
+}

package/cloud-runtime/standalone/app/api/linear/cycles/route.ts

@@ -0,0 +1,22 @@
+import { NextResponse } from "next/server";
+import { getLinearClient } from "@/lib/linear-client";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+export async function GET() {
+  const client = getLinearClient();
+  if (!client) {
+    return NextResponse.json({ error: "Not connected" }, { status: 401 });
+  }
+
+  try {
+    const cycles = await client.cycles();
+    return NextResponse.json({ cycles });
+  } catch (err: any) {
+    return NextResponse.json(
+      { error: err.message ?? "Failed to fetch cycles" },
+      { status: 500 },
+    );
+  }
+}

package/cloud-runtime/standalone/app/api/linear/issues/route.ts

@@ -0,0 +1,66 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getLinearClient } from "@/lib/linear-client";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+export async function GET(req: NextRequest) {
+  const client = getLinearClient();
+  if (!client) {
+    return NextResponse.json({ error: "Not connected" }, { status: 401 });
+  }
+
+  const params = req.nextUrl.searchParams;
+  const teamId = params.get("teamId") ?? undefined;
+  const status = params.get("status") ?? undefined;
+  const search = params.get("search") ?? undefined;
+  const cursor = params.get("cursor") ?? undefined;
+  const assignedToMe = params.get("assignedToMe") === "true";
+  const cycleId = params.get("cycleId") ?? undefined;
+  const limit = Number(params.get("limit") ?? "50");
+
+  try {
+    const filter: Record<string, unknown> = {};
+    if (teamId) filter.team = { id: { eq: teamId } };
+    if (status) filter.state = { name: { eqIgnoreCase: status } };
+    if (search) filter.searchableContent = { contains: search };
+    if (assignedToMe) filter.assignee = { isMe: { eq: true } };
+    if (cycleId) filter.cycle = { id: { eq: cycleId } };
+
+    const result = await client.issues({
+      first: limit,
+      after: cursor,
+      filter,
+      orderBy: "updatedAt" as any,
+    });
+
+    const issues = await Promise.all(
+      result.nodes.map(async (issue) => {
+        const state = await issue.state;
+        const assignee = await issue.assignee;
+        return {
+          id: issue.id,
+          identifier: issue.identifier,
+          title: issue.title,
+          url: issue.url,
+          status: state?.name ?? "Unknown",
+          assignee: assignee?.name ?? null,
+          updatedAt: issue.updatedAt,
+        };
+      }),
+    );
+
+    return NextResponse.json({
+      issues,
+      pageInfo: {
+        hasNextPage: result.pageInfo.hasNextPage,
+        endCursor: result.pageInfo.endCursor,
+      },
+    });
+  } catch (err: any) {
+    return NextResponse.json(
+      { error: err.message ?? "Failed to fetch issues" },
+      { status: 500 },
+    );
+  }
+}

package/cloud-runtime/standalone/app/api/linear/mcp-setup/route.ts

@@ -0,0 +1,181 @@
+import { NextRequest, NextResponse } from "next/server";
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import { parse as parseToml, stringify as stringifyToml } from "@iarna/toml";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+interface CliConfigInfo {
+  path: string;
+  read: () => Record<string, unknown>;
+  write: (config: Record<string, unknown>) => void;
+  hasLinearMcp: (config: Record<string, unknown>) => boolean;
+  addLinearMcp: (config: Record<string, unknown>) => Record<string, unknown>;
+  removeLinearMcp: (config: Record<string, unknown>) => Record<string, unknown>;
+}
+
+function getCliConfigInfo(cli: string): CliConfigInfo | null {
+  const home = homedir();
+
+  switch (cli) {
+    case "claude": {
+      const configPath = path.join(home, ".claude", "settings.json");
+      return {
+        path: configPath,
+        read: () => {
+          if (!existsSync(configPath)) return {};
+          return JSON.parse(readFileSync(configPath, "utf8")) as Record<string, unknown>;
+        },
+        write: (config) => {
+          writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+        },
+        hasLinearMcp: (config) => {
+          const servers = config.mcpServers as Record<string, unknown> | undefined;
+          return !!servers?.linear;
+        },
+        addLinearMcp: (config) => {
+          const servers = (config.mcpServers ?? {}) as Record<string, unknown>;
+          servers.linear = { type: "url", url: "https://mcp.linear.app/sse" };
+          return { ...config, mcpServers: servers };
+        },
+        removeLinearMcp: (config) => {
+          const servers = config.mcpServers as Record<string, unknown> | undefined;
+          if (servers?.linear) delete servers.linear;
+          return config;
+        },
+      };
+    }
+
+    case "gemini": {
+      const configPath = path.join(home, ".gemini", "settings.json");
+      return {
+        path: configPath,
+        read: () => {
+          if (!existsSync(configPath)) return {};
+          return JSON.parse(readFileSync(configPath, "utf8")) as Record<string, unknown>;
+        },
+        write: (config) => {
+          writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+        },
+        hasLinearMcp: (config) => {
+          const servers = config.mcpServers as Record<string, unknown> | undefined;
+          return !!servers?.linear;
+        },
+        addLinearMcp: (config) => {
+          const servers = (config.mcpServers ?? {}) as Record<string, unknown>;
+          servers.linear = { type: "url", url: "https://mcp.linear.app/sse" };
+          return { ...config, mcpServers: servers };
+        },
+        removeLinearMcp: (config) => {
+          const servers = config.mcpServers as Record<string, unknown> | undefined;
+          if (servers?.linear) delete servers.linear;
+          return config;
+        },
+      };
+    }
+
+    case "codex": {
+      const configPath = path.join(home, ".codex", "config.toml");
+      return {
+        path: configPath,
+        read: () => {
+          if (!existsSync(configPath)) return {};
+          return parseToml(readFileSync(configPath, "utf8")) as Record<string, unknown>;
+        },
+        write: (config) => {
+          writeFileSync(configPath, stringifyToml(config as Parameters<typeof stringifyToml>[0]) + "\n");
+        },
+        hasLinearMcp: (config) => {
+          const servers = config.mcp_servers as Record<string, unknown> | undefined;
+          return !!servers?.linear;
+        },
+        addLinearMcp: (config) => {
+          const servers = (config.mcp_servers ?? {}) as Record<string, unknown>;
+          servers.linear = { url: "https://mcp.linear.app/mcp" };
+          return { ...config, mcp_servers: servers };
+        },
+        removeLinearMcp: (config) => {
+          const servers = config.mcp_servers as Record<string, unknown> | undefined;
+          if (servers?.linear) delete servers.linear;
+          return config;
+        },
+      };
+    }
+
+    default:
+      return null;
+  }
+}
+
+// GET: Check MCP config status for each CLI
+export async function GET() {
+  const results: Record<string, boolean> = {};
+
+  for (const cli of ["claude", "codex", "gemini"]) {
+    const info = getCliConfigInfo(cli);
+    if (!info) {
+      results[cli] = false;
+      continue;
+    }
+    try {
+      const config = info.read();
+      results[cli] = info.hasLinearMcp(config);
+    } catch {
+      results[cli] = false;
+    }
+  }
+
+  return NextResponse.json({ configured: results });
+}
+
+// POST: Configure MCP for a specific CLI
+export async function POST(request: NextRequest) {
+  const body = (await request.json()) as { cli: string };
+  const { cli } = body;
+
+  if (!cli) {
+    return NextResponse.json({ error: "Missing cli parameter" }, { status: 400 });
+  }
+
+  const info = getCliConfigInfo(cli);
+  if (!info) {
+    return NextResponse.json(
+      { error: `MCP configuration not supported for ${cli} yet` },
+      { status: 400 }
+    );
+  }
+
+  try {
+    const config = info.read();
+    const updated = info.addLinearMcp(config);
+    info.write(updated);
+
+    return NextResponse.json({ ok: true });
+  } catch (e) {
+    const message = e instanceof Error ? e.message : "Failed to write config";
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}
+
+// DELETE: Remove Linear MCP config from a specific CLI
+export async function DELETE(request: NextRequest) {
+  const body = (await request.json()) as { cli: string };
+  const { cli } = body;
+
+  const info = getCliConfigInfo(cli);
+  if (!info) {
+    return NextResponse.json({ error: `Unsupported CLI: ${cli}` }, { status: 400 });
+  }
+
+  try {
+    const config = info.read();
+    const updated = info.removeLinearMcp(config);
+    info.write(updated);
+    return NextResponse.json({ ok: true });
+  } catch (e) {
+    const message = e instanceof Error ? e.message : "Failed to update config";
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}

package/cloud-runtime/standalone/app/api/linear/runs/[id]/route.ts

@@ -0,0 +1,81 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getLinearRun, updateLinearRun, type LinearRunStatus } from "@/lib/linear-run-store";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+type RouteContext = { params: Promise<{ id: string }> };
+
+interface UpdateLinearRunBody {
+  rootMessageId?: unknown;
+  chatRunId?: unknown;
+  status?: unknown;
+  error?: unknown;
+}
+
+function toOptionalString(value: unknown): string | null | undefined {
+  if (value === undefined) return undefined;
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+
+function toStatus(value: unknown): LinearRunStatus | undefined {
+  if (
+    value === "queued" ||
+    value === "running" ||
+    value === "success" ||
+    value === "failed" ||
+    value === "cancelled"
+  ) {
+    return value;
+  }
+  return undefined;
+}
+
+export async function GET(_request: NextRequest, context: RouteContext) {
+  try {
+    const { id } = await context.params;
+    const run = await getLinearRun(id);
+    if (!run) {
+      return NextResponse.json({ error: "Linear run not found" }, { status: 404 });
+    }
+    return NextResponse.json({ run });
+  } catch (error) {
+    console.error("Failed to load Linear run:", error);
+    return NextResponse.json(
+      {
+        error: "Failed to load Linear run",
+        message: error instanceof Error ? error.message : String(error),
+      },
+      { status: 500 }
+    );
+  }
+}
+
+export async function PATCH(request: NextRequest, context: RouteContext) {
+  try {
+    const { id } = await context.params;
+    const body = (await request.json().catch(() => ({}))) as UpdateLinearRunBody;
+    const run = await updateLinearRun({
+      id,
+      rootMessageId: toOptionalString(body.rootMessageId),
+      chatRunId: toOptionalString(body.chatRunId),
+      status: toStatus(body.status),
+      error: toOptionalString(body.error),
+    });
+
+    if (!run) {
+      return NextResponse.json({ error: "Linear run not found" }, { status: 404 });
+    }
+
+    return NextResponse.json({ run });
+  } catch (error) {
+    console.error("Failed to update Linear run:", error);
+    return NextResponse.json(
+      {
+        error: "Failed to update Linear run",
+        message: error instanceof Error ? error.message : String(error),
+      },
+      { status: 500 }
+    );
+  }
+}

package/cloud-runtime/standalone/app/api/linear/runs/route.ts

@@ -0,0 +1,91 @@
+import { NextRequest, NextResponse } from "next/server";
+import { createLinearRun, listLinearRuns } from "@/lib/linear-run-store";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+interface CreateLinearRunBody {
+  projectId?: unknown;
+  projectSlug?: unknown;
+  issueId?: unknown;
+  issueIdentifier?: unknown;
+  issueTitle?: unknown;
+  issueStatus?: unknown;
+  issueAssignee?: unknown;
+  agentId?: unknown;
+  agentName?: unknown;
+}
+
+function toOptionalString(value: unknown): string | null {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+
+export async function GET(request: NextRequest) {
+  try {
+    const issueId = request.nextUrl.searchParams.get("issueId")?.trim();
+    const projectId = request.nextUrl.searchParams.get("projectId")?.trim() ?? null;
+    const limitParam = request.nextUrl.searchParams.get("limit");
+    const limit = limitParam ? Number.parseInt(limitParam, 10) : undefined;
+
+    if (!issueId) {
+      return NextResponse.json({ error: "issueId is required" }, { status: 400 });
+    }
+
+    const runs = await listLinearRuns({ issueId, projectId, limit });
+    return NextResponse.json({ count: runs.length, runs });
+  } catch (error) {
+    console.error("Failed to list Linear runs:", error);
+    return NextResponse.json(
+      {
+        error: "Failed to list Linear runs",
+        message: error instanceof Error ? error.message : String(error),
+      },
+      { status: 500 }
+    );
+  }
+}
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = (await request.json().catch(() => ({}))) as CreateLinearRunBody;
+    const issueId = toOptionalString(body.issueId);
+    const issueIdentifier = toOptionalString(body.issueIdentifier);
+    const issueTitle = toOptionalString(body.issueTitle);
+    const issueStatus = toOptionalString(body.issueStatus);
+    const agentId = toOptionalString(body.agentId);
+    const agentName = toOptionalString(body.agentName);
+
+    if (!issueId || !issueIdentifier || !issueTitle || !issueStatus || !agentId || !agentName) {
+      return NextResponse.json(
+        {
+          error:
+            "issueId, issueIdentifier, issueTitle, issueStatus, agentId, and agentName are required",
+        },
+        { status: 400 }
+      );
+    }
+
+    const run = await createLinearRun({
+      projectId: toOptionalString(body.projectId),
+      projectSlug: toOptionalString(body.projectSlug),
+      issueId,
+      issueIdentifier,
+      issueTitle,
+      issueStatus,
+      issueAssignee: toOptionalString(body.issueAssignee),
+      agentId,
+      agentName,
+    });
+
+    return NextResponse.json({ run }, { status: 201 });
+  } catch (error) {
+    console.error("Failed to create Linear run:", error);
+    return NextResponse.json(
+      {
+        error: "Failed to create Linear run",
+        message: error instanceof Error ? error.message : String(error),
+      },
+      { status: 500 }
+    );
+  }
+}