termbridge 0.3.1 → 0.3.3

package/README.md

@@ -16,6 +16,7 @@ npx termbridge
 ```
 
 Scan the QR code and open the URL on your phone. The CLI stays running while the tunnel is active.
+Use the action tray in the UI for quick navigation, including line + page scroll jumps.
 
 ## Documentation
 

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
@@ -1910,6 +1928,12 @@ var createTmuxBackend = (deps = {}) => {
   const runtime = { ...defaultDeps, ...deps };
   const sessions = /* @__PURE__ */ new Map();
   const runTmux = async (args) => runtime.execFile("tmux", args);
+  const setSessionOption = async (name, option, value) => {
+    try {
+      await runTmux(["set-option", "-t", name, option, value]);
+    } catch {
+    }
+  };
   const createSession = async (name) => {
     const existing = sessions.get(name);
     if (existing) {
@@ -1924,10 +1948,12 @@ var createTmuxBackend = (deps = {}) => {
         throw error;
       }
     }
-    try {
-      await runTmux(["set-option", "-t", name, "status", "off"]);
-    } catch {
-    }
+    await setSessionOption(name, "status", "off");
+    await setSessionOption(name, "status-left", "");
+    await setSessionOption(name, "status-right", "");
+    await setSessionOption(name, "status-style", "bg=default,fg=default");
+    await setSessionOption(name, "message-style", "bg=default,fg=default");
+    await setSessionOption(name, "message-command-style", "bg=default,fg=default");
     const session = { name, createdAt: /* @__PURE__ */ new Date() };
     sessions.set(name, {
       session,
@@ -2000,6 +2026,29 @@ var createTmuxBackend = (deps = {}) => {
     const controlSequence = controlKeyMap[key];
     ensurePty(entry).write(controlSequence);
   };
+  const scroll = async (sessionName, mode, amount) => {
+    if (!Number.isFinite(amount) || amount === 0) {
+      return;
+    }
+    if (!sessions.has(sessionName)) {
+      return;
+    }
+    const direction = amount < 0 ? "up" : "down";
+    const command = mode === "pages" ? `page-${direction}` : `scroll-${direction}`;
+    const steps = Math.min(50, Math.abs(Math.trunc(amount)));
+    try {
+      await runTmux(["copy-mode", "-e", "-t", sessionName]);
+    } catch {
+      return;
+    }
+    for (let index = 0; index < steps; index += 1) {
+      try {
+        await runTmux(["send-keys", "-t", sessionName, "-X", command]);
+      } catch {
+        break;
+      }
+    }
+  };
   const resize = async (sessionName, cols, rows) => {
     const entry = sessions.get(sessionName);
     if (!entry) {
@@ -2042,6 +2091,7 @@ var createTmuxBackend = (deps = {}) => {
     write,
     resize,
     sendControl,
+    scroll,
     onOutput,
     closeSession
   };
@@ -2062,36 +2112,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 () => {
@@ -2395,6 +2492,9 @@ var parseClientMessage = (payload) => {
     if (parsed.type === "control" && allowedControlKeys.has(parsed.key)) {
       return { ok: true, message: parsed };
     }
+    if (parsed.type === "scroll" && (parsed.mode === "lines" || parsed.mode === "pages") && typeof parsed.amount === "number" && Number.isFinite(parsed.amount)) {
+      return { ok: true, message: parsed };
+    }
     return { ok: false, error: "invalid" };
   } catch {
     return { ok: false, error: "invalid" };
@@ -2611,6 +2711,10 @@ var createAppServer = (deps) => {
         void deps.terminalBackend.resize(info.sessionName, message.cols, message.rows);
         return;
       }
+      if (message.type === "scroll") {
+        void deps.terminalBackend.scroll(info.sessionName, message.mode, message.amount);
+        return;
+      }
       void deps.terminalBackend.sendControl(info.sessionName, message.key);
     });
     socket.on("close", () => {
@@ -2663,6 +2767,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;
@@ -2677,6 +2793,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,
@@ -2707,7 +2833,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";