termbridge 0.3.0 → 0.3.2

package/dist/bin.js

@@ -1828,6 +1828,22 @@ var parseArgs = (argv) => {
       options.tunnel = "cloudflare";
       continue;
     }
+    if (current === "--tunnel-token") {
+      const token = args.shift();
+      if (!token) {
+        throw new Error("missing tunnel token");
+      }
+      options.tunnelToken = token;
+      continue;
+    }
+    if (current === "--tunnel-url") {
+      const url = args.shift();
+      if (!url) {
+        throw new Error("missing tunnel url");
+      }
+      options.tunnelUrl = url;
+      continue;
+    }
     throw new Error(`unknown option: ${current}`);
   }
   return { command, options };
@@ -1842,6 +1858,8 @@ Usage:
 Options:
   --port <port>       Bind the local server to a fixed port
   --proxy <port>      Proxy a local dev server (e.g., Vite) through termbridge
+  --tunnel-token <t>  Use a named Cloudflare Tunnel token (requires --port)
+  --tunnel-url <url>  Public URL for a named tunnel (required with --tunnel-token)
   --session <name>    Use a specific tmux session name
   --kill-on-exit      Kill the tmux session when the CLI exits
   --no-qr             Disable QR code output
@@ -1883,7 +1901,8 @@ var defaultDeps = {
   spawnPty: pty.spawn,
   env: process.env,
   defaultCols: 80,
-  defaultRows: 24
+  defaultRows: 24,
+  _skipSpawnHelperCheck: false
 };
 var ensureSpawnHelperExecutable = () => {
   if (spawnHelperChecked || process.platform === "win32") {
@@ -1956,7 +1975,9 @@ var createTmuxBackend = (deps = {}) => {
     if (entry.pty) {
       return entry.pty;
     }
-    ensureSpawnHelperExecutable();
+    if (!runtime._skipSpawnHelperCheck) {
+      ensureSpawnHelperExecutable();
+    }
     const ptyInstance = runtime.spawnPty("tmux", ["attach-session", "-t", entry.session.name], {
       name: "xterm-256color",
       cols: entry.cols,
@@ -2059,36 +2080,83 @@ var readLines = (data, carry, onLine) => {
   }
   return remainder;
 };
+var normalizeLine = (line) => line.trim();
 var createCloudflaredProvider = (deps = {}) => {
   const spawn2 = deps.spawn ?? spawnCallback;
   let child = null;
-  const start = (localUrl) => {
+  const start = (localUrl, options = {}) => {
     if (child) {
       return Promise.reject(new Error("cloudflared already running"));
     }
-    child = spawn2("cloudflared", ["tunnel", "--url", localUrl]);
+    const token = options.token?.trim();
+    const publicUrl = options.publicUrl?.trim();
+    if (token && !publicUrl) {
+      return Promise.reject(new Error("tunnel public URL required when using tunnel token"));
+    }
+    const args = token ? ["tunnel", "run", "--token", token] : ["tunnel", "--url", localUrl];
+    child = spawn2("cloudflared", args);
     let stdoutCarry = "";
     let stderrCarry = "";
+    const errorLines = [];
     return new Promise((resolve4, reject) => {
+      let resolved = false;
+      let resolveTimer = null;
+      const resolveOnce = (url) => {
+        if (resolved) {
+          return;
+        }
+        resolved = true;
+        if (resolveTimer) {
+          clearTimeout(resolveTimer);
+          resolveTimer = null;
+        }
+        resolve4({ publicUrl: url });
+      };
       const handleLine = (line) => {
-        const url = parseCloudflaredUrl(line);
+        const cleaned = normalizeLine(line);
+        if (!cleaned) {
+          return;
+        }
+        options.log?.(cleaned, "stdout");
+        const url = parseCloudflaredUrl(cleaned);
         if (url) {
-          resolve4({ publicUrl: url });
+          resolveOnce(url);
         }
       };
       const handleOutput = (data, isStdout) => {
         if (isStdout) {
           stdoutCarry = readLines(data.toString(), stdoutCarry, handleLine);
         } else {
-          stderrCarry = readLines(data.toString(), stderrCarry, handleLine);
+          stderrCarry = readLines(data.toString(), stderrCarry, (line) => {
+            const cleaned = normalizeLine(line);
+            if (!cleaned) {
+              return;
+            }
+            options.log?.(cleaned, "stderr");
+            errorLines.push(cleaned);
+            if (errorLines.length > 6) {
+              errorLines.shift();
+            }
+            const url = parseCloudflaredUrl(cleaned);
+            if (url) {
+              resolveOnce(url);
+            }
+          });
         }
       };
       child?.stdout.on("data", (data) => handleOutput(data, true));
       child?.stderr.on("data", (data) => handleOutput(data, false));
       child?.once("error", (error) => reject(error));
       child?.once("exit", (code) => {
-        reject(new Error(`cloudflared exited (${code ?? "unknown"})`));
+        if (resolved) {
+          return;
+        }
+        const suffix = errorLines.length > 0 ? `: ${errorLines.join(" | ")}` : "";
+        reject(new Error(`cloudflared exited (${code ?? "unknown"})${suffix}`));
       });
+      if (token && publicUrl) {
+        resolveTimer = setTimeout(() => resolveOnce(publicUrl), 1200);
+      }
     });
   };
   const stop = async () => {
@@ -2373,11 +2441,11 @@ var isAllowedOrigin = (origin, host) => {
 };
 var allowedControlKeys = new Set(TERMINAL_CONTROL_KEYS);
 var parseClientMessage = (payload) => {
-  const size = typeof payload === "string" ? payload.length : payload.byteLength;
+  const size = typeof payload === "string" ? payload.length : Array.isArray(payload) ? payload.reduce((sum, buf) => sum + buf.length, 0) : payload.byteLength;
   if (size > MAX_WS_MESSAGE_SIZE) {
     return { ok: false, error: "too_large" };
   }
-  const text = typeof payload === "string" ? payload : payload.toString();
+  const text = typeof payload === "string" ? payload : Array.isArray(payload) ? Buffer.concat(payload).toString() : payload.toString();
   try {
     const parsed = JSON.parse(text);
     if (parsed.type === "input" && typeof parsed.data === "string") {
@@ -2660,6 +2728,18 @@ var parseSessionCount = (value) => {
   }
   return parsed;
 };
+var normalizePublicUrl = (value) => {
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch {
+    throw new Error("invalid tunnel url");
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error("invalid tunnel url");
+  }
+  return value.endsWith("/") ? value.slice(0, -1) : value;
+};
 var startCommand = async (options, deps = {}) => {
   const logger = deps.logger ?? createDefaultLogger();
   const processRef = deps.process ?? process;
@@ -2674,6 +2754,16 @@ var startCommand = async (options, deps = {}) => {
   const terminalBackend = (deps.createTerminalBackend ?? (() => createTmuxBackend()))();
   const terminalRegistry = (deps.createTerminalRegistry ?? (() => createTerminalRegistry()))();
   const tunnelProvider = (deps.createTunnelProvider ?? (() => createCloudflaredProvider()))();
+  const tunnelTokenRaw = options.tunnelToken ?? env.TERMBRIDGE_TUNNEL_TOKEN;
+  const tunnelToken = tunnelTokenRaw?.trim() || void 0;
+  const tunnelUrlRaw = options.tunnelUrl ?? env.TERMBRIDGE_TUNNEL_URL;
+  const tunnelUrl = tunnelToken && tunnelUrlRaw ? normalizePublicUrl(tunnelUrlRaw) : void 0;
+  if (tunnelToken && !options.port) {
+    throw new Error("port required when using tunnel token");
+  }
+  if (tunnelToken && !tunnelUrl) {
+    throw new Error("tunnel url required when using tunnel token");
+  }
   const wsLimiter = createRateLimiter({ limit: 30, windowMs: 6e4 });
   const serverFactory = deps.createServer ?? ((serverDeps) => createAppServer({
     ...serverDeps,
@@ -2704,7 +2794,10 @@ var startCommand = async (options, deps = {}) => {
   const { token } = auth.issueToken();
   let publicUrl = "";
   try {
-    const result = await tunnelProvider.start(localUrl);
+    const result = await tunnelProvider.start(localUrl, {
+      token: tunnelToken,
+      publicUrl: tunnelUrl
+    });
     publicUrl = result.publicUrl;
   } catch (error) {
     const message = error instanceof Error ? error.message : "unknown error";
@@ -2796,7 +2889,7 @@ var buildSessionName = (options, localUrl) => {
     return "termbridge";
   }
 };
-var buildRedeemUrl = (result) => `${result.publicUrl}/s/${result.token}`;
+var buildRedeemUrl = (result) => `${result.publicUrl}/__tb/s/${result.token}`;
 var generateQr = async (text) => new Promise((resolve4) => {
   qrcode.generate(text, { small: true }, (output) => resolve4(output));
 });