stagent 0.6.2 → 0.7.0

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);
+}

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

@@ -0,0 +1,111 @@
+import { NextRequest, NextResponse } from "next/server";
+import { getTable, addColumn, getColumns } from "@/lib/data/tables";
+import {
+  extractStructuredData,
+  inferColumnTypes,
+  importRows,
+  createImportRecord,
+} from "@/lib/tables/import";
+
+export async function POST(
+  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 body = await req.json();
+    const { documentId, columnMapping, preview } = body as {
+      documentId?: string;
+      columnMapping?: Array<{
+        name: string;
+        displayName: string;
+        dataType: string;
+        skip?: boolean;
+      }>;
+      preview?: boolean;
+    };
+
+    if (!documentId) {
+      return NextResponse.json(
+        { error: "documentId is required" },
+        { status: 400 }
+      );
+    }
+
+    // Step 1: Extract structured data from the document
+    const { headers, rows } = await extractStructuredData(documentId);
+
+    // Step 2: Infer column types from a sample (first 100 rows)
+    const sampleRows = rows.slice(0, 100);
+    const inferredColumns = inferColumnTypes(headers, sampleRows);
+
+    // If preview mode, return data without importing
+    if (preview) {
+      return NextResponse.json({
+        headers,
+        sampleRows: rows.slice(0, 10),
+        totalRows: rows.length,
+        inferredColumns,
+      });
+    }
+
+    // Step 3: Use user-provided column mapping or fall back to inferred
+    const finalColumns = columnMapping
+      ? inferredColumns.map((col) => {
+          const mapped = columnMapping.find(
+            (m) => m.name === col.name || m.displayName === col.displayName
+          );
+          if (mapped?.skip) return null;
+          if (mapped) {
+            return {
+              ...col,
+              name: mapped.name,
+              displayName: mapped.displayName,
+              dataType: mapped.dataType as typeof col.dataType,
+            };
+          }
+          return col;
+        }).filter(Boolean) as typeof inferredColumns
+      : inferredColumns;
+
+    // Step 4: Ensure columns exist on the table
+    const existingColumns = await getColumns(id);
+    const existingNames = new Set(existingColumns.map((c) => c.name));
+
+    for (const col of finalColumns) {
+      if (!existingNames.has(col.name)) {
+        await addColumn(id, {
+          name: col.name,
+          displayName: col.displayName,
+          dataType: col.dataType,
+          config: col.config,
+        });
+      }
+    }
+
+    // Step 5: Import all rows
+    const result = await importRows(id, rows, finalColumns);
+
+    // Step 6: Create import audit record
+    await createImportRecord(id, documentId, result);
+
+    return NextResponse.json({
+      importId: result.importId,
+      rowsImported: result.rowsImported,
+      rowsSkipped: result.rowsSkipped,
+      errors: result.errors.slice(0, 20), // Limit error detail in response
+      columns: finalColumns,
+    });
+  } catch (err) {
+    console.error("[tables/import] POST error:", err);
+    const message =
+      err instanceof Error ? err.message : "Failed to import data";
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}