railcode 0.1.10 → 0.1.12

package/README.md

@@ -23,7 +23,7 @@ railcode deploy                    Build (if configured) and deploy the app here
 railcode db <list|query> ...       List data connectors / run read-only SQL
 ```
 
-- **`login`** prompts for the server URL (default `http://api.127.0.0.1.nip.io`),
+- **`login`** prompts for the server URL (default `https://api.railcode.app`),
   email, and password. It exchanges credentials for a short-lived JWT, mints a
   personal API token, resolves your organization, and saves everything to
   `~/.railcode/config.json` (dir `0700`, file `0600`). The JWT is used once and
@@ -42,7 +42,7 @@ railcode db <list|query> ...       List data connectors / run read-only SQL
   `railcode db list` (aliases `ls`, `connections`) prints each connector's
   `name` + `engine` (`--json` for the raw array). `railcode db query "<sql>"`
   (alias `sql`) runs SQL against `--connection` (default `default`) and prints a
-  table + row count; `--engine <postgres|mysql>` is inferred from the connector
+  table + row count; `--engine <postgres|bigquery|snowflake>` is inferred from the connector
   list when omitted, `--params '<json-array>'` binds `$1, $2, …` placeholders
   (SQL is never interpolated), `--file <path>` reads SQL from a file, and
   `--json` prints the raw `{ columns, rows, rowcount, truncated }` envelope.

package/dist/connectors.js

@@ -5,20 +5,74 @@
 import { formatTable } from "./db.js";
 export class ConnectorError extends Error {
 }
-// Render the connector list as a table. The `description` column is only added
-// when at least one connector actually has one, so the common (description-less)
-// case stays narrow.
+// What goes in the optional `docs` column: which kinds of documentation a connector
+// exposes (pull the content with `railcode connector docs <name>`).
+function docsCell(c) {
+    const parts = [];
+    if (c.has_docs)
+        parts.push("api");
+    if (c.has_openapi)
+        parts.push("openapi");
+    return parts.join(", ");
+}
+// Render the connector list as a table. The `description` and `docs` columns are each
+// only added when at least one connector actually has that, so the common (bare) case
+// stays narrow.
 export function connectorTable(connectors) {
     const hasDescription = connectors.some((c) => (c.description ?? "").length > 0);
-    const columns = hasDescription
-        ? ["name", "auth_type", "allowed_methods", "description"]
-        : ["name", "auth_type", "allowed_methods"];
+    const hasDocs = connectors.some((c) => c.has_docs || c.has_openapi);
+    const columns = ["name", "auth_type", "allowed_methods"];
+    if (hasDescription)
+        columns.push("description");
+    if (hasDocs)
+        columns.push("docs");
     const rows = connectors.map((c) => {
-        const base = [c.name, c.auth_type, (c.allowed_methods ?? []).join(", ")];
-        return hasDescription ? [...base, c.description ?? ""] : base;
+        const row = [c.name, c.auth_type, (c.allowed_methods ?? []).join(", ")];
+        if (hasDescription)
+            row.push(c.description ?? "");
+        if (hasDocs)
+            row.push(docsCell(c));
+        return row;
     });
     return formatTable(columns, rows);
 }
+// What `--openapi` emits for one connector: the inline spec verbatim if present,
+// otherwise the spec URL, otherwise null (no spec configured).
+export function connectorOpenapiOutput(docs) {
+    if (docs.openapi_spec_inline)
+        return docs.openapi_spec_inline;
+    if (docs.openapi_spec_link)
+        return docs.openapi_spec_link;
+    return null;
+}
+// Human render of a connector's docs bundle: identity line, then usage instructions,
+// API docs (link or inline), and the OpenAPI spec (link or inline) when present.
+export function renderConnectorDocs(docs) {
+    const methods = (docs.allowed_methods ?? []).join(", ") || "(all)";
+    const sections = [`${docs.name} (${docs.auth_type}) — methods: ${methods}`];
+    if (docs.description)
+        sections.push(docs.description);
+    const hasAny = docs.usage_instructions ||
+        docs.api_docs_link ||
+        docs.api_docs_inline ||
+        docs.openapi_spec_link ||
+        docs.openapi_spec_inline;
+    if (!hasAny) {
+        sections.push(`No documentation is configured for connector "${docs.name}".`);
+        return sections.join("\n\n");
+    }
+    if (docs.usage_instructions)
+        sections.push(`Usage instructions:\n${docs.usage_instructions}`);
+    if (docs.api_docs_link)
+        sections.push(`API docs: ${docs.api_docs_link}`);
+    else if (docs.api_docs_inline)
+        sections.push(`API docs (inline):\n${docs.api_docs_inline}`);
+    if (docs.openapi_spec_link)
+        sections.push(`OpenAPI spec: ${docs.openapi_spec_link}`);
+    else if (docs.openapi_spec_inline)
+        sections.push(`OpenAPI spec (inline):\n${docs.openapi_spec_inline}`);
+    return sections.join("\n\n");
+}
 // `--connector <name>` is required for `fetch`. Reject a missing value or a bare
 // flag with a usage message.
 export function parseConnectorOption(raw) {

package/dist/db.js

@@ -3,7 +3,7 @@
 // the command layer in index.ts does the HTTP, file reads, and printing.
 export class DbError extends Error {
 }
-export const DB_ENGINES = ["postgres", "mysql"];
+export const DB_ENGINES = ["postgres", "bigquery", "snowflake"];
 // `--params '<json-array>'` → the positional $1,$2,… values. Empty when omitted.
 export function parseSqlParams(raw) {
     if (raw === undefined)
@@ -24,8 +24,9 @@ export function parseSqlParams(raw) {
 export function parseEngine(raw) {
     if (raw === undefined)
         return undefined;
-    if (typeof raw !== "string")
-        throw new DbError("--engine requires a value (postgres or mysql).");
+    if (typeof raw !== "string") {
+        throw new DbError(`--engine requires a value (one of: ${DB_ENGINES.join(", ")}).`);
+    }
     if (DB_ENGINES.includes(raw))
         return raw;
     throw new DbError(`Unknown --engine "${raw}". Use one of: ${DB_ENGINES.join(", ")}.`);

package/dist/index.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
-import { createReadStream, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { createReadStream, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync, } from "node:fs";
 import { spawn } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
 import { createServer, request as httpRequest, } from "node:http";
-import { connect as netConnect } from "node:net";
+import { createServer as createNetServer, connect as netConnect } from "node:net";
 import { homedir } from "node:os";
 import { Readable } from "node:stream";
 import { dirname, join, relative, resolve, sep } from "node:path";
@@ -12,7 +12,7 @@ import { createInterface } from "node:readline/promises";
 import { fileURLToPath } from "node:url";
 import { KvQueryError, kvCount, kvQuery, } from "./dev/kv-query.js";
 import { DbError, formatTable, inferEngine, parseEngine, parseSqlParams, pickSqlSource, } from "./db.js";
-import { ConnectorError, buildConnectorRequest, connectorTable, parseConnectorOption, parseMethodOption, pickConnectorBody, proxyExitCode, renderProxyResponse, } from "./connectors.js";
+import { ConnectorError, buildConnectorRequest, connectorOpenapiOutput, connectorTable, parseConnectorOption, parseMethodOption, pickConnectorBody, proxyExitCode, renderConnectorDocs, renderProxyResponse, } from "./connectors.js";
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
@@ -20,7 +20,7 @@ const RAILCODE_HOME = process.env.RAILCODE_HOME || join(homedir(), ".railcode");
 const CONFIG_PATH = join(RAILCODE_HOME, "config.json");
 const CLI_PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 const VERSION = readCliPackageVersion();
-const DEFAULT_API_URL = "http://api.127.0.0.1.nip.io";
+const DEFAULT_API_URL = "https://api.railcode.app";
 const MANIFEST_NAME = "railcode.json";
 const CLI_AUTH_CALLBACK_PATH = "/railcode-cli/callback";
 const CLI_AUTH_TIMEOUT_MS = 5 * 60 * 1000;
@@ -35,7 +35,7 @@ Usage:
   railcode init <app> [--template static|react]
   railcode design-system               Print your org's design-system guidance (markdown)
   railcode db <list|query> ...         List data connectors / run read-only SQL
-  railcode connector <list|fetch> ...  List service connectors / proxy one call
+  railcode connector <list|docs|fetch> ...  List connectors / show API docs / proxy a call
   railcode --version
   railcode --help
 
@@ -951,14 +951,19 @@ const CONNECTOR_HELP = `railcode connector — service connectors
 
 Usage:
   railcode connector list                       List this org's service connectors
+  railcode connector docs <name> [opts]         Show how to call a connector's API
   railcode connector fetch <path> --connector <name> [opts]
                                                  Proxy one HTTP call through a connector
 
-Aliases: connector = connectors; list = ls, connectors; fetch = request.
+Aliases: connector = connectors; list = ls, connectors; docs = doc; fetch = request.
 
 List options:
   --json                                 Print the raw connector array
 
+Docs options:
+  --json                                 Print the raw docs object
+  --openapi                              Print only the OpenAPI spec (inline text, else its URL)
+
 Fetch options:
   --connector <name>                     Connector to call (required)
   --method <verb>                        HTTP method (default GET; must be allowed by the connector)
@@ -979,6 +984,10 @@ async function commandConnector(args) {
             case "connectors":
                 await commandConnectorList(args);
                 return;
+            case "docs":
+            case "doc":
+                await commandConnectorDocs(args);
+                return;
             case "fetch":
             case "request":
                 await commandConnectorFetch(args);
@@ -1043,12 +1052,50 @@ async function commandConnectorFetch(args) {
     // it, but exit non-zero so scripts can tell success from failure.
     process.exitCode = proxyExitCode(envelope);
 }
+async function commandConnectorDocs(args) {
+    assertKnownConnectorOptions(args, ["json", "openapi", "apiUrl"]);
+    const name = args.rest[1];
+    if (!name) {
+        throw new CliError("Usage: railcode connector docs <name>. Run `railcode connector list` to see names.", 2);
+    }
+    if (args.rest.length > 2) {
+        throw new CliError(`railcode connector docs takes a single connector name (got "${args.rest[2]}").`, 2);
+    }
+    if (args.options.json && args.options.openapi) {
+        throw new CliError("Pass either --json or --openapi, not both.", 2);
+    }
+    const config = requireLogin(args);
+    const app = await resolveExistingApp(config, requireAppSlug());
+    const docs = await fetchServiceConnectorDocs(config, app.uuid, name);
+    if (args.options.json) {
+        console.log(JSON.stringify(docs, null, 2));
+        return;
+    }
+    if (args.options.openapi) {
+        const spec = connectorOpenapiOutput(docs);
+        if (spec === null) {
+            throw new CliError(`Connector "${name}" has no OpenAPI spec.`, 1);
+        }
+        console.log(spec);
+        return;
+    }
+    console.log(renderConnectorDocs(docs));
+}
 async function fetchServiceConnectors(config, appUuid) {
     const resp = await authedFetch(config, `/api/organizations/${config.orgUuid}/apps/${appUuid}/service-connectors`);
     if (resp.status === 401)
         await reLoginOrThrow();
     return (await readJsonOrThrow(resp, "List service connectors"));
 }
+async function fetchServiceConnectorDocs(config, appUuid, name) {
+    const resp = await authedFetch(config, `/api/organizations/${config.orgUuid}/apps/${appUuid}/service-connectors/${encodeURIComponent(name)}`);
+    if (resp.status === 401)
+        await reLoginOrThrow();
+    if (resp.status === 404) {
+        throw new CliError(`Connector "${name}" not found (or not enabled) in your org. Run \`railcode connector list\`.`, 1);
+    }
+    return (await readJsonOrThrow(resp, "Connector docs"));
+}
 async function runConnectorRequest(config, appUuid, body) {
     const resp = await authedFetch(config, `/api/organizations/${config.orgUuid}/apps/${appUuid}/service-connectors/request`, {
         method: "POST",
@@ -1324,33 +1371,62 @@ async function commandDev(args) {
         port: requestedPort,
         config,
     };
+    // Asset mode needs its deps before we bind anything; the check is cheap and
+    // failing early avoids leaving the proxy port bound on a misconfigured app.
+    if (plan.mode === "asset")
+        ensureAppDeps(cwd);
+    const server = createServer((req, res) => {
+        handleDevRequest(ctx, req, res).catch((err) => {
+            sendJson(res, 500, { detail: err instanceof Error ? err.message : String(err) });
+        });
+    });
+    server.on("upgrade", (req, socket, head) => proxyUpgrade(ctx, req, socket, head));
+    // Bind the main proxy port FIRST, so the asset (Vite) child receives the real
+    // RAILCODE_DEV_PORT even when the requested proxy port was busy.
+    const actualPort = await listenLoopback(server, requestedPort);
+    ctx.port = actualPort;
+    if (actualPort !== requestedPort) {
+        console.log(`Port ${requestedPort} was busy; using ${actualPort}.`);
+    }
     // Asset mode: start the app's own dev server (Vite) and reverse-proxy to it,
     // tunnelling the HMR WebSocket. Static mode serves files straight from disk.
     if (plan.mode === "asset") {
-        ensureAppDeps(cwd);
-        const assetPort = assetServerPort(args, manifest);
-        const child = startAssetServer(plan, cwd, assetPort, requestedPort);
+        const startPort = assetServerPort(args, manifest);
+        let asset;
+        try {
+            asset = await startAssetServer(plan, cwd, startPort, actualPort);
+        }
+        catch (err) {
+            server.close();
+            throw err;
+        }
+        const { child, reservation } = asset;
+        if (reservation.port !== startPort) {
+            console.log(`Port ${startPort} was busy; using ${reservation.port}.`);
+        }
         process.on("SIGINT", () => {
             child.kill();
+            reservation.release();
             process.exit(0);
         });
         child.on("exit", (code) => {
+            reservation.release();
             if (code && code !== 0) {
                 console.error(`\nAsset dev server exited (code ${code}).`);
                 process.exit(code);
             }
         });
-        await waitForPort(assetPort, 30_000);
-        ctx.assetPort = assetPort;
+        try {
+            await waitForPort(reservation.port, 30_000);
+        }
+        catch (err) {
+            child.kill();
+            reservation.release();
+            server.close();
+            throw err;
+        }
+        ctx.assetPort = reservation.port;
     }
-    const server = createServer((req, res) => {
-        handleDevRequest(ctx, req, res).catch((err) => {
-            sendJson(res, 500, { detail: err instanceof Error ? err.message : String(err) });
-        });
-    });
-    server.on("upgrade", (req, socket, head) => proxyUpgrade(ctx, req, socket, head));
-    const actualPort = await listenLoopback(server, requestedPort);
-    ctx.port = actualPort;
     printDevBanner(ctx, config);
 }
 function devPort(args) {
@@ -1363,6 +1439,126 @@ function devPort(args) {
     }
     return DEFAULT_DEV_PORT;
 }
+// ---------------------------------------------------------------------------
+// Port reservation (asset / Vite dev server)
+//
+// Unlike the main proxy port — which the CLI binds itself, so a plain
+// EADDRINUSE retry loop (`listenLoopback`) suffices — the asset port is handed
+// to a *child* (Vite, `--strictPort`). Two concurrent `railcode dev` sessions
+// could each probe the same free port and then both tell Vite to bind it, and
+// the loser dies. To prevent that we take a cross-process filesystem lock under
+// `~/.railcode/dev/.ports/<port>` (reusing RAILCODE_HOME) *before* probing, and
+// hold it for the lifetime of the asset child. Ported from railcode-core.
+// ---------------------------------------------------------------------------
+const PORT_SEARCH_LIMIT = 100;
+const PORTS_DIR = join(RAILCODE_HOME, "dev", ".ports");
+function errorCode(err) {
+    return typeof err === "object" && err !== null && "code" in err
+        ? String(err.code)
+        : undefined;
+}
+function nowIso() {
+    return new Date().toISOString();
+}
+function readJsonFile(path) {
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function writeJsonFile(path, value) {
+    writeFileSync(path, JSON.stringify(value), { mode: 0o600 });
+}
+// `process.kill(pid, 0)` sends no signal but performs the existence/permission
+// check: ESRCH => gone, EPERM => alive but owned by someone else (still running).
+function processIsRunning(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        return errorCode(err) === "EPERM";
+    }
+}
+// Drop a lock dir whose owner process is no longer alive, so a crashed session
+// doesn't wedge a port forever. No-op if the owner is still running.
+function removeStalePortLock(lockDir) {
+    const owner = readJsonFile(join(lockDir, "owner.json"));
+    if (owner && typeof owner.pid === "number" && processIsRunning(owner.pid)) {
+        return;
+    }
+    rmSync(lockDir, { recursive: true, force: true });
+}
+// Atomically claim `<portsDir>/<port>` via a non-recursive mkdir (fails EEXIST
+// if already held). Reclaims a stale lock once, then retries. Returns null if a
+// live session already holds it; otherwise a reservation whose release() frees
+// the lock.
+export function reserveRailcodePort(port, portsDir = PORTS_DIR) {
+    const lockDir = join(portsDir, String(port));
+    const claim = () => {
+        try {
+            mkdirSync(lockDir);
+            return true;
+        }
+        catch (err) {
+            if (errorCode(err) !== "EEXIST")
+                throw err;
+            return false;
+        }
+    };
+    if (!claim()) {
+        removeStalePortLock(lockDir);
+        if (!claim())
+            return null;
+    }
+    writeJsonFile(join(lockDir, "owner.json"), { pid: process.pid, createdAt: nowIso() });
+    let released = false;
+    return {
+        port,
+        release: () => {
+            if (released)
+                return;
+            released = true;
+            rmSync(lockDir, { recursive: true, force: true });
+        },
+    };
+}
+// Real OS probe: can we bind 127.0.0.1:<port> right now? Binds and immediately
+// closes. Complements the filesystem lock (which only guards against other
+// railcode sessions) by catching unrelated processes already on the port.
+export function canListenOnPort(port) {
+    return new Promise((resolvePromise) => {
+        const probe = createNetServer();
+        probe.once("error", () => {
+            probe.close();
+            resolvePromise(false);
+        });
+        probe.listen(port, "127.0.0.1", () => {
+            probe.close(() => resolvePromise(true));
+        });
+    });
+}
+// Walk up from `startPort` (capped at PORT_SEARCH_LIMIT) and return the first
+// port that is both lockable (cross-process) and OS-bindable. The lock is taken
+// before the bind probe so two sessions can't both pass the probe on the same
+// port; if the lock succeeds but the OS port is busy we release and move on.
+export async function reserveAvailablePort(startPort, label, portsDir = PORTS_DIR) {
+    mkdirSync(portsDir, { recursive: true });
+    const end = Math.min(startPort + PORT_SEARCH_LIMIT, 65536);
+    for (let port = startPort; port < end; port++) {
+        const reservation = reserveRailcodePort(port, portsDir);
+        if (!reservation)
+            continue;
+        if (await canListenOnPort(port))
+            return reservation;
+        reservation.release();
+    }
+    throw new CliError(`No free ${label} port found in range ${startPort}-${end - 1}.`, 1);
+}
 function assetServerPort(args, manifest) {
     const opt = args.options.assetPort;
     if (typeof opt === "string") {
@@ -1381,7 +1577,12 @@ function ensureAppDeps(cwd) {
         throw new CliError("Dependencies are not installed. Run `pnpm install` here, then `railcode dev` again.", 1);
     }
 }
-function startAssetServer(plan, cwd, assetPort, devProxyPort) {
+async function startAssetServer(plan, cwd, startPort, devProxyPort) {
+    // Reserve the first free port from `startPort` (cross-process lock + OS probe)
+    // so a busy asset port auto-increments instead of dead-ending on Vite's
+    // `--strictPort`. The reservation is held for the asset child's lifetime.
+    const reservation = await reserveAvailablePort(startPort, "asset");
+    const assetPort = reservation.port;
     // For the detected Vite case, run the local vite binary directly with pinned
     // host/port so the proxy target is known. (Going through `pnpm dev -- …` would
     // forward the `--` separator to vite, which then ignores the flags.) A custom
@@ -1390,17 +1591,24 @@ function startAssetServer(plan, cwd, assetPort, devProxyPort) {
         ? `pnpm exec vite --host 127.0.0.1 --port ${assetPort} --strictPort --clearScreen false`
         : plan.command;
     console.log(`  asset server: ${command}`);
-    return spawn(command, {
-        cwd,
-        shell: true,
-        stdio: "inherit",
-        env: {
-            ...process.env,
-            PORT: String(assetPort),
-            RAILCODE_DEV_PORT: String(devProxyPort),
-            RAILCODE_ASSET_PORT: String(assetPort),
-        },
-    });
+    try {
+        const child = spawn(command, {
+            cwd,
+            shell: true,
+            stdio: "inherit",
+            env: {
+                ...process.env,
+                PORT: String(assetPort),
+                RAILCODE_DEV_PORT: String(devProxyPort),
+                RAILCODE_ASSET_PORT: String(assetPort),
+            },
+        });
+        return { child, reservation };
+    }
+    catch (err) {
+        reservation.release();
+        throw err;
+    }
 }
 function waitForPort(port, timeoutMs) {
     const deadline = Date.now() + timeoutMs;
@@ -2151,11 +2359,27 @@ function printDevBanner(ctx, config) {
     console.log("");
     console.log("  Ctrl-C to stop.");
 }
-main().catch((error) => {
-    if (error instanceof CliError) {
-        console.error(error.message);
-        process.exit(error.exitCode);
+// Run the CLI only when invoked as a script (the `railcode` bin), not when this
+// module is imported — e.g. by unit tests that exercise the exported helpers.
+// realpath both sides so a bin symlink (global install) still matches.
+function invokedAsScript() {
+    const arg = process.argv[1];
+    if (!arg)
+        return false;
+    try {
+        return realpathSync(arg) === realpathSync(fileURLToPath(import.meta.url));
     }
-    console.error(error instanceof Error ? error.message : String(error));
-    process.exit(1);
-});
+    catch {
+        return false;
+    }
+}
+if (invokedAsScript()) {
+    main().catch((error) => {
+        if (error instanceof CliError) {
+            console.error(error.message);
+            process.exit(error.exitCode);
+        }
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "railcode",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "Developer CLI for the multi-tenant Railcode platform: log in, scaffold, and deploy static apps.",
   "license": "MIT",
   "type": "module",

package/static/sdk.js

@@ -234,12 +234,14 @@
   };
   var runSQL = (engine, connection, query, params) => {
     const trimmed = shorten(query.replace(/\s+/g, " ").trim(), QUERY_LABEL_MAX);
-    const label2 = `${engine}(${q(connection)}).runSQL(${q(trimmed)}${params && params.length ? `, ${shorten(JSON.stringify(params), PARAMS_LABEL_MAX)}` : ""})`;
+    const label2 = `${engine ?? "data"}(${q(connection)}).runSQL(${q(trimmed)}${params && params.length ? `, ${shorten(JSON.stringify(params), PARAMS_LABEL_MAX)}` : ""})`;
     return track(
       "sql",
       label2,
       () => call("POST", "/sql", {
-        body: { engine, connection, query, params: params || [] }
+        // engine is advisory; omit it for the generic data() namespace so the backend
+        // dispatches on the connection's stored kind. postgres() pins engine="postgres".
+        body: { ...engine ? { engine } : {}, connection, query, params: params || [] }
       }).then(toSqlRows)
     );
   };
@@ -251,7 +253,10 @@
     ns.runSQL = (query, params) => runSQL(engine, "default", query, params);
     return ns;
   };
+  var data = namespace();
   var postgres = namespace("postgres");
+  var bigquery = namespace("bigquery");
+  var snowflake = namespace("snowflake");
   var dataConnectors = () => track("connections", "dataConnectors()", () => call("GET", "/connections"));
 
   // ../sdk/src/util.ts
@@ -383,16 +388,16 @@
   });
 
   // ../sdk/src/files.ts
-  function contentTypeOf(data, explicit) {
+  function contentTypeOf(data2, explicit) {
     if (explicit) return explicit;
-    if (data instanceof Blob && data.type) return data.type;
+    if (data2 instanceof Blob && data2.type) return data2.type;
     return "application/octet-stream";
   }
-  function upload(name, data, contentType) {
-    return track("files", `files.upload(${q(name)}, <blob>)`, () => doUpload(name, data, contentType));
+  function upload(name, data2, contentType) {
+    return track("files", `files.upload(${q(name)}, <blob>)`, () => doUpload(name, data2, contentType));
   }
-  async function doUpload(name, data, contentType) {
-    const ct = contentTypeOf(data, contentType);
+  async function doUpload(name, data2, contentType) {
+    const ct = contentTypeOf(data2, contentType);
     const target2 = await call("POST", "/files", {
       body: { name, content_type: ct }
     });
@@ -400,14 +405,14 @@
     if (target2.mode === "proxy") {
       const resp2 = await send(new URL(target2.url, location.origin).toString(), {
         method: target2.method,
-        body: data,
+        body: data2,
         headers,
         credentials: "include"
       });
       if (!resp2.ok) throw new Error(`upload failed: ${resp2.status} ${await resp2.text()}`);
       return await resp2.json();
     }
-    const resp = await fetch(target2.url, { method: target2.method, body: data, headers });
+    const resp = await fetch(target2.url, { method: target2.method, body: data2, headers });
     if (!resp.ok) throw new Error(`upload failed: ${resp.status}`);
     return call("POST", "/files/finalize", { body: { name } });
   }
@@ -535,7 +540,10 @@
   target.appUsers = appUsers;
   target.designSystem = designSystem;
   target.llm = llm;
+  target.data = data;
   target.postgres = postgres;
+  target.bigquery = bigquery;
+  target.snowflake = snowflake;
   target.dataConnectors = dataConnectors;
   target.connector = connector;
   target.serviceConnectors = serviceConnectors;