@clawcard/cli 0.1.3 → 1.0.0

package/src/commands/setup.js

@@ -0,0 +1,291 @@
+import * as p from "@clack/prompts";
+import { execSync } from "child_process";
+import {
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  existsSync,
+} from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { requireAuth } from "../auth-guard.js";
+import { listAgents } from "../api.js";
+import { getSavedKey } from "../config.js";
+import chalk from "chalk";
+
+const orange = chalk.hex("#FF6B35");
+const home = homedir();
+
+// ── Per-harness env var writers ──
+
+const HARNESSES = [
+  {
+    value: "claude-code",
+    label: "Claude Code",
+    hint: "~/.claude/settings.json",
+    write(apiKey) {
+      const settingsPath = join(home, ".claude", "settings.json");
+      let settings = {};
+      try {
+        settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+      } catch {
+        // doesn't exist yet
+      }
+      if (!settings.env) settings.env = {};
+      settings.env.CLAWCARD_API_KEY = apiKey;
+      mkdirSync(join(home, ".claude"), { recursive: true });
+      writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+      return settingsPath;
+    },
+  },
+  {
+    value: "cursor",
+    label: "Cursor",
+    hint: ".cursor/environment.json (project)",
+    write(apiKey) {
+      const envPath = join(process.cwd(), ".cursor", "environment.json");
+      let config = {};
+      try {
+        config = JSON.parse(readFileSync(envPath, "utf-8"));
+      } catch {
+        // doesn't exist yet
+      }
+      if (!config.env) config.env = {};
+      config.env.CLAWCARD_API_KEY = apiKey;
+      mkdirSync(join(process.cwd(), ".cursor"), { recursive: true });
+      writeFileSync(envPath, JSON.stringify(config, null, 2));
+      return envPath;
+    },
+  },
+  {
+    value: "openclaw",
+    label: "OpenClaw",
+    hint: "~/.openclaw/.env",
+    write(apiKey) {
+      const envPath = join(home, ".openclaw", ".env");
+      let content = "";
+      try {
+        content = readFileSync(envPath, "utf-8");
+      } catch {
+        // doesn't exist
+      }
+      const regex = /^CLAWCARD_API_KEY=.*$/m;
+      if (regex.test(content)) {
+        content = content.replace(regex, `CLAWCARD_API_KEY=${apiKey}`);
+      } else {
+        content = content.trimEnd() + `\nCLAWCARD_API_KEY=${apiKey}\n`;
+      }
+      mkdirSync(join(home, ".openclaw"), { recursive: true });
+      writeFileSync(envPath, content);
+      return envPath;
+    },
+  },
+  {
+    value: "codex",
+    label: "Codex (OpenAI)",
+    hint: "shell env",
+    write(apiKey) {
+      // Codex reads from shell env; write to ~/.clawcard/.env and instruct user
+      return writeToClawcardEnv(apiKey);
+    },
+  },
+  {
+    value: "cline",
+    label: "Cline",
+    hint: "shell env",
+    write(apiKey) {
+      // Cline reads from shell env; write to ~/.clawcard/.env and instruct user
+      return writeToClawcardEnv(apiKey);
+    },
+  },
+  {
+    value: "other",
+    label: "Other / manual",
+    hint: "~/.clawcard/.env",
+    write(apiKey) {
+      return writeToClawcardEnv(apiKey);
+    },
+  },
+];
+
+function writeToClawcardEnv(apiKey) {
+  const envPath = join(home, ".clawcard", ".env");
+  mkdirSync(join(home, ".clawcard"), { recursive: true });
+  let content = "";
+  try {
+    content = readFileSync(envPath, "utf-8");
+  } catch {
+    // doesn't exist
+  }
+  const regex = /^CLAWCARD_API_KEY=.*$/m;
+  if (regex.test(content)) {
+    content = content.replace(regex, `CLAWCARD_API_KEY=${apiKey}`);
+  } else {
+    content = content.trimEnd() + `\nCLAWCARD_API_KEY=${apiKey}\n`;
+  }
+  writeFileSync(envPath, content);
+  return envPath;
+}
+
+export async function setupCommand() {
+  requireAuth();
+
+  p.intro(orange.bold("Agent Setup"));
+
+  // Step 1: Pick or create a key
+  const s = p.spinner();
+  s.start("Fetching your keys...");
+
+  let agents;
+  try {
+    agents = await listAgents();
+    s.stop("");
+  } catch (err) {
+    s.stop("Failed to fetch keys");
+    p.log.error(err.message);
+    return;
+  }
+
+  if (agents.length === 0) {
+    p.log.info("You don't have any keys yet. Let's create one first.");
+    const { keysCreateCommand } = await import("./keys.js");
+    await keysCreateCommand();
+    return setupCommand();
+  }
+
+  const keyChoice = await p.select({
+    message: "Which API key should this agent use?",
+    options: [
+      ...agents.map((a) => ({
+        value: a.id,
+        label: `${a.name || "unnamed"} (${a.keyPrefix}...)`,
+        hint: a.email,
+      })),
+      { value: "create", label: "Create a new key" },
+    ],
+  });
+
+  if (p.isCancel(keyChoice)) return;
+
+  if (keyChoice === "create") {
+    const { keysCreateCommand } = await import("./keys.js");
+    await keysCreateCommand();
+    return setupCommand();
+  }
+
+  const selectedKey = agents.find((a) => a.id === keyChoice);
+
+  // Step 2: Get the raw API key
+  let apiKey = getSavedKey(keyChoice);
+
+  if (!apiKey) {
+    p.log.warn("Raw API key not found locally (it's only shown at creation).");
+    const pastedKey = await p.text({
+      message: "Paste the API key for this agent",
+      placeholder: "ak_live_...",
+      validate: (v) => {
+        if (!v?.startsWith("ak_live_")) return "Must start with ak_live_";
+      },
+    });
+    if (p.isCancel(pastedKey)) return;
+    apiKey = pastedKey;
+  }
+
+  // Step 3: Which harness?
+  const harness = await p.select({
+    message: "Which agent harness are you using?",
+    options: HARNESSES.map((h) => ({
+      value: h.value,
+      label: h.label,
+      hint: h.hint,
+    })),
+  });
+
+  if (p.isCancel(harness)) return;
+
+  // Step 4: Global or project?
+  const scope = await p.select({
+    message: "Install skill globally or for this project?",
+    options: [
+      {
+        value: "global",
+        label: "Global",
+        hint: "available to all your agents everywhere",
+      },
+      {
+        value: "project",
+        label: "This project",
+        hint: "scoped to current directory",
+      },
+    ],
+  });
+
+  if (p.isCancel(scope)) return;
+
+  // Step 5: Install skill via skills.sh
+  const s2 = p.spinner();
+  s2.start("Installing ClawCard skill...");
+
+  try {
+    const globalFlag = scope === "global" ? " -g" : "";
+    execSync(`npx -y skills add clawcard/skill${globalFlag} -y`, {
+      stdio: "pipe",
+      timeout: 60_000,
+    });
+    s2.stop("Skill installed!");
+  } catch {
+    s2.stop("Skill installation failed");
+    p.log.warn(
+      "Failed to install skill via skills.sh. You can install it manually:"
+    );
+    p.log.info(
+      `Run: npx skills add clawcard/skill${scope === "global" ? " -g" : ""}`
+    );
+  }
+
+  // Step 6: Write API key to harness-specific location
+  const s3 = p.spinner();
+  s3.start("Configuring API key...");
+
+  const harnessConfig = HARNESSES.find((h) => h.value === harness);
+  const writtenPath = harnessConfig.write(apiKey);
+
+  s3.stop("API key configured!");
+
+  // Step 7: Harness-specific follow-up instructions
+  const needsShellExport = ["codex", "cline", "other"].includes(harness);
+
+  if (needsShellExport) {
+    p.note(
+      [
+        `Key saved to: ${chalk.dim(writtenPath)}`,
+        "",
+        `Add this to your shell profile (.zshrc, .bashrc):`,
+        "",
+        orange(`  export CLAWCARD_API_KEY="${apiKey}"`),
+        "",
+        chalk.dim("Or source the env file:"),
+        orange(`  source ${writtenPath}`),
+      ].join("\n"),
+      "Manual step required"
+    );
+  } else {
+    p.log.info(`Key written to ${chalk.dim(writtenPath)}`);
+  }
+
+  // Step 8: Summary
+  p.log.success("Your agent is ready to use ClawCard!");
+  p.log.info(
+    [
+      `Key:   ${orange(selectedKey.name || "unnamed")} (${selectedKey.keyPrefix}...)`,
+      selectedKey.email && `Email: ${selectedKey.email}`,
+      selectedKey.phone && `Phone: ${selectedKey.phone}`,
+    ]
+      .filter(Boolean)
+      .join("\n")
+  );
+
+  p.outro(
+    chalk.dim('Tell your agent to "use ClawCard to check your identity"')
+  );
+}

package/src/commands/signup.js

@@ -0,0 +1,47 @@
+import * as p from "@clack/prompts";
+import open from "open";
+import { startCallbackServer } from "../auth-server.js";
+import { saveConfig, BASE_URL } from "../config.js";
+
+export async function signupCommand() {
+  const code = await p.text({
+    message: "Enter your invite code",
+    placeholder: "CLAW-XXXX",
+    validate: (val) => {
+      if (!/^CLAW-[A-Z0-9]{4}$/i.test(val)) {
+        return "Invite code must be in CLAW-XXXX format";
+      }
+    },
+  });
+
+  if (p.isCancel(code)) {
+    p.cancel("Signup cancelled");
+    return;
+  }
+
+  const s = p.spinner();
+  s.start("Opening browser...");
+
+  const { promise, port } = startCallbackServer();
+  const actualPort = await port;
+  const signupUrl = `${BASE_URL}/login?cli=true&port=${actualPort}&signup=true&code=${code}`;
+  await open(signupUrl);
+
+  s.message("Waiting for signup in browser...");
+
+  try {
+    const { token, email } = await promise;
+    s.stop("Account created!");
+
+    saveConfig({
+      token,
+      email,
+      loggedInAt: new Date().toISOString(),
+    });
+
+    p.log.success(`Welcome to ClawCard, ${email}!`);
+  } catch (err) {
+    s.stop("Signup failed");
+    p.log.error(err.message);
+  }
+}

package/src/commands/whoami.js

@@ -0,0 +1,31 @@
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+import { requireAuth } from "../auth-guard.js";
+import { getConfig } from "../config.js";
+import { getSubscription } from "../api.js";
+
+const orange = chalk.hex("#FF6B35");
+
+export async function whoamiCommand() {
+  requireAuth();
+
+  const config = getConfig();
+  const s = p.spinner();
+  s.start("Fetching account...");
+
+  try {
+    const sub = await getSubscription();
+    s.stop("");
+
+    p.note(
+      [
+        `Email: ${orange(config.email)}`,
+        `Plan:  ${sub.subscription?.planName || "Free"}`,
+      ].join("\n"),
+      "Account"
+    );
+  } catch {
+    s.stop("");
+    p.note(`Email: ${orange(config.email)}`, "Account");
+  }
+}

package/src/config.js

@@ -0,0 +1,68 @@
+import { readFileSync, writeFileSync, mkdirSync, unlinkSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+const CONFIG_DIR = join(homedir(), ".clawcard");
+const CONFIG_PATH = join(CONFIG_DIR, "config.json");
+
+export const BASE_URL = "https://www.clawcard.sh";
+
+export function getConfig() {
+  try {
+    const raw = readFileSync(CONFIG_PATH, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+export function saveConfig(config) {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+
+export function clearConfig() {
+  try {
+    unlinkSync(CONFIG_PATH);
+  } catch {
+    // already gone
+  }
+}
+
+export function isLoggedIn() {
+  const config = getConfig();
+  if (!config?.token) return false;
+  if (config.expiresAt && new Date(config.expiresAt) < new Date()) return false;
+  return true;
+}
+
+export function getToken() {
+  const config = getConfig();
+  return config?.token ?? null;
+}
+
+// ── Local key storage ──
+// Saves raw API keys locally so `clawcard setup` can reference them later.
+// Keys are stored in ~/.clawcard/keys.json keyed by agent ID.
+
+const KEYS_PATH = join(CONFIG_DIR, "keys.json");
+
+export function saveKey(agentId, apiKey, meta = {}) {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  const keys = getSavedKeys();
+  keys[agentId] = { apiKey, ...meta, savedAt: new Date().toISOString() };
+  writeFileSync(KEYS_PATH, JSON.stringify(keys, null, 2));
+}
+
+export function getSavedKeys() {
+  try {
+    return JSON.parse(readFileSync(KEYS_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+export function getSavedKey(agentId) {
+  const keys = getSavedKeys();
+  return keys[agentId]?.apiKey ?? null;
+}

package/src/index.js

@@ -0,0 +1,209 @@
+import { Command } from "commander";
+import * as p from "@clack/prompts";
+import { showSplash } from "./splash.js";
+import { isLoggedIn } from "./config.js";
+
+// Show splash on every invocation
+showSplash();
+
+const program = new Command();
+program.name("clawcard").description("The ClawCard CLI").version("1.0.0");
+
+// Auth commands
+program
+  .command("login")
+  .description("Log in via browser")
+  .action(async () => {
+    const { loginCommand } = await import("./commands/login.js");
+    await loginCommand();
+  });
+
+program
+  .command("signup")
+  .description("Sign up with invite code")
+  .action(async () => {
+    const { signupCommand } = await import("./commands/signup.js");
+    await signupCommand();
+  });
+
+program
+  .command("logout")
+  .description("Clear session")
+  .action(async () => {
+    const { logoutCommand } = await import("./commands/logout.js");
+    await logoutCommand();
+  });
+
+program
+  .command("whoami")
+  .description("Show current account")
+  .action(async () => {
+    const { whoamiCommand } = await import("./commands/whoami.js");
+    await whoamiCommand();
+  });
+
+// Keys
+const keys = program.command("keys").description("Manage API keys");
+
+keys.action(async () => {
+  const { keysCommand } = await import("./commands/keys.js");
+  await keysCommand();
+});
+
+keys
+  .command("create")
+  .description("Create a new API key")
+  .action(async () => {
+    const { keysCreateCommand } = await import("./commands/keys.js");
+    await keysCreateCommand();
+  });
+
+keys
+  .command("list")
+  .description("List all keys")
+  .action(async () => {
+    const { keysListCommand } = await import("./commands/keys.js");
+    await keysListCommand();
+  });
+
+keys
+  .command("info [keyId]")
+  .description("Show key details")
+  .action(async (keyId) => {
+    const { keysInfoCommand } = await import("./commands/keys.js");
+    await keysInfoCommand(keyId);
+  });
+
+keys
+  .command("revoke")
+  .description("Revoke a key")
+  .action(async () => {
+    const { keysRevokeCommand } = await import("./commands/keys.js");
+    await keysRevokeCommand();
+  });
+
+// Setup
+program
+  .command("setup")
+  .description("Install ClawCard skill for your agent")
+  .action(async () => {
+    const { setupCommand } = await import("./commands/setup.js");
+    await setupCommand();
+  });
+
+// Billing
+const billing = program.command("billing").description("Billing dashboard");
+
+billing.action(async () => {
+  const { billingCommand } = await import("./commands/billing.js");
+  await billingCommand();
+});
+
+billing
+  .command("balance")
+  .description("Quick balance check")
+  .action(async () => {
+    const { billingBalanceCommand } = await import("./commands/billing.js");
+    await billingBalanceCommand();
+  });
+
+billing
+  .command("topup")
+  .description("Top up balance")
+  .action(async () => {
+    const { billingTopupCommand } = await import("./commands/billing.js");
+    await billingTopupCommand();
+  });
+
+billing
+  .command("upgrade")
+  .description("Upgrade subscription")
+  .action(async () => {
+    const { billingUpgradeCommand } = await import("./commands/billing.js");
+    await billingUpgradeCommand();
+  });
+
+billing
+  .command("transactions")
+  .description("View transaction history")
+  .action(async () => {
+    const { billingTransactionsCommand } = await import(
+      "./commands/billing.js"
+    );
+    await billingTransactionsCommand();
+  });
+
+// Referral
+program
+  .command("referral")
+  .description("Show referral code")
+  .action(async () => {
+    const { referralCommand } = await import("./commands/referral.js");
+    await referralCommand();
+  });
+
+// Help
+program
+  .command("help")
+  .description("Show all commands")
+  .action(async () => {
+    const { helpCommand } = await import("./commands/help.js");
+    helpCommand();
+  });
+
+// If no subcommand, show interactive menu
+if (process.argv.length <= 2) {
+  const loggedIn = isLoggedIn();
+
+  const options = loggedIn
+    ? [
+        {
+          value: "setup",
+          label: "Setup",
+          hint: "connect ClawCard to your agent",
+        },
+        { value: "keys", label: "Keys", hint: "create & manage API keys" },
+        { value: "billing", label: "Billing", hint: "check balance & top up" },
+        { value: "referral", label: "Referral", hint: "share & earn $10" },
+        { value: "whoami", label: "Who am I?", hint: "show current account" },
+        { value: "logout", label: "Logout", hint: "clear session" },
+        { value: "help", label: "Help", hint: "show all commands" },
+      ]
+    : [
+        { value: "login", label: "Log in", hint: "authenticate via browser" },
+        {
+          value: "signup",
+          label: "Sign up",
+          hint: "create account with invite code",
+        },
+        { value: "help", label: "Help", hint: "show all commands" },
+      ];
+
+  const action = await p.select({
+    message: "What would you like to do?",
+    options,
+  });
+
+  if (p.isCancel(action)) {
+    p.cancel("Goodbye!");
+    process.exit(0);
+  }
+
+  const commands = {
+    login: () => import("./commands/login.js").then((m) => m.loginCommand()),
+    signup: () => import("./commands/signup.js").then((m) => m.signupCommand()),
+    logout: () => import("./commands/logout.js").then((m) => m.logoutCommand()),
+    whoami: () => import("./commands/whoami.js").then((m) => m.whoamiCommand()),
+    keys: () => import("./commands/keys.js").then((m) => m.keysCommand()),
+    setup: () => import("./commands/setup.js").then((m) => m.setupCommand()),
+    billing: () =>
+      import("./commands/billing.js").then((m) => m.billingCommand()),
+    referral: () =>
+      import("./commands/referral.js").then((m) => m.referralCommand()),
+    help: () => import("./commands/help.js").then((m) => m.helpCommand()),
+  };
+
+  await commands[action]?.();
+} else {
+  program.parse();
+}

package/src/splash.js

@@ -0,0 +1,11 @@
+import chalk from "chalk";
+
+const o = chalk.hex("#FF6B35");
+const d = chalk.dim;
+
+export function showSplash() {
+  console.log();
+  console.log(`  🦞 ${o.bold("clawcard.sh")}`);
+  console.log(`  ${d("on-demand credit cards, email and phone for your agents")}`);
+  console.log();
+}