@pgplex/pgconsole 0.1.1 → 0.2.1

package/dist/server.mjs

@@ -41051,16 +41051,17 @@ function requiredPlan(name) {
 var validSslModes = ["disable", "prefer", "require", "verify-full"];
 var DEFAULT_CONFIG = { users: [], groups: [], labels: [], connections: [], auth: void 0, ai: void 0, banner: void 0, license: void 0, iam: [], plan: "FREE", licenseExpiry: void 0, licenseMaxUsers: 1, licenseEmail: void 0, stripeCustomerId: void 0 };
 var loadedConfig = { ...DEFAULT_CONFIG };
+var demoMode = false;
 function isValidHexColor(color) {
   return /^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$/.test(color);
 }
 async function loadConfig(configPath) {
-  const path5 = configPath || "pgconsole.toml";
-  if (!existsSync(path5)) {
-    throw new Error(`Config file not found: ${path5}
+  demoMode = false;
+  if (!existsSync(configPath)) {
+    throw new Error(`Config file not found: ${configPath}
 See https://docs.pgconsole.com/configuration/config`);
   }
-  const content = readFileSync(path5, "utf-8");
+  const content = readFileSync(configPath, "utf-8");
   const parsed = parse2(content);
   let external_url = void 0;
   let license = void 0;
@@ -41496,6 +41497,24 @@ function getLicenseEmail() {
 function getStripeCustomerId() {
   return loadedConfig.stripeCustomerId;
 }
+function loadDemoConfig(port) {
+  demoMode = true;
+  loadedConfig = {
+    ...DEFAULT_CONFIG,
+    connections: [{
+      id: "demo",
+      name: "Demo Database",
+      host: "127.0.0.1",
+      port,
+      database: "postgres",
+      username: "postgres",
+      ssl_mode: "disable"
+    }]
+  };
+}
+function isDemoMode() {
+  return demoMode;
+}
 
 // server/lib/auth.ts
 var DEFAULT_SIGNIN_EXPIRY = "7d";
@@ -47402,9 +47421,9 @@ var stripe_esm_node_default = Stripe;
 // server/lib/stripe.ts
 var STRIPE_CONFIG = {
   production: {
-    secretKey: "sk_live_TODO",
-    priceIdMonthly: "",
-    priceIdAnnual: ""
+    secretKey: "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",
+    priceIdMonthly: "price_1SxRoPAeLQYhEB73WDP94cQL",
+    priceIdAnnual: "price_1SxRtGAeLQYhEB73eVoF9CWv"
   },
   development: {
     secretKey: "sk_test_51SxNkLAiTf6mjLlIo5lVvoXxyxh0gJEOECcLgQUH4YeTKUaeogfQsUJwAi22JOGq98AnEvoWQuFvqODH93QPB7BW00UBfwibpW",
@@ -54813,6 +54832,10 @@ var GetConstraintsResponse = class _GetConstraintsResponse extends Message {
    * @generated from field: repeated query.v1.ConstraintInfo constraints = 1;
    */
   constraints = [];
+  /**
+   * @generated from field: repeated query.v1.ConstraintInfo referenced_by = 2;
+   */
+  referencedBy = [];
   constructor(data) {
     super();
     proto3.util.initPartial(data, this);
@@ -54820,7 +54843,8 @@ var GetConstraintsResponse = class _GetConstraintsResponse extends Message {
   static runtime = proto3;
   static typeName = "query.v1.GetConstraintsResponse";
   static fields = proto3.util.newFieldList(() => [
-    { no: 1, name: "constraints", kind: "message", T: ConstraintInfo, repeated: true }
+    { no: 1, name: "constraints", kind: "message", T: ConstraintInfo, repeated: true },
+    { no: 2, name: "referenced_by", kind: "message", T: ConstraintInfo, repeated: true }
   ]);
   static fromBinary(bytes, options) {
     return new _GetConstraintsResponse().fromBinary(bytes, options);
@@ -57424,6 +57448,12 @@ var AssessChangeRiskResponse = class _AssessChangeRiskResponse extends Message {
    * @generated from field: string error = 3;
    */
   error = "";
+  /**
+   * Mermaid diagram of object dependencies
+   *
+   * @generated from field: string dependency_graph = 4;
+   */
+  dependencyGraph = "";
   constructor(data) {
     super();
     proto3.util.initPartial(data, this);
@@ -57445,6 +57475,13 @@ var AssessChangeRiskResponse = class _AssessChangeRiskResponse extends Message {
       kind: "scalar",
       T: 9
       /* ScalarType.STRING */
+    },
+    {
+      no: 4,
+      name: "dependency_graph",
+      kind: "scalar",
+      T: 9
+      /* ScalarType.STRING */
     }
   ]);
   static fromBinary(bytes, options) {
@@ -57549,6 +57586,8 @@ function createClient(details, appUser) {
     ssl: details.sslMode === "disable" ? false : details.sslMode,
     connect_timeout: 10,
     max: 1,
+    onnotice: () => {
+    },
     connection: {
       application_name: formatAppName(appUser),
       ...details.lockTimeout && { lock_timeout: details.lockTimeout },
@@ -62318,22 +62357,42 @@ function extractFunctionsFromStatement(stmt) {
 function getFunctionPermission(name) {
   return functionPermissions.get(name) ?? "read";
 }
+var TRANSACTION_UNSAFE_KINDS = /* @__PURE__ */ new Set([
+  "create_db",
+  "drop_db",
+  "create_tablespace",
+  "drop_tablespace",
+  "alter_system",
+  "vacuum",
+  "cluster",
+  "reindex"
+]);
 async function detectRequiredPermissions(sql) {
   try {
     const parsed = await parseSql(sql);
     if (parsed.statements.length === 0) {
-      return /* @__PURE__ */ new Set(["read"]);
+      return { permissions: /* @__PURE__ */ new Set(["read"]), statementCount: 0, transactionSafe: true };
     }
     const permissions = /* @__PURE__ */ new Set();
+    let transactionSafe = true;
     for (const stmt of parsed.statements) {
       permissions.add(getRequiredPermission(stmt.kind));
+      if (TRANSACTION_UNSAFE_KINDS.has(stmt.kind) || stmt.kind === "transaction") {
+        transactionSafe = false;
+      }
+      if (stmt.kind === "create_index" && stmt.concurrent) {
+        transactionSafe = false;
+      }
+      if (stmt.kind === "drop" && stmt.objectType === "index" && /\bCONCURRENTLY\b/i.test(stmt.source)) {
+        transactionSafe = false;
+      }
       for (const name of extractFunctionsFromStatement(stmt)) {
         permissions.add(getFunctionPermission(name));
       }
     }
-    return permissions;
+    return { permissions, statementCount: parsed.statements.length, transactionSafe };
   } catch {
-    return /* @__PURE__ */ new Set(["admin"]);
+    return { permissions: /* @__PURE__ */ new Set(["admin"]), statementCount: 1, transactionSafe: false };
   }
 }
 
@@ -62445,8 +62504,8 @@ var queryServiceHandlers = {
     if (!user) {
       throw new ConnectError("Authentication required", Code.Unauthenticated);
     }
-    const requiredPerms = await detectRequiredPermissions(req.sql);
-    requirePermissions(user, req.connectionId, requiredPerms, `execute query`);
+    const analysis = await detectRequiredPermissions(req.sql);
+    requirePermissions(user, req.connectionId, analysis.permissions, `execute query`);
     const details = getConnectionDetails(req.connectionId);
     const queryId = req.queryId;
     const client = createClient(details, user.email);
@@ -62473,7 +62532,10 @@ var queryServiceHandlers = {
         error: "",
         backendPid
       };
-      const result = await client.unsafe(req.sql);
+      const sql = analysis.statementCount > 1 && analysis.transactionSafe ? `BEGIN;
+${req.sql}
+COMMIT;` : req.sql;
+      const result = await client.unsafe(sql);
       const executionTimeMs = Date.now() - start2;
       let columnMeta = [];
       if (result.columns) {
@@ -62796,9 +62858,16 @@ var queryServiceHandlers = {
     const user = await getUserFromContext(context.values);
     requireAnyPermission(user, req.connectionId);
     const details = getConnectionDetails(req.connectionId);
-    const constraints = await withConnection(details, async (sql) => {
+    const result = await withConnection(details, async (sql) => {
       const rows = await sql`
+        WITH target AS (
+          SELECT c.oid FROM pg_class c
+          JOIN pg_namespace n ON n.oid = c.relnamespace
+          WHERE n.nspname = ${req.schema} AND c.relname = ${req.table}
+        )
+        -- Forward: constraints on this table
         SELECT
+          'constraint' as source,
           con.conname as name,
           CASE con.contype
             WHEN 'p' THEN 'PRIMARY KEY'
@@ -62817,26 +62886,42 @@ var queryServiceHandlers = {
              FROM pg_attribute af WHERE af.attrelid = con.confrelid AND af.attnum = ANY(con.confkey))
           END as ref_columns
         FROM pg_constraint con
-        JOIN pg_class c ON c.oid = con.conrelid
-        JOIN pg_namespace n ON n.oid = c.relnamespace
-        LEFT JOIN pg_attribute a ON a.attrelid = c.oid AND a.attnum = ANY(con.conkey)
-        WHERE n.nspname = ${req.schema}
-          AND c.relname = ${req.table}
+        JOIN target t ON con.conrelid = t.oid
+        LEFT JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(con.conkey)
         GROUP BY con.oid, con.conname, con.contype, con.confrelid, con.confkey
-        ORDER BY
-          CASE con.contype WHEN 'p' THEN 1 WHEN 'f' THEN 2 WHEN 'u' THEN 3 WHEN 'c' THEN 4 ELSE 5 END,
-          con.conname
+        UNION ALL
+        -- Reverse: FK constraints from other tables referencing this table
+        SELECT
+          'referenced_by' as source,
+          con.conname as name,
+          'FOREIGN KEY' as type,
+          (SELECT array_agg(a.attname ORDER BY array_position(con.conkey, a.attnum))
+           FROM pg_attribute a WHERE a.attrelid = con.conrelid AND a.attnum = ANY(con.conkey)) as columns,
+          pg_get_constraintdef(con.oid) as definition,
+          (SELECT ns.nspname || '.' || cs.relname FROM pg_class cs JOIN pg_namespace ns ON ns.oid = cs.relnamespace WHERE cs.oid = con.conrelid) as ref_table,
+          (SELECT array_agg(af.attname ORDER BY array_position(con.confkey, af.attnum))
+           FROM pg_attribute af WHERE af.attrelid = con.confrelid AND af.attnum = ANY(con.confkey)) as ref_columns
+        FROM pg_constraint con
+        JOIN target t ON con.confrelid = t.oid
+        WHERE con.contype = 'f'
       `;
-      return rows.map((r2) => ({
+      const mapRow = (r2) => ({
         name: r2.name,
         type: r2.type,
         columns: r2.columns || [],
         definition: r2.definition,
         refTable: r2.ref_table || "",
         refColumns: r2.ref_columns || []
-      }));
+      });
+      const constraints = rows.filter((r2) => r2.source === "constraint").sort((a, b) => {
+        const order = { "PRIMARY KEY": 1, "FOREIGN KEY": 2, "UNIQUE": 3, "CHECK": 4, "EXCLUDE": 5 };
+        const diff = (order[a.type] ?? 6) - (order[b.type] ?? 6);
+        return diff !== 0 ? diff : a.name.localeCompare(b.name);
+      }).map(mapRow);
+      const referencedBy = rows.filter((r2) => r2.source === "referenced_by").map(mapRow);
+      return { constraints, referencedBy };
     }, user?.email);
-    return { constraints };
+    return result;
   },
   async getTriggers(req, context) {
     if (!req.connectionId) {
@@ -92198,9 +92283,9 @@ var ASSESS_RISK = {
 
 ## Focus Areas
 
-- **Data Loss**: Permanent deletion of data, large-scale operations (100+ rows)
-- **Foreign Key Impact**: Cascading deletes, orphaned records, constraint violations
-- **Dependent Objects**: Impact on views, materialized views, functions, triggers
+- **Foreign Key Cascading**: Trace every foreign key chain in the schema. A DELETE or UPDATE on a parent table may CASCADE to child tables, which may in turn cascade further. Flag the full cascade path and estimate affected scope. Also flag operations that would violate FK constraints (inserting with non-existent references, dropping referenced columns/tables).
+- **Data Loss**: Permanent deletion of data, large-scale operations (100+ rows), TRUNCATE
+- **Dependent Objects**: Impact on views, materialized views, functions, triggers that reference the affected tables
 - **Critical Columns**: Changes to primary keys, foreign keys, unique constraints
 - **Transaction Scope**: Multi-table operations, data consistency concerns
 
@@ -92223,7 +92308,19 @@ The operations appear safe with no major integrity concerns detected.
 - Focus on data integrity risks, not query performance
 - Consider cascading effects and dependent objects
 - Identify potential data loss or corruption scenarios
-- Keep descriptions concise but actionable`,
+- Keep descriptions concise but actionable
+
+## Dependency Graph
+
+If the operations involve dependencies between database objects, include a Mermaid flowchart showing the affected tables and how changes propagate. Use this format:
+
+\`\`\`mermaid
+graph TD
+  orders -->|CASCADE DELETE| order_items
+  products -->|RESTRICT| order_items
+\`\`\`
+
+Only include the graph if there are meaningful dependencies. Omit it for simple, independent operations.`,
   user: ({ sqlStatements }) => `Assess the risk of executing these SQL statements:
 
 ${sqlStatements}`
@@ -92266,6 +92363,12 @@ async function getOrRefreshSchema(connectionId, schemas) {
   return cached.formatted;
 }
 function parseRiskAssessment(response) {
+  let dependencyGraph = "";
+  const mermaidMatch = response.match(/```mermaid\n([\s\S]*?)```/);
+  if (mermaidMatch) {
+    dependencyGraph = mermaidMatch[1].trim();
+    response = response.replace(/```mermaid\n[\s\S]*?```/, "").trim();
+  }
   const lines = response.trim().split("\n");
   const firstLine = lines[0].trim().toUpperCase();
   const overallRisk = firstLine.match(/\b(HIGH|MODERATE|LOW)\b/)?.[1] || "MODERATE";
@@ -92297,7 +92400,7 @@ function parseRiskAssessment(response) {
       description: response.substring(firstLine.length).trim() || "Risk assessment completed."
     });
   }
-  return { overallRisk: overallRisk.toLowerCase(), findings };
+  return { overallRisk: overallRisk.toLowerCase(), findings, dependencyGraph };
 }
 var aiServiceHandlers = {
   async listAIProviders() {
@@ -92489,11 +92592,12 @@ var aiServiceHandlers = {
       return {
         overallRisk: parsed.overallRisk,
         findings: parsed.findings,
-        error: ""
+        error: "",
+        dependencyGraph: parsed.dependencyGraph
       };
     } catch (err) {
       const message2 = err instanceof Error ? err.message : "Failed to assess change risk";
-      return { overallRisk: "", findings: [], error: message2 };
+      return { overallRisk: "", findings: [], error: message2, dependencyGraph: "" };
     }
   }
 };
@@ -92527,6 +92631,180 @@ var connectRouter = expressConnectMiddleware({
   }
 });
 
+// server/lib/demo.ts
+import { PGlite } from "@electric-sql/pglite";
+import { PGLiteSocketServer } from "@electric-sql/pglite-socket";
+var db;
+var socketServer;
+var SEED_SQL = `
+CREATE TABLE departments (
+  id SERIAL PRIMARY KEY,
+  name VARCHAR(100) NOT NULL,
+  location VARCHAR(100),
+  created_at TIMESTAMP DEFAULT NOW()
+);
+
+CREATE TABLE employees (
+  id SERIAL PRIMARY KEY,
+  first_name VARCHAR(50) NOT NULL,
+  last_name VARCHAR(50) NOT NULL,
+  email VARCHAR(100) UNIQUE NOT NULL,
+  department_id INTEGER REFERENCES departments(id),
+  title VARCHAR(100),
+  salary NUMERIC(10,2),
+  hire_date DATE DEFAULT CURRENT_DATE,
+  created_at TIMESTAMP DEFAULT NOW()
+);
+
+CREATE TABLE projects (
+  id SERIAL PRIMARY KEY,
+  name VARCHAR(100) NOT NULL,
+  description TEXT,
+  department_id INTEGER REFERENCES departments(id),
+  lead_id INTEGER REFERENCES employees(id),
+  status VARCHAR(20) DEFAULT 'active' CHECK (status IN ('active', 'completed', 'on_hold')),
+  start_date DATE DEFAULT CURRENT_DATE,
+  created_at TIMESTAMP DEFAULT NOW()
+);
+
+CREATE VIEW employee_directory AS
+SELECT
+  e.id,
+  e.first_name || ' ' || e.last_name AS full_name,
+  e.email,
+  e.title,
+  d.name AS department,
+  d.location
+FROM employees e
+LEFT JOIN departments d ON e.department_id = d.id
+ORDER BY e.last_name, e.first_name;
+
+INSERT INTO departments (name, location) VALUES
+  ('Engineering', 'San Francisco'),
+  ('Marketing', 'New York'),
+  ('Sales', 'Chicago'),
+  ('Human Resources', 'San Francisco');
+
+INSERT INTO employees (first_name, last_name, email, department_id, title, salary, hire_date) VALUES
+  ('Alice', 'Chen', 'alice.chen@example.com', 1, 'Staff Engineer', 185000, '2021-03-15'),
+  ('Bob', 'Smith', 'bob.smith@example.com', 1, 'Senior Engineer', 165000, '2022-01-10'),
+  ('Carol', 'Johnson', 'carol.johnson@example.com', 2, 'Marketing Director', 155000, '2020-06-01'),
+  ('David', 'Williams', 'david.williams@example.com', 3, 'Sales Manager', 130000, '2023-02-20'),
+  ('Eva', 'Martinez', 'eva.martinez@example.com', 1, 'Engineer', 140000, '2023-07-01'),
+  ('Frank', 'Brown', 'frank.brown@example.com', 2, 'Content Strategist', 110000, '2023-09-15'),
+  ('Grace', 'Lee', 'grace.lee@example.com', 4, 'HR Manager', 125000, '2021-11-01'),
+  ('Henry', 'Taylor', 'henry.taylor@example.com', 3, 'Account Executive', 120000, '2024-01-08'),
+  ('Iris', 'Garcia', 'iris.garcia@example.com', 1, 'Engineering Manager', 175000, '2020-09-12'),
+  ('Jack', 'Wilson', 'jack.wilson@example.com', 2, 'Designer', 115000, '2024-03-01');
+
+INSERT INTO projects (name, description, department_id, lead_id, status, start_date) VALUES
+  ('Platform Redesign', 'Modernize the core platform architecture', 1, 1, 'active', '2024-01-15'),
+  ('Brand Refresh', 'Update brand guidelines and marketing materials', 2, 3, 'active', '2024-02-01'),
+  ('Q1 Sales Campaign', 'Enterprise outreach for Q1', 3, 4, 'completed', '2024-01-01'),
+  ('Employee Portal', 'Internal HR self-service portal', 4, 7, 'active', '2024-03-01'),
+  ('API v2', 'Next generation public API', 1, 9, 'on_hold', '2024-04-01');
+
+-- Materialized view: department summary stats
+CREATE MATERIALIZED VIEW department_stats AS
+SELECT
+  d.id AS department_id,
+  d.name AS department,
+  COUNT(e.id) AS employee_count,
+  COALESCE(ROUND(AVG(e.salary), 2), 0) AS avg_salary,
+  COALESCE(MIN(e.hire_date), CURRENT_DATE) AS earliest_hire,
+  COUNT(p.id) AS project_count
+FROM departments d
+LEFT JOIN employees e ON e.department_id = d.id
+LEFT JOIN projects p ON p.department_id = d.id
+GROUP BY d.id, d.name;
+
+-- Function: look up employees by department name
+CREATE FUNCTION get_employees_by_department(dept_name TEXT)
+RETURNS TABLE(id INT, full_name TEXT, title VARCHAR, salary NUMERIC) AS $$
+BEGIN
+  RETURN QUERY
+  SELECT e.id, e.first_name || ' ' || e.last_name, e.title, e.salary
+  FROM employees e
+  JOIN departments d ON e.department_id = d.id
+  WHERE d.name = dept_name
+  ORDER BY e.last_name;
+END;
+$$ LANGUAGE plpgsql STABLE;
+
+-- Procedure: give a percentage raise to all employees in a department
+CREATE PROCEDURE give_department_raise(dept_name TEXT, pct NUMERIC)
+LANGUAGE plpgsql AS $$
+BEGIN
+  UPDATE employees SET salary = ROUND(salary * (1 + pct / 100), 2)
+  WHERE department_id = (SELECT id FROM departments WHERE name = dept_name);
+END;
+$$;
+
+-- analytics schema
+CREATE SCHEMA analytics;
+
+CREATE TABLE analytics.page_views (
+  id SERIAL PRIMARY KEY,
+  path VARCHAR(200) NOT NULL,
+  visitor_id UUID NOT NULL,
+  referrer VARCHAR(500),
+  duration_ms INTEGER,
+  viewed_at TIMESTAMP DEFAULT NOW()
+);
+
+CREATE TABLE analytics.events (
+  id SERIAL PRIMARY KEY,
+  name VARCHAR(100) NOT NULL,
+  visitor_id UUID NOT NULL,
+  properties JSONB DEFAULT '{}',
+  created_at TIMESTAMP DEFAULT NOW()
+);
+
+INSERT INTO analytics.page_views (path, visitor_id, referrer, duration_ms) VALUES
+  ('/', 'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11', 'https://google.com', 4200),
+  ('/pricing', 'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11', '/', 8500),
+  ('/', 'b1ffcd00-ad1c-5f09-cc7e-7ccace491b22', 'https://github.com', 3100),
+  ('/docs', 'b1ffcd00-ad1c-5f09-cc7e-7ccace491b22', '/', 12400),
+  ('/pricing', 'c200de11-be2d-4a00-dd8f-8ddbdf502c33', 'https://twitter.com', 6700),
+  ('/', 'c200de11-be2d-4a00-dd8f-8ddbdf502c33', NULL, 2300);
+
+INSERT INTO analytics.events (name, visitor_id, properties) VALUES
+  ('signup_click', 'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11', '{"plan": "pro"}'),
+  ('page_scroll', 'b1ffcd00-ad1c-5f09-cc7e-7ccace491b22', '{"depth": 75}'),
+  ('signup_click', 'c200de11-be2d-4a00-dd8f-8ddbdf502c33', '{"plan": "free"}'),
+  ('feature_click', 'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11', '{"feature": "sql-editor"}');
+
+CREATE VIEW analytics.daily_summary AS
+SELECT
+  viewed_at::date AS day,
+  COUNT(*) AS views,
+  COUNT(DISTINCT visitor_id) AS unique_visitors,
+  ROUND(AVG(duration_ms)) AS avg_duration_ms
+FROM analytics.page_views
+GROUP BY viewed_at::date;
+`;
+async function startDemoDatabase() {
+  db = await PGlite.create({ debug: 0 });
+  await db.exec(SEED_SQL);
+  return new Promise((resolve, reject) => {
+    socketServer = new PGLiteSocketServer({ db, port: 0 });
+    socketServer.addEventListener("listening", (event) => {
+      const detail = event.detail;
+      resolve(detail.port);
+    });
+    socketServer.addEventListener("error", (event) => {
+      reject(new Error(`Failed to start demo database: ${event}`));
+    });
+    socketServer.start();
+  });
+}
+async function stopDemoDatabase() {
+  await socketServer?.stop();
+  await db?.close();
+  db = void 0;
+  socketServer = void 0;
+}
+
 // server/lib/test-connections.ts
 async function testAllConnections() {
   const connections = getConnections();
@@ -92610,7 +92888,8 @@ app.get("/api/setting", (_req, res) => {
     licenseEmail: getLicenseEmail(),
     maxUsers: getLicenseMaxUsers(),
     userCount: getUsers().length,
-    stripeCustomerId: getStripeCustomerId()
+    stripeCustomerId: getStripeCustomerId(),
+    demo: isDemoMode()
   });
 });
 var clientDir = path4.join(__dirname, "client");
@@ -92630,13 +92909,19 @@ app.use((req, res, next) => {
 async function start() {
   const args = parseArgs();
   const port = args.port || process.env.PORT || 9876;
-  const configPath = args.config || "pgconsole.toml";
-  try {
-    await loadConfig(configPath);
-    console.log(`\u2713 Loaded config from: ${path4.resolve(configPath)}`);
-  } catch (error) {
-    console.error("Failed to load config:", error instanceof Error ? error.message : error);
-    process.exit(1);
+  if (!args.config) {
+    console.log("No --config specified \u2014 starting in demo mode...");
+    const demoPort = await startDemoDatabase();
+    loadDemoConfig(demoPort);
+    console.log(`\u2713 Demo database started on port ${demoPort}`);
+  } else {
+    try {
+      await loadConfig(args.config);
+      console.log(`\u2713 Loaded config from: ${path4.resolve(args.config)}`);
+    } catch (error) {
+      console.error("Failed to load config:", error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
   }
   const licenseExpiry = getLicenseExpiry();
   if (licenseExpiry) {
@@ -92663,7 +92948,7 @@ async function start() {
    \\ \\_\\    /\\____/
     \\/_/    \\_/__/
 
-    Version ${"0.1.1"}
+    Version ${"0.2.1-dev"}
 `);
     console.log(`Server running on http://localhost:${port}`);
     const browserUrl = false ? `http://localhost:5173` : getExternalUrl() || `http://localhost:${port}`;
@@ -92677,8 +92962,12 @@ async function start() {
     }
     process.exit(1);
   });
-  const shutdown = () => {
+  const shutdown = async () => {
     console.log("\nShutting down...");
+    try {
+      if (isDemoMode()) await stopDemoDatabase();
+    } catch {
+    }
     server.close(() => {
       process.exit(0);
     });