termbridge 0.3.5 → 0.3.6

package/dist/bin.js

@@ -920,21 +920,21 @@ var require_react_development = __commonJS({
         );
         actScopeDepth = prevActScopeDepth;
       }
-      function recursivelyFlushAsyncActWork(returnValue, resolve4, reject) {
+      function recursivelyFlushAsyncActWork(returnValue, resolve5, reject) {
         var queue = ReactSharedInternals.actQueue;
         if (null !== queue)
           if (0 !== queue.length)
             try {
               flushActQueue(queue);
               enqueueTask(function() {
-                return recursivelyFlushAsyncActWork(returnValue, resolve4, reject);
+                return recursivelyFlushAsyncActWork(returnValue, resolve5, reject);
               });
               return;
             } catch (error) {
               ReactSharedInternals.thrownErrors.push(error);
             }
           else ReactSharedInternals.actQueue = null;
-        0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve4(returnValue);
+        0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve5(returnValue);
       }
       function flushActQueue(queue) {
         if (!isFlushing) {
@@ -1121,7 +1121,7 @@ var require_react_development = __commonJS({
             ));
           });
           return {
-            then: function(resolve4, reject) {
+            then: function(resolve5, reject) {
               didAwaitActCall = true;
               thenable.then(
                 function(returnValue) {
@@ -1131,7 +1131,7 @@ var require_react_development = __commonJS({
                       flushActQueue(queue), enqueueTask(function() {
                         return recursivelyFlushAsyncActWork(
                           returnValue,
-                          resolve4,
+                          resolve5,
                           reject
                         );
                       });
@@ -1145,7 +1145,7 @@ var require_react_development = __commonJS({
                       ReactSharedInternals.thrownErrors.length = 0;
                       reject(_thrownError);
                     }
-                  } else resolve4(returnValue);
+                  } else resolve5(returnValue);
                 },
                 function(error) {
                   popActScope(prevActQueue, prevActScopeDepth);
@@ -1167,15 +1167,15 @@ var require_react_development = __commonJS({
         if (0 < ReactSharedInternals.thrownErrors.length)
           throw callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
         return {
-          then: function(resolve4, reject) {
+          then: function(resolve5, reject) {
             didAwaitActCall = true;
             0 === prevActScopeDepth ? (ReactSharedInternals.actQueue = queue, enqueueTask(function() {
               return recursivelyFlushAsyncActWork(
                 returnValue$jscomp$0,
-                resolve4,
+                resolve5,
                 reject
               );
-            })) : resolve4(returnValue$jscomp$0);
+            })) : resolve5(returnValue$jscomp$0);
           }
         };
       };
@@ -1749,6 +1749,10 @@ var require_jsx_runtime = __commonJS({
   }
 });
 
+// src/bin.ts
+import { resolve as resolve4 } from "path";
+import { config as loadEnv } from "dotenv";
+
 // src/cli/run.ts
 import qrcode2 from "qrcode-terminal";
 
@@ -1820,12 +1824,16 @@ var parseArgs = (argv) => {
       options.noQr = true;
       continue;
     }
+    if (current === "--no-tunnel") {
+      options.tunnel = "none";
+      continue;
+    }
     if (current === "--tunnel") {
       const tunnel = args.shift();
-      if (tunnel !== "cloudflare") {
+      if (tunnel !== "cloudflare" && tunnel !== "none") {
         throw new Error("unsupported tunnel provider");
       }
-      options.tunnel = "cloudflare";
+      options.tunnel = tunnel;
       continue;
     }
     if (current === "--tunnel-token") {
@@ -1844,6 +1852,74 @@ var parseArgs = (argv) => {
       options.tunnelUrl = url;
       continue;
     }
+    if (current === "--public-url") {
+      const url = args.shift();
+      if (!url) {
+        throw new Error("missing public url");
+      }
+      options.publicUrl = url;
+      continue;
+    }
+    if (current === "--backend") {
+      const backend = args.shift();
+      if (!backend) {
+        throw new Error("missing backend");
+      }
+      if (backend !== "tmux" && backend !== "daytona") {
+        throw new Error("invalid backend");
+      }
+      options.backend = backend;
+      continue;
+    }
+    if (current === "--daytona-repo") {
+      const repo = args.shift();
+      if (!repo) {
+        throw new Error("missing daytona repo");
+      }
+      options.daytonaRepo = repo;
+      continue;
+    }
+    if (current === "--daytona-branch") {
+      const branch = args.shift();
+      if (!branch) {
+        throw new Error("missing daytona branch");
+      }
+      options.daytonaBranch = branch;
+      continue;
+    }
+    if (current === "--daytona-path") {
+      const path = args.shift();
+      if (!path) {
+        throw new Error("missing daytona path");
+      }
+      options.daytonaPath = path;
+      continue;
+    }
+    if (current === "--daytona-name") {
+      const name = args.shift();
+      if (!name) {
+        throw new Error("missing daytona name");
+      }
+      options.daytonaSandboxName = name;
+      continue;
+    }
+    if (current === "--daytona-preview-port") {
+      const port = parseNumber(args.shift());
+      if (!port || port <= 0) {
+        throw new Error("missing daytona preview port");
+      }
+      options.daytonaPreviewPort = port;
+      continue;
+    }
+    if (current === "--daytona-public") {
+      options.daytonaPublic = true;
+      continue;
+    }
+    if (current === "--daytona-direct") {
+      options.daytonaDirect = true;
+      options.tunnel = "none";
+      continue;
+    }
     throw new Error(`unknown option: ${current}`);
   }
   return { command, options };
@@ -1860,10 +1936,20 @@ Options:
   --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)
+  --public-url <url>  Public URL when tunnel is disabled
   --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
-  --tunnel <provider> Tunnel provider (cloudflare)
+  --no-tunnel         Disable tunnel (requires --public-url or TERMBRIDGE_PUBLIC_URL)
+  --backend <name>    Terminal backend (tmux | daytona)
+  --daytona-repo <u>  Git repo to clone into Daytona
+  --daytona-branch <b> Git branch to checkout in Daytona
+  --daytona-path <p>  Repo directory inside the sandbox
+  --daytona-name <n>  Daytona sandbox name
+  --daytona-preview-port <p> Preview port to expose from Daytona
+  --daytona-public    Make the Daytona sandbox preview public
+  --daytona-direct    Run the server inside the Daytona sandbox (no tunnel)
+  --tunnel <provider> Tunnel provider (cloudflare | none)
   -h, --help          Show this help message
 `;
 
@@ -1874,6 +1960,7 @@ import qrcode from "qrcode-terminal";
 // src/cli/start.ts
 import { resolve as resolve3, dirname as dirname2 } from "path";
 import { existsSync } from "fs";
+import { writeFile } from "fs/promises";
 import { fileURLToPath } from "url";
 
 // ../packages/terminal/src/index.ts
@@ -1902,6 +1989,7 @@ var defaultDeps = {
   env: process.env,
   defaultCols: 80,
   defaultRows: 24,
+  defaultCwd: void 0,
   _skipSpawnHelperCheck: false
 };
 var ensureSpawnHelperExecutable = () => {
@@ -1939,8 +2027,12 @@ var createTmuxBackend = (deps = {}) => {
     if (existing) {
       return existing.session;
     }
+    const newSessionArgs = ["new-session", "-d", "-s", name];
+    if (runtime.defaultCwd) {
+      newSessionArgs.push("-c", runtime.defaultCwd);
+    }
     try {
-      await runTmux(["new-session", "-d", "-s", name]);
+      await runTmux(newSessionArgs);
     } catch (error) {
       try {
         await runTmux(["has-session", "-t", name]);
@@ -2130,7 +2222,7 @@ var createCloudflaredProvider = (deps = {}) => {
     let stdoutCarry = "";
     let stderrCarry = "";
     const errorLines = [];
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       let resolved = false;
       let resolveTimer = null;
       const resolveOnce = (url) => {
@@ -2142,7 +2234,7 @@ var createCloudflaredProvider = (deps = {}) => {
           clearTimeout(resolveTimer);
           resolveTimer = null;
         }
-        resolve4({ publicUrl: url });
+        resolve5({ publicUrl: url });
       };
       const handleLine = (line) => {
         const cleaned = normalizeLine(line);
@@ -2364,6 +2456,7 @@ var createTerminalRegistry = () => {
 
 // src/server/server.ts
 import { createServer as createHttpServer, request as httpRequest } from "http";
+import { request as httpsRequest } from "https";
 import { randomBytes as randomBytes3 } from "crypto";
 import { WebSocketServer, WebSocket as WsWebSocket } from "ws";
 
@@ -2508,13 +2601,33 @@ var createAppServer = (deps) => {
   const staticHandler = createStaticHandler(deps.uiDistPath, "/__tb/app");
   const wss = new WebSocketServer({ noServer: true });
   const connectionInfo = /* @__PURE__ */ new WeakMap();
+  const hasProxy = typeof deps.proxyPort === "number" || deps.devProxyUrl !== void 0;
+  const resolveProxyUrl = (targetPath, search) => {
+    if (typeof deps.proxyPort === "number") {
+      return new URL(`http://localhost:${deps.proxyPort}${targetPath}${search}`);
+    }
+    if (deps.devProxyUrl) {
+      try {
+        return new URL(`${targetPath}${search}`, deps.devProxyUrl);
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  };
   const proxyRequest = (request, response, targetPath, search) => {
-    const targetUrl = `http://localhost:${deps.proxyPort}${targetPath}${search}`;
-    const proxyHeaders = { ...request.headers };
+    const targetUrl = resolveProxyUrl(targetPath, search);
+    if (!targetUrl) {
+      response.statusCode = 502;
+      response.end("proxy error");
+      return;
+    }
+    const proxyHeaders = { ...request.headers, ...deps.devProxyHeaders ?? {} };
     delete proxyHeaders.cookie;
     delete proxyHeaders.host;
-    proxyHeaders.host = `localhost:${deps.proxyPort}`;
-    const proxyReq = httpRequest(
+    proxyHeaders.host = targetUrl.host;
+    const requestImpl = targetUrl.protocol === "https:" ? httpsRequest : httpRequest;
+    const proxyReq = requestImpl(
       targetUrl,
       { method: request.method, headers: proxyHeaders },
       (proxyRes) => {
@@ -2535,7 +2648,7 @@ var createAppServer = (deps) => {
       response.end("ok");
       return;
     }
-    if (request.method === "GET" && url.pathname === "/" && !deps.proxyPort) {
+    if (request.method === "GET" && url.pathname === "/" && !hasProxy) {
       response.statusCode = 302;
       response.setHeader("Location", "/__tb/app");
       response.end();
@@ -2616,13 +2729,14 @@ var createAppServer = (deps) => {
       }
       jsonResponse(response, 200, {
         proxyPort: deps.proxyPort ?? null,
-        devProxyUrl: deps.devProxyUrl ?? null
+        devProxyUrl: deps.devProxyUrl ?? null,
+        hideTerminalSwitcher: Boolean(deps.hideTerminalSwitcher)
       });
       return;
     }
     const handled = await staticHandler(request, response);
     if (!handled) {
-      if (deps.proxyPort && deps.auth.getSessionFromRequest(request)) {
+      if (hasProxy && deps.auth.getSessionFromRequest(request)) {
         proxyRequest(request, response, url.pathname, url.search);
         return;
       }
@@ -2633,9 +2747,22 @@ var createAppServer = (deps) => {
   server.on("upgrade", (request, socket, head) => {
     const url = new URL(request.url, `http://${request.headers.host}`);
     if (!url.pathname.startsWith("/__tb/ws/terminal/")) {
-      if (deps.proxyPort && deps.auth.getSessionFromRequest(request)) {
-        const targetUrl = `ws://localhost:${deps.proxyPort}${url.pathname}${url.search}`;
-        const proxyWs = new WsWebSocket(targetUrl);
+      if (hasProxy && deps.auth.getSessionFromRequest(request)) {
+        let baseUrl = null;
+        try {
+          baseUrl = typeof deps.proxyPort === "number" ? new URL(`http://localhost:${deps.proxyPort}`) : new URL(deps.devProxyUrl);
+        } catch {
+          socket.destroy();
+          return;
+        }
+        const wsProtocol = baseUrl.protocol === "https:" ? "wss:" : "ws:";
+        const targetUrl = new URL(`${url.pathname}${url.search}`, baseUrl);
+        targetUrl.protocol = wsProtocol;
+        const proxyHeaders = { ...request.headers, ...deps.devProxyHeaders ?? {} };
+        delete proxyHeaders.cookie;
+        delete proxyHeaders.host;
+        proxyHeaders.host = targetUrl.host;
+        const proxyWs = new WsWebSocket(targetUrl.toString(), { headers: proxyHeaders });
         proxyWs.on("open", () => {
           wss.handleUpgrade(request, socket, head, (clientWs) => {
             clientWs.on("message", (data) => proxyWs.send(data));
@@ -2721,10 +2848,10 @@ var createAppServer = (deps) => {
       unsubscribe();
     });
   });
-  const listen = (port) => new Promise((resolve4, _reject) => {
+  const listen = (port) => new Promise((resolve5, _reject) => {
     server.listen(port, "127.0.0.1", () => {
       const address = server.address();
-      resolve4({
+      resolve5({
         port: address.port,
         close: async () => {
           await new Promise((closeResolve) => server.close(() => closeResolve()));
@@ -2736,6 +2863,459 @@ var createAppServer = (deps) => {
   return { listen };
 };
 
+// src/daytona/daytona-backend.ts
+import { randomBytes as randomBytes4 } from "crypto";
+import { Daytona } from "@daytonaio/sdk";
+var controlKeyMap2 = {
+  ctrl_c: "",
+  esc: "\x1B",
+  tab: "	",
+  up: "\x1B[A",
+  down: "\x1B[B",
+  left: "\x1B[D",
+  right: "\x1B[C"
+};
+var noopLogger = {
+  info: () => void 0,
+  warn: () => void 0,
+  error: () => void 0
+};
+var deriveRepoPath = (repoUrl) => {
+  const trimmed = repoUrl.replace(/\/$/, "");
+  const last = trimmed.split("/").pop();
+  if (!last) {
+    return "repo";
+  }
+  return last.endsWith(".git") ? last.slice(0, -4) : last;
+};
+var createDaytonaBackend = (options) => {
+  const logger = options.logger ?? noopLogger;
+  const sessions = /* @__PURE__ */ new Map();
+  const daytona = new Daytona({
+    apiKey: options.apiKey,
+    apiUrl: options.apiUrl,
+    target: options.target
+  });
+  let sandboxRef = null;
+  let sandboxInit = null;
+  const ensureSandbox = async () => {
+    if (!sandboxInit) {
+      sandboxInit = (async () => {
+        try {
+          const name = options.sandboxName ?? `termbridge-${randomBytes4(4).toString("hex")}`;
+          logger.info(`Daytona: creating sandbox ${name}`);
+          const sandbox = await daytona.create({ name, public: options.public });
+          await sandbox.start();
+          const repoPath = options.repoPath ?? deriveRepoPath(options.repoUrl);
+          logger.info(`Daytona: cloning ${options.repoUrl}`);
+          await sandbox.git.clone(
+            options.repoUrl,
+            repoPath,
+            options.repoBranch,
+            void 0,
+            options.gitUsername,
+            options.gitPassword
+          );
+          sandboxRef = sandbox;
+          logger.info(`Daytona: repo ready at ${repoPath}`);
+          return { sandbox, repoPath };
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "unknown error";
+          logger.error(`Daytona: sandbox init failed (${message})`);
+          throw error;
+        }
+      })();
+    }
+    return sandboxInit;
+  };
+  const ensurePty = async (entry) => {
+    if (entry.handle) {
+      return entry.handle;
+    }
+    const { sandbox, repoPath } = await ensureSandbox();
+    const handle = await sandbox.process.createPty({
+      id: entry.session.name,
+      cwd: repoPath,
+      cols: entry.cols,
+      rows: entry.rows,
+      envs: {
+        TERM: "xterm-256color",
+        COLORTERM: "truecolor"
+      },
+      onData: (data) => {
+        if (!sessions.has(entry.session.name)) {
+          return;
+        }
+        const text = Buffer.from(data).toString("utf8");
+        if (!text) {
+          return;
+        }
+        for (const subscriber of entry.subscribers) {
+          subscriber(text);
+        }
+      }
+    });
+    await handle.waitForConnection();
+    entry.handle = handle;
+    return handle;
+  };
+  const createSession = async (name) => {
+    const existing = sessions.get(name);
+    if (existing) {
+      return existing.session;
+    }
+    const entry = {
+      session: { name, createdAt: /* @__PURE__ */ new Date() },
+      handle: null,
+      subscribers: /* @__PURE__ */ new Set(),
+      cols: 80,
+      rows: 24
+    };
+    sessions.set(name, entry);
+    await ensurePty(entry);
+    return entry.session;
+  };
+  const write = async (sessionName, data) => {
+    if (!data) {
+      return;
+    }
+    const entry = sessions.get(sessionName);
+    if (!entry) {
+      return;
+    }
+    const handle = await ensurePty(entry);
+    await handle.sendInput(data);
+  };
+  const resize = async (sessionName, cols, rows) => {
+    const entry = sessions.get(sessionName);
+    if (!entry) {
+      return;
+    }
+    entry.cols = cols;
+    entry.rows = rows;
+    if (!entry.handle) {
+      return;
+    }
+    await entry.handle.resize(cols, rows);
+  };
+  const sendControl = async (sessionName, key) => {
+    const entry = sessions.get(sessionName);
+    if (!entry) {
+      return;
+    }
+    const handle = await ensurePty(entry);
+    const controlSequence = controlKeyMap2[key];
+    await handle.sendInput(controlSequence);
+  };
+  const scroll = async (_sessionName, _mode, _amount) => {
+    return;
+  };
+  const onOutput = (sessionName, callback) => {
+    const entry = sessions.get(sessionName);
+    if (!entry) {
+      return () => void 0;
+    }
+    entry.subscribers.add(callback);
+    return () => {
+      entry.subscribers.delete(callback);
+    };
+  };
+  const closeSession = async (sessionName) => {
+    const entry = sessions.get(sessionName);
+    if (!entry) {
+      return;
+    }
+    sessions.delete(sessionName);
+    if (entry.handle) {
+      try {
+        await entry.handle.kill();
+      } catch {
+      }
+      try {
+        await entry.handle.disconnect();
+      } catch {
+      }
+    }
+  };
+  const shutdown = async () => {
+    const names = Array.from(sessions.keys());
+    await Promise.all(names.map((name) => closeSession(name)));
+    if (!sandboxRef) {
+      return;
+    }
+    try {
+      await sandboxRef.stop();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "unknown error";
+      logger.warn(`Daytona: stop failed (${message})`);
+    }
+    if (options.deleteOnExit) {
+      try {
+        await daytona.delete(sandboxRef);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "unknown error";
+        logger.warn(`Daytona: delete failed (${message})`);
+      }
+    }
+  };
+  return {
+    createSession,
+    write,
+    resize,
+    sendControl,
+    scroll,
+    onOutput,
+    closeSession,
+    shutdown,
+    getPreviewUrl: async (port) => {
+      const { sandbox } = await ensureSandbox();
+      try {
+        const preview = await sandbox.getPreviewLink(port);
+        if (!preview.url) {
+          return null;
+        }
+        const headers = {};
+        if (preview.token) {
+          headers["x-daytona-preview-token"] = preview.token;
+        }
+        headers["x-daytona-skip-preview-warning"] = "true";
+        return { url: preview.url, headers };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "unknown error";
+        logger.warn(`Daytona: preview failed (${message})`);
+        return null;
+      }
+    }
+  };
+};
+
+// src/daytona/daytona-direct.ts
+import { randomBytes as randomBytes5 } from "crypto";
+import { Daytona as Daytona2 } from "@daytonaio/sdk";
+var noopLogger2 = {
+  info: () => void 0,
+  warn: () => void 0,
+  error: () => void 0
+};
+var deriveRepoPath2 = (repoUrl) => {
+  const trimmed = repoUrl.replace(/\/$/, "");
+  const last = trimmed.split("/").pop();
+  if (!last) {
+    return "repo";
+  }
+  return last.endsWith(".git") ? last.slice(0, -4) : last;
+};
+var normalizePublicUrl = (value) => {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    throw new Error("missing public url");
+  }
+  let parsed;
+  try {
+    parsed = new URL(trimmed);
+  } catch {
+    throw new Error("invalid public url");
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error("invalid public url");
+  }
+  return trimmed.endsWith("/") ? trimmed.slice(0, -1) : trimmed;
+};
+var delay = (ms) => new Promise((resolve5) => setTimeout(resolve5, ms));
+var ensureTmux = async (sandbox, logger) => {
+  const check = await sandbox.process.executeCommand("command -v tmux");
+  if (check.exitCode === 0) {
+    return;
+  }
+  logger.info("Daytona: installing tmux");
+  const installScript = [
+    "set -e",
+    'SUDO=""',
+    'if command -v sudo >/dev/null 2>&1; then SUDO="sudo"; fi',
+    "if command -v apt-get >/dev/null 2>&1; then $SUDO apt-get update -y && $SUDO apt-get install -y tmux;",
+    "elif command -v apk >/dev/null 2>&1; then $SUDO apk add --no-cache tmux;",
+    "elif command -v dnf >/dev/null 2>&1; then $SUDO dnf install -y tmux;",
+    "elif command -v yum >/dev/null 2>&1; then $SUDO yum install -y tmux;",
+    "else echo 'tmux install failed: no supported package manager'; exit 1; fi"
+  ].join(" ");
+  const result = await sandbox.process.executeCommand(installScript);
+  if (result.exitCode !== 0) {
+    throw new Error("tmux install failed");
+  }
+};
+var resolvePreviewUrl = async (sandbox, port, logger) => {
+  const preview = await sandbox.getPreviewLink(port);
+  if (!preview.url) {
+    throw new Error("Daytona preview url unavailable");
+  }
+  if (preview.token) {
+    try {
+      const signed = await sandbox.getSignedPreviewUrl(port, 60 * 60 * 24);
+      if (signed.url) {
+        return signed.url;
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "unknown error";
+      logger.warn(`Daytona: signed preview url failed (${message})`);
+    }
+  }
+  return preview.url;
+};
+var readShareUrl = async (sandbox, path, timeoutMs) => {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      const contents = await sandbox.fs.downloadFile(path);
+      const text = contents.toString("utf8").trim();
+      if (text) {
+        return text.split(/\s+/)[0];
+      }
+    } catch {
+    }
+    await delay(500);
+  }
+  throw new Error("share url unavailable");
+};
+var parseShareUrl = (shareUrl) => {
+  const trimmed = shareUrl.trim();
+  const marker = "/__tb/s/";
+  const index = trimmed.indexOf(marker);
+  if (index === -1) {
+    throw new Error("invalid share url");
+  }
+  const publicUrl = trimmed.slice(0, index);
+  const token = trimmed.slice(index + marker.length);
+  if (!publicUrl || !token) {
+    throw new Error("invalid share url");
+  }
+  return { publicUrl, token };
+};
+var buildEnv = (values) => Object.fromEntries(
+  Object.entries(values).filter(([, value]) => typeof value === "string" && value.length > 0)
+);
+var createDaytonaSandboxServerProvider = (options = {}) => {
+  const baseLogger = options.logger ?? noopLogger2;
+  const daytona = new Daytona2({
+    apiKey: options.apiKey,
+    apiUrl: options.apiUrl,
+    target: options.target
+  });
+  return {
+    start: async (startOptions) => {
+      const logger = startOptions.logger ?? baseLogger;
+      let sandboxRef = null;
+      try {
+        const name = startOptions.sandboxName ?? `termbridge-${randomBytes5(4).toString("hex")}`;
+        logger.info(`Daytona: creating sandbox ${name}`);
+        const sandbox = await daytona.create({ name, public: startOptions.public });
+        sandboxRef = sandbox;
+        await sandbox.start();
+        const repoPath = startOptions.repoPath ?? deriveRepoPath2(startOptions.repoUrl);
+        logger.info(`Daytona: cloning ${startOptions.repoUrl}`);
+        await sandbox.git.clone(
+          startOptions.repoUrl,
+          repoPath,
+          startOptions.repoBranch,
+          void 0,
+          startOptions.gitUsername,
+          startOptions.gitPassword
+        );
+        const workDir = await sandbox.getWorkDir();
+        const repoDir = repoPath.startsWith("/") ? repoPath : workDir ? `${workDir.replace(/\/$/, "")}/${repoPath}` : repoPath;
+        await ensureTmux(sandbox, logger);
+        const publicUrl = normalizePublicUrl(
+          await resolvePreviewUrl(sandbox, startOptions.serverPort, logger)
+        );
+        const runId = randomBytes5(4).toString("hex");
+        const shareFile = `/tmp/termbridge-share-${runId}.txt`;
+        const pidFile = `/tmp/termbridge-${runId}.pid`;
+        const logFile = `/tmp/termbridge-${runId}.log`;
+        const args = [
+          "npx",
+          "termbridge",
+          "start",
+          "--port",
+          String(startOptions.serverPort),
+          "--no-qr",
+          "--tunnel",
+          "none"
+        ];
+        if (startOptions.proxyPort) {
+          args.push("--proxy", String(startOptions.proxyPort));
+        }
+        if (startOptions.sessionName) {
+          args.push("--session", startOptions.sessionName);
+        }
+        if (startOptions.killOnExit) {
+          args.push("--kill-on-exit");
+        }
+        const env = buildEnv({
+          TERMBRIDGE_BACKEND: "tmux",
+          TERMBRIDGE_PUBLIC_URL: publicUrl,
+          TERMBRIDGE_SHARE_FILE: shareFile,
+          TERMBRIDGE_TMUX_CWD: repoDir,
+          TERMBRIDGE_HIDE_TERMINAL_SWITCHER: startOptions.hideTerminalSwitcher ? "1" : void 0
+        });
+        const startCommand2 = `nohup ${args.join(" ")} > ${logFile} 2>&1 & echo $! > ${pidFile}`;
+        await sandbox.process.executeCommand(startCommand2, repoDir, env);
+        logger.info("Daytona: waiting for share url");
+        const shareUrl = await readShareUrl(sandbox, shareFile, 9e4);
+        const parsed = parseShareUrl(shareUrl);
+        const stop = async () => {
+          try {
+            const pidBuffer = await sandbox.fs.downloadFile(pidFile);
+            const pid = Number.parseInt(pidBuffer.toString("utf8").trim(), 10);
+            if (Number.isFinite(pid)) {
+              await sandbox.process.executeCommand(`kill ${pid}`);
+            }
+          } catch {
+          }
+          try {
+            await sandbox.stop();
+          } catch (error) {
+            const message = error instanceof Error ? error.message : "unknown error";
+            logger.warn(`Daytona: stop failed (${message})`);
+          }
+          if (startOptions.deleteOnExit) {
+            try {
+              await daytona.delete(sandbox);
+            } catch (error) {
+              const message = error instanceof Error ? error.message : "unknown error";
+              logger.warn(`Daytona: delete failed (${message})`);
+            }
+          }
+        };
+        return {
+          localUrl: parsed.publicUrl,
+          publicUrl: parsed.publicUrl,
+          token: parsed.token,
+          stop
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "unknown error";
+        logger.error(`Daytona: sandbox start failed (${message})`);
+        if (sandboxRef) {
+          try {
+            await sandboxRef.stop();
+          } catch (stopError) {
+            const message2 = stopError instanceof Error ? stopError.message : "unknown error";
+            baseLogger.warn(`Daytona: stop failed (${message2})`);
+          }
+          if (startOptions.deleteOnExit) {
+            try {
+              await daytona.delete(sandboxRef);
+            } catch (deleteError) {
+              const message2 = deleteError instanceof Error ? deleteError.message : "unknown error";
+              baseLogger.warn(`Daytona: delete failed (${message2})`);
+            }
+          }
+        }
+        throw error;
+      }
+    }
+  };
+};
+
 // src/cli/start.ts
 var resolveUiDistPath = () => {
   const currentDir = dirname2(fileURLToPath(import.meta.url));
@@ -2767,7 +3347,38 @@ var parseSessionCount = (value) => {
   }
   return parsed;
 };
-var normalizePublicUrl = (value) => {
+var parseBoolean = (value) => {
+  if (!value) {
+    return false;
+  }
+  const normalized = value.trim().toLowerCase();
+  return normalized === "1" || normalized === "true" || normalized === "yes";
+};
+var parseOptionalNumber = (value) => {
+  if (!value) {
+    return void 0;
+  }
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) ? parsed : void 0;
+};
+var resolveBackendMode = (value) => {
+  if (!value) {
+    return "tmux";
+  }
+  if (value === "tmux" || value === "daytona") {
+    return value;
+  }
+  throw new Error("invalid backend");
+};
+var deriveRepoPath3 = (repoUrl) => {
+  const trimmed = repoUrl.replace(/\/$/, "");
+  const last = trimmed.split("/").pop();
+  if (!last) {
+    return "repo";
+  }
+  return last.endsWith(".git") ? last.slice(0, -4) : last;
+};
+var normalizePublicUrl2 = (value) => {
   let parsed;
   try {
     parsed = new URL(value);
@@ -2779,6 +3390,38 @@ var normalizePublicUrl = (value) => {
   }
   return value.endsWith("/") ? value.slice(0, -1) : value;
 };
+var normalizeExternalUrl = (value) => {
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch {
+    throw new Error("invalid public url");
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error("invalid public url");
+  }
+  return value.endsWith("/") ? value.slice(0, -1) : value;
+};
+var resolveTunnelMode = (value) => {
+  if (!value) {
+    return "cloudflare";
+  }
+  if (value === "cloudflare" || value === "none") {
+    return value;
+  }
+  throw new Error("invalid tunnel provider");
+};
+var maybeWriteShareFile = async (path, url, logger) => {
+  if (!path) {
+    return;
+  }
+  try {
+    await writeFile(path, url, "utf8");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "unknown error";
+    logger.warn(`Share file write failed (${message})`);
+  }
+};
 var startCommand = async (options, deps = {}) => {
   const logger = deps.logger ?? createDefaultLogger();
   const processRef = deps.process ?? process;
@@ -2790,17 +3433,106 @@ var startCommand = async (options, deps = {}) => {
     sessionMaxMs: 8 * 60 * 6e4,
     cookieSecure: !insecureCookie
   })))();
-  const terminalBackend = (deps.createTerminalBackend ?? (() => createTmuxBackend()))();
+  const backendMode = resolveBackendMode(options.backend ?? env.TERMBRIDGE_BACKEND);
+  const daytonaDirect = options.daytonaDirect ?? parseBoolean(env.TERMBRIDGE_DAYTONA_DIRECT);
+  const publicUrlOverride = options.publicUrl ?? env.TERMBRIDGE_PUBLIC_URL;
+  const hideTerminalSwitcher = parseBoolean(env.TERMBRIDGE_HIDE_TERMINAL_SWITCHER);
+  const tmuxCwd = env.TERMBRIDGE_TMUX_CWD;
+  const daytonaRepo = options.daytonaRepo ?? env.TERMBRIDGE_DAYTONA_REPO ?? "https://github.com/inline0/termbridge-test-app.git";
+  const daytonaPreviewPort = options.daytonaPreviewPort ?? parseOptionalNumber(env.TERMBRIDGE_DAYTONA_PREVIEW_PORT);
+  const daytonaPublic = options.daytonaPublic ?? parseBoolean(env.TERMBRIDGE_DAYTONA_PUBLIC);
+  const daytonaDeleteOnExit = parseBoolean(env.TERMBRIDGE_DAYTONA_DELETE_ON_EXIT);
+  const daytonaConfig = {
+    apiKey: env.DAYTONA_API_KEY,
+    apiUrl: env.DAYTONA_API_URL,
+    target: env.DAYTONA_TARGET,
+    repoUrl: daytonaRepo,
+    repoBranch: options.daytonaBranch ?? env.TERMBRIDGE_DAYTONA_BRANCH,
+    repoPath: options.daytonaPath ?? env.TERMBRIDGE_DAYTONA_PATH ?? deriveRepoPath3(daytonaRepo),
+    sandboxName: options.daytonaSandboxName ?? env.TERMBRIDGE_DAYTONA_NAME,
+    public: daytonaPublic,
+    deleteOnExit: daytonaDeleteOnExit,
+    gitUsername: env.TERMBRIDGE_DAYTONA_GIT_USERNAME,
+    gitPassword: env.TERMBRIDGE_DAYTONA_GIT_PASSWORD ?? env.TERMBRIDGE_DAYTONA_GIT_TOKEN,
+    logger
+  };
+  if (backendMode === "daytona" && daytonaDirect) {
+    const serverPort = options.port ?? parseOptionalNumber(env.TERMBRIDGE_DAYTONA_SERVER_PORT) ?? 8080;
+    const proxyPort = options.proxy ?? daytonaPreviewPort;
+    const sandboxProvider = (deps.createSandboxProvider ?? createDaytonaSandboxServerProvider)({
+      apiKey: daytonaConfig.apiKey,
+      apiUrl: daytonaConfig.apiUrl,
+      target: daytonaConfig.target,
+      logger
+    });
+    const result = await sandboxProvider.start({
+      repoUrl: daytonaConfig.repoUrl,
+      repoBranch: daytonaConfig.repoBranch,
+      repoPath: daytonaConfig.repoPath,
+      sandboxName: daytonaConfig.sandboxName,
+      public: daytonaConfig.public,
+      deleteOnExit: daytonaConfig.deleteOnExit,
+      gitUsername: daytonaConfig.gitUsername,
+      gitPassword: daytonaConfig.gitPassword,
+      serverPort,
+      proxyPort,
+      sessionName: options.session,
+      killOnExit: options.killOnExit,
+      hideTerminalSwitcher: true,
+      logger
+    });
+    const redeemUrl2 = `${result.publicUrl}/__tb/s/${result.token}`;
+    logger.info(`Public URL: ${result.publicUrl}`);
+    logger.info(`Share URL: ${redeemUrl2}`);
+    if (!options.noQr && deps.qr) {
+      deps.qr.generate(redeemUrl2, { small: true });
+    } else if (!options.noQr) {
+      logger.warn("QR output unavailable");
+    }
+    const shutdown2 = () => {
+      void result.stop();
+    };
+    processRef.on("SIGINT", shutdown2);
+    processRef.on("SIGTERM", shutdown2);
+    return result;
+  }
+  const tunnelMode = resolveTunnelMode(env.TERMBRIDGE_TUNNEL ?? options.tunnel);
+  const terminalBackend = backendMode === "daytona" ? (deps.createDaytonaBackend ?? createDaytonaBackend)(daytonaConfig) : (deps.createTerminalBackend ?? (() => createTmuxBackend({ defaultCwd: tmuxCwd })))();
   const terminalRegistry = (deps.createTerminalRegistry ?? (() => createTerminalRegistry()))();
-  const tunnelProvider = (deps.createTunnelProvider ?? (() => createCloudflaredProvider()))();
+  const tunnelProvider = tunnelMode === "cloudflare" ? (deps.createTunnelProvider ?? (() => createCloudflaredProvider()))() : null;
   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) {
+  const tunnelUrl = tunnelToken && tunnelUrlRaw ? normalizePublicUrl2(tunnelUrlRaw) : void 0;
+  let devProxyUrl = options.devProxyUrl;
+  let devProxyHeaders;
+  let publicUrl = "";
+  if (tunnelMode === "none") {
+    if (!publicUrlOverride) {
+      throw new Error("public url required when tunnel disabled");
+    }
+    if (tunnelToken || tunnelUrlRaw) {
+      throw new Error("tunnel token/url not supported when tunnel disabled");
+    }
+    publicUrl = normalizeExternalUrl(publicUrlOverride);
+  }
+  if (!devProxyUrl && backendMode === "daytona" && daytonaPreviewPort) {
+    const previewInfo = await terminalBackend.getPreviewUrl?.(daytonaPreviewPort);
+    if (previewInfo) {
+      if (typeof previewInfo === "string") {
+        devProxyUrl = previewInfo;
+      } else {
+        devProxyUrl = previewInfo.url;
+        devProxyHeaders = previewInfo.headers;
+      }
+    } else {
+      logger.warn("Daytona: preview URL unavailable");
+    }
+  }
+  if (tunnelMode === "cloudflare" && tunnelToken && !options.port) {
     throw new Error("port required when using tunnel token");
   }
-  if (tunnelToken && !tunnelUrl) {
+  if (tunnelMode === "cloudflare" && tunnelToken && !tunnelUrl) {
     throw new Error("tunnel url required when using tunnel token");
   }
   const wsLimiter = createRateLimiter({ limit: 30, windowMs: 6e4 });
@@ -2816,50 +3548,68 @@ var startCommand = async (options, deps = {}) => {
     terminalRegistry,
     terminalBackend,
     proxyPort: options.proxy,
-    devProxyUrl: options.devProxyUrl
+    devProxyUrl,
+    devProxyHeaders,
+    hideTerminalSwitcher
   });
   const started = await server.listen(options.port ?? 0);
   const localUrl = `http://127.0.0.1:${started.port}`;
   const sessionName = options.session ?? `termbridge-${started.port}`;
   const sessionCount = parseSessionCount(env.TERMBRIDGE_SESSIONS);
   const createdSessions = [];
+  const terminalSource = backendMode === "daytona" ? "daytona" : "tmux";
   for (let index = 0; index < sessionCount; index += 1) {
     const suffix = index === 0 ? "" : `-${index + 1}`;
     const nextName = `${sessionName}${suffix}`;
     const session = await terminalBackend.createSession(nextName);
-    terminalRegistry.add(session.name, session.name, "tmux");
+    terminalRegistry.add(session.name, session.name, terminalSource);
     createdSessions.push(session.name);
   }
   const { token } = auth.issueToken();
-  let publicUrl = "";
-  try {
-    const result = await tunnelProvider.start(localUrl, {
-      token: tunnelToken,
-      publicUrl: tunnelUrl
-    });
-    publicUrl = result.publicUrl;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "unknown error";
-    logger.error(`Tunnel failed: ${message}`);
-    await started.close();
-    throw error;
+  if (tunnelMode === "cloudflare") {
+    if (!tunnelProvider) {
+      throw new Error("tunnel provider unavailable");
+    }
+    try {
+      const result = await tunnelProvider.start(localUrl, {
+        token: tunnelToken,
+        publicUrl: tunnelUrl
+      });
+      publicUrl = result.publicUrl;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "unknown error";
+      logger.error(`Tunnel failed: ${message}`);
+      await started.close();
+      throw error;
+    }
   }
   const redeemUrl = `${publicUrl}/__tb/s/${token}`;
+  await maybeWriteShareFile(env.TERMBRIDGE_SHARE_FILE, redeemUrl, logger);
   logger.info(`Local server: ${localUrl}`);
-  logger.info(`Tunnel URL: ${redeemUrl}`);
+  if (tunnelMode === "cloudflare") {
+    logger.info(`Tunnel URL: ${redeemUrl}`);
+  } else {
+    logger.info(`Public URL: ${publicUrl}`);
+    logger.info(`Share URL: ${redeemUrl}`);
+  }
   if (!options.noQr && deps.qr) {
     deps.qr.generate(redeemUrl, { small: true });
   } else if (!options.noQr) {
     logger.warn("QR output unavailable");
   }
   const stop = async () => {
-    await tunnelProvider.stop();
+    if (tunnelProvider) {
+      await tunnelProvider.stop();
+    }
     await started.close();
     if (options.killOnExit) {
       for (const name of createdSessions) {
         await terminalBackend.closeSession(name);
       }
     }
+    if (terminalBackend.shutdown) {
+      await terminalBackend.shutdown();
+    }
   };
   const shutdown = () => {
     void stop();
@@ -2929,8 +3679,8 @@ var buildSessionName = (options, localUrl) => {
   }
 };
 var buildRedeemUrl = (result) => `${result.publicUrl}/__tb/s/${result.token}`;
-var generateQr = async (text) => new Promise((resolve4) => {
-  qrcode.generate(text, { small: true }, (output) => resolve4(output));
+var generateQr = async (text) => new Promise((resolve5) => {
+  qrcode.generate(text, { small: true }, (output) => resolve5(output));
 });
 var runInkCli = async (options, deps = {}) => {
   const processRef = deps.process ?? process;
@@ -3015,6 +3765,9 @@ var runCli = async (argv, deps = {}) => {
 };
 
 // src/bin.ts
+if (process.env.NODE_ENV !== "test") {
+  loadEnv({ path: resolve4(process.cwd(), ".env") });
+}
 var main = async (argv = process.argv.slice(2), proc = process) => {
   const exitCode = await runCli(argv, { process: proc, stdout: proc.stdout, stderr: proc.stderr });
   proc.exitCode = exitCode;