apiblaze 0.1.22 → 0.3.0

package/README.md

@@ -11,7 +11,7 @@ npm install -g apiblaze
 Or run without installing:
 
 ```bash
-npx apiblaze dev
+npx apiblaze --help
 ```
 
 ## Requirements
@@ -21,14 +21,29 @@ npx apiblaze dev
 ## Quick start
 
 ```bash
-# 1. Log in to your APIblaze account
-apiblaze login
+# Create a proxy (no account needed)
+npx apiblaze create --target https://api.example.com
+
+# Optional: sign in if you want it under your team
+npx apiblaze login
+
+# Create a proxy under your team
+npx apiblaze create --name myapi --target https://api.example.com --auth api_key
+
+# Start a dev tunnel (defaults to port 3000)
+npx apiblaze dev
 
-# 2. Start tunneling (default port 3000)
-apiblaze dev
+# Or specify a port
+npx apiblaze dev 3000
 
-# Or specify a different port
-apiblaze dev --port 8080
+```
+
+## Help
+
+```bash
+apiblaze --help
+apiblaze help create
+apiblaze help dev
 ```
 
 ## Commands
@@ -36,20 +51,25 @@ apiblaze dev --port 8080
 | Command | Description |
 |---|---|
 | `apiblaze login` | Authenticate with your APIblaze account |
-| `apiblaze dev [--port <n>]` | Tunnel localhost projects through Cloudflare |
+| `apiblaze create [options]` | Create a new API proxy (anonymous if not logged in) |
+| `apiblaze claim [code]` | Claim an anonymously-created proxy into your team |
+| `apiblaze projects` | List your team projects |
+| `apiblaze dev [port]` | Start a dev tunnel for your localhost projects |
+| `apiblaze team [team]` | Switch the active team |
+| `apiblaze whoami` | Show the signed-in identity and active team |
+| `apiblaze logout` | Sign out and remove stored credentials |
 
 ## 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
+1. Fetches your APIblaze projects that target `localhost` (or other internal targets)
+2. Registers a temporary dev tunnel with APIblaze
+3. Opens a secure connection and forwards incoming requests to your local server
+4. Streams live traffic logs to your terminal in real time
 
 On Ctrl+C the tunnel is cleanly deregistered.
 
 ## License
 
 MIT
-# npm-apiblaze

package/dist/index.js

@@ -93,6 +93,7 @@ var init_auth = __esm({
 // src/lib/api.ts
 var api_exports = {};
 __export(api_exports, {
+  agentCall: () => agentCall,
   checkProxyName: () => checkProxyName,
   claimProxy: () => claimProxy,
   createProxy: () => createProxy,
@@ -147,6 +148,20 @@ async function apiFetch(path2, options = {}) {
   }
   return res.json();
 }
+async function agentCall(path2, method, body) {
+  const token = getAccessToken();
+  const res = await fetch(`${DASHBOARD_BASE}/api/cli/agents`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
+    body: JSON.stringify({ path: path2, method, body })
+  });
+  let data = null;
+  try {
+    data = await res.json();
+  } catch {
+  }
+  return { status: res.status, data };
+}
 async function getTeams() {
   const res = await apiFetch("/api/cli/teams");
   const raw = Array.isArray(res) ? res : res?.teams ?? res?.data ?? [];
@@ -203,10 +218,10 @@ var init_api = __esm({
 
 // src/index.ts
 var import_commander = require("commander");
-var import_chalk10 = __toESM(require("chalk"));
+var import_chalk14 = __toESM(require("chalk"));
 
 // package.json
-var version = "0.1.22";
+var version = "0.3.0";
 
 // src/index.ts
 init_types();
@@ -1200,6 +1215,290 @@ async function runTeam(arg) {
 \u2714 Active team: ${import_chalk9.default.bold(chosen.name)}`));
 }
 
+// src/commands/authz.ts
+var import_chalk11 = __toESM(require("chalk"));
+init_auth();
+init_api();
+
+// src/lib/agent-chat.ts
+var import_readline = __toESM(require("readline"));
+var import_chalk10 = __toESM(require("chalk"));
+init_api();
+async function runAgentChatRepl(opts) {
+  const { title, subtitle, endpoint, buildBody, seedPrompt, summarizeProposal, commands } = opts;
+  console.log("\n" + import_chalk10.default.cyan.bold(title));
+  if (subtitle) console.log(import_chalk10.default.dim(subtitle));
+  const messages = [];
+  const ctx = { proposal: null, lastData: null, log: (s) => console.log(s) };
+  const cmdByName = new Map(commands.map((c) => [c.name, c]));
+  const footer = () => {
+    const parts = [
+      import_chalk10.default.dim("type to chat/refine"),
+      ...commands.map((c) => import_chalk10.default.dim(`/${c.name} ${c.describe}`)),
+      import_chalk10.default.dim("/show"),
+      import_chalk10.default.dim("/drop discard & exit")
+    ];
+    return "  " + import_chalk10.default.dim("[ ") + parts.join(import_chalk10.default.dim(" \xB7 ")) + import_chalk10.default.dim(" ]");
+  };
+  async function turn(content) {
+    messages.push({ role: "user", content });
+    process.stdout.write(import_chalk10.default.dim("  \u2026thinking\n"));
+    const { status, data } = await agentCall(endpoint, "POST", { messages, ...buildBody(messages) });
+    if (status === 402) {
+      console.log(import_chalk10.default.red("  Insufficient credits \u2014 top up to keep using the agents.\n"));
+      messages.pop();
+      return;
+    }
+    if (status >= 400 || !data) {
+      console.log(import_chalk10.default.red(`  Error (${status}): ${(data && data.error) ?? "request failed"}
+`));
+      messages.pop();
+      return;
+    }
+    ctx.lastData = data;
+    const reply = data.reply ?? data.message ?? "(no reply)";
+    messages.push({ role: "assistant", content: reply });
+    console.log("\n" + import_chalk10.default.cyan("agent \u203A ") + reply + "\n");
+    if (data.proposal) {
+      ctx.proposal = data.proposal;
+      const summary = summarizeProposal?.(data);
+      if (summary) console.log(import_chalk10.default.yellow("  " + summary));
+      const ready = commands.filter((c) => c.needsProposal).map((c) => `/${c.name}`).join(" or ");
+      if (ready) console.log(import_chalk10.default.dim(`  Ready \u2014 ${ready} to make it official, or keep refining.`));
+      console.log();
+    }
+    const llm = data.llm;
+    if (llm) {
+      const credits = data.credits_remaining;
+      const left = typeof credits === "number" ? ` \xB7 $${(credits / 100).toFixed(2)} credit left` : "";
+      console.log(import_chalk10.default.dim(`  ~$${(llm.cost_estimate ?? 0).toFixed(4)} \xB7 ${llm.model ?? "?"}${left}`));
+    }
+  }
+  const rl = import_readline.default.createInterface({ input: process.stdin, output: process.stdout });
+  const ask = (q) => new Promise((res) => rl.question(q, res));
+  await turn(seedPrompt);
+  for (; ; ) {
+    console.log(footer());
+    const line = (await ask(import_chalk10.default.green("you \u203A "))).trim();
+    if (!line) continue;
+    if (line === "/drop" || line === "/exit" || line === "/quit") {
+      console.log(import_chalk10.default.dim("  Dropped \u2014 nothing applied.\n"));
+      break;
+    }
+    if (line === "/show") {
+      if (!ctx.proposal) console.log(import_chalk10.default.dim("  No proposal yet \u2014 keep chatting until the agent proposes one.\n"));
+      else console.log("\n" + JSON.stringify(ctx.proposal, null, 2) + "\n");
+      continue;
+    }
+    if (line.startsWith("/")) {
+      const cmd = cmdByName.get(line.slice(1));
+      if (!cmd) {
+        console.log(import_chalk10.default.red(`  Unknown command "${line}". Try one of: ${commands.map((c) => "/" + c.name).join(", ")}, /show, /drop
+`));
+        continue;
+      }
+      if (cmd.needsProposal && !ctx.proposal) {
+        console.log(import_chalk10.default.yellow("  No proposal yet \u2014 keep chatting until the agent generates one, then try again.\n"));
+        continue;
+      }
+      await cmd.run(ctx);
+      continue;
+    }
+    await turn(line);
+  }
+  rl.close();
+}
+
+// src/commands/authz.ts
+async function runAuthz(projectArg, apiVersionArg) {
+  const creds = loadCredentials();
+  if (!creds) throw new Error("Not authenticated. Run `apiblaze login` first.");
+  const teamId = creds.teamId ?? "";
+  const projects = await getProjects(teamId);
+  const match = projects.find((p) => p.projectId === projectArg || p.projectName === projectArg);
+  if (!match) {
+    throw new Error(`Project "${projectArg}" not found in your active team (${creds.teamName ?? teamId}). Run \`apiblaze projects\`.`);
+  }
+  const projectId = match.projectId;
+  const apiVersion = apiVersionArg || match.apiVersion;
+  const tenant = match.tenant || projectId;
+  async function apply(ctx, enable) {
+    const proposal = ctx.proposal;
+    if (!enable) {
+      const m = await agentCall(`/projects/${projectId}/${apiVersion}/policies/model?tenantId=${encodeURIComponent(tenant)}`, "POST", proposal.model);
+      if (m.status === 404) {
+        ctx.log(import_chalk11.default.red("  Authorization store not provisioned yet. Open the dashboard Authorization tab for this project once (it auto-provisions the store), then re-run.\n"));
+        return;
+      }
+      if (m.status >= 400) {
+        ctx.log(import_chalk11.default.red(`  Model save failed (${m.status}): ${m.data?.error ?? ""}
+`));
+        return;
+      }
+    }
+    let ok = 0;
+    let fail4 = 0;
+    for (const r of proposal.routes) {
+      const resource = "/" + String(r.resource || "").replace(/^\/+/, "");
+      const policiesBody = {
+        rule_mode: r.rule_mode === "list" ? "list" : "check-write",
+        on_request_read: Array.isArray(r.on_request_read) ? r.on_request_read : [],
+        post_response_write: Array.isArray(r.post_response_write) ? r.post_response_write : [],
+        list_objects_read: r.list_objects_read ?? null,
+        authentication_config: { require_authentication: true },
+        authorization_enabled: enable
+      };
+      const encoded = resource.replace(/\{/g, "%7B").replace(/\}/g, "%7D");
+      const putPath = `/projects/${projectId}/${apiVersion}/policies/route/${r.method.toUpperCase()}${encoded}`;
+      let res = await agentCall(putPath, "PUT", { ...policiesBody, resource });
+      if (res.status === 404) {
+        res = await agentCall(`/projects/${projectId}/${apiVersion}/policies/route`, "POST", { method: r.method.toUpperCase(), resource, ...policiesBody });
+      }
+      if (res.status >= 200 && res.status < 300) ok++;
+      else fail4++;
+    }
+    if (enable) {
+      const e = await agentCall(`/${projectId}/${apiVersion}/config`, "PATCH", { authorization: { enforce_authorization: true }, tenant });
+      if (e.status >= 400) {
+        ctx.log(import_chalk11.default.red(`  Enforced ${ok} route(s) but turning on the project-level switch failed (${e.status}). Toggle "Enforce Authorization" on in the dashboard.
+`));
+        return;
+      }
+      ctx.log(import_chalk11.default.green(`  \u2713 Enforcement ON \u2014 ${ok} route(s) + project switch on${fail4 ? `, ${fail4} failed` : ""}.
+`));
+    } else {
+      ctx.log(import_chalk11.default.green(`  \u2713 Published (shadow): model + ${ok} route(s)${fail4 ? `, ${fail4} failed` : ""}. Review, then /enable.
+`));
+    }
+  }
+  await runAgentChatRepl({
+    title: `Authorization assistant \u2014 ${projectId} ${apiVersion}`,
+    subtitle: `tenant ${tenant} \xB7 discuss what authorization fits this API, then make it official.`,
+    endpoint: `/projects/${projectId}/${apiVersion}/authz/chat`,
+    buildBody: () => ({ included_sample_ids: [], existing_model: null, existing_routes: [] }),
+    seedPrompt: "Analyze this API and tell me what authorization is feasible. If it is read-only, say so plainly. Then propose options \u2014 do not generate rules yet.",
+    summarizeProposal: (data) => {
+      const proposal = data.proposal;
+      const sim = data.simulation;
+      const cov = sim ? `, ${sim.routes_covered ?? 0} covered by rules` : "";
+      const warn = sim?.blocked_without_backfill ? ` \u26A0 ${sim.blocked_without_backfill} currently-OK request(s) would be denied until tuples exist.` : "";
+      return `Proposal ready: ${proposal.routes.length} route(s)${cov}.${warn}`;
+    },
+    commands: [
+      { name: "publish", describe: "save in shadow mode", needsProposal: true, run: (ctx) => apply(ctx, false) },
+      { name: "enable", describe: "turn on enforcement", needsProposal: true, run: (ctx) => apply(ctx, true) }
+    ]
+  });
+}
+
+// src/commands/openapi.ts
+var import_chalk12 = __toESM(require("chalk"));
+init_auth();
+init_api();
+async function runOpenapi(projectArg, apiVersionArg) {
+  const creds = loadCredentials();
+  if (!creds) throw new Error("Not authenticated. Run `apiblaze login` first.");
+  const projects = await getProjects(creds.teamId ?? "");
+  const match = projects.find((p) => p.projectId === projectArg || p.projectName === projectArg);
+  if (!match) throw new Error(`Project "${projectArg}" not found in your active team. Run \`apiblaze projects\`.`);
+  const projectId = match.projectId;
+  const apiVersion = apiVersionArg || match.apiVersion;
+  console.log(import_chalk12.default.dim("Gathering captured traffic samples\u2026"));
+  const routesRes = await agentCall(`/projects/${projectId}/${apiVersion}/samples/routes`, "GET");
+  if (routesRes.status >= 400) {
+    console.log(import_chalk12.default.red(`Could not list traffic (${routesRes.status}): ${routesRes.data?.error ?? ""}`));
+    return;
+  }
+  const routes = routesRes.data?.routes ?? (Array.isArray(routesRes.data) ? routesRes.data : []);
+  const hashes = routes.map((r) => r.route_hash).filter((h) => !!h);
+  const ids = /* @__PURE__ */ new Set();
+  for (const h of hashes) {
+    const s = await agentCall(`/projects/${projectId}/${apiVersion}/samples/routes/${encodeURIComponent(h)}/samples`, "GET");
+    const arr = s.data?.samples ?? [];
+    for (const x of arr) if (x.sample_id) ids.add(x.sample_id);
+  }
+  const sampleIds = [...ids];
+  if (sampleIds.length === 0) {
+    console.log(import_chalk12.default.yellow("No captured traffic samples found. Hit the dev environment of this proxy to capture some traces, then retry."));
+    return;
+  }
+  async function publish(ctx) {
+    const patch = ctx.proposal.patch;
+    if (!Array.isArray(patch) || patch.length === 0) {
+      ctx.log(import_chalk12.default.green("  Nothing to publish \u2014 the spec already covers the observed traffic.\n"));
+      return;
+    }
+    const specSource = ctx.lastData?.spec_source ?? "unknown";
+    const endpoint = specSource === "github" ? "open-pr" : "publish-openapi";
+    const pub = await agentCall(`/projects/${projectId}/${apiVersion}/samples/${endpoint}`, "POST", { patch, sample_ids_used: sampleIds });
+    if (pub.status >= 400) {
+      ctx.log(import_chalk12.default.red(`  Publish failed (${pub.status}): ${pub.data?.error ?? ""}
+`));
+      return;
+    }
+    const prUrl = pub.data?.pr_url;
+    ctx.log(import_chalk12.default.green(prUrl ? `  \u2713 Pull request opened: ${prUrl}
+` : "  \u2713 Published updated OpenAPI spec.\n"));
+  }
+  await runAgentChatRepl({
+    title: `API-docs assistant \u2014 ${projectId} ${apiVersion}`,
+    subtitle: `${sampleIds.length} captured sample(s) \xB7 discuss what to document, then make it official.`,
+    endpoint: `/projects/${projectId}/${apiVersion}/openapi/chat`,
+    buildBody: () => ({ included_sample_ids: sampleIds }),
+    seedPrompt: "Compare the captured samples against the current spec and tell me what's missing or wrong. List the changes you'd make \u2014 don't produce a patch yet.",
+    summarizeProposal: (data) => {
+      const patch = data.proposal.patch;
+      const n = Array.isArray(patch) ? patch.length : 0;
+      return n === 0 ? "The spec already covers the observed traffic \u2014 nothing to publish." : `Patch ready: ${n} additive change(s) to the OpenAPI spec.`;
+    },
+    commands: [
+      { name: "publish", describe: "publish / open PR", needsProposal: true, run: publish }
+    ]
+  });
+}
+
+// src/commands/mcp.ts
+var import_chalk13 = __toESM(require("chalk"));
+init_auth();
+init_api();
+async function runMcp(projectArg, apiVersionArg, opts) {
+  const creds = loadCredentials();
+  if (!creds) throw new Error("Not authenticated. Run `apiblaze login` first.");
+  const projects = await getProjects(creds.teamId ?? "");
+  const match = projects.find((p) => p.projectId === projectArg || p.projectName === projectArg);
+  if (!match) throw new Error(`Project "${projectArg}" not found in your active team. Run \`apiblaze projects\`.`);
+  const projectId = match.projectId;
+  const apiVersion = apiVersionArg || match.apiVersion;
+  const environment = opts.environment || "prod";
+  async function publish(ctx) {
+    const spec = ctx.proposal;
+    const pub = await agentCall(`/projects/${projectId}/${apiVersion}/mcp/spec`, "PUT", { environment, spec });
+    if (pub.status >= 400) {
+      ctx.log(import_chalk13.default.red(`  Publish failed (${pub.status}): ${pub.data?.error ?? ""}
+`));
+      return;
+    }
+    ctx.log(import_chalk13.default.green(`  \u2713 Published MCP server \u2014 ${projectId}.mcp.apiblaze.com/${apiVersion}/${environment}.
+`));
+  }
+  await runAgentChatRepl({
+    title: `MCP builder \u2014 ${projectId} ${apiVersion} (${environment})`,
+    subtitle: "discuss which routes to expose as tools, then make the catalogue official.",
+    endpoint: `/projects/${projectId}/${apiVersion}/mcp/chat`,
+    buildBody: () => ({ environment, included_sample_ids: [] }),
+    seedPrompt: "Look at this API's routes and recommend which should become MCP tools, with good names and descriptions. Don't finalize yet \u2014 explain first.",
+    summarizeProposal: (data) => {
+      const spec = data.proposal;
+      const tools = Array.isArray(spec.tools) ? spec.tools : [];
+      const names = tools.slice(0, 12).map((t) => t.name ?? "(unnamed)").join(", ");
+      return `Catalogue ready: ${tools.length} tool(s)${names ? ` \u2014 ${names}${tools.length > 12 ? ", \u2026" : ""}` : ""}.`;
+    },
+    commands: [
+      { name: "publish", describe: `to ${projectId}.mcp.apiblaze.com`, needsProposal: true, run: publish }
+    ]
+  });
+}
+
 // src/index.ts
 var program = new import_commander.Command();
 program.name("apiblaze").description("APIblaze CLI \u2014 create & manage API proxies and run dev tunnels").version(version);
@@ -1259,11 +1558,35 @@ program.command("projects").description("List the projects in your team").action
     process.exit(1);
   }
 });
+program.command("authz").description("Design API authorization interactively (chat), then publish + enable it").argument("<project>", "Project name or id (see `apiblaze projects`)").argument("[apiVersion]", "API version (defaults to the project's version)").action(async (project, apiVersion) => {
+  try {
+    await runAuthz(project, apiVersion);
+  } catch (err) {
+    printError(err);
+    process.exit(1);
+  }
+});
+program.command("openapi").description("Design your OpenAPI spec from captured traffic interactively (chat), then publish it").argument("<project>", "Project name or id (see `apiblaze projects`)").argument("[apiVersion]", "API version (defaults to the project's version)").action(async (project, apiVersion) => {
+  try {
+    await runOpenapi(project, apiVersion);
+  } catch (err) {
+    printError(err);
+    process.exit(1);
+  }
+});
+program.command("mcp").description("Design an MCP server from the spec + traffic interactively (chat), then publish it").argument("<project>", "Project name or id (see `apiblaze projects`)").argument("[apiVersion]", "API version (defaults to the project's version)").option("--environment <env>", "Environment to publish (default: prod)").action(async (project, apiVersion, opts) => {
+  try {
+    await runMcp(project, apiVersion, opts);
+  } catch (err) {
+    printError(err);
+    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) => {
   try {
     const resolved = parseInt(port ?? opts.port, 10);
     if (Number.isNaN(resolved)) {
-      console.error(import_chalk10.default.red(`Invalid port: ${port ?? opts.port}`));
+      console.error(import_chalk14.default.red(`Invalid port: ${port ?? opts.port}`));
       process.exit(1);
     }
     await runDev({ port: resolved });
@@ -1296,13 +1619,13 @@ Examples:
 );
 function printError(err) {
   if (err instanceof ApiError) {
-    console.error(import_chalk10.default.red(`
+    console.error(import_chalk14.default.red(`
 API error (${err.status}): ${err.message}`));
   } else if (err instanceof Error) {
-    console.error(import_chalk10.default.red(`
+    console.error(import_chalk14.default.red(`
 Error: ${err.message}`));
   } else {
-    console.error(import_chalk10.default.red("\nUnknown error"));
+    console.error(import_chalk14.default.red("\nUnknown error"));
   }
 }
 program.parse(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apiblaze",
-  "version": "0.1.22",
+  "version": "0.3.0",
   "description": "Dev tunnel CLI for APIblaze — route localhost projects through your APIblaze endpoints",
   "keywords": [
     "apiblaze",
@@ -27,7 +27,7 @@
     "build:watch": "tsup --watch",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "npm run build && npm run typecheck",
-    "release": "bash scripts/release.sh"
+    "release": "bash release.sh"
   },
   "dependencies": {
     "chalk": "^4.1.2",