stagent 0.6.2 → 0.7.0

package/src/app/api/tasks/[id]/siblings/route.ts

@@ -0,0 +1,48 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db } from "@/lib/db";
+import { tasks } from "@/lib/db/schema";
+import { eq, and, ne, isNull } from "drizzle-orm";
+
+export async function GET(
+  _req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+
+  const [task] = await db
+    .select({
+      workflowId: tasks.workflowId,
+      workflowRunNumber: tasks.workflowRunNumber,
+    })
+    .from(tasks)
+    .where(eq(tasks.id, id));
+
+  if (!task || !task.workflowId) {
+    return NextResponse.json([]);
+  }
+  // Match siblings by workflowId + workflowRunNumber.
+  // For pre-existing tasks (workflowRunNumber is NULL), match all tasks
+  // in the same workflow that also have NULL workflowRunNumber.
+  const runCondition = task.workflowRunNumber != null
+    ? eq(tasks.workflowRunNumber, task.workflowRunNumber)
+    : isNull(tasks.workflowRunNumber);
+
+  const siblings = await db
+    .select({
+      id: tasks.id,
+      title: tasks.title,
+      status: tasks.status,
+      createdAt: tasks.createdAt,
+    })
+    .from(tasks)
+    .where(
+      and(
+        eq(tasks.workflowId, task.workflowId),
+        runCondition,
+        ne(tasks.id, id)
+      )
+    )
+    .orderBy(tasks.createdAt);
+
+  return NextResponse.json(siblings);
+}

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

@@ -66,27 +66,26 @@ export async function POST(req: NextRequest) {
     updatedAt: now,
   });
 
-  // Link already-uploaded documents to this task
-  if (parsed.data.fileIds && parsed.data.fileIds.length > 0) {
+  // Link documents to this task (from document picker or legacy fileIds)
+  if (parsed.data.documentIds && parsed.data.documentIds.length > 0) {
     try {
-      for (const fileId of parsed.data.fileIds) {
-        // Update existing document record (created by /api/uploads) to link to this task
+      for (const docId of parsed.data.documentIds) {
         await db.update(documents)
           .set({
             taskId: id,
             projectId: parsed.data.projectId ?? null,
             updatedAt: now,
           })
-          .where(eq(documents.id, fileId));
+          .where(eq(documents.id, docId));
 
         // Trigger processing if not already done (fire-and-forget)
-        processDocument(fileId).catch((err) => {
-          console.error(`[tasks] processDocument failed for ${fileId}:`, err);
+        processDocument(docId).catch((err) => {
+          console.error(`[tasks] processDocument failed for ${docId}:`, err);
         });
       }
     } catch (err) {
-      // File association is best-effort — don't fail task creation
-      console.error("[tasks] File association failed:", err);
+      // Document association is best-effort — don't fail task creation
+      console.error("[tasks] Document association failed:", err);
     }
   }
 

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

@@ -0,0 +1,209 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db } from "@/lib/db";
+import {
+  workflowDocumentInputs,
+  documents,
+  workflows,
+} from "@/lib/db/schema";
+import { eq, and, inArray } from "drizzle-orm";
+
+type RouteContext = { params: Promise<{ id: string }> };
+
+/**
+ * GET /api/workflows/[id]/documents
+ * List all document bindings for a workflow, with document metadata.
+ */
+export async function GET(
+  _request: NextRequest,
+  context: RouteContext
+) {
+  const { id: workflowId } = await context.params;
+
+  try {
+    const bindings = await db
+      .select()
+      .from(workflowDocumentInputs)
+      .where(eq(workflowDocumentInputs.workflowId, workflowId));
+
+    if (bindings.length === 0) {
+      return NextResponse.json([]);
+    }
+
+    const docIds = bindings.map((b) => b.documentId);
+    const docs = await db
+      .select()
+      .from(documents)
+      .where(inArray(documents.id, docIds));
+
+    const docMap = new Map(docs.map((d) => [d.id, d]));
+
+    const result = bindings.map((binding) => {
+      const doc = docMap.get(binding.documentId);
+      return {
+        bindingId: binding.id,
+        documentId: binding.documentId,
+        stepId: binding.stepId,
+        createdAt: binding.createdAt,
+        document: doc
+          ? {
+              id: doc.id,
+              originalName: doc.originalName,
+              filename: doc.filename,
+              mimeType: doc.mimeType,
+              size: doc.size,
+              direction: doc.direction,
+              status: doc.status,
+              category: doc.category,
+            }
+          : null,
+      };
+    });
+
+    return NextResponse.json(result);
+  } catch (error) {
+    console.error("[workflow-documents] GET failed:", error);
+    return NextResponse.json(
+      { error: "Failed to fetch workflow documents" },
+      { status: 500 }
+    );
+  }
+}
+
+/**
+ * POST /api/workflows/[id]/documents
+ * Attach document IDs to a workflow.
+ * Body: { documentIds: string[], stepId?: string }
+ */
+export async function POST(
+  request: NextRequest,
+  context: RouteContext
+) {
+  const { id: workflowId } = await context.params;
+
+  try {
+    const body = await request.json();
+    const { documentIds, stepId } = body as {
+      documentIds: string[];
+      stepId?: string;
+    };
+
+    if (!Array.isArray(documentIds) || documentIds.length === 0) {
+      return NextResponse.json(
+        { error: "documentIds must be a non-empty array" },
+        { status: 400 }
+      );
+    }
+
+    // Verify workflow exists
+    const [workflow] = await db
+      .select({ id: workflows.id, projectId: workflows.projectId })
+      .from(workflows)
+      .where(eq(workflows.id, workflowId));
+
+    if (!workflow) {
+      return NextResponse.json(
+        { error: "Workflow not found" },
+        { status: 404 }
+      );
+    }
+
+    // Verify all documents exist
+    const existingDocs = await db
+      .select({ id: documents.id })
+      .from(documents)
+      .where(inArray(documents.id, documentIds));
+
+    const existingIds = new Set(existingDocs.map((d) => d.id));
+    const missing = documentIds.filter((id) => !existingIds.has(id));
+    if (missing.length > 0) {
+      return NextResponse.json(
+        { error: `Documents not found: ${missing.join(", ")}` },
+        { status: 404 }
+      );
+    }
+
+    // Insert bindings (ignore duplicates via ON CONFLICT)
+    const now = new Date();
+    const values = documentIds.map((docId) => ({
+      id: crypto.randomUUID(),
+      workflowId,
+      documentId: docId,
+      stepId: stepId ?? null,
+      createdAt: now,
+    }));
+
+    for (const value of values) {
+      try {
+        await db.insert(workflowDocumentInputs).values(value);
+      } catch (err) {
+        // Skip duplicates (unique constraint violation)
+        const msg = err instanceof Error ? err.message : "";
+        if (!msg.includes("UNIQUE constraint")) throw err;
+      }
+    }
+
+    return NextResponse.json(
+      { attached: documentIds.length, workflowId, stepId: stepId ?? null },
+      { status: 201 }
+    );
+  } catch (error) {
+    console.error("[workflow-documents] POST failed:", error);
+    return NextResponse.json(
+      { error: "Failed to attach documents" },
+      { status: 500 }
+    );
+  }
+}
+
+/**
+ * DELETE /api/workflows/[id]/documents
+ * Remove document bindings from a workflow.
+ * Body: { documentIds: string[], stepId?: string }
+ * If no body, removes all bindings.
+ */
+export async function DELETE(
+  request: NextRequest,
+  context: RouteContext
+) {
+  const { id: workflowId } = await context.params;
+
+  try {
+    let body: { documentIds?: string[]; stepId?: string } = {};
+    try {
+      body = await request.json();
+    } catch {
+      // Empty body = remove all
+    }
+
+    const { documentIds, stepId } = body;
+
+    if (documentIds && documentIds.length > 0) {
+      // Remove specific bindings
+      for (const docId of documentIds) {
+        const conditions = [
+          eq(workflowDocumentInputs.workflowId, workflowId),
+          eq(workflowDocumentInputs.documentId, docId),
+        ];
+        if (stepId !== undefined) {
+          conditions.push(eq(workflowDocumentInputs.stepId, stepId));
+        }
+        await db
+          .delete(workflowDocumentInputs)
+          .where(and(...conditions));
+      }
+    } else {
+      // Remove all bindings for this workflow
+      await db
+        .delete(workflowDocumentInputs)
+        .where(eq(workflowDocumentInputs.workflowId, workflowId));
+    }
+
+    return NextResponse.json({ ok: true });
+  } catch (error) {
+    console.error("[workflow-documents] DELETE failed:", error);
+    return NextResponse.json(
+      { error: "Failed to remove document bindings" },
+      { status: 500 }
+    );
+  }
+}

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

@@ -1,7 +1,7 @@
 import { NextRequest, NextResponse } from "next/server";
 import { db } from "@/lib/db";
 import { workflows } from "@/lib/db/schema";
-import { eq, and } from "drizzle-orm";
+import { eq, and, sql } from "drizzle-orm";
 import { executeWorkflow } from "@/lib/workflows/engine";
 import type { WorkflowDefinition } from "@/lib/workflows/types";
 
@@ -57,7 +57,11 @@ export async function POST(
   // Prevents concurrent double-execution from parallel requests.
   const claimResult = db
     .update(workflows)
-    .set({ status: "active", updatedAt: new Date() })
+    .set({
+      status: "active",
+      runNumber: sql`${workflows.runNumber} + 1`,
+      updatedAt: new Date(),
+    })
     .where(
       and(
         eq(workflows.id, id),

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

@@ -35,17 +35,30 @@ export async function PATCH(
     return NextResponse.json({ error: "Workflow not found" }, { status: 404 });
   }
 
-  // Edit name/definition — draft only
+  // Edit name/definition — draft, completed, or failed
   if (name !== undefined || definition !== undefined) {
-    if (workflow.status !== "draft") {
+    if (!["draft", "completed", "failed"].includes(workflow.status)) {
       return NextResponse.json(
-        { error: "Can only edit draft workflows" },
+        { error: "Cannot edit active or paused workflows" },
         { status: 409 }
       );
     }
 
     const updates: Record<string, unknown> = { updatedAt: new Date() };
 
+    // Reset non-draft workflows to draft and strip execution state
+    if (workflow.status !== "draft") {
+      updates.status = "draft";
+      try {
+        const existingDef = JSON.parse(workflow.definition) as Record<string, unknown>;
+        delete existingDef._state;
+        delete existingDef._loopState;
+        updates.definition = JSON.stringify(existingDef);
+      } catch {
+        // Definition will be overwritten below if provided
+      }
+    }
+
     if (name !== undefined) {
       if (!name.trim()) {
         return NextResponse.json({ error: "Name is required" }, { status: 400 });

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

@@ -1,7 +1,7 @@
 import { NextRequest, NextResponse } from "next/server";
 import { db } from "@/lib/db";
-import { workflows, documents } from "@/lib/db/schema";
-import { eq, and, inArray } from "drizzle-orm";
+import { workflows, tasks, documents } from "@/lib/db/schema";
+import { eq, and, inArray, count, desc, sql as drizzleSql } from "drizzle-orm";
 import { parseWorkflowState } from "@/lib/workflows/engine";
 
 /** Collect output documents for workflow step tasks + input documents from parent task */
@@ -81,6 +81,18 @@ export async function GET(
     return NextResponse.json({ error: "Workflow not found" }, { status: 404 });
   }
 
+  const runHistory = await db
+    .select({
+      runNumber: tasks.workflowRunNumber,
+      taskCount: count(tasks.id),
+      completedCount: drizzleSql<number>`SUM(CASE WHEN ${tasks.status} = 'completed' THEN 1 ELSE 0 END)`,
+      failedCount: drizzleSql<number>`SUM(CASE WHEN ${tasks.status} = 'failed' THEN 1 ELSE 0 END)`,
+    })
+    .from(tasks)
+    .where(eq(tasks.workflowId, id))
+    .groupBy(tasks.workflowRunNumber)
+    .orderBy(desc(tasks.workflowRunNumber));
+
   const { definition, state, loopState } = parseWorkflowState(workflow.definition);
   const sourceTaskId: string | undefined = definition.sourceTaskId;
   const { stepDocuments, parentDocuments } = await getWorkflowDocuments(state, sourceTaskId);
@@ -100,6 +112,8 @@ export async function GET(
       steps: definition.steps,
       stepDocuments,
       parentDocuments,
+      runNumber: workflow.runNumber,
+      runHistory,
     });
   }
 
@@ -118,5 +132,7 @@ export async function GET(
     workflowState: state,
     stepDocuments,
     parentDocuments,
+    runNumber: workflow.runNumber,
+    runHistory,
   });
 }

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

@@ -1,14 +1,25 @@
 import { NextRequest, NextResponse } from "next/server";
 import { db } from "@/lib/db";
 import { workflows } from "@/lib/db/schema";
-import { desc, eq } from "drizzle-orm";
+import { desc, eq, sql } 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()
+    .select({
+      id: workflows.id,
+      name: workflows.name,
+      projectId: workflows.projectId,
+      definition: workflows.definition,
+      status: workflows.status,
+      runNumber: workflows.runNumber,
+      createdAt: workflows.createdAt,
+      updatedAt: workflows.updatedAt,
+      taskCount: sql<number>`(SELECT COUNT(*) FROM tasks t WHERE t.workflow_id = "workflows"."id")`.as("taskCount"),
+      outputDocCount: sql<number>`(SELECT COUNT(*) FROM documents d WHERE d.task_id IN (SELECT t2.id FROM tasks t2 WHERE t2.workflow_id = "workflows"."id") AND d.direction = 'output')`.as("outputDocCount"),
+    })
     .from(workflows)
     .orderBy(desc(workflows.createdAt));
 

package/src/app/documents/page.tsx

@@ -1,5 +1,5 @@
 import { db } from "@/lib/db";
-import { documents, tasks, projects } from "@/lib/db/schema";
+import { documents, tasks, projects, workflows } from "@/lib/db/schema";
 import { desc, eq } from "drizzle-orm";
 import { DocumentBrowser } from "@/components/documents/document-browser";
 import { PageShell } from "@/components/shared/page-shell";
@@ -31,9 +31,13 @@ export default async function DocumentsPage() {
       updatedAt: documents.updatedAt,
       taskTitle: tasks.title,
       projectName: projects.name,
+      workflowId: workflows.id,
+      workflowName: workflows.name,
+      workflowRunNumber: tasks.workflowRunNumber,
     })
     .from(documents)
     .leftJoin(tasks, eq(documents.taskId, tasks.id))
+    .leftJoin(workflows, eq(tasks.workflowId, workflows.id))
     .leftJoin(projects, eq(documents.projectId, projects.id))
     .orderBy(desc(documents.createdAt));
 

package/src/app/layout.tsx

@@ -25,7 +25,6 @@ export const metadata: Metadata = {
   icons: {
     icon: [
       { url: "/stagent-s-64.png", sizes: "64x64", type: "image/png" },
-      { url: "/icon.svg", type: "image/svg+xml" },
     ],
     apple: [
       { url: "/stagent-s-128.png", sizes: "128x128", type: "image/png" },

package/src/app/manifest.ts

@@ -23,9 +23,9 @@ export default function manifest(): MetadataRoute.Manifest {
         purpose: "maskable",
       },
       {
-        src: "/icon.svg",
-        sizes: "any",
-        type: "image/svg+xml",
+        src: "/stagent-s-64.png",
+        sizes: "64x64",
+        type: "image/png",
       },
     ],
   };

package/src/app/projects/[id]/page.tsx

@@ -1,12 +1,14 @@
 import { notFound } from "next/navigation";
 import { db } from "@/lib/db";
-import { projects, tasks, workflows } from "@/lib/db/schema";
-import { eq, count, getTableColumns } from "drizzle-orm";
+import { projects, tasks, workflows, documents } from "@/lib/db/schema";
+import { eq, count, desc, getTableColumns } from "drizzle-orm";
 import { Badge } from "@/components/ui/badge";
 import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
 import { COLUMN_ORDER } from "@/lib/constants/task-status";
 import { PageShell } from "@/components/shared/page-shell";
 import { ProjectDetailClient } from "@/components/projects/project-detail";
+import Link from "next/link";
+import { FileText } from "lucide-react";
 import { Sparkline } from "@/components/charts/sparkline";
 import { getProjectCompletionTrend } from "@/lib/queries/chart-data";
 import { EnvironmentSummaryCard } from "@/components/environment/environment-summary-card";
@@ -38,6 +40,27 @@ export default async function ProjectDetailPage({
     .where(eq(tasks.projectId, id))
     .orderBy(tasks.priority, tasks.createdAt);
 
+  // Document count and recent docs
+  const [{ docCount }] = await db
+    .select({ docCount: count(documents.id) })
+    .from(documents)
+    .where(eq(documents.projectId, id));
+
+  const recentDocs = docCount > 0 ? await db
+    .select({
+      id: documents.id,
+      originalName: documents.originalName,
+      direction: documents.direction,
+      version: documents.version,
+      size: documents.size,
+      createdAt: documents.createdAt,
+    })
+    .from(documents)
+    .where(eq(documents.projectId, id))
+    .orderBy(desc(documents.createdAt))
+    .limit(5)
+  : [];
+
   // Status breakdown (standalone tasks only for headline metrics)
   const statusCounts: Record<string, number> = {};
   const standaloneForCounts = projectTasks.filter((t) => !t.workflowId);
@@ -144,6 +167,40 @@ export default async function ProjectDetailPage({
         </div>
       )}
 
+      {/* Recent documents */}
+      {recentDocs.length > 0 && (
+        <div className="mb-6">
+          <Card>
+            <CardHeader className="pb-2">
+              <div className="flex items-center justify-between">
+                <CardTitle className="text-sm">Recent Documents</CardTitle>
+                <Link href={`/documents?projectId=${id}`} className="text-xs text-muted-foreground hover:text-foreground transition-colors">
+                  View all &rarr;
+                </Link>
+              </div>
+            </CardHeader>
+            <CardContent className="divide-y divide-border">
+              {recentDocs.map((doc) => (
+                <Link
+                  key={doc.id}
+                  href={`/documents/${doc.id}`}
+                  className="flex items-center gap-3 py-2 text-xs hover:bg-accent/50 transition-colors -mx-6 px-6"
+                >
+                  <FileText className="h-3.5 w-3.5 text-muted-foreground shrink-0" />
+                  <span className="truncate flex-1">{doc.originalName}</span>
+                  <Badge variant="outline" className="text-[10px]">
+                    {doc.direction}
+                  </Badge>
+                  {doc.direction === "output" && (
+                    <span className="text-muted-foreground">v{doc.version}</span>
+                  )}
+                </Link>
+              ))}
+            </CardContent>
+          </Card>
+        </div>
+      )}
+
       {/* Task count summary */}
       {(standaloneCount > 0 || workflowCount > 0) && (
         <p className="text-xs text-muted-foreground mb-4">
@@ -151,6 +208,9 @@ export default async function ProjectDetailPage({
           {workflowCount > 0 && (
             <> &middot; {workflowCount} workflow task{workflowCount !== 1 ? "s" : ""} across {workflowGroupCount} workflow{workflowGroupCount !== 1 ? "s" : ""}</>
           )}
+          {docCount > 0 && (
+            <> &middot; {docCount} document{docCount !== 1 ? "s" : ""}</>
+          )}
         </p>
       )}
 

package/src/app/settings/page.tsx

@@ -1,6 +1,7 @@
 import { ProvidersAndRuntimesSection } from "@/components/settings/providers-runtimes-section";
 import { PermissionsSections } from "@/components/settings/permissions-sections";
 import { DataManagementSection } from "@/components/settings/data-management-section";
+import { DatabaseSnapshotsSection } from "@/components/settings/database-snapshots-section";
 import { BudgetGuardrailsSection } from "@/components/settings/budget-guardrails-section";
 import { ChatSettingsSection } from "@/components/settings/chat-settings-section";
 import { RuntimeTimeoutSection } from "@/components/settings/runtime-timeout-section";
@@ -27,6 +28,7 @@ export default function SettingsPage() {
         <ChannelsSection />
         <BudgetGuardrailsSection />
         <PermissionsSections />
+        <DatabaseSnapshotsSection />
         <DataManagementSection />
       </div>
     </PageShell>

package/src/app/tables/[id]/page.tsx

@@ -0,0 +1,67 @@
+import { notFound } from "next/navigation";
+import { db } from "@/lib/db";
+import { projects } from "@/lib/db/schema";
+import { eq } from "drizzle-orm";
+import { getTable, listRows } from "@/lib/data/tables";
+import { PageShell } from "@/components/shared/page-shell";
+import { TableDetailTabs } from "@/components/tables/table-detail-tabs";
+import { evaluateComputedColumns } from "@/lib/tables/computed";
+import type { ColumnDef } from "@/lib/tables/types";
+
+export const dynamic = "force-dynamic";
+
+interface Props {
+  params: Promise<{ id: string }>;
+}
+
+export default async function TableDetailPage({ params }: Props) {
+  const { id } = await params;
+  const table = await getTable(id);
+
+  if (!table) {
+    notFound();
+  }
+
+  let columns: ColumnDef[] = [];
+  try {
+    columns = JSON.parse(table.columnSchema) as ColumnDef[];
+  } catch {
+    columns = [];
+  }
+
+  // Fetch project name if table is linked to a project
+  let projectName: string | null = null;
+  if (table.projectId) {
+    const project = db
+      .select({ name: projects.name })
+      .from(projects)
+      .where(eq(projects.id, table.projectId))
+      .get();
+    projectName = project?.name ?? null;
+  }
+
+  const rawRows = await listRows(id, { limit: 500 });
+  const rows = evaluateComputedColumns(columns, rawRows);
+
+  return (
+    <PageShell
+      title={table.name}
+      description={table.description ?? undefined}
+      backHref="/tables"
+      backLabel="Tables"
+    >
+      <TableDetailTabs
+        tableId={id}
+        columns={columns}
+        initialRows={rows}
+        tableMeta={{
+          source: table.source,
+          projectName,
+          rowCount: table.rowCount,
+          createdAt: table.createdAt ? new Date(table.createdAt).toISOString() : null,
+          updatedAt: table.updatedAt ? new Date(table.updatedAt).toISOString() : null,
+        }}
+      />
+    </PageShell>
+  );
+}

package/src/app/tables/page.tsx

@@ -0,0 +1,21 @@
+import { listTables } from "@/lib/data/tables";
+import { db } from "@/lib/db";
+import { projects } from "@/lib/db/schema";
+import { TableBrowser } from "@/components/tables/table-browser";
+import { PageShell } from "@/components/shared/page-shell";
+
+export const dynamic = "force-dynamic";
+
+export default async function TablesPage() {
+  const tables = await listTables();
+
+  const projectList = await db
+    .select({ id: projects.id, name: projects.name })
+    .from(projects);
+
+  return (
+    <PageShell title="Tables">
+      <TableBrowser initialTables={tables} projects={projectList} />
+    </PageShell>
+  );
+}