@openacp/cli 0.2.16 → 0.2.18

package/dist/tunnel-service-FPRPBPQ5.js

@@ -0,0 +1,633 @@
+import {
+  createChildLogger
+} from "./chunk-ZATQZUJT.js";
+
+// src/tunnel/tunnel-service.ts
+import { serve } from "@hono/node-server";
+
+// src/tunnel/providers/cloudflare.ts
+import { spawn } from "child_process";
+var log = createChildLogger({ module: "cloudflare-tunnel" });
+var CloudflareTunnelProvider = class {
+  child = null;
+  publicUrl = "";
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  async start(localPort) {
+    const args = ["tunnel", "--url", `http://localhost:${localPort}`];
+    if (this.options.domain) {
+      args.push("--hostname", String(this.options.domain));
+    }
+    return new Promise((resolve2, reject) => {
+      const timeout = setTimeout(() => {
+        this.stop();
+        reject(new Error("Cloudflare tunnel timed out after 30s. Is cloudflared installed?"));
+      }, 3e4);
+      try {
+        this.child = spawn("cloudflared", args, { stdio: ["ignore", "pipe", "pipe"] });
+      } catch {
+        clearTimeout(timeout);
+        reject(new Error(
+          "Failed to start cloudflared. Install it from https://developers.cloudflare.com/cloudflare-one/connections/connect-apps/install-and-setup/installation/"
+        ));
+        return;
+      }
+      const urlPattern = /https:\/\/[a-zA-Z0-9-]+\.trycloudflare\.com/;
+      const onData = (data) => {
+        const line = data.toString();
+        log.debug(line.trim());
+        const match = line.match(urlPattern);
+        if (match) {
+          clearTimeout(timeout);
+          this.publicUrl = match[0];
+          log.info({ url: this.publicUrl }, "Cloudflare tunnel ready");
+          resolve2(this.publicUrl);
+        }
+      };
+      this.child.stdout?.on("data", onData);
+      this.child.stderr?.on("data", onData);
+      this.child.on("error", (err) => {
+        clearTimeout(timeout);
+        reject(new Error(
+          `cloudflared failed to start: ${err.message}. Install it from https://developers.cloudflare.com/cloudflare-one/connections/connect-apps/install-and-setup/installation/`
+        ));
+      });
+      this.child.on("exit", (code) => {
+        if (!this.publicUrl) {
+          clearTimeout(timeout);
+          reject(new Error(`cloudflared exited with code ${code} before establishing tunnel`));
+        }
+      });
+    });
+  }
+  async stop() {
+    if (this.child) {
+      this.child.kill("SIGTERM");
+      this.child = null;
+      log.info("Cloudflare tunnel stopped");
+    }
+  }
+  getPublicUrl() {
+    return this.publicUrl;
+  }
+};
+
+// src/tunnel/viewer-store.ts
+import * as path from "path";
+import { nanoid } from "nanoid";
+var log2 = createChildLogger({ module: "viewer-store" });
+var MAX_CONTENT_SIZE = 1e6;
+var EXTENSION_LANGUAGE = {
+  ".ts": "typescript",
+  ".tsx": "typescript",
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".py": "python",
+  ".rs": "rust",
+  ".go": "go",
+  ".java": "java",
+  ".kt": "kotlin",
+  ".rb": "ruby",
+  ".php": "php",
+  ".c": "c",
+  ".cpp": "cpp",
+  ".h": "c",
+  ".hpp": "cpp",
+  ".cs": "csharp",
+  ".swift": "swift",
+  ".sh": "bash",
+  ".zsh": "bash",
+  ".bash": "bash",
+  ".json": "json",
+  ".yaml": "yaml",
+  ".yml": "yaml",
+  ".toml": "toml",
+  ".xml": "xml",
+  ".html": "html",
+  ".css": "css",
+  ".scss": "scss",
+  ".sql": "sql",
+  ".md": "markdown",
+  ".dockerfile": "dockerfile",
+  ".tf": "hcl",
+  ".vue": "xml",
+  ".svelte": "xml"
+};
+var ViewerStore = class {
+  entries = /* @__PURE__ */ new Map();
+  cleanupTimer;
+  ttlMs;
+  constructor(ttlMinutes = 60) {
+    this.ttlMs = ttlMinutes * 60 * 1e3;
+    this.cleanupTimer = setInterval(() => this.cleanup(), 5 * 60 * 1e3);
+  }
+  storeFile(sessionId, filePath, content, workingDirectory) {
+    if (!this.isPathAllowed(filePath, workingDirectory)) {
+      log2.warn({ filePath, workingDirectory }, "Path outside workspace, rejecting");
+      return null;
+    }
+    if (content.length > MAX_CONTENT_SIZE) {
+      log2.debug({ filePath, size: content.length }, "File too large for viewer");
+      return null;
+    }
+    const id = nanoid(12);
+    const now = Date.now();
+    this.entries.set(id, {
+      id,
+      type: "file",
+      filePath,
+      content,
+      language: this.detectLanguage(filePath),
+      sessionId,
+      workingDirectory,
+      createdAt: now,
+      expiresAt: now + this.ttlMs
+    });
+    log2.debug({ id, filePath }, "Stored file for viewing");
+    return id;
+  }
+  storeDiff(sessionId, filePath, oldContent, newContent, workingDirectory) {
+    if (!this.isPathAllowed(filePath, workingDirectory)) {
+      log2.warn({ filePath, workingDirectory }, "Path outside workspace, rejecting");
+      return null;
+    }
+    const combined = oldContent.length + newContent.length;
+    if (combined > MAX_CONTENT_SIZE) {
+      log2.debug({ filePath, size: combined }, "Diff content too large for viewer");
+      return null;
+    }
+    const id = nanoid(12);
+    const now = Date.now();
+    this.entries.set(id, {
+      id,
+      type: "diff",
+      filePath,
+      content: newContent,
+      oldContent,
+      language: this.detectLanguage(filePath),
+      sessionId,
+      workingDirectory,
+      createdAt: now,
+      expiresAt: now + this.ttlMs
+    });
+    log2.debug({ id, filePath }, "Stored diff for viewing");
+    return id;
+  }
+  get(id) {
+    const entry = this.entries.get(id);
+    if (!entry) return void 0;
+    if (Date.now() > entry.expiresAt) {
+      this.entries.delete(id);
+      return void 0;
+    }
+    return entry;
+  }
+  cleanup() {
+    const now = Date.now();
+    let removed = 0;
+    for (const [id, entry] of this.entries) {
+      if (now > entry.expiresAt) {
+        this.entries.delete(id);
+        removed++;
+      }
+    }
+    if (removed > 0) {
+      log2.debug({ removed, remaining: this.entries.size }, "Cleaned up expired viewer entries");
+    }
+  }
+  isPathAllowed(filePath, workingDirectory) {
+    const resolved = path.resolve(workingDirectory, filePath);
+    return resolved.startsWith(path.resolve(workingDirectory));
+  }
+  detectLanguage(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return EXTENSION_LANGUAGE[ext];
+  }
+  destroy() {
+    clearInterval(this.cleanupTimer);
+    this.entries.clear();
+  }
+};
+
+// src/tunnel/server.ts
+import { Hono } from "hono";
+
+// src/tunnel/templates/file-viewer.ts
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+var MONACO_LANGUAGE = {
+  typescript: "typescript",
+  javascript: "javascript",
+  python: "python",
+  rust: "rust",
+  go: "go",
+  java: "java",
+  kotlin: "kotlin",
+  ruby: "ruby",
+  php: "php",
+  c: "c",
+  cpp: "cpp",
+  csharp: "csharp",
+  swift: "swift",
+  bash: "shell",
+  json: "json",
+  yaml: "yaml",
+  toml: "ini",
+  xml: "xml",
+  html: "html",
+  css: "css",
+  scss: "scss",
+  sql: "sql",
+  markdown: "markdown",
+  dockerfile: "dockerfile",
+  hcl: "hcl",
+  plaintext: "plaintext"
+};
+function getMonacoLang(lang) {
+  if (!lang) return "plaintext";
+  return MONACO_LANGUAGE[lang] || "plaintext";
+}
+function renderFileViewer(entry) {
+  const fileName = entry.filePath || "untitled";
+  const lang = getMonacoLang(entry.language);
+  const safeContent = JSON.stringify(entry.content).replace(/<\//g, "<\\/");
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${escapeHtml(fileName)} - OpenACP</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body { background: #1e1e1e; color: #d4d4d4; font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; display: flex; flex-direction: column; height: 100vh; }
+    .header { background: #252526; border-bottom: 1px solid #3c3c3c; padding: 8px 16px; display: flex; align-items: center; justify-content: space-between; flex-shrink: 0; z-index: 10; }
+    .file-info { display: flex; align-items: center; gap: 8px; font-size: 13px; min-width: 0; }
+    .file-icon { font-size: 14px; flex-shrink: 0; }
+    .file-path { color: #969696; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+    .file-name { color: #e0e0e0; font-weight: 500; flex-shrink: 0; }
+    .actions { display: flex; gap: 6px; flex-shrink: 0; }
+    .btn { background: #3c3c3c; color: #d4d4d4; border: 1px solid #505050; padding: 4px 10px; border-radius: 4px; cursor: pointer; font-size: 12px; transition: background 0.15s; }
+    .btn:hover { background: #505050; }
+    .btn.active { background: #0e639c; border-color: #1177bb; }
+    #editor-container { flex: 1; overflow: hidden; }
+    .status-bar { background: #007acc; color: #fff; padding: 2px 16px; font-size: 12px; display: flex; justify-content: space-between; flex-shrink: 0; }
+  </style>
+</head>
+<body>
+  <div class="header">
+    <div class="file-info">
+      <span class="file-icon">\u{1F4C4}</span>
+      ${formatBreadcrumb(fileName)}
+    </div>
+    <div class="actions">
+      <button class="btn" onclick="toggleWordWrap()" id="btn-wrap">Wrap</button>
+      <button class="btn" onclick="toggleMinimap()" id="btn-minimap">Minimap</button>
+      <button class="btn" onclick="toggleTheme()" id="btn-theme">Light</button>
+      <button class="btn" onclick="copyCode()">Copy</button>
+    </div>
+  </div>
+  <div id="editor-container"></div>
+  <div class="status-bar">
+    <span>${escapeHtml(entry.language || "plaintext")} | ${entry.content.split("\n").length} lines</span>
+    <span>OpenACP Viewer (read-only)</span>
+  </div>
+
+  <script src="https://cdn.jsdelivr.net/npm/monaco-editor@0.52.2/min/vs/loader.js"></script>
+  <script>
+    const content = ${safeContent};
+    const lang = ${JSON.stringify(lang)};
+    let editor;
+    let isDark = true;
+    let wordWrap = false;
+    let minimap = true;
+
+    require.config({ paths: { vs: 'https://cdn.jsdelivr.net/npm/monaco-editor@0.52.2/min/vs' } });
+    require(['vs/editor/editor.main'], function () {
+      editor = monaco.editor.create(document.getElementById('editor-container'), {
+        value: content,
+        language: lang,
+        theme: 'vs-dark',
+        readOnly: true,
+        automaticLayout: true,
+        minimap: { enabled: true },
+        scrollBeyondLastLine: false,
+        fontSize: 13,
+        fontFamily: "'SF Mono', SFMono-Regular, Consolas, 'Liberation Mono', Menlo, monospace",
+        lineNumbers: 'on',
+        renderLineHighlight: 'all',
+        wordWrap: 'off',
+        padding: { top: 8 },
+      });
+
+      // Handle line range from URL hash: #L42 or #L42-L55
+      function highlightFromHash() {
+        const hash = location.hash.slice(1);
+        const match = hash.match(/^L(\\d+)(?:-L?(\\d+))?$/);
+        if (!match) return;
+        const startLine = parseInt(match[1], 10);
+        const endLine = match[2] ? parseInt(match[2], 10) : startLine;
+        editor.revealLineInCenter(startLine);
+        editor.setSelection(new monaco.Selection(startLine, 1, endLine + 1, 1));
+      }
+      highlightFromHash();
+      window.addEventListener('hashchange', highlightFromHash);
+    });
+
+    function toggleTheme() {
+      isDark = !isDark;
+      monaco.editor.setTheme(isDark ? 'vs-dark' : 'vs');
+      document.body.style.background = isDark ? '#1e1e1e' : '#ffffff';
+      document.querySelector('.header').style.background = isDark ? '#252526' : '#f3f3f3';
+      document.querySelector('.header').style.borderColor = isDark ? '#3c3c3c' : '#e0e0e0';
+      document.getElementById('btn-theme').textContent = isDark ? 'Light' : 'Dark';
+    }
+
+    function toggleWordWrap() {
+      wordWrap = !wordWrap;
+      editor.updateOptions({ wordWrap: wordWrap ? 'on' : 'off' });
+      document.getElementById('btn-wrap').classList.toggle('active', wordWrap);
+    }
+
+    function toggleMinimap() {
+      minimap = !minimap;
+      editor.updateOptions({ minimap: { enabled: minimap } });
+      document.getElementById('btn-minimap').classList.toggle('active', !minimap);
+    }
+
+    function copyCode() {
+      navigator.clipboard.writeText(content).then(() => {
+        const btn = event.target;
+        btn.textContent = 'Copied!';
+        setTimeout(() => btn.textContent = 'Copy', 2000);
+      });
+    }
+  </script>
+</body>
+</html>`;
+}
+function formatBreadcrumb(filePath) {
+  const parts = filePath.split("/");
+  if (parts.length <= 1) return `<span class="file-name">${escapeHtml(filePath)}</span>`;
+  const dir = parts.slice(0, -1).join(" / ");
+  const name = parts[parts.length - 1];
+  return `<span class="file-path">${escapeHtml(dir)} /</span> <span class="file-name">${escapeHtml(name)}</span>`;
+}
+
+// src/tunnel/templates/diff-viewer.ts
+import { createPatch } from "diff";
+function escapeHtml2(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+var MONACO_LANGUAGE2 = {
+  typescript: "typescript",
+  javascript: "javascript",
+  python: "python",
+  rust: "rust",
+  go: "go",
+  java: "java",
+  kotlin: "kotlin",
+  ruby: "ruby",
+  php: "php",
+  c: "c",
+  cpp: "cpp",
+  csharp: "csharp",
+  swift: "swift",
+  bash: "shell",
+  json: "json",
+  yaml: "yaml",
+  toml: "ini",
+  xml: "xml",
+  html: "html",
+  css: "css",
+  scss: "scss",
+  sql: "sql",
+  markdown: "markdown",
+  dockerfile: "dockerfile",
+  hcl: "hcl",
+  plaintext: "plaintext"
+};
+function getMonacoLang2(lang) {
+  if (!lang) return "plaintext";
+  return MONACO_LANGUAGE2[lang] || "plaintext";
+}
+function renderDiffViewer(entry) {
+  const fileName = entry.filePath || "untitled";
+  const lang = getMonacoLang2(entry.language);
+  const oldContent = entry.oldContent || "";
+  const newContent = entry.content;
+  const patch = createPatch(fileName, oldContent, newContent, "before", "after");
+  const adds = (patch.match(/^\+[^+]/gm) || []).length;
+  const dels = (patch.match(/^-[^-]/gm) || []).length;
+  const safeOld = JSON.stringify(oldContent).replace(/<\//g, "<\\/");
+  const safeNew = JSON.stringify(newContent).replace(/<\//g, "<\\/");
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${escapeHtml2(fileName)} (diff) - OpenACP</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body { background: #1e1e1e; color: #d4d4d4; font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; display: flex; flex-direction: column; height: 100vh; }
+    .header { background: #252526; border-bottom: 1px solid #3c3c3c; padding: 8px 16px; display: flex; align-items: center; justify-content: space-between; flex-shrink: 0; z-index: 10; }
+    .file-info { display: flex; align-items: center; gap: 8px; font-size: 13px; }
+    .file-icon { font-size: 14px; }
+    .file-name { color: #e0e0e0; font-weight: 500; }
+    .stats { font-size: 12px; margin-left: 12px; }
+    .stats .add { color: #4ec9b0; }
+    .stats .del { color: #f14c4c; }
+    .actions { display: flex; gap: 6px; }
+    .btn { background: #3c3c3c; color: #d4d4d4; border: 1px solid #505050; padding: 4px 10px; border-radius: 4px; cursor: pointer; font-size: 12px; transition: background 0.15s; }
+    .btn:hover { background: #505050; }
+    .btn.active { background: #0e639c; border-color: #1177bb; }
+    #editor-container { flex: 1; overflow: hidden; }
+    .status-bar { background: #007acc; color: #fff; padding: 2px 16px; font-size: 12px; display: flex; justify-content: space-between; flex-shrink: 0; }
+  </style>
+</head>
+<body>
+  <div class="header">
+    <div class="file-info">
+      <span class="file-icon">\u{1F4DD}</span>
+      <span class="file-name">${escapeHtml2(fileName)}</span>
+      <span class="stats"><span class="add">+${adds}</span> / <span class="del">-${dels}</span></span>
+    </div>
+    <div class="actions">
+      <button class="btn active" id="btn-side" onclick="setView('side')">Side by Side</button>
+      <button class="btn" id="btn-inline" onclick="setView('inline')">Inline</button>
+      <button class="btn" onclick="toggleTheme()" id="btn-theme">Light</button>
+    </div>
+  </div>
+  <div id="editor-container"></div>
+  <div class="status-bar">
+    <span>${escapeHtml2(entry.language || "plaintext")} | <span class="add">+${adds}</span> <span class="del">-${dels}</span></span>
+    <span>OpenACP Diff Viewer</span>
+  </div>
+
+  <script src="https://cdn.jsdelivr.net/npm/monaco-editor@0.52.2/min/vs/loader.js"></script>
+  <script>
+    const oldContent = ${safeOld};
+    const newContent = ${safeNew};
+    const lang = ${JSON.stringify(lang)};
+    let diffEditor;
+    let isDark = true;
+    let renderSideBySide = true;
+
+    require.config({ paths: { vs: 'https://cdn.jsdelivr.net/npm/monaco-editor@0.52.2/min/vs' } });
+    require(['vs/editor/editor.main'], function () {
+      const originalModel = monaco.editor.createModel(oldContent, lang);
+      const modifiedModel = monaco.editor.createModel(newContent, lang);
+
+      diffEditor = monaco.editor.createDiffEditor(document.getElementById('editor-container'), {
+        theme: 'vs-dark',
+        readOnly: true,
+        automaticLayout: true,
+        renderSideBySide: true,
+        scrollBeyondLastLine: false,
+        fontSize: 13,
+        fontFamily: "'SF Mono', SFMono-Regular, Consolas, 'Liberation Mono', Menlo, monospace",
+        padding: { top: 8 },
+        enableSplitViewResizing: true,
+        renderOverviewRuler: true,
+      });
+
+      diffEditor.setModel({ original: originalModel, modified: modifiedModel });
+    });
+
+    function setView(mode) {
+      renderSideBySide = mode === 'side';
+      diffEditor.updateOptions({ renderSideBySide });
+      document.getElementById('btn-side').classList.toggle('active', renderSideBySide);
+      document.getElementById('btn-inline').classList.toggle('active', !renderSideBySide);
+    }
+
+    function toggleTheme() {
+      isDark = !isDark;
+      monaco.editor.setTheme(isDark ? 'vs-dark' : 'vs');
+      document.body.style.background = isDark ? '#1e1e1e' : '#ffffff';
+      document.querySelector('.header').style.background = isDark ? '#252526' : '#f3f3f3';
+      document.querySelector('.header').style.borderColor = isDark ? '#3c3c3c' : '#e0e0e0';
+      document.getElementById('btn-theme').textContent = isDark ? 'Light' : 'Dark';
+    }
+  </script>
+</body>
+</html>`;
+}
+
+// src/tunnel/server.ts
+function notFoundPage() {
+  return `<!DOCTYPE html>
+<html><head><meta charset="UTF-8"><title>Not Found - OpenACP</title>
+<style>body{background:#0d1117;color:#c9d1d9;font-family:sans-serif;display:flex;align-items:center;justify-content:center;min-height:100vh;margin:0}
+.box{text-align:center;padding:40px}.code{font-size:72px;font-weight:bold;color:#484f58}p{margin-top:16px;color:#8b949e}</style>
+</head><body><div class="box"><div class="code">404</div><p>This viewer link has expired or does not exist.</p></div></body></html>`;
+}
+function createTunnelServer(store, authToken) {
+  const app = new Hono();
+  if (authToken) {
+    app.use("*", async (c, next) => {
+      if (c.req.path === "/health") return next();
+      const bearer = c.req.header("Authorization")?.replace("Bearer ", "");
+      const query = c.req.query("token");
+      if (bearer !== authToken && query !== authToken) {
+        return c.text("Unauthorized", 401);
+      }
+      return next();
+    });
+  }
+  app.get("/health", (c) => c.json({ status: "ok" }));
+  app.get("/view/:id", (c) => {
+    const entry = store.get(c.req.param("id"));
+    if (!entry || entry.type !== "file") {
+      return c.html(notFoundPage(), 404);
+    }
+    return c.html(renderFileViewer(entry));
+  });
+  app.get("/diff/:id", (c) => {
+    const entry = store.get(c.req.param("id"));
+    if (!entry || entry.type !== "diff") {
+      return c.html(notFoundPage(), 404);
+    }
+    return c.html(renderDiffViewer(entry));
+  });
+  app.get("/api/file/:id", (c) => {
+    const entry = store.get(c.req.param("id"));
+    if (!entry || entry.type !== "file") {
+      return c.json({ error: "not found" }, 404);
+    }
+    return c.json({ filePath: entry.filePath, content: entry.content, language: entry.language });
+  });
+  app.get("/api/diff/:id", (c) => {
+    const entry = store.get(c.req.param("id"));
+    if (!entry || entry.type !== "diff") {
+      return c.json({ error: "not found" }, 404);
+    }
+    return c.json({ filePath: entry.filePath, oldContent: entry.oldContent, newContent: entry.content, language: entry.language });
+  });
+  return app;
+}
+
+// src/tunnel/tunnel-service.ts
+var log3 = createChildLogger({ module: "tunnel" });
+var TunnelService = class {
+  provider;
+  store;
+  server = null;
+  publicUrl = "";
+  config;
+  constructor(config) {
+    this.config = config;
+    this.store = new ViewerStore(config.storeTtlMinutes);
+    this.provider = this.createProvider(config.provider, config.options);
+  }
+  async start() {
+    const authToken = this.config.auth.enabled ? this.config.auth.token : void 0;
+    const app = createTunnelServer(this.store, authToken);
+    this.server = serve({ fetch: app.fetch, port: this.config.port });
+    log3.info({ port: this.config.port }, "Tunnel HTTP server started");
+    try {
+      this.publicUrl = await this.provider.start(this.config.port);
+      log3.info({ url: this.publicUrl }, "Tunnel public URL ready");
+    } catch (err) {
+      log3.warn({ err }, "Tunnel provider failed to start, running without public URL");
+      this.publicUrl = `http://localhost:${this.config.port}`;
+    }
+    return this.publicUrl;
+  }
+  async stop() {
+    await this.provider.stop();
+    if (this.server) {
+      this.server.close();
+      this.server = null;
+    }
+    this.store.destroy();
+    log3.info("Tunnel service stopped");
+  }
+  getPublicUrl() {
+    return this.publicUrl;
+  }
+  getStore() {
+    return this.store;
+  }
+  fileUrl(entryId) {
+    return `${this.publicUrl}/view/${entryId}`;
+  }
+  diffUrl(entryId) {
+    return `${this.publicUrl}/diff/${entryId}`;
+  }
+  createProvider(name, options) {
+    switch (name) {
+      case "cloudflare":
+        return new CloudflareTunnelProvider(options);
+      default:
+        log3.warn({ provider: name }, "Unknown tunnel provider, falling back to cloudflare");
+        return new CloudflareTunnelProvider(options);
+    }
+  }
+};
+export {
+  TunnelService
+};
+//# sourceMappingURL=tunnel-service-FPRPBPQ5.js.map