@graphenedata/cli 0.0.3 → 0.0.5

package/dist/cli/cli.js

@@ -58,6 +58,15 @@ function walkExpression(root, fn, parent = null) {
     });
   }
 }
+async function pollFor(fn, timeoutMs, interval) {
+  let end = Date.now() + timeoutMs;
+  while (Date.now() < end) {
+    let res = fn();
+    if (res) return res;
+    await new Promise((r) => setTimeout(r, interval));
+  }
+  return null;
+}
 var init_util = __esm({
   "../lang/util.ts"() {
   }
@@ -147,17 +156,15 @@ function loadConfig(dir) {
   } catch {
     console.warn("No package.json found in current directory");
   }
-  setConfig({
-    ...packageJsonObject,
-    dialect: packageJsonObject.dialect || "duckdb",
-    port: process.env.GRAPHENE_PORT || packageJsonObject.port || 4e3,
-    root: packageJsonObject.root || process.cwd()
-  });
+  let dialect = "duckdb";
+  if (packageJsonObject.bigquery) dialect = "bigquery";
+  else if (packageJsonObject.snowflake) dialect = "snowflake";
+  setConfig({ ...packageJsonObject, dialect, root: packageJsonObject.root || process.cwd() });
 }
 var config;
 var init_config = __esm({
   "../lang/config.ts"() {
-    config = { dialect: "duckdb" };
+    config = { dialect: "duckdb", root: "" };
   }
 });
 
@@ -521,10 +528,10 @@ function analyzeQueryTable(table2) {
   if (table2.query) return;
   let node = TABLE_NODE_MAP.get(table2);
   let query = analyzeQuery(node.getChild("QueryStatement"));
-  if (!query) throw new Error("Couldnt find query in QueryStatement");
+  if (!query) return;
   table2.fields = query.fields.map((f) => ({ type: f.type, name: f.name, metadata: f.metadata }));
   table2.query = query.malloyQuery;
-  if (typeof table2.query.structRef == "string") {
+  if (table2.query && typeof table2.query.structRef == "string") {
     table2.query.structRef = lookupTable(table2.query.structRef, node);
   }
 }
@@ -534,9 +541,10 @@ function analyzeQuery(queryNode) {
   let isAgg = false;
   let subQuerySources = [];
   if (!txt(queryNode)) return;
+  if (txt(queryNode).trim().toLowerCase() == "select 1") return { fields: [{ name: "col_0", type: "number", metadata: {}, e: { node: "numberLiteral", literal: "1", type: "number" } }], subQuerySources, rawSql: "select 1" };
   let froms = queryNode.getChild("FromClause")?.getChildren("TablePrimary") || [];
   if (froms.find((f) => f.name == "JoinClause")) diag(froms[0], "Query joins not yet supported");
-  if (froms.length == 0) diag(queryNode, "No tables in FROM clause");
+  if (froms.length == 0) return diag(queryNode, "No tables in FROM clause");
   if (froms.length > 1) diag(froms[0], "Multiple tables/joins in FROM clause not yet supported");
   if (froms[0].name == "Subquery") {
     structRef = txt(froms[0].getChild("Alias")) || "subquery";
@@ -862,6 +870,10 @@ function convertDataType(dataType) {
       return "number";
     case "INT64":
       return "number";
+    case "NUMBER":
+      return "number";
+    case "VARIANT":
+      return "string";
     case "TEXT":
       return "string";
     case "STRING":
@@ -884,6 +896,8 @@ function convertDataType(dataType) {
       return "timestamp";
     case "TIMESTAMP":
       return "timestamp";
+    case "TIMESTAMP_NTZ":
+      return "timestamp";
     case "DECIMAL":
       return "number";
     case "DOUBLE":
@@ -1243,11 +1257,13 @@ function analyze(contents, type) {
   }
 }
 function toSql(query, params = {}) {
+  if (query.rawSql) return query.rawSql;
   let contents = {};
   let gsqlTables = Object.values(FILE_MAP).filter((f) => f.path !== "input").flatMap((f) => f.tables);
   gsqlTables.forEach((t) => contents[t.name] = t);
   let inputTables = [...FILE_MAP["input"]?.tables || [], ...query.subQuerySources];
   inputTables.forEach((t) => contents[t.name] = { ...t, query: t.query && fillInParams(t.query, params) });
+  if (!query.malloyQuery) throw new Error("Cannot compile query without Malloy query");
   let malloyQuery = fillInParams(query.malloyQuery, params);
   let qm = new QueryModel({
     name: "generated_model",
@@ -1281,13 +1297,177 @@ var init_core = __esm({
   }
 });
 
+// printer.ts
+import { styleText as nodeStyleText } from "node:util";
+import Table from "cli-table3";
+import chalk from "chalk";
+function offsetToLineCol(src, offset2) {
+  let lines = src.split(/\r?\n/);
+  let acc = 0;
+  for (let i = 0; i < lines.length; i++) {
+    let lineText = lines[i];
+    let nextAcc = acc + lineText.length + 1;
+    if (offset2 < nextAcc || i === lines.length - 1) {
+      let col = Math.max(0, offset2 - acc);
+      return { line: i + 1, col, lineStart: acc, lineText };
+    }
+    acc = nextAcc;
+  }
+  return { line: 1, col: 0, lineStart: 0, lineText: lines[0] || "" };
+}
+function printDiagnostics(diags, log) {
+  log ||= console.log;
+  let parts = [];
+  for (let d of diags) {
+    let src = getFile2(d.file)?.contents || "";
+    let { line, col, lineStart, lineText } = offsetToLineCol(src, d.from.offset);
+    let endCol = Math.max(col + 1, Math.min(lineText.length, d.to.offset - lineStart));
+    let caretLen = Math.max(1, endCol - col);
+    let sev = d.severity === "error" ? "red" : "yellow";
+    let header = `${styleText(sev, d.severity.toUpperCase())}: ${d.file} line ${line}: ${d.message}`;
+    let gutter = "   | ";
+    let caretLine = `${" ".repeat(col)}${styleText(sev, "^".repeat(caretLen))}`;
+    parts.push([header, `${gutter}${lineText}`, `${gutter}${caretLine}`].join("\n"));
+  }
+  if (parts.length) log(parts.join("\n"));
+}
+function printTable(rows) {
+  if (!rows || rows.length === 0) {
+    console.log(chalk.yellow("No results returned"));
+    return;
+  }
+  let headers = Object.keys(rows[0]);
+  let table2 = new Table({ head: headers.map((h) => chalk.blue(h)) });
+  let MAX_DISPLAY_ROWS = 200;
+  let displayRows = rows.slice(0, MAX_DISPLAY_ROWS);
+  displayRows.forEach((row) => table2.push(headers.map((h) => row[h]?.toString() || "")));
+  console.log(table2.toString());
+  if (rows.length > MAX_DISPLAY_ROWS) {
+    console.log(chalk.yellow(`Displayed first ${MAX_DISPLAY_ROWS} rows (of ${rows.length} total).`));
+  }
+}
+var styleText;
+var init_printer = __esm({
+  "printer.ts"() {
+    init_core();
+    styleText = (style, text) => {
+      try {
+        return nodeStyleText ? nodeStyleText(style, text) : text;
+      } catch {
+        return text;
+      }
+    };
+  }
+});
+
+// background.ts
+import { spawn } from "child_process";
+import { fileURLToPath } from "url";
+import fs2 from "fs-extra";
+import path3 from "path";
+async function runServeInBackground() {
+  let root = process.cwd();
+  let grapheneCache = getGrapheneCache(root);
+  let logFile = path3.join(grapheneCache, "serve.log");
+  await fs2.ensureDir(grapheneCache);
+  await stopGrapheneIfRunning(root);
+  let log = fs2.openSync(logFile, "w");
+  let entryPoint = process.argv[1] || fileURLToPath(import.meta.url);
+  let childArgs = [...process.execArgv, entryPoint, "serve", "--fg", ...process.argv.slice(3)];
+  let child = spawn(process.execPath, childArgs, {
+    cwd: root,
+    detached: true,
+    env: { ...process.env },
+    stdio: ["ignore", log, log]
+  });
+  if (!child.pid) throw new Error("Failed to start server process");
+  await new Promise((resolve, reject) => {
+    let buffer = "";
+    fs2.watchFile(logFile, { interval: 200 }, (curr, prev) => {
+      if (curr.size > prev.size) {
+        let stream = fs2.createReadStream(logFile, { start: 0, end: curr.size - 1 });
+        stream.on("data", (d) => {
+          process.stdout.write(d);
+          buffer = (buffer + d.toString()).slice(-200);
+          if (buffer.includes("Server running at http://localhost:")) resolve();
+        });
+      }
+    });
+    child.once("exit", () => {
+      process.stdout.write(fs2.readFileSync(logFile));
+      reject(new Error("Exited before server started"));
+    });
+    child.once("error", (e) => reject(e));
+  });
+}
+function getGrapheneCache(root) {
+  return path3.join(root, "node_modules", ".graphene");
+}
+function getPidFilePath(root) {
+  return path3.join(getGrapheneCache(root), process.env.NODE_ENV == "test" ? "test.pid" : "serve.pid");
+}
+function targetPids(pid) {
+  if (process.platform === "win32") return [pid];
+  return [pid, -pid];
+}
+function sendSignal(pid, signal) {
+  for (let target of targetPids(pid)) {
+    try {
+      process.kill(target, signal);
+    } catch (err) {
+      let code = err.code;
+      if (code === "ESRCH" || code === "EINVAL") continue;
+      return false;
+    }
+  }
+  return true;
+}
+async function stopGrapheneIfRunning(root) {
+  if (!await isServerRunning()) return;
+  let pidFile = getPidFilePath(root);
+  let pid = await readPid(pidFile);
+  if (!pid) return;
+  console.log(`Stopping server (${pid})`);
+  sendSignal(pid, "SIGTERM");
+  let end = Date.now() + 5e3;
+  while (Date.now() < end && isServerRunning()) {
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  if (!isServerRunning()) return;
+  sendSignal(pid, "SIGKILL");
+  await fs2.remove(pidFile);
+}
+async function readPid(pidFile) {
+  if (!await fs2.pathExists(pidFile)) return void 0;
+  let contents = (await fs2.readFile(pidFile, "utf8")).trim();
+  if (!contents) return void 0;
+  let pid = Number.parseInt(contents, 10);
+  if (Number.isNaN(pid)) return void 0;
+  return pid;
+}
+async function isServerRunning() {
+  let pidFile = getPidFilePath(config.root);
+  let pid = await readPid(pidFile);
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    fs2.removeSync(pidFile);
+    return false;
+  }
+}
+var init_background = __esm({
+  "background.ts"() {
+    init_config();
+  }
+});
+
 // connections/bigQuery.ts
 var bigQuery_exports = {};
 __export(bigQuery_exports, {
   BigQueryConnection: () => BigQueryConnection
 });
-import fs3 from "fs";
-import path4 from "path";
 import { BigQuery, BigQueryDate, BigQueryTimestamp } from "@google-cloud/bigquery";
 var BigQueryConnection;
 var init_bigQuery = __esm({
@@ -1296,18 +1476,14 @@ var init_bigQuery = __esm({
     BigQueryConnection = class {
       client;
       constructor(options = {}) {
+        options.projectId ||= config.bigquery?.projectId;
         if (process.env.GOOGLE_CREDENTIALS_CONTENT) {
           let parsed = JSON.parse(process.env.GOOGLE_CREDENTIALS_CONTENT);
-          let credPath = path4.resolve("./bq.json");
-          fs3.writeFileSync("./bq.json", process.env.GOOGLE_CREDENTIALS_CONTENT.replace("  ", "\n  "));
-          process.env.GOOGLE_APPLICATION_CREDENTIALS = credPath;
           options.projectId = parsed.project_id;
+          options.credentials = parsed;
         }
-        options.projectId ||= config.googleProjectId;
-        options.maxRetries ||= 3;
-        options.userAgent ||= "Graphene";
-        if (!options.projectId) throw new Error("googleProjectId must be set in config or provided in service account credentials");
-        this.client = new BigQuery(options);
+        if (!options.projectId) throw new Error("projectId must be set in config or provided in service account credentials");
+        this.client = new BigQuery({ ...options, userAgent: "Graphene" });
       }
       async runQuery(sql) {
         let [job] = await this.client.createQueryJob({ query: sql, useLegacySql: false });
@@ -1331,27 +1507,32 @@ var duckdb_exports = {};
 __export(duckdb_exports, {
   DuckDBConnection: () => DuckDBConnection
 });
-import { promises as fs4 } from "fs";
-import path5 from "path";
+import { promises as fs3 } from "fs";
+import path4 from "path";
 import { DuckDBTimestampValue, DuckDBInstance, DuckDBDateValue } from "@duckdb/node-api";
 var DuckDBConnection;
 var init_duckdb = __esm({
   "connections/duckdb.ts"() {
     init_config();
     DuckDBConnection = class {
+      options;
       ready;
       connection = null;
-      constructor() {
+      constructor(options) {
+        this.options = options || {};
         this.ready = this.initialize();
       }
       async initialize() {
-        let files = await fs4.readdir(config.root);
-        let databasePath = files.find((f) => f.endsWith(".duckdb"));
-        if (!databasePath) throw new Error("No .duckdb file found in current directory");
-        databasePath = path5.resolve(config.root, databasePath);
+        let dbPath = this.options.path;
+        if (!dbPath) {
+          let files = await fs3.readdir(config.root);
+          dbPath = files.find((f) => f.endsWith(".duckdb"));
+          if (!dbPath) throw new Error("No .duckdb file found in current directory");
+          dbPath = path4.resolve(config.root, dbPath);
+        }
         let db = await DuckDBInstance.create(":memory:");
         this.connection = await db.connect();
-        let escapedPath = databasePath.replace(/'/g, "''");
+        let escapedPath = dbPath.replace(/'/g, "''");
         await this.connection.run(`attach '${escapedPath}' as graphene_cli (READ_ONLY);`);
         await this.connection.run("use graphene_cli;");
       }
@@ -1376,6 +1557,76 @@ var init_duckdb = __esm({
   }
 });
 
+// connections/snowflake.ts
+var snowflake_exports = {};
+__export(snowflake_exports, {
+  SnowflakeConnection: () => SnowflakeConnection
+});
+import { createPrivateKey } from "node:crypto";
+import snowflake from "snowflake-sdk";
+var SnowflakeConnection;
+var init_snowflake = __esm({
+  "connections/snowflake.ts"() {
+    init_config();
+    SnowflakeConnection = class {
+      ready;
+      connection;
+      constructor(opts) {
+        this.ready = this.initialize(opts || {});
+      }
+      async initialize(opts) {
+        let privateKeyPath = process.env.SNOWFLAKE_PRI_KEY_PATH || config.snowflake?.privateKeyPath;
+        let privateKeyPass = process.env.SNOWFLAKE_PRI_PASSPHRASE;
+        let authOptions = {};
+        if (privateKeyPath) {
+          authOptions = { privateKeyPath, privateKeyPass };
+        } else if (opts.privateKey) {
+          let privateKey = createPrivateKey({ key: opts.privateKey, format: "pem", passphrase: privateKeyPass });
+          authOptions = { privateKey: privateKey.export({ format: "pem", type: "pkcs8" }) };
+        }
+        snowflake.configure({ logLevel: process.env.SNOWFLAKE_LOG_LEVEL || "WARN", logFilePath: "/dev/null" });
+        this.connection = snowflake.createConnection({
+          ...opts,
+          ...config.snowflake || {},
+          ...authOptions,
+          authenticator: "SNOWFLAKE_JWT",
+          application: "Graphene"
+        });
+        await new Promise((resolve, reject) => {
+          this.connection.connect((err, conn) => err ? reject(err) : resolve(conn));
+        });
+      }
+      async runQuery(sql) {
+        await this.ready;
+        return await new Promise((resolve, reject) => {
+          let rows = [];
+          this.connection.execute({
+            sqlText: sql,
+            streamResult: true,
+            complete: (error, statement) => {
+              if (error) {
+                reject(new Error(`Snowflake query failed: ${error.message || error}`));
+                return;
+              }
+              let stream = statement.streamRows();
+              stream.on("error", (err) => reject(err));
+              stream.on("readable", function(row) {
+                while ((row = this.read()) !== null) {
+                  rows.push(row);
+                }
+              });
+              stream.on("end", () => {
+                let totalRows = Number(statement.getNumRows());
+                resolve({ rows, totalRows });
+              });
+            }
+          });
+        });
+      }
+    };
+  }
+});
+
 // connections/index.ts
 async function getConnection() {
   if (config.dialect === "bigquery") {
@@ -1383,7 +1634,10 @@ async function getConnection() {
     return new mod.BigQueryConnection();
   } else if (config.dialect === "duckdb") {
     let mod = await Promise.resolve().then(() => (init_duckdb(), duckdb_exports));
-    return new mod.DuckDBConnection();
+    return new mod.DuckDBConnection({});
+  } else if (config.dialect === "snowflake") {
+    let mod = await Promise.resolve().then(() => (init_snowflake(), snowflake_exports));
+    return new mod.SnowflakeConnection({});
   } else {
     throw new Error(`Unsupported dialect: ${config.dialect}`);
   }
@@ -1394,6 +1648,201 @@ var init_connections = __esm({
   }
 });
 
+// mockFiles.ts
+var mockFileMap;
+var init_mockFiles = __esm({
+  "mockFiles.ts"() {
+    mockFileMap = {};
+  }
+});
+
+// check.ts
+import fs4 from "fs-extra";
+import os from "os";
+import path5 from "path";
+import { spawn as spawn2 } from "child_process";
+import { WebSocketServer } from "ws";
+import { readFileSync as readFileSync2 } from "node:fs";
+import { styleText as styleText2 } from "node:util";
+async function check(options) {
+  let log = options.log || console.log;
+  let mdFile = options.mdArg && normalizeMdFile(options.mdArg);
+  if (options.mdArg && !mdFile) {
+    log(`Couldn't find ${options.mdArg}`);
+    return false;
+  }
+  await loadWorkspace(config.root, !mdFile);
+  if (mdFile) {
+    if (process.env.NODE_ENV == "test" && mockFileMap[mdFile]) {
+      updateFile(mockFileMap[mdFile], mdFile);
+    } else {
+      let content = readFileSync2(path5.resolve(config.root, mdFile), "utf-8");
+      updateFile(content, mdFile);
+    }
+  }
+  analyze();
+  if (getDiagnostics().length > 0) {
+    printDiagnostics(getDiagnostics(), log);
+    return false;
+  }
+  if (!mdFile) {
+    log("No errors found \u{1F48E}");
+    return true;
+  }
+  let host = `http://localhost:${config.port || Number(process.env.GRAPHENE_PORT) || 4e3}`;
+  let pageUrl = "/" + mdFile.replace(/\.md$/, "").replace(/^\//, "").replace(/\\/g, "/");
+  if (pageUrl === "/index") pageUrl = "/";
+  if (process.env.NODE_ENV !== "test" && !await isServerRunning()) {
+    log("Starting Graphene server...");
+    await runServeInBackground();
+  }
+  let resp = await sendCheckRequest({ host, pageUrl, chart: options.chart });
+  if (resp.checkError == "no_server") {
+    log("Failed to start Graphene server");
+    return false;
+  }
+  if (resp.checkError == "no_tab" && process.env.NODE_ENV !== "test") {
+    log(`Opening page ${host}${pageUrl}`);
+    spawn2("open", [host + pageUrl]);
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    resp = await sendCheckRequest({ host, pageUrl, chart: options.chart });
+  }
+  if (resp.checkError == "no_tab") {
+    log("Failed to open a new tab");
+    return false;
+  }
+  if (resp.checkError) {
+    log("Failed to run check: " + resp.checkError);
+    return false;
+  }
+  let errors = Array.from(resp.errors || []);
+  if (errors.length) {
+    log(styleText2("red", "Runtime errors") + ` in ${mdFile}:`);
+  } else {
+    log("No errors found \u{1F48E}");
+  }
+  errors.forEach((e) => {
+    if (e.file && e.line) printDiagnostics([e], log);
+    else if (e.id) log(`${e.id}: ${e.message}`);
+    else log(e.message);
+  });
+  if (resp?.stillLoading) {
+    log("Warning: Queries were still loading when the screenshot was taken");
+  }
+  if (resp?.screenshot) {
+    let filename = `graphene-screenshot-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.png`;
+    let screenshotPath = path5.join(os.tmpdir(), filename);
+    let base64Data = resp.screenshot.replace(/^data:image\/png;base64,/, "");
+    await fs4.writeFile(screenshotPath, base64Data, "base64");
+    log("Screenshot saved to", screenshotPath);
+  }
+  return !!errors.length;
+}
+async function sendCheckRequest({ host, pageUrl, chart }) {
+  let abort = new AbortController();
+  let timeout = setTimeout(() => abort.abort(), 3e4);
+  try {
+    let response = await fetch(`${host}/_api/check`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ pageUrl: host + pageUrl, chart }),
+      signal: abort.signal
+    });
+    clearTimeout(timeout);
+    let body = response.headers.get("content-type") == "application/json" ? await response.json() : { error: await response.text() };
+    if (!response.ok) {
+      if (body.error) return { checkError: body.error };
+      console.error(`Unexpected response: ${JSON.stringify(body)}`);
+      return { checkError: "Unexpected response from Graphene server" };
+    }
+    return body;
+  } catch (err) {
+    clearTimeout(timeout);
+    if (err.name === "AbortError") return { checkError: "timeout" };
+    return { checkError: "no_server" };
+  }
+}
+function normalizeMdFile(mdFile) {
+  let clean = mdFile.trim();
+  if (!clean) return null;
+  if (!clean.endsWith(".md")) clean = clean + ".md";
+  if (process.env.NODE_ENV == "test" && mockFileMap[clean]) {
+    return clean;
+  }
+  let absolute = [
+    path5.resolve(process.cwd(), clean),
+    path5.resolve(config.root, clean)
+  ].find((p) => fs4.existsSync(p)) || null;
+  if (!absolute) return null;
+  let relative = path5.relative(config.root, absolute);
+  return relative;
+}
+async function proxyCheckRequest(req, res) {
+  let chunks = [];
+  for await (let chunk of req) chunks.push(chunk);
+  let { pageUrl, chart } = JSON.parse(Buffer.concat(chunks).toString());
+  let id = Math.random().toString(36).slice(2);
+  res.setHeader("Content-Type", "application/json");
+  let normalizedPageUrl = pageUrl.replace(/\/$/, "");
+  let conn = await pollFor(() => browserConnections.find((conn2) => conn2.url === normalizedPageUrl), 5e3, 100);
+  if (!conn) {
+    res.statusCode = 400;
+    res.end(JSON.stringify({ error: "no_tab" }));
+    return;
+  } else {
+    conn.socket.send(JSON.stringify({ type: "check", chart, requestId: id }));
+    pendingRequests[id] = { response: res };
+  }
+}
+function checkVitePlugin() {
+  return {
+    name: "graphene-check-plugin",
+    configureServer(server) {
+      let wss = new WebSocketServer({ noServer: true });
+      server.httpServer?.on("upgrade", (req, socket, head) => {
+        if (!req.url || !req.url.includes("/_api/ws") && !req.url.includes("graphene-ws")) return;
+        wss.handleUpgrade(req, socket, head, (ws) => {
+          wss.emit("connection", ws, req);
+        });
+      });
+      wss.on("connection", (socket) => {
+        socket.on("message", (data) => {
+          let message = JSON.parse(data.toString());
+          if (message.type === "register") {
+            let normalizedUrl = message.url.replace(/\/$/, "");
+            browserConnections.push({ url: normalizedUrl, socket });
+          }
+          if (message.type === "checkResponse") {
+            pendingRequests[message.requestId].response.end(JSON.stringify(message));
+            delete pendingRequests[message.requestId];
+          }
+        });
+        socket.on("close", () => {
+          browserConnections = browserConnections.filter((conn) => conn.socket !== socket);
+        });
+      });
+      server.httpServer?.on("close", () => wss.close());
+      server.middlewares.use(async (req, res, next) => {
+        let [pathName] = (req.url || "").split("?");
+        if (pathName === "/_api/check") await proxyCheckRequest(req, res);
+        else next();
+      });
+    }
+  };
+}
+var browserConnections, pendingRequests;
+var init_check = __esm({
+  "check.ts"() {
+    init_core();
+    init_printer();
+    init_mockFiles();
+    init_background();
+    init_util();
+    browserConnections = [];
+    pendingRequests = {};
+  }
+});
+
 // mdCompile.ts
 import fs5 from "fs";
 import path6 from "path";
@@ -1487,7 +1936,6 @@ var init_mdCompile = __esm({
 // serve2.ts
 var serve2_exports = {};
 __export(serve2_exports, {
-  mockFileMap: () => mockFileMap,
   serve2: () => serve2
 });
 import { createServer, optimizeDeps } from "vite";
@@ -1497,13 +1945,11 @@ import crypto from "crypto";
 import { mdsvex } from "mdsvex";
 import path7 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { WebSocketServer } from "ws";
-import { spawn as spawn2 } from "child_process";
 async function serve2() {
-  grapheneRoot = config.root;
   uiRoot = path7.join(fileURLToPath2(import.meta.url), "../../ui");
-  await fs6.ensureDir(path7.resolve(grapheneRoot, "node_modules/.graphene"));
-  await fs6.writeFile(path7.resolve(grapheneRoot, `node_modules/.graphene/${process.env.NODE_ENV == "test" ? "test" : "serve"}.pid`), String(process.pid));
+  let port = Number(process.env.GRAPHENE_PORT) || 4e3;
+  await fs6.ensureDir(path7.resolve(config.root, "node_modules/.graphene"));
+  await fs6.writeFile(path7.resolve(config.root, `node_modules/.graphene/${process.env.NODE_ENV == "test" ? "test" : "serve"}.pid`), String(process.pid));
   let server = await createServer({
     root: config.root,
     plugins: [
@@ -1519,12 +1965,14 @@ async function serve2() {
           injectComponentImports()
         ]
       }),
+      checkVitePlugin(),
       handleRequestPlugin,
       updateWorkspacePlugin,
       mockFilesForTests()
     ],
+    publicDir: path7.resolve(uiRoot),
     server: {
-      port: config.port,
+      port,
       fs: { strict: false },
       strictPort: true
     },
@@ -1533,10 +1981,16 @@ async function serve2() {
         graphene: path7.resolve(uiRoot, "web.js")
       }
     }
+    // optimizeDeps: { // this seems prudent in tests, but currently breaks because ssf needs to be optimized, even in tests
+    //   noDiscovery: process.env.NODE_ENV == 'test',
+    //   include: process.env.NODE_ENV == 'test' ? [] : undefined,
+    // },
   });
   await optimizeDeps(server.config);
   await server.listen();
-  console.log(`Server running at http://localhost:${config.port}`);
+  if (process.env.NODE_ENV !== "test") {
+    console.log(`Server running at http://localhost:${port}`);
+  }
   return server;
 }
 async function handleQuery(req, res) {
@@ -1566,31 +2020,6 @@ async function handleQuery(req, res) {
   let fields = queries[0].fields.map((f) => ({ name: f.name, type: f.type }));
   res.end(JSON.stringify({ rows: queryResults.rows, hash, fields, sql }));
 }
-async function handleView(req, res) {
-  let chunks = [];
-  for await (let chunk of req) chunks.push(chunk);
-  let { mdFile, chart } = JSON.parse(Buffer.concat(chunks).toString());
-  let id = Math.random().toString(36).slice(2);
-  res.setHeader("Content-Type", "application/json");
-  viewRequests[id] = { response: res };
-  let pageUrl = "/" + mdFile.replace(/\.md$/, "").replace(/^\//, "");
-  if (pageUrl === "/index") pageUrl = "/";
-  pageUrl = `http://localhost:${config.port || 4e3}${pageUrl}`;
-  let conn = browserConnections.find((conn2) => conn2.url === pageUrl);
-  if (!conn) {
-    spawn2("open", [pageUrl]);
-    let end = Date.now() + 5e3;
-    while (Date.now() < end && !conn) {
-      conn = browserConnections.find((conn2) => conn2.url === pageUrl);
-      await new Promise((resolve) => setTimeout(resolve, 100));
-    }
-    if (!conn) {
-      res.statusCode = 500;
-      return res.end(JSON.stringify({ error: "No browser tab available and failed to open one" }));
-    }
-  }
-  conn.socket.send(JSON.stringify({ type: "view", chart, requestId: id }));
-}
 async function handlePage(server, res, filePath, mount) {
   res.setHeader("Content-Type", "text/html");
   let mdMount = mount ? `
@@ -1603,7 +2032,7 @@ async function handlePage(server, res, filePath, mount) {
       <meta charset="UTF-8" />
       <meta name="viewport" content="width=device-width, initial-scale=1.0" />
       <title>Graphene</title>
-      <link rel="icon" href="@graphenedata/ui/assets/favicon.ico" />
+      <link rel="icon" href="/assets/favicon.ico" />
       <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=Inter:wght@100..900&display=swap" rel="stylesheet">
@@ -1613,10 +2042,7 @@ async function handlePage(server, res, filePath, mount) {
         <div id="content"></div>
       </main>
       <script type="module">
-        // do this first so we can track errors caused by importing the md file
-        import 'graphene'
-      </script>
-      <script type="module">
+        import 'graphene' // do this first so we can track errors caused by importing the md file
         ${mdMount}
       </script>
     </body>
@@ -1629,62 +2055,43 @@ function mockFilesForTests() {
     name: "mock-files-for-tests",
     enforce: "pre",
     resolveId(id) {
-      if (mockFileMap[id.replace(grapheneRoot, "")]) return id + "?mock";
+      if (mockFileMap[id.replace(config.root + "/", "")]) return id + "?mock";
     },
     load(id) {
       if (!id.endsWith("?mock")) return null;
-      return mockFileMap[id.replace(grapheneRoot, "").replace(/\?mock$/, "")];
+      return mockFileMap[id.replace(config.root + "/", "").replace(/\?mock$/, "")];
     }
   };
 }
-var grapheneRoot, uiRoot, workspaceLoadPromise, updateWorkspacePlugin, handleRequestPlugin, browserConnections, viewRequests, mockFileMap;
+var uiRoot, workspaceLoadPromise, updateWorkspacePlugin, handleRequestPlugin;
 var init_serve2 = __esm({
   "serve2.ts"() {
     init_core();
     init_connections();
     init_mdCompile();
+    init_check();
+    init_mockFiles();
     updateWorkspacePlugin = {
       name: "updateWorkspace",
       configureServer: (s) => {
         s.watcher.add("**/*.gsql");
         s.watcher.on("change", () => {
           clearWorkspace();
-          workspaceLoadPromise = loadWorkspace(grapheneRoot, false);
+          workspaceLoadPromise = loadWorkspace(config.root, false);
         });
-        workspaceLoadPromise = loadWorkspace(grapheneRoot, false);
+        workspaceLoadPromise = loadWorkspace(config.root, false);
       }
     };
     handleRequestPlugin = {
       name: "handleRequest",
       configureServer: (s) => {
-        let wss = new WebSocketServer({ noServer: true });
-        s.httpServer.on("upgrade", (req, socket, head) => {
-          if (!req.url?.endsWith("/graphene-ws")) return;
-          wss.handleUpgrade(req, socket, head, (ws) => {
-            wss.emit("connection", ws, req);
-          });
-        });
-        wss.on("connection", (socket) => {
-          socket.on("message", (data) => {
-            let message = JSON.parse(data.toString());
-            if (message.type === "register") {
-              browserConnections.push({ url: message.url, socket });
-            }
-            if (message.type === "viewResponse") {
-              viewRequests[message.requestId].response.end(JSON.stringify(message));
-              delete viewRequests[message.requestId];
-            }
-          });
-          socket.on("close", () => browserConnections = browserConnections.filter((conn) => conn.socket !== socket));
-        });
         s.middlewares.use(async function handleRequest(req, res, next) {
           try {
             let [pathName] = (req.url || "").split("?");
             if (pathName == "/_api/query") return await handleQuery(req, res);
-            if (pathName == "/graphene/view") return await handleView(req, res);
             if (pathName == "/__ct") return await handlePage(s, res, "__ct", false);
             if (!pathName || pathName == "/") pathName = "index";
-            let mdPath = path7.join(grapheneRoot, pathName + ".md");
+            let mdPath = path7.join(config.root, pathName + ".md");
             if (await fs6.exists(mdPath)) {
               await handlePage(s, res, mdPath, true);
             } else {
@@ -1698,166 +2105,19 @@ var init_serve2 = __esm({
         });
       }
     };
-    browserConnections = [];
-    viewRequests = {};
-    mockFileMap = {};
   }
 });
 
 // cli.ts
-import { Command } from "commander";
-
-// printer.ts
-init_core();
-import { styleText as nodeStyleText } from "node:util";
-import Table from "cli-table3";
-import chalk from "chalk";
-var styleText = (style, text) => {
-  try {
-    return nodeStyleText ? nodeStyleText(style, text) : text;
-  } catch {
-    return text;
-  }
-};
-function offsetToLineCol(src, offset2) {
-  let lines = src.split(/\r?\n/);
-  let acc = 0;
-  for (let i = 0; i < lines.length; i++) {
-    let lineText = lines[i];
-    let nextAcc = acc + lineText.length + 1;
-    if (offset2 < nextAcc || i === lines.length - 1) {
-      let col = Math.max(0, offset2 - acc);
-      return { line: i + 1, col, lineStart: acc, lineText };
-    }
-    acc = nextAcc;
-  }
-  return { line: 1, col: 0, lineStart: 0, lineText: lines[0] || "" };
-}
-function printDiagnostics(diags) {
-  let parts = [];
-  for (let d of diags) {
-    let src = getFile2(d.file)?.contents || "";
-    let { line, col, lineStart, lineText } = offsetToLineCol(src, d.from.offset);
-    let endCol = Math.max(col + 1, Math.min(lineText.length, d.to.offset - lineStart));
-    let caretLen = Math.max(1, endCol - col);
-    let sev = d.severity === "error" ? "red" : "yellow";
-    let header = `${styleText(sev, d.severity.toUpperCase())}: ${d.file} line ${line}: ${d.message}`;
-    let gutter = "   | ";
-    let caretLine = `${" ".repeat(col)}${styleText(sev, "^".repeat(caretLen))}`;
-    parts.push([header, `${gutter}${lineText}`, `${gutter}${caretLine}`].join("\n"));
-  }
-  if (parts.length) console.error(parts.join("\n"));
-}
-function printTable(rows) {
-  if (!rows || rows.length === 0) {
-    console.log(chalk.yellow("No results returned"));
-    return;
-  }
-  let headers = Object.keys(rows[0]);
-  let table2 = new Table({ head: headers.map((h) => chalk.blue(h)) });
-  let MAX_DISPLAY_ROWS = 200;
-  let displayRows = rows.slice(0, MAX_DISPLAY_ROWS);
-  displayRows.forEach((row) => table2.push(headers.map((h) => row[h]?.toString() || "")));
-  console.log(table2.toString());
-  if (rows.length > MAX_DISPLAY_ROWS) {
-    console.log(chalk.yellow(`Displayed first ${MAX_DISPLAY_ROWS} rows (of ${rows.length} total).`));
-  }
-}
-
-// cli.ts
+init_printer();
 init_core();
 init_config();
+init_background();
+init_connections();
+init_check();
+import { Command } from "commander";
 import fs7 from "fs-extra";
 import path8 from "path";
-import os from "os";
-
-// background.ts
-import { spawn } from "child_process";
-import { fileURLToPath } from "url";
-import fs2 from "fs-extra";
-import path3 from "path";
-async function runServeInBackground() {
-  let root = process.cwd();
-  let grapheneCache = getGrapheneCache(root);
-  let logFile = path3.join(grapheneCache, "serve.log");
-  await fs2.ensureDir(grapheneCache);
-  await stopGrapheneIfRunning(root);
-  let log = fs2.openSync(logFile, "w");
-  let entryPoint = process.argv[1] || fileURLToPath(import.meta.url);
-  let childArgs = [...process.execArgv, entryPoint, "serve", "--fg", ...process.argv.slice(3)];
-  let child = spawn(process.execPath, childArgs, {
-    cwd: root,
-    detached: true,
-    env: { ...process.env },
-    stdio: ["ignore", log, log]
-  });
-  if (!child.pid) throw new Error("Failed to start server process");
-  await new Promise((resolve, reject) => {
-    let buffer = "";
-    fs2.watchFile(logFile, { interval: 200 }, (curr, prev) => {
-      if (curr.size > prev.size) {
-        let stream = fs2.createReadStream(logFile, { start: 0, end: curr.size - 1 });
-        stream.on("data", (d) => {
-          process.stdout.write(d);
-          buffer = (buffer + d.toString()).slice(-200);
-          if (buffer.includes("Server running at http://localhost:")) resolve();
-        });
-      }
-    });
-    child.once("exit", () => {
-      process.stdout.write(fs2.readFileSync(logFile));
-      reject(new Error("Exited before server started"));
-    });
-    child.once("error", (e) => reject(e));
-  });
-}
-function getGrapheneCache(root) {
-  return path3.join(root, "node_modules", ".graphene");
-}
-function getPidFilePath(root) {
-  return path3.join(getGrapheneCache(root), process.env.NODE_ENV == "test" ? "test.pid" : "serve.pid");
-}
-async function stopGrapheneIfRunning(root) {
-  let pidFile = getPidFilePath(root);
-  let pid = await readPid(pidFile);
-  if (!pid) return true;
-  if (!isProcessRunning(pid)) {
-    await fs2.remove(pidFile);
-    return true;
-  }
-  try {
-    console.log(`Stopping server (${pid})`);
-    process.kill(pid, "SIGTERM");
-  } catch (err) {
-    if (err.code === "ESRCH") return true;
-    return false;
-  }
-  let end = Date.now() + 5e3;
-  while (Date.now() < end && isProcessRunning(pid)) {
-    await new Promise((resolve) => setTimeout(resolve, 100));
-  }
-  await fs2.remove(pidFile);
-  return !isProcessRunning(pid);
-}
-async function readPid(pidFile) {
-  if (!await fs2.pathExists(pidFile)) return void 0;
-  let contents = (await fs2.readFile(pidFile, "utf8")).trim();
-  if (!contents) return void 0;
-  let pid = Number.parseInt(contents, 10);
-  if (Number.isNaN(pid)) return void 0;
-  return pid;
-}
-function isProcessRunning(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// cli.ts
-init_connections();
 var program = new Command();
 program.name("graphene").description("Graphene CLI").version("1.0.0");
 program.hook("preAction", async () => {
@@ -1895,37 +2155,9 @@ program.command("serve").description("Run the local server").option("--fg", "Run
 program.command("stop").description("Stop the local server").action(async () => {
   await stopGrapheneIfRunning(process.cwd());
 });
-program.command("check").description("Check the project for errors").action(async () => {
-  await loadWorkspace(process.cwd(), true);
-  analyze();
-  if (getDiagnostics().length) {
-    printDiagnostics(getDiagnostics());
-    process.exit(1);
-  }
-  console.log("No errors found \u{1F48E}");
-});
-program.command("view").description("Capture a screenshot of a rendered markdown file").argument("<mdFile>", "Markdown file to view (e.g., index.md)").option("-c, --chart <chartName>", "Name of specific chart to capture").action(async (mdFile, options) => {
-  let response = await fetch("http://localhost:4000/graphene/view", {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ mdFile, chart: options.chart })
-  });
-  if (!response.ok) throw new Error(`View request failed: ${await response.text()}`);
-  let result = await response.json();
-  if (result.errors && result.errors.length > 0) {
-    console.error("Errors found:");
-    result.errors.forEach((error) => console.error(JSON.stringify(error)));
-  }
-  if (result.stillLoading) {
-    console.error("Warning: Queries were still loading when the screenshot was taken");
-  }
-  if (result.screenshot) {
-    let filename = `graphene-screenshot-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.png`;
-    let screenshotPath = path8.join(os.tmpdir(), filename);
-    let base64Data = result.screenshot.replace(/^data:image\/png;base64,/, "");
-    await fs7.writeFile(screenshotPath, base64Data, "base64");
-    console.log("Screenshot saved to", screenshotPath);
-  }
+program.command("check").description("Check the project for errors, optionally capturing a page screenshot").argument("[mdFile]", "Markdown file to check (e.g., index.md)").option("-c, --chart <chartTitle>", "Title of a specific chart to capture").action(async (mdArg, options) => {
+  let res = await check({ mdArg, chart: options.chart });
+  process.exit(res ? 0 : 1);
 });
 program.parse(process.argv);
 async function readInput(arg) {