buncargo 3.0.0 → 3.2.0

package/dist/index-6d6x175r.js

@@ -0,0 +1,572 @@
+import {
+  logPublicUrls
+} from "./index-bnk6nr0g.js";
+import {
+  spawnWatchdog,
+  startHeartbeat,
+  stopHeartbeat
+} from "./index-mam0bcyz.js";
+import {
+  killProcessesOnAppPorts
+} from "./index-mm412dkp.js";
+
+// src/core/quick-tunnel/index.ts
+import { existsSync } from "node:fs";
+import { createInterface } from "node:readline";
+
+// src/core/quick-tunnel/constants.ts
+import path from "node:path";
+import { tmpdir } from "node:os";
+var CLOUDFLARED_VERSION = process.env.CLOUDFLARED_VERSION || "2023.10.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}`);
+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
+import { spawn } from "node:child_process";
+var urlRegex = /\|\s+(https?:\/\/\S+)/;
+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 child = spawn(cloudflaredBinPath, args, {
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if (process.env.DEBUG) {
+    child.stdout?.pipe(process.stdout);
+    child.stderr?.pipe(process.stderr);
+  }
+  let urlResolver;
+  let urlRejector;
+  const url = new Promise((resolve, reject) => {
+    urlResolver = resolve;
+    urlRejector = reject;
+  });
+  const parser = (data) => {
+    const str = data.toString();
+    const urlMatch = str.match(urlRegex);
+    if (urlMatch) {
+      urlResolver(urlMatch[1] ?? "");
+    }
+  };
+  child.stdout?.on("data", parser).on("error", urlRejector);
+  child.stderr?.on("data", parser).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-amd64.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 resolvedLocalUrl(opts) {
+  return opts.url ?? `${opts.protocol || "http"}://${opts.hostname ?? "localhost"}:${opts.port ?? 3000}`;
+}
+function envAcceptsCloudflareNotice() {
+  const v = process.env.BUNCARGO_ACCEPT_CLOUDFLARE_NOTICE;
+  const u = process.env.UNTUN_ACCEPT_CLOUDFLARE_NOTICE;
+  return v === "1" || v === "true" || u === "1" || u === "true";
+}
+async function promptInstallCloudflared() {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    return false;
+  }
+  return new Promise((resolve) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    rl.question("Do you agree with the above terms and wish to install the binary from GitHub? (y/N) ", (answer) => {
+      rl.close();
+      resolve(/^y(es)?$/i.test(answer.trim()));
+    });
+  });
+}
+async function startQuickTunnel(opts) {
+  const url = resolvedLocalUrl(opts);
+  console.log(`Starting cloudflared tunnel to ${url}`);
+  if (!existsSync(cloudflaredBinPath)) {
+    console.log(cloudflaredNotice);
+    const canInstall = opts.acceptCloudflareNotice || envAcceptsCloudflareNotice() || await promptInstallCloudflared();
+    if (!canInstall) {
+      console.error("Skipping tunnel setup.");
+      return;
+    }
+    await installCloudflared();
+  }
+  const argEntries = [["--url", url]];
+  if (!opts.verifyTLS) {
+    argEntries.push(["--no-tls-verify", ""]);
+  }
+  const tunnel = startCloudflaredTunnel(Object.fromEntries(argEntries));
+  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 };
+}
+async function startPublicTunnels(targets, options = {}) {
+  const start = options.start ?? ((input) => startQuickTunnel(input));
+  const tunnels = [];
+  try {
+    for (const target of targets) {
+      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 (cloudflared missing or install declined)`);
+      }
+      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 (error) {
+    await stopPublicTunnels(tunnels);
+    throw error;
+  }
+}
+async function stopPublicTunnels(tunnels) {
+  await Promise.allSettled(tunnels.map((tunnel) => tunnel.close()));
+}
+
+// src/cli/run-cli.ts
+import { spawn as spawn2 } from "node:child_process";
+var ACCEPTED_FLAGS = [
+  "--help",
+  "--down",
+  "--reset",
+  "--migrate",
+  "--seed",
+  "--up-only",
+  "--expose"
+];
+function printHelp() {
+  console.log(`
+Usage: buncargo dev [options]
+
+Options:
+  --help      Show this help message
+  --down      Stop all containers
+  --reset     Stop containers and remove volumes (fresh start)
+  --migrate   Run migrations and exit
+  --seed      Run migrations and seeders, then exit
+  --up-only   Start containers and run migrations, then exit (no dev servers)
+  --expose    Expose configured targets via public quick tunnels
+
+Examples:
+  bun dev              Start dev environment with all services
+  bun dev --seed       Run migrations and seed the database
+  bun dev --down       Stop all containers
+  bun dev --reset      Stop containers and remove all data
+  bun dev --expose     Expose all targets with expose: true
+  bun dev --expose=api,web  Expose specific targets
+`);
+}
+function getUnknownFlags(args) {
+  return args.filter((arg) => arg.startsWith("--") && !ACCEPTED_FLAGS.includes(arg.includes("=") ? arg.split("=")[0] : arg));
+}
+async function runCli(env, options = {}) {
+  const {
+    args = process.argv.slice(2),
+    watchdog = true,
+    watchdogTimeout = 10,
+    devServersCommand
+  } = options;
+  const exposeRequested = hasFlag(args, "--expose");
+  const exposeValue = getFlagValue(args, "--expose");
+  let tunnels = [];
+  async function cleanupTunnels() {
+    env.clearPublicUrls();
+    if (tunnels.length === 0)
+      return;
+    await stopPublicTunnels(tunnels);
+    tunnels = [];
+  }
+  if (args.includes("--help")) {
+    printHelp();
+    process.exit(0);
+  }
+  const unknownFlags = getUnknownFlags(args);
+  if (unknownFlags.length > 0) {
+    console.error(`❌ Unknown flag${unknownFlags.length > 1 ? "s" : ""}: ${unknownFlags.join(", ")}`);
+    console.error("");
+    printHelp();
+    process.exit(1);
+  }
+  if (args.includes("--down")) {
+    env.logInfo();
+    await cleanupTunnels();
+    await env.stop();
+    process.exit(0);
+  }
+  if (args.includes("--reset")) {
+    env.logInfo();
+    await cleanupTunnels();
+    await env.stop({ removeVolumes: true });
+    process.exit(0);
+  }
+  const skipSeed = args.includes("--seed");
+  await env.start({ startServers: false, wait: true, skipSeed });
+  if (exposeRequested) {
+    const { targets, unknownNames, notEnabledNames } = resolveExposeTargets(env, exposeValue);
+    if (unknownNames.length > 0) {
+      console.error(`❌ Unknown expose target${unknownNames.length > 1 ? "s" : ""}: ${unknownNames.join(", ")}`);
+      await cleanupTunnels();
+      process.exit(1);
+    }
+    if (notEnabledNames.length > 0) {
+      console.error(`❌ Target${notEnabledNames.length > 1 ? "s" : ""} missing expose: true: ${notEnabledNames.join(", ")}`);
+      console.error("   Mark these in dev.config.ts with expose: true or remove them from --expose.");
+      await cleanupTunnels();
+      process.exit(1);
+    }
+    if (targets.length === 0) {
+      console.error("❌ No expose targets selected. Add expose: true to services/apps or pass names with --expose=<name>.");
+      await cleanupTunnels();
+      process.exit(1);
+    }
+    tunnels = await startPublicTunnels(targets);
+    env.setPublicUrls(Object.fromEntries(tunnels.map((tunnel) => [tunnel.name, tunnel.publicUrl])));
+    logPublicUrls(tunnels);
+  }
+  if (args.includes("--migrate")) {
+    console.log("");
+    console.log("✅ Migrations applied successfully");
+    await cleanupTunnels();
+    process.exit(0);
+  }
+  if (args.includes("--seed")) {
+    console.log("\uD83C\uDF31 Running seeders...");
+    const result = await env.exec("bun run run:seeder", {
+      throwOnError: false
+    });
+    if (result.exitCode !== 0) {
+      console.error("❌ Seeding failed");
+      if (result.stderr) {
+        console.error(result.stderr);
+      }
+      if (result.stdout) {
+        console.error(result.stdout);
+      }
+      await cleanupTunnels();
+      process.exit(1);
+    }
+    console.log("");
+    console.log("✅ Seeding complete");
+    await cleanupTunnels();
+    process.exit(0);
+  }
+  if (args.includes("--up-only")) {
+    console.log("");
+    console.log("✅ Containers started. Environment ready.");
+    console.log("");
+    await cleanupTunnels();
+    process.exit(0);
+  }
+  if (watchdog) {
+    await spawnWatchdog(env.projectName, env.root, {
+      timeoutMinutes: watchdogTimeout,
+      verbose: true,
+      composeFile: env.composeFile
+    });
+    startHeartbeat(env.projectName);
+  }
+  const command = devServersCommand ?? buildDevServersCommand(env.apps);
+  if (!command) {
+    console.log("✅ Containers ready. No apps configured.");
+    await new Promise(() => {});
+    await cleanupTunnels();
+    return;
+  }
+  await killProcessesOnAppPorts(env.apps, env.ports);
+  console.log("");
+  console.log("\uD83D\uDD27 Starting dev servers...");
+  console.log("");
+  await runCommand(command, env.root, env.buildEnvVars(), {
+    onSignal: async () => {
+      await cleanupTunnels();
+      stopHeartbeat();
+    }
+  });
+  stopHeartbeat();
+  await cleanupTunnels();
+}
+function buildDevServersCommand(apps) {
+  const appEntries = Object.entries(apps);
+  if (appEntries.length === 0)
+    return null;
+  const commands = [];
+  const names = [];
+  const colors = ["blue", "green", "yellow", "magenta", "cyan", "red"];
+  for (const [name, config] of appEntries) {
+    names.push(name);
+    const cwdPart = config.cwd ? `--cwd ${config.cwd}` : "";
+    commands.push(`"bun run ${cwdPart} ${config.devCommand}"`.replace(/\s+/g, " ").trim());
+  }
+  const namesArg = `-n ${names.join(",")}`;
+  const colorsArg = `-c ${colors.slice(0, names.length).join(",")}`;
+  const commandsArg = commands.join(" ");
+  return `bun concurrently ${namesArg} ${colorsArg} ${commandsArg}`;
+}
+function runCommand(command, cwd, envVars, options = {}) {
+  const { onSignal } = options;
+  return new Promise((resolve, reject) => {
+    const proc = spawn2(command, [], {
+      cwd,
+      env: { ...process.env, ...envVars },
+      stdio: "inherit",
+      shell: true
+    });
+    proc.on("close", (code) => {
+      if (code === 0 || code === null) {
+        resolve();
+      } else {
+        reject(new Error(`Command exited with code ${code}`));
+      }
+    });
+    proc.on("error", reject);
+    const cleanup = () => {
+      if (onSignal) {
+        onSignal();
+      }
+      proc.kill("SIGTERM");
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+  });
+}
+function hasFlag(args, flag) {
+  return args.includes(flag);
+}
+function getFlagValue(args, flag) {
+  const prefixed = args.find((arg) => arg.startsWith(`${flag}=`));
+  if (prefixed) {
+    return prefixed.split("=")[1];
+  }
+  const index = args.indexOf(flag);
+  if (index !== -1 && index + 1 < args.length) {
+    const nextArg = args[index + 1];
+    if (nextArg !== undefined && !nextArg.startsWith("-")) {
+      return nextArg;
+    }
+  }
+  return;
+}
+
+export { resolveExposeTargets, startPublicTunnels, stopPublicTunnels, runCli, hasFlag, getFlagValue };