@runcontext/ui 0.5.2 → 0.5.4

package/dist/index.mjs

@@ -1,9 +1,9 @@
 // src/server.ts
-import { Hono as Hono6 } from "hono";
+import { Hono as Hono8 } from "hono";
 import { serve } from "@hono/node-server";
 import { cors } from "hono/cors";
-import * as fs5 from "fs";
-import * as path4 from "path";
+import * as fs6 from "fs";
+import * as path6 from "path";
 import * as url from "url";
 
 // src/routes/api/brief.ts
@@ -22,17 +22,17 @@ function briefRoutes(contextDir) {
     }
     const brief = ContextBriefSchema.parse(body);
     brief.created_at = brief.created_at || (/* @__PURE__ */ new Date()).toISOString();
-    const productDir = path.join(contextDir, "products", brief.product_name);
-    fs.mkdirSync(productDir, { recursive: true });
-    fs.writeFileSync(path.join(productDir, "context-brief.yaml"), stringify(brief), "utf-8");
-    return c.json({ ok: true, path: `products/${brief.product_name}/context-brief.yaml` });
+    const briefPath = path.join(contextDir, `${brief.product_name}.context-brief.yaml`);
+    fs.mkdirSync(contextDir, { recursive: true });
+    fs.writeFileSync(briefPath, stringify(brief), "utf-8");
+    return c.json({ ok: true, path: `${brief.product_name}.context-brief.yaml` });
   });
   app.get("/api/brief/:name", async (c) => {
     const name = c.req.param("name");
     if (!PRODUCT_NAME_RE.test(name)) {
       return c.json({ error: "Invalid product name" }, 400);
     }
-    const briefPath = path.join(contextDir, "products", name, "context-brief.yaml");
+    const briefPath = path.join(contextDir, `${name}.context-brief.yaml`);
     if (!fs.existsSync(briefPath)) return c.json({ error: "Not found" }, 404);
     return c.json(parse(fs.readFileSync(briefPath, "utf-8")));
   });
@@ -42,10 +42,183 @@ function briefRoutes(contextDir) {
 // src/routes/api/sources.ts
 import { Hono as Hono2 } from "hono";
 import * as fs2 from "fs";
+import * as os from "os";
+import * as path2 from "path";
+import * as yaml from "yaml";
+var NAME_PATTERNS = {
+  duckdb: "duckdb",
+  motherduck: "duckdb",
+  postgres: "postgres",
+  postgresql: "postgres",
+  neon: "postgres",
+  supabase: "postgres",
+  mysql: "mysql",
+  sqlite: "sqlite",
+  snowflake: "snowflake",
+  bigquery: "bigquery",
+  clickhouse: "clickhouse",
+  databricks: "databricks",
+  mssql: "mssql",
+  "sql-server": "mssql",
+  redshift: "postgres"
+};
+var PACKAGE_PATTERNS = {
+  "@motherduck/mcp": "duckdb",
+  "mcp-server-duckdb": "duckdb",
+  "mcp-server-postgres": "postgres",
+  "mcp-server-postgresql": "postgres",
+  "@neon/mcp": "postgres",
+  "@supabase/mcp": "postgres",
+  "mcp-server-mysql": "mysql",
+  "mcp-server-sqlite": "sqlite",
+  "mcp-server-snowflake": "snowflake",
+  "mcp-server-bigquery": "bigquery",
+  "mcp-server-clickhouse": "clickhouse",
+  "mcp-server-databricks": "databricks",
+  "mcp-server-mssql": "mssql",
+  "mcp-server-redshift": "postgres"
+};
+function readJsonSafe(filePath) {
+  try {
+    if (!fs2.existsSync(filePath)) return null;
+    let raw = fs2.readFileSync(filePath, "utf-8");
+    raw = raw.replace(/[\x00-\x08\x0b\x0c\x0e-\x1f]/g, "");
+    try {
+      return JSON.parse(raw);
+    } catch {
+      const cleaned = raw.replace(/^\s*\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/,(\s*[}\]])/g, "$1");
+      return JSON.parse(cleaned);
+    }
+  } catch {
+    return null;
+  }
+}
+function getConfigLocations(cwd) {
+  const home = os.homedir();
+  const locations = [];
+  locations.push({ ide: "claude-code", path: path2.join(cwd, ".mcp.json") });
+  locations.push({ ide: "claude-code", path: path2.join(home, ".claude.json") });
+  locations.push({ ide: "claude-code", path: path2.join(home, ".claude", "mcp_servers.json") });
+  if (process.platform === "darwin") {
+    locations.push({ ide: "claude-desktop", path: path2.join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json") });
+  } else if (process.platform === "win32") {
+    const appData = process.env.APPDATA ?? path2.join(home, "AppData", "Roaming");
+    locations.push({ ide: "claude-desktop", path: path2.join(appData, "Claude", "claude_desktop_config.json") });
+  } else {
+    locations.push({ ide: "claude-desktop", path: path2.join(home, ".config", "claude", "claude_desktop_config.json") });
+  }
+  locations.push({ ide: "cursor", path: path2.join(cwd, ".cursor", "mcp.json") });
+  locations.push({ ide: "cursor", path: path2.join(home, ".cursor", "mcp.json") });
+  if (process.platform === "darwin") {
+    locations.push({ ide: "cursor", path: path2.join(home, "Library", "Application Support", "Cursor", "User", "globalStorage", "cursor.mcp", "mcp.json") });
+  }
+  locations.push({ ide: "vscode", path: path2.join(cwd, ".vscode", "mcp.json") });
+  locations.push({ ide: "windsurf", path: path2.join(cwd, ".windsurf", "mcp.json") });
+  if (process.platform === "darwin") {
+    locations.push({ ide: "windsurf", path: path2.join(home, "Library", "Application Support", "Windsurf", "User", "globalStorage", "windsurf.mcp", "mcp.json") });
+  }
+  return locations;
+}
+function detectAdapterType(serverName, entry) {
+  const nameLower = serverName.toLowerCase();
+  for (const [pattern, adapter] of Object.entries(NAME_PATTERNS)) {
+    if (nameLower.includes(pattern)) return adapter;
+  }
+  const args = entry.args ?? [];
+  const allArgs = [entry.command ?? "", ...args].join(" ").toLowerCase();
+  for (const [pkg, adapter] of Object.entries(PACKAGE_PATTERNS)) {
+    if (allArgs.includes(pkg.toLowerCase())) return adapter;
+  }
+  if (entry.url) {
+    const urlLower = entry.url.toLowerCase();
+    for (const [pattern, adapter] of Object.entries(NAME_PATTERNS)) {
+      if (urlLower.includes(pattern)) return adapter;
+    }
+  }
+  return null;
+}
+function discoverMcpDatabases(cwd) {
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  try {
+    const locations = getConfigLocations(cwd);
+    for (const loc of locations) {
+      const json = readJsonSafe(loc.path);
+      if (!json) continue;
+      const servers = json.mcpServers ?? json.mcp_servers ?? json.servers ?? json;
+      if (!servers || typeof servers !== "object") continue;
+      for (const [serverName, entry] of Object.entries(servers)) {
+        if (!entry || typeof entry !== "object") continue;
+        const adapterType = detectAdapterType(serverName, entry);
+        if (!adapterType) continue;
+        const key = `${adapterType}:${serverName}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        const dbInfo = extractDbName(entry);
+        const label = dbInfo ? `${serverName} (${adapterType}${dbInfo ? " \u2014 " + dbInfo : ""})` : `${serverName} (${adapterType})`;
+        results.push({
+          name: label,
+          adapter: adapterType,
+          origin: `mcp:${loc.ide}/${serverName}`,
+          status: "detected"
+        });
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+function extractDbName(entry) {
+  const args = entry.args ?? [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if ((arg === "--database" || arg === "--db" || arg === "--dbname") && args[i + 1]) {
+      return args[i + 1];
+    }
+    if (arg && /^(postgres|mysql|mssql|clickhouse):\/\//.test(arg)) {
+      try {
+        const u = new URL(arg);
+        return u.pathname.replace(/^\//, "") || u.hostname;
+      } catch {
+      }
+    }
+  }
+  if (entry.env) {
+    for (const [key, val] of Object.entries(entry.env)) {
+      if (/^(DATABASE_URL|POSTGRES_URL|PG_CONNECTION)/.test(key) && val) {
+        try {
+          const u = new URL(val);
+          return u.pathname.replace(/^\//, "") || u.hostname;
+        } catch {
+        }
+      }
+    }
+  }
+  return "";
+}
 function sourcesRoutes(rootDir, contextDir) {
   const app = new Hono2();
   app.get("/api/sources", (c) => {
     const sources = [];
+    try {
+      const configPath = path2.join(rootDir, "runcontext.config.yaml");
+      if (fs2.existsSync(configPath)) {
+        const raw = fs2.readFileSync(configPath, "utf-8");
+        const config = yaml.parse(raw);
+        if (config?.data_sources && typeof config.data_sources === "object") {
+          for (const [name, ds] of Object.entries(config.data_sources)) {
+            const src = ds;
+            sources.push({
+              name,
+              adapter: src.adapter ?? "auto",
+              origin: `config:${name}`,
+              status: "detected"
+            });
+          }
+        }
+      }
+    } catch {
+    }
     const envChecks = [
       { env: "DATABASE_URL", adapter: "auto", name: "Database (DATABASE_URL)" },
       { env: "POSTGRES_URL", adapter: "postgres", name: "PostgreSQL" },
@@ -93,15 +266,63 @@ function sourcesRoutes(rootDir, contextDir) {
       }
     } catch {
     }
+    const mcpSources = discoverMcpDatabases(rootDir);
+    for (const mcp of mcpSources) {
+      const alreadyFound = sources.some(
+        (s) => s.origin === mcp.origin || s.adapter === mcp.adapter && s.name === mcp.name
+      );
+      if (!alreadyFound) {
+        sources.push(mcp);
+      }
+    }
     return c.json(sources);
   });
+  app.post("/api/sources", async (c) => {
+    const body = await c.req.json();
+    const { connection, name = "default" } = body;
+    if (!connection) {
+      return c.json({ error: "connection is required" }, 400);
+    }
+    let adapter = "auto";
+    if (connection.startsWith("postgres://") || connection.startsWith("postgresql://")) {
+      adapter = "postgres";
+    } else if (connection.startsWith("mysql://")) {
+      adapter = "mysql";
+    } else if (connection.startsWith("mssql://") || connection.startsWith("sqlserver://")) {
+      adapter = "mssql";
+    } else if (connection.startsWith("clickhouse://")) {
+      adapter = "clickhouse";
+    }
+    const configPath = path2.join(rootDir, "runcontext.config.yaml");
+    let config = {};
+    try {
+      if (fs2.existsSync(configPath)) {
+        const raw = fs2.readFileSync(configPath, "utf-8");
+        config = yaml.parse(raw) ?? {};
+      }
+    } catch {
+    }
+    if (!config.data_sources || typeof config.data_sources !== "object") {
+      config.data_sources = {};
+    }
+    const dataSources = config.data_sources;
+    dataSources[name] = { adapter, connection };
+    fs2.writeFileSync(configPath, yaml.stringify(config), "utf-8");
+    const created = {
+      name,
+      adapter,
+      origin: `config:${name}`,
+      status: "detected"
+    };
+    return c.json(created, 201);
+  });
   return app;
 }
 
 // src/routes/api/upload.ts
 import { Hono as Hono3 } from "hono";
 import * as fs3 from "fs";
-import * as path2 from "path";
+import * as path3 from "path";
 import { PRODUCT_NAME_RE as PRODUCT_NAME_RE2 } from "@runcontext/core";
 var MAX_FILE_SIZE = 10 * 1024 * 1024;
 var ALLOWED_EXTENSIONS = [".md", ".txt", ".pdf", ".csv", ".json", ".yaml", ".yml", ".sql", ".html"];
@@ -120,15 +341,15 @@ function uploadRoutes(contextDir) {
     if (file.size > MAX_FILE_SIZE) {
       return c.json({ error: "File too large (max 10MB)" }, 400);
     }
-    const ext = path2.extname(file.name).toLowerCase();
+    const ext = path3.extname(file.name).toLowerCase();
     if (!ALLOWED_EXTENSIONS.includes(ext)) {
       return c.json({ error: `File type ${ext} not allowed` }, 400);
     }
     const safeName = file.name.replace(/[^a-zA-Z0-9._-]/g, "_");
-    const docsDir = path2.join(contextDir, "products", productName, "docs");
+    const docsDir = path3.join(contextDir, "products", productName, "docs");
     fs3.mkdirSync(docsDir, { recursive: true });
     const buffer = Buffer.from(await file.arrayBuffer());
-    fs3.writeFileSync(path2.join(docsDir, safeName), buffer);
+    fs3.writeFileSync(path3.join(docsDir, safeName), buffer);
     return c.json({ ok: true, filename: safeName });
   });
   return app;
@@ -136,7 +357,53 @@ function uploadRoutes(contextDir) {
 
 // src/routes/api/pipeline.ts
 import { Hono as Hono4 } from "hono";
+import { execFile as execFileCb } from "child_process";
+import { randomUUID as randomUUID2 } from "crypto";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join4, dirname } from "path";
+import { promisify } from "util";
+import { fileURLToPath } from "url";
+import { parse as parseYaml } from "yaml";
+
+// src/events.ts
+import { EventEmitter } from "events";
 import { randomUUID } from "crypto";
+var SetupEventBus = class extends EventEmitter {
+  sessions = /* @__PURE__ */ new Map();
+  createSession() {
+    const id = randomUUID();
+    this.sessions.set(id, { createdAt: (/* @__PURE__ */ new Date()).toISOString() });
+    return id;
+  }
+  hasSession(id) {
+    return this.sessions.has(id);
+  }
+  removeSession(id) {
+    this.sessions.delete(id);
+  }
+  emitEvent(event) {
+    this.emit("event", event);
+    this.emit(event.type, event);
+  }
+};
+var setupBus = new SetupEventBus();
+
+// src/routes/api/pipeline.ts
+var execFile = promisify(execFileCb);
+function resolveCliBin() {
+  try {
+    const thisDir = dirname(fileURLToPath(import.meta.url));
+    const localCli = join4(thisDir, "..", "..", "..", "cli", "dist", "index.js");
+    if (existsSync3(localCli)) {
+      return { cmd: process.execPath, prefix: [localCli] };
+    }
+  } catch {
+  }
+  if (process.argv[1] && existsSync3(process.argv[1])) {
+    return { cmd: process.execPath, prefix: [process.argv[1]] };
+  }
+  return { cmd: "npx", prefix: ["--yes", "@runcontext/cli"] };
+}
 var ALL_STAGES = [
   "introspect",
   "scaffold",
@@ -158,14 +425,21 @@ function pipelineRoutes(rootDir, contextDir) {
   const app = new Hono4();
   app.post("/api/pipeline/start", async (c) => {
     const body = await c.req.json();
-    const { productName, targetTier, dataSource } = body;
+    const { productName, targetTier, dataSource, sessionId } = body;
     if (!productName || !targetTier) {
       return c.json({ error: "productName and targetTier required" }, 400);
     }
     if (!["bronze", "silver", "gold"].includes(targetTier)) {
       return c.json({ error: "targetTier must be bronze, silver, or gold" }, 400);
     }
-    const id = randomUUID();
+    const safeNamePattern = /^[a-zA-Z0-9_-]+$/;
+    if (!safeNamePattern.test(productName)) {
+      return c.json({ error: "productName must contain only letters, numbers, hyphens, and underscores" }, 400);
+    }
+    if (dataSource && !safeNamePattern.test(dataSource)) {
+      return c.json({ error: "dataSource must contain only letters, numbers, hyphens, and underscores" }, 400);
+    }
+    const id = randomUUID2();
     const activeStages = stagesForTier(targetTier);
     const skippedStages = ALL_STAGES.filter((s) => !activeStages.includes(s));
     const run = {
@@ -180,7 +454,7 @@ function pipelineRoutes(rootDir, contextDir) {
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     runs.set(id, run);
-    executePipeline(run, rootDir, contextDir, dataSource).catch((err) => {
+    executePipeline(run, rootDir, contextDir, dataSource, sessionId).catch((err) => {
       run.status = "error";
       const currentStage = run.stages.find((s) => s.status === "running");
       if (currentStage) {
@@ -195,21 +469,128 @@ function pipelineRoutes(rootDir, contextDir) {
     if (!run) return c.json({ error: "Not found" }, 404);
     return c.json(run);
   });
+  app.get("/api/mcp-config", (c) => {
+    let connection;
+    try {
+      const configPath = join4(rootDir, "runcontext.config.yaml");
+      const configRaw = readFileSync3(configPath, "utf-8");
+      const config = parseYaml(configRaw);
+      const dataSources = config?.data_sources;
+      if (dataSources) {
+        const firstKey = Object.keys(dataSources)[0];
+        if (firstKey) {
+          connection = dataSources[firstKey].connection || dataSources[firstKey].path;
+        }
+      }
+    } catch {
+    }
+    const cli = resolveCliBin();
+    const mcpServers = {
+      runcontext: {
+        command: cli.cmd,
+        args: [...cli.prefix, "serve"],
+        cwd: rootDir
+      }
+    };
+    if (connection) {
+      mcpServers["runcontext-db"] = {
+        command: "npx",
+        args: ["--yes", "@runcontext/db", "--url", connection]
+      };
+    }
+    return c.json({ mcpServers });
+  });
   return app;
 }
-async function executePipeline(run, _rootDir, _contextDir, _dataSource) {
+function buildCliArgs(stage, dataSource) {
+  switch (stage) {
+    case "introspect": {
+      const args = ["introspect"];
+      if (dataSource) args.push("--source", dataSource);
+      return args;
+    }
+    case "scaffold":
+      return ["build"];
+    case "enrich-silver": {
+      const args = ["enrich", "--target", "silver", "--apply"];
+      if (dataSource) args.push("--source", dataSource);
+      return args;
+    }
+    case "enrich-gold": {
+      const args = ["enrich", "--target", "gold", "--apply"];
+      if (dataSource) args.push("--source", dataSource);
+      return args;
+    }
+    case "verify":
+      return ["verify"];
+    case "autofix":
+      return ["fix"];
+    case "agent-instructions":
+      return ["build"];
+  }
+}
+function extractSummary(stdout) {
+  const lines = stdout.trim().split("\n").filter(Boolean);
+  return lines.slice(-3).join("\n") || "completed";
+}
+async function executePipeline(run, rootDir, contextDir, dataSource, sessionId) {
   for (const stage of run.stages) {
     if (stage.status === "skipped") continue;
     stage.status = "running";
     stage.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    if (sessionId) {
+      setupBus.emitEvent({
+        type: "pipeline:stage",
+        sessionId,
+        payload: { stage: stage.stage, status: "running" }
+      });
+    }
     try {
+      const cliArgs = buildCliArgs(stage.stage, dataSource);
+      const cli = resolveCliBin();
+      const { stdout } = await execFile(cli.cmd, [...cli.prefix, ...cliArgs], {
+        cwd: rootDir,
+        timeout: 12e4,
+        env: {
+          ...process.env,
+          NODE_OPTIONS: "--max-old-space-size=4096 --no-deprecation"
+        }
+      });
       stage.status = "done";
-      stage.summary = `${stage.stage} completed`;
+      stage.summary = extractSummary(stdout);
       stage.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      if (sessionId) {
+        setupBus.emitEvent({
+          type: "pipeline:stage",
+          sessionId,
+          payload: { stage: stage.stage, status: "done", summary: stage.summary }
+        });
+      }
     } catch (err) {
+      const execErr = err;
+      if (execErr.stdout && execErr.stdout.trim().length > 0) {
+        stage.status = "done";
+        stage.summary = extractSummary(execErr.stdout);
+        stage.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+        if (sessionId) {
+          setupBus.emitEvent({
+            type: "pipeline:stage",
+            sessionId,
+            payload: { stage: stage.stage, status: "done", summary: stage.summary }
+          });
+        }
+        continue;
+      }
       stage.status = "error";
       stage.error = err instanceof Error ? err.message : String(err);
       stage.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      if (sessionId) {
+        setupBus.emitEvent({
+          type: "pipeline:stage",
+          sessionId,
+          payload: { stage: stage.stage, status: "error", error: stage.error }
+        });
+      }
       run.status = "error";
       return;
     }
@@ -220,29 +601,29 @@ async function executePipeline(run, _rootDir, _contextDir, _dataSource) {
 // src/routes/api/products.ts
 import { Hono as Hono5 } from "hono";
 import * as fs4 from "fs";
-import * as path3 from "path";
-import { parse as parse2 } from "yaml";
+import * as path4 from "path";
+import { parse as parse3 } from "yaml";
 function productsRoutes(contextDir) {
   const app = new Hono5();
   app.get("/api/products", (c) => {
-    const productsDir = path3.join(contextDir, "products");
+    const productsDir = path4.join(contextDir, "products");
     if (!fs4.existsSync(productsDir)) {
       return c.json([]);
     }
     const products = [];
     const dirs = fs4.readdirSync(productsDir).filter((name) => {
-      const fullPath = path3.join(productsDir, name);
+      const fullPath = path4.join(productsDir, name);
       return fs4.statSync(fullPath).isDirectory() && !name.startsWith(".");
     });
     for (const name of dirs) {
-      const briefPath = path3.join(productsDir, name, "context-brief.yaml");
+      const briefPath = path4.join(productsDir, name, "context-brief.yaml");
       let description;
       let sensitivity;
       let hasBrief = false;
       if (fs4.existsSync(briefPath)) {
         hasBrief = true;
         try {
-          const brief = parse2(fs4.readFileSync(briefPath, "utf-8"));
+          const brief = parse3(fs4.readFileSync(briefPath, "utf-8"));
           description = brief?.description;
           sensitivity = brief?.sensitivity;
         } catch {
@@ -255,28 +636,244 @@ function productsRoutes(contextDir) {
   return app;
 }
 
+// src/routes/api/auth.ts
+import { Hono as Hono6 } from "hono";
+import {
+  createDefaultRegistry,
+  CredentialStore
+} from "@runcontext/core";
+import * as fs5 from "fs";
+import * as path5 from "path";
+import { parse as parseYaml2, stringify as stringifyYaml } from "yaml";
+function authRoutes(rootDir) {
+  const app = new Hono6();
+  const registry = createDefaultRegistry();
+  const store = new CredentialStore();
+  app.get("/api/auth/providers", async (c) => {
+    const providers = await Promise.all(
+      registry.getAll().map(async (p) => {
+        const cli = await p.detectCli();
+        return {
+          id: p.id,
+          displayName: p.displayName,
+          adapters: p.adapters,
+          cliInstalled: cli.installed,
+          cliAuthenticated: cli.authenticated
+        };
+      })
+    );
+    return c.json(providers);
+  });
+  app.post("/api/auth/start", async (c) => {
+    const { provider: providerId } = await c.req.json();
+    const provider = registry.get(providerId);
+    if (!provider) {
+      return c.json({ error: `Unknown provider: ${providerId}` }, 400);
+    }
+    const result = await provider.authenticate();
+    if (!result.ok) {
+      return c.json({ error: result.error }, 401);
+    }
+    const databases = await provider.listDatabases(result.token);
+    return c.json({
+      ok: true,
+      provider: providerId,
+      databases
+    });
+  });
+  app.post("/api/auth/select-db", async (c) => {
+    const { provider: providerId, database } = await c.req.json();
+    const provider = registry.get(providerId);
+    if (!provider) {
+      return c.json({ error: `Unknown provider: ${providerId}` }, 400);
+    }
+    const authResult = await provider.authenticate();
+    if (!authResult.ok) {
+      return c.json({ error: authResult.error }, 401);
+    }
+    database.metadata = { ...database.metadata, token: authResult.token };
+    const connStr = await provider.getConnectionString(database);
+    try {
+      const { createAdapter } = await import("@runcontext/core");
+      const adapter = await createAdapter({
+        adapter: database.adapter,
+        connection: connStr
+      });
+      await adapter.connect();
+      await adapter.query("SELECT 1");
+      await adapter.disconnect();
+    } catch (err) {
+      return c.json({ error: `Connection failed: ${err.message}` }, 400);
+    }
+    const credKey = `${providerId}:${database.id}`;
+    await store.save({
+      provider: providerId,
+      key: credKey,
+      token: authResult.token,
+      refreshToken: authResult.ok ? authResult.refreshToken : void 0,
+      expiresAt: authResult.ok ? authResult.expiresAt : void 0,
+      metadata: {
+        host: database.host,
+        database: database.name,
+        ...database.metadata,
+        token: void 0
+      }
+    });
+    const configPath = path5.join(rootDir, "runcontext.config.yaml");
+    let config = {};
+    if (fs5.existsSync(configPath)) {
+      try {
+        config = parseYaml2(fs5.readFileSync(configPath, "utf-8")) ?? {};
+      } catch {
+      }
+    }
+    config.data_sources = config.data_sources ?? {};
+    config.data_sources.default = { adapter: database.adapter, auth: credKey };
+    fs5.writeFileSync(configPath, stringifyYaml(config), "utf-8");
+    return c.json({ ok: true, auth: credKey });
+  });
+  app.get("/api/auth/credentials", async (c) => {
+    const keys = await store.list();
+    return c.json(keys);
+  });
+  return app;
+}
+
+// src/routes/api/suggest-brief.ts
+import { Hono as Hono7 } from "hono";
+import { execFile as execFileCb2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execFile2 = promisify2(execFileCb2);
+function suggestBriefRoutes(rootDir) {
+  const app = new Hono7();
+  app.post("/api/suggest-brief", async (c) => {
+    const body = await c.req.json();
+    const source = body.source || {};
+    const meta = source.metadata || {};
+    const projectName = meta.project || "";
+    const dbName = source.name || "";
+    const rawName = projectName || dbName || "my-data";
+    const productName = rawName.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+    const branch = meta.branch || "main";
+    const adapter = source.adapter || "database";
+    const region = meta.region || "";
+    const org = meta.org || "";
+    let description = `Semantic context for the ${rawName} ${adapter} database`;
+    if (branch !== "main") description += ` (${branch} branch)`;
+    if (org && org !== "Personal") description += `, managed by ${org}`;
+    description += ".";
+    let ownerName = "";
+    let ownerEmail = "";
+    let ownerTeam = "";
+    try {
+      const { stdout: name } = await execFile2("git", ["config", "user.name"], {
+        cwd: rootDir,
+        timeout: 3e3
+      });
+      ownerName = name.trim();
+    } catch {
+    }
+    try {
+      const { stdout: email } = await execFile2("git", ["config", "user.email"], {
+        cwd: rootDir,
+        timeout: 3e3
+      });
+      ownerEmail = email.trim();
+    } catch {
+    }
+    if (org && org !== "Personal") {
+      ownerTeam = org;
+    } else if (ownerEmail) {
+      const domain = ownerEmail.split("@")[1];
+      if (domain && !["gmail.com", "yahoo.com", "hotmail.com", "outlook.com", "icloud.com"].includes(domain)) {
+        ownerTeam = domain.split(".")[0].charAt(0).toUpperCase() + domain.split(".")[0].slice(1);
+      }
+    }
+    return c.json({
+      product_name: productName,
+      description,
+      owner: {
+        name: ownerName,
+        email: ownerEmail,
+        team: ownerTeam
+      },
+      sensitivity: "internal"
+    });
+  });
+  return app;
+}
+
+// src/routes/ws.ts
+import { WebSocketServer, WebSocket } from "ws";
+function attachWebSocket(server) {
+  const wss = new WebSocketServer({ server, path: "/ws" });
+  wss.on("connection", (ws, req) => {
+    const url2 = new URL(req.url ?? "/", `http://${req.headers.host}`);
+    const sessionId = url2.searchParams.get("session");
+    if (!sessionId) {
+      ws.close(4001, "session query param required");
+      return;
+    }
+    if (!setupBus.hasSession(sessionId)) {
+      setupBus.createSession();
+    }
+    const onEvent = (event) => {
+      if (event.sessionId !== sessionId) return;
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify(event));
+      }
+    };
+    setupBus.on("event", onEvent);
+    ws.on("message", (raw) => {
+      try {
+        const msg = JSON.parse(raw.toString());
+        msg.sessionId = sessionId;
+        setupBus.emitEvent(msg);
+      } catch {
+      }
+    });
+    ws.on("close", () => {
+      setupBus.off("event", onEvent);
+    });
+  });
+}
+
 // src/server.ts
-var __dirname = path4.dirname(url.fileURLToPath(import.meta.url));
-var staticDir = path4.resolve(__dirname, "..", "static");
+var __dirname = path6.dirname(url.fileURLToPath(import.meta.url));
+var staticDir = path6.resolve(__dirname, "..", "static");
 function createApp(opts) {
-  const app = new Hono6();
-  app.use("*", cors());
+  const app = new Hono8();
+  app.use("*", cors({
+    origin: (origin) => {
+      if (!origin) return origin;
+      if (/^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?$/.test(origin)) {
+        return origin;
+      }
+      return null;
+    }
+  }));
   app.route("", briefRoutes(opts.contextDir));
   app.route("", sourcesRoutes(opts.rootDir, opts.contextDir));
   app.route("", uploadRoutes(opts.contextDir));
   app.route("", pipelineRoutes(opts.rootDir, opts.contextDir));
   app.route("", productsRoutes(opts.contextDir));
+  app.route("", authRoutes(opts.rootDir));
+  app.route("", suggestBriefRoutes(opts.rootDir));
   app.get("/api/health", (c) => c.json({ ok: true }));
+  app.post("/api/session", (c) => {
+    const id = setupBus.createSession();
+    return c.json({ sessionId: id });
+  });
   app.get("/static/:filename", (c) => {
     const filename = c.req.param("filename");
     if (!/^[a-zA-Z0-9._-]+$/.test(filename)) {
       return c.text("Not found", 404);
     }
-    const filePath = path4.join(staticDir, filename);
-    if (!fs5.existsSync(filePath)) return c.text("Not found", 404);
-    const ext = path4.extname(filename);
+    const filePath = path6.join(staticDir, filename);
+    if (!fs6.existsSync(filePath)) return c.text("Not found", 404);
+    const ext = path6.extname(filename);
     const contentType = ext === ".css" ? "text/css" : ext === ".js" ? "application/javascript" : "application/octet-stream";
-    return c.body(fs5.readFileSync(filePath), 200, { "Content-Type": contentType });
+    return c.body(fs6.readFileSync(filePath), 200, { "Content-Type": contentType });
   });
   app.get("/setup", (c) => {
     return c.html(setupPageHTML());
@@ -290,138 +887,95 @@ function setupPageHTML() {
 <head>
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1" />
-  <title>ContextKit \u2014 Build Your Data Product</title>
+  <title>RunContext \u2014 Build Your Data Product</title>
+  <link rel="preconnect" href="https://fonts.googleapis.com" />
+  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+  <link href="https://fonts.googleapis.com/css2?family=Plus+Jakarta+Sans:wght@400;500;600;700&family=Geist+Mono:wght@400;500&display=swap" rel="stylesheet" />
+  <link rel="stylesheet" href="/static/uxd.css" />
   <link rel="stylesheet" href="/static/setup.css" />
 </head>
 <body>
-  <div class="wizard">
-    <header class="wizard-header">
-      <h1>ContextKit</h1>
-      <p class="tagline">Build your data product. AI handles the rest.</p>
-    </header>
-
-    <div class="progress-bar">
-      <div class="progress-step active" data-step="1"><span class="step-num">1</span><span class="step-label">Product</span></div>
-      <div class="progress-step" data-step="2"><span class="step-num">2</span><span class="step-label">Owner</span></div>
-      <div class="progress-step" data-step="3"><span class="step-num">3</span><span class="step-label">Context</span></div>
-      <div class="progress-step" data-step="4"><span class="step-num">4</span><span class="step-label">Review</span></div>
-      <div class="progress-step" data-step="5"><span class="step-num">5</span><span class="step-label">Build</span></div>
-    </div>
-
-    <!-- Step 1: Product Name + Description -->
-    <div class="step active" id="step-1">
-      <h2>Name your data product</h2>
-      <div class="field">
-        <label for="product-name">Product Name</label>
-        <input type="text" id="product-name" class="input" placeholder="e.g. player-engagement" />
-        <p class="hint">Letters, numbers, dashes, underscores only</p>
+  <div class="app-shell">
+    <!-- Sidebar -->
+    <aside class="sidebar">
+      <div class="sidebar-brand">
+        <svg class="brand-chevron" width="24" height="24" viewBox="0 0 24 24" fill="none">
+          <path d="M4 4l8 8-8 8" stroke="#c9a55a" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round"/>
+          <path d="M12 4l8 8-8 8" stroke="#c9a55a" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round" opacity="0.5"/>
+        </svg>
+        <span class="brand-text">
+          <span class="brand-run">Run</span><span class="brand-context">Context</span>
+        </span>
+        <span class="brand-badge">Local</span>
       </div>
-      <div class="field">
-        <label for="description">Description</label>
-        <div class="textarea-wrapper">
-          <textarea id="description" class="textarea" rows="4" placeholder="Describe what this data product covers..."></textarea>
-          <button type="button" id="voice-btn" class="btn-icon" title="Voice input">\u{1F3A4}</button>
+      <nav class="sidebar-nav">
+        <a class="nav-item active" data-nav="setup">
+          <span>Setup</span>
+        </a>
+        <a class="nav-item locked" data-nav="planes">
+          <span>Semantic Planes</span>
+          <svg class="lock-icon" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+            <rect x="3" y="11" width="18" height="11" rx="2" ry="2"/>
+            <path d="M7 11V7a5 5 0 0110 0v4"/>
+          </svg>
+        </a>
+        <a class="nav-item locked" data-nav="analytics">
+          <span>Analytics</span>
+          <svg class="lock-icon" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+            <rect x="3" y="11" width="18" height="11" rx="2" ry="2"/>
+            <path d="M7 11V7a5 5 0 0110 0v4"/>
+          </svg>
+        </a>
+        <a class="nav-item" data-nav="mcp">
+          <span class="status-dot" id="mcp-status-dot"></span>
+          <span>MCP Server</span>
+          <span class="nav-detail" id="mcp-status-text">checking...</span>
+        </a>
+        <a class="nav-item locked" data-nav="settings">
+          <span>Settings</span>
+          <svg class="lock-icon" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+            <rect x="3" y="11" width="18" height="11" rx="2" ry="2"/>
+            <path d="M7 11V7a5 5 0 0110 0v4"/>
+          </svg>
+        </a>
+      </nav>
+      <div class="sidebar-status">
+        <div class="status-row">
+          <span class="status-dot" id="db-status-dot"></span>
+          <span id="db-status-text">No database</span>
         </div>
-      </div>
-      <div class="step-actions">
-        <div></div>
-        <button type="button" class="btn btn-primary" data-next>Next</button>
-      </div>
-    </div>
-
-    <!-- Step 2: Owner -->
-    <div class="step" id="step-2">
-      <h2>Who owns this data?</h2>
-      <div class="field">
-        <label for="owner-name">Your Name</label>
-        <input type="text" id="owner-name" class="input" placeholder="e.g. Tyler" />
-      </div>
-      <div class="field">
-        <label for="owner-team">Team</label>
-        <input type="text" id="owner-team" class="input" placeholder="e.g. Analytics" />
-      </div>
-      <div class="field">
-        <label for="owner-email">Email</label>
-        <input type="email" id="owner-email" class="input" placeholder="e.g. tyler@company.com" />
-      </div>
-      <div class="step-actions">
-        <button type="button" class="btn btn-secondary" data-prev>Back</button>
-        <button type="button" class="btn btn-primary" data-next>Next</button>
-      </div>
-    </div>
-
-    <!-- Step 3: Sensitivity + Sources + Upload -->
-    <div class="step" id="step-3">
-      <h2>Context &amp; sensitivity</h2>
-      <div class="field">
-        <label>Data Sensitivity</label>
-        <div class="sensitivity-cards">
-          <div class="card" data-sensitivity="public">
-            <strong>Public</strong>
-            <p>Open data, no restrictions</p>
-          </div>
-          <div class="card selected" data-sensitivity="internal">
-            <strong>Internal</strong>
-            <p>Company use only</p>
-          </div>
-          <div class="card" data-sensitivity="confidential">
-            <strong>Confidential</strong>
-            <p>Need-to-know basis</p>
-          </div>
-          <div class="card" data-sensitivity="restricted">
-            <strong>Restricted</strong>
-            <p>Strict access controls</p>
-          </div>
-        </div>
-      </div>
-
-      <div class="field">
-        <label>Data Sources</label>
-        <div id="sources-list" class="source-cards">
-          <p class="muted">Detecting data sources...</p>
+        <div class="status-row">
+          <span class="status-dot" id="mcp-server-dot"></span>
+          <span id="mcp-server-text">MCP stopped</span>
         </div>
-      </div>
-
-      <div class="field">
-        <label>Documentation (optional)</label>
-        <div id="upload-area" class="upload-area">
-          <p>Drop files here or click to upload</p>
-          <p class="hint">Supports .md, .txt, .pdf, .csv, .json, .yaml, .sql</p>
-          <input type="file" id="file-input" hidden multiple accept=".md,.txt,.pdf,.csv,.json,.yaml,.yml,.sql,.html" />
+        <div class="status-row" id="tier-row">
+          <span class="tier-badge" id="tier-badge">Free</span>
         </div>
-        <div id="uploaded-files"></div>
       </div>
+    </aside>
 
-      <div class="step-actions">
-        <button type="button" class="btn btn-secondary" data-prev>Back</button>
-        <button type="button" class="btn btn-primary" data-next>Next</button>
-      </div>
-    </div>
-
-    <!-- Step 4: Review -->
-    <div class="step" id="step-4">
-      <h2>Review your data product</h2>
-      <div id="review-content" class="review-content"></div>
-      <div class="step-actions">
-        <button type="button" class="btn btn-secondary" data-prev>Back</button>
-        <button type="button" class="btn btn-primary" data-next>Build it</button>
-      </div>
-    </div>
+    <!-- Header -->
+    <header class="app-header">
+      <div class="header-stepper" id="stepper"></div>
+    </header>
 
-    <!-- Step 5: Build Pipeline -->
-    <div class="step" id="step-5">
-      <h2>Building your semantic plane</h2>
-      <div id="pipeline-timeline" class="pipeline-timeline"></div>
-      <div id="pipeline-done" class="pipeline-done" style="display:none">
-        <p>Your semantic plane is live. AI agents can now query your data with context.</p>
-        <p class="muted">Powered by ContextKit \xB7 Open Semantic Interchange</p>
-      </div>
-    </div>
+    <!-- Main Content -->
+    <main class="main-content">
+      <div class="content-wrapper" id="wizard-content"></div>
+    </main>
 
-    <footer class="wizard-footer">
-      <p>Powered by ContextKit \xB7 Open Semantic Interchange</p>
+    <!-- Footer -->
+    <footer class="app-footer">
+      <span>Powered by RunContext &middot; Open Semantic Interchange</span>
     </footer>
   </div>
+
+  <!-- Locked tooltip (hidden by default) -->
+  <div class="locked-tooltip" id="locked-tooltip" style="display:none">
+    <p>Available on RunContext Cloud</p>
+    <a href="https://runcontext.dev/pricing" target="_blank" rel="noopener">Learn more</a>
+  </div>
+
   <script src="/static/setup.js"></script>
 </body>
 </html>`;
@@ -434,9 +988,10 @@ function startUIServer(opts) {
       port: opts.port,
       hostname: opts.host
     }, (info) => {
-      console.log(`ContextKit UI running at http://${opts.host === "0.0.0.0" ? "localhost" : opts.host}:${info.port}/setup`);
+      console.log(`RunContext UI running at http://${opts.host === "0.0.0.0" ? "localhost" : opts.host}:${info.port}/setup`);
       resolve2();
     });
+    attachWebSocket(server);
     server.on("error", reject);
   });
 }