1tube 0.1.9 → 0.1.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "1tube",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "private": false,
   "description": "Self-hosted Supabase Edge Functions gateway for Deno, plus an ESLint plugin for consumers",
   "license": "MIT",

package/src/boot-progress.ts

@@ -1,101 +1,98 @@
 /**
- * TTY-aware live boot progress for function discovery.
+ * Append-only boot progress reporter for function discovery.
  *
- * Problem: with `concurrency=8` (the discovery default), all eight imports
- * start in parallel and don't finish for several seconds. The previous
- * "print one line per completion" UI showed nothing during that window —
- * users assumed the process was hung. This module fills the gap with a
- * single in-place updated status line that shows what's currently being
- * compiled, plus elapsed time. Completed lines still print above it as
- * they finish, so scrollback is preserved.
+ * Why not a live in-place spinner? With many functions importing in
+ * parallel, their top-level `console.log()` calls hit the same TTY as our
+ * renderer. Any cursor-rewrite scheme (\r + clear-line, ANSI cursor
+ * positioning, alt-screen, even Ink) corrupts the moment a foreign writer
+ * lands a line — you get flicker, half-erased frames, or text glued to
+ * the spinner. Below 200 ms of redraw cadence the eye also reads it as
+ * blinking, which the operator perceives as "broken UI".
  *
- * On non-TTY stdouts (piped output, CI logs) the spinner is silent and we
- * fall back to printing "starting" markers — same total information, no
- * cursor manipulation that would render as garbage in a log file.
+ * So we don't redraw. We print one normal newline-terminated line every
+ * `pulseMs` saying "still working, X/Y done, in progress: …". It's not
+ * animated, but it's:
+ *   - race-free with foreign stdout writers,
+ *   - zero-cost (one syscall every couple of seconds),
+ *   - safe to pipe to a file or capture in CI,
+ *   - and identical between TTY and non-TTY paths (no branching).
+ *
+ * Pulses self-suppress when no work has changed since the previous tick,
+ * so a wedged import won't spam the log either.
  */
 
-const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-const REFRESH_MS = 100;
-/** Truncate the in-flight name list so the line fits a typical terminal. */
-const MAX_LINE = 100;
+const DEFAULT_PULSE_MS = 2000;
+/** Cap inflight names rendered inline so a long list doesn't wrap. */
+const MAX_INFLIGHT_RENDERED = 4;
 
 export interface BootProgress {
-  /** Initialise / reset for a new batch of `total` items. */
+  /** Reset and arm the heartbeat for a new batch of `total` items. */
   start(total: number): void;
   /** An import has begun. */
   onStart(name: string): void;
-  /** An item finished — print `line` (the formatted completion) above the spinner. */
+  /** Print a completion line and update internal counters. */
   onFinish(line: string, name: string): void;
-  /** Stop refreshing and clear the live line. Call from a try/finally. */
+  /** Stop the heartbeat. Safe to call repeatedly. */
   stop(): void;
 }
 
 interface Sink {
-  isTerminal(): boolean;
   writeSync(chunk: Uint8Array): number;
+  // Kept in the interface for future use / fakes; renderer ignores it.
+  isTerminal?(): boolean;
 }
 
-/**
- * Build a progress renderer. `sink` defaults to Deno.stdout but can be
- * overridden in tests.
- */
-export function createBootProgress(sink: Sink = Deno.stdout): BootProgress {
+export interface BootProgressOptions {
+  /** Heartbeat cadence in ms. Default 2000. Set ≤0 to disable heartbeats. */
+  pulseMs?: number;
+}
+
+export function createBootProgress(
+  sink: Sink = Deno.stdout,
+  opts: BootProgressOptions = {},
+): BootProgress {
   const enc = new TextEncoder();
-  const isTty = (() => {
-    try {
-      return sink.isTerminal();
-    } catch {
-      return false;
-    }
-  })();
+  const pulseMs = opts.pulseMs ?? DEFAULT_PULSE_MS;
 
   const active = new Set<string>();
   let completed = 0;
   let total = 0;
   let startedAt = 0;
   let timer: number | undefined;
-  let frame = 0;
-  // Track how many cells the live line currently occupies so we can erase
-  // it cleanly even if it wrapped.
-  let lastDrawn = "";
+  // Snapshot used to suppress a heartbeat when nothing has moved since the
+  // last pulse — important when a single slow import blocks the worker
+  // pool and we'd otherwise emit identical lines forever.
+  let lastSnapshot = "";
 
   const write = (s: string) => {
     try {
       sink.writeSync(enc.encode(s));
     } catch {
-      // closed pipe — give up silently rather than crash boot.
+      // Closed pipe — never crash boot over a broken stdout.
     }
   };
 
-  const eraseLive = () => {
-    if (!isTty || lastDrawn.length === 0) return;
-    // CR + clear-to-end-of-line. Works in any VT100-compatible terminal.
-    write("\r\x1b[K");
-    lastDrawn = "";
+  const renderInflight = (): string => {
+    if (active.size === 0) return "(idle)";
+    const names = [...active];
+    if (names.length <= MAX_INFLIGHT_RENDERED) return names.join(", ");
+    return (
+      names.slice(0, MAX_INFLIGHT_RENDERED).join(", ") +
+      ` +${names.length - MAX_INFLIGHT_RENDERED} more`
+    );
   };
 
-  const draw = () => {
-    if (!isTty) return;
+  const pulse = () => {
+    if (total === 0) return;
+    if (completed >= total) return;
+    const snapshot = `${completed}|${[...active].sort().join(",")}`;
+    if (snapshot === lastSnapshot) return;
+    lastSnapshot = snapshot;
     const elapsed = ((performance.now() - startedAt) / 1000).toFixed(1);
-    const spin = SPINNER[frame++ % SPINNER.length];
-    const names = [...active];
-    let inflight: string;
-    if (names.length === 0) {
-      inflight = "waiting…";
-    } else if (names.length <= 4) {
-      inflight = names.join(", ");
-    } else {
-      inflight = names.slice(0, 4).join(", ") + ` +${names.length - 4} more`;
-    }
-    let line =
-      `\x1b[36m${spin}\x1b[0m \x1b[1m${completed}/${total}\x1b[0m loaded, ` +
-      `${active.size} in progress: \x1b[2m${inflight}\x1b[0m \x1b[2m(${elapsed}s)\x1b[0m`;
-    if (line.length > MAX_LINE) {
-      line = line.slice(0, MAX_LINE - 1) + "…";
-    }
-    eraseLive();
-    write(line);
-    lastDrawn = line;
+    write(
+      `[1tube]    \x1b[2m… still working: ${completed}/${total} loaded, ` +
+        `${active.size} in progress (${renderInflight()}) (${elapsed}s)\x1b[0m\n`,
+    );
   };
 
   return {
@@ -104,37 +101,31 @@ export function createBootProgress(sink: Sink = Deno.stdout): BootProgress {
       completed = 0;
       active.clear();
       startedAt = performance.now();
-      frame = 0;
-      lastDrawn = "";
-      if (isTty && t > 0) {
-        timer = setInterval(draw, REFRESH_MS) as unknown as number;
-        // Draw immediately so users see *something* before the first onStart.
-        draw();
+      lastSnapshot = "";
+      if (timer !== undefined) {
+        clearInterval(timer);
+        timer = undefined;
+      }
+      if (pulseMs > 0 && t > 0) {
+        timer = setInterval(pulse, pulseMs) as unknown as number;
       }
     },
     onStart(name) {
       active.add(name);
-      // Non-TTY: announce starts inline so logs still show progress between
-      // completions. We rate-limit to one announcement per batch by only
-      // emitting when nothing else is in-flight yet.
-      if (!isTty && active.size <= 4) {
-        write(`[1tube]    \x1b[2m→ compiling ${name}\x1b[0m\n`);
-      }
-      draw();
     },
     onFinish(line, name) {
       active.delete(name);
       completed++;
-      eraseLive();
       write(line + "\n");
-      draw();
+      // Reset the snapshot so the next pulse always reflects the new state
+      // immediately rather than waiting another `pulseMs`.
+      lastSnapshot = "";
     },
     stop() {
       if (timer !== undefined) {
         clearInterval(timer);
         timer = undefined;
       }
-      eraseLive();
     },
   };
 }

package/src/server.ts

@@ -303,37 +303,32 @@ async function reloadFunctions(
   // very next request — even when boot-time discovery was lazy.
   const useLazy = opts.lazy && isFullReload;
 
-  // Live progress: shows a spinner with currently in-flight imports so the
-  // operator doesn't stare at a silent terminal during the multi-second
-  // first-transpile window. Falls back to plain "starting…" lines when
-  // stdout isn't a TTY (CI logs, output redirection).
-  const progress = createBootProgress();
-  // Skip the live spinner for tiny HMR reloads (one or two functions) —
-  // the existing per-completion line is enough and a spinner would just
-  // flicker on screen.
-  const useSpinner = isFullReload ||
-    (changedFunctionNames instanceof Set && changedFunctionNames.size > 2);
+  // Append-only "still working" heartbeat. Does not redraw, does not race
+  // with foreign console.log() from imported modules — see
+  // src/boot-progress.ts for the design rationale. Heartbeat is silent for
+  // tiny HMR reloads (≤2 functions) where the per-completion line is
+  // already enough signal.
+  const isTinyReload = changedFunctionNames instanceof Set &&
+    changedFunctionNames.size <= 2;
+  const progress = createBootProgress(Deno.stdout, {
+    pulseMs: isTinyReload ? 0 : 2000,
+  });
 
   let result;
   try {
-    if (useSpinner) progress.start(0); // total filled in once we see the first onStart
     result = await discoverAndLoad(
       opts.functionsPath,
       registry,
       {
         cacheBust,
         only: isFullReload ? undefined : changedFunctionNames,
-        onStart: useSpinner
-          ? (p) => {
-              // Late-bind the total on the first start event — by then we
-              // know the real work-list size.
-              if (p.index === 1) progress.start(p.total);
-              progress.onStart(p.name);
-            }
-          : undefined,
-        onProgress: useSpinner
-          ? (p) => progress.onFinish(progressLine(p), p.name)
-          : (p) => console.log(progressLine(p)),
+        onStart: (p) => {
+          // Late-bind the total on the first start event — by then we
+          // know the real work-list size after `only`/exists filtering.
+          if (p.index === 1) progress.start(p.total);
+          progress.onStart(p.name);
+        },
+        onProgress: (p) => progress.onFinish(progressLine(p), p.name),
         lazy: useLazy,
       },
     );