apiblaze 0.3.0 → 0.3.1

package/README.md

@@ -36,6 +36,9 @@ npx apiblaze dev
 # Or specify a port
 npx apiblaze dev 3000
 
+# Stream full request/response traffic to a file (JSON lines)
+npx apiblaze dev 3000 --capture-file traffic.jsonl
+
 ```
 
 ## Help
@@ -70,6 +73,17 @@ apiblaze help dev
 
 On Ctrl+C the tunnel is cleanly deregistered.
 
+### Zero-setup conveniences
+
+- **No project yet?** If none of your projects point at this machine, `apiblaze dev`
+  offers to spin up a throwaway dev proxy (random name like `braveotter42`) pointed at
+  `http://localhost:<port>` and tunnels it immediately — pick `none` or `api_key` auth.
+- **Server not running yet?** If nothing is listening on the local port, requests aren't
+  dropped: each one is printed in full (headers + body, with API keys/JWTs masked and JWTs
+  decoded) and answered with a friendly synthetic `200`. The moment your dev server comes
+  up, the next request forwards to it automatically. Add `--capture-file <path>` to also
+  stream every request/response to a JSON-lines file.
+
 ## License
 
 MIT

package/dist/index.js

@@ -221,7 +221,7 @@ var import_commander = require("commander");
 var import_chalk14 = __toESM(require("chalk"));
 
 // package.json
-var version = "0.3.0";
+var version = "0.3.1";
 
 // src/index.ts
 init_types();
@@ -342,6 +342,7 @@ ${import_chalk.default.cyan("\u2192")} Team: ${import_chalk.default.bold(teamNam
 }
 
 // src/commands/dev.ts
+var import_fs = __toESM(require("fs"));
 var import_chalk3 = __toESM(require("chalk"));
 var import_ora2 = __toESM(require("ora"));
 var import_inquirer = __toESM(require("inquirer"));
@@ -376,10 +377,217 @@ function colorLatency(latency) {
   if (latency < 500) return import_chalk2.default.yellow(s);
   return import_chalk2.default.red(s);
 }
+function timestamp() {
+  return (/* @__PURE__ */ new Date()).toTimeString().slice(0, 8);
+}
 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)})`)}`;
+  return `${import_chalk2.default.gray(`[${timestamp()}]`)} ${colorMethod(entry.method)} ${import_chalk2.default.white(entry.path)} ${import_chalk2.default.gray("\u2192")} ${colorStatus(entry.status)} ${import_chalk2.default.gray(`(${colorLatency(entry.latency)})`)}`;
+}
+var SENSITIVE_HEADERS = /* @__PURE__ */ new Set([
+  "authorization",
+  "proxy-authorization",
+  "cookie",
+  "set-cookie",
+  "x-api-key",
+  "api-key",
+  "apikey",
+  "x-auth-token",
+  "x-access-token",
+  "x-refresh-token",
+  "x-amz-security-token",
+  "x-csrf-token"
+]);
+var SENSITIVE_QUERY = /* @__PURE__ */ new Set([
+  "api_key",
+  "apikey",
+  "key",
+  "token",
+  "access_token",
+  "refresh_token",
+  "id_token",
+  "secret",
+  "client_secret",
+  "password",
+  "sig",
+  "signature"
+]);
+function maskSecret(value) {
+  const v = value.trim();
+  if (v.length <= 8) return "\u2022\u2022\u2022\u2022";
+  const head = v.slice(0, 4);
+  const tail = v.slice(-4);
+  return `${head}\u2026${tail} ${import_chalk2.default.gray(`(${v.length} chars, masked)`)}`;
+}
+function base64UrlDecode(seg) {
+  try {
+    const pad = seg.length % 4 === 0 ? "" : "=".repeat(4 - seg.length % 4);
+    const b64 = seg.replace(/-/g, "+").replace(/_/g, "/") + pad;
+    return Buffer.from(b64, "base64").toString("utf8");
+  } catch {
+    return null;
+  }
+}
+function decodeJwt(token) {
+  const parts = token.trim().split(".");
+  if (parts.length !== 3) return null;
+  const headerRaw = base64UrlDecode(parts[0]);
+  const payloadRaw = base64UrlDecode(parts[1]);
+  if (!headerRaw || !payloadRaw) return null;
+  try {
+    const header = JSON.parse(headerRaw);
+    const payload = JSON.parse(payloadRaw);
+    if (!header || typeof header !== "object" || !("alg" in header)) return null;
+    return { header, payload };
+  } catch {
+    return null;
+  }
+}
+function maskPath(path2) {
+  const q = path2.indexOf("?");
+  if (q < 0) return path2;
+  const base = path2.slice(0, q);
+  const query = path2.slice(q + 1);
+  const masked = query.split("&").map((pair) => {
+    const eq = pair.indexOf("=");
+    if (eq < 0) return pair;
+    const name = pair.slice(0, eq);
+    const val = pair.slice(eq + 1);
+    if (val && SENSITIVE_QUERY.has(decodeURIComponent(name).toLowerCase())) {
+      return `${name}=${maskSecret(decodeURIComponent(val))}`;
+    }
+    return pair;
+  }).join("&");
+  return `${base}?${masked}`;
+}
+function formatHeaderLines(name, value) {
+  const lower = name.toLowerCase();
+  if (lower === "authorization" || lower === "proxy-authorization") {
+    const m = /^Bearer\s+(.+)$/i.exec(value.trim());
+    if (m) {
+      const token = m[1];
+      const jwt = decodeJwt(token);
+      if (jwt) {
+        return [
+          `    ${import_chalk2.default.dim(name)}: Bearer ${maskSecret(token)} ${import_chalk2.default.cyan("(JWT)")}`,
+          `      ${import_chalk2.default.gray("\u251C header: ")} ${import_chalk2.default.gray(JSON.stringify(jwt.header))}`,
+          `      ${import_chalk2.default.gray("\u2514 payload:")} ${import_chalk2.default.gray(JSON.stringify(jwt.payload))}`
+        ];
+      }
+      return [`    ${import_chalk2.default.dim(name)}: Bearer ${maskSecret(token)}`];
+    }
+    return [`    ${import_chalk2.default.dim(name)}: ${maskSecret(value)}`];
+  }
+  if (SENSITIVE_HEADERS.has(lower)) {
+    return [`    ${import_chalk2.default.dim(name)}: ${maskSecret(value)}`];
+  }
+  return [`    ${import_chalk2.default.dim(name)}: ${value}`];
+}
+function formatBody(body, contentType) {
+  if (body.length === 0) return import_chalk2.default.gray("    (empty)");
+  if (body.includes(0)) return import_chalk2.default.gray(`    <binary, ${body.length} bytes>`);
+  let text = body.toString("utf8");
+  const ct = (contentType ?? "").toLowerCase();
+  if (ct.includes("json") || /^[[{]/.test(text.trim())) {
+    try {
+      text = JSON.stringify(JSON.parse(text), null, 2);
+    } catch {
+    }
+  }
+  const MAX = 4e3;
+  const truncated = text.length > MAX;
+  const shown = truncated ? text.slice(0, MAX) : text;
+  const indented = shown.split("\n").map((l) => `    ${l}`).join("\n");
+  return indented + (truncated ? import_chalk2.default.gray(`
+    \u2026 (${text.length - MAX} more bytes \u2014 see --capture-file for full)`) : "");
+}
+function formatCapturedRequest(req, note) {
+  const headerLines = Object.keys(req.headers).flatMap((name) => formatHeaderLines(name, req.headers[name]));
+  const contentType = Object.keys(req.headers).find((k) => k.toLowerCase() === "content-type");
+  return [
+    `${import_chalk2.default.gray(`[${timestamp()}]`)} ${import_chalk2.default.magenta("\u26B2 CAPTURED")} ${colorMethod(req.method)} ${import_chalk2.default.white(maskPath(req.path))} ${import_chalk2.default.gray(`\u2014 ${note}`)}`,
+    import_chalk2.default.bold("  Headers:"),
+    ...headerLines,
+    import_chalk2.default.bold("  Body:"),
+    formatBody(req.body, contentType ? req.headers[contentType] : void 0),
+    ""
+  ].join("\n");
+}
+
+// src/lib/random-name.ts
+var ADJECTIVES = [
+  "amber",
+  "azure",
+  "brave",
+  "bright",
+  "calm",
+  "clever",
+  "cosmic",
+  "crisp",
+  "eager",
+  "fancy",
+  "gentle",
+  "happy",
+  "jolly",
+  "keen",
+  "lively",
+  "lucky",
+  "mellow",
+  "merry",
+  "nimble",
+  "noble",
+  "plucky",
+  "quiet",
+  "rapid",
+  "shiny",
+  "smooth",
+  "snappy",
+  "sunny",
+  "swift",
+  "tidy",
+  "vivid",
+  "witty",
+  "zesty"
+];
+var NOUNS = [
+  "badger",
+  "beacon",
+  "cedar",
+  "comet",
+  "dolphin",
+  "ember",
+  "falcon",
+  "finch",
+  "harbor",
+  "heron",
+  "koala",
+  "lark",
+  "lemur",
+  "maple",
+  "meadow",
+  "otter",
+  "panda",
+  "pebble",
+  "puffin",
+  "quail",
+  "raccoon",
+  "river",
+  "robin",
+  "sparrow",
+  "spruce",
+  "tiger",
+  "turtle",
+  "walrus",
+  "willow",
+  "wombat",
+  "yak",
+  "zebra"
+];
+function pick(list) {
+  return list[Math.floor(Math.random() * list.length)];
+}
+function randomProxyName() {
+  const digits = String(Math.floor(Math.random() * 100)).padStart(2, "0");
+  return `${pick(ADJECTIVES)}${pick(NOUNS)}${digits}`;
 }
 
 // src/lib/tunnel-client.ts
@@ -387,6 +595,7 @@ var import_ws = __toESM(require("ws"));
 var CHUNK_BYTES = 512 * 1024;
 var PING_INTERVAL_MS = 6e4;
 var MAX_RECONNECT_DELAY_MS = 15e3;
+var OFFLINE_CODES = /* @__PURE__ */ new Set(["ECONNREFUSED", "ECONNRESET", "ENOTFOUND", "EHOSTUNREACH"]);
 var STRIP_HEADERS = /* @__PURE__ */ new Set([
   "host",
   "content-length",
@@ -404,6 +613,10 @@ function stripHeaders(headers) {
   }
   return out;
 }
+function encodeBody(buf) {
+  if (buf.includes(0)) return { value: buf.toString("base64"), encoding: "base64" };
+  return { value: buf.toString("utf8"), encoding: "utf8" };
+}
 function startTunnelClient(opts) {
   const target = `http://127.0.0.1:${opts.localPort}`;
   const inflight = /* @__PURE__ */ new Map();
@@ -411,6 +624,7 @@ function startTunnelClient(opts) {
   let closed = false;
   let reconnects = 0;
   let pingTimer;
+  let capturing = false;
   function connect() {
     const url = `${opts.connectUrl}?project=${encodeURIComponent(opts.projectId)}&token=${encodeURIComponent(opts.token)}`;
     const socket = new import_ws.default(url);
@@ -470,30 +684,80 @@ function startTunnelClient(opts) {
     inflight.delete(id);
     void forward(socket, id, f);
   }
+  function sendResponse(socket, id, status, headers, body) {
+    send(socket, { id, type: "res", status, headers, bodyLen: body.length });
+    if (body.length === 0) {
+      send(socket, { id, type: "chunk", seq: 0, data: "", final: true });
+      return;
+    }
+    for (let off = 0, seq = 0; off < body.length; off += CHUNK_BYTES) {
+      const slice = body.subarray(off, Math.min(off + CHUNK_BYTES, body.length));
+      send(socket, { id, type: "chunk", seq: seq++, data: slice.toString("base64"), final: off + CHUNK_BYTES >= body.length });
+    }
+  }
+  function record(f, reqBody, status, captured, resHeaders, resBody) {
+    if (!opts.onRecord) return;
+    const req = encodeBody(reqBody);
+    const res = resBody ? encodeBody(resBody) : void 0;
+    opts.onRecord({
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      projectId: opts.projectId,
+      captured,
+      method: f.method,
+      path: f.path,
+      requestHeaders: f.headers,
+      requestBody: reqBody.length ? req.value : void 0,
+      requestBodyEncoding: reqBody.length ? req.encoding : void 0,
+      status,
+      responseHeaders: resHeaders,
+      responseBody: res?.value,
+      responseBodyEncoding: res?.encoding,
+      latencyMs: Date.now() - f.start
+    });
+  }
   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 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 });
+      if (capturing) {
+        capturing = false;
+        opts.onResume?.();
       }
+      sendResponse(socket, id, status, headers, buf);
+      opts.onEntry({ method: f.method, path: f.path, status, latency: Date.now() - f.start });
+      record(f, body, status, false, headers, buf);
     } catch (err) {
       const code = err?.cause?.code;
-      const message = code === "ECONNREFUSED" || code === "ECONNRESET" || code === "ENOTFOUND" || code === "EHOSTUNREACH" ? `No local server reachable at ${target} \u2014 is your dev server running on port ${opts.localPort}?` : err?.cause?.message || err?.message || String(err);
+      if (OFFLINE_CODES.has(code)) {
+        if (!capturing) {
+          capturing = true;
+          opts.onCaptureStart?.();
+        }
+        const note = `no local server on port ${opts.localPort}`;
+        const payload = Buffer.from(JSON.stringify({
+          apiblaze_dev: "captured",
+          message: `No local server on port ${opts.localPort} \u2014 request captured by \`apiblaze dev\`. Start your server and resend to forward it.`,
+          request: { method: f.method, path: f.path }
+        }, null, 2));
+        const headers = { "content-type": "application/json", "x-apiblaze-dev": "captured" };
+        sendResponse(socket, id, 200, headers, payload);
+        opts.onCapture?.({ method: f.method, path: f.path, headers: f.headers, body }, note);
+        record(f, body, 200, true, headers, payload);
+        return;
+      }
+      const message = err?.cause?.message || err?.message || String(err);
       send(socket, { id, type: "err", message });
+      opts.onEntry({ method: f.method, path: f.path, status: 502, latency: Date.now() - f.start });
+      record(f, body, 502, false);
     }
-    opts.onEntry({ method: f.method, path: f.path, status, latency: Date.now() - f.start });
   }
   function send(socket, frame) {
     try {
@@ -515,6 +779,76 @@ function startTunnelClient(opts) {
 }
 
 // src/commands/dev.ts
+async function offerAutoCreate(teamId, port) {
+  if (!process.stdin.isTTY) {
+    console.log(import_chalk3.default.yellow("No projects found with an internal target."));
+    console.log("Point a project at localhost in the dashboard, or run `apiblaze dev` in an interactive terminal to create one automatically.");
+    return null;
+  }
+  const { create } = await import_inquirer.default.prompt([{
+    type: "confirm",
+    name: "create",
+    message: `No project points at this machine. Create a quick dev proxy \u2192 ${import_chalk3.default.bold(`http://localhost:${port}`)} and tunnel it?`,
+    default: true
+  }]);
+  if (!create) return null;
+  const { auth } = await import_inquirer.default.prompt([{
+    type: "list",
+    name: "auth",
+    message: "How should callers authenticate to the new proxy?",
+    choices: [
+      { name: "none \u2014 open to anyone with the URL (simplest)", value: "none" },
+      { name: "api_key \u2014 callers must send an X-API-Key header", value: "api_key" }
+    ],
+    default: "none"
+  }]);
+  let name = randomProxyName();
+  for (let i = 0; i < 8; i++) {
+    const check = await checkProxyName(name, teamId).catch(() => null);
+    if (!check || check.canUseProjectName && check.canUseApiVersion) break;
+    name = randomProxyName();
+  }
+  const spinner = (0, import_ora2.default)(`Creating dev proxy "${name}"...`).start();
+  let result;
+  try {
+    result = await createProxy({ name, target_url: `http://localhost:${port}`, auth_type: auth, team_id: teamId });
+    spinner.succeed(import_chalk3.default.green(`Created dev proxy "${name}".`));
+  } catch (err) {
+    spinner.fail("Failed to create the dev proxy.");
+    throw err;
+  }
+  const version2 = result.api_version || "1.0.0";
+  const endpoint = `https://${name}.apiblaze.com/${version2}/dev`;
+  console.log(`  ${import_chalk3.default.dim("Endpoint:")} ${import_chalk3.default.bold(endpoint)}`);
+  if (auth === "api_key") {
+    const key = result.api_keys?.dev ?? Object.values(result.api_keys ?? {})[0];
+    if (key) {
+      console.log(`  ${import_chalk3.default.dim("API key (dev):")} ${import_chalk3.default.bold.green(key)}`);
+      console.log(import_chalk3.default.dim("  Send it as the X-API-Key header. It may not be shown again."));
+    }
+  }
+  const targets = await getLocalhostTargets(teamId).catch(() => []);
+  const created = targets.find((t) => t.projectId === result.project_id);
+  if (!created) {
+    console.log(import_chalk3.default.yellow("  Proxy created, but it did not appear as a localhost target \u2014 try `apiblaze dev` again."));
+    return null;
+  }
+  return created;
+}
+async function probeLocalServer(port) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), 1500);
+  try {
+    await fetch(`http://127.0.0.1:${port}/`, { method: "HEAD", signal: controller.signal });
+    return true;
+  } catch (err) {
+    if (err?.name === "AbortError") return true;
+    const code = err?.cause?.code;
+    return !(code === "ECONNREFUSED" || code === "ENOTFOUND" || code === "EHOSTUNREACH");
+  } finally {
+    clearTimeout(timer);
+  }
+}
 async function runDev(options) {
   const creds = loadCredentials();
   if (!creds) {
@@ -555,13 +889,15 @@ async function runDev(options) {
       throw err;
     }
   }
-  if (targets.length === 0) {
-    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;
-  if (targets.length === 1) {
+  if (targets.length === 0) {
+    const created = await offerAutoCreate(teamId, options.port);
+    if (!created) {
+      console.log("Set a project's upstream target to localhost or a private IP, then try again.");
+      process.exit(0);
+    }
+    selectedTargets = [created];
+  } else if (targets.length === 1) {
     const { confirmed } = await import_inquirer.default.prompt([{
       type: "confirm",
       name: "confirmed",
@@ -595,6 +931,14 @@ async function runDev(options) {
 Tunneling ${selectedTargets.length} project(s) to localhost:${options.port}
 `)
   );
+  let recordSink;
+  let captureStream;
+  if (options.captureFile) {
+    captureStream = import_fs.default.createWriteStream(options.captureFile, { flags: "a" });
+    recordSink = (r) => captureStream.write(JSON.stringify(r) + "\n");
+    console.log(import_chalk3.default.gray(`Streaming full traffic to ${options.captureFile}
+`));
+  }
   let restore = [];
   let connect;
   {
@@ -618,11 +962,27 @@ Tunneling ${selectedTargets.length} project(s) to localhost:${options.port}
       projectId,
       localPort: options.port,
       onEntry: (entry) => console.log(formatLogLine(entry)),
-      onStatus: (status) => console.log(import_chalk3.default.gray(`[${projectId}] ${status}`))
+      onStatus: (status) => console.log(import_chalk3.default.gray(`[${projectId}] ${status}`)),
+      onCapture: (req, note) => console.log(formatCapturedRequest(req, note)),
+      onCaptureStart: () => console.log(
+        import_chalk3.default.magenta(`
+\u26B2 No local server on port ${options.port} yet \u2014 capturing requests below. Start your server and they'll forward automatically.
+`)
+      ),
+      onResume: () => console.log(
+        import_chalk3.default.green(`
+\u2713 Local server detected on port ${options.port} \u2014 forwarding resumed.
+`)
+      ),
+      onRecord: recordSink
     })
   );
+  const localUp = await probeLocalServer(options.port);
   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(
+    localUp ? import_chalk3.default.green(`\u2713 Local server detected on port ${options.port} \u2014 forwarding live.`) : import_chalk3.default.magenta(`\u26B2 Nothing listening on port ${options.port} yet \u2014 requests will be captured until your server starts.`)
+  );
   console.log(import_chalk3.default.gray("\u2500".repeat(60)) + "\n");
   let isCleaningUp = false;
   async function cleanup() {
@@ -630,6 +990,7 @@ Tunneling ${selectedTargets.length} project(s) to localhost:${options.port}
     isCleaningUp = true;
     console.log(import_chalk3.default.gray("\n\nShutting down..."));
     for (const client of clients) client.close();
+    captureStream?.end();
     await deleteDevTunnel(restore).catch(() => {
     });
     console.log(import_chalk3.default.green("Tunnel stopped."));
@@ -702,7 +1063,7 @@ ${projects.length} project${projects.length === 1 ? "" : "s"}`));
 }
 
 // src/commands/create.ts
-var import_fs = __toESM(require("fs"));
+var import_fs2 = __toESM(require("fs"));
 var import_chalk5 = __toESM(require("chalk"));
 var import_ora4 = __toESM(require("ora"));
 init_auth();
@@ -937,7 +1298,7 @@ async function runAnonymousCreate(opts) {
   if (opts.config) {
     let raw = "";
     try {
-      raw = import_fs.default.readFileSync(opts.config, "utf8");
+      raw = import_fs2.default.readFileSync(opts.config, "utf8");
     } catch {
       fail(`Cannot read --config file: ${opts.config}`);
     }
@@ -1582,14 +1943,14 @@ program.command("mcp").description("Design an MCP server from the spec + traffic
     process.exit(1);
   }
 });
-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) => {
+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").option("-o, --capture-file <path>", "Stream full request/response traffic to a file (JSON lines)").action(async (port, opts) => {
   try {
     const resolved = parseInt(port ?? opts.port, 10);
     if (Number.isNaN(resolved)) {
       console.error(import_chalk14.default.red(`Invalid port: ${port ?? opts.port}`));
       process.exit(1);
     }
-    await runDev({ port: resolved });
+    await runDev({ port: resolved, captureFile: opts.captureFile });
   } catch (err) {
     printError(err);
     process.exit(1);
@@ -1609,11 +1970,15 @@ Examples:
   $ npx apiblaze login
   $ npx apiblaze create --name myapi --target https://api.example.com --auth api_key
 
+  # Dev tunnel \u2014 auto-creates a proxy if none point here, and captures
+  # traffic (full headers + body, secrets masked) until your server is up:
+  $ npx apiblaze dev 3000
+  $ npx apiblaze dev 3000 --capture-file traffic.jsonl
+
   # Manage:
   $ npx apiblaze whoami
   $ npx apiblaze projects
   $ npx apiblaze team
-  $ npx apiblaze dev 3000
   $ npx apiblaze logout
 `
 );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apiblaze",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Dev tunnel CLI for APIblaze — route localhost projects through your APIblaze endpoints",
   "keywords": [
     "apiblaze",