@base44-preview/cli 0.0.30-pr.223.517d2cd → 0.0.30-pr.225.09b17d9

package/dist/cli/index.js

@@ -136896,12 +136896,12 @@ var require_linker = __commonJS((exports) => {
 var require_optionValidator = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.validateOptions = undefined;
-  function validateOptions2({ maxItems }) {
+  function validateOptions3({ maxItems }) {
     if (maxItems !== undefined && maxItems < -1) {
       throw RangeError(`Expected options.maxItems to be >= -1, but was given ${maxItems}.`);
     }
   }
-  exports.validateOptions = validateOptions2;
+  exports.validateOptions = validateOptions3;
 });
 
 // node_modules/json-schema-to-typescript/dist/src/index.js
@@ -152521,6 +152521,24 @@ class FileReadError extends SystemError {
     });
   }
 }
+
+class FunctionNotFoundError extends ApiError {
+  constructor(functionName, cause) {
+    super(`Function "${functionName}" was not found in this app`, {
+      statusCode: 404,
+      cause,
+      hints: [
+        {
+          message: "Make sure the function name is correct and has been deployed",
+          command: "base44 functions deploy"
+        },
+        {
+          message: "List project functions by checking the base44/functions/ directory"
+        }
+      ]
+    });
+  }
+}
 class TypeGenerationError extends SystemError {
   code = "TYPE_GENERATION_ERROR";
   entityName;
@@ -154019,6 +154037,13 @@ var DeployFunctionsResponseSchema = exports_external.object({
   skipped: exports_external.array(exports_external.string()).optional().nullable(),
   errors: exports_external.array(exports_external.object({ name: exports_external.string(), message: exports_external.string() })).nullable()
 });
+var LogLevelSchema = exports_external.enum(["log", "info", "warn", "error", "debug"]);
+var FunctionLogEntrySchema = exports_external.object({
+  time: exports_external.string(),
+  level: LogLevelSchema,
+  message: exports_external.string()
+});
+var FunctionLogsResponseSchema = exports_external.array(FunctionLogEntrySchema);
 
 // src/core/resources/function/api.ts
 function toDeployPayloadItem(fn) {
@@ -154049,6 +154074,55 @@ async function deployFunctions(functions) {
   }
   return result.data;
 }
+function buildLogsQueryString(filters) {
+  const params = new URLSearchParams;
+  if (filters.since) {
+    params.set("since", filters.since);
+  }
+  if (filters.until) {
+    params.set("until", filters.until);
+  }
+  if (filters.level) {
+    params.set("level", filters.level);
+  }
+  if (filters.limit !== undefined) {
+    params.set("limit", String(filters.limit));
+  }
+  if (filters.order) {
+    params.set("order", filters.order);
+  }
+  const queryString = params.toString();
+  return queryString ? `?${queryString}` : "";
+}
+async function fetchFunctionLogs(functionName, filters = {}) {
+  const appClient = getAppClient();
+  const queryString = buildLogsQueryString(filters);
+  let response;
+  try {
+    response = await appClient.get(`functions-mgmt/${functionName}/logs${queryString}`);
+  } catch (error48) {
+    if (error48 instanceof HTTPError) {
+      if (error48.response.status === 404) {
+        throw new FunctionNotFoundError(functionName, error48);
+      }
+      try {
+        const body = await error48.response.clone().json();
+        if (body.error_type === "KeyError") {
+          throw new FunctionNotFoundError(functionName, error48);
+        }
+      } catch (parseError) {
+        if (parseError instanceof ApiError)
+          throw parseError;
+      }
+    }
+    throw await ApiError.fromHttpError(error48, `fetching function logs: '${functionName}'`);
+  }
+  const result = FunctionLogsResponseSchema.safeParse(await response.json());
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid function logs response from server", result.error);
+  }
+  return result.data;
+}
 // src/core/resources/function/config.ts
 import { dirname as dirname3, join as join3 } from "node:path";
 async function readFunctionConfig(configPath) {
@@ -168812,14 +168886,18 @@ async function printUpgradeNotificationIfAvailable() {
 
 // src/cli/utils/runCommand.ts
 async function runCommand(commandFn, options, context) {
-  console.log();
-  if (options?.fullBanner) {
-    await printBanner();
-    Ie("");
-  } else {
-    Ie(theme.colors.base44OrangeBackground(" Base 44 "));
+  const skipIntro = options?.skipIntro === true;
+  const skipOutro = options?.skipOutro === true;
+  if (!skipIntro) {
+    console.log();
+    if (options?.fullBanner) {
+      await printBanner();
+      Ie("");
+    } else {
+      Ie(theme.colors.base44OrangeBackground(" Base 44 "));
+    }
+    await printUpgradeNotificationIfAvailable();
   }
-  await printUpgradeNotificationIfAvailable();
   try {
     if (options?.requireAuth) {
       const loggedIn = await isLoggedIn();
@@ -168839,7 +168917,9 @@ async function runCommand(commandFn, options, context) {
       context.errorReporter.setContext({ appId: appConfig.id });
     }
     const { outroMessage } = await commandFn();
-    Se(outroMessage || "");
+    if (!skipOutro) {
+      Se(outroMessage || "");
+    }
   } catch (error48) {
     const errorMessage = error48 instanceof Error ? error48.message : String(error48);
     M2.error(errorMessage);
@@ -168853,7 +168933,12 @@ async function runCommand(commandFn, options, context) {
       }
     }
     const errorContext = context.errorReporter.getErrorContext();
-    Se(theme.format.errorContext(errorContext));
+    if (!skipOutro) {
+      Se(theme.format.errorContext(errorContext));
+    } else {
+      process.stderr.write(`${theme.format.errorContext(errorContext)}
+`);
+    }
     throw error48;
   }
 }
@@ -169669,6 +169754,152 @@ function getFunctionsDeployCommand(context) {
   }));
 }
 
+// src/cli/commands/logs/index.ts
+var VALID_LEVELS = ["log", "info", "warn", "error", "debug"];
+function parseFunctionFilters(options) {
+  const filters = {};
+  if (options.since) {
+    filters.since = options.since;
+  }
+  if (options.until) {
+    filters.until = options.until;
+  }
+  if (options.level) {
+    filters.level = options.level;
+  }
+  if (options.limit) {
+    filters.limit = Number.parseInt(options.limit, 10);
+  }
+  if (options.order) {
+    filters.order = options.order.toLowerCase();
+  }
+  return filters;
+}
+function parseFunctionNames(option) {
+  if (!option)
+    return [];
+  return option.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+}
+function normalizeDatetime(value) {
+  if (/Z$|[+-]\d{2}:\d{2}$/.test(value))
+    return value;
+  return `${value}Z`;
+}
+function validateOptions2(options) {
+  if (options.level && !VALID_LEVELS.includes(options.level)) {
+    throw new InvalidInputError(`Invalid level: "${options.level}". Must be one of: ${VALID_LEVELS.join(", ")}.`);
+  }
+  if (options.limit) {
+    const limit = Number.parseInt(options.limit, 10);
+    if (Number.isNaN(limit) || limit < 1 || limit > 1000) {
+      throw new InvalidInputError(`Invalid limit: "${options.limit}". Must be a number between 1 and 1000.`);
+    }
+  }
+  if (options.order) {
+    const order = options.order.toUpperCase();
+    if (order !== "ASC" && order !== "DESC") {
+      throw new InvalidInputError(`Invalid order: "${options.order}". Must be "ASC" or "DESC".`);
+    }
+  }
+}
+function formatEntry(entry) {
+  const time3 = entry.time.substring(0, 19).replace("T", " ");
+  const level = entry.level.toUpperCase().padEnd(5);
+  const message = entry.message.trim();
+  return `${time3} ${level} ${message}
+`;
+}
+function displayLogs(entries) {
+  if (entries.length === 0) {
+    process.stdout.write(`No logs found matching the filters.
+`);
+    return;
+  }
+  process.stdout.write(`Showing ${entries.length} function log entries
+
+`);
+  for (const entry of entries) {
+    process.stdout.write(formatEntry(entry));
+  }
+}
+function normalizeLogEntry(entry, functionName) {
+  return {
+    time: entry.time,
+    level: entry.level,
+    message: `[${functionName}] ${entry.message}`,
+    source: functionName
+  };
+}
+async function fetchLogsForFunctions(functionNames, options, availableFunctionNames) {
+  const filters = parseFunctionFilters(options);
+  const allEntries = [];
+  for (const functionName of functionNames) {
+    let logs;
+    try {
+      logs = await fetchFunctionLogs(functionName, filters);
+    } catch (error48) {
+      if (error48 instanceof FunctionNotFoundError && availableFunctionNames.length > 0) {
+        const available = availableFunctionNames.join(", ");
+        throw new InvalidInputError(`Function "${functionName}" was not found in this app`, {
+          hints: [
+            {
+              message: `Available functions in this project: ${available}`
+            },
+            {
+              message: "Make sure the function has been deployed before fetching logs",
+              command: "base44 functions deploy"
+            }
+          ]
+        });
+      }
+      throw error48;
+    }
+    const entries = logs.map((entry) => normalizeLogEntry(entry, functionName));
+    allEntries.push(...entries);
+  }
+  if (functionNames.length > 1) {
+    const order = options.order?.toUpperCase() === "ASC" ? 1 : -1;
+    allEntries.sort((a2, b3) => order * a2.time.localeCompare(b3.time));
+  }
+  return allEntries;
+}
+async function getAllFunctionNames() {
+  const { functions } = await readProjectConfig();
+  return functions.map((fn) => fn.name);
+}
+async function logsAction(options) {
+  if (options.since)
+    options.since = normalizeDatetime(options.since);
+  if (options.until)
+    options.until = normalizeDatetime(options.until);
+  validateOptions2(options);
+  const specifiedFunctions = parseFunctionNames(options.function);
+  const allProjectFunctions = await getAllFunctionNames();
+  const functionNames = specifiedFunctions.length > 0 ? specifiedFunctions : allProjectFunctions;
+  if (functionNames.length === 0) {
+    process.stdout.write(`No functions found in this project.
+`);
+    return {};
+  }
+  let entries = await fetchLogsForFunctions(functionNames, options, allProjectFunctions);
+  const limit = options.limit ? Number.parseInt(options.limit, 10) : undefined;
+  if (limit !== undefined && entries.length > limit) {
+    entries = entries.slice(0, limit);
+  }
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify(entries, null, 2)}
+`);
+  } else {
+    displayLogs(entries);
+  }
+  return {};
+}
+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)").option("--until <datetime>", "Show logs until this time (ISO format)").option("--level <level>", "Filter by log level: log, info, warn, error, debug").option("-n, --limit <n>", "Results per page (1-1000, default: 50)").option("--order <order>", "Sort order: ASC|DESC (default: DESC)").option("--json", "Output raw JSON").action(async (options) => {
+    await runCommand(() => logsAction(options), { requireAuth: true, skipIntro: true, skipOutro: true }, context);
+  });
+}
+
 // src/cli/commands/project/create.ts
 import { basename as basename3, join as join9, resolve as resolve2 } from "node:path";
 var import_lodash = __toESM(require_lodash(), 1);
@@ -170251,6 +170482,7 @@ function createProgram(context) {
   program2.addCommand(getFunctionsDeployCommand(context));
   program2.addCommand(getSiteCommand(context));
   program2.addCommand(getTypesCommand(context), { hidden: true });
+  program2.addCommand(getLogsCommand(context));
   return program2;
 }
 
@@ -174517,4 +174749,4 @@ export {
   CLIExitError
 };
 
-//# debugId=CAC914B71B29789364756E2164756E21
+//# debugId=8FC5567422BA15ED64756E2164756E21