@base44-preview/cli 0.1.5-pr.577.1701370 → 0.1.6-pr.555.928bd24

package/bin/binary-entry.ts

@@ -1,7 +1,7 @@
 /**
  * Entry point for standalone compiled binaries (built with `bun build --compile`).
  *
- * This file embeds a single assets tarball (templates + deno-runtime) into the
+ * This file embeds a single assets tarball (templates + backend-runtime) into the
  * binary and extracts it to ~/.base44/assets/<version>/ on first run.
  * The npm distribution uses bin/run.js instead — this file is only used
  * for the compiled binary path.
@@ -25,7 +25,11 @@ const assetsDir = join(homedir(), ".base44", "assets", VERSION);
 // Extract assets if this version hasn't been unpacked yet.
 // Bun.file() reads from the virtual $bunfs, then we write to real disk
 // so the rest of the CLI can access these files normally.
-if (!existsSync(assetsDir)) {
+//
+// The directory existing is not proof its contents are current: an install
+// that predates a renamed or added asset directory would otherwise keep the
+// stale layout forever, so check for an expected directory too.
+if (!existsSync(assetsDir) || !existsSync(join(assetsDir, "backend-runtime"))) {
   mkdirSync(assetsDir, { recursive: true });
   const bytes = await Bun.file(assetsTarball).bytes();
   const archive = new Bun.Archive(bytes);

package/dist/assets/backend-runtime/base44-runtime.ts

@@ -0,0 +1,62 @@
+/**
+ * Local implementation of the `base44:runtime` module.
+ *
+ * Deployed backend functions import this module by its bare specifier
+ * (`import { secrets } from "base44:runtime"`). No such module exists on a
+ * developer machine, so `import-map.json` maps the specifier onto this file and
+ * `base44 dev` hands that import map to the Deno subprocess.
+ *
+ * Like the deployed module, this is only a delegator: it holds no state and
+ * reads no environment. Everything is served by the `globalThis.Base44` bridge
+ * that the host installs before loading the function — `main.ts` locally, the
+ * generated Worker entry when deployed. Keeping the two the same shape means a
+ * change to what a secret *is* only touches the host, never this file.
+ */
+
+/** Contract the host installs on `globalThis.Base44`. */
+export interface Base44Bridge {
+  waitUntil(promise: Promise<unknown>): void;
+  secrets: { get(name: string): string | undefined };
+}
+
+function bridge(): Base44Bridge {
+  const installed = (globalThis as { Base44?: Base44Bridge }).Base44;
+  if (!installed) {
+    throw new Error(
+      'base44:runtime was imported without a Base44 function host. It is only available inside a backend function — "base44 dev" installs the bridge before loading your code.',
+    );
+  }
+  return installed;
+}
+
+/**
+ * App secrets.
+ *
+ * Deployed, these come from the Worker env binding of the current request.
+ * Locally the host reads them from the environment `base44 dev` was started
+ * with, so a production secret is never copied onto a developer machine —
+ * export the variable in your shell to exercise a function that reads it.
+ *
+ * Returns `undefined` for an unset name rather than throwing, matching the
+ * deployed signature. Code needing a secret should construct inside the
+ * handler: at module scope a client built from `undefined` throws during boot,
+ * where no try/catch is reached and nothing is logged.
+ */
+export const secrets: { get(name: string): string | undefined } = {
+  get(name: string): string | undefined {
+    return bridge().secrets.get(name);
+  },
+};
+
+/**
+ * Continue work after the response has been sent.
+ *
+ * Deployed, this rides `ctx.waitUntil` to extend the invocation until the
+ * promise settles. Locally the function is a long-lived server process, so the
+ * host has nothing to hold open and only reports rejections. Returns the same
+ * promise either way, so it composes.
+ */
+export function waitUntil<T>(promise: Promise<T>): Promise<T> {
+  bridge().waitUntil(promise);
+  return promise;
+}

package/dist/assets/backend-runtime/import-map.json

@@ -0,0 +1,5 @@
+{
+  "imports": {
+    "base44:runtime": "./base44-runtime.ts"
+  }
+}

package/dist/assets/backend-runtime/main.ts

@@ -0,0 +1,169 @@
+/**
+ * Deno Function Wrapper
+ *
+ * This script is executed by Deno to run user functions.
+ * It patches Deno.serve to inject a dynamic port before importing the user's function.
+ *
+ * Two handler shapes are supported:
+ * - `export default async function (req) { ... }` — the shape the deployed
+ *   runtime expects. The wrapper serves it after importing the module.
+ * - `Deno.serve(handler)` — the legacy shape. A module that calls Deno.serve
+ *   while being imported serves itself and its default export is ignored,
+ *   mirroring the deployed bundler's precedence.
+ *
+ * Environment variables:
+ * - FUNCTION_PATH: Absolute path to the user's function entry file
+ * - FUNCTION_PORT: Port number for the function to listen on
+ * - FUNCTION_NAME: Name of the function (for logging)
+ */
+
+// Make this file a module for top-level await support
+export {};
+
+import type { Base44Bridge } from "./base44-runtime.ts";
+
+const functionPath = Deno.env.get("FUNCTION_PATH");
+const port = parseInt(Deno.env.get("FUNCTION_PORT") || "8000", 10);
+const functionName = Deno.env.get("FUNCTION_NAME") || "unknown";
+
+if (!functionPath) {
+  console.error("[wrapper] FUNCTION_PATH environment variable is required");
+  Deno.exit(1);
+}
+
+// Store the original Deno.serve
+const originalServe = Deno.serve.bind(Deno);
+
+// Set when the user's module calls Deno.serve while it is being imported.
+// Such a module serves itself, so its default export (if any) is ignored.
+let servedDuringImport = false;
+
+// Patch Deno.serve to inject our port and add onListen callback.
+const patchedServe = (
+  optionsOrHandler:
+    | Deno.ServeOptions
+    | Deno.ServeHandler
+    | (Deno.ServeOptions & { handler: Deno.ServeHandler }),
+  maybeHandler?: Deno.ServeHandler,
+): Deno.HttpServer<Deno.NetAddr> => {
+  servedDuringImport = true;
+
+  const onListen = () => {
+    // This message is used by FunctionManager to detect when the function is ready
+    console.log(`[${functionName}] Listening on http://localhost:${port}`);
+  };
+
+  // Handle the different Deno.serve signatures:
+  // 1. Deno.serve(handler)
+  // 2. Deno.serve(options, handler)
+  // 3. Deno.serve({ ...options, handler })
+  if (typeof optionsOrHandler === "function") {
+    // Signature: Deno.serve(handler)
+    return originalServe({ port, onListen }, optionsOrHandler);
+  }
+
+  if (maybeHandler) {
+    // Signature: Deno.serve(options, handler)
+    return originalServe({ ...optionsOrHandler, port, onListen }, maybeHandler);
+  }
+
+  // Signature: Deno.serve({ ...options, handler })
+  const options = optionsOrHandler as Deno.ServeOptions & {
+    handler: Deno.ServeHandler;
+  };
+  return originalServe({ ...options, port, onListen });
+};
+
+// Deno 2.8 exposes `Deno.serve` as a getter-only property, so a plain
+// `Deno.serve = ...` assignment throws. Use defineProperty to override it
+// (works on both the old writable property and the new accessor).
+Object.defineProperty(Deno, "serve", {
+  value: patchedServe,
+  writable: true,
+  configurable: true,
+});
+
+// Local stand-in for the bridge the deployed Worker entry installs. It must be
+// in place before the function is imported, because module-scope code may read
+// a secret. Deployed, secrets come from the request's Worker env binding and
+// `waitUntil` rides `ctx.waitUntil`; locally secrets come from this process's
+// environment and the server is long-lived, so there is nothing to hold open —
+// in-flight work is only tracked so a rejection is reported against the
+// function instead of surfacing as an unhandled rejection.
+const inFlight = new Set<Promise<unknown>>();
+
+const base44Bridge: Base44Bridge = {
+  secrets: {
+    get: (name: string) => Deno.env.get(name),
+  },
+  waitUntil: (promise: Promise<unknown>) => {
+    const tracked = Promise.resolve(promise)
+      .catch((error: unknown) => {
+        console.error(`[${functionName}] waitUntil task failed:`, error);
+      })
+      .finally(() => {
+        inFlight.delete(tracked);
+      });
+    inFlight.add(tracked);
+  },
+};
+
+Object.defineProperty(globalThis, "Base44", {
+  value: base44Bridge,
+  writable: false,
+  configurable: true,
+});
+
+type FetchHandler = (req: Request) => Response | Promise<Response>;
+
+/**
+ * Pull the request handler off the user's module namespace, accepting both
+ * `export default async function (req)` and the `export default { fetch }`
+ * object form.
+ */
+const resolveDefaultHandler = (
+  module: Record<string, unknown>,
+): FetchHandler | null => {
+  const exported = module.default;
+
+  if (typeof exported === "function") {
+    return exported as FetchHandler;
+  }
+
+  if (exported && typeof exported === "object") {
+    const { fetch } = exported as { fetch?: unknown };
+    if (typeof fetch === "function") {
+      return (fetch as FetchHandler).bind(exported);
+    }
+  }
+
+  return null;
+};
+
+console.log(`[${functionName}] Starting function from ${functionPath}`);
+
+// Dynamically import the user's function. A legacy function calls Deno.serve
+// during import, which is now patched to use our port.
+let functionModule: Record<string, unknown>;
+try {
+  functionModule = await import(functionPath);
+} catch (error) {
+  console.error(`[${functionName}] Failed to load function:`, error);
+  Deno.exit(1);
+}
+
+// Nothing served itself during import, so the module is expected to export a
+// handler. Serving it here goes through the same patched Deno.serve, so the
+// readiness line still gets printed exactly once.
+if (!servedDuringImport) {
+  const handler = resolveDefaultHandler(functionModule);
+
+  if (!handler) {
+    console.error(
+      `[${functionName}] The function must export default a request handler or call Deno.serve()`,
+    );
+    Deno.exit(1);
+  }
+
+  Deno.serve(handler);
+}