@squadbase/vite-server 0.0.1-build-3 → 0.0.1-build-5

package/dist/cli/index.js

@@ -1,848 +0,0 @@
-#!/usr/bin/env node
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/cli/interactive.ts
-var interactive_exports = {};
-__export(interactive_exports, {
-  confirmRunAll: () => confirmRunAll,
-  inputParameters: () => inputParameters,
-  selectDataSource: () => selectDataSource
-});
-async function getPrompts() {
-  try {
-    const mod = await import("@clack/prompts");
-    return mod;
-  } catch {
-    throw new Error(
-      "@clack/prompts is not installed. Run: npm install @clack/prompts --save-dev"
-    );
-  }
-}
-async function selectDataSource(slugs) {
-  const { select, isCancel } = await getPrompts();
-  const result = await select({
-    message: "Select a data source to test:",
-    options: slugs.map((s) => ({ value: s, label: s }))
-  });
-  if (isCancel(result)) return null;
-  return result;
-}
-async function inputParameters(params) {
-  if (params.length === 0) return {};
-  const { text, isCancel } = await getPrompts();
-  const result = {};
-  for (const p of params) {
-    const defaultHint = p.default !== void 0 ? ` (default: ${p.default})` : "";
-    const requiredHint = p.required ? " *required*" : "";
-    const value = await text({
-      message: `${p.name}${requiredHint} [${p.type}]${defaultHint}: ${p.description}`,
-      placeholder: p.default !== void 0 ? String(p.default) : "",
-      validate: (v) => {
-        if (p.required && !v && p.default === void 0) {
-          return `${p.name} is required`;
-        }
-      }
-    });
-    if (isCancel(value)) {
-      process.exit(0);
-    }
-    const strValue = value;
-    if (!strValue && p.default !== void 0) {
-      result[p.name] = p.default;
-    } else if (strValue) {
-      if (p.type === "number") result[p.name] = Number(strValue);
-      else if (p.type === "boolean") result[p.name] = strValue === "true";
-      else result[p.name] = strValue;
-    }
-  }
-  return result;
-}
-async function confirmRunAll() {
-  const { confirm, isCancel } = await getPrompts();
-  const result = await confirm({
-    message: "Run all data sources?"
-  });
-  if (isCancel(result)) return false;
-  return result;
-}
-var init_interactive = __esm({
-  "src/cli/interactive.ts"() {
-    "use strict";
-  }
-});
-
-// src/cli/index.ts
-import { parseArgs } from "util";
-import path4 from "path";
-import { readFile as readFile3 } from "fs/promises";
-
-// src/connector-client/registry.ts
-import { readFileSync, watch as fsWatch } from "fs";
-import path from "path";
-
-// src/connector-client/postgresql.ts
-import pg from "pg";
-var { Pool } = pg;
-function createPostgreSQLClient(connectionString) {
-  const pool = new Pool({ connectionString, ssl: { rejectUnauthorized: false } });
-  return {
-    async query(sql, params) {
-      const result = await pool.query(sql, params);
-      return { rows: result.rows };
-    }
-  };
-}
-
-// src/connector-client/env.ts
-function resolveEnvVar(entry, key, slug) {
-  const envVarName = entry.envVars[key];
-  if (!envVarName) {
-    throw new Error(`Connector "${slug}" is missing envVars mapping for key "${key}"`);
-  }
-  const value = process.env[envVarName];
-  if (!value) {
-    throw new Error(`Environment variable "${envVarName}" (for "${slug}.${key}") is not set`);
-  }
-  return value;
-}
-function resolveEnvVarOptional(entry, key) {
-  const envVarName = entry.envVars[key];
-  if (!envVarName) return void 0;
-  return process.env[envVarName] || void 0;
-}
-
-// src/connector-client/bigquery.ts
-function createBigQueryClient(entry, slug) {
-  const projectId = resolveEnvVar(entry, "project-id", slug);
-  const serviceAccountJsonBase64 = resolveEnvVar(entry, "service-account-json-base64", slug);
-  const serviceAccountJson = Buffer.from(serviceAccountJsonBase64, "base64").toString("utf-8");
-  let gcpCredentials;
-  try {
-    gcpCredentials = JSON.parse(serviceAccountJson);
-  } catch {
-    throw new Error(
-      `BigQuery service account JSON (decoded from base64) is not valid JSON for slug "${slug}"`
-    );
-  }
-  return {
-    async query(sql) {
-      const { BigQuery } = await import("@google-cloud/bigquery");
-      const bq = new BigQuery({ projectId, credentials: gcpCredentials });
-      const [job] = await bq.createQueryJob({ query: sql });
-      const [allRows] = await job.getQueryResults({ timeoutMs: 3e4 });
-      return { rows: allRows };
-    }
-  };
-}
-
-// src/connector-client/snowflake.ts
-function createSnowflakeClient(entry, slug) {
-  const accountIdentifier = resolveEnvVar(entry, "account", slug);
-  const user = resolveEnvVar(entry, "user", slug);
-  const role = resolveEnvVar(entry, "role", slug);
-  const warehouse = resolveEnvVar(entry, "warehouse", slug);
-  const privateKeyBase64 = resolveEnvVar(entry, "private-key-base64", slug);
-  const privateKey = Buffer.from(privateKeyBase64, "base64").toString("utf-8");
-  return {
-    async query(sql) {
-      const snowflake = (await import("snowflake-sdk")).default;
-      snowflake.configure({ logLevel: "ERROR" });
-      const connection = snowflake.createConnection({
-        account: accountIdentifier,
-        username: user,
-        role,
-        warehouse,
-        authenticator: "SNOWFLAKE_JWT",
-        privateKey
-      });
-      await new Promise((resolve, reject) => {
-        connection.connect((err) => {
-          if (err) reject(new Error(`Snowflake connect failed: ${err.message}`));
-          else resolve();
-        });
-      });
-      const rows = await new Promise((resolve, reject) => {
-        connection.execute({
-          sqlText: sql,
-          complete: (err, _stmt, rows2) => {
-            if (err) reject(new Error(`Snowflake query failed: ${err.message}`));
-            else resolve(rows2 ?? []);
-          }
-        });
-      });
-      connection.destroy((err) => {
-        if (err) console.warn(`[connector-client] Snowflake destroy error: ${err.message}`);
-      });
-      return { rows };
-    }
-  };
-}
-
-// src/connector-client/mysql.ts
-function createMySQLClient(entry, slug) {
-  const connectionUrl = resolveEnvVar(entry, "connection-url", slug);
-  let poolPromise = null;
-  function getPool() {
-    if (!poolPromise) {
-      poolPromise = import("mysql2/promise").then(
-        (mysql) => mysql.default.createPool(connectionUrl)
-      );
-    }
-    return poolPromise;
-  }
-  return {
-    async query(sql, params) {
-      const pool = await getPool();
-      const [rows] = await pool.execute(sql, params);
-      return { rows };
-    }
-  };
-}
-
-// src/connector-client/aws-athena.ts
-function createAthenaClient(entry, slug) {
-  const region = resolveEnvVar(entry, "aws-region", slug);
-  const accessKeyId = resolveEnvVar(entry, "aws-access-key-id", slug);
-  const secretAccessKey = resolveEnvVar(entry, "aws-secret-access-key", slug);
-  const workgroup = resolveEnvVarOptional(entry, "workgroup") ?? "primary";
-  const outputLocation = resolveEnvVarOptional(entry, "output-location");
-  return {
-    async query(sql) {
-      const {
-        AthenaClient,
-        StartQueryExecutionCommand,
-        GetQueryExecutionCommand,
-        GetQueryResultsCommand
-      } = await import("@aws-sdk/client-athena");
-      const client = new AthenaClient({
-        region,
-        credentials: { accessKeyId, secretAccessKey }
-      });
-      const startParams = {
-        QueryString: sql,
-        WorkGroup: workgroup
-      };
-      if (outputLocation) {
-        startParams.ResultConfiguration = { OutputLocation: outputLocation };
-      }
-      const { QueryExecutionId } = await client.send(
-        new StartQueryExecutionCommand(startParams)
-      );
-      if (!QueryExecutionId) throw new Error("Athena: failed to start query execution");
-      while (true) {
-        const { QueryExecution } = await client.send(
-          new GetQueryExecutionCommand({ QueryExecutionId })
-        );
-        const state = QueryExecution?.Status?.State;
-        if (state === "SUCCEEDED") break;
-        if (state === "FAILED") {
-          throw new Error(
-            `Athena query failed: ${QueryExecution?.Status?.StateChangeReason ?? "unknown"}`
-          );
-        }
-        if (state === "CANCELLED") throw new Error("Athena query was cancelled");
-        await new Promise((r) => setTimeout(r, 500));
-      }
-      const { ResultSet } = await client.send(
-        new GetQueryResultsCommand({ QueryExecutionId })
-      );
-      const resultRows = ResultSet?.Rows ?? [];
-      if (resultRows.length === 0) return { rows: [] };
-      const headers = resultRows[0].Data?.map((d) => d.VarCharValue ?? "") ?? [];
-      const rows = resultRows.slice(1).map((row) => {
-        const obj = {};
-        row.Data?.forEach((d, i) => {
-          obj[headers[i]] = d.VarCharValue ?? null;
-        });
-        return obj;
-      });
-      return { rows };
-    }
-  };
-}
-
-// src/connector-client/redshift.ts
-function createRedshiftClient(entry, slug) {
-  const region = resolveEnvVar(entry, "aws-region", slug);
-  const accessKeyId = resolveEnvVar(entry, "aws-access-key-id", slug);
-  const secretAccessKey = resolveEnvVar(entry, "aws-secret-access-key", slug);
-  const database = resolveEnvVar(entry, "database", slug);
-  const clusterIdentifier = resolveEnvVarOptional(entry, "cluster-identifier");
-  const workgroupName = resolveEnvVarOptional(entry, "workgroup-name");
-  const secretArn = resolveEnvVarOptional(entry, "secret-arn");
-  const dbUser = resolveEnvVarOptional(entry, "db-user");
-  return {
-    async query(sql) {
-      const {
-        RedshiftDataClient,
-        ExecuteStatementCommand,
-        DescribeStatementCommand,
-        GetStatementResultCommand
-      } = await import("@aws-sdk/client-redshift-data");
-      const client = new RedshiftDataClient({
-        region,
-        credentials: { accessKeyId, secretAccessKey }
-      });
-      const executeParams = {
-        Sql: sql,
-        Database: database
-      };
-      if (clusterIdentifier) executeParams.ClusterIdentifier = clusterIdentifier;
-      if (workgroupName) executeParams.WorkgroupName = workgroupName;
-      if (secretArn) executeParams.SecretArn = secretArn;
-      if (dbUser) executeParams.DbUser = dbUser;
-      const { Id } = await client.send(
-        new ExecuteStatementCommand(executeParams)
-      );
-      if (!Id) throw new Error("Redshift: failed to start statement execution");
-      while (true) {
-        const desc = await client.send(new DescribeStatementCommand({ Id }));
-        const status = desc.Status;
-        if (status === "FINISHED") break;
-        if (status === "FAILED") {
-          throw new Error(`Redshift query failed: ${desc.Error ?? "unknown"}`);
-        }
-        if (status === "ABORTED") throw new Error("Redshift query was aborted");
-        await new Promise((r) => setTimeout(r, 500));
-      }
-      const result = await client.send(new GetStatementResultCommand({ Id }));
-      const columns = result.ColumnMetadata?.map((c) => c.name ?? "") ?? [];
-      const rows = (result.Records ?? []).map((record) => {
-        const obj = {};
-        record.forEach((field, i) => {
-          const col = columns[i];
-          const value = field.stringValue ?? field.longValue ?? field.doubleValue ?? field.booleanValue ?? (field.isNull ? null : field.blobValue ?? null);
-          obj[col] = value;
-        });
-        return obj;
-      });
-      return { rows };
-    }
-  };
-}
-
-// src/connector-client/databricks.ts
-function createDatabricksClient(entry, slug) {
-  const host = resolveEnvVar(entry, "host", slug);
-  const httpPath = resolveEnvVar(entry, "http-path", slug);
-  const token = resolveEnvVar(entry, "token", slug);
-  return {
-    async query(sql) {
-      const { DBSQLClient } = await import("@databricks/sql");
-      const client = new DBSQLClient();
-      await client.connect({ host, path: httpPath, token });
-      try {
-        const session = await client.openSession();
-        try {
-          const operation = await session.executeStatement(sql);
-          const result = await operation.fetchAll();
-          await operation.close();
-          return { rows: result };
-        } finally {
-          await session.close();
-        }
-      } finally {
-        await client.close();
-      }
-    }
-  };
-}
-
-// src/connector-client/registry.ts
-function createConnectorRegistry() {
-  let connectionsCache = null;
-  const clientCache = /* @__PURE__ */ new Map();
-  function getConnectionsFilePath() {
-    return process.env.CONNECTIONS_PATH ?? path.join(process.cwd(), "../../.squadbase/connections.json");
-  }
-  function loadConnections2() {
-    if (connectionsCache !== null) return connectionsCache;
-    const filePath = getConnectionsFilePath();
-    try {
-      const raw = readFileSync(filePath, "utf-8");
-      connectionsCache = JSON.parse(raw);
-    } catch {
-      connectionsCache = {};
-    }
-    return connectionsCache;
-  }
-  async function getClient2(connectorSlug, connectorType) {
-    if (!connectorSlug) {
-      const cacheKey = "__squadbase-db__";
-      const cached2 = clientCache.get(cacheKey);
-      if (cached2) return cached2;
-      const url = process.env.SQUADBASE_POSTGRESQL_URL;
-      if (!url) throw new Error("SQUADBASE_POSTGRESQL_URL environment variable is not set");
-      const client = createPostgreSQLClient(url);
-      clientCache.set(cacheKey, client);
-      return client;
-    }
-    const cached = clientCache.get(connectorSlug);
-    if (cached) return cached;
-    const connections = loadConnections2();
-    const entry = connections[connectorSlug];
-    if (!entry) {
-      throw new Error(`connector slug '${connectorSlug}' not found in .squadbase/connections.json`);
-    }
-    const resolvedType = connectorType ?? entry.connectorType;
-    if (!resolvedType) {
-      throw new Error(
-        `connector type could not be determined for slug '${connectorSlug}'. Specify connectorType in the data-source JSON or in .squadbase/connections.json.`
-      );
-    }
-    if (resolvedType === "snowflake") {
-      return createSnowflakeClient(entry, connectorSlug);
-    }
-    if (resolvedType === "bigquery") {
-      return createBigQueryClient(entry, connectorSlug);
-    }
-    if (resolvedType === "athena") {
-      return createAthenaClient(entry, connectorSlug);
-    }
-    if (resolvedType === "redshift") {
-      return createRedshiftClient(entry, connectorSlug);
-    }
-    if (resolvedType === "databricks") {
-      return createDatabricksClient(entry, connectorSlug);
-    }
-    if (resolvedType === "mysql") {
-      const client = createMySQLClient(entry, connectorSlug);
-      clientCache.set(connectorSlug, client);
-      return client;
-    }
-    if (resolvedType === "postgresql" || resolvedType === "squadbase-db") {
-      const urlEnvName = entry.envVars["connection-url"];
-      if (!urlEnvName) {
-        throw new Error(`'connection-url' is not defined in envVars for connector '${connectorSlug}'`);
-      }
-      const connectionUrl = process.env[urlEnvName];
-      if (!connectionUrl) {
-        throw new Error(
-          `environment variable '${urlEnvName}' (mapped from connector '${connectorSlug}') is not set`
-        );
-      }
-      const client = createPostgreSQLClient(connectionUrl);
-      clientCache.set(connectorSlug, client);
-      return client;
-    }
-    throw new Error(
-      `connector type '${resolvedType}' is not supported as a SQL connector. Supported SQL types: "postgresql", "squadbase-db", "mysql", "snowflake", "bigquery", "athena", "redshift", "databricks". Non-SQL types (airtable, google-analytics, kintone, wix-store, dbt) should be used via TypeScript handlers.`
-    );
-  }
-  function reloadEnvFile2(envPath) {
-    try {
-      const raw = readFileSync(envPath, "utf-8");
-      for (const line of raw.split("\n")) {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith("#")) continue;
-        const eqIdx = trimmed.indexOf("=");
-        if (eqIdx === -1) continue;
-        const key = trimmed.slice(0, eqIdx).trim();
-        const value = trimmed.slice(eqIdx + 1).trim();
-        if (key) process.env[key] = value;
-      }
-      console.log("[connector-client] .env reloaded");
-    } catch {
-    }
-  }
-  function watchConnectionsFile2() {
-    const filePath = getConnectionsFilePath();
-    const envPath = path.join(process.cwd(), "..", "..", ".env");
-    try {
-      fsWatch(filePath, { persistent: false }, () => {
-        console.log("[connector-client] connections.json changed, clearing cache");
-        connectionsCache = null;
-        clientCache.clear();
-        setImmediate(() => reloadEnvFile2(envPath));
-      });
-    } catch {
-    }
-  }
-  return { getClient: getClient2, loadConnections: loadConnections2, reloadEnvFile: reloadEnvFile2, watchConnectionsFile: watchConnectionsFile2 };
-}
-
-// src/connector-client/index.ts
-var { getClient, loadConnections, reloadEnvFile, watchConnectionsFile } = createConnectorRegistry();
-
-// src/cli/env-loader.ts
-import { readFileSync as readFileSync2 } from "fs";
-function loadEnvFile(envPath) {
-  reloadEnvFile(envPath);
-}
-
-// src/cli/runner.ts
-import { pathToFileURL } from "url";
-import { readFile as readFile2, readdir as readdir2 } from "fs/promises";
-import path3 from "path";
-
-// src/registry.ts
-import { readdir, readFile, mkdir } from "fs/promises";
-import { watch as fsWatch2 } from "fs";
-import path2 from "path";
-function buildQuery(queryTemplate, parameterMeta, runtimeParams) {
-  const defaults = new Map(
-    parameterMeta.map((p) => [p.name, p.default ?? null])
-  );
-  const placeholderToIndex = /* @__PURE__ */ new Map();
-  const values = [];
-  const text = queryTemplate.replace(
-    /\{\{(\w+)\}\}/g,
-    (_match, name) => {
-      if (!placeholderToIndex.has(name)) {
-        const value = Object.prototype.hasOwnProperty.call(runtimeParams, name) ? runtimeParams[name] : defaults.get(name) ?? null;
-        values.push(value);
-        placeholderToIndex.set(name, values.length);
-      }
-      return `$${placeholderToIndex.get(name)}`;
-    }
-  );
-  return { text, values };
-}
-var defaultDataSourceDir = path2.join(process.cwd(), "data-source");
-
-// src/cli/runner.ts
-function createStubContext(params) {
-  const stub = {
-    req: {
-      json: () => Promise.resolve(params),
-      query: (name) => {
-        if (name === void 0) {
-          return Object.fromEntries(
-            Object.entries(params).map(([k, v2]) => [k, String(v2)])
-          );
-        }
-        const v = params[name];
-        return v !== void 0 ? String(v) : "";
-      },
-      param: (_name) => void 0,
-      header: (_name) => void 0,
-      raw: new Request("http://localhost/cli")
-    },
-    json: (data) => data,
-    text: (data) => data,
-    body: (data) => data,
-    env: {},
-    var: {},
-    get: (_key) => void 0,
-    set: () => {
-    }
-  };
-  return stub;
-}
-async function runSqlDataSource(slug, def, params, limit) {
-  const start = Date.now();
-  try {
-    const client = await getClient(def.connectorSlug, def.connectorType);
-    const isExternal = def.connectorType === "snowflake" || def.connectorType === "bigquery";
-    let queryText;
-    let queryValues;
-    if (isExternal) {
-      const defaults = new Map(
-        (def.parameters ?? []).map((p) => [p.name, p.default ?? null])
-      );
-      queryText = def.query.replace(/\{\{(\w+)\}\}/g, (_match, name) => {
-        const value = Object.prototype.hasOwnProperty.call(params, name) ? params[name] : defaults.get(name) ?? "";
-        if (typeof value === "string") return `'${value.replace(/'/g, "''")}'`;
-        if (value === null || value === void 0) return "NULL";
-        return String(value);
-      });
-      queryValues = [];
-    } else {
-      const built = buildQuery(def.query, def.parameters ?? [], params);
-      queryText = built.text;
-      queryValues = built.values;
-    }
-    const result = await client.query(queryText, queryValues);
-    const rows = result.rows.slice(0, limit);
-    return {
-      slug,
-      rows,
-      rowCount: result.rows.length,
-      durationMs: Date.now() - start,
-      query: queryText,
-      queryValues
-    };
-  } catch (error) {
-    return {
-      slug,
-      rows: [],
-      rowCount: 0,
-      durationMs: Date.now() - start,
-      error: error instanceof Error ? error : new Error(String(error))
-    };
-  }
-}
-async function runTypescriptDataSource(slug, handlerPath, params) {
-  const start = Date.now();
-  try {
-    const mod = await import(pathToFileURL(handlerPath).href);
-    const handler = mod.default;
-    if (typeof handler !== "function") {
-      throw new Error(`Handler must export a default function: ${handlerPath}`);
-    }
-    const ctx = createStubContext(params);
-    const raw = await handler(ctx);
-    let rows;
-    if (Array.isArray(raw)) {
-      rows = raw;
-    } else if (raw !== null && typeof raw === "object") {
-      rows = [raw];
-    } else {
-      rows = [{ result: raw }];
-    }
-    return {
-      slug,
-      rows,
-      rowCount: rows.length,
-      durationMs: Date.now() - start
-    };
-  } catch (error) {
-    return {
-      slug,
-      rows: [],
-      rowCount: 0,
-      durationMs: Date.now() - start,
-      error: error instanceof Error ? error : new Error(String(error))
-    };
-  }
-}
-async function runDataSource(slug, dirPath, params, limit) {
-  const jsonPath = path3.join(dirPath, `${slug}.json`);
-  let def;
-  try {
-    const raw = await readFile2(jsonPath, "utf-8");
-    def = JSON.parse(raw);
-  } catch {
-    return {
-      slug,
-      rows: [],
-      rowCount: 0,
-      durationMs: 0,
-      error: new Error(`Data source not found: ${jsonPath}`)
-    };
-  }
-  if (def.type === "typescript") {
-    const absolutePath = path3.resolve(dirPath, def.handlerPath);
-    return runTypescriptDataSource(slug, absolutePath, params);
-  }
-  return runSqlDataSource(slug, def, params, limit);
-}
-async function listSlugs(dirPath) {
-  try {
-    const files = await readdir2(dirPath);
-    return files.filter((f) => f.endsWith(".json")).map((f) => f.replace(/\.json$/, ""));
-  } catch {
-    return [];
-  }
-}
-async function runAll(dirPath, params, limit) {
-  const slugs = await listSlugs(dirPath);
-  return Promise.all(slugs.map((slug) => runDataSource(slug, dirPath, params, limit)));
-}
-
-// src/cli/display.ts
-var RESET = "\x1B[0m";
-var BOLD = "\x1B[1m";
-var RED = "\x1B[31m";
-var GREEN = "\x1B[32m";
-var YELLOW = "\x1B[33m";
-var CYAN = "\x1B[36m";
-var DIM = "\x1B[2m";
-function truncate(value, maxLen) {
-  return value.length > maxLen ? value.slice(0, maxLen - 1) + "\u2026" : value;
-}
-function formatValue(value) {
-  if (value === null || value === void 0) return DIM + "null" + RESET;
-  if (typeof value === "object") return JSON.stringify(value);
-  return String(value);
-}
-function displayTable(rows, limit) {
-  if (rows.length === 0) {
-    console.log(DIM + "  (no rows)" + RESET);
-    return;
-  }
-  const display = rows.slice(0, limit);
-  const columns = Object.keys(display[0] ?? {});
-  const colWidths = columns.map((col) => {
-    const maxData = Math.max(...display.map((r) => formatValue(r[col]).replace(/\x1b\[[0-9;]*m/g, "").length));
-    return Math.min(40, Math.max(col.length, maxData));
-  });
-  const header = columns.map((c, i) => BOLD + CYAN + c.padEnd(colWidths[i] ?? 0) + RESET).join("  ");
-  const divider = colWidths.map((w) => "-".repeat(w)).join("--");
-  console.log("  " + header);
-  console.log("  " + DIM + divider + RESET);
-  for (const row of display) {
-    const line = columns.map((c, i) => {
-      const raw = formatValue(row[c]);
-      const plain = raw.replace(/\x1b\[[0-9;]*m/g, "");
-      const padded = truncate(plain, colWidths[i] ?? 40).padEnd(colWidths[i] ?? 0);
-      return raw.startsWith(DIM) ? DIM + padded + RESET : padded;
-    }).join("  ");
-    console.log("  " + line);
-  }
-  if (rows.length > limit) {
-    console.log(DIM + `  \u2026 and ${rows.length - limit} more rows (use --limit to show more)` + RESET);
-  }
-}
-function displaySummary(result) {
-  const status = result.error ? RED + "\u2717 FAIL" + RESET : GREEN + "\u2713 OK" + RESET;
-  const duration = DIM + `(${result.durationMs}ms)` + RESET;
-  console.log(`
-${BOLD}[${result.slug}]${RESET} ${status} ${duration}`);
-  if (result.error) {
-    console.log(RED + `  Error: ${result.error.message}` + RESET);
-    return;
-  }
-  console.log(DIM + `  ${result.rowCount} row(s)` + RESET);
-}
-function displayDebug(result) {
-  if (result.query) {
-    console.log(YELLOW + "  Query:" + RESET);
-    console.log(DIM + `    ${result.query.replace(/\n/g, "\n    ")}` + RESET);
-  }
-  if (result.queryValues && result.queryValues.length > 0) {
-    console.log(YELLOW + "  Params:" + RESET, result.queryValues);
-  }
-}
-function displayJson(results) {
-  const output = results.map((r) => ({
-    slug: r.slug,
-    rowCount: r.rowCount,
-    durationMs: r.durationMs,
-    rows: r.rows,
-    error: r.error?.message
-  }));
-  console.log(JSON.stringify(output, null, 2));
-}
-function displayError(error) {
-  console.error(RED + "Error: " + error.message + RESET);
-}
-
-// src/cli/index.ts
-var HELP = `
-Usage: squadbase-ds-test [options]
-
-Options:
-  --slug <slug>     Run a specific data source
-  --all             Run all data sources
-  --params k=v,...  Comma-separated key=value parameters
-  --env <path>      Path to .env file (default: ../../.env)
-  --dir <path>      Data source directory (default: ./data-source)
-  --format table|json  Output format (default: table)
-  --limit <n>       Max rows to display (default: 50)
-  --debug           Show SQL query and parameter values
-  --help            Show this help
-
-Examples:
-  npx tsx src/cli/index.ts --slug sales-summary
-  npx tsx src/cli/index.ts --slug sales-summary --params year=2024,limit=10
-  npx tsx src/cli/index.ts --all --format json
-  npx tsx src/cli/index.ts  # interactive mode
-`;
-async function main() {
-  const { values } = parseArgs({
-    options: {
-      slug: { type: "string" },
-      all: { type: "boolean", default: false },
-      params: { type: "string" },
-      env: { type: "string" },
-      dir: { type: "string" },
-      format: { type: "string", default: "table" },
-      limit: { type: "string", default: "50" },
-      debug: { type: "boolean", default: false },
-      help: { type: "boolean", default: false }
-    },
-    allowPositionals: false
-  });
-  if (values.help) {
-    console.log(HELP);
-    process.exit(0);
-  }
-  const cwd = process.cwd();
-  const dirPath = values.dir ? path4.resolve(cwd, values.dir) : path4.join(cwd, "data-source");
-  const envPath = values.env ? path4.resolve(cwd, values.env) : path4.join(cwd, "../../.env");
-  const limit = parseInt(values.limit ?? "50", 10);
-  const format = values.format ?? "table";
-  loadEnvFile(envPath);
-  const params = {};
-  if (values.params) {
-    for (const pair of values.params.split(",")) {
-      const eqIdx = pair.indexOf("=");
-      if (eqIdx === -1) continue;
-      const key = pair.slice(0, eqIdx).trim();
-      const val = pair.slice(eqIdx + 1).trim();
-      params[key] = val;
-    }
-  }
-  if (values.slug) {
-    const result = await runDataSource(values.slug, dirPath, params, limit);
-    if (format === "json") {
-      displayJson([result]);
-    } else {
-      displaySummary(result);
-      if (values.debug) displayDebug(result);
-      if (!result.error) displayTable(result.rows, limit);
-    }
-    if (result.error) process.exit(1);
-  } else if (values.all) {
-    const results = await runAll(dirPath, params, limit);
-    if (format === "json") {
-      displayJson(results);
-    } else {
-      for (const r of results) {
-        displaySummary(r);
-        if (values.debug) displayDebug(r);
-        if (!r.error) displayTable(r.rows, limit);
-      }
-      const failed = results.filter((r) => r.error).length;
-      console.log(`
-Total: ${results.length}, Failed: ${failed}`);
-    }
-    const anyFailed = results.some((r) => r.error);
-    if (anyFailed) process.exit(1);
-  } else {
-    const slugs = await listSlugs(dirPath);
-    if (slugs.length === 0) {
-      displayError(new Error(`No data sources found in ${dirPath}`));
-      process.exit(1);
-    }
-    try {
-      const { selectDataSource: selectDataSource2, inputParameters: inputParameters2 } = await Promise.resolve().then(() => (init_interactive(), interactive_exports));
-      const slug = await selectDataSource2(slugs);
-      if (!slug) {
-        console.log("Cancelled.");
-        process.exit(0);
-      }
-      const jsonPath = path4.join(dirPath, `${slug}.json`);
-      let paramMeta = [];
-      try {
-        const raw = await readFile3(jsonPath, "utf-8");
-        const def = JSON.parse(raw);
-        paramMeta = def.parameters ?? [];
-      } catch {
-      }
-      const interactiveParams = await inputParameters2(paramMeta);
-      const merged = { ...interactiveParams, ...params };
-      const result = await runDataSource(slug, dirPath, merged, limit);
-      displaySummary(result);
-      if (values.debug) displayDebug(result);
-      if (!result.error) displayTable(result.rows, limit);
-      if (result.error) process.exit(1);
-    } catch (err) {
-      displayError(err instanceof Error ? err : new Error(String(err)));
-      process.exit(1);
-    }
-  }
-}
-main().catch((err) => {
-  displayError(err instanceof Error ? err : new Error(String(err)));
-  process.exit(1);
-});