1tube 0.1.18 → 0.1.20

package/package.json

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

package/src/backends/workerd/backend.ts

@@ -1352,89 +1352,85 @@ export function createWorkerdBackend(opts: WorkerdBackendOptions): WorkerdBacken
 
       // Preflight: refuse to spawn workerd against ports that are
       // already in use. Without this, a leftover workerd from a
-      // previous run silently steals our traffic and the failure
-      // surfaces only as wrong-looking response bodies. See
-      // `probeSocketsFree` doc comment for the full rationale.
-      // We skip the check on reload because the still-serving old
-      // generation occupies the OTHER slot's ports by design — the
-      // even/odd `slot` shift above guarantees no overlap, and
-      // probing here would race against that intentional overlap.
-      if (args.gen === 0) {
-        let conflicts = probeSocketsFree(capnp.routes);
-        if (conflicts.length > 0 && opts.killStaleWorkerd) {
-          console.log(
-            `[1tube] port preflight found ${conflicts.length} conflict(s); ` +
-              `--kill-stale-workerd is set, attempting cleanup...`,
-          );
+      // previous run can satisfy the readiness probe and silently
+      // steal our traffic; the failure then surfaces only as stale
+      // response bodies. On reload the still-serving current process
+      // occupies the OTHER slot's ports by design, so probing the next
+      // slot is safe and catches orphaned older generations.
+      let conflicts = probeSocketsFree(capnp.routes);
+      if (conflicts.length > 0 && opts.killStaleWorkerd) {
+        console.log(
+          `[1tube] port preflight found ${conflicts.length} conflict(s)` +
+            (args.gen > 0 ? ` for reload gen=${args.gen}` : "") +
+            `; --kill-stale-workerd is set, attempting cleanup...`,
+        );
 
-          // First try the precise fix: resolve the conflicted port(s)
-          // to their owning PID(s), and kill only owners named workerd.
-          // That is the behavior we want during firmware flashing:
-          // remove the stale candidate that owns 8800, but never kill
-          // a random non-workerd process that happens to be there.
-          const targeted = await killWorkerdOwnersOfPorts(conflicts);
-          if (targeted.attempted) {
-            if (targeted.code === 0) {
-              const details = targeted.stdout?.trim();
-              console.log(
-                `[1tube] targeted stale-workerd cleanup by port complete` +
-                  (details ? ` (${details})` : "") +
-                  `; re-probing...`,
-              );
-            } else {
-              console.warn(
-                `[1tube] targeted stale-workerd cleanup exited ${targeted.code}` +
-                  (targeted.stderr ? `: ${targeted.stderr.trim()}` : ""),
-              );
-            }
-            await new Promise((r) => setTimeout(r, 250));
-            conflicts = probeSocketsFree(capnp.routes);
+        // First try the precise fix: resolve the conflicted port(s)
+        // to their owning PID(s), and kill only owners named workerd.
+        // That is the behavior we want during firmware flashing:
+        // remove the stale candidate that owns 8800, but never kill
+        // a random non-workerd process that happens to be there.
+        const targeted = await killWorkerdOwnersOfPorts(conflicts);
+        if (targeted.attempted) {
+          if (targeted.code === 0) {
+            const details = targeted.stdout?.trim();
+            console.log(
+              `[1tube] targeted stale-workerd cleanup by port complete` +
+                (details ? ` (${details})` : "") +
+                `; re-probing...`,
+            );
+          } else {
+            console.warn(
+              `[1tube] targeted stale-workerd cleanup exited ${targeted.code}` +
+                (targeted.stderr ? `: ${targeted.stderr.trim()}` : ""),
+            );
           }
+          await new Promise((r) => setTimeout(r, 250));
+          conflicts = probeSocketsFree(capnp.routes);
+        }
 
-          // If targeted cleanup did not exist on this platform, or it
-          // found no matching workerd owner, fall back to the old typed
-          // process-name cleanup.
-          const result = conflicts.length > 0 ? await killStaleWorkerd() : null;
-          if (result === null) {
-            // Already clear.
-          } else
-          if (result.attempted) {
-            // taskkill returns 128 when no matching image is running —
-            // that's not an error in our context (means the offender
-            // wasn't workerd, which is fine; preflight will catch it).
-            // pkill returns 1 in the same case.
-            const noMatch = (Deno.build.os === "windows" && result.code === 128) ||
-              (Deno.build.os !== "windows" && result.code === 1);
-            if (result.code === 0) {
-              console.log(`[1tube] killed leftover workerd process(es); re-probing...`);
-            } else if (noMatch) {
-              console.log(
-                `[1tube] no leftover workerd processes found; the conflict is held ` +
-                  `by something else (re-probing to confirm)...`,
-              );
-            } else {
-              console.warn(
-                `[1tube] ${result.command?.join(" ")} exited ${result.code}` +
-                  (result.stderr ? `: ${result.stderr.trim()}` : ""),
-              );
-            }
-            // Brief settle time: Windows TCP sockets in CLOSE_WAIT can
-            // hold the port for a fraction of a second after the owner
-            // process is killed. 250ms is empirically enough on the
-            // dev boxes we've tested without making the boot path feel
-            // sluggish.
-            await new Promise((r) => setTimeout(r, 250));
-            conflicts = probeSocketsFree(capnp.routes);
+        // If targeted cleanup did not exist on this platform, or it
+        // found no matching workerd owner, fall back to the old typed
+        // process-name cleanup.
+        const result = conflicts.length > 0 ? await killStaleWorkerd() : null;
+        if (result === null) {
+          // Already clear.
+        } else if (result.attempted) {
+          // taskkill returns 128 when no matching image is running —
+          // that's not an error in our context (means the offender
+          // wasn't workerd, which is fine; preflight will catch it).
+          // pkill returns 1 in the same case.
+          const noMatch = (Deno.build.os === "windows" && result.code === 128) ||
+            (Deno.build.os !== "windows" && result.code === 1);
+          if (result.code === 0) {
+            console.log(`[1tube] killed leftover workerd process(es); re-probing...`);
+          } else if (noMatch) {
+            console.log(
+              `[1tube] no leftover workerd processes found; the conflict is held ` +
+                `by something else (re-probing to confirm)...`,
+            );
           } else {
             console.warn(
-              `[1tube] could not run ${result.command?.join(" ")}: ` +
-                `${result.stderr ?? "unknown error"}`,
+              `[1tube] ${result.command?.join(" ")} exited ${result.code}` +
+                (result.stderr ? `: ${result.stderr.trim()}` : ""),
             );
           }
+          // Brief settle time: Windows TCP sockets in CLOSE_WAIT can
+          // hold the port for a fraction of a second after the owner
+          // process is killed. 250ms is empirically enough on the
+          // dev boxes we've tested without making the boot path feel
+          // sluggish.
+          await new Promise((r) => setTimeout(r, 250));
+          conflicts = probeSocketsFree(capnp.routes);
+        } else {
+          console.warn(
+            `[1tube] could not run ${result.command?.join(" ")}: ` +
+              `${result.stderr ?? "unknown error"}`,
+          );
         }
-        if (conflicts.length > 0) {
-          throw new Error(formatPortConflictError(conflicts));
-        }
+      }
+      if (conflicts.length > 0) {
+        throw new Error(formatPortConflictError(conflicts));
       }
 
       const inspectorArgs = buildInspectorExtraArgs(opts.inspectorAddr, slot);

package/src/server.ts

@@ -398,6 +398,15 @@ const LOCAL_SUPABASE_DEFAULTS: Record<string, string> = {
   JWT_SECRET: "super-secret-jwt-token-with-at-least-32-characters-long",
 };
 
+const LOCAL_SUPABASE_STATUS_KEYS: Record<string, string[]> = {
+  SUPABASE_URL: ["API_URL"],
+  JWT_SECRET: ["JWT_SECRET"],
+  SUPABASE_ANON_KEY: ["ANON_KEY"],
+  SUPABASE_PUBLISHABLE_KEY: ["PUBLISHABLE_KEY"],
+  SUPABASE_SECRET_KEY: ["SECRET_KEY"],
+  SUPABASE_SERVICE_ROLE_KEY: ["SERVICE_ROLE_KEY"],
+};
+
 // Only secrets the gateway *itself* uses on the hot path. Anything an edge
 // function happens to need (publishable/secret keys, OPENAI_API_KEY, …) is
 // the function author's contract with the host — refusing to boot because
@@ -405,8 +414,24 @@ const LOCAL_SUPABASE_DEFAULTS: Record<string, string> = {
 // confusing failures.
 const SECRETS_REQUIRED_IN_PROD = ["JWT_SECRET"];
 
-function applyDevDefaults() {
+async function applyDevDefaults() {
   let applied = 0;
+  const statusEnv = await readLocalSupabaseStatusEnv();
+  for (const [target, sources] of Object.entries(LOCAL_SUPABASE_STATUS_KEYS)) {
+    if (Deno.env.get(target)) continue;
+    const value = sources
+      .map((source) => statusEnv[source])
+      .find((candidate) => typeof candidate === "string" && candidate.length > 0);
+    if (!value) continue;
+    Deno.env.set(target, value);
+    applied++;
+  }
+
+  if (!Deno.env.get("SUPABASE_URL") && Deno.env.get("VITE_SUPABASE_URL")) {
+    Deno.env.set("SUPABASE_URL", Deno.env.get("VITE_SUPABASE_URL")!);
+    applied++;
+  }
+
   for (const [key, value] of Object.entries(LOCAL_SUPABASE_DEFAULTS)) {
     if (!Deno.env.get(key)) {
       Deno.env.set(key, value);
@@ -418,6 +443,48 @@ function applyDevDefaults() {
   }
 }
 
+async function readLocalSupabaseStatusEnv(): Promise<Record<string, string>> {
+  const runners: Array<{ command: string; args: string[] }> = [
+    { command: "supabase", args: ["status", "-o", "env"] },
+    { command: "bunx", args: ["supabase", "status", "-o", "env"] },
+  ];
+
+  for (const runner of runners) {
+    try {
+      const output = await new Deno.Command(runner.command, {
+        args: runner.args,
+        stdout: "piped",
+        stderr: "null",
+      }).output();
+      if (!output.success) continue;
+      return parseSupabaseStatusEnv(new TextDecoder().decode(output.stdout));
+    } catch {
+      // CLI not installed on PATH (or bunx unavailable). Try the next runner.
+    }
+  }
+  return {};
+}
+
+function parseSupabaseStatusEnv(text: string): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const rawLine of text.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const eq = line.indexOf("=");
+    if (eq <= 0) continue;
+    const key = line.slice(0, eq).trim();
+    let value = line.slice(eq + 1).trim();
+    if (
+      (value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1);
+    }
+    out[key] = value;
+  }
+  return out;
+}
+
 function enforceProdSecrets() {
   // We deliberately do NOT reject "well-known dev default" values
   // here. The local Supabase Docker stack ships with a fixed
@@ -463,7 +530,7 @@ function requireInternal(c: Context): Response | null {
 }
 
 if (opts.dev) {
-  applyDevDefaults();
+  await applyDevDefaults();
 } else {
   enforceProdSecrets();
 }