railcode 0.1.11 → 0.1.12

package/README.md

@@ -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/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";
@@ -1371,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) {
@@ -1410,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") {
@@ -1428,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
@@ -1437,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;
@@ -2198,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.11",
+  "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;