@base44-preview/cli 0.1.12-pr.609.cbdaa40 → 0.1.13-pr.612.0c05567

package/dist/cli/index.js

@@ -221222,7 +221222,7 @@ var require_dist5 = __commonJS(function(exports, module) {
     determineAgent: () => determineAgent
   });
   module.exports = __toCommonJS2(src_exports);
-  var import_promises25 = __require("node:fs/promises");
+  var import_promises26 = __require("node:fs/promises");
   var import_node_fs25 = __require("node:fs");
   var DEVIN_LOCAL_PATH = "/opt/.devin";
   var CURSOR2 = "cursor";
@@ -221280,7 +221280,7 @@ var require_dist5 = __commonJS(function(exports, module) {
       return { isAgent: true, agent: { name: REPLIT } };
     }
     try {
-      await (0, import_promises25.access)(DEVIN_LOCAL_PATH, import_node_fs25.constants.F_OK);
+      await (0, import_promises26.access)(DEVIN_LOCAL_PATH, import_node_fs25.constants.F_OK);
       return { isAgent: true, agent: { name: DEVIN } };
     } catch (error48) {}
     return { isAgent: false, agent: undefined };
@@ -247752,6 +247752,138 @@ var functionResource = {
   readAll: readAllFunctions,
   push: (functions) => deployFunctionsSequentially(functions)
 };
+// src/core/resources/function/stream-api.ts
+var StreamLogEventSchema = exports_external.object({
+  time: exports_external.string(),
+  level: exports_external.preprocess((value) => value === "warn" ? "warning" : value, LogLevelSchema),
+  function: exports_external.string().nullable(),
+  message: exports_external.string()
+});
+var StreamEndEventSchema = exports_external.object({
+  reason: exports_external.string(),
+  retriable: exports_external.boolean()
+});
+function buildStreamUrl(filters) {
+  const { id } = getAppContext();
+  const url2 = new URL(`/api/apps/${id}/functions-mgmt/logs/stream`, getBase44ApiUrl());
+  if (filters.functions?.length) {
+    url2.searchParams.set("function", filters.functions.join(","));
+  }
+  if (filters.env) {
+    url2.searchParams.set("env", filters.env);
+  }
+  return url2.href;
+}
+async function buildStreamAuthHeaders() {
+  const workspaceApiKey = getWorkspaceApiKeyFromEnv();
+  if (workspaceApiKey && isWorkspaceApiKey(workspaceApiKey)) {
+    return { api_key: workspaceApiKey };
+  }
+  const auth = await readAuth();
+  if (isTokenExpired(auth)) {
+    const refreshedToken = await refreshAndSaveTokens();
+    if (refreshedToken) {
+      return { Authorization: `Bearer ${refreshedToken}` };
+    }
+  }
+  return { Authorization: `Bearer ${auth.accessToken}` };
+}
+function parseStreamEvent(eventName, data) {
+  try {
+    const payload = JSON.parse(data);
+    if (eventName === "end") {
+      const result = StreamEndEventSchema.safeParse(payload);
+      return result.success ? { kind: "end", end: result.data } : null;
+    }
+    if (eventName === "") {
+      const result = StreamLogEventSchema.safeParse(payload);
+      return result.success ? { kind: "log", log: result.data } : null;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+var STREAM_SILENCE_TIMEOUT_MS = 60000;
+async function readOrSilence(reader) {
+  let timer;
+  const silence = new Promise((resolve3) => {
+    timer = setTimeout(() => resolve3("silence"), STREAM_SILENCE_TIMEOUT_MS);
+  });
+  try {
+    return await Promise.race([reader.read(), silence]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function* readLines(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder;
+  let buffered = "";
+  try {
+    while (true) {
+      const result = await readOrSilence(reader);
+      if (result === "silence")
+        return;
+      if (result.done || !result.value)
+        return;
+      buffered += decoder.decode(result.value, { stream: true });
+      const lines = buffered.split(`
+`);
+      buffered = lines.pop() ?? "";
+      yield* lines;
+    }
+  } finally {
+    await reader.cancel().catch(() => {});
+  }
+}
+async function* readStreamEvents(body) {
+  let eventName = "";
+  for await (const line of readLines(body)) {
+    if (line.startsWith(":")) {
+      yield { kind: "ping" };
+      continue;
+    }
+    if (line.startsWith("event:")) {
+      eventName = line.slice(6).trim();
+      continue;
+    }
+    if (line.startsWith("data:")) {
+      const event = parseStreamEvent(eventName, line.slice(5));
+      eventName = "";
+      if (event)
+        yield event;
+      continue;
+    }
+    if (line.trim() === "")
+      eventName = "";
+  }
+}
+var STREAM_CONNECT_TIMEOUT_MS = 1e4;
+var isWorthReconnecting = (status) => status >= 500;
+async function openLogStream(filters) {
+  const url2 = buildStreamUrl(filters);
+  const headers = {
+    Accept: "text/event-stream",
+    ...await buildStreamAuthHeaders()
+  };
+  const connectPhase = new AbortController;
+  const connectTimer = setTimeout(() => connectPhase.abort(), STREAM_CONNECT_TIMEOUT_MS);
+  let response;
+  try {
+    response = await fetch(url2, { headers, signal: connectPhase.signal });
+  } catch {
+    return { kind: "transient" };
+  } finally {
+    clearTimeout(connectTimer);
+  }
+  if (!response.ok) {
+    return isWorthReconnecting(response.status) ? { kind: "transient" } : { kind: "refused" };
+  }
+  if (!response.body)
+    return { kind: "transient" };
+  return { kind: "stream", events: readStreamEvents(response.body) };
+}
 // src/core/project/config.ts
 class ProjectConfigReader {
   pluginSourceByNamespace = new Map;
@@ -247927,7 +248059,7 @@ import { join as join12 } from "node:path";
 // package.json
 var package_default = {
   name: "base44",
-  version: "0.1.12",
+  version: "0.1.13",
   description: "Base44 CLI - Unified interface for managing Base44 applications",
   type: "module",
   bin: {
@@ -258278,6 +258410,7 @@ function getLinkCommand() {
 }
 
 // src/cli/commands/project/logs.ts
+import { setTimeout as delay2 } from "node:timers/promises";
 function parseFunctionFilters(options) {
   const filters = {};
   if (options.since) {
@@ -258338,9 +258471,108 @@ function writeFollowLine(entry, jsonMode) {
   process.stdout.write(`${line}
 `);
 }
-async function followLogs(functionNames, options, availableFunctionNames, jsonMode) {
-  let state = { lastTime: "", boundaryKeys: new Set };
-  let first = true;
+function streamEventToLogEntry(event) {
+  return {
+    time: event.time,
+    level: event.level,
+    message: event.function ? `[${event.function}] ${event.message}` : event.message,
+    source: event.function ?? ""
+  };
+}
+async function printStreamUntilEnd(stream, levelFilter, jsonMode, startTime) {
+  let lastTime = startTime;
+  let provedAlive = false;
+  try {
+    for await (const event of stream) {
+      provedAlive = true;
+      if (event.kind === "end")
+        return { lastTime, provedAlive, end: event.end };
+      if (event.kind === "ping")
+        continue;
+      if (levelFilter && event.log.level !== levelFilter)
+        continue;
+      writeFollowLine(streamEventToLogEntry(event.log), jsonMode);
+      if (event.log.time > lastTime)
+        lastTime = event.log.time;
+    }
+  } catch {}
+  return { lastTime, provedAlive, end: null };
+}
+var STREAM_RECONNECT_DELAY_MS = 1000;
+var MAX_DROPS_SINCE_LAST_EVENT = 2;
+var CONNECT_RETRY_DELAYS_MS = [1000, 2000, 4000, 8000];
+var countDropTowardGivingUp = (dropsSinceLastEvent, provedAlive) => provedAlive ? 1 : dropsSinceLastEvent + 1;
+var shouldGiveUpStreaming = (dropsSinceLastEvent) => dropsSinceLastEvent >= MAX_DROPS_SINCE_LAST_EVENT;
+async function connectWhileTransientlyUnavailable(filters) {
+  let attempt = await openLogStream(filters);
+  for (const retryDelay of CONNECT_RETRY_DELAYS_MS) {
+    if (attempt.kind !== "transient")
+      return attempt;
+    await delay2(retryDelay);
+    attempt = await openLogStream(filters);
+  }
+  return attempt;
+}
+async function streamUntilExhausted(firstStream, filters, options, jsonMode) {
+  let events = firstStream;
+  let lastTime = "";
+  let dropsSinceLastEvent = 0;
+  while (true) {
+    const ending = await printStreamUntilEnd(events, options.level, jsonMode, lastTime);
+    lastTime = ending.lastTime;
+    if (ending.end) {
+      if (!ending.end.retriable)
+        return;
+      dropsSinceLastEvent = 0;
+    } else {
+      dropsSinceLastEvent = countDropTowardGivingUp(dropsSinceLastEvent, ending.provedAlive);
+      if (shouldGiveUpStreaming(dropsSinceLastEvent))
+        return;
+    }
+    await delay2(STREAM_RECONNECT_DELAY_MS);
+    const reopened = await connectWhileTransientlyUnavailable(filters);
+    if (reopened.kind !== "stream")
+      return;
+    events = reopened.events;
+  }
+}
+function streamLostError() {
+  return new ApiError("The realtime log stream stopped and could not be re-established", {
+    hints: [
+      { message: "Start a new live tail", command: "base44 logs --follow" },
+      {
+        message: "Or read recent logs without streaming",
+        command: "base44 logs"
+      }
+    ]
+  });
+}
+async function followLogs(functionNames, options, availableFunctionNames, jsonMode, logger2) {
+  const filters = {
+    functions: parseFunctionNames(options.function),
+    env: options.env
+  };
+  if (options.since) {
+    logger2.warn("--since reads the past, so this run polls instead of streaming (lines may lag ~20-30s).");
+    return pollLogs(functionNames, options, availableFunctionNames, jsonMode, {
+      lastTime: "",
+      boundaryKeys: new Set
+    });
+  }
+  const opened = await connectWhileTransientlyUnavailable(filters);
+  if (opened.kind !== "stream") {
+    logger2.warn(opened.kind === "refused" ? "Realtime logs are not available for this app — falling back to polling (lines may lag ~20-30s)." : "Could not reach the realtime log stream — falling back to polling (lines may lag ~20-30s).");
+    return pollLogs(functionNames, options, availableFunctionNames, jsonMode, {
+      lastTime: "",
+      boundaryKeys: new Set
+    });
+  }
+  await streamUntilExhausted(opened.events, filters, options, jsonMode);
+  throw streamLostError();
+}
+async function pollLogs(functionNames, options, availableFunctionNames, jsonMode, initialState) {
+  let state = initialState;
+  let first = state.lastTime === "";
   while (true) {
     const pollOptions = first ? options : { ...options, since: state.lastTime };
     const entries = await fetchLogsForFunctions(functionNames, pollOptions, availableFunctionNames);
@@ -258350,7 +258582,7 @@ async function followLogs(functionNames, options, availableFunctionNames, jsonMo
     for (const entry of fresh)
       writeFollowLine(entry, jsonMode);
     first = false;
-    await new Promise((resolve9) => setTimeout(resolve9, 2000));
+    await delay2(2000);
   }
 }
 function formatLogs(entries, env3) {
@@ -258449,7 +258681,7 @@ async function logsAction(ctx, options) {
       throw new InvalidInputError("--order cannot be combined with --follow (a live tail always streams oldest to newest).");
     }
     options.order = "asc";
-    return followLogs(functionNames, options, availableFunctionNames, ctx.jsonMode);
+    return followLogs(functionNames, options, availableFunctionNames, ctx.jsonMode, ctx.log);
   }
   let entries = await fetchLogsForFunctions(functionNames, options, availableFunctionNames);
   const limit = options.limit ? Number.parseInt(options.limit, 10) : undefined;
@@ -258468,7 +258700,7 @@ async function logsAction(ctx, options) {
 function getLogsCommand() {
   return new Base44Command("logs").description("Fetch function logs for this app").option("--function <names>", "Filter by function name(s), comma-separated. If omitted, fetches logs for all deployed functions").option("--since <datetime>", "Show logs from this time. ISO datetime or relative shorthand (e.g. 1h, 30m, 2d)", normalizeDatetime).option("--until <datetime>", "Show logs until this time. ISO datetime or relative shorthand (e.g. 1h, 30m, 2d)", normalizeDatetime).addOption(new Option("--level <level>", "Filter by log level").choices([
     ...LogLevelSchema.options
-  ])).option("-n, --limit <n>", "Results per page (1-1000, default: 50)").option("-f, --follow", "Stream new logs as they arrive").addOption(new Option("--order <order>", "Sort order").choices(["asc", "desc"])).addOption(new Option("--env <env>", "Which deployment to read logs from: preview (current draft) or prod (published). Default: preview").choices([...LogEnvSchema.options])).action(logsAction);
+  ])).option("-n, --limit <n>", "Results per page (1-1000; the server returns at most 500)").option("-f, --follow", "Stream new logs as they arrive").addOption(new Option("--order <order>", "Sort order").choices(["asc", "desc"])).addOption(new Option("--env <env>", "Which deployment to read logs from: preview (current draft) or prod (published). Default: preview").choices([...LogEnvSchema.options])).action(logsAction);
 }
 
 // src/cli/commands/project/scaffold.ts
@@ -268098,4 +268330,4 @@ export {
   runCLI
 };
 
-//# debugId=31021F5DECFABABC64756E2164756E21
+//# debugId=80FBE85BCE476A3564756E2164756E21