npm - @clawcard/cli - Versions diffs - 0.1.3 → 1.0.0 - Mend

@clawcard/cli 0.1.3 → 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (18) hide show

package/bin/clawcard.mjs ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ #!/usr/bin/env node
2	+ import "../src/index.js";

package/package.json CHANGED Viewed

@@ -1,13 +1,21 @@
 {
   "name": "@clawcard/cli",
-  "version": "0.1.3",
-  "description": "Set up ClawCard for your OpenClaw agent in one command",
+  "version": "1.0.0",
+  "description": "The ClawCard CLI — manage your agent keys, billing, and setup from the terminal",
   "bin": {
-    "clawcard": "./bin/setup.mjs"
+    "clawcard": "./bin/clawcard.mjs"
   },
   "type": "module",
   "license": "MIT",
   "files": [
-    "bin/"
-  ]
+    "bin/",
+    "src/"
+  ],
+  "dependencies": {
+    "@clack/prompts": "^0.10.0",
+    "chalk": "^5.4.1",
+    "clipboardy": "^4.0.0",
+    "commander": "^13.1.0",
+    "open": "^10.1.0"
+  }
 }

package/src/api.js ADDED Viewed

@@ -0,0 +1,55 @@
+import { getToken, BASE_URL } from "./config.js";
+class ApiError extends Error {
+  constructor(status, body) {
+    super(body?.message || body?.error || `API error ${status}`);
+    this.status = status;
+    this.body = body;
+  }
+}
+export { ApiError };
+async function request(path, options = {}) {
+  const token = getToken();
+  if (!token) throw new Error("Not authenticated");
+  const url = `${BASE_URL}${path}`;
+  const headers = {
+    "Content-Type": "application/json",
+    Cookie: `better-auth.session_token=${token}`,
+    ...options.headers,
+  };
+  const res = await fetch(url, { ...options, headers });
+  const body = await res.json().catch(() => null);
+  if (!res.ok) {
+    throw new ApiError(res.status, body);
+  }
+  return body;
+}
+// Agents / Keys
+export const listAgents = () => request("/api/agents");
+export const createAgent = (data) =>
+  request("/api/agents", { method: "POST", body: JSON.stringify(data) });
+export const getAgent = (id) => request(`/api/agents/${id}`);
+export const deleteAgent = (id) =>
+  request(`/api/agents/${id}`, { method: "DELETE" });
+// Billing
+export const getBalance = () => request("/api/billing/balance");
+export const getSubscription = () => request("/api/billing/subscription");
+export const getTransactions = () => request("/api/billing/transactions");
+export const createCheckout = (amountCents) =>
+  request("/api/billing/checkout", {
+    method: "POST",
+    body: JSON.stringify({ amountCents }),
+  });
+export const createPortal = () =>
+  request("/api/billing/portal", { method: "POST" });
+// User
+export const getMe = () => request("/api/me");

package/src/auth-guard.js ADDED Viewed

@@ -0,0 +1,9 @@
+import * as p from "@clack/prompts";
+import { isLoggedIn } from "./config.js";
+export function requireAuth() {
+  if (!isLoggedIn()) {
+    p.log.error("You need to log in first. Run: clawcard login");
+    process.exit(1);
+  }
+}

package/src/auth-server.js ADDED Viewed

@@ -0,0 +1,63 @@
+import http from "http";
+/**
+ * Starts a temporary localhost server that waits for an auth callback.
+ * Returns { promise, port } where:
+ *   - port: Promise<number> that resolves with the port once the server is listening
+ *   - promise: Promise<{ token, email }> that resolves when the callback is received
+ */
+export function startCallbackServer({ timeout = 120_000 } = {}) {
+  let resolvePort;
+  const portPromise = new Promise((r) => {
+    resolvePort = r;
+  });
+  const resultPromise = new Promise((resolve, reject) => {
+    const server = http.createServer((req, res) => {
+      const url = new URL(req.url, "http://localhost");
+      if (url.pathname === "/callback") {
+        const token = url.searchParams.get("token");
+        const email = url.searchParams.get("email");
+        const error = url.searchParams.get("error");
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(`<!DOCTYPE html>
+<html>
+<head><title>ClawCard</title></head>
+<body style="display:flex;align-items:center;justify-content:center;height:100vh;font-family:system-ui;background:#1a1a1a;color:#fff;">
+  <div style="text-align:center;">
+    <h1 style="color:#FF6B35;">&#x1F99E; ClawCard</h1>
+    <p>${error ? "Something went wrong. Please try again in the terminal." : "You're all set! You can close this window."}</p>
+  </div>
+</body>
+</html>`);
+        server.close();
+        clearTimeout(timer);
+        if (error) {
+          reject(new Error(error));
+        } else {
+          resolve({ token, email });
+        }
+      } else {
+        res.writeHead(404);
+        res.end();
+      }
+    });
+    server.listen(0, "127.0.0.1", () => {
+      resolvePort(server.address().port);
+    });
+    const timer = setTimeout(() => {
+      server.close();
+      reject(
+        new Error("Auth timed out — no callback received within 2 minutes")
+      );
+    }, timeout);
+  });
+  return { promise: resultPromise, port: portPromise };
+}

package/src/commands/billing.js ADDED Viewed

@@ -0,0 +1,169 @@
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+import open from "open";
+import { requireAuth } from "../auth-guard.js";
+import {
+  getBalance,
+  getSubscription,
+  getTransactions,
+  createCheckout,
+  createPortal,
+} from "../api.js";
+const orange = chalk.hex("#FF6B35");
+export async function billingCommand() {
+  requireAuth();
+  const s = p.spinner();
+  s.start("Loading billing info...");
+  try {
+    const [balance, sub] = await Promise.all([
+      getBalance(),
+      getSubscription(),
+    ]);
+    s.stop("Billing loaded");
+    const planColors = {
+      free: chalk.gray,
+      starter: chalk.blue,
+      pro: orange,
+    };
+    const colorPlan = (planColors[sub.subscription?.plan] || chalk.white)(
+      sub.subscription?.planName || sub.subscription?.plan || "Free"
+    );
+    const info = [
+      `Plan:     ${colorPlan}`,
+      `Balance:  ${chalk.green("$" + (balance.amountCents / 100).toFixed(2))}`,
+      `Keys:     ${sub.subscription?.currentAgentKeys || 0}/${sub.subscription?.maxAgentKeys || 1}`,
+      `Cards:    ${sub.subscription?.currentCards || 0}/${sub.subscription?.maxCardsPerMonth || 1} this period`,
+    ].join("\n");
+    p.note(info, "Billing");
+    const action = await p.select({
+      message: "What would you like to do?",
+      options: [
+        { value: "topup", label: "Top up balance" },
+        { value: "upgrade", label: "Upgrade plan" },
+        { value: "transactions", label: "View transactions" },
+        { value: "back", label: "Back" },
+      ],
+    });
+    if (p.isCancel(action) || action === "back") return;
+    switch (action) {
+      case "topup":
+        return billingTopupCommand();
+      case "upgrade":
+        return billingUpgradeCommand();
+      case "transactions":
+        return billingTransactionsCommand();
+    }
+  } catch (err) {
+    s.stop("Failed to load billing");
+    p.log.error(err.message);
+  }
+}
+export async function billingBalanceCommand() {
+  requireAuth();
+  const s = p.spinner();
+  s.start("Checking balance...");
+  try {
+    const balance = await getBalance();
+    s.stop("");
+    p.log.info(
+      `Balance: ${chalk.green("$" + (balance.amountCents / 100).toFixed(2))}`
+    );
+  } catch (err) {
+    s.stop("Failed");
+    p.log.error(err.message);
+  }
+}
+export async function billingTopupCommand() {
+  requireAuth();
+  const amount = await p.select({
+    message: "How much would you like to add?",
+    options: [
+      { value: 500, label: "$5.00" },
+      { value: 1000, label: "$10.00" },
+      { value: 2500, label: "$25.00" },
+      { value: 5000, label: "$50.00" },
+      { value: 10000, label: "$100.00" },
+    ],
+  });
+  if (p.isCancel(amount)) return;
+  const s = p.spinner();
+  s.start("Creating checkout...");
+  try {
+    const result = await createCheckout(amount);
+    s.stop("");
+    p.log.info("Opening Stripe checkout in browser...");
+    await open(result.url);
+    p.log.success("Complete the payment in your browser");
+  } catch (err) {
+    s.stop("Failed");
+    p.log.error(err.message);
+  }
+}
+export async function billingUpgradeCommand() {
+  requireAuth();
+  const s = p.spinner();
+  s.start("Opening billing portal...");
+  try {
+    const result = await createPortal();
+    s.stop("");
+    await open(result.url);
+    p.log.success("Manage your subscription in the browser");
+  } catch (err) {
+    s.stop("Failed");
+    p.log.error(err.message);
+  }
+}
+export async function billingTransactionsCommand() {
+  requireAuth();
+  const s = p.spinner();
+  s.start("Fetching transactions...");
+  try {
+    const txns = await getTransactions();
+    s.stop("");
+    if (!txns.length) {
+      p.log.info("No transactions yet");
+      return;
+    }
+    const lines = txns.map((tx) => {
+      const amount =
+        tx.amountCents >= 0
+          ? chalk.green(`+$${(tx.amountCents / 100).toFixed(2)}`)
+          : chalk.red(`-$${(Math.abs(tx.amountCents) / 100).toFixed(2)}`);
+      const date = new Date(tx.createdAt).toLocaleDateString();
+      return `${date}  ${amount}  ${chalk.dim(tx.type)}  ${tx.description || ""}`;
+    });
+    p.note(lines.join("\n"), "Transactions");
+  } catch (err) {
+    s.stop("Failed");
+    p.log.error(err.message);
+  }
+}

package/src/commands/help.js ADDED Viewed

@@ -0,0 +1,49 @@
+import chalk from "chalk";
+const orange = chalk.hex("#FF6B35");
+const dim = chalk.dim;
+const COMMANDS = [
+  ["", ""],
+  [orange.bold("Authentication"), ""],
+  ["  login", "Log in via browser"],
+  ["  signup", "Sign up with invite code"],
+  ["  logout", "Clear session"],
+  ["  whoami", "Show current account"],
+  ["", ""],
+  [orange.bold("Keys"), ""],
+  ["  keys", "Interactive key management"],
+  ["  keys create", "Create a new API key"],
+  ["  keys list", "List all keys"],
+  ["  keys info", "Show key details"],
+  ["  keys revoke", "Revoke a key"],
+  ["", ""],
+  [orange.bold("Setup"), ""],
+  ["  setup", "Install ClawCard skill for your agent"],
+  ["", ""],
+  [orange.bold("Billing"), ""],
+  ["  billing", "Interactive billing dashboard"],
+  ["  billing balance", "Quick balance check"],
+  ["  billing topup", "Top up balance"],
+  ["  billing upgrade", "Upgrade subscription"],
+  ["  billing transactions", "View transaction history"],
+  ["", ""],
+  [orange.bold("Other"), ""],
+  ["  referral", "Show referral code"],
+  ["  help", "Show this help"],
+  ["  --version", "Show version"],
+];
+export function helpCommand() {
+  console.log();
+  for (const [cmd, desc] of COMMANDS) {
+    if (!cmd && !desc) {
+      console.log();
+    } else if (!desc) {
+      console.log(`  ${cmd}`);
+    } else {
+      console.log(`  ${cmd.padEnd(24)}${dim(desc)}`);
+    }
+  }
+  console.log();
+}

package/src/commands/keys.js ADDED Viewed

@@ -0,0 +1,230 @@
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+import { requireAuth } from "../auth-guard.js";
+import { listAgents, createAgent, getAgent, deleteAgent } from "../api.js";
+import { saveKey } from "../config.js";
+const orange = chalk.hex("#FF6B35");
+export async function keysCommand() {
+  requireAuth();
+  const action = await p.select({
+    message: "Key management",
+    options: [
+      { value: "create", label: "Create new key" },
+      { value: "list", label: "List keys" },
+      { value: "revoke", label: "Revoke a key" },
+      { value: "back", label: "Back" },
+    ],
+  });
+  if (p.isCancel(action) || action === "back") return;
+  switch (action) {
+    case "create":
+      return keysCreateCommand();
+    case "list":
+      return keysListCommand();
+    case "revoke":
+      return keysRevokeCommand();
+  }
+}
+export async function keysCreateCommand() {
+  requireAuth();
+  const name = await p.text({
+    message: "Key name",
+    placeholder: "my-agent",
+    validate: (v) => {
+      if (!v?.trim()) return "Name is required";
+    },
+  });
+  if (p.isCancel(name)) return;
+  const spendLimit = await p.text({
+    message: "Spend limit (dollars)",
+    placeholder: "50",
+    validate: (v) => {
+      const n = parseFloat(v);
+      if (isNaN(n) || n <= 0) return "Enter a valid dollar amount";
+    },
+  });
+  if (p.isCancel(spendLimit)) return;
+  const s = p.spinner();
+  s.start("Creating key...");
+  try {
+    const result = await createAgent({
+      name,
+      spendLimitCents: Math.round(parseFloat(spendLimit) * 100),
+    });
+    s.stop("Key created!");
+    // Save raw key locally so `clawcard setup` can use it later
+    saveKey(result.id, result.apiKey, {
+      name: result.name,
+      keyPrefix: result.keyPrefix,
+    });
+    p.note(
+      `${orange.bold(result.apiKey)}\n\n${chalk.dim("This key will only be shown once. Copy it now.")}`,
+      "Your API Key"
+    );
+    const copy = await p.confirm({ message: "Copy to clipboard?" });
+    if (copy && !p.isCancel(copy)) {
+      const { default: clipboardy } = await import("clipboardy");
+      await clipboardy.write(result.apiKey);
+      p.log.success("Copied to clipboard");
+    }
+    if (result.email || result.phone) {
+      p.log.info(
+        [
+          result.email && `Email: ${result.email}`,
+          result.phone && `Phone: ${result.phone}`,
+        ]
+          .filter(Boolean)
+          .join("\n")
+      );
+    }
+  } catch (err) {
+    s.stop("Failed to create key");
+    p.log.error(err.message);
+  }
+}
+export async function keysListCommand() {
+  requireAuth();
+  const s = p.spinner();
+  s.start("Fetching keys...");
+  try {
+    const agents = await listAgents();
+    s.stop("Keys loaded");
+    if (!agents.length) {
+      p.log.info("No keys yet. Create one with: clawcard keys create");
+      return;
+    }
+    const lines = agents.map((a) => {
+      const status =
+        a.status === "active" ? chalk.green("active") : chalk.red(a.status);
+      return [
+        orange.bold(a.name || "unnamed"),
+        chalk.dim(a.keyPrefix + "..."),
+        a.email || "-",
+        a.phone || "-",
+        `$${(a.spendLimitCents / 100).toFixed(2)} limit`,
+        status,
+      ].join("  ");
+    });
+    p.note(lines.join("\n"), "Your Keys");
+  } catch (err) {
+    s.stop("Failed to fetch keys");
+    p.log.error(err.message);
+  }
+}
+export async function keysInfoCommand(keyIdOrPrefix) {
+  requireAuth();
+  const s = p.spinner();
+  if (!keyIdOrPrefix) {
+    s.start("Fetching keys...");
+    let agents;
+    try {
+      agents = await listAgents();
+      s.stop("");
+    } catch (err) {
+      s.stop("Failed");
+      p.log.error(err.message);
+      return;
+    }
+    if (!agents.length) {
+      p.log.info("No keys found");
+      return;
+    }
+    const selected = await p.select({
+      message: "Which key?",
+      options: agents.map((a) => ({
+        value: a.id,
+        label: `${a.name || "unnamed"} (${a.keyPrefix}...)`,
+      })),
+    });
+    if (p.isCancel(selected)) return;
+    keyIdOrPrefix = selected;
+  }
+  s.start("Fetching key details...");
+  try {
+    const agent = await getAgent(keyIdOrPrefix);
+    s.stop("Key details");
+    const info = [
+      `Name:        ${orange.bold(agent.name || "unnamed")}`,
+      `Key prefix:  ${chalk.dim(agent.keyPrefix + "...")}`,
+      `Email:       ${agent.email || "-"}`,
+      `Phone:       ${agent.phone || "-"}`,
+      `Spend limit: $${(agent.spendLimitCents / 100).toFixed(2)}`,
+      `Status:      ${agent.status === "active" ? chalk.green("active") : chalk.red(agent.status)}`,
+      `Created:     ${new Date(agent.createdAt).toLocaleDateString()}`,
+    ].join("\n");
+    p.note(info, "Key Details");
+  } catch (err) {
+    s.stop("Failed");
+    p.log.error(err.message);
+  }
+}
+export async function keysRevokeCommand() {
+  requireAuth();
+  const s = p.spinner();
+  s.start("Fetching keys...");
+  try {
+    const agents = await listAgents();
+    s.stop("");
+    if (!agents.length) {
+      p.log.info("No keys to revoke");
+      return;
+    }
+    const selected = await p.select({
+      message: "Which key do you want to revoke?",
+      options: agents.map((a) => ({
+        value: a.id,
+        label: `${a.name || "unnamed"} (${a.keyPrefix}...)`,
+      })),
+    });
+    if (p.isCancel(selected)) return;
+    const confirm = await p.confirm({
+      message: "Are you sure? This cannot be undone.",
+    });
+    if (p.isCancel(confirm) || !confirm) return;
+    s.start("Revoking key...");
+    await deleteAgent(selected);
+    s.stop("Key revoked");
+    p.log.success("Key has been revoked");
+  } catch (err) {
+    s.stop("Failed");
+    p.log.error(err.message);
+  }
+}

package/src/commands/login.js ADDED Viewed

@@ -0,0 +1,39 @@
+import * as p from "@clack/prompts";
+import open from "open";
+import { startCallbackServer } from "../auth-server.js";
+import { saveConfig, isLoggedIn, getConfig, BASE_URL } from "../config.js";
+export async function loginCommand() {
+  if (isLoggedIn()) {
+    const config = getConfig();
+    p.log.info(`Already logged in as ${config.email}`);
+    const cont = await p.confirm({ message: "Log in as a different account?" });
+    if (p.isCancel(cont) || !cont) return;
+  }
+  const s = p.spinner();
+  s.start("Opening browser...");
+  const { promise, port } = startCallbackServer();
+  const actualPort = await port;
+  const loginUrl = `${BASE_URL}/login?cli=true&port=${actualPort}`;
+  await open(loginUrl);
+  s.message("Waiting for login in browser...");
+  try {
+    const { token, email } = await promise;
+    s.stop("Logged in!");
+    saveConfig({
+      token,
+      email,
+      loggedInAt: new Date().toISOString(),
+    });
+    p.log.success(`Logged in as ${email}`);
+  } catch (err) {
+    s.stop("Login failed");
+    p.log.error(err.message);
+  }
+}

package/src/commands/logout.js ADDED Viewed

@@ -0,0 +1,12 @@
+import * as p from "@clack/prompts";
+import { clearConfig, isLoggedIn } from "../config.js";
+export async function logoutCommand() {
+  if (!isLoggedIn()) {
+    p.log.info("Not logged in");
+    return;
+  }
+  clearConfig();
+  p.log.success("Logged out");
+}

package/src/commands/referral.js ADDED Viewed

@@ -0,0 +1,37 @@
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+import { requireAuth } from "../auth-guard.js";
+import { getMe } from "../api.js";
+const orange = chalk.hex("#FF6B35");
+export async function referralCommand() {
+  requireAuth();
+  const s = p.spinner();
+  s.start("Fetching referral code...");
+  try {
+    const me = await getMe();
+    s.stop("");
+    p.note(
+      [
+        `Your code: ${orange.bold(me.referralCode || "N/A")}`,
+        "",
+        chalk.dim("Share this code — you both get $10 credit!"),
+      ].join("\n"),
+      "Referral"
+    );
+    const copy = await p.confirm({ message: "Copy to clipboard?" });
+    if (copy && !p.isCancel(copy) && me.referralCode) {
+      const { default: clipboardy } = await import("clipboardy");
+      await clipboardy.write(me.referralCode);
+      p.log.success("Copied to clipboard");
+    }
+  } catch (err) {
+    s.stop("Failed");
+    p.log.error(err.message);
+  }
+}