railcode 0.1.6 → 0.1.8

package/dist/index.js

@@ -26,8 +26,11 @@ Usage:
   railcode login [--api-url <url>]
   railcode deploy [--private | --public]
   railcode access [public|private|restricted] [--users <a,b>]
+  railcode network
   railcode db list
   railcode db query "<sql>" [--connection <name>] [--engine <postgres|mysql>]
+  railcode connector list
+  railcode connector fetch <name> <path> [--method <verb>] [--body <data>]
   railcode get design-system
   railcode init <app>
   railcode upgrade
@@ -61,9 +64,16 @@ async function main() {
         case "access":
             await commandAccess(args);
             return;
+        case "network":
+            await commandNetwork(args);
+            return;
         case "db":
             await commandDb(args);
             return;
+        case "connector":
+        case "connectors":
+            await commandConnector(args);
+            return;
         case "get":
             await commandGet(args);
             return;
@@ -625,7 +635,8 @@ async function handleLocalApi(ctx, request, response, url) {
         await handleLocalFiles(ctx, request, response, path);
         return;
     }
-    if (path === "/connections" && (!ctx.token || !ctx.apiBase)) {
+    if ((path === "/connections" || path === "/service-connectors") &&
+        (!ctx.token || !ctx.apiBase)) {
         sendJson(response, 200, []);
         return;
     }
@@ -1599,6 +1610,70 @@ function appUrlFromOrigin(app, origin) {
     url.hash = "";
     return url.toString();
 }
+const NETWORK_HELP = `Usage:
+  railcode network        Show the platform default network mode for new apps
+
+Network mode is the per-app egress policy, enforced as a CSP:
+  open        No CSP — the app may fetch any origin.
+  restricted  External calls only via the Railcode proxy (connect-src 'self').
+  sandboxed   Same-origin only — no inline <script>, no external CDN/fonts.
+
+Admins set the default and flip individual apps from the admin console; the CLI
+only reports the default so you know how to build a new app.
+`;
+const NETWORK_MODE_BUILD_HINTS = {
+    open: "Build freely: direct fetch() to any origin is allowed.",
+    restricted: "Don't fetch external origins directly — route them through the Railcode proxy. Inline scripts and CDN assets are fine.",
+    sandboxed: "Same-origin only: no external fetch, no inline <script>, no external CDN/font links. Use the SDK and bundle every asset locally.",
+};
+async function commandNetwork(args) {
+    if (booleanOption(args, "help") || args.rest[0] === "help") {
+        console.log(NETWORK_HELP);
+        return;
+    }
+    if (args.rest.length > 0) {
+        throw new CliError("railcode network shows the platform default. Admins flip individual apps from the admin console.", 2);
+    }
+    rejectUnknownOptions(args, ["help", "json", "apiUrl"], "network");
+    const config = loadConfig();
+    const manifestApiUrl = readRailcodeManifest(process.cwd())?.manifest.deploy?.apiUrl;
+    const authUrl = await resolveRequiredAuthOrigin({
+        config,
+        args,
+        action: "Network mode",
+        fallbackApiUrl: manifestApiUrl,
+        missingUrlHint: "Pass --api-url <url>, set deploy.apiUrl in railcode.json, or set RAILCODE_API_URL.",
+    });
+    const apiUrl = canonicalApiOrigin(authUrl);
+    let authedConfig = await ensureApiToken({ ...config, apiUrl: authUrl }, authUrl, "Network mode");
+    let response = await fetchNetworkDefault(apiUrl, authedConfig);
+    if (response.status === 401 && !process.env.RAILCODE_API_TOKEN && process.stdin.isTTY) {
+        console.log("Saved login expired. Log in again to continue.");
+        const retryConfig = { ...authedConfig, apiUrl: authUrl };
+        delete retryConfig.apiToken;
+        delete retryConfig.apiTokenPrefix;
+        delete retryConfig.cookies;
+        saveConfig(retryConfig);
+        authedConfig = await ensureApiToken(retryConfig, authUrl, "Network mode");
+        response = await fetchNetworkDefault(apiUrl, authedConfig);
+    }
+    const view = (await readDbResponse(response, "Network mode"));
+    printNetworkDefault(view, booleanOption(args, "json"));
+}
+function fetchNetworkDefault(apiUrl, config) {
+    return dbFetch(apiUrl, config, "/v1/network-default", { redirect: "manual" });
+}
+function printNetworkDefault(view, json) {
+    if (json) {
+        console.log(JSON.stringify(view, null, 2));
+        return;
+    }
+    const mode = view.network_mode || "restricted";
+    console.log(`Platform default network mode: ${mode}`);
+    const hint = NETWORK_MODE_BUILD_HINTS[mode];
+    if (hint)
+        console.log(hint);
+}
 const DB_ENGINES = new Set(["postgres", "mysql"]);
 const DB_HELP = `Query Railcode data connectors.
 
@@ -1836,6 +1911,137 @@ function printSqlResult(result, asJson) {
     const count = typeof result.rowcount === "number" ? result.rowcount : rows.length;
     console.log(`${columns.length > 0 ? "\n" : ""}${count} ${count === 1 ? "row" : "rows"}${result.truncated ? " (truncated to first 1000)" : ""}`);
 }
+const CONNECTOR_HELP = `Call admin-configured HTTP service connectors (Stripe, PostHog, …).
+
+Usage:
+  railcode connector list
+  railcode connector fetch <name> <path> [options]
+
+Commands:
+  list                       List service connectors you can call (name + auth type).
+  fetch <name> <path>        Proxy an HTTP request through a connector.
+
+Fetch options:
+  --method <verb>            HTTP method (default GET). Must be allowed by the connector.
+  --body <data>              Raw request body (the connector sets the Content-Type).
+  --file <path>              Read the request body from a file instead.
+  --json                     Print the raw JSON envelope instead of the body.
+
+Options:
+  --api-url <url>            Railcode auth/API URL. Defaults to saved config or railcode.json.
+
+Examples:
+  railcode connector list
+  railcode connector fetch stripe /v1/charges
+  railcode connector fetch stripe /v1/charges --method POST --body "amount=100&currency=usd"
+`;
+async function commandConnector(args) {
+    const subcommand = args.rest[0];
+    const rest = { ...args, rest: args.rest.slice(1) };
+    switch (subcommand) {
+        case "list":
+        case "ls":
+            await commandConnectorList(rest);
+            return;
+        case "fetch":
+        case "request":
+            await commandConnectorFetch(rest);
+            return;
+        case undefined:
+        case "help":
+            console.log(CONNECTOR_HELP);
+            return;
+        default:
+            if (booleanOption(args, "help")) {
+                console.log(CONNECTOR_HELP);
+                return;
+            }
+            throw new CliError(`Unknown connector command: ${subcommand}\n\n${CONNECTOR_HELP}`, 2);
+    }
+}
+async function commandConnectorList(args) {
+    if (booleanOption(args, "help") || args.rest[0] === "help") {
+        console.log(CONNECTOR_HELP);
+        return;
+    }
+    rejectUnknownOptions(args, ["help", "json", "apiUrl"], "connector list");
+    if (args.rest.length > 0) {
+        throw new CliError("railcode connector list does not accept positional arguments.", 2);
+    }
+    const response = await dbAuthedRequest(args, "Service connectors list", fetchServiceConnectors);
+    const connectors = (await readDbResponse(response, "Service connectors list"));
+    printServiceConnectors(connectors, booleanOption(args, "json"));
+}
+async function commandConnectorFetch(args) {
+    if (booleanOption(args, "help") || args.rest[0] === "help") {
+        console.log(CONNECTOR_HELP);
+        return;
+    }
+    rejectUnknownOptions(args, ["help", "json", "apiUrl", "method", "body", "file"], "connector fetch");
+    const name = args.rest[0];
+    const path = args.rest[1];
+    if (!name || !path) {
+        throw new CliError("Usage: railcode connector fetch <name> <path> [--method <verb>] [--body <data>].", 2);
+    }
+    if (args.rest.length > 2) {
+        throw new CliError("railcode connector fetch takes a single connector name and path.", 2);
+    }
+    if (!path.startsWith("/")) {
+        throw new CliError("The connector path must start with '/'.", 2);
+    }
+    const method = (stringOption(args, "method") || "GET").trim().toUpperCase();
+    const body = resolveConnectorBody(args);
+    const requestBody = { connector: name, method, path, body };
+    const response = await dbAuthedRequest(args, "Connector request", (apiUrl, config) => postConnectorRequest(apiUrl, config, requestBody));
+    const result = (await readDbResponse(response, "Connector request", "Run `railcode connector list` to see connectors you can call."));
+    printConnectorResponse(result, booleanOption(args, "json"));
+}
+function resolveConnectorBody(args) {
+    const file = stringOption(args, "file");
+    const inline = stringOption(args, "body");
+    if (file && inline !== undefined) {
+        throw new CliError("Pass --body or --file, not both.", 2);
+    }
+    if (file) {
+        const path = resolve(file);
+        if (!existsSync(path))
+            throw new CliError(`Body file not found: ${path}`, 1);
+        return readFileSync(path, "utf8");
+    }
+    return inline;
+}
+function fetchServiceConnectors(apiUrl, config) {
+    return dbFetch(apiUrl, config, "/v1/service-connectors", { redirect: "manual" });
+}
+function postConnectorRequest(apiUrl, config, body) {
+    return dbFetch(apiUrl, config, "/v1/service-connectors/request", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+        redirect: "manual",
+    });
+}
+function printServiceConnectors(connectors, asJson) {
+    if (asJson) {
+        console.log(JSON.stringify(connectors, null, 2));
+        return;
+    }
+    if (!connectors || connectors.length === 0) {
+        console.log("No service connectors available.");
+        return;
+    }
+    console.log(formatTable(["NAME", "AUTH", "METHODS"], connectors.map((c) => [c.name, c.auth_type ?? "none", (c.allowed_methods ?? []).join(",")])));
+}
+function printConnectorResponse(result, asJson) {
+    if (asJson) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    const status = result.status ?? 0;
+    console.log(`${status} ${result.ok ? "OK" : "ERROR"}${result.truncated ? " (truncated)" : ""}`);
+    if (result.body)
+        console.log(result.body);
+}
 function rejectUnknownOptions(args, allowed, label) {
     const set = new Set(allowed);
     const unknown = Object.keys(args.options).filter((option) => !set.has(option));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "railcode",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "CLI for building, testing, and deploying Railcode apps.",
   "license": "MIT",
   "type": "module",

package/static/sdk.js

@@ -371,6 +371,39 @@
   var dataConnectors = () => track("connections", "dataConnectors()", () => call("GET", "/connections"));
   var databaseConnectors = dataConnectors;
 
+  // src/service-connectors.ts
+  var PATH_LABEL_MAX = 60;
+  var toResponse = (env) => {
+    const body = env.body ?? "";
+    return {
+      status: env.status,
+      ok: env.ok,
+      headers: env.headers || {},
+      truncated: Boolean(env.truncated),
+      text: () => Promise.resolve(body),
+      json: () => Promise.resolve(JSON.parse(body))
+    };
+  };
+  var request = (name, path, opts) => {
+    const method = (opts?.method || "GET").toUpperCase();
+    const label = `connector(${q(name)}).fetch(${q(method)} ${q(shorten(path, PATH_LABEL_MAX))})`;
+    return track(
+      "connector",
+      label,
+      () => call("POST", "/service-connectors/request", {
+        json: { connector: name, method, path, body: opts?.body }
+      }).then(toResponse)
+    );
+  };
+  var connector = (name) => ({
+    fetch: (path, opts) => request(name, path, opts)
+  });
+  var serviceConnectors = () => track(
+    "service-connectors",
+    "serviceConnectors()",
+    () => call("GET", "/service-connectors")
+  );
+
   // src/design-system.ts
   var designSystem = () => track("design-system", "designSystem()", async () => {
     const response = await call("GET", "/config/design-system");
@@ -437,6 +470,8 @@
   window.mysql = mysql;
   window.dataConnectors = dataConnectors;
   window.databaseConnectors = databaseConnectors;
+  window.connector = connector;
+  window.serviceConnectors = serviceConnectors;
   window.designSystem = designSystem;
   window.me = me;
   window.appUsers = appUsers;