@base44-preview/cli 0.0.45-pr.422.d49cf05 → 0.0.45-pr.424.8513daf

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

@@ -0,0 +1,72 @@
+/**
+ * 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.
+ *
+ * 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 {};
+
+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);
+
+// Patch Deno.serve to inject our port and add onListen callback
+// @ts-expect-error - We're intentionally overriding Deno.serve
+Deno.serve = (
+  optionsOrHandler:
+    | Deno.ServeOptions
+    | Deno.ServeHandler
+    | (Deno.ServeOptions & { handler: Deno.ServeHandler }),
+  maybeHandler?: Deno.ServeHandler,
+): Deno.HttpServer<Deno.NetAddr> => {
+  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 });
+};
+
+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
+try {
+  await import(functionPath);
+} catch (error) {
+  console.error(`[${functionName}] Failed to load function:`, error);
+  Deno.exit(1);
+}

package/dist/cli/index.js

@@ -141617,12 +141617,12 @@ var require_linker = __commonJS((exports) => {
 var require_optionValidator = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.validateOptions = undefined;
-  function validateOptions3({ maxItems }) {
+  function validateOptions2({ maxItems }) {
     if (maxItems !== undefined && maxItems < -1) {
       throw RangeError(`Expected options.maxItems to be >= -1, but was given ${maxItems}.`);
     }
   }
-  exports.validateOptions = validateOptions3;
+  exports.validateOptions = validateOptions2;
 });
 
 // ../../node_modules/json-schema-to-typescript/dist/src/index.js
@@ -238351,6 +238351,61 @@ async function fetchFunctionLogs(functionName, filters = {}) {
   }
   return result.data;
 }
+function buildStreamQueryString(filters) {
+  const params = new URLSearchParams;
+  if (filters.level) {
+    params.set("level", filters.level);
+  }
+  return params;
+}
+async function* streamFunctionLogs(functionName, filters = {}, signal) {
+  const appClient = getAppClient();
+  const searchParams = buildStreamQueryString(filters);
+  let response;
+  try {
+    response = await appClient.get(`functions-mgmt/${encodeURIComponent(functionName)}/logs/stream`, {
+      searchParams,
+      timeout: false,
+      signal
+    });
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, `streaming function logs: '${functionName}'`);
+  }
+  if (!response.body) {
+    throw new ApiError("Server returned empty response for log stream");
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder;
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      buffer += decoder.decode(value, { stream: true });
+      for (let newlineIndex = buffer.indexOf(`
+`);newlineIndex !== -1; newlineIndex = buffer.indexOf(`
+`)) {
+        const line = buffer.slice(0, newlineIndex).trimEnd();
+        buffer = buffer.slice(newlineIndex + 1);
+        if (line === "" || line.startsWith(":")) {
+          continue;
+        }
+        if (line.startsWith("data: ")) {
+          const jsonStr = line.slice(6);
+          try {
+            const parsed = FunctionLogEntrySchema.safeParse(JSON.parse(jsonStr));
+            if (parsed.success) {
+              yield parsed.data;
+            }
+          } catch {}
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
 // src/core/resources/function/config.ts
 import { basename as basename2, dirname as dirname3, join as join5, relative } from "node:path";
 async function readFunctionConfig(configPath) {
@@ -238807,7 +238862,7 @@ function getTemplatesIndexPath() {
   return join8(ASSETS_DIR, "templates", "templates.json");
 }
 function getDenoWrapperPath() {
-  return join8(ASSETS_DIR, "deno-runtime", "main.js");
+  return join8(ASSETS_DIR, "deno-runtime", "main.ts");
 }
 function ensureNpmAssets(sourceDir) {
   if (existsSync(ASSETS_DIR))
@@ -246812,152 +246867,6 @@ function getAgentsCommand(context) {
   return new Command("agents").description("Manage project agents").addCommand(getAgentsPushCommand(context)).addCommand(getAgentsPullCommand(context));
 }
 
-// src/core/auth-config/schema.ts
-var GoogleOAuthMode = exports_external.enum(["default", "custom"]);
-var AuthConfigSchema = exports_external.object({
-  enable_username_password: exports_external.boolean(),
-  enable_google_login: exports_external.boolean(),
-  enable_microsoft_login: exports_external.boolean(),
-  enable_facebook_login: exports_external.boolean(),
-  enable_apple_login: exports_external.boolean(),
-  sso_provider_name: exports_external.string().nullable(),
-  enable_sso_login: exports_external.boolean(),
-  google_oauth_mode: GoogleOAuthMode,
-  google_oauth_client_id: exports_external.string().nullable(),
-  use_workspace_sso: exports_external.boolean()
-}).transform((data) => ({
-  enableUsernamePassword: data.enable_username_password,
-  enableGoogleLogin: data.enable_google_login,
-  enableMicrosoftLogin: data.enable_microsoft_login,
-  enableFacebookLogin: data.enable_facebook_login,
-  enableAppleLogin: data.enable_apple_login,
-  ssoProviderName: data.sso_provider_name,
-  enableSSOLogin: data.enable_sso_login,
-  googleOAuthMode: data.google_oauth_mode,
-  googleOAuthClientId: data.google_oauth_client_id,
-  useWorkspaceSSO: data.use_workspace_sso
-}));
-var AppAuthConfigResponseSchema = exports_external.object({
-  auth_config: AuthConfigSchema
-}).transform((data) => ({
-  authConfig: data.auth_config
-}));
-function toAuthConfigPayload(config10) {
-  return {
-    enable_username_password: config10.enableUsernamePassword,
-    enable_google_login: config10.enableGoogleLogin,
-    enable_microsoft_login: config10.enableMicrosoftLogin,
-    enable_facebook_login: config10.enableFacebookLogin,
-    enable_apple_login: config10.enableAppleLogin,
-    sso_provider_name: config10.ssoProviderName,
-    enable_sso_login: config10.enableSSOLogin,
-    google_oauth_mode: config10.googleOAuthMode,
-    google_oauth_client_id: config10.googleOAuthClientId,
-    use_workspace_sso: config10.useWorkspaceSSO
-  };
-}
-
-// src/core/auth-config/api.ts
-async function getAuthConfig() {
-  const { id } = getAppConfig();
-  let response;
-  try {
-    response = await base44Client.get(`api/apps/${id}`);
-  } catch (error48) {
-    throw await ApiError.fromHttpError(error48, "fetching auth config");
-  }
-  const result = AppAuthConfigResponseSchema.safeParse(await response.json());
-  if (!result.success) {
-    throw new SchemaValidationError("Invalid response from server", result.error);
-  }
-  return result.data.authConfig;
-}
-async function updateAuthConfig(updates) {
-  const current = await getAuthConfig();
-  const merged = { ...current, ...updates };
-  const { id } = getAppConfig();
-  let response;
-  try {
-    response = await base44Client.put(`api/apps/${id}`, {
-      json: { auth_config: toAuthConfigPayload(merged) }
-    });
-  } catch (error48) {
-    throw await ApiError.fromHttpError(error48, "updating auth config");
-  }
-  const result = AppAuthConfigResponseSchema.safeParse(await response.json());
-  if (!result.success) {
-    throw new SchemaValidationError("Invalid response from server", result.error);
-  }
-  return result.data.authConfig;
-}
-function hasAnyLoginMethod(config10) {
-  return config10.enableUsernamePassword || config10.enableGoogleLogin || config10.enableMicrosoftLogin || config10.enableFacebookLogin || config10.enableAppleLogin || config10.enableSSOLogin;
-}
-async function updatePasswordAuth(enable) {
-  return await updateAuthConfig({ enableUsernamePassword: enable });
-}
-// src/cli/commands/auth/password-login.ts
-function validateOptions2(options) {
-  const errors5 = [];
-  if (!options.enable && !options.disable) {
-    errors5.push("Missing required flag: specify --enable or --disable");
-  }
-  if (options.enable && options.disable) {
-    errors5.push("Conflicting flags: --enable and --disable cannot be used together");
-  }
-  if (errors5.length > 0) {
-    throw new InvalidInputError(errors5.join(`
-`), {
-      hints: [
-        {
-          message: "Enable password auth:  base44 auth password-login --enable",
-          command: "base44 auth password-login --enable"
-        },
-        {
-          message: "Disable password auth: base44 auth password-login --disable",
-          command: "base44 auth password-login --disable"
-        }
-      ]
-    });
-  }
-}
-async function passwordLoginAction(options) {
-  validateOptions2(options);
-  const shouldEnable = !!options.enable;
-  const current = await runTask("Fetching current auth config", async () => await getAuthConfig());
-  if (shouldEnable === current.enableUsernamePassword) {
-    const status = shouldEnable ? "enabled" : "disabled";
-    return {
-      outroMessage: `Username & password authentication is already ${status}`
-    };
-  }
-  if (!shouldEnable) {
-    const configWithoutPassword = {
-      ...current,
-      enableUsernamePassword: false
-    };
-    if (!hasAnyLoginMethod(configWithoutPassword)) {
-      R2.warn("Disabling password auth will leave no login methods enabled. Users will be locked out.");
-    }
-  }
-  const action = shouldEnable ? "Enabling" : "Disabling";
-  await runTask(`${action} username & password authentication`, async () => await updatePasswordAuth(shouldEnable));
-  const newStatus = shouldEnable ? "enabled" : "disabled";
-  return {
-    outroMessage: `Username & password authentication ${newStatus}`
-  };
-}
-function getPasswordLoginCommand(context) {
-  return new Command("password-login").description("Enable or disable username & password authentication").option("--enable", "Enable password authentication").option("--disable", "Disable password authentication").action(async (options) => {
-    await runCommand(() => passwordLoginAction(options), { requireAuth: true }, context);
-  });
-}
-
-// src/cli/commands/auth/index.ts
-function getAuthCommand(context) {
-  return new Command("auth").description("Manage app authentication settings").addCommand(getPasswordLoginCommand(context));
-}
-
 // src/cli/commands/auth/login.ts
 function getLoginCommand(context) {
   return new Command("login").description("Authenticate with Base44").action(async () => {
@@ -248645,6 +248554,91 @@ function validateLimit(limit) {
     throw new InvalidInputError(`Invalid limit: "${limit}". Must be a number between 1 and 1000.`);
   }
 }
+function validateTailFlags(options) {
+  if (!options.tail)
+    return;
+  const incompatible = [
+    ["--since", options.since],
+    ["--until", options.until],
+    ["--limit", options.limit],
+    ["--order", options.order]
+  ];
+  for (const [flag, value] of incompatible) {
+    if (value !== undefined) {
+      throw new InvalidInputError(`Cannot use ${flag} with --tail`);
+    }
+  }
+}
+function formatStreamEntry(entry, functionName, json2) {
+  if (json2) {
+    return JSON.stringify({
+      source: functionName,
+      time: entry.time,
+      level: entry.level,
+      message: entry.message
+    });
+  }
+  const normalized = normalizeLogEntry(entry, functionName);
+  return formatEntry(normalized);
+}
+async function consumeStream(functionName, filters, signal, json2) {
+  try {
+    for await (const entry of streamFunctionLogs(functionName, filters, signal)) {
+      process.stdout.write(`${formatStreamEntry(entry, functionName, json2)}
+`);
+    }
+    return "ended";
+  } catch (error48) {
+    if (signal.aborted)
+      return "aborted";
+    throw error48;
+  }
+}
+async function tailAction(options) {
+  validateTailFlags(options);
+  const specifiedFunctions = parseFunctionNames(options.function);
+  const allProjectFunctions = await getAllFunctionNames();
+  const functionNames = specifiedFunctions.length > 0 ? specifiedFunctions : allProjectFunctions;
+  if (functionNames.length === 0) {
+    return { outroMessage: "No functions found in this project." };
+  }
+  const filters = {};
+  if (options.level) {
+    filters.level = options.level;
+  }
+  const json2 = options.json ?? false;
+  const functionList = functionNames.join(", ");
+  R2.info(`Tailing logs for ${functionList}... (Ctrl+C to stop)`);
+  const controller = new AbortController;
+  const onSigint = () => controller.abort();
+  process.on("SIGINT", onSigint);
+  let userAborted = false;
+  try {
+    if (functionNames.length === 1) {
+      const result = await consumeStream(functionNames[0], filters, controller.signal, json2);
+      userAborted = result === "aborted";
+    } else {
+      const results = await Promise.allSettled(functionNames.map((fn) => consumeStream(fn, filters, controller.signal, json2)));
+      const allFailed = results.every((r) => r.status === "rejected");
+      if (allFailed && !controller.signal.aborted) {
+        const firstError = results.find((r) => r.status === "rejected");
+        throw firstError.reason;
+      }
+      for (let i2 = 0;i2 < results.length; i2++) {
+        const result = results[i2];
+        if (result.status === "rejected" && !controller.signal.aborted) {
+          R2.warn(`Connection lost for function '${functionNames[i2]}'`);
+        }
+      }
+      userAborted = controller.signal.aborted;
+    }
+  } finally {
+    process.removeListener("SIGINT", onSigint);
+  }
+  return {
+    outroMessage: userAborted ? "Stream closed" : "Stream ended"
+  };
+}
 async function logsAction(options) {
   validateLimit(options.limit);
   const specifiedFunctions = parseFunctionNames(options.function);
@@ -248663,8 +248657,9 @@ async function logsAction(options) {
   return { outroMessage: "Fetched logs", stdout: logsOutput };
 }
 function getLogsCommand(context) {
-  return new Command("logs").description("Fetch function logs for this app").option("--function <names>", "Filter by function name(s), comma-separated. If omitted, fetches logs for all project functions").option("--since <datetime>", "Show logs from this time (ISO format)", normalizeDatetime).option("--until <datetime>", "Show logs until this time (ISO format)", normalizeDatetime).addOption(new Option("--level <level>", "Filter by log level").choices([...LogLevelSchema.options]).hideHelp()).option("-n, --limit <n>", "Results per page (1-1000, default: 50)").addOption(new Option("--order <order>", "Sort order").choices(["asc", "desc"])).action(async (options) => {
-    await runCommand(() => logsAction(options), { requireAuth: true }, context);
+  return new Command("logs").description("Fetch function logs for this app (use --tail to stream in real-time)").option("--function <names>", "Filter by function name(s), comma-separated. If omitted, fetches logs for all project functions").option("--since <datetime>", "Show logs from this time (ISO format)", normalizeDatetime).option("--until <datetime>", "Show logs until this time (ISO format)", normalizeDatetime).addOption(new Option("--level <level>", "Filter by log level").choices([...LogLevelSchema.options]).hideHelp()).option("-n, --limit <n>", "Results per page (1-1000, default: 50)").addOption(new Option("--order <order>", "Sort order").choices(["asc", "desc"])).option("--json", "Output raw JSON").option("-f, --tail", "Stream logs in real-time").action(async (options) => {
+    const action = options.tail ? () => tailAction(options) : () => logsAction(options);
+    await runCommand(action, { requireAuth: true }, context);
   });
 }
 
@@ -251861,7 +251856,6 @@ function createProgram(context) {
   program2.addCommand(getConnectorsCommand(context));
   program2.addCommand(getFunctionsCommand(context));
   program2.addCommand(getSecretsCommand(context));
-  program2.addCommand(getAuthCommand(context));
   program2.addCommand(getSiteCommand(context));
   program2.addCommand(getTypesCommand(context));
   program2.addCommand(getDevCommand(context), { hidden: true });
@@ -256107,4 +256101,4 @@ export {
   CLIExitError
 };
 
-//# debugId=FD70C1725704242064756E2164756E21
+//# debugId=FFECB82AD6C33D2764756E2164756E21