stagent 0.1.0

package/src/app/api/uploads/route.ts

@@ -0,0 +1,66 @@
+import { NextRequest, NextResponse } from "next/server";
+import { writeFile, mkdir } from "fs/promises";
+import { join } from "path";
+import { db } from "@/lib/db";
+import { documents } from "@/lib/db/schema";
+import { processDocument } from "@/lib/documents/processor";
+import { getStagentUploadsDir } from "@/lib/utils/stagent-paths";
+
+const UPLOAD_DIR = getStagentUploadsDir();
+
+export async function POST(req: NextRequest) {
+  const formData = await req.formData();
+  const file = formData.get("file") as File | null;
+  const taskId = formData.get("taskId") as string | null;
+
+  if (!file) {
+    return NextResponse.json({ error: "No file provided" }, { status: 400 });
+  }
+
+  if (file.size > 50 * 1024 * 1024) {
+    return NextResponse.json({ error: "File too large (max 50MB)" }, { status: 400 });
+  }
+
+  await mkdir(UPLOAD_DIR, { recursive: true });
+
+  const id = crypto.randomUUID();
+  const ext = file.name.split(".").pop() ?? "";
+  const filename = ext ? `${id}.${ext}` : id;
+  const filepath = join(UPLOAD_DIR, filename);
+
+  const bytes = new Uint8Array(await file.arrayBuffer());
+  await writeFile(filepath, bytes);
+
+  // Create document record in DB
+  await db.insert(documents).values({
+    id,
+    taskId: taskId ?? null,
+    projectId: null,
+    filename,
+    originalName: file.name,
+    mimeType: file.type || "application/octet-stream",
+    size: file.size,
+    storagePath: filepath,
+    direction: "input",
+    status: "uploaded",
+    createdAt: new Date(),
+    updatedAt: new Date(),
+  });
+
+  // Fire-and-forget: trigger async document processing
+  processDocument(id).catch((err) =>
+    console.error(`[upload] Processing failed for ${id}:`, err)
+  );
+
+  return NextResponse.json(
+    {
+      id,
+      filename,
+      originalName: file.name,
+      size: file.size,
+      type: file.type,
+      taskId,
+    },
+    { status: 201 }
+  );
+}

package/src/app/api/workflows/[id]/execute/route.ts

@@ -0,0 +1,82 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db } from "@/lib/db";
+import { workflows } from "@/lib/db/schema";
+import { eq, and } from "drizzle-orm";
+import { executeWorkflow } from "@/lib/workflows/engine";
+import type { WorkflowDefinition } from "@/lib/workflows/types";
+
+export async function POST(
+  _req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+
+  const [workflow] = await db
+    .select()
+    .from(workflows)
+    .where(eq(workflows.id, id));
+
+  if (!workflow) {
+    return NextResponse.json({ error: "Workflow not found" }, { status: 404 });
+  }
+
+  if (workflow.status === "active") {
+    return NextResponse.json(
+      { error: "Workflow is already running" },
+      { status: 409 }
+    );
+  }
+
+  // Re-run: reset state for completed/failed workflows
+  if (workflow.status === "completed" || workflow.status === "failed") {
+    try {
+      const def = JSON.parse(workflow.definition) as WorkflowDefinition & {
+        _state?: unknown;
+        _loopState?: unknown;
+      };
+      delete def._state;
+      delete def._loopState;
+
+      await db
+        .update(workflows)
+        .set({
+          definition: JSON.stringify(def),
+          status: "draft",
+          updatedAt: new Date(),
+        })
+        .where(eq(workflows.id, id));
+    } catch {
+      return NextResponse.json(
+        { error: "Failed to reset workflow state" },
+        { status: 500 }
+      );
+    }
+  }
+
+  // Atomic claim: transition to "active" only if still in draft state.
+  // Prevents concurrent double-execution from parallel requests.
+  const claimResult = db
+    .update(workflows)
+    .set({ status: "active", updatedAt: new Date() })
+    .where(
+      and(
+        eq(workflows.id, id),
+        eq(workflows.status, "draft")
+      )
+    )
+    .run();
+
+  if (claimResult.changes === 0) {
+    return NextResponse.json(
+      { error: "Workflow is already running" },
+      { status: 409 }
+    );
+  }
+
+  // Fire-and-forget execution
+  executeWorkflow(id).catch((error) => {
+    console.error(`Workflow ${id} execution failed:`, error);
+  });
+
+  return NextResponse.json({ status: "started", workflowId: id }, { status: 202 });
+}

package/src/app/api/workflows/[id]/route.ts

@@ -0,0 +1,133 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db } from "@/lib/db";
+import { workflows } from "@/lib/db/schema";
+import { eq } from "drizzle-orm";
+import type { WorkflowDefinition } from "@/lib/workflows/types";
+import { validateWorkflowDefinitionAssignments } from "@/lib/agents/profiles/assignment-validation";
+import { validateWorkflowDefinition } from "@/lib/workflows/definition-validation";
+
+export async function PATCH(
+  req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+  const body = await req.json();
+  const { status, name, definition } = body as {
+    status?: string;
+    name?: string;
+    definition?: WorkflowDefinition;
+  };
+
+  const [workflow] = await db
+    .select()
+    .from(workflows)
+    .where(eq(workflows.id, id));
+
+  if (!workflow) {
+    return NextResponse.json({ error: "Workflow not found" }, { status: 404 });
+  }
+
+  // Edit name/definition — draft only
+  if (name !== undefined || definition !== undefined) {
+    if (workflow.status !== "draft") {
+      return NextResponse.json(
+        { error: "Can only edit draft workflows" },
+        { status: 409 }
+      );
+    }
+
+    const updates: Record<string, unknown> = { updatedAt: new Date() };
+
+    if (name !== undefined) {
+      if (!name.trim()) {
+        return NextResponse.json({ error: "Name is required" }, { status: 400 });
+      }
+      updates.name = name.trim();
+    }
+
+    if (definition !== undefined) {
+      const definitionError = validateWorkflowDefinition(definition);
+      if (definitionError) {
+        return NextResponse.json(
+          { error: definitionError },
+          { status: 400 }
+        );
+      }
+
+      const compatibilityError =
+        validateWorkflowDefinitionAssignments(definition);
+      if (compatibilityError) {
+        return NextResponse.json(
+          { error: compatibilityError },
+          { status: 400 }
+        );
+      }
+      updates.definition = JSON.stringify(definition);
+    }
+
+    await db.update(workflows).set(updates).where(eq(workflows.id, id));
+
+    const [updated] = await db.select().from(workflows).where(eq(workflows.id, id));
+    return NextResponse.json(updated);
+  }
+
+  // Status transitions
+  if (!status) {
+    return NextResponse.json({ error: "status, name, or definition is required" }, { status: 400 });
+  }
+
+  if (status === "paused") {
+    if (workflow.status !== "active") {
+      return NextResponse.json(
+        { error: "Can only pause an active workflow" },
+        { status: 409 }
+      );
+    }
+
+    await db
+      .update(workflows)
+      .set({ status: "paused", updatedAt: new Date() })
+      .where(eq(workflows.id, id));
+
+    return NextResponse.json({ id, status: "paused" });
+  }
+
+  if (status === "active") {
+    return NextResponse.json(
+      { error: "Use POST /api/workflows/[id]/execute to resume a workflow" },
+      { status: 400 }
+    );
+  }
+
+  return NextResponse.json(
+    { error: `Invalid status transition: ${status}` },
+    { status: 400 }
+  );
+}
+
+export async function DELETE(
+  _req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+
+  const [workflow] = await db
+    .select()
+    .from(workflows)
+    .where(eq(workflows.id, id));
+
+  if (!workflow) {
+    return NextResponse.json({ error: "Workflow not found" }, { status: 404 });
+  }
+
+  if (workflow.status === "active") {
+    return NextResponse.json(
+      { error: "Cannot delete an active workflow — pause or wait for completion" },
+      { status: 409 }
+    );
+  }
+
+  await db.delete(workflows).where(eq(workflows.id, id));
+
+  return NextResponse.json({ deleted: true });
+}

package/src/app/api/workflows/[id]/status/route.ts

@@ -0,0 +1,54 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db } from "@/lib/db";
+import { workflows } from "@/lib/db/schema";
+import { eq } from "drizzle-orm";
+import { parseWorkflowState } from "@/lib/workflows/engine";
+
+export async function GET(
+  _req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+
+  const [workflow] = await db
+    .select()
+    .from(workflows)
+    .where(eq(workflows.id, id));
+
+  if (!workflow) {
+    return NextResponse.json({ error: "Workflow not found" }, { status: 404 });
+  }
+
+  const { definition, state, loopState } = parseWorkflowState(workflow.definition);
+
+  // Loop pattern returns loop-specific data instead of step states
+  if (definition.pattern === "loop") {
+    return NextResponse.json({
+      id: workflow.id,
+      name: workflow.name,
+      status: workflow.status,
+      projectId: workflow.projectId,
+      definition: workflow.definition,
+      pattern: definition.pattern,
+      loopConfig: definition.loopConfig,
+      swarmConfig: definition.swarmConfig,
+      loopState,
+      steps: definition.steps,
+    });
+  }
+
+  return NextResponse.json({
+    id: workflow.id,
+    name: workflow.name,
+    status: workflow.status,
+    projectId: workflow.projectId,
+    definition: workflow.definition,
+    pattern: definition.pattern,
+    swarmConfig: definition.swarmConfig,
+    steps: definition.steps.map((step, i) => ({
+      ...step,
+      state: state?.stepStates[i] ?? { stepId: step.id, status: "pending" },
+    })),
+    workflowState: state,
+  });
+}

package/src/app/api/workflows/[id]/steps/[stepId]/retry/route.ts

@@ -0,0 +1,22 @@
+import { NextRequest, NextResponse } from "next/server";
+import { retryWorkflowStep } from "@/lib/workflows/engine";
+
+export async function POST(
+  _req: NextRequest,
+  {
+    params,
+  }: {
+    params: Promise<{ id: string; stepId: string }>;
+  }
+) {
+  const { id, stepId } = await params;
+
+  retryWorkflowStep(id, stepId).catch((error) => {
+    console.error(`Workflow ${id} step ${stepId} retry failed:`, error);
+  });
+
+  return NextResponse.json(
+    { status: "retry_started", workflowId: id, stepId },
+    { status: 202 }
+  );
+}

package/src/app/api/workflows/route.ts

@@ -0,0 +1,61 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db } from "@/lib/db";
+import { workflows } from "@/lib/db/schema";
+import { desc, eq } from "drizzle-orm";
+import type { WorkflowDefinition } from "@/lib/workflows/types";
+import { validateWorkflowDefinitionAssignments } from "@/lib/agents/profiles/assignment-validation";
+import { validateWorkflowDefinition } from "@/lib/workflows/definition-validation";
+
+export async function GET() {
+  const result = await db
+    .select()
+    .from(workflows)
+    .orderBy(desc(workflows.createdAt));
+
+  return NextResponse.json(result);
+}
+
+export async function POST(req: NextRequest) {
+  const body = await req.json();
+  const { name, projectId, definition: rawDefinition } = body as {
+    name?: string;
+    projectId?: string;
+    definition?: WorkflowDefinition;
+  };
+
+  if (!name?.trim()) {
+    return NextResponse.json({ error: "Name is required" }, { status: 400 });
+  }
+  const definitionError = rawDefinition
+    ? validateWorkflowDefinition(rawDefinition)
+    : "Definition must include pattern and at least one step";
+  if (definitionError) {
+    return NextResponse.json(
+      { error: definitionError },
+      { status: 400 }
+    );
+  }
+
+  const definition = rawDefinition as WorkflowDefinition;
+  const compatibilityError = validateWorkflowDefinitionAssignments(definition);
+  if (compatibilityError) {
+    return NextResponse.json({ error: compatibilityError }, { status: 400 });
+  }
+
+  const id = crypto.randomUUID();
+  const now = new Date();
+
+  await db.insert(workflows).values({
+    id,
+    name: name.trim(),
+    projectId: projectId || null,
+    definition: JSON.stringify(definition),
+    status: "draft",
+    createdAt: now,
+    updatedAt: now,
+  });
+
+  const [created] = await db.select().from(workflows).where(eq(workflows.id, id));
+
+  return NextResponse.json(created, { status: 201 });
+}

package/src/app/apple-icon.tsx

@@ -0,0 +1,31 @@
+import { ImageResponse } from "next/og";
+import { readFileSync } from "fs";
+import { join } from "path";
+
+export const size = { width: 180, height: 180 };
+export const contentType = "image/png";
+
+export default function AppleIcon() {
+  const logoData = readFileSync(join(process.cwd(), "public/stagent-s-128.png"));
+  const logoSrc = `data:image/png;base64,${logoData.toString("base64")}`;
+
+  return new ImageResponse(
+    (
+      <div
+        style={{
+          width: "100%",
+          height: "100%",
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "center",
+          background: "#0f172a",
+          borderRadius: "36px",
+        }}
+      >
+        {/* eslint-disable-next-line @next/next/no-img-element */}
+        <img src={logoSrc} width="130" height="130" alt="" />
+      </div>
+    ),
+    { ...size }
+  );
+}

package/src/app/costs/page.tsx

@@ -0,0 +1,256 @@
+import { listRuntimeCatalog } from "@/lib/agents/runtime/catalog";
+import { CostDashboard } from "@/components/costs/cost-dashboard";
+import { getBudgetGuardrailSnapshot } from "@/lib/settings/budget-guardrails";
+import {
+  getDailySpendTotals,
+  getDailyTokenTotals,
+  getProviderModelBreakdown,
+  listUsageAuditEntries,
+  type ProviderModelBreakdownEntry,
+  type UsageActivityType,
+  type UsageLedgerStatus,
+} from "@/lib/usage/ledger";
+
+export const dynamic = "force-dynamic";
+
+const runtimeCatalog = listRuntimeCatalog();
+const validRuntimeIds = new Set<string>(runtimeCatalog.map((runtime) => runtime.id));
+const validDateRanges = new Set(["7d", "30d", "90d", "all"]);
+const validStatuses = new Set<UsageLedgerStatus>([
+  "completed",
+  "failed",
+  "cancelled",
+  "blocked",
+  "unknown_pricing",
+]);
+const validActivityTypes = new Set<UsageActivityType>([
+  "task_run",
+  "task_resume",
+  "workflow_step",
+  "scheduled_firing",
+  "task_assist",
+  "profile_test",
+]);
+
+function toScalar(value: string | string[] | undefined) {
+  return Array.isArray(value) ? value[0] : value;
+}
+
+function resolveDateRange(value: string | undefined) {
+  return value && validDateRanges.has(value) ? value : "30d";
+}
+
+function resolveRuntime(value: string | undefined) {
+  return value && validRuntimeIds.has(value) ? value : "all";
+}
+
+function resolveStatus(value: string | undefined) {
+  return value && validStatuses.has(value as UsageLedgerStatus) ? value : "all";
+}
+
+function resolveActivityType(value: string | undefined) {
+  return value && validActivityTypes.has(value as UsageActivityType) ? value : "all";
+}
+
+function getRangeStart(range: string) {
+  if (range === "all") {
+    return undefined;
+  }
+
+  const now = new Date();
+  const days =
+    range === "7d"
+      ? 7
+      : range === "90d"
+        ? 90
+        : 30;
+  const start = new Date(now);
+  start.setHours(0, 0, 0, 0);
+  start.setDate(start.getDate() - (days - 1));
+  return start;
+}
+
+function startOfCurrentMonth() {
+  const now = new Date();
+  return new Date(now.getFullYear(), now.getMonth(), 1);
+}
+
+function buildDateKeys(days: number) {
+  const dates: string[] = [];
+  for (let i = days - 1; i >= 0; i--) {
+    const date = new Date();
+    date.setHours(0, 0, 0, 0);
+    date.setDate(date.getDate() - i);
+    dates.push(
+      new Intl.DateTimeFormat("en-CA", {
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+      }).format(date)
+    );
+  }
+  return dates;
+}
+
+function fillSeries<T extends { day: string }>(
+  days: number,
+  rows: T[],
+  getValue: (row: T) => number
+) {
+  const keys = buildDateKeys(days);
+  const values = new Map(rows.map((row) => [row.day, getValue(row)]));
+  return keys.map((key) => values.get(key) ?? 0);
+}
+
+function findOverallSpend(
+  statuses: Array<{
+    scopeId: string;
+    window: string;
+    metric: string;
+    currentValue: number;
+  }>,
+  window: "daily" | "monthly"
+) {
+  return (
+    statuses.find(
+      (status) =>
+        status.scopeId === "overall" &&
+        status.window === window &&
+        status.metric === "spend"
+    )?.currentValue ?? 0
+  );
+}
+
+function buildRuntimeBreakdown(
+  rows: ProviderModelBreakdownEntry[]
+): Array<{
+  runtimeId: string;
+  label: string;
+  providerId: string;
+  costMicros: number;
+  totalTokens: number;
+  runs: number;
+  share: number;
+  unknownPricingRuns: number;
+}> {
+  const totals = new Map<
+    string,
+    {
+      runtimeId: string;
+      label: string;
+      providerId: string;
+      costMicros: number;
+      totalTokens: number;
+      runs: number;
+      unknownPricingRuns: number;
+    }
+  >();
+
+  for (const row of rows) {
+    const current = totals.get(row.runtimeId) ?? {
+      runtimeId: row.runtimeId,
+      label:
+        runtimeCatalog.find((runtime) => runtime.id === row.runtimeId)?.label ??
+        row.runtimeId,
+      providerId: row.providerId,
+      costMicros: 0,
+      totalTokens: 0,
+      runs: 0,
+      unknownPricingRuns: 0,
+    };
+
+    current.costMicros += row.costMicros;
+    current.totalTokens += row.totalTokens;
+    current.runs += row.runs;
+    current.unknownPricingRuns += row.unknownPricingRuns;
+    totals.set(row.runtimeId, current);
+  }
+
+  const totalCost = Array.from(totals.values()).reduce(
+    (sum, row) => sum + row.costMicros,
+    0
+  );
+
+  return Array.from(totals.values())
+    .map((row) => ({
+      ...row,
+      share: totalCost > 0 ? (row.costMicros / totalCost) * 100 : 0,
+    }))
+    .sort((left, right) => right.costMicros - left.costMicros);
+}
+
+export default async function CostsPage({
+  searchParams,
+}: {
+  searchParams: Promise<{
+    range?: string | string[];
+    runtime?: string | string[];
+    status?: string | string[];
+    activity?: string | string[];
+  }>;
+}) {
+  const params = await searchParams;
+  const dateRange = resolveDateRange(toScalar(params.range));
+  const runtimeId = resolveRuntime(toScalar(params.runtime));
+  const status = resolveStatus(toScalar(params.status));
+  const activityType = resolveActivityType(toScalar(params.activity));
+
+  const rangeStart = getRangeStart(dateRange);
+  const [spendRows30, tokenRows30, monthBreakdown, filteredBreakdown, auditEntries, budgetSnapshot] =
+    await Promise.all([
+      getDailySpendTotals(30),
+      getDailyTokenTotals(30),
+      getProviderModelBreakdown({ startedAt: startOfCurrentMonth() }),
+      getProviderModelBreakdown(
+        rangeStart ? { startedAt: rangeStart } : undefined
+      ),
+      listUsageAuditEntries({
+        limit: 100,
+        runtimeIds: runtimeId === "all" ? undefined : [runtimeId],
+        statuses: status === "all" ? undefined : [status as UsageLedgerStatus],
+        activityTypes:
+          activityType === "all"
+            ? undefined
+            : [activityType as UsageActivityType],
+        startedAt: rangeStart,
+      }),
+      getBudgetGuardrailSnapshot(),
+    ]);
+
+  const spendSeries30 = fillSeries(30, spendRows30, (row) => row.costMicros);
+  const tokenSeries30 = fillSeries(30, tokenRows30, (row) => row.totalTokens);
+  const runtimeBreakdown = buildRuntimeBreakdown(filteredBreakdown);
+  const monthTokens = monthBreakdown.reduce(
+    (sum, row) => sum + row.totalTokens,
+    0
+  );
+
+  return (
+    <div className="gradient-neutral min-h-screen p-6">
+      <CostDashboard
+        filters={{
+          dateRange,
+          runtimeId,
+          status,
+          activityType,
+        }}
+        summary={{
+          todaySpendMicros: findOverallSpend(budgetSnapshot.statuses, "daily"),
+          monthSpendMicros: findOverallSpend(budgetSnapshot.statuses, "monthly"),
+          todayTokens: tokenSeries30[tokenSeries30.length - 1] ?? 0,
+          monthTokens,
+        }}
+        trendSeries={{
+          spend7: spendSeries30.slice(-7),
+          spend30: spendSeries30,
+          tokens7: tokenSeries30.slice(-7),
+          tokens30: tokenSeries30,
+        }}
+        budgetStatuses={budgetSnapshot.statuses}
+        runtimeBreakdown={runtimeBreakdown}
+        modelBreakdown={filteredBreakdown}
+        auditEntries={auditEntries}
+      />
+    </div>
+  );
+}