@base44-preview/cli 0.1.11-pr.602.81713bc → 0.1.12-pr.595.db709c9

package/dist/cli/index.js

@@ -247752,6 +247752,137 @@ 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("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;
@@ -247927,7 +248058,7 @@ import { join as join12 } from "node:path";
 // package.json
 var package_default = {
   name: "base44",
-  version: "0.1.11",
+  version: "0.1.12",
   description: "Base44 CLI - Unified interface for managing Base44 applications",
   type: "module",
   bin: {
@@ -258338,9 +258469,84 @@ 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 producedEvents = false;
+  try {
+    for await (const event of stream) {
+      producedEvents = true;
+      if (event.kind === "end")
+        return { lastTime, producedEvents, end: event.end };
+      if (levelFilter && event.log.level !== levelFilter)
+        continue;
+      writeFollowLine(streamEventToLogEntry(event.log), jsonMode);
+      if (event.log.time > lastTime)
+        lastTime = event.log.time;
+    }
+  } catch {}
+  return { lastTime, producedEvents, end: null };
+}
+var STREAM_RECONNECT_DELAY_MS = 1000;
+var MAX_DROPS_SINCE_LAST_EVENT = 2;
+var CONNECT_RETRY_DELAYS_MS = [1000, 2000, 4000, 8000];
+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(options, jsonMode) {
+  const filters = {
+    functions: parseFunctionNames(options.function),
+    env: options.env
+  };
+  let everConnected = false;
+  let lastTime = "";
+  let dropsSinceLastEvent = 0;
+  while (true) {
+    const attempt = await connectWhileTransientlyUnavailable(filters);
+    if (attempt.kind !== "stream")
+      break;
+    everConnected = true;
+    const ending = await printStreamUntilEnd(attempt.events, options.level, jsonMode, lastTime);
+    lastTime = ending.lastTime;
+    if (ending.end) {
+      if (!ending.end.retriable)
+        break;
+      dropsSinceLastEvent = 0;
+    } else {
+      dropsSinceLastEvent = ending.producedEvents ? 1 : dropsSinceLastEvent + 1;
+      if (dropsSinceLastEvent >= MAX_DROPS_SINCE_LAST_EVENT)
+        break;
+    }
+    await delay2(STREAM_RECONNECT_DELAY_MS);
+  }
+  return { everConnected, lastTime };
+}
+async function followLogs(functionNames, options, availableFunctionNames, jsonMode, logger2) {
+  const { everConnected, lastTime } = await streamUntilExhausted(options, jsonMode);
+  logger2.warn(everConnected ? "Realtime stream disconnected — falling back to polling (lines may lag ~20-30s)." : "Realtime stream unavailable — falling back to polling (lines may lag ~20-30s).");
+  return pollLogs(functionNames, options, availableFunctionNames, jsonMode, {
+    lastTime,
+    boundaryKeys: new Set
+  });
+}
+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 +258556,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 +258648,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 +258658,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;
@@ -268098,4 +268307,4 @@ export {
   runCLI
 };
 
-//# debugId=A79A364B5E1F19E564756E2164756E21
+//# debugId=9A9871757366EC3764756E2164756E21