stagent 0.6.3 → 0.8.0

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

@@ -17,6 +17,18 @@ import {
   chatMessages,
   conversations,
   projectDocumentDefaults,
+  userTables,
+  userTableColumns,
+  userTableRows,
+  userTableViews,
+  userTableImports,
+  userTableRelationships,
+  tableDocumentInputs,
+  taskTableInputs,
+  workflowTableInputs,
+  scheduleTableInputs,
+  userTableTriggers,
+  userTableRowHistory,
 } from "@/lib/db/schema";
 import { eq, inArray } from "drizzle-orm";
 import { updateProjectSchema } from "@/lib/validators/project";
@@ -192,6 +204,31 @@ export async function DELETE(
     // 6. Project document defaults (junction table)
     db.delete(projectDocumentDefaults).where(eq(projectDocumentDefaults.projectId, id)).run();
 
+    // 6b. User-defined tables — cascade-delete children before parent
+    const tableIds = db
+      .select({ id: userTables.id })
+      .from(userTables)
+      .where(eq(userTables.projectId, id))
+      .all()
+      .map((r) => r.id);
+
+    if (tableIds.length > 0) {
+      // Junction tables first
+      db.delete(tableDocumentInputs).where(inArray(tableDocumentInputs.tableId, tableIds)).run();
+      db.delete(taskTableInputs).where(inArray(taskTableInputs.tableId, tableIds)).run();
+      db.delete(workflowTableInputs).where(inArray(workflowTableInputs.tableId, tableIds)).run();
+      db.delete(scheduleTableInputs).where(inArray(scheduleTableInputs.tableId, tableIds)).run();
+      // Children
+      db.delete(userTableRowHistory).where(inArray(userTableRowHistory.tableId, tableIds)).run();
+      db.delete(userTableTriggers).where(inArray(userTableTriggers.tableId, tableIds)).run();
+      db.delete(userTableImports).where(inArray(userTableImports.tableId, tableIds)).run();
+      db.delete(userTableViews).where(inArray(userTableViews.tableId, tableIds)).run();
+      db.delete(userTableRelationships).where(inArray(userTableRelationships.fromTableId, tableIds)).run();
+      db.delete(userTableRows).where(inArray(userTableRows.tableId, tableIds)).run();
+      db.delete(userTableColumns).where(inArray(userTableColumns.tableId, tableIds)).run();
+      db.delete(userTables).where(inArray(userTables.id, tableIds)).run();
+    }
+
     // 7. Direct project children
     db.delete(documents).where(eq(documents.projectId, id)).run();
     db.delete(tasks).where(eq(tasks.projectId, id)).run();

package/src/app/api/projects/__tests__/delete-project.test.ts

@@ -28,6 +28,7 @@ describe("project DELETE cascade coverage", () => {
     "environmentCheckpoints",
     "conversations",
     "projectDocumentDefaults",
+    "userTables",
   ];
 
   // Tables that are indirect children (FK to a table that has projectId)
@@ -39,6 +40,17 @@ describe("project DELETE cascade coverage", () => {
     { table: "chatMessages", parent: "conversations", via: "conversationId" },
     { table: "environmentArtifacts", parent: "environmentScans", via: "scanId" },
     { table: "environmentSyncOps", parent: "environmentCheckpoints", via: "checkpointId" },
+    { table: "userTableColumns", parent: "userTables", via: "tableId" },
+    { table: "userTableRows", parent: "userTables", via: "tableId" },
+    { table: "userTableViews", parent: "userTables", via: "tableId" },
+    { table: "userTableImports", parent: "userTables", via: "tableId" },
+    { table: "userTableRelationships", parent: "userTables", via: "fromTableId" },
+    { table: "tableDocumentInputs", parent: "userTables", via: "tableId" },
+    { table: "taskTableInputs", parent: "userTables", via: "tableId" },
+    { table: "workflowTableInputs", parent: "userTables", via: "tableId" },
+    { table: "scheduleTableInputs", parent: "userTables", via: "tableId" },
+    { table: "userTableTriggers", parent: "userTables", via: "tableId" },
+    { table: "userTableRowHistory", parent: "userTables", via: "tableId" },
   ];
 
   it("handles all tables with direct projectId FK", () => {

package/src/app/api/snapshots/[id]/restore/route.ts

@@ -0,0 +1,62 @@
+import { NextRequest, NextResponse } from "next/server";
+import {
+  restoreFromSnapshot,
+  isSnapshotLocked,
+} from "@/lib/snapshots/snapshot-manager";
+import { db } from "@/lib/db";
+import { tasks } from "@/lib/db/schema";
+import { eq } from "drizzle-orm";
+
+/** POST /api/snapshots/[id]/restore — restore from a snapshot (destructive) */
+export async function POST(
+  _req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+
+  if (isSnapshotLocked()) {
+    return NextResponse.json(
+      { error: "Another snapshot operation is already in progress" },
+      { status: 409 }
+    );
+  }
+
+  // Check for running tasks
+  const runningTasks = await db
+    .select()
+    .from(tasks)
+    .where(eq(tasks.status, "running"));
+
+  if (runningTasks.length > 0) {
+    return NextResponse.json(
+      {
+        error: `${runningTasks.length} task(s) are currently running. Stop them before restoring.`,
+        runningTasks: runningTasks.map((t) => ({
+          id: t.id,
+          title: t.title,
+        })),
+      },
+      { status: 409 }
+    );
+  }
+
+  try {
+    const result = await restoreFromSnapshot(id);
+
+    return NextResponse.json({
+      success: true,
+      requiresRestart: result.requiresRestart,
+      preRestoreSnapshotId: result.preRestoreSnapshotId,
+      message:
+        "Restore complete. Please restart the server to load the restored database.",
+    });
+  } catch (error) {
+    return NextResponse.json(
+      {
+        error:
+          error instanceof Error ? error.message : "Failed to restore snapshot",
+      },
+      { status: 500 }
+    );
+  }
+}

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

@@ -0,0 +1,44 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getSnapshot, deleteSnapshot } from "@/lib/snapshots/snapshot-manager";
+
+/** GET /api/snapshots/[id] — get snapshot details */
+export async function GET(
+  _req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+
+  try {
+    const snapshot = await getSnapshot(id);
+    if (!snapshot) {
+      return NextResponse.json({ error: "Snapshot not found" }, { status: 404 });
+    }
+    return NextResponse.json(snapshot);
+  } catch (error) {
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : "Failed to get snapshot" },
+      { status: 500 }
+    );
+  }
+}
+
+/** DELETE /api/snapshots/[id] — delete a snapshot and its files */
+export async function DELETE(
+  _req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+
+  try {
+    const deleted = await deleteSnapshot(id);
+    if (!deleted) {
+      return NextResponse.json({ error: "Snapshot not found" }, { status: 404 });
+    }
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : "Failed to delete snapshot" },
+      { status: 500 }
+    );
+  }
+}

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

@@ -0,0 +1,54 @@
+import { NextRequest, NextResponse } from "next/server";
+import {
+  createSnapshot,
+  listSnapshots,
+  getSnapshotsSize,
+  isSnapshotLocked,
+} from "@/lib/snapshots/snapshot-manager";
+
+/** GET /api/snapshots — list all snapshots with disk usage */
+export async function GET() {
+  try {
+    const [snapshotList, usage] = await Promise.all([
+      listSnapshots(),
+      getSnapshotsSize(),
+    ]);
+
+    return NextResponse.json({
+      snapshots: snapshotList,
+      totalBytes: usage.totalBytes,
+      snapshotCount: usage.snapshotCount,
+    });
+  } catch (error) {
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : "Failed to list snapshots" },
+      { status: 500 }
+    );
+  }
+}
+
+/** POST /api/snapshots — create a manual snapshot */
+export async function POST(req: NextRequest) {
+  if (isSnapshotLocked()) {
+    return NextResponse.json(
+      { error: "Another snapshot operation is already in progress" },
+      { status: 409 }
+    );
+  }
+
+  try {
+    const body = await req.json().catch(() => ({}));
+    const label = typeof body.label === "string" && body.label.trim()
+      ? body.label.trim()
+      : `Manual snapshot`;
+
+    const snapshot = await createSnapshot(label, "manual");
+
+    return NextResponse.json(snapshot, { status: 201 });
+  } catch (error) {
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : "Failed to create snapshot" },
+      { status: 500 }
+    );
+  }
+}

package/src/app/api/snapshots/settings/route.ts

@@ -0,0 +1,67 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getSetting, setSetting } from "@/lib/settings/helpers";
+
+const SETTINGS_KEYS = {
+  enabled: "snapshot.autoBackup.enabled",
+  interval: "snapshot.autoBackup.interval",
+  maxCount: "snapshot.retention.maxCount",
+  maxAgeWeeks: "snapshot.retention.maxAgeWeeks",
+} as const;
+
+const DEFAULTS = {
+  enabled: "false",
+  interval: "1d",
+  maxCount: "10",
+  maxAgeWeeks: "4",
+} as const;
+
+/** GET /api/snapshots/settings — read snapshot settings */
+export async function GET() {
+  try {
+    const [enabled, interval, maxCount, maxAgeWeeks] = await Promise.all([
+      getSetting(SETTINGS_KEYS.enabled),
+      getSetting(SETTINGS_KEYS.interval),
+      getSetting(SETTINGS_KEYS.maxCount),
+      getSetting(SETTINGS_KEYS.maxAgeWeeks),
+    ]);
+
+    return NextResponse.json({
+      enabled: enabled ?? DEFAULTS.enabled,
+      interval: interval ?? DEFAULTS.interval,
+      maxCount: maxCount ?? DEFAULTS.maxCount,
+      maxAgeWeeks: maxAgeWeeks ?? DEFAULTS.maxAgeWeeks,
+    });
+  } catch (error) {
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : "Failed to read settings" },
+      { status: 500 }
+    );
+  }
+}
+
+/** PUT /api/snapshots/settings — update snapshot settings */
+export async function PUT(req: NextRequest) {
+  try {
+    const body = await req.json();
+
+    if (body.enabled !== undefined) {
+      await setSetting(SETTINGS_KEYS.enabled, String(body.enabled));
+    }
+    if (body.interval !== undefined) {
+      await setSetting(SETTINGS_KEYS.interval, String(body.interval));
+    }
+    if (body.maxCount !== undefined) {
+      await setSetting(SETTINGS_KEYS.maxCount, String(body.maxCount));
+    }
+    if (body.maxAgeWeeks !== undefined) {
+      await setSetting(SETTINGS_KEYS.maxAgeWeeks, String(body.maxAgeWeeks));
+    }
+
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : "Failed to save settings" },
+      { status: 500 }
+    );
+  }
+}

package/src/app/api/tables/[id]/charts/[chartId]/route.ts

@@ -0,0 +1,89 @@
+import { NextRequest, NextResponse } from "next/server";
+import { db } from "@/lib/db";
+import { userTableViews } from "@/lib/db/schema";
+import { eq, and } from "drizzle-orm";
+
+interface RouteContext {
+  params: Promise<{ id: string; chartId: string }>;
+}
+
+/** PATCH /api/tables/[id]/charts/[chartId] — Update a chart */
+export async function PATCH(req: NextRequest, { params }: RouteContext) {
+  const { id, chartId } = await params;
+
+  const chart = db
+    .select()
+    .from(userTableViews)
+    .where(
+      and(
+        eq(userTableViews.id, chartId),
+        eq(userTableViews.tableId, id),
+        eq(userTableViews.type, "chart")
+      )
+    )
+    .get();
+
+  if (!chart) {
+    return NextResponse.json({ error: "Chart not found" }, { status: 404 });
+  }
+
+  const body = await req.json();
+  const existingConfig = chart.config ? JSON.parse(chart.config) : {};
+  const updates: Record<string, unknown> = { updatedAt: new Date() };
+
+  if (body.title !== undefined) updates.name = body.title;
+
+  // Merge config fields
+  const configUpdates: Record<string, unknown> = {};
+  if (body.type !== undefined) configUpdates.type = body.type;
+  if (body.xColumn !== undefined) configUpdates.xColumn = body.xColumn;
+  if (body.yColumn !== undefined) configUpdates.yColumn = body.yColumn;
+  if (body.aggregation !== undefined) configUpdates.aggregation = body.aggregation;
+
+  if (Object.keys(configUpdates).length > 0) {
+    updates.config = JSON.stringify({ ...existingConfig, ...configUpdates });
+  }
+
+  db.update(userTableViews)
+    .set(updates)
+    .where(eq(userTableViews.id, chartId))
+    .run();
+
+  const updated = db
+    .select()
+    .from(userTableViews)
+    .where(eq(userTableViews.id, chartId))
+    .get();
+
+  return NextResponse.json({
+    ...updated,
+    config: updated?.config ? JSON.parse(updated.config) : null,
+  });
+}
+
+/** DELETE /api/tables/[id]/charts/[chartId] — Remove a chart */
+export async function DELETE(_req: NextRequest, { params }: RouteContext) {
+  const { id, chartId } = await params;
+
+  const chart = db
+    .select()
+    .from(userTableViews)
+    .where(
+      and(
+        eq(userTableViews.id, chartId),
+        eq(userTableViews.tableId, id),
+        eq(userTableViews.type, "chart")
+      )
+    )
+    .get();
+
+  if (!chart) {
+    return NextResponse.json({ error: "Chart not found" }, { status: 404 });
+  }
+
+  db.delete(userTableViews)
+    .where(eq(userTableViews.id, chartId))
+    .run();
+
+  return new NextResponse(null, { status: 204 });
+}

package/src/app/api/tables/[id]/charts/route.ts

@@ -0,0 +1,72 @@
+import { NextRequest, NextResponse } from "next/server";
+import { randomUUID } from "crypto";
+import { db } from "@/lib/db";
+import { userTableViews } from "@/lib/db/schema";
+import { eq, and } from "drizzle-orm";
+import { getTable } from "@/lib/data/tables";
+
+interface RouteContext {
+  params: Promise<{ id: string }>;
+}
+
+/** GET /api/tables/[id]/charts — List chart views for a table */
+export async function GET(_req: NextRequest, { params }: RouteContext) {
+  const { id } = await params;
+
+  const charts = db
+    .select()
+    .from(userTableViews)
+    .where(and(eq(userTableViews.tableId, id), eq(userTableViews.type, "chart")))
+    .all();
+
+  return NextResponse.json(
+    charts.map((c) => ({
+      ...c,
+      config: c.config ? JSON.parse(c.config) : null,
+    }))
+  );
+}
+
+/** POST /api/tables/[id]/charts — Save a new chart configuration */
+export async function POST(req: NextRequest, { params }: RouteContext) {
+  const { id } = await params;
+
+  const table = await getTable(id);
+  if (!table) {
+    return NextResponse.json({ error: "Table not found" }, { status: 404 });
+  }
+
+  const body = await req.json();
+  const { type, title, xColumn, yColumn, aggregation } = body as {
+    type?: string;
+    title?: string;
+    xColumn?: string;
+    yColumn?: string;
+    aggregation?: string;
+  };
+
+  if (!type || !title || !xColumn) {
+    return NextResponse.json(
+      { error: "type, title, and xColumn are required" },
+      { status: 400 }
+    );
+  }
+
+  const viewId = randomUUID();
+  const now = new Date();
+
+  db.insert(userTableViews)
+    .values({
+      id: viewId,
+      tableId: id,
+      name: title,
+      type: "chart",
+      config: JSON.stringify({ type, xColumn, yColumn, aggregation }),
+      isDefault: false,
+      createdAt: now,
+      updatedAt: now,
+    })
+    .run();
+
+  return NextResponse.json({ id: viewId, name: title }, { status: 201 });
+}

package/src/app/api/tables/[id]/columns/route.ts

@@ -0,0 +1,70 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getTable, addColumn, reorderColumns } from "@/lib/data/tables";
+import {
+  addColumnSchema,
+  reorderColumnsSchema,
+} from "@/lib/tables/validation";
+
+export async function POST(
+  req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+
+  try {
+    const existing = await getTable(id);
+    if (!existing) {
+      return NextResponse.json({ error: "Table not found" }, { status: 404 });
+    }
+
+    const body = await req.json();
+    const parsed = addColumnSchema.safeParse(body);
+    if (!parsed.success) {
+      return NextResponse.json(
+        { error: parsed.error.flatten() },
+        { status: 400 }
+      );
+    }
+
+    const column = await addColumn(id, parsed.data);
+    return NextResponse.json(column, { status: 201 });
+  } catch (err) {
+    console.error("[tables] POST column error:", err);
+    return NextResponse.json(
+      { error: "Failed to add column" },
+      { status: 500 }
+    );
+  }
+}
+
+export async function PATCH(
+  req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+
+  try {
+    const existing = await getTable(id);
+    if (!existing) {
+      return NextResponse.json({ error: "Table not found" }, { status: 404 });
+    }
+
+    const body = await req.json();
+    const parsed = reorderColumnsSchema.safeParse(body);
+    if (!parsed.success) {
+      return NextResponse.json(
+        { error: parsed.error.flatten() },
+        { status: 400 }
+      );
+    }
+
+    const columns = await reorderColumns(id, parsed.data.columnIds);
+    return NextResponse.json(columns);
+  } catch (err) {
+    console.error("[tables] PATCH columns reorder error:", err);
+    return NextResponse.json(
+      { error: "Failed to reorder columns" },
+      { status: 500 }
+    );
+  }
+}

package/src/app/api/tables/[id]/export/route.ts

@@ -0,0 +1,94 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getTable, listRows } from "@/lib/data/tables";
+import type { ColumnDef } from "@/lib/tables/types";
+
+export async function GET(
+  req: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params;
+
+  try {
+    const table = await getTable(id);
+    if (!table) {
+      return NextResponse.json({ error: "Table not found" }, { status: 404 });
+    }
+
+    const url = new URL(req.url);
+    const format = url.searchParams.get("format") ?? "csv";
+
+    let columns: ColumnDef[] = [];
+    try {
+      columns = JSON.parse(table.columnSchema) as ColumnDef[];
+    } catch {
+      columns = [];
+    }
+
+    // Fetch all rows (up to 10000)
+    const rows = await listRows(id, { limit: 10000 });
+    const parsedRows = rows.map((r) => JSON.parse(r.data) as Record<string, unknown>);
+
+    switch (format) {
+      case "json":
+        return new NextResponse(JSON.stringify(parsedRows, null, 2), {
+          headers: {
+            "Content-Type": "application/json",
+            "Content-Disposition": `attachment; filename="${table.name}.json"`,
+          },
+        });
+
+      case "xlsx": {
+        const ExcelJS = await import("exceljs");
+        const workbook = new ExcelJS.Workbook();
+        const worksheet = workbook.addWorksheet(table.name);
+
+        // Add header row
+        worksheet.addRow(columns.map((c) => c.displayName));
+
+        // Add data rows
+        for (const row of parsedRows) {
+          worksheet.addRow(columns.map((c) => row[c.name] ?? ""));
+        }
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const buffer = await workbook.xlsx.writeBuffer() as any;
+        return new NextResponse(buffer, {
+          headers: {
+            "Content-Type": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+            "Content-Disposition": `attachment; filename="${table.name}.xlsx"`,
+          },
+        });
+      }
+
+      case "csv":
+      default: {
+        const lines: string[] = [];
+        // Header
+        lines.push(columns.map((c) => escapeCsvField(c.displayName)).join(","));
+        // Data rows
+        for (const row of parsedRows) {
+          lines.push(
+            columns.map((c) => escapeCsvField(String(row[c.name] ?? ""))).join(",")
+          );
+        }
+        const csv = lines.join("\n");
+        return new NextResponse(csv, {
+          headers: {
+            "Content-Type": "text/csv; charset=utf-8",
+            "Content-Disposition": `attachment; filename="${table.name}.csv"`,
+          },
+        });
+      }
+    }
+  } catch (err) {
+    console.error("[tables/export] GET error:", err);
+    return NextResponse.json({ error: "Failed to export table" }, { status: 500 });
+  }
+}
+
+function escapeCsvField(value: string): string {
+  if (value.includes(",") || value.includes('"') || value.includes("\n")) {
+    return `"${value.replace(/"/g, '""')}"`;
+  }
+  return value;
+}

package/src/app/api/tables/[id]/history/route.ts

@@ -0,0 +1,15 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getTableHistory } from "@/lib/tables/history";
+
+interface RouteContext {
+  params: Promise<{ id: string }>;
+}
+
+export async function GET(req: NextRequest, { params }: RouteContext) {
+  const { id } = await params;
+  const url = new URL(req.url);
+  const limit = Math.min(parseInt(url.searchParams.get("limit") ?? "100", 10), 500);
+
+  const history = getTableHistory(id, limit);
+  return NextResponse.json(history);
+}