@base44-preview/cli 0.1.12-pr.609.cbdaa40 → 0.1.12-pr.611.23d31b2

package/dist/cli/index.js

@@ -247752,6 +247752,141 @@ 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") {
+        await reader.cancel();
+        return;
+      }
+      if (result.done || !result.value)
+        return;
+      buffered += decoder.decode(result.value, { stream: true });
+      const lines = buffered.split(`
+`);
+      buffered = lines.pop() ?? "";
+      yield* lines;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+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 connectPhase = new AbortController;
+  const connectTimer = setTimeout(() => connectPhase.abort(), STREAM_CONNECT_TIMEOUT_MS);
+  let response;
+  try {
+    response = await fetch(buildStreamUrl(filters), {
+      headers: {
+        Accept: "text/event-stream",
+        ...await buildStreamAuthHeaders()
+      },
+      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;
@@ -258338,9 +258473,106 @@ function writeFollowLine(entry, jsonMode) {
   process.stdout.write(`${line}
 `);
 }
-async function followLogs(functionNames, options, availableFunctionNames, jsonMode) {
-  let state = { lastTime: "", boundaryKeys: new Set };
-  let first = true;
+var delay2 = (ms2) => new Promise((resolve9) => setTimeout(resolve9, ms2));
+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 RECONNECT_DELAYS_MS = [1000, 2000, 4000, 8000];
+var ONE_STRIKE_FOR_A_STREAM_THAT_WORKED = 1;
+var strikesAfter = (ending, strikes) => {
+  if (ending.end)
+    return 0;
+  return ending.provedAlive ? ONE_STRIKE_FOR_A_STREAM_THAT_WORKED : strikes + 1;
+};
+var hasRunOutOfStrikes = (strikes) => strikes >= RECONNECT_DELAYS_MS.length;
+async function connectWithinStrikes(filters, strikes) {
+  let spent = strikes;
+  let attempt = await openLogStream(filters);
+  while (attempt.kind === "transient") {
+    spent += 1;
+    if (hasRunOutOfStrikes(spent))
+      return { kind: "exhausted" };
+    await delay2(RECONNECT_DELAYS_MS[spent - 1]);
+    attempt = await openLogStream(filters);
+  }
+  if (attempt.kind === "refused")
+    return { kind: "refused" };
+  return { kind: "stream", events: attempt.events, strikes: spent };
+}
+async function streamUntilExhausted(firstStream, filters, options, jsonMode) {
+  let events = firstStream;
+  let lastTime = "";
+  let strikes = 0;
+  while (true) {
+    const ending = await printStreamUntilEnd(events, options.level, jsonMode, lastTime);
+    lastTime = ending.lastTime;
+    if (ending.end && !ending.end.retriable)
+      return;
+    strikes = strikesAfter(ending, strikes);
+    if (hasRunOutOfStrikes(strikes))
+      return;
+    await delay2(RECONNECT_DELAYS_MS[strikes]);
+    const reconnected = await connectWithinStrikes(filters, strikes);
+    if (reconnected.kind !== "stream")
+      return;
+    events = reconnected.events;
+    strikes = reconnected.strikes;
+  }
+}
+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
+  };
+  const opened = await connectWithinStrikes(filters, 0);
+  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) {
@@ -258442,6 +258674,9 @@ async function logsAction(ctx, options) {
     return { outroMessage: "No functions found in this app." };
   }
   if (options.follow) {
+    if (options.since) {
+      throw new InvalidInputError("--since cannot be combined with --follow yet (the realtime stream starts from now).");
+    }
     if (options.until) {
       throw new InvalidInputError("--until cannot be combined with --follow (a stream has no end).");
     }
@@ -258449,7 +258684,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 +258703,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 +268333,4 @@ export {
   runCLI
 };
 
-//# debugId=31021F5DECFABABC64756E2164756E21
+//# debugId=F798B29EB4A3A54F64756E2164756E21