context-vault 2.7.0 → 2.8.0

package/scripts/local-server.js

@@ -7,13 +7,26 @@
  */
 
 import { createServer } from "node:http";
-import { createReadStream, existsSync, statSync, unlinkSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import {
+  createReadStream,
+  existsSync,
+  statSync,
+  unlinkSync,
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+} from "node:fs";
 import { join, resolve, dirname, extname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { homedir, platform } from "node:os";
 import { execSync } from "node:child_process";
 import { resolveConfig } from "@context-vault/core/core/config";
-import { initDatabase, prepareStatements, insertVec, deleteVec } from "@context-vault/core/index/db";
+import {
+  initDatabase,
+  prepareStatements,
+  insertVec,
+  deleteVec,
+} from "@context-vault/core/index/db";
 import { embed } from "@context-vault/core/index/embed";
 import { captureAndIndex, updateEntryFile } from "@context-vault/core/capture";
 import { indexEntry } from "@context-vault/core/index";
@@ -24,7 +37,12 @@ import { categoryFor } from "@context-vault/core/core/categories";
 import { parseFile } from "@context-vault/core/capture/importers";
 import { importEntries } from "@context-vault/core/capture/import-pipeline";
 import { ingestUrl } from "@context-vault/core/capture/ingest-url";
-import { buildLocalManifest, fetchRemoteManifest, computeSyncPlan, executeSync } from "@context-vault/core/sync";
+import {
+  buildLocalManifest,
+  fetchRemoteManifest,
+  computeSyncPlan,
+  executeSync,
+} from "@context-vault/core/sync";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const LOCAL_ROOT = resolve(__dirname, "..");
@@ -32,7 +50,9 @@ const LOCAL_ROOT = resolve(__dirname, "..");
 // Try bundled path first (npm install), then workspace path (local dev)
 const bundledDist = resolve(LOCAL_ROOT, "app-dist");
 const workspaceDist = resolve(LOCAL_ROOT, "..", "app", "dist");
-const APP_DIST = existsSync(join(bundledDist, "index.html")) ? bundledDist : workspaceDist;
+const APP_DIST = existsSync(join(bundledDist, "index.html"))
+  ? bundledDist
+  : workspaceDist;
 
 const MIME = {
   ".html": "text/html",
@@ -51,7 +71,11 @@ function formatEntry(row) {
     title: row.title || null,
     body: row.body || null,
     tags: row.tags ? JSON.parse(row.tags) : [],
-    meta: row.meta ? (typeof row.meta === "string" ? JSON.parse(row.meta) : row.meta) : {},
+    meta: row.meta
+      ? typeof row.meta === "string"
+        ? JSON.parse(row.meta)
+        : row.meta
+      : {},
     source: row.source || null,
     identity_key: row.identity_key || null,
     expires_at: row.expires_at || null,
@@ -60,17 +84,30 @@ function formatEntry(row) {
 }
 
 function validateEntry(data, { requireKind = true, requireBody = true } = {}) {
-  if (requireKind && !data.kind) return { error: "kind is required", status: 400 };
-  if (data.kind && !/^[a-z0-9-]+$/.test(data.kind)) return { error: "kind must be lowercase alphanumeric/hyphens", status: 400 };
-  if (requireBody && !data.body) return { error: "body is required", status: 400 };
-  if (data.body && data.body.length > 100 * 1024) return { error: "body max 100KB", status: 400 };
-  if (categoryFor(data.kind) === "entity" && !data.identity_key) return { error: `Entity kind "${data.kind}" requires identity_key`, status: 400 };
+  if (requireKind && !data.kind)
+    return { error: "kind is required", status: 400 };
+  if (data.kind && !/^[a-z0-9-]+$/.test(data.kind))
+    return {
+      error: "kind must be lowercase alphanumeric/hyphens",
+      status: 400,
+    };
+  if (requireBody && !data.body)
+    return { error: "body is required", status: 400 };
+  if (data.body && data.body.length > 100 * 1024)
+    return { error: "body max 100KB", status: 400 };
+  if (categoryFor(data.kind) === "entity" && !data.identity_key)
+    return {
+      error: `Entity kind "${data.kind}" requires identity_key`,
+      status: 400,
+    };
   return null;
 }
 
 async function main() {
   const portArg = process.argv.find((a) => a.startsWith("--port="));
-  const portVal = portArg ? portArg.split("=")[1] : process.argv[process.argv.indexOf("--port") + 1];
+  const portVal = portArg
+    ? portArg.split("=")[1]
+    : process.argv[process.argv.indexOf("--port") + 1];
   const port = parseInt(portVal || "3141", 10);
 
   const config = resolveConfig();
@@ -143,15 +180,18 @@ async function main() {
         if (os === "darwin") {
           selected = execSync(
             `osascript -e 'POSIX path of (choose folder with prompt "Select vault folder")'`,
-            { encoding: "utf-8", timeout: 30000 }
+            { encoding: "utf-8", timeout: 30000 },
           ).trim();
         } else if (os === "linux") {
           selected = execSync(
             `zenity --file-selection --directory --title="Select vault folder" 2>/dev/null`,
-            { encoding: "utf-8", timeout: 30000 }
+            { encoding: "utf-8", timeout: 30000 },
           ).trim();
         } else {
-          return json({ error: "Folder picker not supported on this platform" }, 501);
+          return json(
+            { error: "Folder picker not supported on this platform" },
+            501,
+          );
         }
 
         if (selected) {
@@ -167,14 +207,33 @@ async function main() {
     // ─── API: POST /api/local/connect — switch to a local vault folder ───────
     if (url === "/api/local/connect" && req.method === "POST") {
       const data = await readBody();
-      if (!data?.vaultDir?.trim()) return json({ error: "vaultDir is required", code: "INVALID_INPUT" }, 400);
+      if (!data?.vaultDir?.trim())
+        return json(
+          { error: "vaultDir is required", code: "INVALID_INPUT" },
+          400,
+        );
       let vaultPath = data.vaultDir.trim().replace(/^~/, homedir());
       vaultPath = resolve(vaultPath);
-      if (!existsSync(vaultPath)) return json({ error: "Vault folder not found", code: "NOT_FOUND" }, 404);
-      if (!statSync(vaultPath).isDirectory()) return json({ error: "Path is not a directory", code: "INVALID_INPUT" }, 400);
+      if (!existsSync(vaultPath))
+        return json(
+          { error: "Vault folder not found", code: "NOT_FOUND" },
+          404,
+        );
+      if (!statSync(vaultPath).isDirectory())
+        return json(
+          { error: "Path is not a directory", code: "INVALID_INPUT" },
+          400,
+        );
       try {
-        try { state.db.close(); } catch {}
-        const newConfig = { ...state.config, vaultDir: vaultPath, dbPath: join(vaultPath, ".context-vault.db"), vaultDirExists: true };
+        try {
+          state.db.close();
+        } catch {}
+        const newConfig = {
+          ...state.config,
+          vaultDir: vaultPath,
+          dbPath: join(vaultPath, ".context-vault.db"),
+          vaultDirExists: true,
+        };
         state.config = newConfig;
         state.db = await initDatabase(newConfig.dbPath);
         state.stmts = prepareStatements(state.db);
@@ -188,7 +247,10 @@ async function main() {
         });
       } catch (e) {
         console.error(`[local-server] Connect error: ${e.message}`);
-        return json({ error: `Failed to connect: ${e.message}`, code: "CONNECT_FAILED" }, 500);
+        return json(
+          { error: `Failed to connect: ${e.message}`, code: "CONNECT_FAILED" },
+          500,
+        );
       }
     }
 
@@ -207,10 +269,16 @@ async function main() {
     if (url === "/api/billing/usage" && req.method === "GET") {
       const status = gatherVaultStatus(ctx, {});
       const total = status.kindCounts.reduce((s, k) => s + k.c, 0);
-      const storageMb = Math.round((status.dbSizeBytes / (1024 * 1024)) * 100) / 100;
+      const storageMb =
+        Math.round((status.dbSizeBytes / (1024 * 1024)) * 100) / 100;
       return json({
         tier: "free",
-        limits: { maxEntries: "unlimited", requestsPerDay: "unlimited", storageMb: 1024, exportEnabled: true },
+        limits: {
+          maxEntries: "unlimited",
+          requestsPerDay: "unlimited",
+          storageMb: 1024,
+          exportEnabled: true,
+        },
         usage: { requestsToday: 0, entriesUsed: total, storageMb },
       });
     }
@@ -226,14 +294,24 @@ async function main() {
       return json({
         entries: {
           total: status.kindCounts.reduce((s, k) => s + k.c, 0),
-          by_kind: Object.fromEntries(status.kindCounts.map((k) => [k.kind, k.c])),
-          by_category: Object.fromEntries(status.categoryCounts.map((k) => [k.category, k.c])),
+          by_kind: Object.fromEntries(
+            status.kindCounts.map((k) => [k.kind, k.c]),
+          ),
+          by_category: Object.fromEntries(
+            status.categoryCounts.map((k) => [k.category, k.c]),
+          ),
         },
         files: { total: status.fileCount, directories: status.subdirs },
-        database: { size: status.dbSize, size_bytes: status.dbSizeBytes, stale_paths: status.staleCount, expired: status.expiredCount },
+        database: {
+          size: status.dbSize,
+          size_bytes: status.dbSizeBytes,
+          stale_paths: status.staleCount,
+          expired: status.expiredCount,
+        },
         embeddings: status.embeddingStatus,
         embed_model_available: status.embedModelAvailable,
-        health: status.errors.length === 0 && !status.stalePaths ? "ok" : "degraded",
+        health:
+          status.errors.length === 0 && !status.stalePaths ? "ok" : "degraded",
         errors: status.errors,
       });
     }
@@ -243,13 +321,17 @@ async function main() {
       const idMatch = url.match(/\/api\/vault\/entries\/([^/]+)$/);
       if (idMatch) {
         const entry = stmts.getEntryById.get(idMatch[1]);
-        if (!entry) return json({ error: "Entry not found", code: "NOT_FOUND" }, 404);
+        if (!entry)
+          return json({ error: "Entry not found", code: "NOT_FOUND" }, 404);
         return json(formatEntry(entry));
       }
       const u = new URL(req.url || "", "http://localhost");
       const kind = u.searchParams.get("kind") || null;
       const category = u.searchParams.get("category") || null;
-      const limit = Math.min(parseInt(u.searchParams.get("limit") || "20", 10) || 20, 100);
+      const limit = Math.min(
+        parseInt(u.searchParams.get("limit") || "20", 10) || 20,
+        100,
+      );
       const offset = parseInt(u.searchParams.get("offset") || "0", 10) || 0;
       const clauses = ["(expires_at IS NULL OR expires_at > datetime('now'))"];
       const params = [];
@@ -262,37 +344,44 @@ async function main() {
         params.push(category);
       }
       const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
-      const total = ctx.db.prepare(`SELECT COUNT(*) as c FROM vault ${where}`).get(...params).c;
-      const rows = ctx.db.prepare(`SELECT * FROM vault ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`).all(...params, limit, offset);
+      const total = ctx.db
+        .prepare(`SELECT COUNT(*) as c FROM vault ${where}`)
+        .get(...params).c;
+      const rows = ctx.db
+        .prepare(
+          `SELECT * FROM vault ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`,
+        )
+        .all(...params, limit, offset);
       return json({ entries: rows.map(formatEntry), total, limit, offset });
     }
 
     // ─── API: POST /api/vault/entries ────────────────────────────────────────
     if (url === "/api/vault/entries" && req.method === "POST") {
       const data = await readBody();
-      if (!data) return json({ error: "Invalid JSON body", code: "INVALID_INPUT" }, 400);
+      if (!data)
+        return json({ error: "Invalid JSON body", code: "INVALID_INPUT" }, 400);
       const err = validateEntry(data);
-      if (err) return json({ error: err.error, code: "INVALID_INPUT" }, err.status);
+      if (err)
+        return json({ error: err.error, code: "INVALID_INPUT" }, err.status);
       try {
-        const entry = await captureAndIndex(
-          ctx,
-          {
-            kind: data.kind,
-            title: data.title,
-            body: data.body,
-            meta: data.meta,
-            tags: data.tags,
-            source: data.source || "rest-api",
-            identity_key: data.identity_key,
-            expires_at: data.expires_at,
-            userId: null,
-          },
-          indexEntry
-        );
+        const entry = await captureAndIndex(ctx, {
+          kind: data.kind,
+          title: data.title,
+          body: data.body,
+          meta: data.meta,
+          tags: data.tags,
+          source: data.source || "rest-api",
+          identity_key: data.identity_key,
+          expires_at: data.expires_at,
+          userId: null,
+        });
         return json(formatEntry(stmts.getEntryById.get(entry.id)), 201);
       } catch (e) {
         console.error(`[local-server] Create error: ${e.message}`);
-        return json({ error: "Failed to create entry", code: "CREATE_FAILED" }, 500);
+        return json(
+          { error: "Failed to create entry", code: "CREATE_FAILED" },
+          500,
+        );
       }
     }
 
@@ -300,11 +389,17 @@ async function main() {
     if (url.match(/^\/api\/vault\/entries\/[^/]+$/) && req.method === "PUT") {
       const id = url.split("/").pop();
       const data = await readBody();
-      if (!data) return json({ error: "Invalid JSON body", code: "INVALID_INPUT" }, 400);
-      const err = validateEntry(data, { requireKind: false, requireBody: false });
-      if (err) return json({ error: err.error, code: "INVALID_INPUT" }, err.status);
+      if (!data)
+        return json({ error: "Invalid JSON body", code: "INVALID_INPUT" }, 400);
+      const err = validateEntry(data, {
+        requireKind: false,
+        requireBody: false,
+      });
+      if (err)
+        return json({ error: err.error, code: "INVALID_INPUT" }, err.status);
       const existing = stmts.getEntryById.get(id);
-      if (!existing) return json({ error: "Entry not found", code: "NOT_FOUND" }, 404);
+      if (!existing)
+        return json({ error: "Entry not found", code: "NOT_FOUND" }, 404);
       try {
         const entry = updateEntryFile(ctx, existing, {
           title: data.title,
@@ -318,15 +413,22 @@ async function main() {
         return json(formatEntry(stmts.getEntryById.get(id)));
       } catch (e) {
         console.error(`[local-server] Update error: ${e.message}`);
-        return json({ error: "Failed to update entry", code: "UPDATE_FAILED" }, 500);
+        return json(
+          { error: "Failed to update entry", code: "UPDATE_FAILED" },
+          500,
+        );
       }
     }
 
     // ─── API: DELETE /api/vault/entries/:id ──────────────────────────────────
-    if (url.match(/^\/api\/vault\/entries\/[^/]+$/) && req.method === "DELETE") {
+    if (
+      url.match(/^\/api\/vault\/entries\/[^/]+$/) &&
+      req.method === "DELETE"
+    ) {
       const id = url.split("/").pop();
       const entry = stmts.getEntryById.get(id);
-      if (!entry) return json({ error: "Entry not found", code: "NOT_FOUND" }, 404);
+      if (!entry)
+        return json({ error: "Entry not found", code: "NOT_FOUND" }, 404);
       if (entry.file_path) {
         try {
           unlinkSync(entry.file_path);
@@ -339,13 +441,19 @@ async function main() {
         } catch {}
       }
       stmts.deleteEntry.run(id);
-      return json({ deleted: true, id, kind: entry.kind, title: entry.title || null });
+      return json({
+        deleted: true,
+        id,
+        kind: entry.kind,
+        title: entry.title || null,
+      });
     }
 
     // ─── API: POST /api/vault/search ─────────────────────────────────────────
     if (url === "/api/vault/search" && req.method === "POST") {
       const data = await readBody();
-      if (!data || !data.query?.trim()) return json({ error: "query is required", code: "INVALID_INPUT" }, 400);
+      if (!data || !data.query?.trim())
+        return json({ error: "query is required", code: "INVALID_INPUT" }, 400);
       const limit = Math.min(parseInt(data.limit || 20, 10) || 20, 100);
       const offset = parseInt(data.offset || 0, 10) || 0;
       try {
@@ -357,8 +465,15 @@ async function main() {
           decayDays: ctx.config.eventDecayDays || 30,
           userIdFilter: undefined,
         });
-        const formatted = results.map((row) => ({ ...formatEntry(row), score: Math.round(row.score * 1000) / 1000 }));
-        return json({ results: formatted, count: formatted.length, query: data.query });
+        const formatted = results.map((row) => ({
+          ...formatEntry(row),
+          score: Math.round(row.score * 1000) / 1000,
+        }));
+        return json({
+          results: formatted,
+          count: formatted.length,
+          query: data.query,
+        });
       } catch (e) {
         console.error(`[local-server] Search error: ${e.message}`);
         return json({ error: "Search failed", code: "SEARCH_FAILED" }, 500);
@@ -369,28 +484,60 @@ async function main() {
     if (url === "/api/vault/import/bulk" && req.method === "POST") {
       const data = await readBody();
       if (!data || !Array.isArray(data.entries)) {
-        return json({ error: "Invalid body — expected { entries: [...] }", code: "INVALID_INPUT" }, 400);
+        return json(
+          {
+            error: "Invalid body — expected { entries: [...] }",
+            code: "INVALID_INPUT",
+          },
+          400,
+        );
       }
       if (data.entries.length > 500) {
-        return json({ error: "Maximum 500 entries per request", code: "LIMIT_EXCEEDED" }, 400);
+        return json(
+          { error: "Maximum 500 entries per request", code: "LIMIT_EXCEEDED" },
+          400,
+        );
       }
 
-      const result = await importEntries(ctx, data.entries, { source: "bulk-import" });
-      return json({ imported: result.imported, failed: result.failed, errors: result.errors.slice(0, 10).map((e) => e.error) });
+      const result = await importEntries(ctx, data.entries, {
+        source: "bulk-import",
+      });
+      return json({
+        imported: result.imported,
+        failed: result.failed,
+        errors: result.errors.slice(0, 10).map((e) => e.error),
+      });
     }
 
     // ─── API: POST /api/vault/import/file — Import from file content ────────
     if (url === "/api/vault/import/file" && req.method === "POST") {
       const data = await readBody();
       if (!data?.filename || !data?.content) {
-        return json({ error: "filename and content are required", code: "INVALID_INPUT" }, 400);
+        return json(
+          { error: "filename and content are required", code: "INVALID_INPUT" },
+          400,
+        );
       }
 
-      const entries = parseFile(data.filename, data.content, { kind: data.kind, source: data.source || "file-import" });
-      if (!entries.length) return json({ imported: 0, failed: 0, errors: ["No entries parsed from file"] });
+      const entries = parseFile(data.filename, data.content, {
+        kind: data.kind,
+        source: data.source || "file-import",
+      });
+      if (!entries.length)
+        return json({
+          imported: 0,
+          failed: 0,
+          errors: ["No entries parsed from file"],
+        });
 
-      const result = await importEntries(ctx, entries, { source: data.source || "file-import" });
-      return json({ imported: result.imported, failed: result.failed, errors: result.errors.slice(0, 10).map((e) => e.error) });
+      const result = await importEntries(ctx, entries, {
+        source: data.source || "file-import",
+      });
+      return json({
+        imported: result.imported,
+        failed: result.failed,
+        errors: result.errors.slice(0, 10).map((e) => e.error),
+      });
     }
 
     // ─── API: GET /api/vault/export — Export all entries ─────────────────────
@@ -398,14 +545,27 @@ async function main() {
       const u = new URL(req.url || "", "http://localhost");
       const format = u.searchParams.get("format") || "json";
 
-      const rows = ctx.db.prepare(
-        "SELECT * FROM vault WHERE (expires_at IS NULL OR expires_at > datetime('now')) ORDER BY created_at DESC"
-      ).all();
+      const rows = ctx.db
+        .prepare(
+          "SELECT * FROM vault WHERE (expires_at IS NULL OR expires_at > datetime('now')) ORDER BY created_at DESC",
+        )
+        .all();
 
       const entries = rows.map(formatEntry);
 
       if (format === "csv") {
-        const headers = ["id", "kind", "category", "title", "body", "tags", "source", "identity_key", "expires_at", "created_at"];
+        const headers = [
+          "id",
+          "kind",
+          "category",
+          "title",
+          "body",
+          "tags",
+          "source",
+          "identity_key",
+          "expires_at",
+          "created_at",
+        ];
         const csvLines = [headers.join(",")];
         for (const e of entries) {
           const row = headers.map((h) => {
@@ -420,34 +580,57 @@ async function main() {
           });
           csvLines.push(row.join(","));
         }
-        res.writeHead(200, { "Content-Type": "text/csv", "Access-Control-Allow-Origin": "*" });
+        res.writeHead(200, {
+          "Content-Type": "text/csv",
+          "Access-Control-Allow-Origin": "*",
+        });
         res.end(csvLines.join("\n"));
         return;
       }
 
-      return json({ entries, total: entries.length, exported_at: new Date().toISOString() });
+      return json({
+        entries,
+        total: entries.length,
+        exported_at: new Date().toISOString(),
+      });
     }
 
     // ─── API: POST /api/vault/ingest — Fetch URL and save as entry ──────────
     if (url === "/api/vault/ingest" && req.method === "POST") {
       const data = await readBody();
-      if (!data?.url) return json({ error: "url is required", code: "INVALID_INPUT" }, 400);
+      if (!data?.url)
+        return json({ error: "url is required", code: "INVALID_INPUT" }, 400);
 
       try {
-        const entry = await ingestUrl(data.url, { kind: data.kind, tags: data.tags });
-        const result = await captureAndIndex(ctx, entry, indexEntry);
+        const entry = await ingestUrl(data.url, {
+          kind: data.kind,
+          tags: data.tags,
+        });
+        const result = await captureAndIndex(ctx, entry);
         return json(formatEntry(ctx.stmts.getEntryById.get(result.id)), 201);
       } catch (e) {
-        return json({ error: `Ingestion failed: ${e.message}`, code: "INGEST_FAILED" }, 500);
+        return json(
+          { error: `Ingestion failed: ${e.message}`, code: "INGEST_FAILED" },
+          500,
+        );
       }
     }
 
     // ─── API: GET /api/vault/manifest — Lightweight entry list for sync ─────
     if (url === "/api/vault/manifest" && req.method === "GET") {
-      const rows = ctx.db.prepare(
-        "SELECT id, kind, title, created_at FROM vault WHERE (expires_at IS NULL OR expires_at > datetime('now')) ORDER BY created_at DESC"
-      ).all();
-      return json({ entries: rows.map((r) => ({ id: r.id, kind: r.kind, title: r.title || null, created_at: r.created_at })) });
+      const rows = ctx.db
+        .prepare(
+          "SELECT id, kind, title, created_at FROM vault WHERE (expires_at IS NULL OR expires_at > datetime('now')) ORDER BY created_at DESC",
+        )
+        .all();
+      return json({
+        entries: rows.map((r) => ({
+          id: r.id,
+          kind: r.kind,
+          title: r.title || null,
+          created_at: r.created_at,
+        })),
+      });
     }
 
     // ─── API: GET /api/local/link — Get link status ─────────────────────────
@@ -456,7 +639,9 @@ async function main() {
       const configPath = join(dataDir, "config.json");
       let storedConfig = {};
       if (existsSync(configPath)) {
-        try { storedConfig = JSON.parse(readFileSync(configPath, "utf-8")); } catch {}
+        try {
+          storedConfig = JSON.parse(readFileSync(configPath, "utf-8"));
+        } catch {}
       }
       return json({
         linked: !!storedConfig.apiKey,
@@ -475,7 +660,9 @@ async function main() {
 
       let storedConfig = {};
       if (existsSync(configPath)) {
-        try { storedConfig = JSON.parse(readFileSync(configPath, "utf-8")); } catch {}
+        try {
+          storedConfig = JSON.parse(readFileSync(configPath, "utf-8"));
+        } catch {}
       }
 
       if (!data?.apiKey) {
@@ -508,9 +695,16 @@ async function main() {
         mkdirSync(dataDir, { recursive: true });
         writeFileSync(configPath, JSON.stringify(storedConfig, null, 2) + "\n");
 
-        return json({ linked: true, email: user.email, tier: user.tier || "free" });
+        return json({
+          linked: true,
+          email: user.email,
+          tier: user.tier || "free",
+        });
       } catch (e) {
-        return json({ error: `Verification failed: ${e.message}`, code: "AUTH_FAILED" }, 401);
+        return json(
+          { error: `Verification failed: ${e.message}`, code: "AUTH_FAILED" },
+          401,
+        );
       }
     }
 
@@ -520,16 +714,24 @@ async function main() {
       const configPath = join(dataDir, "config.json");
       let storedConfig = {};
       if (existsSync(configPath)) {
-        try { storedConfig = JSON.parse(readFileSync(configPath, "utf-8")); } catch {}
+        try {
+          storedConfig = JSON.parse(readFileSync(configPath, "utf-8"));
+        } catch {}
       }
 
       if (!storedConfig.apiKey) {
-        return json({ error: "Not linked. Use link endpoint first.", code: "NOT_LINKED" }, 400);
+        return json(
+          { error: "Not linked. Use link endpoint first.", code: "NOT_LINKED" },
+          400,
+        );
       }
 
       try {
         const local = buildLocalManifest(ctx);
-        const remote = await fetchRemoteManifest(storedConfig.hostedUrl, storedConfig.apiKey);
+        const remote = await fetchRemoteManifest(
+          storedConfig.hostedUrl,
+          storedConfig.apiKey,
+        );
         const plan = computeSyncPlan(local, remote);
         const result = await executeSync(ctx, {
           hostedUrl: storedConfig.hostedUrl,
@@ -538,12 +740,18 @@ async function main() {
         });
         return json(result);
       } catch (e) {
-        return json({ error: `Sync failed: ${e.message}`, code: "SYNC_FAILED" }, 500);
+        return json(
+          { error: `Sync failed: ${e.message}`, code: "SYNC_FAILED" },
+          500,
+        );
       }
     }
 
     // ─── Static files ───────────────────────────────────────────────────────
-    const filePath = join(APP_DIST, url === "/" ? "index.html" : url.replace(/^\//, ""));
+    const filePath = join(
+      APP_DIST,
+      url === "/" ? "index.html" : url.replace(/^\//, ""),
+    );
     if (!filePath.startsWith(APP_DIST)) {
       res.writeHead(403);
       res.end();
@@ -572,11 +780,15 @@ async function main() {
   });
 
   process.on("SIGINT", () => {
-    try { state.db.close(); } catch {}
+    try {
+      state.db.close();
+    } catch {}
     process.exit(0);
   });
   process.on("SIGTERM", () => {
-    try { state.db.close(); } catch {}
+    try {
+      state.db.close();
+    } catch {}
     process.exit(0);
   });
 }