@mndrk/agx 2.3.3 → 2.4.2

package/cloud-runtime/standalone/apps/local/app/api/{linear → trackers/[tracker]}/runs/scripted/route.ts

@@ -1,5 +1,5 @@
 import { NextRequest, NextResponse } from "next/server";
-import { startScriptedLinearSession } from "@/lib/linear-scripted-session";
+import "@/lib/tracker"; // Ensure adapters are registered
 
 export const runtime = "nodejs";
 export const dynamic = "force-dynamic";
@@ -8,7 +8,11 @@ function toOptionalString(value: unknown): string | null {
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
 
-export async function POST(request: NextRequest) {
+export async function POST(
+  request: NextRequest,
+  { params }: { params: Promise<{ tracker: string }> }
+) {
+  const { tracker } = await params;
   try {
     const body = (await request.json().catch(() => ({}))) as Record<string, unknown>;
     const issueId = toOptionalString(body.issueId);
@@ -27,7 +31,10 @@ export async function POST(request: NextRequest) {
       );
     }
 
-    const result = await startScriptedLinearSession({
+    // Delegate to the scripted session starter, which is tracker-aware
+    const { startScriptedTrackerSession } = await import("@/lib/tracker/scripted-session");
+    const result = await startScriptedTrackerSession({
+      trackerType: tracker,
       projectId: toOptionalString(body.projectId),
       projectSlug: toOptionalString(body.projectSlug),
       issue: {
@@ -44,15 +51,15 @@ export async function POST(request: NextRequest) {
 
     return NextResponse.json(result, { status: 201 });
   } catch (error) {
-    console.error("Failed to start scripted Linear session:", error);
+    console.error("Failed to start scripted tracker session:", error);
     return NextResponse.json(
       {
         error:
           error instanceof Error
             ? error.message
-            : "Failed to start scripted Linear session",
+            : "Failed to start scripted tracker session",
       },
       { status: 500 }
     );
   }
-}
+}

package/cloud-runtime/standalone/apps/local/app/api/trackers/[tracker]/status/route.ts

@@ -0,0 +1,48 @@
+import { NextRequest, NextResponse } from "next/server";
+import "@/lib/tracker"; // Ensure adapters are registered
+import { resolveAdapter, badRequest } from "@/lib/tracker/route-helpers";
+import { commandExists } from "@/lib/shell-env";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+export async function GET(
+  req: NextRequest,
+  { params }: { params: Promise<{ tracker: string }> }
+) {
+  const { tracker } = await params;
+  const projectId = req.nextUrl.searchParams.get("projectId")?.trim();
+  if (!projectId) return badRequest("projectId required");
+
+  const adapter = resolveAdapter(tracker);
+  const status = await adapter.getStatus(projectId);
+
+  return NextResponse.json({
+    provider: tracker,
+    connected: status.connected,
+    user: status.user,
+    clis: {
+      claude: commandExists("claude"),
+      codex: commandExists("codex"),
+      gemini: commandExists("gemini"),
+    },
+  });
+}
+
+export async function DELETE(
+  req: NextRequest,
+  { params }: { params: Promise<{ tracker: string }> }
+) {
+  const { tracker } = await params;
+  const projectId = req.nextUrl.searchParams.get("projectId")?.trim();
+  if (!projectId) return badRequest("projectId required");
+
+  const adapter = resolveAdapter(tracker);
+  await adapter.disconnect(projectId);
+
+  // Remove from connection manifest
+  const { removeTrackerConnection } = await import("@/lib/tracker/connections");
+  removeTrackerConnection(projectId, tracker);
+
+  return NextResponse.json({ disconnected: true });
+}

package/cloud-runtime/standalone/apps/local/app/api/trackers/[tracker]/token/route.ts

@@ -0,0 +1,49 @@
+import { NextRequest, NextResponse } from "next/server";
+import "@/lib/tracker";
+import { resolveAdapter, badRequest } from "@/lib/tracker/route-helpers";
+import { addTrackerConnection } from "@/lib/tracker/connections";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+export async function POST(
+  req: NextRequest,
+  { params }: { params: Promise<{ tracker: string }> }
+) {
+  const { tracker } = await params;
+  const body = (await req.json().catch(() => ({}))) as {
+    projectId?: string;
+    accessToken?: string;
+  };
+
+  const projectId = body.projectId?.trim();
+  const accessToken = body.accessToken?.trim();
+
+  if (!projectId) return badRequest("projectId required");
+  if (!accessToken) return badRequest("accessToken required");
+
+  const adapter = resolveAdapter(tracker);
+
+  if (!adapter.handleApiKeyConnect) {
+    return NextResponse.json(
+      { error: `${adapter.displayName} does not support API key authentication` },
+      { status: 400 }
+    );
+  }
+
+  try {
+    await adapter.handleApiKeyConnect(projectId, accessToken);
+  } catch (err) {
+    return NextResponse.json(
+      { error: err instanceof Error ? err.message : "Failed to save token" },
+      { status: 400 }
+    );
+  }
+
+  addTrackerConnection(projectId, {
+    type: tracker,
+    connectedAt: new Date().toISOString(),
+  });
+
+  return NextResponse.json({ ok: true });
+}

package/cloud-runtime/standalone/apps/local/app/api/trackers/[tracker]/token-receive/route.ts

@@ -0,0 +1,52 @@
+import { NextRequest, NextResponse } from "next/server";
+import "@/lib/tracker";
+import { resolveAdapter } from "@/lib/tracker/route-helpers";
+import { addTrackerConnection } from "@/lib/tracker/connections";
+import { getConfiguredAppBaseUrl } from "@/lib/app-config";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+const AUTH_PROJECT_COOKIE = "agx-tracker-auth-project";
+
+function redirect(path: string) {
+  return NextResponse.redirect(new URL(path, getConfiguredAppBaseUrl()));
+}
+
+export async function GET(
+  req: NextRequest,
+  { params }: { params: Promise<{ tracker: string }> }
+) {
+  const { tracker } = await params;
+  const projectId = req.cookies.get(AUTH_PROJECT_COOKIE)?.value?.trim();
+
+  if (!projectId) {
+    return redirect("/?tracker=error&reason=missing_project");
+  }
+
+  const adapter = resolveAdapter(tracker);
+
+  if (!adapter.handleTokenDelivery) {
+    return redirect("/?tracker=error&reason=unsupported");
+  }
+
+  const tokenParams: Record<string, string> = {};
+  for (const [key, value] of req.nextUrl.searchParams.entries()) {
+    tokenParams[key] = value;
+  }
+
+  try {
+    await adapter.handleTokenDelivery(projectId, tokenParams);
+
+    addTrackerConnection(projectId, {
+      type: tracker,
+      connectedAt: new Date().toISOString(),
+    });
+
+    const response = redirect("/?tracker=connected");
+    response.cookies.delete(AUTH_PROJECT_COOKIE);
+    return response;
+  } catch {
+    return redirect(`/?${tracker}=error`);
+  }
+}

package/cloud-runtime/standalone/apps/local/app/api/trackers/[tracker]/worker/route.ts

@@ -0,0 +1,163 @@
+import { NextRequest, NextResponse } from "next/server";
+import "@/lib/tracker"; // Ensure adapters are registered
+import { getPromptJobStore } from "@/src/prompt-scheduler/get-store";
+import {
+  TASK_WORKER_JOB_NAME,
+  TASK_WORKER_DEFAULT_PROMPT,
+  TASK_WORKER_DEFAULT_CADENCE,
+  findTaskWorkerJob,
+} from "@/src/prompt-scheduler/task-worker-job";
+import {
+  computePrevRun,
+  parseCadence,
+} from "@/src/prompt-scheduler/cron";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+/**
+ * GET /api/trackers/[tracker]/worker
+ * Return the current task worker config (the prompt job with executionMode === 'task_worker').
+ */
+export async function GET(
+  req: NextRequest,
+  { params }: { params: Promise<{ tracker: string }> }
+) {
+  const { tracker: _tracker } = await params;
+  try {
+    const projectId = req.nextUrl.searchParams.get("projectId") ?? undefined;
+    const job = findTaskWorkerJob(projectId);
+
+    if (!job) {
+      return NextResponse.json({ job: null });
+    }
+
+    const cronExpr = job.cronExpr || job.cadence;
+    const prevScheduledAt = cronExpr ? computePrevRun(cronExpr) : null;
+
+    return NextResponse.json({ job: { ...job, prevScheduledAt } });
+  } catch (error) {
+    console.error("Failed to get task worker:", error);
+    return NextResponse.json(
+      { error: "Failed to get task worker", message: error instanceof Error ? error.message : String(error) },
+      { status: 500 }
+    );
+  }
+}
+
+/**
+ * POST /api/trackers/[tracker]/worker
+ * Create or update the task worker prompt job.
+ */
+export async function POST(
+  req: NextRequest,
+  { params }: { params: Promise<{ tracker: string }> }
+) {
+  const { tracker: _tracker } = await params;
+  try {
+    const body = await req.json();
+    const {
+      projectId,
+      prompt,
+      scriptPrompt,
+      cadence,
+      agentId,
+      provider,
+      model,
+      state,
+      teamId,
+    } = body;
+
+    const store = getPromptJobStore();
+    const existing = findTaskWorkerJob(projectId);
+
+    if (existing) {
+      // Update existing
+      const updates: Record<string, unknown> = {};
+      if (typeof prompt === "string") updates.prompt = prompt;
+      if (typeof scriptPrompt === "string") updates.scriptPrompt = scriptPrompt;
+      if (typeof teamId === "string") updates.teamId = teamId;
+      if (typeof agentId === "string") updates.agentId = agentId;
+      if (typeof provider === "string") updates.provider = provider;
+      if (typeof model === "string") updates.model = model;
+      if (typeof state === "string") updates.state = state;
+
+      if (typeof cadence === "string" && cadence.trim()) {
+        const parsed = parseCadence(cadence.trim());
+        if (parsed) {
+          updates.cadence = parsed.cadence;
+          updates.cronExpr = parsed.cronExpr;
+        } else {
+          return NextResponse.json(
+            { error: `Could not parse cadence: "${cadence}"` },
+            { status: 400 }
+          );
+        }
+      }
+
+      const job = store.updateJob(existing.id, updates);
+      return NextResponse.json({ job });
+    }
+
+    // Create new
+    const resolvedPrompt = typeof prompt === "string" && prompt.trim()
+      ? prompt
+      : TASK_WORKER_DEFAULT_PROMPT;
+
+    const resolvedCadence = typeof cadence === "string" && cadence.trim()
+      ? cadence
+      : TASK_WORKER_DEFAULT_CADENCE;
+
+    const job = store.createJob({
+      name: TASK_WORKER_JOB_NAME,
+      prompt: resolvedPrompt,
+      scriptPrompt: typeof scriptPrompt === "string" ? scriptPrompt : undefined,
+      teamId: typeof teamId === "string" ? teamId : undefined,
+      executionMode: "task_worker",
+      projectId: projectId || undefined,
+      builtIn: true,
+      cadence: resolvedCadence,
+      provider: provider ?? "claude",
+      model,
+      agentId,
+    });
+
+    return NextResponse.json({ job }, { status: 201 });
+  } catch (error) {
+    console.error("Failed to create/update task worker:", error);
+    return NextResponse.json(
+      { error: "Failed to create/update task worker", message: error instanceof Error ? error.message : String(error) },
+      { status: 500 }
+    );
+  }
+}
+
+/**
+ * DELETE /api/trackers/[tracker]/worker
+ * Remove/disable the task worker.
+ */
+export async function DELETE(
+  req: NextRequest,
+  { params }: { params: Promise<{ tracker: string }> }
+) {
+  const { tracker: _tracker } = await params;
+  try {
+    const projectId = req.nextUrl.searchParams.get("projectId") ?? undefined;
+    const store = getPromptJobStore();
+    const existing = findTaskWorkerJob(projectId);
+
+    if (!existing) {
+      return NextResponse.json({ error: "Task worker not found" }, { status: 404 });
+    }
+
+    // Pause instead of deleting since it's a built-in job
+    const job = store.updateJob(existing.id, { state: "paused" });
+    return NextResponse.json({ success: true, job });
+  } catch (error) {
+    console.error("Failed to disable task worker:", error);
+    return NextResponse.json(
+      { error: "Failed to disable task worker", message: error instanceof Error ? error.message : String(error) },
+      { status: 500 }
+    );
+  }
+}

package/cloud-runtime/standalone/apps/local/app/api/trackers/connections/route.ts

@@ -0,0 +1,96 @@
+import { NextRequest, NextResponse } from "next/server";
+import { listTrackerConnections, addTrackerConnection, removeTrackerConnection } from "@/lib/tracker/connections";
+import { getAdapterOrNull, listAdapters } from "@/lib/tracker/registry";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+export async function GET(req: NextRequest) {
+  const projectId = req.nextUrl.searchParams.get("projectId")?.trim();
+  if (!projectId) {
+    return NextResponse.json({ error: "projectId required" }, { status: 400 });
+  }
+
+  const connections = listTrackerConnections(projectId);
+  const registeredTypes = new Set(connections.map((c) => c.type));
+
+  // Auto-register any adapter that has a valid token but no registry entry (migration path)
+  const allAdapters = listAdapters();
+  await Promise.all(
+    allAdapters
+      .filter((adapter) => !registeredTypes.has(adapter.type))
+      .map(async (adapter) => {
+        try {
+          const status = await adapter.getStatus(projectId);
+          if (status.connected) {
+            addTrackerConnection(projectId, {
+              type: adapter.type,
+              connectedAt: new Date().toISOString(),
+            });
+            connections.push({ type: adapter.type, connectedAt: new Date().toISOString() });
+          }
+        } catch {
+          // ignore — token absent or invalid
+        }
+      })
+  );
+
+  // Enrich with live status
+  const enriched = await Promise.all(
+    connections.map(async (conn) => {
+      const adapter = getAdapterOrNull(conn.type);
+      if (!adapter) return { ...conn, connected: false };
+      try {
+        const status = await adapter.getStatus(projectId);
+        return { ...conn, connected: status.connected, user: status.user };
+      } catch {
+        return { ...conn, connected: false };
+      }
+    })
+  );
+
+  return NextResponse.json({ connections: enriched });
+}
+
+export async function POST(req: NextRequest) {
+  const body = (await req.json().catch(() => ({}))) as {
+    projectId?: string;
+    type?: string;
+  };
+
+  const projectId = body.projectId?.trim();
+  const type = body.type?.trim();
+
+  if (!projectId || !type) {
+    return NextResponse.json({ error: "projectId and type required" }, { status: 400 });
+  }
+
+  const adapter = getAdapterOrNull(type);
+  if (!adapter) {
+    return NextResponse.json({ error: `Unknown tracker type: ${type}` }, { status: 400 });
+  }
+
+  addTrackerConnection(projectId, {
+    type,
+    connectedAt: new Date().toISOString(),
+  });
+
+  return NextResponse.json({ ok: true, type });
+}
+
+export async function DELETE(req: NextRequest) {
+  const body = (await req.json().catch(() => ({}))) as {
+    projectId?: string;
+    type?: string;
+  };
+
+  const projectId = body.projectId?.trim();
+  const type = body.type?.trim();
+
+  if (!projectId || !type) {
+    return NextResponse.json({ error: "projectId and type required" }, { status: 400 });
+  }
+
+  removeTrackerConnection(projectId, type);
+  return NextResponse.json({ ok: true });
+}

package/cloud-runtime/standalone/apps/local/app/api/update-check/route.ts

@@ -0,0 +1,50 @@
+import { NextResponse } from "next/server";
+import { spawnSync } from "child_process";
+import { buildSpawnEnv } from "@/lib/shell-env";
+import { SHELL_COMMAND_TIMEOUT_MS } from "@/lib/constants/timing";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+function parseVersion(raw: string): string | null {
+  // agx --version outputs e.g. "agx/1.2.3 darwin-arm64 node-v20"
+  const match = raw.match(/agx\/(\S+)/);
+  return match ? match[1] : null;
+}
+
+export async function GET() {
+  let latestVersion: string | null = null;
+  let currentVersion: string | null = null;
+
+  try {
+    const res = await fetch("https://registry.npmjs.org/agx/latest", {
+      signal: AbortSignal.timeout(SHELL_COMMAND_TIMEOUT_MS),
+    });
+    if (res.ok) {
+      const data = (await res.json()) as { version: string };
+      latestVersion = data.version;
+    }
+  } catch {
+    // fail silently
+  }
+
+  try {
+    const result = spawnSync("agx", ["--version"], {
+      encoding: "utf8",
+      timeout: SHELL_COMMAND_TIMEOUT_MS,
+      env: buildSpawnEnv(),
+    });
+    if (result.status === 0) {
+      currentVersion = parseVersion(result.stdout.trim());
+    }
+  } catch {
+    // fail silently
+  }
+
+  const updateAvailable =
+    latestVersion !== null &&
+    currentVersion !== null &&
+    latestVersion !== currentVersion;
+
+  return NextResponse.json({ updateAvailable, latestVersion, currentVersion });
+}

package/cloud-runtime/standalone/apps/local/app/projects/[slug]/layout.tsx

@@ -105,7 +105,7 @@ function ProjectLayoutContent({
     [pathname]
   );
 
-  const { show: stageShow } = useSidebarStage(currentProject);
+  const { show: stageShow, trackerConnections } = useSidebarStage(currentProject);
 
   const toggleSidebar = () => {
     const next = !sidebarVisible;
@@ -171,6 +171,7 @@ function ProjectLayoutContent({
         activeProjectId={currentProject.id}
         activeProjectView={activeProjectView}
         stageShow={stageShow}
+        trackerConnections={trackerConnections}
         onUpdateParticipant={async (participant) => {
           const response = await fetch("/api/participants", {
             method: "PATCH",

package/cloud-runtime/standalone/apps/local/app/projects/[slug]/terminal/page.tsx

@@ -1,11 +1,14 @@
 "use client";
 
+import { Suspense } from "react";
 import ProjectTerminal from "@/components/terminal/ProjectTerminal";
 
 export default function TerminalPage() {
   return (
     <div className="flex flex-col h-full min-h-0 overflow-hidden">
-      <ProjectTerminal />
+      <Suspense>
+        <ProjectTerminal />
+      </Suspense>
     </div>
   );
 }

package/cloud-runtime/standalone/apps/local/app/projects/[slug]/{linear → tracking/[tracker]}/page.tsx

@@ -3,24 +3,29 @@
 import { use } from "react";
 import { useSearchParams } from "next/navigation";
 import { useProjects } from "@/hooks/useProjects";
-import LinearBoard from "@/components/LinearBoard";
+import TrackerBoard from "@/components/TrackerBoard";
 
-export default function ProjectLinearPage({
+/**
+ * Tracker-specific board page.
+ * Renders the tracker-agnostic TrackerBoard for any connected tracker type.
+ */
+export default function ProjectTrackerPage({
   params,
 }: {
-  params: Promise<{ slug: string }>;
+  params: Promise<{ slug: string; tracker: string }>;
 }) {
-  const { slug } = use(params);
+  const { slug, tracker } = use(params);
   const searchParams = useSearchParams();
   const { projects } = useProjects();
   const project = projects.find((p) => p.slug === slug);
   const showSettings = searchParams.get("settings") === "true";
 
   return (
-    <LinearBoard
+    <TrackerBoard
+      trackerType={tracker}
       projectId={project?.id}
       projectSlug={project?.slug ?? slug}
       initialShowSettings={showSettings}
     />
   );
-}
+}