@base44-preview/cli 0.1.32-pr.658.bc0ac49 → 0.1.32-pr.660.017611e

package/dist/cli/index.js

@@ -221164,6 +221164,34 @@ var require_dist5 = __commonJS(function(exports, module) {
   }
 });
 
+// ../../node_modules/commander/index.js
+var exports_commander = {};
+__exportCjs(exports_commander, {
+  program: () => $program,
+  createCommand: () => $createCommand,
+  createOption: () => $createOption,
+  createArgument: () => $createArgument,
+  Command: () => $Command,
+  Option: () => $Option,
+  Argument: () => $Argument,
+  Help: () => $Help,
+  CommanderError: () => $CommanderError,
+  InvalidArgumentError: () => $InvalidArgumentError,
+  InvalidOptionArgumentError: () => $InvalidOptionArgumentError
+}, {
+  program: (value) => $program = value,
+  createCommand: (value) => $createCommand = value,
+  createOption: (value) => $createOption = value,
+  createArgument: (value) => $createArgument = value,
+  Command: (value) => $Command = value,
+  Option: (value) => $Option = value,
+  Argument: (value) => $Argument = value,
+  Help: (value) => $Help = value,
+  CommanderError: (value) => $CommanderError = value,
+  InvalidArgumentError: (value) => $InvalidArgumentError = value,
+  InvalidOptionArgumentError: (value) => $InvalidOptionArgumentError = value
+});
+
 // src/core/utils/env.ts
 var import_dotenv = __toESM(require_main(), 1);
 import { basename, dirname as dirname3, join } from "node:path";
@@ -229878,32 +229906,6 @@ class SimpleLogger {
   }
 }
 // ../../node_modules/commander/index.js
-var exports_commander = {};
-__exportCjs(exports_commander, {
-  program: () => $program,
-  createCommand: () => $createCommand,
-  createOption: () => $createOption,
-  createArgument: () => $createArgument,
-  Command: () => $Command,
-  Option: () => $Option,
-  Argument: () => $Argument,
-  Help: () => $Help,
-  CommanderError: () => $CommanderError,
-  InvalidArgumentError: () => $InvalidArgumentError,
-  InvalidOptionArgumentError: () => $InvalidOptionArgumentError
-}, {
-  program: (value) => $program = value,
-  createCommand: (value) => $createCommand = value,
-  createOption: (value) => $createOption = value,
-  createArgument: (value) => $createArgument = value,
-  Command: (value) => $Command = value,
-  Option: (value) => $Option = value,
-  Argument: (value) => $Argument = value,
-  Help: (value) => $Help = value,
-  CommanderError: (value) => $CommanderError = value,
-  InvalidArgumentError: (value) => $InvalidArgumentError = value,
-  InvalidOptionArgumentError: (value) => $InvalidOptionArgumentError = value
-});
 var { Argument } = require_argument();
 var { Command } = require_command();
 var { CommanderError, InvalidArgumentError } = require_error2();
@@ -236769,27 +236771,6 @@ function siteOrDefault(project) {
   warnConfigFallback(`${project.configPath} has no 'site' block; using the default site commands.`);
   return DEFAULT_SITE;
 }
-var COMMAND_NOT_FOUND_EXIT_CODES = new Set([127, 9009]);
-async function runSiteCommandOrDefault(command, fallback, run) {
-  try {
-    return await run(command);
-  } catch (error) {
-    if (command === fallback || !isCommandNotFound(error)) {
-      throw error;
-    }
-    warnSiteCommandFallback(command, fallback);
-    return run(fallback);
-  }
-}
-function warnSiteCommandFallback(command, fallback) {
-  warnConfigFallback(`'${command}' could not start because its program is not installed; running '${fallback}' instead.`);
-}
-function isCommandNotFoundExit(code) {
-  return typeof code === "number" && COMMAND_NOT_FOUND_EXIT_CODES.has(code);
-}
-function isCommandNotFound(error) {
-  return typeof error === "object" && error !== null && "exitCode" in error && isCommandNotFoundExit(error.exitCode);
-}
 function withoutKey(record, key) {
   return Object.fromEntries(Object.entries(record).filter(([k]) => k !== key));
 }
@@ -249772,11 +249753,11 @@ function getFunctionsCommand() {
 
 // src/cli/commands/project/site-build.ts
 async function runSiteBuild({ runTask }, { root, buildCommand = DEFAULT_SITE.buildCommand, appId }) {
-  await runTask("Building site...", () => runSiteCommandOrDefault(buildCommand, DEFAULT_SITE.buildCommand, (command) => execa({
+  await runTask("Building site...", () => execa({
     cwd: root,
     shell: true,
     env: { VITE_BASE44_APP_ID: appId }
-  })`${command}`), {
+  })`${buildCommand}`, {
     successMessage: "Site built successfully",
     errorMessage: "Build failed"
   });
@@ -253293,7 +253274,97 @@ function installStaticEgressFetch() {
   staticEgressFetchInstalled = true;
 }
 
+// src/static-egress-tcp-core.mjs
+function normalizeHost(host) {
+  return host.toLowerCase().replace(/^\\[(.*)\\]$/, "$1").replace(/\\.$/, "");
+}
+function destination(address) {
+  const hostname4 = address?.hostname;
+  const port = address?.port;
+  if (typeof hostname4 !== "string" || !hostname4 || /[\\s/@\\\\?#%]/.test(hostname4) || hostname4.startsWith("[") && !hostname4.endsWith("]")) {
+    throw new TypeError("staticEgress.connect requires a hostname or IP address, not a URL");
+  }
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new TypeError("staticEgress.connect requires an integer port between 1 and 65535");
+  }
+  const authority = hostname4.includes(":") && !hostname4.startsWith("[") ? \`[\${hostname4}]\` : hostname4;
+  let url2;
+  try {
+    url2 = new URL(\`http://\${authority}\`);
+  } catch {
+    throw new TypeError("staticEgress.connect requires a valid hostname or IP address");
+  }
+  if (url2.port || url2.pathname !== "/" || !url2.hostname) {
+    throw new TypeError("staticEgress.connect requires hostname and port as separate fields");
+  }
+  return { hostname: normalizeHost(url2.hostname), port };
+}
+function publicHost(host) {
+  if (host === "localhost" || /\\.(localhost|local|internal)$/.test(host)) return false;
+  if (host.includes(":")) return /^[23][0-9a-f]{3}:/.test(host);
+  if (!/^\\d+\\.\\d+\\.\\d+\\.\\d+$/.test(host)) return host.includes(".");
+  const [a2, b] = host.split(".").map(Number);
+  return !(a2 === 0 || a2 === 10 || a2 === 127 || a2 >= 224 || a2 === 100 && b >= 64 && b <= 127 || a2 === 169 && b === 254 || a2 === 172 && b >= 16 && b <= 31 || a2 === 192 && b === 168 || a2 === 198 && (b === 18 || b === 19));
+}
+function configuredList(raw) {
+  if (raw === void 0) return [];
+  try {
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed)) return parsed;
+  } catch {
+  }
+  throw new Error("Static egress destination restrictions are unavailable");
+}
+function createStaticEgress(readEnvironment) {
+  return Object.freeze({
+    async connect(address, options = {}) {
+      if (options === null || typeof options !== "object" || Array.isArray(options) || Object.keys(options).some((key) => key !== "secureTransport") || options.secureTransport !== void 0 && options.secureTransport !== "off") {
+        throw new TypeError("Static egress TCP currently supports only secureTransport: off; TLS and STARTTLS are not supported");
+      }
+      const target = destination(address);
+      const env2 = readEnvironment();
+      if (!env2) throw new Error("Static egress TCP requires an active server request");
+      if (env2.BASE44_STATIC_EGRESS_ENABLED !== "1") {
+        throw new Error("Workspace static egress is not enabled");
+      }
+      const binding = env2.STATIC_EGRESS;
+      if (typeof binding?.connect !== "function") {
+        throw new Error("Static egress TCP binding is unavailable; rebuild and redeploy with a supported runtime");
+      }
+      const excluded = [
+        ...configuredList(env2.BASE44_STATIC_EGRESS_EXCLUDED_HOSTS),
+        ...configuredList(env2.BASE44_PRIVATE_DATA_SOURCES).map((entry) => entry?.host)
+      ];
+      if (!publicHost(target.hostname) || excluded.some((host) => {
+        if (typeof host !== "string") return false;
+        const normalized = normalizeHost(host);
+        return normalized.startsWith(".") ? target.hostname === normalized.slice(1) || target.hostname.endsWith(normalized) : target.hostname === normalized;
+      })) {
+        throw new Error("Destination is not allowed through static egress TCP; use the configured private-data-source API for private services");
+      }
+      return binding.connect(target);
+    }
+  });
+}
+
+// src/static-egress-tcp.ts
+import { getRuntimeManifest } from "base44:private-data-sources/runtime-manifest-store";
+function installStaticEgressTcp() {
+  const staticEgress = createStaticEgress(() => {
+    const context = currentWorkerRuntimeContext();
+    if (!context) return void 0;
+    const runtimeManifest = getRuntimeManifest();
+    return {
+      ...context.workerEnv,
+      BASE44_PRIVATE_DATA_SOURCES: runtimeManifest === void 0 ? context.workerEnv.BASE44_PRIVATE_DATA_SOURCES : runtimeManifest || "[]"
+    };
+  });
+  const globals = globalThis;
+  globals.Base44 = Object.assign(globals.Base44 ?? {}, { staticEgress });
+}
+
 // src/shim/entry.ts
+installStaticEgressTcp();
 var registeredHandler = null;
 var initContext = new AsyncLocalStorage();
 function serve(arg1, arg2) {
@@ -254862,6 +254933,7 @@ export {
 interface Base44Bridge {
   waitUntil(promise: Promise<unknown>): void;
   secrets: { get(name: string): string | undefined };
+  staticEgress?: { connect(address: StaticEgressAddress, options?: StaticEgressOptions): Promise<StaticEgressSocket> };
 }
 
 function bridge(): Base44Bridge {
@@ -254882,6 +254954,31 @@ export const secrets: { get(name: string): string | undefined } = {
     return bridge().secrets.get(name);
   },
 };
+
+export interface StaticEgressAddress {
+  hostname: string;
+  port: number;
+}
+
+export interface StaticEgressOptions {
+  secureTransport?: "off";
+}
+
+export interface StaticEgressSocket {
+  readable: ReadableStream<Uint8Array>;
+  writable: WritableStream<Uint8Array>;
+  opened: Promise<{ remoteAddress?: string | null; localAddress?: string | null }>;
+  closed: Promise<void>;
+  close(): Promise<void>;
+}
+
+export const staticEgress = Object.freeze({
+  async connect(address: StaticEgressAddress, options?: StaticEgressOptions): Promise<StaticEgressSocket> {
+    const api = bridge()?.staticEgress;
+    if (!api) throw new Error("Static egress TCP is unavailable; rebuild and redeploy with a supported runtime");
+    return api.connect(address, options);
+  },
+});
 `,
   "runtime-context.ts": `import { AsyncLocalStorage } from "node:async_hooks";
 
@@ -255953,7 +256050,7 @@ export function redis(name: unknown) {
   workerEnvironment,
 } from "base44:internal/runtime-context";
 `,
-  "private-data-sources/runtime-manifest-store.ts": "// Private, single-instance channel for the handshake-delivered PDS manifest.\n//\n// The manifest carries plaintext VPC/DB credentials, so it must NOT be\n// reachable by user code. It lives here in module-private state: the activation\n// shim writes it (via `setRuntimeManifest`) and `manifest.ts` reads it (via\n// `getRuntimeManifest`) — both resolve to THIS one module instance in the final\n// bundle, so the value never touches `globalThis`, `process.env`, or any\n// user-importable surface. User function code cannot import this module, via\n// two independent gates: (1) the bundler's private-data-sources virtual plugin\n// resolves the `base44:private-data-sources/runtime-manifest-store` specifier\n// ONLY when the importer is EXACTLY the injected activation shim's bundle-root\n// key (not a suffix/segment match — else a nested `x/__base44_activation.mjs`\n// could pose as it); (2) `assertNoReservedFilenames` rejects that basename at\n// any depth in user files. The relative `./runtime-manifest-store` path only\n// resolves inside the plugin's namespace (the adapters + manifest.ts), never\n// from a user file.\n//\n// Single instance: both importers resolve to the SAME (namespace, path) pair,\n// so esbuild emits one module. The runtime-secrets e2e proves this end to end —\n// if the two ever diverged into separate instances, the shim would write one\n// and manifest.ts would read the other (empty), and the delivered manifest\n// would resolve as \"not bound\".\n\nlet runtimeManifestRaw: string | undefined;\n\nexport function setRuntimeManifest(raw: string | undefined): void {\n  runtimeManifestRaw = raw;\n}\n\nexport function getRuntimeManifest(): string | undefined {\n  return runtimeManifestRaw;\n}\n",
+  "private-data-sources/runtime-manifest-store.ts": "// Private, single-instance channel for the handshake-delivered PDS manifest.\n//\n// The manifest carries plaintext VPC/DB credentials, so it must NOT be\n// reachable by user code. It lives here in module-private state: the activation\n// shim writes it (via `setRuntimeManifest`); `manifest.ts` and the trusted TCP\n// runtime read it (via `getRuntimeManifest`) from THIS module instance in the final\n// bundle, so the value never touches `globalThis`, `process.env`, or any\n// user-importable surface. User function code cannot import this module, via\n// two independent gates: (1) the bundler's private-data-sources virtual plugin\n// resolves the `base44:private-data-sources/runtime-manifest-store` specifier\n// ONLY when the importer is EXACTLY the injected activation or runtime shim's bundle-root\n// key (not a suffix/segment match — else a nested `x/__base44_activation.mjs`\n// could pose as it); (2) `assertNoReservedFilenames` rejects those basenames at\n// any depth in user files. The relative `./runtime-manifest-store` path only\n// resolves inside the plugin's namespace (the adapters + manifest.ts), never\n// from a user file.\n//\n// Single instance: both importers resolve to the SAME (namespace, path) pair,\n// so esbuild emits one module. The runtime-secrets e2e proves this end to end —\n// if the two ever diverged into separate instances, the shim would write one\n// and manifest.ts would read the other (empty), and the delivered manifest\n// would resolve as \"not bound\".\n\nlet runtimeManifestRaw: string | undefined;\n\nexport function setRuntimeManifest(raw: string | undefined): void {\n  runtimeManifestRaw = raw;\n}\n\nexport function getRuntimeManifest(): string | undefined {\n  return runtimeManifestRaw;\n}\n",
   "private-data-sources/sqlserver.ts": `import { buildTediousConnectorFactory } from "./tedious-adapter";
 import { privateDataSourceReference } from "./manifest";
 import { buildTcpPrivateDataSource } from "./tcp";
@@ -256550,8 +256647,8 @@ function publicModulePath(specifier) {
   return `${moduleName}.ts`;
 }
 var INTERNAL_STORE_SPECIFIER = `${PREFIX2}/runtime-manifest-store`;
-function isActivationShimImporter(namespace, importer) {
-  return namespace === USER_NAMESPACE && importer === ACTIVATION_FILENAME;
+function isRuntimeShimImporter(namespace, importer) {
+  return namespace === USER_NAMESPACE && (importer === ACTIVATION_FILENAME || importer === SHIM_FILENAME);
 }
 function relativeModulePath(importer, specifier) {
   if (!specifier.startsWith("./") && !specifier.startsWith("../"))
@@ -256571,7 +256668,7 @@ function privateDataSourcesVirtualPlugin() {
     setup(build) {
       build.onResolve({ filter: /^base44:private-data-sources(?:\/.*)?$/ }, (args) => {
         if (args.path === INTERNAL_STORE_SPECIFIER) {
-          if (!isActivationShimImporter(args.namespace, args.importer)) {
+          if (!isRuntimeShimImporter(args.namespace, args.importer)) {
             return {
               errors: [
                 {
@@ -262348,25 +262445,14 @@ async function siteDevAction(ctx, forwarded) {
   const site = siteOrDefault(project);
   const serveCommand = site.serveCommand ?? DEFAULT_SERVE_COMMAND;
   const command = [serveCommand, ...forwarded].join(" ");
-  const fallback = [DEFAULT_SERVE_COMMAND, ...forwarded].join(" ");
-  const serve = (line) => {
-    const runner = createServeCommandRunner({
-      serveCommand: line,
-      projectRoot: project.root,
-      appId: app.id
-    });
-    stopRunnerOnProcessSignals(runner);
-    runner.onExit((code) => {
-      if (line !== fallback && isCommandNotFoundExit(code)) {
-        warnSiteCommandFallback(line, fallback);
-        serve(fallback);
-        return;
-      }
-      process.exit(code ?? 1);
-    });
-    runner.start();
-  };
-  serve(command);
+  const runner = createServeCommandRunner({
+    serveCommand: command,
+    projectRoot: project.root,
+    appId: app.id
+  });
+  stopRunnerOnProcessSignals(runner);
+  runner.onExit((code) => process.exit(code ?? 1));
+  runner.start();
   return { outroMessage: `Frontend dev server running '${command}'` };
 }
 function getSiteDevCommand() {
@@ -262379,16 +262465,12 @@ async function installAction({
 }) {
   const project = await readProjectSettingsOrDefaults();
   const { installCommand } = siteOrDefault(project);
-  let ran = installCommand;
-  await runTask("Installing site dependencies...", () => runSiteCommandOrDefault(installCommand, DEFAULT_SITE.installCommand, (command) => {
-    ran = command;
-    return execa({ cwd: project.root, shell: true })`${command}`;
-  }), {
+  await runTask("Installing site dependencies...", () => execa({ cwd: project.root, shell: true })`${installCommand}`, {
     successMessage: "Dependencies installed",
     errorMessage: "Install failed"
   });
   return {
-    outroMessage: `Installed with ${theme.styles.bold(ran)}`
+    outroMessage: `Installed with ${theme.styles.bold(installCommand)}`
   };
 }
 function getSiteInstallCommand() {
@@ -271320,4 +271402,4 @@ export {
   runCLI
 };
 
-//# debugId=61E073E485FD166064756E2164756E21
+//# debugId=5ADBB560F1D5EE5164756E2164756E21