apiblaze 0.1.10 → 0.1.13

package/dist/index.js

@@ -69,9 +69,6 @@ function getAccessToken() {
   }
   return creds.accessToken;
 }
-function getApiblazeDir() {
-  return APIBLAZE_DIR;
-}
 var fs, os, path, APIBLAZE_DIR, CREDENTIALS_PATH;
 var init_auth = __esm({
   "src/lib/auth.ts"() {
@@ -95,9 +92,9 @@ __export(api_exports, {
   getTeams: () => getTeams,
   putDevTunnel: () => putDevTunnel
 });
-async function apiFetch(path3, options = {}) {
+async function apiFetch(path2, options = {}) {
   const token = getAccessToken();
-  const url = `${DASHBOARD_BASE}${path3}`;
+  const url = `${DASHBOARD_BASE}${path2}`;
   const res = await fetch(url, {
     ...options,
     headers: {
@@ -150,8 +147,11 @@ async function putDevTunnel(payload) {
     body: JSON.stringify(payload)
   });
 }
-async function deleteDevTunnel() {
-  return apiFetch("/api/cli/dev-tunnel", { method: "DELETE" });
+async function deleteDevTunnel(restore) {
+  return apiFetch("/api/cli/dev-tunnel", {
+    method: "DELETE",
+    body: JSON.stringify({ restore })
+  });
 }
 var DASHBOARD_BASE;
 var init_api = __esm({
@@ -285,129 +285,13 @@ ${import_chalk.default.cyan("\u2192")} Team: ${import_chalk.default.bold(teamNam
 
 // src/commands/dev.ts
 var import_chalk3 = __toESM(require("chalk"));
-var import_ora3 = __toESM(require("ora"));
+var import_ora2 = __toESM(require("ora"));
 var import_inquirer = __toESM(require("inquirer"));
 init_auth();
 init_api();
 
-// src/lib/cloudflared.ts
-var fs2 = __toESM(require("fs"));
-var path2 = __toESM(require("path"));
-var readline = __toESM(require("readline"));
-var import_child_process = require("child_process");
-var import_ora2 = __toESM(require("ora"));
-init_auth();
-var TUNNEL_URL_RE = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/;
-var DOWNLOAD_TIMEOUT_MS = 3e4;
-var TUNNEL_START_TIMEOUT_MS = 3e4;
-function getCloudflaredFilename() {
-  const platform = process.platform;
-  const arch = process.arch;
-  if (platform === "darwin" && arch === "arm64") return "cloudflared-darwin-arm64";
-  if (platform === "darwin" && arch === "x64") return "cloudflared-darwin-amd64";
-  if (platform === "linux" && arch === "arm64") return "cloudflared-linux-arm64";
-  if (platform === "linux" && arch === "x64") return "cloudflared-linux-amd64";
-  if (platform === "win32" && arch === "x64") return "cloudflared-windows-amd64.exe";
-  throw new Error(`Unsupported platform: ${platform} ${arch}`);
-}
-function getCloudflaredBinPath() {
-  const filename = process.platform === "win32" ? "cloudflared.exe" : "cloudflared";
-  return path2.join(getApiblazeDir(), "bin", filename);
-}
-function isExecutable(filePath) {
-  try {
-    fs2.accessSync(filePath, fs2.constants.X_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function downloadCloudflared(binPath) {
-  const filename = getCloudflaredFilename();
-  const url = `https://github.com/cloudflare/cloudflared/releases/latest/download/${filename}`;
-  const res = await fetch(url, { signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS) });
-  if (!res.ok || !res.body) {
-    throw new Error(`Failed to download cloudflared: ${res.status} ${res.statusText}`);
-  }
-  fs2.mkdirSync(path2.dirname(binPath), { recursive: true });
-  const tmpPath = `${binPath}.tmp`;
-  const writer = fs2.createWriteStream(tmpPath);
-  const reader = res.body.getReader();
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      await new Promise((resolve, reject) => {
-        writer.write(value, (err) => err ? reject(err) : resolve());
-      });
-    }
-  } finally {
-    reader.releaseLock();
-  }
-  await new Promise((resolve, reject) => {
-    writer.end((err) => err ? reject(err) : resolve());
-  });
-  fs2.renameSync(tmpPath, binPath);
-  if (process.platform !== "win32") {
-    fs2.chmodSync(binPath, 493);
-  }
-}
-async function ensureCloudflared() {
-  const binPath = getCloudflaredBinPath();
-  if (fs2.existsSync(binPath) && isExecutable(binPath)) {
-    return;
-  }
-  const spinner = (0, import_ora2.default)("Downloading cloudflared...").start();
-  try {
-    await downloadCloudflared(binPath);
-    spinner.succeed("cloudflared downloaded.");
-  } catch (err) {
-    spinner.fail("Failed to download cloudflared.");
-    throw err;
-  }
-}
-function spawnCloudflared(port) {
-  return new Promise((resolve, reject) => {
-    const binPath = getCloudflaredBinPath();
-    const proc = (0, import_child_process.spawn)(binPath, ["tunnel", "--url", `http://localhost:${port}`], {
-      stdio: ["ignore", "ignore", "pipe"]
-    });
-    const timer = setTimeout(() => {
-      proc.kill();
-      reject(new Error("Timed out waiting for cloudflared tunnel URL (30s). Is something already running on the port?"));
-    }, TUNNEL_START_TIMEOUT_MS);
-    const rl = readline.createInterface({ input: proc.stderr });
-    rl.on("line", (line) => {
-      const match = line.match(TUNNEL_URL_RE);
-      if (match) {
-        clearTimeout(timer);
-        rl.close();
-        resolve({ process: proc, tunnelUrl: match[0] });
-      }
-    });
-    proc.on("error", (err) => {
-      clearTimeout(timer);
-      reject(new Error(`Failed to start cloudflared: ${err.message}`));
-    });
-    proc.on("exit", (code) => {
-      clearTimeout(timer);
-      if (code !== null && code !== 0) {
-        reject(new Error(`cloudflared exited with code ${code}`));
-      }
-    });
-  });
-}
-function killCloudflared(proc) {
-  try {
-    proc.kill("SIGTERM");
-  } catch {
-  }
-}
-
 // src/lib/traffic.ts
-var import_ws = __toESM(require("ws"));
 var import_chalk2 = __toESM(require("chalk"));
-init_auth();
 var METHOD_COLORS = {
   GET: import_chalk2.default.cyan,
   POST: import_chalk2.default.green,
@@ -439,35 +323,136 @@ function formatLogLine(entry) {
   const ts = now.toTimeString().slice(0, 8);
   return `${import_chalk2.default.gray(`[${ts}]`)} ${colorMethod(entry.method)} ${import_chalk2.default.white(entry.path)} ${import_chalk2.default.gray("\u2192")} ${colorStatus(entry.status)} ${import_chalk2.default.gray(`(${colorLatency(entry.latency)})`)}`;
 }
-function connectTrafficStream(wsUrl, onEntry) {
-  const token = getAccessToken();
-  let ws;
-  let reconnectCount = 0;
-  const MAX_RECONNECTS = 3;
+
+// src/lib/tunnel-client.ts
+var import_ws = __toESM(require("ws"));
+var CHUNK_BYTES = 512 * 1024;
+var PING_INTERVAL_MS = 6e4;
+var MAX_RECONNECT_DELAY_MS = 15e3;
+var STRIP_HEADERS = /* @__PURE__ */ new Set([
+  "host",
+  "content-length",
+  "connection",
+  "keep-alive",
+  "transfer-encoding",
+  "upgrade",
+  "proxy-connection",
+  "expect"
+]);
+function stripHeaders(headers) {
+  const out = {};
+  for (const key of Object.keys(headers)) {
+    if (!STRIP_HEADERS.has(key.toLowerCase())) out[key] = headers[key];
+  }
+  return out;
+}
+function startTunnelClient(opts) {
+  const target = `http://127.0.0.1:${opts.localPort}`;
+  const inflight = /* @__PURE__ */ new Map();
+  let ws = null;
+  let closed = false;
+  let reconnects = 0;
+  let pingTimer;
   function connect() {
-    ws = new import_ws.default(wsUrl, { headers: { Authorization: `Bearer ${token}` } });
-    ws.on("message", (data) => {
-      try {
-        const entry = JSON.parse(data.toString());
-        onEntry(entry);
-      } catch {
-      }
+    const url = `${opts.connectUrl}?project=${encodeURIComponent(opts.projectId)}&token=${encodeURIComponent(opts.token)}`;
+    const socket = new import_ws.default(url);
+    ws = socket;
+    socket.on("open", () => {
+      reconnects = 0;
+      opts.onStatus?.("connected");
+      pingTimer = setInterval(() => {
+        try {
+          socket.send("ping");
+        } catch {
+        }
+      }, PING_INTERVAL_MS);
     });
-    ws.on("close", () => {
-      if (reconnectCount < MAX_RECONNECTS) {
-        reconnectCount++;
-        setTimeout(() => connect(), 2e3);
-      } else {
-        console.warn(import_chalk2.default.yellow("\nTraffic stream disconnected. Stop and restart `apiblaze dev` to reconnect."));
-      }
+    socket.on("message", (data) => handleFrame(socket, data.toString()));
+    socket.on("close", () => {
+      if (pingTimer) clearInterval(pingTimer);
+      if (!closed) scheduleReconnect();
     });
-    ws.on("error", (err) => {
-      console.warn(import_chalk2.default.yellow(`
-Traffic stream error: ${err.message}`));
+    socket.on("error", () => {
     });
-    return ws;
   }
-  return connect();
+  function scheduleReconnect() {
+    const delay = Math.min(1e3 * 2 ** reconnects, MAX_RECONNECT_DELAY_MS);
+    reconnects++;
+    opts.onStatus?.(`disconnected \u2014 reconnecting in ${Math.round(delay / 1e3)}s`);
+    setTimeout(() => {
+      if (!closed) connect();
+    }, delay);
+  }
+  function handleFrame(socket, raw) {
+    let frame;
+    try {
+      frame = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (frame.type === "req") {
+      inflight.set(frame.id, {
+        method: frame.method,
+        path: frame.path,
+        headers: frame.headers ?? {},
+        chunks: [],
+        start: Date.now()
+      });
+      if (frame.bodyLen === 0) finish(socket, frame.id);
+    } else if (frame.type === "chunk") {
+      const f = inflight.get(frame.id);
+      if (!f) return;
+      f.chunks.push(Buffer.from(frame.data ?? "", "base64"));
+      if (frame.final) finish(socket, frame.id);
+    }
+  }
+  function finish(socket, id) {
+    const f = inflight.get(id);
+    if (!f) return;
+    inflight.delete(id);
+    void forward(socket, id, f);
+  }
+  async function forward(socket, id, f) {
+    const body = Buffer.concat(f.chunks);
+    const init = { method: f.method, headers: stripHeaders(f.headers) };
+    if (body.length) init.body = body;
+    let status = 502;
+    try {
+      const resp = await fetch(target + f.path, init);
+      status = resp.status;
+      const buf = Buffer.from(await resp.arrayBuffer());
+      const headers = {};
+      resp.headers.forEach((value, key) => {
+        if (!STRIP_HEADERS.has(key.toLowerCase())) headers[key] = value;
+      });
+      send(socket, { id, type: "res", status, headers, bodyLen: buf.length });
+      for (let off = 0, seq = 0; off < buf.length; off += CHUNK_BYTES) {
+        const slice = buf.subarray(off, Math.min(off + CHUNK_BYTES, buf.length));
+        send(socket, { id, type: "chunk", seq: seq++, data: slice.toString("base64"), final: off + CHUNK_BYTES >= buf.length });
+      }
+    } catch (err) {
+      const message = err?.cause?.message || err?.message || String(err);
+      send(socket, { id, type: "err", message });
+    }
+    opts.onEntry({ method: f.method, path: f.path, status, latency: Date.now() - f.start });
+  }
+  function send(socket, frame) {
+    try {
+      socket.send(JSON.stringify(frame));
+    } catch {
+    }
+  }
+  connect();
+  return {
+    close() {
+      closed = true;
+      if (pingTimer) clearInterval(pingTimer);
+      try {
+        ws?.close();
+      } catch {
+      }
+    }
+  };
 }
 
 // src/commands/dev.ts
@@ -502,7 +487,7 @@ async function runDev(options) {
   }
   let targets;
   {
-    const spinner = (0, import_ora3.default)("Fetching your localhost projects...").start();
+    const spinner = (0, import_ora2.default)("Fetching your localhost projects...").start();
     try {
       targets = await getLocalhostTargets(teamId);
       spinner.stop();
@@ -512,8 +497,8 @@ async function runDev(options) {
     }
   }
   if (targets.length === 0) {
-    console.log(import_chalk3.default.yellow("No projects found with localhost targets."));
-    console.log("Set a project's upstream target to localhost in your APIblaze dashboard, then try again.");
+    console.log(import_chalk3.default.yellow("No projects found with an internal target."));
+    console.log("Set a project's upstream target to localhost or a private IP in your APIblaze dashboard, then try again.");
     process.exit(0);
   }
   let selectedTargets;
@@ -521,7 +506,7 @@ async function runDev(options) {
     const { confirmed } = await import_inquirer.default.prompt([{
       type: "confirm",
       name: "confirmed",
-      message: `Found 1 project targeting localhost \u2014 tunnel "${import_chalk3.default.bold(targets[0].projectName)}" (${targets[0].tenantName})?`,
+      message: `Found 1 project with an internal target \u2014 tunnel "${import_chalk3.default.bold(targets[0].projectName)}" (${targets[0].tenantName})?`,
       default: true
     }]);
     if (!confirmed) {
@@ -533,7 +518,7 @@ async function runDev(options) {
     const { chosen } = await import_inquirer.default.prompt([{
       type: "checkbox",
       name: "chosen",
-      message: `Found ${targets.length} projects targeting localhost \u2014 select which to tunnel:`,
+      message: `Found ${targets.length} projects with an internal target \u2014 select which to tunnel:`,
       choices: targets.map((t) => ({
         name: `${import_chalk3.default.bold(t.projectName)} (${t.tenantName}) \u2014 ${t.target}`,
         value: t,
@@ -551,66 +536,55 @@ async function runDev(options) {
 Tunneling ${selectedTargets.length} project(s) to localhost:${options.port}
 `)
   );
-  await ensureCloudflared();
-  let cfProcess;
-  let tunnelUrl;
-  {
-    const spinner = (0, import_ora3.default)("Starting Cloudflare tunnel...").start();
-    try {
-      ({ process: cfProcess, tunnelUrl } = await spawnCloudflared(options.port));
-      spinner.succeed(`Tunnel active: ${import_chalk3.default.bold.cyan(tunnelUrl)}`);
-    } catch (err) {
-      spinner.fail("Failed to start cloudflared tunnel.");
-      throw err;
-    }
-  }
+  let restore = [];
+  let connect;
   {
-    const spinner = (0, import_ora3.default)("Registering tunnel with APIblaze...").start();
-    let wsUrl;
+    const spinner = (0, import_ora2.default)("Registering tunnel with APIblaze...").start();
     try {
       const result = await putDevTunnel({
-        tunnelUrl,
         targets: selectedTargets.map((t) => ({ projectId: t.projectId, tenantId: t.tenantId }))
       });
-      wsUrl = result.wsUrl;
-      spinner.succeed("Tunnel registered. Proxying traffic.");
+      restore = result.restore ?? [];
+      connect = result.connect;
+      spinner.succeed("Tunnel registered.");
     } catch (err) {
       spinner.fail("Failed to register tunnel.");
-      killCloudflared(cfProcess);
       throw err;
     }
-    let ws;
-    console.log("\n" + import_chalk3.default.gray("\u2500".repeat(60)));
-    console.log(import_chalk3.default.bold("Live traffic") + import_chalk3.default.gray(" (Ctrl+C to stop)"));
-    console.log(import_chalk3.default.gray("\u2500".repeat(60)) + "\n");
-    ws = connectTrafficStream(wsUrl, (entry) => {
-      console.log(formatLogLine(entry));
-    });
-    let isCleaningUp = false;
-    async function cleanup() {
-      if (isCleaningUp) return;
-      isCleaningUp = true;
-      console.log(import_chalk3.default.gray("\n\nShutting down..."));
-      try {
-        ws.close();
-      } catch {
-      }
-      await deleteDevTunnel().catch(() => {
-      });
-      killCloudflared(cfProcess);
-      console.log(import_chalk3.default.green("Tunnel stopped."));
-      process.exit(0);
-    }
-    process.on("SIGINT", () => void cleanup());
-    process.on("SIGTERM", () => void cleanup());
-    await new Promise(() => {
+  }
+  const clients = connect.projects.map(
+    (projectId) => startTunnelClient({
+      connectUrl: connect.url,
+      token: connect.token,
+      projectId,
+      localPort: options.port,
+      onEntry: (entry) => console.log(formatLogLine(entry)),
+      onStatus: (status) => console.log(import_chalk3.default.gray(`[${projectId}] ${status}`))
+    })
+  );
+  console.log("\n" + import_chalk3.default.gray("\u2500".repeat(60)));
+  console.log(import_chalk3.default.bold("Live traffic") + import_chalk3.default.gray(" (Ctrl+C to stop)"));
+  console.log(import_chalk3.default.gray("\u2500".repeat(60)) + "\n");
+  let isCleaningUp = false;
+  async function cleanup() {
+    if (isCleaningUp) return;
+    isCleaningUp = true;
+    console.log(import_chalk3.default.gray("\n\nShutting down..."));
+    for (const client of clients) client.close();
+    await deleteDevTunnel(restore).catch(() => {
     });
+    console.log(import_chalk3.default.green("Tunnel stopped."));
+    process.exit(0);
   }
+  process.on("SIGINT", () => void cleanup());
+  process.on("SIGTERM", () => void cleanup());
+  await new Promise(() => {
+  });
 }
 
 // src/commands/projects.ts
 var import_chalk4 = __toESM(require("chalk"));
-var import_ora4 = __toESM(require("ora"));
+var import_ora3 = __toESM(require("ora"));
 init_auth();
 init_api();
 async function runProjects() {
@@ -647,7 +621,7 @@ async function runProjects() {
   }
   console.log(`${import_chalk4.default.cyan("\u2192")} Team: ${import_chalk4.default.bold(teamName ?? teamId)}
 `);
-  const spinner = (0, import_ora4.default)("Fetching projects...").start();
+  const spinner = (0, import_ora3.default)("Fetching projects...").start();
   let projects;
   try {
     projects = await getProjects(teamId);
@@ -670,7 +644,7 @@ ${projects.length} project${projects.length === 1 ? "" : "s"}`));
 
 // src/commands/create.ts
 var import_chalk5 = __toESM(require("chalk"));
-var import_ora5 = __toESM(require("ora"));
+var import_ora4 = __toESM(require("ora"));
 init_auth();
 init_api();
 function normalizeName(raw) {
@@ -749,7 +723,7 @@ async function runCreate(opts = {}) {
         console.log(import_chalk5.default.yellow("  Name must be at least 3 characters (letters and digits only).\n"));
         continue;
       }
-      const spinner2 = (0, import_ora5.default)("Checking availability...").start();
+      const spinner2 = (0, import_ora4.default)("Checking availability...").start();
       try {
         const check = await checkProxyName(name, teamId);
         spinner2.stop();
@@ -805,7 +779,7 @@ async function runCreate(opts = {}) {
       return;
     }
   }
-  const spinner = !opts.json ? (0, import_ora5.default)("Creating proxy (tenant, keys, dev portal)...").start() : null;
+  const spinner = !opts.json ? (0, import_ora4.default)("Creating proxy (tenant, keys, dev portal)...").start() : null;
   let result;
   try {
     result = await createProxy({ name, target_url: targetUrl, auth_type: auth, team_id: teamId });
@@ -895,7 +869,7 @@ async function runTeam(arg) {
 
 // src/index.ts
 var program = new import_commander.Command();
-program.name("apiblaze").description("APIblaze dev tunnel CLI").version("0.1.0");
+program.name("apiblaze").description("APIblaze dev tunnel CLI").version("0.1.11");
 program.command("login").description("Authenticate with APIblaze").action(async () => {
   try {
     await runLogin();
@@ -928,9 +902,14 @@ program.command("projects").description("List the projects in your team").action
     process.exit(1);
   }
 });
-program.command("dev").description("Start a dev tunnel for your localhost projects").option("-p, --port <number>", "Local port to tunnel", "3000").action(async (opts) => {
+program.command("dev").description("Start a dev tunnel for your localhost projects").argument("[port]", "Local port to tunnel (positional; overrides --port)").option("-p, --port <number>", "Local port to tunnel", "3000").action(async (port, opts) => {
   try {
-    await runDev({ port: parseInt(opts.port, 10) });
+    const resolved = parseInt(port ?? opts.port, 10);
+    if (Number.isNaN(resolved)) {
+      console.error(import_chalk7.default.red(`Invalid port: ${port ?? opts.port}`));
+      process.exit(1);
+    }
+    await runDev({ port: resolved });
   } catch (err) {
     printError(err);
     process.exit(1);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "apiblaze",
-  "version": "0.1.10",
-  "description": "Dev tunnel CLI for APIblaze — route localhost projects through Cloudflare tunnels",
+  "version": "0.1.13",
+  "description": "Dev tunnel CLI for APIblaze — route localhost projects through your APIblaze endpoints",
   "keywords": [
     "apiblaze",
     "dev-tunnel",