1tube 0.1.8 → 0.1.9

package/package.json

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

package/src/boot-progress.ts

@@ -0,0 +1,140 @@
+/**
+ * TTY-aware live boot progress 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.
+ *
+ * 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.
+ */
+
+const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const REFRESH_MS = 100;
+/** Truncate the in-flight name list so the line fits a typical terminal. */
+const MAX_LINE = 100;
+
+export interface BootProgress {
+  /** Initialise / reset 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. */
+  onFinish(line: string, name: string): void;
+  /** Stop refreshing and clear the live line. Call from a try/finally. */
+  stop(): void;
+}
+
+interface Sink {
+  isTerminal(): boolean;
+  writeSync(chunk: Uint8Array): number;
+}
+
+/**
+ * Build a progress renderer. `sink` defaults to Deno.stdout but can be
+ * overridden in tests.
+ */
+export function createBootProgress(sink: Sink = Deno.stdout): BootProgress {
+  const enc = new TextEncoder();
+  const isTty = (() => {
+    try {
+      return sink.isTerminal();
+    } catch {
+      return false;
+    }
+  })();
+
+  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 = "";
+
+  const write = (s: string) => {
+    try {
+      sink.writeSync(enc.encode(s));
+    } catch {
+      // closed pipe — give up silently rather than crash boot.
+    }
+  };
+
+  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 draw = () => {
+    if (!isTty) return;
+    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;
+  };
+
+  return {
+    start(t) {
+      total = t;
+      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();
+      }
+    },
+    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();
+    },
+    stop() {
+      if (timer !== undefined) {
+        clearInterval(timer);
+        timer = undefined;
+      }
+      eraseLive();
+    },
+  };
+}

package/src/discovery.ts

@@ -34,6 +34,14 @@ export interface DiscoveryOptions {
   concurrency?: number;
   /** Invoked once per function as it finishes (success or failure). */
   onProgress?: (p: DiscoveryProgress) => void;
+  /**
+   * Invoked once per function the moment its dynamic import is dispatched
+   * (or, in lazy mode, the moment it's registered as a candidate). Useful
+   * for live progress UIs that want to show what's currently in-flight,
+   * not just what's completed — important because a single transpile can
+   * block a worker for several seconds with no completion events.
+   */
+  onStart?: (p: { name: string; index: number; total: number }) => void;
   /**
    * When true, candidates are registered for lazy import on first dispatch.
    * Functions whose manifest sets `warm: true` are still imported eagerly
@@ -109,6 +117,7 @@ export async function discoverAndLoad(
   }
 
   const total = work.length;
+  let started = 0;
   let completed = 0;
 
   const loadOne = async (name: string): Promise<void> => {
@@ -121,6 +130,7 @@ export async function discoverAndLoad(
       moduleUrl.searchParams.set("v", options.cacheBust);
     }
 
+    options?.onStart?.({ name, index: ++started, total });
     const start = performance.now();
     try {
       // Load the manifest first so it is attached to the registry before the

package/src/server.ts

@@ -21,6 +21,7 @@ import { bodyLimit } from "npm:hono@4/body-limit";
 import { relative, sep as SEPARATOR } from "node:path";
 import { currentRequestStorage, FunctionRegistry } from "./registry.ts";
 import { discoverAndLoad, type DiscoveryProgress } from "./discovery.ts";
+import { createBootProgress } from "./boot-progress.ts";
 import { validateRequest } from "./gateway/auth.ts";
 import { watchdogBody } from "./gateway/body-watchdog.ts";
 import { corsMiddleware } from "./gateway/cors.ts";
@@ -64,9 +65,12 @@ function parseArgs(): CliOpts {
 
   let dev = envFlag("1TUBE_DEV");
   let hmr = envFlag("1TUBE_HMR");
-  // Lazy-load is on by default; opt out with --eager / 1TUBE_LAZY=0.
+  // Eager loading is the default — first-request latency reflects real
+  // function cost (no on-demand transpile tax). Opt in to lazy with
+  // --lazy or 1TUBE_LAZY=1 when boot speed matters more than first-hit
+  // latency (e.g. sites with hundreds of rarely-called functions).
   const lazyEnv = Deno.env.get("1TUBE_LAZY");
-  let lazy = lazyEnv === undefined ? true : !(lazyEnv === "0" || lazyEnv === "false");
+  let lazy = lazyEnv === undefined ? false : (lazyEnv === "1" || lazyEnv === "true");
   let port = parseInt(Deno.env.get("PORT") || "3100", 10);
   let host = (Deno.env.get("1TUBE_HOST") || "127.0.0.1").trim();
   let functionsPath = Deno.env.get("FUNCTIONS_PATH") || "./supabase/functions";
@@ -298,16 +302,45 @@ async function reloadFunctions(
   // HMR reloads always import eagerly so the change is observable on the
   // very next request — even when boot-time discovery was lazy.
   const useLazy = opts.lazy && isFullReload;
-  const { loaded, skipped, errors, removed, deferred } = await discoverAndLoad(
-    opts.functionsPath,
-    registry,
-    {
-      cacheBust,
-      only: isFullReload ? undefined : changedFunctionNames,
-      onProgress: (p) => console.log(progressLine(p)),
-      lazy: useLazy,
-    },
-  );
+
+  // 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);
+
+  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)),
+        lazy: useLazy,
+      },
+    );
+  } finally {
+    progress.stop();
+  }
+  const { loaded, skipped, errors, removed, deferred } = result;
 
   for (const name of removed) {
     if (registry.delete(name)) {