apiblaze 0.1.0

package/README.md

@@ -0,0 +1,54 @@
+# apiblaze
+
+CLI for [APIblaze](https://apiblaze.com) — instantly tunnel localhost to your APIblaze projects during development.
+
+## Installation
+
+```bash
+npm install -g apiblaze
+```
+
+Or run without installing:
+
+```bash
+npx apiblaze dev
+```
+
+## Requirements
+
+- Node.js 18+
+
+## Quick start
+
+```bash
+# 1. Log in to your APIblaze account
+apiblaze login
+
+# 2. Start tunneling (default port 3000)
+apiblaze dev
+
+# Or specify a different port
+apiblaze dev --port 8080
+```
+
+## Commands
+
+| Command | Description |
+|---|---|
+| `apiblaze login` | Authenticate with your APIblaze account |
+| `apiblaze dev [--port <n>]` | Tunnel localhost projects through Cloudflare |
+
+## How it works
+
+`apiblaze dev` automatically:
+
+1. Finds all your APIblaze projects that target `localhost`
+2. Downloads and starts a [Cloudflare Quick Tunnel](https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/do-more-with-tunnels/trycloudflare/) (no account required)
+3. Registers the tunnel URL with APIblaze so incoming API requests are forwarded to your machine
+4. Streams live traffic logs to your terminal in real-time
+
+On Ctrl+C the tunnel is cleanly deregistered.
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,517 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/index.ts
+var import_commander = require("commander");
+var import_chalk4 = __toESM(require("chalk"));
+
+// src/types.ts
+var ApiError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "ApiError";
+  }
+};
+
+// src/commands/login.ts
+var import_chalk = __toESM(require("chalk"));
+var import_ora = __toESM(require("ora"));
+
+// src/lib/auth.ts
+var fs = __toESM(require("fs"));
+var os = __toESM(require("os"));
+var path = __toESM(require("path"));
+var APIBLAZE_DIR = path.join(os.homedir(), ".apiblaze");
+var CREDENTIALS_PATH = path.join(APIBLAZE_DIR, "credentials.json");
+function saveCredentials(creds) {
+  fs.mkdirSync(APIBLAZE_DIR, { recursive: true });
+  fs.writeFileSync(CREDENTIALS_PATH, JSON.stringify(creds, null, 2), "utf-8");
+  fs.chmodSync(CREDENTIALS_PATH, 384);
+}
+function loadCredentials() {
+  try {
+    const raw = fs.readFileSync(CREDENTIALS_PATH, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function getAccessToken() {
+  const creds = loadCredentials();
+  if (!creds) {
+    throw new Error("Not authenticated. Run `apiblaze login` first.");
+  }
+  if (Date.now() >= creds.expiresAt) {
+    throw new Error("Session expired. Run `apiblaze login` to re-authenticate.");
+  }
+  return creds.accessToken;
+}
+function getApiblazeDir() {
+  return APIBLAZE_DIR;
+}
+
+// src/commands/login.ts
+var AUTH_BASE = "https://auth.apiblaze.com";
+var CLIENT_ID = "emdE4-Pt9LGOAXL5MA1zEQ";
+function openBrowser(url) {
+  const { exec } = require("child_process");
+  const cmd = process.platform === "darwin" ? `open "${url}"` : process.platform === "win32" ? `start "${url}"` : `xdg-open "${url}"`;
+  exec(cmd, () => {
+  });
+}
+async function requestDeviceCode() {
+  const res = await fetch(`${AUTH_BASE}/oauth/device/code`, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({ client_id: CLIENT_ID, scope: "offline_access" })
+  });
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`Failed to start device flow: ${res.status} ${body}`);
+  }
+  return res.json();
+}
+async function pollForToken(deviceCode, intervalSecs) {
+  let pollInterval = intervalSecs * 1e3;
+  while (true) {
+    await new Promise((r) => setTimeout(r, pollInterval));
+    const res = await fetch(`${AUTH_BASE}/oauth/token`, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+        device_code: deviceCode,
+        client_id: CLIENT_ID
+      })
+    });
+    const body = await res.json();
+    if (res.ok) {
+      return body;
+    }
+    if (body.error === "authorization_pending") {
+      continue;
+    } else if (body.error === "slow_down") {
+      pollInterval += 5e3;
+    } else if (body.error === "expired_token") {
+      throw new Error("Device code expired. Run `apiblaze login` again.");
+    } else if (body.error === "access_denied") {
+      throw new Error("Login was denied or cancelled.");
+    } else {
+      throw new Error(`Unexpected error during login: ${body.error ?? "unknown"}`);
+    }
+  }
+}
+async function runLogin() {
+  console.log(import_chalk.default.bold("\nLogging in to APIblaze...\n"));
+  const deviceAuth = await requestDeviceCode();
+  console.log(`${import_chalk.default.cyan("\u2192")} Open this URL in your browser:`);
+  console.log(`  ${import_chalk.default.bold.underline(deviceAuth.verification_uri_complete ?? deviceAuth.verification_uri)}
+`);
+  if (!deviceAuth.verification_uri_complete) {
+    console.log(`${import_chalk.default.cyan("\u2192")} Enter code: ${import_chalk.default.bold(deviceAuth.user_code)}
+`);
+  }
+  openBrowser(deviceAuth.verification_uri_complete ?? deviceAuth.verification_uri);
+  const spinner = (0, import_ora.default)("Waiting for authorization...").start();
+  const token = await pollForToken(deviceAuth.device_code, deviceAuth.interval);
+  saveCredentials({
+    accessToken: token.access_token,
+    refreshToken: token.refresh_token,
+    expiresAt: Date.now() + token.expires_in * 1e3,
+    tokenType: token.token_type
+  });
+  spinner.succeed(import_chalk.default.green("Logged in successfully!"));
+}
+
+// src/commands/dev.ts
+var import_chalk3 = __toESM(require("chalk"));
+var import_ora3 = __toESM(require("ora"));
+var import_inquirer = __toESM(require("inquirer"));
+
+// src/lib/api.ts
+var API_BASE = "https://adminapioauth.abz.run/1.0.0/prod";
+async function apiFetch(path3, options = {}) {
+  const token = getAccessToken();
+  const url = `${API_BASE}${path3}`;
+  const res = await fetch(url, {
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`,
+      ...options.headers ?? {}
+    }
+  });
+  if (!res.ok) {
+    let message = res.statusText;
+    try {
+      const body = await res.json();
+      message = body.message ?? body.error ?? message;
+    } catch {
+    }
+    throw new ApiError(res.status, message);
+  }
+  if (res.status === 204) {
+    return void 0;
+  }
+  return res.json();
+}
+async function getLocalhostTargets() {
+  return apiFetch("/projects/localhost-targets");
+}
+async function putDevTunnel(payload) {
+  return apiFetch("/dev-tunnel", {
+    method: "PUT",
+    body: JSON.stringify(payload)
+  });
+}
+async function deleteDevTunnel() {
+  return apiFetch("/dev-tunnel", { method: "DELETE" });
+}
+
+// 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"));
+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"));
+var METHOD_COLORS = {
+  GET: import_chalk2.default.cyan,
+  POST: import_chalk2.default.green,
+  PUT: import_chalk2.default.yellow,
+  PATCH: import_chalk2.default.magenta,
+  DELETE: import_chalk2.default.red,
+  HEAD: import_chalk2.default.blue,
+  OPTIONS: import_chalk2.default.gray
+};
+function colorMethod(method) {
+  const colorFn = METHOD_COLORS[method.toUpperCase()] ?? import_chalk2.default.white;
+  return colorFn(method.padEnd(7));
+}
+function colorStatus(status) {
+  const s = String(status);
+  if (status >= 500) return import_chalk2.default.red(s);
+  if (status >= 400) return import_chalk2.default.yellow(s);
+  if (status >= 300) return import_chalk2.default.cyan(s);
+  return import_chalk2.default.green(s);
+}
+function colorLatency(latency) {
+  const s = `${latency}ms`;
+  if (latency < 100) return import_chalk2.default.green(s);
+  if (latency < 500) return import_chalk2.default.yellow(s);
+  return import_chalk2.default.red(s);
+}
+function formatLogLine(entry) {
+  const now = /* @__PURE__ */ new Date();
+  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;
+  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 {
+      }
+    });
+    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."));
+      }
+    });
+    ws.on("error", (err) => {
+      console.warn(import_chalk2.default.yellow(`
+Traffic stream error: ${err.message}`));
+    });
+    return ws;
+  }
+  return connect();
+}
+
+// src/commands/dev.ts
+async function runDev(options) {
+  const creds = loadCredentials();
+  if (!creds) {
+    console.error(import_chalk3.default.red("Not logged in. Run `apiblaze login` first."));
+    process.exit(1);
+  }
+  let targets;
+  {
+    const spinner = (0, import_ora3.default)("Fetching your localhost projects...").start();
+    try {
+      targets = await getLocalhostTargets();
+      spinner.stop();
+    } catch (err) {
+      spinner.fail("Failed to fetch projects.");
+      throw err;
+    }
+  }
+  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.");
+    process.exit(0);
+  }
+  let selectedTargets;
+  if (targets.length === 1) {
+    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})?`,
+      default: true
+    }]);
+    if (!confirmed) {
+      console.log("Aborted.");
+      process.exit(0);
+    }
+    selectedTargets = targets;
+  } else {
+    const { chosen } = await import_inquirer.default.prompt([{
+      type: "checkbox",
+      name: "chosen",
+      message: `Found ${targets.length} projects targeting localhost \u2014 select which to tunnel:`,
+      choices: targets.map((t) => ({
+        name: `${import_chalk3.default.bold(t.projectName)} (${t.tenantName}) \u2014 ${t.target}`,
+        value: t,
+        checked: true
+      }))
+    }]);
+    if (chosen.length === 0) {
+      console.log("No projects selected. Aborted.");
+      process.exit(0);
+    }
+    selectedTargets = chosen;
+  }
+  console.log(
+    import_chalk3.default.green(`
+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;
+    }
+  }
+  {
+    const spinner = (0, import_ora3.default)("Registering tunnel with APIblaze...").start();
+    let wsUrl;
+    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.");
+    } 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(() => {
+    });
+  }
+}
+
+// src/index.ts
+var program = new import_commander.Command();
+program.name("apiblaze").description("APIblaze dev tunnel CLI").version("0.1.0");
+program.command("login").description("Authenticate with APIblaze").action(async () => {
+  try {
+    await runLogin();
+  } catch (err) {
+    printError(err);
+    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) => {
+  try {
+    await runDev({ port: parseInt(opts.port, 10) });
+  } catch (err) {
+    printError(err);
+    process.exit(1);
+  }
+});
+function printError(err) {
+  if (err instanceof ApiError) {
+    console.error(import_chalk4.default.red(`
+API error (${err.status}): ${err.message}`));
+  } else if (err instanceof Error) {
+    console.error(import_chalk4.default.red(`
+Error: ${err.message}`));
+  } else {
+    console.error(import_chalk4.default.red("\nUnknown error"));
+  }
+}
+program.parse(process.argv);

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "apiblaze",
+  "version": "0.1.0",
+  "description": "Dev tunnel CLI for APIblaze — route localhost projects through Cloudflare tunnels",
+  "keywords": [
+    "apiblaze",
+    "dev-tunnel",
+    "cloudflared",
+    "api",
+    "proxy"
+  ],
+  "license": "MIT",
+  "author": "APIblaze",
+  "bin": {
+    "apiblaze": "dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "build:watch": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build && npm run typecheck"
+  },
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "commander": "^11.1.0",
+    "inquirer": "^8.2.6",
+    "ora": "^5.4.1",
+    "ws": "^8.17.0"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^8.2.10",
+    "@types/node": "^20.0.0",
+    "@types/ws": "^8.5.10",
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0"
+  }
+}