@base44-preview/cli 0.0.33-pr.286.941c114 → 0.0.34-pr.228.2ae7cac

package/dist/cli/index.js

@@ -178557,9 +178557,10 @@ class ApiError extends SystemError {
       } catch {
         message = error48.message;
       }
+      const statusCode = ApiError.normalizeStatusCode(error48.response.status, responseBody);
       const requestBody = error48.options.context?.__requestBody;
       return new ApiError(`Error ${context}: ${message}`, {
-        statusCode: error48.response.status,
+        statusCode,
         requestUrl: error48.request.url,
         requestMethod: error48.request.method,
         requestBody,
@@ -178616,6 +178617,12 @@ class ApiError extends SystemError {
       return;
     return REASON_HINTS[reason];
   }
+  static normalizeStatusCode(statusCode, responseBody) {
+    if (responseBody?.error_type === "KeyError") {
+      return 404;
+    }
+    return statusCode;
+  }
 }
 
 class FileNotFoundError extends SystemError {
@@ -185382,18 +185389,16 @@ async function fetchAgents() {
 }
 // src/core/resources/agent/config.ts
 import { join as join3 } from "node:path";
-function toFileSlug(name2) {
-  return name2.toLowerCase().replace(/[^a-z0-9_]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");
-}
+import { isDeepStrictEqual } from "node:util";
 async function readAgentFile(agentPath) {
-  const parsed = await readJsonFile(agentPath);
-  const result = AgentConfigSchema.safeParse(parsed);
+  const raw2 = await readJsonFile(agentPath);
+  const result = AgentConfigSchema.safeParse(raw2);
   if (!result.success) {
     throw new SchemaValidationError("Invalid agent file", result.error, agentPath);
   }
-  return result.data;
+  return { data: result.data, raw: raw2 };
 }
-async function readAllAgents(agentsDir) {
+async function readAgentFiles(agentsDir) {
   if (!await pathExists(agentsDir)) {
     return [];
   }
@@ -185401,37 +185406,49 @@ async function readAllAgents(agentsDir) {
     cwd: agentsDir,
     absolute: true
   });
-  const agents = await Promise.all(files.map((filePath) => readAgentFile(filePath)));
+  return await Promise.all(files.map(async (filePath) => {
+    const { data, raw: raw2 } = await readAgentFile(filePath);
+    return { data, raw: raw2, filePath };
+  }));
+}
+async function readAllAgents(agentsDir) {
+  const entries = await readAgentFiles(agentsDir);
   const names = new Set;
-  for (const agent of agents) {
-    if (names.has(agent.name)) {
-      throw new Error(`Duplicate agent name "${agent.name}"`);
+  for (const { data } of entries) {
+    if (names.has(data.name)) {
+      throw new Error(`Duplicate agent name "${data.name}"`);
     }
-    names.add(agent.name);
+    names.add(data.name);
   }
-  return agents;
+  return entries.map((e2) => e2.data);
 }
 async function writeAgents(agentsDir, remoteAgents) {
-  const existingAgents = await readAllAgents(agentsDir);
+  const entries = await readAgentFiles(agentsDir);
+  const nameToEntry = new Map;
+  for (const entry of entries) {
+    if (nameToEntry.has(entry.data.name)) {
+      throw new Error(`Duplicate agent name "${entry.data.name}"`);
+    }
+    nameToEntry.set(entry.data.name, entry);
+  }
   const newNames = new Set(remoteAgents.map((a) => a.name));
-  const toDelete = existingAgents.filter((a) => !newNames.has(a.name));
-  for (const agent of toDelete) {
-    const slug = toFileSlug(agent.name);
-    const files = await globby(`${slug}.${CONFIG_FILE_EXTENSION_GLOB}`, {
-      cwd: agentsDir,
-      absolute: true
-    });
-    for (const filePath of files) {
-      await deleteFile(filePath);
+  const deleted = [];
+  for (const [name2, entry] of nameToEntry) {
+    if (!newNames.has(name2)) {
+      await deleteFile(entry.filePath);
+      deleted.push(name2);
     }
   }
+  const written = [];
   for (const agent of remoteAgents) {
-    const slug = toFileSlug(agent.name);
-    const filePath = join3(agentsDir, `${slug}.${CONFIG_FILE_EXTENSION}`);
+    const existing = nameToEntry.get(agent.name);
+    if (existing && isDeepStrictEqual(existing.raw, agent)) {
+      continue;
+    }
+    const filePath = existing?.filePath ?? join3(agentsDir, `${agent.name}.${CONFIG_FILE_EXTENSION}`);
     await writeJsonFile(filePath, agent);
+    written.push(agent.name);
   }
-  const written = remoteAgents.map((a) => a.name);
-  const deleted = toDelete.map((a) => a.name);
   return { written, deleted };
 }
 // src/core/resources/agent/resource.ts
@@ -185648,7 +185665,7 @@ async function removeConnector(integrationType) {
 }
 // src/core/resources/connector/config.ts
 import { join as join4 } from "node:path";
-import { isDeepStrictEqual } from "node:util";
+import { isDeepStrictEqual as isDeepStrictEqual2 } from "node:util";
 async function readConnectorFile(connectorPath) {
   const parsed = await readJsonFile(connectorPath);
   const result = ConnectorResourceSchema.safeParse(parsed);
@@ -185709,7 +185726,7 @@ async function writeConnectors(connectorsDir, remoteConnectors) {
       type: connector.integrationType,
       scopes: connector.scopes
     };
-    if (existing && isDeepStrictEqual(existing.data, localConnector)) {
+    if (existing && isDeepStrictEqual2(existing.data, localConnector)) {
       continue;
     }
     const filePath = existing?.filePath ?? join4(connectorsDir, `${connector.integrationType}.${CONFIG_FILE_EXTENSION}`);
@@ -186012,6 +186029,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) {
@@ -186042,6 +186066,42 @@ 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);
+  }
+  return params;
+}
+async function fetchFunctionLogs(functionName, filters = {}) {
+  const appClient = getAppClient();
+  const searchParams = buildLogsQueryString(filters);
+  let response;
+  try {
+    response = await appClient.get(`functions-mgmt/${functionName}/logs`, {
+      searchParams
+    });
+  } catch (error48) {
+    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 dirname4, join as join5 } from "node:path";
 async function readFunctionConfig(configPath) {
@@ -193875,7 +193935,7 @@ var {
 // package.json
 var package_default = {
   name: "base44",
-  version: "0.0.33",
+  version: "0.0.34",
   description: "Base44 CLI - Unified interface for managing Base44 applications",
   type: "module",
   bin: {
@@ -194003,7 +194063,6 @@ async function printUpgradeNotificationIfAvailable() {
 
 // src/cli/utils/runCommand.ts
 async function runCommand(commandFn, options, context) {
-  console.log();
   if (options?.fullBanner) {
     await printBanner(context.isNonInteractive);
     We("");
@@ -194029,8 +194088,11 @@ async function runCommand(commandFn, options, context) {
       const appConfig = await initAppConfig();
       context.errorReporter.setContext({ appId: appConfig.id });
     }
-    const { outroMessage } = await commandFn();
-    Le(outroMessage || "");
+    const result = await commandFn();
+    Le(result.outroMessage || "");
+    if (result.stdout) {
+      process.stdout.write(result.stdout);
+    }
   } catch (error48) {
     const errorMessage = error48 instanceof Error ? error48.message : String(error48);
     R2.error(errorMessage);
@@ -194078,14 +194140,11 @@ async function pullAgentsAction() {
     successMessage: "Agents fetched successfully",
     errorMessage: "Failed to fetch agents"
   });
-  if (remoteAgents.items.length === 0) {
-    return { outroMessage: "No agents found on Base44" };
-  }
-  const { written, deleted } = await runTask("Writing agent files", async () => {
+  const { written, deleted } = await runTask("Syncing agent files", async () => {
     return await writeAgents(agentsDir, remoteAgents.items);
   }, {
-    successMessage: "Agent files written successfully",
-    errorMessage: "Failed to write agent files"
+    successMessage: "Agent files synced successfully",
+    errorMessage: "Failed to sync agent files"
   });
   if (written.length > 0) {
     R2.success(`Written: ${written.join(", ")}`);
@@ -194093,6 +194152,9 @@ async function pullAgentsAction() {
   if (deleted.length > 0) {
     R2.warn(`Deleted: ${deleted.join(", ")}`);
   }
+  if (written.length === 0 && deleted.length === 0) {
+    R2.info("All agents are already up to date");
+  }
   return {
     outroMessage: `Pulled ${remoteAgents.total} agents to ${agentsDir}`
   };
@@ -195451,6 +195513,122 @@ function getLinkCommand(context) {
   });
 }
 
+// src/cli/commands/project/logs.ts
+function parseFunctionFilters(options) {
+  const filters = {};
+  if (options.since) {
+    filters.since = options.since;
+  }
+  if (options.until) {
+    filters.until = options.until;
+  }
+  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 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 formatLogs(entries) {
+  if (entries.length === 0) {
+    return `No logs found matching the filters.
+`;
+  }
+  const header2 = `Showing ${entries.length} function log entries
+`;
+  return [header2, ...entries.map(formatEntry)].join(`
+`);
+}
+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 ApiError && error48.statusCode === 404 && 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, b) => order * a2.time.localeCompare(b.time));
+  }
+  return allEntries;
+}
+async function getAllFunctionNames() {
+  const { functions } = await readProjectConfig();
+  return functions.map((fn) => fn.name);
+}
+async function logsAction(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." };
+  }
+  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);
+  }
+  const logsOutput = options.json ? `${JSON.stringify(entries, null, 2)}
+` : formatLogs(entries);
+  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).option("-n, --limit <n>", "Results per page (1-1000, default: 50)", (v) => {
+    const n2 = Number.parseInt(v, 10);
+    if (Number.isNaN(n2) || n2 < 1 || n2 > 1000) {
+      throw new InvalidInputError(`Invalid limit: "${v}". Must be a number between 1 and 1000.`);
+    }
+    return v;
+  }).addOption(new Option("--order <order>", "Sort order").choices(["asc", "desc"])).option("--json", "Output raw JSON").action(async (options) => {
+    await runCommand(() => logsAction(options), { requireAuth: true }, context);
+  });
+}
+
 // src/cli/commands/site/deploy.ts
 import { resolve as resolve3 } from "node:path";
 async function deployAction2(options) {
@@ -196172,6 +196350,7 @@ function createProgram(context) {
   program2.addCommand(getSiteCommand(context));
   program2.addCommand(getTypesCommand(context));
   program2.addCommand(getDevCommand(context), { hidden: true });
+  program2.addCommand(getLogsCommand(context), { hidden: true });
   return program2;
 }
 
@@ -200436,4 +200615,4 @@ export {
   CLIExitError
 };
 
-//# debugId=DF6807EB90E6667564756E2164756E21
+//# debugId=199B0E01CD0F366764756E2164756E21