sqlite-hub 1.4.0 → 2.0.0

package/server/routes/externalApi.js

@@ -29,6 +29,232 @@ function readStoreName(req) {
   ).trim();
 }
 
+function decodePathPart(value = "") {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+
+function readPathParts(req) {
+  return String(req.path ?? "")
+    .split("/")
+    .map((part) => part.trim())
+    .filter(Boolean)
+    .map(decodePathPart);
+}
+
+function buildExternalApiAccessDescriptor(req) {
+  const method = String(req.method ?? "GET").toUpperCase();
+  const parts = readPathParts(req);
+
+  if (parts[0] === "info") {
+    return {
+      action: "api.info.get",
+      targetType: "app",
+      targetName: "info",
+    };
+  }
+
+  if (parts[0] === "query") {
+    return {
+      action: "api.query.execute",
+      databaseKey: readDatabaseId(req),
+      targetType: "query",
+      targetName: readStoreName(req) || "raw query",
+    };
+  }
+
+  if (parts[0] !== "databases") {
+    return {
+      action: `api.${method.toLowerCase()}`,
+      targetType: "request",
+      targetName: req.path,
+    };
+  }
+
+  const databaseKey = parts[1] ?? "";
+  const collection = parts[2] ?? "";
+  const itemName = parts[3] ?? "";
+  const subAction = parts[4] ?? "";
+
+  if (!collection) {
+    return {
+      action: "api.database.get",
+      databaseKey,
+      targetType: "database",
+      targetName: databaseKey,
+    };
+  }
+
+  if (collection === "tables") {
+    if (!itemName) {
+      return {
+        action: "api.tables.list",
+        databaseKey,
+        targetType: "database",
+        targetName: databaseKey,
+      };
+    }
+
+    if (subAction === "row") {
+      return {
+        action: "api.table.row.export",
+        databaseKey,
+        targetType: "table",
+        targetName: itemName,
+      };
+    }
+
+    if (subAction === "types") {
+      return {
+        action: "api.table.types.generate",
+        databaseKey,
+        targetType: "table",
+        targetName: itemName,
+      };
+    }
+
+    return {
+      action: "api.table.get",
+      databaseKey,
+      targetType: "table",
+      targetName: itemName,
+    };
+  }
+
+  if (collection === "backups") {
+    return {
+      action: method === "GET" ? "api.backups.list" : "api.backup.create",
+      databaseKey,
+      targetType: "database",
+      targetName: databaseKey,
+    };
+  }
+
+  if (collection === "queries") {
+    if (!itemName) {
+      return {
+        action: "api.queries.list",
+        databaseKey,
+        targetType: "database",
+        targetName: databaseKey,
+      };
+    }
+
+    if (subAction === "execute") {
+      return {
+        action: "api.query.execute.saved",
+        databaseKey,
+        targetType: "query",
+        targetName: itemName,
+      };
+    }
+
+    if (subAction === "export") {
+      return {
+        action: "api.query.export",
+        databaseKey,
+        targetType: "query",
+        targetName: itemName,
+      };
+    }
+
+    if (subAction === "notes") {
+      return {
+        action: "api.query.notes.get",
+        databaseKey,
+        targetType: "query",
+        targetName: itemName,
+      };
+    }
+
+    return {
+      action: "api.query.get",
+      databaseKey,
+      targetType: "query",
+      targetName: itemName,
+    };
+  }
+
+  if (collection === "documents") {
+    if (!itemName) {
+      return {
+        action: "api.documents.list",
+        databaseKey,
+        targetType: "database",
+        targetName: databaseKey,
+      };
+    }
+
+    if (subAction === "export") {
+      return {
+        action: "api.document.export",
+        databaseKey,
+        targetType: "document",
+        targetName: itemName,
+      };
+    }
+
+    return {
+      action: "api.document.get",
+      databaseKey,
+      targetType: "document",
+      targetName: itemName,
+    };
+  }
+
+  return {
+    action: `api.${collection}.${method.toLowerCase()}`,
+    databaseKey,
+    targetType: collection,
+    targetName: itemName || databaseKey,
+  };
+}
+
+function createExternalApiAccessLogger(appStateStore) {
+  return (req, res, next) => {
+    const startedAtMs = Date.now();
+    const startedAt = new Date(startedAtMs).toISOString();
+
+    res.on("finish", () => {
+      if (!appStateStore?.recordAccessLog) {
+        return;
+      }
+
+      const descriptor = buildExternalApiAccessDescriptor(req);
+      const failed = res.statusCode >= 400;
+
+      try {
+        appStateStore.recordAccessLog({
+          source: "api",
+          action: descriptor.action,
+          databaseKey: descriptor.databaseKey,
+          targetType: descriptor.targetType,
+          targetName: descriptor.targetName,
+          status: failed ? "error" : "success",
+          startedAt,
+          durationMs: Date.now() - startedAtMs,
+          errorMessage: failed ? req.accessLogError || `HTTP ${res.statusCode}` : null,
+          metadata: {
+            method: req.method,
+            path: req.path,
+            route: req.route?.path ? String(req.route.path) : null,
+            statusCode: res.statusCode,
+            apiTokenId: req.apiToken?.id ?? null,
+            apiTokenName: req.apiToken?.name ?? null,
+          },
+        });
+      } catch {
+        // Access logging must not change API behavior.
+      }
+    });
+
+    next();
+  };
+}
+
 function authenticateDatabaseRequest(req, tokenService, databaseId) {
   const token = readBearerToken(req.get("authorization"));
 
@@ -38,12 +264,24 @@ function authenticateDatabaseRequest(req, tokenService, databaseId) {
     });
   }
 
-  return tokenService.authenticate(databaseId, token);
+  const apiToken = tokenService.authenticate(databaseId, token);
+
+  req.apiToken = apiToken;
+  return apiToken;
 }
 
-function createExternalApiRouter({ databaseService, tokenService, appInfoService = buildAppInfo }) {
+function createExternalApiRouter({
+  databaseService,
+  tokenService,
+  appStateStore = null,
+  appInfoService = buildAppInfo,
+}) {
   const router = express.Router();
 
+  if (appStateStore?.recordAccessLog) {
+    router.use(createExternalApiAccessLogger(appStateStore));
+  }
+
   router.get(
     "/info",
     route(async (req, res) => {
@@ -131,6 +369,46 @@ function createExternalApiRouter({ databaseService, tokenService, appInfoService
     })
   );
 
+  router.get(
+    "/databases/:databaseId/backups",
+    route((req, res) => {
+      const backups = databaseService.listBackups(req.params.databaseId);
+
+      res.json(
+        successResponse({
+          data: {
+            items: backups,
+          },
+          metadata: {
+            databaseId: req.params.databaseId,
+            total: backups.length,
+          },
+        })
+      );
+    })
+  );
+
+  router.post(
+    "/databases/:databaseId/backups",
+    route(async (req, res) => {
+      const backup = await databaseService.createBackup(req.params.databaseId, {
+        name: req.body?.name,
+        notes: req.body?.notes,
+        context: req.body?.context ?? "api",
+      });
+
+      res.json(
+        successResponse({
+          message: "Backup created and verified.",
+          data: backup,
+          metadata: {
+            databaseId: req.params.databaseId,
+          },
+        })
+      );
+    })
+  );
+
   router.post(
     "/databases/:databaseId/tables/:tableName/row",
     route((req, res) => {
@@ -336,6 +614,11 @@ function createExternalApiRouter({ databaseService, tokenService, appInfoService
     })
   );
 
+  router.use((error, req, res, next) => {
+    req.accessLogError = error?.message ?? null;
+    next(error);
+  });
+
   return router;
 }
 

package/server/routes/logs.js

@@ -0,0 +1,127 @@
+const express = require("express");
+const { DatabaseRequiredError, route, successResponse } = require("../utils/errors");
+
+const RANGE_MS = {
+  "1h": 60 * 60 * 1000,
+  "24h": 24 * 60 * 60 * 1000,
+  "7d": 7 * 24 * 60 * 60 * 1000,
+  "30d": 30 * 24 * 60 * 60 * 1000,
+};
+
+function normalizeOption(value, allowedValues, fallback = "all") {
+  const normalized = String(value ?? fallback).trim().toLowerCase();
+  return allowedValues.includes(normalized) ? normalized : fallback;
+}
+
+function parseLimit(value) {
+  const numeric = Number(value);
+  return Number.isInteger(numeric) && numeric > 0 ? Math.min(numeric, 200) : 100;
+}
+
+function parseOffset(value) {
+  const numeric = Number(value);
+  return Number.isInteger(numeric) && numeric >= 0 ? numeric : 0;
+}
+
+function normalizeTimestamp(value) {
+  const normalized = String(value ?? "").trim();
+
+  if (!normalized) {
+    return null;
+  }
+
+  const timestamp = new Date(normalized).getTime();
+  return Number.isFinite(timestamp) ? new Date(timestamp).toISOString() : null;
+}
+
+function resolveTimeWindow(query = {}, now = new Date()) {
+  const explicitFrom = normalizeTimestamp(query.from);
+  const explicitTo = normalizeTimestamp(query.to);
+  const range = normalizeOption(query.range, ["1h", "24h", "7d", "30d", "all"], "all");
+
+  if (explicitFrom || explicitTo) {
+    return {
+      range,
+      from: explicitFrom,
+      to: explicitTo,
+    };
+  }
+
+  if (range === "all") {
+    return {
+      range,
+      from: null,
+      to: null,
+    };
+  }
+
+  return {
+    range,
+    from: new Date(now.getTime() - RANGE_MS[range]).toISOString(),
+    to: now.toISOString(),
+  };
+}
+
+function resolveActiveDatabase(connectionManager) {
+  const activeDatabase = connectionManager.getActiveConnection() ?? null;
+
+  if (!activeDatabase?.id) {
+    throw new DatabaseRequiredError();
+  }
+
+  return activeDatabase;
+}
+
+function createLogsRouter({ appStateStore, connectionManager, now = () => new Date() }) {
+  const router = express.Router();
+
+  router.get(
+    "/",
+    route((req, res) => {
+      const timeWindow = resolveTimeWindow(req.query, now());
+      const activeDatabase = resolveActiveDatabase(connectionManager);
+      const kind = normalizeOption(req.query.kind, ["all", "query", "access"], "all");
+      const actor = normalizeOption(req.query.actor, ["all", "user", "cli", "api", "mcp"], "all");
+      const status = normalizeOption(req.query.status, ["all", "success", "error"], "all");
+      const queryType = normalizeOption(
+        req.query.queryType,
+        ["all", "select", "insert", "update", "delete", "pragma", "create", "alter", "drop", "other"],
+        "all"
+      );
+      const destructive = normalizeOption(req.query.destructive, ["all", "yes", "no"], "all");
+      const search = String(req.query.search ?? "").trim();
+      const result = appStateStore.listActivityLogs({
+        kind,
+        actor: actor === "all" ? null : actor,
+        status: status === "all" ? null : status,
+        databaseKey: activeDatabase.id,
+        queryType: queryType === "all" ? null : queryType,
+        destructive,
+        from: timeWindow.from,
+        to: timeWindow.to,
+        search,
+        limit: parseLimit(req.query.limit),
+        offset: parseOffset(req.query.offset),
+      });
+
+      res.json(
+        successResponse({
+          data: result,
+          metadata: {
+            ...result.filters,
+            range: timeWindow.range,
+            activeDatabase,
+          },
+        })
+      );
+    })
+  );
+
+  return router;
+}
+
+module.exports = {
+  createLogsRouter,
+  resolveActiveDatabase,
+  resolveTimeWindow,
+};

package/server/routes/settings.js

@@ -1,4 +1,5 @@
 const express = require("express");
+const path = require("node:path");
 const { AppError, DatabaseRequiredError, route, successResponse } = require("../utils/errors");
 const {
   checkLatestAppVersion,
@@ -7,6 +8,8 @@ const {
   readSettingsMetadata,
   readSqliteVersion,
 } = require("../services/appInfoService");
+const { McpStatusService } = require("../services/mcpStatusService");
+const { MCP_TOOL_DEFINITIONS } = require("../services/mcpToolService");
 
 function getActiveTokenContext({ connectionManager, tokenService }) {
   const activeDatabase = connectionManager?.getActiveConnection?.() ?? null;
@@ -34,6 +37,37 @@ function buildSettingsMetadata(context) {
   };
 }
 
+function buildMcpCodexConfig() {
+  const serverPath = path.resolve(__dirname, "../../bin/sqlite-hub-mcp.js");
+
+  return [
+    "[mcp_servers.sqlitehub]",
+    'command = "node"',
+    `args = [${JSON.stringify(serverPath)}]`,
+    "startup_timeout_sec = 10",
+    "tool_timeout_sec = 60",
+  ].join("\n");
+}
+
+function buildMcpSettingsStatus(appStateStore) {
+  const statusService = new McpStatusService({
+    appStateStore,
+    exposedTools: MCP_TOOL_DEFINITIONS,
+    transport: "stdio",
+  });
+  const status = statusService.getStatus();
+
+  return {
+    ...status,
+    toolDetails: MCP_TOOL_DEFINITIONS.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+    })),
+    command: `node ${path.resolve(__dirname, "../../bin/sqlite-hub-mcp.js")}`,
+    codexConfig: buildMcpCodexConfig(),
+  };
+}
+
 function createSettingsRouter({ appStateStore, connectionManager, tokenService, versionCheckService }) {
   const router = express.Router();
   const context = { connectionManager, tokenService };
@@ -89,6 +123,17 @@ function createSettingsRouter({ appStateStore, connectionManager, tokenService,
     })
   );
 
+  router.get(
+    "/mcp",
+    route((req, res) => {
+      res.json(
+        successResponse({
+          data: buildMcpSettingsStatus(appStateStore),
+        })
+      );
+    })
+  );
+
   router.post(
     "/api-tokens",
     route((req, res) => {
@@ -126,6 +171,8 @@ function createSettingsRouter({ appStateStore, connectionManager, tokenService,
 
 module.exports = {
   createSettingsRouter,
+  buildMcpCodexConfig,
+  buildMcpSettingsStatus,
   buildSettingsMetadata,
   checkLatestAppVersion,
   compareSemver,

package/server/server.js

@@ -36,6 +36,7 @@ const { createSettingsRouter } = require("./routes/settings");
 const { createExportRouter } = require("./routes/export");
 const { createDocumentsRouter } = require("./routes/documents");
 const { createExternalApiRouter } = require("./routes/externalApi");
+const { createLogsRouter } = require("./routes/logs");
 
 const PACKAGE_ROOT = path.resolve(__dirname, "..");
 const FRONTEND_ROOT = path.join(PACKAGE_ROOT, "frontend");
@@ -133,11 +134,13 @@ app.use(
 );
 app.use("/api/export", createExportRouter({ exportService }));
 app.use("/api/documents", createDocumentsRouter({ appStateStore, connectionManager }));
+app.use("/api/logs", createLogsRouter({ appStateStore, connectionManager }));
 app.use(
   "/api/v1",
   createExternalApiRouter({
     databaseService: databaseCommandService,
     tokenService: apiTokenService,
+    appStateStore,
   })
 );