buncargo 3.2.3 → 3.2.5

package/dist/index-96q4yh56.js

@@ -0,0 +1,72 @@
+import {
+  createDevEnvironment
+} from "./index-qnpd5fn5.js";
+
+// src/loader/cache.ts
+var cachedEnv = null;
+function setCachedDevEnv(env) {
+  cachedEnv = env;
+}
+function getCachedDevEnv() {
+  return cachedEnv;
+}
+function clearDevEnvCache() {
+  cachedEnv = null;
+}
+// src/loader/find-config-file.ts
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+var CONFIG_FILES = [
+  "dev.config.ts",
+  "dev.config.js",
+  "dev-tools.config.ts",
+  "dev-tools.config.js"
+];
+function findConfigFile(startDir) {
+  let currentDir = startDir;
+  while (true) {
+    for (const file of CONFIG_FILES) {
+      const configPath = join(currentDir, file);
+      if (existsSync(configPath)) {
+        return configPath;
+      }
+    }
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
+}
+// src/loader/load-dev-env.ts
+async function loadDevEnv(options) {
+  if (!options?.reload) {
+    const cached = getCachedDevEnv();
+    if (cached)
+      return cached;
+  }
+  const cwd = options?.cwd ?? process.cwd();
+  const configPath = findConfigFile(cwd);
+  if (configPath) {
+    const mod = await import(configPath);
+    const config = mod.default;
+    if (!config?.projectPrefix || !config?.services) {
+      throw new Error(`Invalid config in "${configPath}". Use defineDevConfig() and export as default.`);
+    }
+    const env = createDevEnvironment(config);
+    setCachedDevEnv(env);
+    return env;
+  }
+  throw new Error("No config file found. Create dev.config.ts with: export default defineDevConfig({ ... })");
+}
+
+// src/loader/index.ts
+function getDevEnv() {
+  const env = getCachedDevEnv();
+  if (!env) {
+    throw new Error("Dev environment not loaded. Call loadDevEnv() first.");
+  }
+  return env;
+}
+
+export { clearDevEnvCache, CONFIG_FILES, findConfigFile, loadDevEnv, getDevEnv };

package/dist/index-bgcx898h.js

@@ -0,0 +1,451 @@
+import {
+  sleep
+} from "./index-fkgqg6w2.js";
+
+// src/core/quick-tunnel/index.ts
+import { existsSync as existsSync2 } from "node:fs";
+
+// src/core/quick-tunnel/cloudflared-process.ts
+import { spawn } from "node:child_process";
+
+// src/core/quick-tunnel/constants.ts
+import { existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+var CLOUDFLARED_VERSION = process.env.CLOUDFLARED_VERSION || "2026.3.0";
+var RELEASE_BASE = "https://github.com/cloudflare/cloudflared/releases/";
+var cloudflaredBinPath = path.join(tmpdir(), "buncargo-cloudflared", process.platform === "win32" ? `cloudflared.${CLOUDFLARED_VERSION}.exe` : `cloudflared.${CLOUDFLARED_VERSION}`);
+function resolvedCloudflaredBinPath() {
+  const override = process.env.BUNCARGO_CLOUDFLARED_PATH?.trim();
+  if (override) {
+    if (!existsSync(override)) {
+      throw new Error(`BUNCARGO_CLOUDFLARED_PATH does not exist: ${override}`);
+    }
+    return path.resolve(override);
+  }
+  return cloudflaredBinPath;
+}
+var cloudflaredNotice = `
+\uD83D\uDD25 Your installation of cloudflared software constitutes a symbol of your signature
+ indicating that you accept the terms of the Cloudflare License, Terms and Privacy Policy.
+
+❯ License: \`https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/downloads/license/\`
+❯ Terms: \`https://www.cloudflare.com/terms/\`
+❯ Privacy Policy: \`https://www.cloudflare.com/privacypolicy/\`
+`;
+
+// src/core/quick-tunnel/cloudflared-process.ts
+var urlRegexPipe = /\|\s+(https?:\/\/\S+)/;
+var urlRegexTryCloudflare = /(https:\/\/[a-zA-Z0-9][-a-zA-Z0-9.]*\.trycloudflare\.com)\b/;
+var MAX_CAPTURED_LOG = 24000;
+function resolveQuickTunnelUrlTimeoutMs() {
+  const raw = process.env.BUNCARGO_QUICK_TUNNEL_TIMEOUT_MS;
+  if (raw === undefined || raw === "") {
+    return 30000;
+  }
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) && n >= 0 ? n : 30000;
+}
+function parseQuickTunnelUrlFromOutput(log) {
+  const pipe = log.match(urlRegexPipe);
+  if (pipe?.[1]) {
+    return pipe[1];
+  }
+  const direct = log.match(urlRegexTryCloudflare);
+  return direct?.[1] ?? null;
+}
+function startCloudflaredTunnel(options) {
+  const args = ["tunnel"];
+  for (const [key, value] of Object.entries(options)) {
+    if (typeof value === "string") {
+      args.push(`${key}`, value);
+    } else if (typeof value === "number") {
+      args.push(`${key}`, value.toString());
+    } else if (value === null) {
+      args.push(`${key}`);
+    }
+  }
+  if (args.length === 1) {
+    args.push("--url", "localhost:8080");
+  }
+  const binPath = resolvedCloudflaredBinPath();
+  const child = spawn(binPath, args, {
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if (process.env.DEBUG) {
+    child.stdout?.pipe(process.stdout);
+    child.stderr?.pipe(process.stderr);
+  }
+  let settled = false;
+  let urlResolver;
+  let urlRejector;
+  let timeoutId;
+  const clearUrlTimeout = () => {
+    if (timeoutId !== undefined) {
+      clearTimeout(timeoutId);
+      timeoutId = undefined;
+    }
+  };
+  const url = new Promise((resolve, reject) => {
+    urlResolver = (v) => {
+      if (!settled) {
+        settled = true;
+        clearUrlTimeout();
+        resolve(v);
+      }
+    };
+    urlRejector = (e) => {
+      if (!settled) {
+        settled = true;
+        clearUrlTimeout();
+        reject(e);
+      }
+    };
+    const timeoutMs = resolveQuickTunnelUrlTimeoutMs();
+    if (timeoutMs > 0) {
+      timeoutId = setTimeout(() => {
+        try {
+          child.kill("SIGINT");
+        } catch {}
+        urlRejector(new Error(`quick tunnel URL timed out after ${timeoutMs}ms (no public URL from cloudflared)`));
+      }, timeoutMs);
+    }
+  });
+  const log = { buf: "" };
+  const append = (data) => {
+    log.buf += data.toString();
+    if (log.buf.length > MAX_CAPTURED_LOG) {
+      log.buf = log.buf.slice(-MAX_CAPTURED_LOG);
+    }
+    const url2 = parseQuickTunnelUrlFromOutput(log.buf);
+    if (url2) {
+      urlResolver(url2);
+    }
+  };
+  child.stdout?.on("data", append).on("error", urlRejector);
+  child.stderr?.on("data", append).on("error", urlRejector);
+  child.on("exit", (code, signal) => {
+    if (!settled) {
+      const tail = log.buf.trimEnd();
+      const excerpt = tail.length > 1200 ? `…${tail.slice(-1200)}` : tail;
+      const detail = excerpt ? `
+cloudflared output (tail):
+${excerpt}` : "";
+      urlRejector(new Error(`cloudflared exited before a tunnel URL was parsed (code=${code}, signal=${signal ?? "none"}). ` + `Parallel quick-tunnel requests are often rate-limited; buncargo starts tunnels sequentially with a short pause. ` + `If this persists, try fewer expose targets or increase BUNCARGO_EXPOSE_TUNNEL_STAGGER_MS.${detail}`));
+    }
+  });
+  child.on("error", urlRejector);
+  const stop = () => child.kill("SIGINT");
+  return { url, child, stop };
+}
+
+// src/core/quick-tunnel/install.ts
+import { execSync } from "node:child_process";
+import fs from "node:fs";
+import https from "node:https";
+import path2 from "node:path";
+var LINUX_URL = {
+  arm64: "cloudflared-linux-arm64",
+  arm: "cloudflared-linux-arm",
+  x64: "cloudflared-linux-amd64",
+  ia32: "cloudflared-linux-386"
+};
+var MACOS_URL = {
+  arm64: "cloudflared-darwin-arm64.tgz",
+  x64: "cloudflared-darwin-amd64.tgz"
+};
+var WINDOWS_URL = {
+  x64: "cloudflared-windows-amd64.exe",
+  ia32: "cloudflared-windows-386.exe"
+};
+function resolveBase(version) {
+  if (version === "latest") {
+    return `${RELEASE_BASE}latest/download/`;
+  }
+  return `${RELEASE_BASE}download/${version}/`;
+}
+function installCloudflared(to = cloudflaredBinPath, version = CLOUDFLARED_VERSION) {
+  switch (process.platform) {
+    case "linux": {
+      return installLinux(to, version);
+    }
+    case "darwin": {
+      return installMacos(to, version);
+    }
+    case "win32": {
+      return installWindows(to, version);
+    }
+    default: {
+      throw new Error(`Unsupported platform: ${process.platform}`);
+    }
+  }
+}
+async function installLinux(to, version = CLOUDFLARED_VERSION) {
+  const file = LINUX_URL[process.arch];
+  if (file === undefined) {
+    throw new Error(`Unsupported architecture: ${process.arch}`);
+  }
+  await download(resolveBase(version) + file, to);
+  fs.chmodSync(to, 493);
+  return to;
+}
+async function installMacos(to, version = CLOUDFLARED_VERSION) {
+  const file = MACOS_URL[process.arch];
+  if (file === undefined) {
+    throw new Error(`Unsupported architecture: ${process.arch}`);
+  }
+  await download(resolveBase(version) + file, `${to}.tgz`);
+  if (process.env.DEBUG) {
+    console.log(`Extracting to ${to}`);
+  }
+  execSync(`tar -xzf ${path2.basename(`${to}.tgz`)}`, {
+    cwd: path2.dirname(to)
+  });
+  fs.unlinkSync(`${to}.tgz`);
+  fs.renameSync(`${path2.dirname(to)}/cloudflared`, to);
+  return to;
+}
+async function installWindows(to, version = CLOUDFLARED_VERSION) {
+  const file = WINDOWS_URL[process.arch];
+  if (file === undefined) {
+    throw new Error(`Unsupported architecture: ${process.arch}`);
+  }
+  await download(resolveBase(version) + file, to);
+  return to;
+}
+function download(url, to, redirect = 0) {
+  if (redirect === 0) {
+    if (process.env.DEBUG) {
+      console.log(`Downloading ${url} to ${to}`);
+    }
+  } else if (process.env.DEBUG) {
+    console.log(`Redirecting to ${url}`);
+  }
+  return new Promise((resolve, reject) => {
+    if (!fs.existsSync(path2.dirname(to))) {
+      fs.mkdirSync(path2.dirname(to), { recursive: true });
+    }
+    let done = true;
+    const file = fs.createWriteStream(to);
+    const request = https.get(url, (res) => {
+      if (res.statusCode === 302 && res.headers.location !== undefined) {
+        const redirection = res.headers.location;
+        done = false;
+        file.close(() => {
+          download(redirection, to, redirect + 1).then(resolve, reject);
+        });
+        return;
+      }
+      res.pipe(file);
+    });
+    file.on("finish", () => {
+      if (done) {
+        file.close(() => {
+          resolve(to);
+        });
+      }
+    });
+    request.on("error", (err) => {
+      fs.unlink(to, () => {
+        reject(err);
+      });
+    });
+    file.on("error", (err) => {
+      fs.unlink(to, () => {
+        reject(err);
+      });
+    });
+    request.end();
+  });
+}
+
+// src/core/quick-tunnel/index.ts
+function resolveMaxQuickTunnelAttempts() {
+  const raw = process.env.BUNCARGO_QUICK_TUNNEL_MAX_ATTEMPTS;
+  if (raw === undefined || raw === "") {
+    return 5;
+  }
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) && n >= 1 ? n : 5;
+}
+function resolveQuickTunnelRetryBaseMs() {
+  const raw = process.env.BUNCARGO_QUICK_TUNNEL_RETRY_BASE_MS;
+  if (raw === undefined || raw === "") {
+    return 2000;
+  }
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) && n >= 0 ? n : 2000;
+}
+function usesBundledCloudflaredCache() {
+  return !process.env.BUNCARGO_CLOUDFLARED_PATH?.trim();
+}
+function isRetryableQuickTunnelError(message) {
+  return message.includes("429") || message.includes("Too Many Requests") || message.includes('status_code="429') || message.includes("failed to unmarshal quick Tunnel") || message.includes("failed to unmarshall quick Tunnel") || message.includes("Error unmarshaling QuickTunnel") || message.includes("invalid character '<'") || message.includes("quick tunnel URL timed out");
+}
+async function startCloudflaredTunnelWithRetry(cfArgs) {
+  const maxAttempts = resolveMaxQuickTunnelAttempts();
+  const baseMs = resolveQuickTunnelRetryBaseMs();
+  for (let attempt = 1;attempt <= maxAttempts; attempt++) {
+    const tunnel = startCloudflaredTunnel(cfArgs);
+    try {
+      await tunnel.url;
+      return tunnel;
+    } catch (e) {
+      try {
+        tunnel.stop();
+      } catch {}
+      const msg = String(e);
+      if (attempt < maxAttempts && isRetryableQuickTunnelError(msg)) {
+        const delayMs = baseMs * attempt;
+        console.log(`Cloudflare quick tunnel temporarily unavailable (${attempt}/${maxAttempts}), retrying in ${delayMs}ms…`);
+        await sleep(delayMs);
+        continue;
+      }
+      throw e;
+    }
+  }
+  throw new Error("startCloudflaredTunnelWithRetry: exhausted attempts");
+}
+function resolvedLocalUrl(opts) {
+  return opts.url ?? `${opts.protocol || "http"}://${opts.hostname ?? "localhost"}:${opts.port ?? 3000}`;
+}
+async function startQuickTunnel(opts) {
+  const url = resolvedLocalUrl(opts);
+  console.log(`Starting cloudflared tunnel to ${url}`);
+  resolvedCloudflaredBinPath();
+  if (usesBundledCloudflaredCache() && !existsSync2(cloudflaredBinPath)) {
+    console.log(cloudflaredNotice);
+    await installCloudflared();
+  }
+  const cfArgs = { "--url": url };
+  if (!opts.verifyTLS) {
+    cfArgs["--no-tls-verify"] = null;
+  }
+  const tunnel = await startCloudflaredTunnelWithRetry(cfArgs);
+  const cleanup = async () => {
+    tunnel.stop();
+  };
+  return {
+    getURL: async () => await tunnel.url,
+    close: cleanup
+  };
+}
+
+// src/core/tunnel.ts
+function parseExposeNames(exposeValue) {
+  if (exposeValue === undefined)
+    return null;
+  const names = exposeValue.split(",").map((name) => name.trim()).filter(Boolean);
+  return new Set(names);
+}
+async function resolvePublicUrl(tunnel) {
+  if (typeof tunnel.getURL === "function") {
+    return await tunnel.getURL();
+  }
+  return tunnel.url ?? tunnel.publicUrl ?? tunnel.tunnelUrl ?? null;
+}
+function toCloseFn(tunnel) {
+  const close = tunnel.close ?? tunnel.stop ?? tunnel.destroy;
+  if (!close)
+    return async () => {};
+  return async () => {
+    await close();
+  };
+}
+function resolveExposeTargets(env, exposeValue) {
+  const requestedNames = parseExposeNames(exposeValue);
+  const knownTargets = new Map;
+  const enabledTargets = new Map;
+  for (const [name, config] of Object.entries(env.services)) {
+    const port = env.ports[name];
+    if (port === undefined)
+      continue;
+    const target = { kind: "service", name, port };
+    knownTargets.set(name, target);
+    if (config.expose === true) {
+      enabledTargets.set(name, target);
+    }
+  }
+  for (const [name, config] of Object.entries(env.apps)) {
+    const port = env.ports[name];
+    if (port === undefined)
+      continue;
+    const target = { kind: "app", name, port };
+    knownTargets.set(name, target);
+    if (config.expose === true) {
+      enabledTargets.set(name, target);
+    }
+  }
+  if (requestedNames === null) {
+    return {
+      targets: Array.from(enabledTargets.values()),
+      unknownNames: [],
+      notEnabledNames: []
+    };
+  }
+  const unknownNames = [];
+  const notEnabledNames = [];
+  const targets = [];
+  for (const name of requestedNames) {
+    if (!knownTargets.has(name)) {
+      unknownNames.push(name);
+      continue;
+    }
+    const enabledTarget = enabledTargets.get(name);
+    if (!enabledTarget) {
+      notEnabledNames.push(name);
+      continue;
+    }
+    targets.push(enabledTarget);
+  }
+  return { targets, unknownNames, notEnabledNames };
+}
+function resolveExposeTunnelStaggerMs() {
+  const raw = process.env.BUNCARGO_EXPOSE_TUNNEL_STAGGER_MS;
+  if (raw === undefined || raw === "") {
+    return 900;
+  }
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) && n >= 0 ? n : 900;
+}
+async function startPublicTunnels(targets, options = {}) {
+  const start = options.start ?? ((input) => startQuickTunnel(input));
+  const staggerMs = resolveExposeTunnelStaggerMs();
+  const tunnels = [];
+  try {
+    let index = 0;
+    for (const target of targets) {
+      if (index > 0 && staggerMs > 0) {
+        await sleep(staggerMs);
+      }
+      index += 1;
+      const localUrl = `http://localhost:${target.port}`;
+      const tunnel = await start({
+        url: localUrl
+      });
+      if (tunnel === undefined) {
+        throw new Error(`Tunnel for "${target.name}" could not be started (tunnel backend returned no instance)`);
+      }
+      const publicUrl = await resolvePublicUrl(tunnel);
+      if (!publicUrl) {
+        throw new Error(`Tunnel for "${target.name}" did not provide a public URL`);
+      }
+      tunnels.push({
+        kind: target.kind,
+        name: target.name,
+        localUrl,
+        publicUrl,
+        close: toCloseFn(tunnel)
+      });
+    }
+    return tunnels;
+  } catch (e) {
+    await stopPublicTunnels(tunnels);
+    throw e;
+  }
+}
+async function stopPublicTunnels(tunnels) {
+  await Promise.allSettled(tunnels.map((tunnel) => tunnel.close()));
+}
+
+export { resolveExposeTargets, startPublicTunnels, stopPublicTunnels };