@base44-preview/cli 0.1.5-pr.575.88555e2 → 0.1.5-pr.576.161be22

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,56 @@
+/**
+ * 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 `deno.json` maps the specifier onto this file and
+ * `base44 dev` hands that import map to the Deno subprocess.
+ *
+ * The surface mirrors production; the deliberate differences are called out on
+ * each export below.
+ */
+
+/**
+ * App secrets.
+ *
+ * Deployed, these are read from the Worker env binding of the current request.
+ * Locally they come from the environment `base44 dev` was started with —
+ * values stored with `base44 secrets set` are deliberately not fetched, 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 that needs 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 Deno.env.get(name);
+  },
+};
+
+// Holds a strong reference to in-flight work so a floating promise cannot be
+// collected before it settles.
+const pending = new Set<Promise<unknown>>();
+
+/**
+ * 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
+ * there is nothing to hold open; the promise is tracked only so a rejection is
+ * reported against the function instead of surfacing as an unhandled
+ * rejection. Returns the same promise so it composes, as in production.
+ */
+export function waitUntil<T>(promise: Promise<T>): Promise<T> {
+  const tracked = Promise.resolve(promise)
+    .catch((error: unknown) => {
+      console.error("[base44:runtime] waitUntil task failed:", error);
+    })
+    .finally(() => {
+      pending.delete(tracked);
+    });
+  pending.add(tracked);
+  return promise;
+}

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

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

package/dist/assets/{deno-runtime → backend-runtime}/main.ts

@@ -4,6 +4,13 @@
  * 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
@@ -25,6 +32,10 @@ if (!functionPath) {
 // 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:
@@ -33,6 +44,8 @@ const patchedServe = (
     | (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}`);
@@ -68,13 +81,56 @@ Object.defineProperty(Deno, "serve", {
   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
-// The function will call Deno.serve which is now patched to use our port
+// 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 {
-  await import(functionPath);
+  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);
+}

package/dist/assets/templates/backend-and-client/base44/agents/task_manager.jsonc

@@ -8,7 +8,6 @@
       "allowed_operations": ["read", "create", "update", "delete"]
     }
   ],
-  "selected_skill_names": ["weekly-report"],
   // Optional: let the agent remember facts across conversations.
   // scope: "user" (per end-user), "global" (shared), or "both".
   "memory_config": {