@promptai.credit/cli 0.1.0 → 0.3.0

package/README.md

@@ -1,7 +1,8 @@
 # promptai CLI
 
 Brings the earn loop (prompt → opt-in ad during the wait → server-side verification →
-credit → USDC claim) to terminal agents. Claude Code is supported today; Codex CLI is next.
+credit → USDC claim) to agents beyond the classic Cursor IDE. Claude Code and the
+Cursor Agents Window are supported today; Codex CLI is next.
 
 ## How it works
 
@@ -14,7 +15,29 @@ credit → USDC claim) to terminal agents. Claude Code is supported today; Codex
      server-verified ad session against it via the API.
 2. The `/watch` page creates the ad session server-side on load, so SSV wall-clock
    timing is enforced by the server; the browser countdown is cosmetic.
-3. `promptai claim` pays out your verified balance as USDC on Base Sepolia.
+3. `promptai claim` pays out your verified balance as USDC on Base.
+
+## Cursor Agents Window (Glass)
+
+The Agents Window doesn't run VS Code extensions, so the promptai extension can't
+cover it. `promptai install cursor` wires `beforeSubmitPrompt` + `stop` into
+`~/.cursor/hooks.json` (core Cursor hooks fire in both the Agents Window and the
+classic IDE):
+
+- Hook payloads are routed by shape (`cursor_version`/`conversation_id`), so events
+  reach the right adapter even if Cursor loads our Claude-format hooks through its
+  third-party mapping.
+- Cursor 3.7+ reports real token usage on the `stop` payload (`input_tokens`,
+  `output_tokens`, cache splits); cost is priced from that, with cached reads/writes
+  discounted. On older versions the cost falls back to a transcript character-volume
+  **estimate** (Glass transcripts carry no token counts and redact assistant prose).
+- When the classic IDE's extension host is running it already credits prompts, so
+  the CLI detects its listener file (live pid) and stands down - no double credit.
+- Duplicate stop events for the same generation are collapsed with an atomic
+  once-lock in `~/.promptai/locks/`.
+- On remote/SSH workspaces (`CURSOR_CODE_REMOTE`), the remote host has no display:
+  no ad tabs open there. Bank credits with `promptai watch` from any browser
+  (`/watch?device=<your device id>`) instead.
 
 State lives in `~/.promptai/` (`config.json`, `state.json`, `cli.log`).
 
@@ -22,13 +45,15 @@ State lives in `~/.promptai/` (`config.json`, `state.json`, `cli.log`).
 
 ```bash
 npm install -g @promptai.credit/cli
-promptai install claude
+promptai install claude      # Claude Code hooks
+promptai install cursor      # Cursor Agents Window / classic IDE hooks
 
 # then:
 promptai status              # device, balance, banked ad watches, recent prompts
 promptai watch               # open a rewarded ad now (banks a credit for later)
+promptai set email you@x.com # override the account email (required for claims)
 promptai set wallet 0x...    # payout address
-promptai claim               # USDC on Base Sepolia
+promptai claim               # USDC on Base
 promptai set ads off         # opt out any time
 ```
 
@@ -43,6 +68,13 @@ Developing from the repo instead: `pnpm --filter @promptai.credit/cli build`, th
 - Credits only accrue for turns funded by a **verified** ad watch, enforced
   server-side (same rules as the Cursor extension: one session funds one prompt,
   capped at $5).
+- Monthly earn caps: $75/device and $150 cumulative per linked email (UTC
+  calendar month). Claims require a linked email that an admin has activated.
+- The account email is auto-detected (Claude Code login in `~/.claude.json`,
+  the Cursor account in its state DB, then `git config user.email`) and linked
+  on the next credited prompt. Auto-detected emails link without verification;
+  `promptai set email` (manual entry or changing a linked email) sends a
+  6-digit code to the address, which the command prompts for.
 - Headless environments (CI, ssh without a display) never get browser tabs and
   simply skip crediting.
 - Uninstall with `promptai uninstall claude`; other hooks in your settings are

package/dist/index.js

@@ -1,10 +1,15 @@
 #!/usr/bin/env node
 
+// src/index.ts
+import * as fs6 from "node:fs";
+import * as path5 from "node:path";
+import * as readline from "node:readline";
+
 // src/claude.ts
 import * as crypto3 from "node:crypto";
-import * as fs3 from "node:fs";
-import * as os2 from "node:os";
-import * as path2 from "node:path";
+import * as fs4 from "node:fs";
+import * as os3 from "node:os";
+import * as path3 from "node:path";
 
 // src/api.ts
 import * as crypto from "node:crypto";
@@ -39,6 +44,12 @@ function redeemCredit(serverUrl, params) {
 function fetchBalance(serverUrl, deviceId) {
   return request(`${serverUrl}/balance/${deviceId}`);
 }
+function linkEmail(serverUrl, params) {
+  return post(serverUrl, "/devices/link", params);
+}
+function verifyEmailLink(serverUrl, params) {
+  return post(serverUrl, "/devices/link/verify", params);
+}
 function claim(serverUrl, params) {
   return post(serverUrl, "/claim", {
     ...params,
@@ -90,7 +101,8 @@ function loadConfig() {
     deviceId: "",
     serverUrl: "https://api.promptai.credit",
     wallet: "",
-    adsOptIn: true
+    adsOptIn: true,
+    email: ""
   });
   if (!config.deviceId) {
     config.deviceId = crypto2.randomUUID();
@@ -135,6 +147,112 @@ function log(message) {
   }
 }
 
+// src/email.ts
+import { execFileSync } from "node:child_process";
+import * as fs2 from "node:fs";
+import * as os2 from "node:os";
+import * as path2 from "node:path";
+var EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]{2,}$/;
+function clean(value) {
+  if (typeof value !== "string") return null;
+  const email = value.trim().toLowerCase();
+  return EMAIL_RE.test(email) ? email : null;
+}
+function fromClaudeJson() {
+  try {
+    const raw = fs2.readFileSync(path2.join(os2.homedir(), ".claude.json"), "utf8");
+    const data = JSON.parse(raw);
+    return clean(data.oauthAccount?.emailAddress);
+  } catch {
+    return null;
+  }
+}
+function cursorStateDbPath() {
+  const home = os2.homedir();
+  switch (process.platform) {
+    case "darwin":
+      return path2.join(
+        home,
+        "Library",
+        "Application Support",
+        "Cursor",
+        "User",
+        "globalStorage",
+        "state.vscdb"
+      );
+    case "win32":
+      return path2.join(
+        process.env.APPDATA ?? path2.join(home, "AppData", "Roaming"),
+        "Cursor",
+        "User",
+        "globalStorage",
+        "state.vscdb"
+      );
+    default:
+      return path2.join(home, ".config", "Cursor", "User", "globalStorage", "state.vscdb");
+  }
+}
+function fromCursorStateDb() {
+  const src = cursorStateDbPath();
+  if (!fs2.existsSync(src)) return null;
+  let dir = null;
+  try {
+    dir = fs2.mkdtempSync(path2.join(os2.tmpdir(), "promptai-email-"));
+    const db = path2.join(dir, "state.vscdb");
+    fs2.copyFileSync(src, db);
+    for (const suffix of ["-wal", "-shm"]) {
+      if (fs2.existsSync(src + suffix)) fs2.copyFileSync(src + suffix, db + suffix);
+    }
+    const stdout = execFileSync(
+      "sqlite3",
+      [db, "SELECT value FROM ItemTable WHERE key='cursorAuth/cachedEmail'"],
+      { encoding: "utf8", timeout: 5e3 }
+    ).trim();
+    if (stdout.startsWith('"')) {
+      try {
+        return clean(JSON.parse(stdout));
+      } catch {
+        return null;
+      }
+    }
+    return clean(stdout);
+  } catch {
+    return null;
+  } finally {
+    if (dir) fs2.rmSync(dir, { recursive: true, force: true });
+  }
+}
+function fromGitConfig() {
+  try {
+    return clean(
+      execFileSync("git", ["config", "--get", "user.email"], {
+        encoding: "utf8",
+        timeout: 5e3
+      })
+    );
+  } catch {
+    return null;
+  }
+}
+function detectEmail() {
+  const claude = fromClaudeJson();
+  if (claude) return { email: claude, source: "claude-account" };
+  const cursor = fromCursorStateDb();
+  if (cursor) return { email: cursor, source: "cursor-account" };
+  const git = fromGitConfig();
+  if (git) return { email: git, source: "git-config" };
+  return null;
+}
+function resolveEmail(config) {
+  if (config.email) return config.email;
+  const detected = detectEmail();
+  if (!detected) return "";
+  config.email = detected.email;
+  saveConfig(config);
+  log(`auto-detected email ${detected.email} (${detected.source})`);
+  return detected.email;
+}
+
 // src/pricing.ts
 var TABLE = [
   { match: ["fable"], inputPerMtok: 3, outputPerMtok: 15 },
@@ -165,9 +283,9 @@ function costUsd(model, inputTokens, outputTokens) {
 }
 
 // src/transcript.ts
-import * as fs2 from "node:fs";
+import * as fs3 from "node:fs";
 function readTranscriptUsage(transcriptPath, watermark) {
-  const raw = fs2.readFileSync(transcriptPath, "utf8");
+  const raw = fs3.readFileSync(transcriptPath, "utf8");
   const byMessageId = /* @__PURE__ */ new Map();
   let parsedCount = 0;
   for (const line of raw.split("\n")) {
@@ -208,6 +326,34 @@ function readTranscriptUsage(transcriptPath, watermark) {
     seenCount: entries.length
   };
 }
+function readGlassTranscriptUsage(transcriptPath, watermark) {
+  const raw = fs3.readFileSync(transcriptPath, "utf8");
+  const lines = raw.split("\n").filter((l) => l.trim());
+  let inputChars = 0;
+  let outputChars = 0;
+  let newEntries = 0;
+  for (const line of lines.slice(watermark.seenCount)) {
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const chars = JSON.stringify(entry.message?.content ?? "").length;
+    if (entry.role === "assistant") {
+      outputChars += chars;
+      newEntries += 1;
+    } else {
+      inputChars += chars;
+    }
+  }
+  return {
+    inputTokens: Math.round(inputChars / 4),
+    outputTokens: Math.round(outputChars / 4),
+    newEntries,
+    seenCount: lines.length
+  };
+}
 
 // src/claude.ts
 var SOURCE = "claude-code";
@@ -216,13 +362,13 @@ var MAX_CREDIT_PER_AD_USD = 5;
 var AD_MIN_INTERVAL_MS = 9e4;
 var SETTLE_RETRIES = [400, 800, 1500];
 function claudeSettingsPath() {
-  return path2.join(os2.homedir(), ".claude", "settings.json");
+  return path3.join(os3.homedir(), ".claude", "settings.json");
 }
 function hookCommand() {
-  let script = path2.resolve(process.argv[1] ?? "");
+  let script = path3.resolve(process.argv[1] ?? "");
   if (script.endsWith(".ts")) {
-    const dist = path2.resolve(path2.dirname(script), "..", "dist", "index.js");
-    if (!fs3.existsSync(dist)) {
+    const dist = path3.resolve(path3.dirname(script), "..", "dist", "index.js");
+    if (!fs4.existsSync(dist)) {
       throw new Error(
         `Build the CLI first (pnpm --filter @promptai.credit/cli build); hooks cannot run ${script} directly.`
       );
@@ -233,13 +379,13 @@ function hookCommand() {
 }
 function installClaudeHooks() {
   const settingsPath = claudeSettingsPath();
-  fs3.mkdirSync(path2.dirname(settingsPath), { recursive: true });
+  fs4.mkdirSync(path3.dirname(settingsPath), { recursive: true });
   let settings = {};
-  if (fs3.existsSync(settingsPath)) {
+  if (fs4.existsSync(settingsPath)) {
     try {
-      settings = JSON.parse(fs3.readFileSync(settingsPath, "utf8"));
+      settings = JSON.parse(fs4.readFileSync(settingsPath, "utf8"));
     } catch {
-      fs3.copyFileSync(settingsPath, settingsPath + ".promptai-backup");
+      fs4.copyFileSync(settingsPath, settingsPath + ".promptai-backup");
       settings = {};
     }
   }
@@ -259,17 +405,17 @@ function installClaudeHooks() {
       changed = true;
     }
   }
-  if (changed || !fs3.existsSync(settingsPath)) {
-    fs3.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  if (changed || !fs4.existsSync(settingsPath)) {
+    fs4.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
   }
   return { changed, settingsPath };
 }
 function uninstallClaudeHooks() {
   const settingsPath = claudeSettingsPath();
-  if (!fs3.existsSync(settingsPath)) return { changed: false };
+  if (!fs4.existsSync(settingsPath)) return { changed: false };
   let settings;
   try {
-    settings = JSON.parse(fs3.readFileSync(settingsPath, "utf8"));
+    settings = JSON.parse(fs4.readFileSync(settingsPath, "utf8"));
   } catch {
     return { changed: false };
   }
@@ -289,7 +435,7 @@ function uninstallClaudeHooks() {
     }
   }
   if (changed) {
-    fs3.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+    fs4.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
   }
   return { changed };
 }
@@ -344,7 +490,13 @@ async function handleStop(payload) {
   const promptId = crypto3.randomUUID();
   let verified = false;
   if (config.adsOptIn && cost > 0) {
-    verified = await redeemAgainstAd(config.serverUrl, config.deviceId, promptId, cost);
+    verified = await redeemAgainstAd(
+      config.serverUrl,
+      config.deviceId,
+      promptId,
+      cost,
+      resolveEmail(config)
+    );
   }
   state.prompts.unshift({
     id: promptId,
@@ -362,7 +514,7 @@ async function handleStop(payload) {
     `[claude] settled session=${sessionId} model=${usage.model} in=${usage.inputTokens} out=${usage.outputTokens} cost=$${cost} verified=${verified}`
   );
 }
-async function redeemAgainstAd(serverUrl, deviceId, promptId, cost) {
+async function redeemAgainstAd(serverUrl, deviceId, promptId, cost, email) {
   try {
     const { sessions } = await listVerifiedSessions(serverUrl, deviceId);
     if (sessions.length === 0) {
@@ -373,7 +525,8 @@ async function redeemAgainstAd(serverUrl, deviceId, promptId, cost) {
       sessionId: sessions[0].sessionId,
       deviceId,
       promptId,
-      amountUsd: Math.min(cost, MAX_CREDIT_PER_AD_USD)
+      amountUsd: Math.min(cost, MAX_CREDIT_PER_AD_USD),
+      email: email || void 0
     });
     return true;
   } catch (err) {
@@ -382,16 +535,257 @@ async function redeemAgainstAd(serverUrl, deviceId, promptId, cost) {
   }
 }
 
+// src/cursor.ts
+import * as crypto4 from "node:crypto";
+import * as fs5 from "node:fs";
+import * as os4 from "node:os";
+import * as path4 from "node:path";
+var CURSOR_SOURCE = "cursor-agents";
+var HOOK_MARKER2 = "promptai";
+var MAX_CREDIT_PER_AD_USD2 = 5;
+var AD_MIN_INTERVAL_MS2 = 9e4;
+var SETTLE_RETRIES2 = [400, 800, 1500];
+function isCursorPayload(payload) {
+  return typeof payload.cursor_version === "string" || typeof payload.conversation_id === "string";
+}
+function cursorHooksJsonPath() {
+  return path4.join(os4.homedir(), ".cursor", "hooks.json");
+}
+function installCursorHooks() {
+  const hooksPath = cursorHooksJsonPath();
+  fs5.mkdirSync(path4.dirname(hooksPath), { recursive: true });
+  let config = {};
+  if (fs5.existsSync(hooksPath)) {
+    try {
+      config = JSON.parse(fs5.readFileSync(hooksPath, "utf8"));
+    } catch {
+      fs5.copyFileSync(hooksPath, hooksPath + ".promptai-backup");
+      config = {};
+    }
+  }
+  config.version = config.version ?? 1;
+  config.hooks = config.hooks ?? {};
+  const command2 = hookCommand();
+  let changed = false;
+  for (const event of ["beforeSubmitPrompt", "stop"]) {
+    const entries = Array.isArray(config.hooks[event]) ? config.hooks[event] : [];
+    const ours = entries.find(
+      (e) => typeof e?.command === "string" && e.command.includes(HOOK_MARKER2)
+    );
+    if (!ours) {
+      entries.push({ command: command2 });
+      config.hooks[event] = entries;
+      changed = true;
+    } else if (ours.command !== command2) {
+      ours.command = command2;
+      changed = true;
+    }
+  }
+  if (changed || !fs5.existsSync(hooksPath)) {
+    fs5.writeFileSync(hooksPath, JSON.stringify(config, null, 2) + "\n");
+  }
+  return { changed, hooksPath };
+}
+function uninstallCursorHooks() {
+  const hooksPath = cursorHooksJsonPath();
+  if (!fs5.existsSync(hooksPath)) return { changed: false };
+  let config;
+  try {
+    config = JSON.parse(fs5.readFileSync(hooksPath, "utf8"));
+  } catch {
+    return { changed: false };
+  }
+  if (!config.hooks) return { changed: false };
+  let changed = false;
+  for (const [event, entries] of Object.entries(config.hooks)) {
+    if (!Array.isArray(entries)) continue;
+    const kept = entries.filter(
+      (e) => !(typeof e?.command === "string" && e.command.includes(HOOK_MARKER2))
+    );
+    if (kept.length !== entries.length) {
+      config.hooks[event] = kept;
+      changed = true;
+    }
+  }
+  if (changed) {
+    fs5.writeFileSync(hooksPath, JSON.stringify(config, null, 2) + "\n");
+  }
+  return { changed };
+}
+function extensionIsActive() {
+  const infoPath = path4.join(os4.homedir(), ".cursor", "promptai-listener.json");
+  try {
+    const info = JSON.parse(fs5.readFileSync(infoPath, "utf8"));
+    if (typeof info.pid !== "number") return false;
+    process.kill(info.pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function acquireOnceLock(key) {
+  const dir = path4.join(promptaiDir(), "locks");
+  fs5.mkdirSync(dir, { recursive: true });
+  try {
+    const cutoff = Date.now() - 24 * 60 * 60 * 1e3;
+    for (const name of fs5.readdirSync(dir)) {
+      const p = path4.join(dir, name);
+      if (fs5.statSync(p).mtimeMs < cutoff) fs5.rmSync(p, { recursive: true, force: true });
+    }
+  } catch {
+  }
+  try {
+    fs5.mkdirSync(path4.join(dir, key.replace(/[^a-zA-Z0-9_-]/g, "_")));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function watermarkKey(conversationId) {
+  return `glass:${conversationId}`;
+}
+function handleCursorPromptSubmitted(payload) {
+  const config = loadConfig();
+  const state = loadState();
+  const convId = payload.conversation_id ?? "unknown";
+  const key = watermarkKey(convId);
+  if (!(key in state.watermarks) && payload.transcript_path) {
+    try {
+      const usage = readGlassTranscriptUsage(payload.transcript_path, { seenCount: 0 });
+      state.watermarks[key] = { lastTs: 0, seenCount: usage.seenCount };
+    } catch {
+      state.watermarks[key] = { lastTs: 0, seenCount: 0 };
+    }
+  }
+  const remote = process.env.CURSOR_CODE_REMOTE === "true";
+  if (config.adsOptIn && !extensionIsActive() && Date.now() - state.lastAdOpenedAt >= AD_MIN_INTERVAL_MS2) {
+    const url = watchUrl(config.serverUrl, config.deviceId, CURSOR_SOURCE);
+    if (!remote && openInBrowser(url)) {
+      state.lastAdOpenedAt = Date.now();
+      log(`[cursor] opened ad tab for conv=${convId}`);
+    } else if (remote || !hasDisplay()) {
+      log(`[cursor] no display here - watch ads at ${url}`);
+    }
+  }
+  saveState(state);
+}
+async function handleCursorStop(payload) {
+  const config = loadConfig();
+  const convId = payload.conversation_id ?? "unknown";
+  if (extensionIsActive()) {
+    log(`[cursor] extension host active, deferring settle for conv=${convId}`);
+    return;
+  }
+  if (!payload.transcript_path) {
+    log(`[cursor] stop without transcript_path conv=${convId} (transcripts disabled?)`);
+    return;
+  }
+  if (!acquireOnceLock(`stop-${convId}-${payload.generation_id ?? "nogen"}`)) {
+    log(`[cursor] duplicate stop event for conv=${convId}, skipping`);
+    return;
+  }
+  const state = loadState();
+  const key = watermarkKey(convId);
+  const watermark = state.watermarks[key] ?? { lastTs: 0, seenCount: 0 };
+  const model = payload.model_id || payload.model || "unknown";
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let estimated = false;
+  const reportedInput = Number(payload.input_tokens ?? 0);
+  const reportedOutput = Number(payload.output_tokens ?? 0);
+  if (reportedInput + reportedOutput > 0) {
+    const cacheRead = Number(payload.cache_read_tokens ?? 0);
+    const cacheWrite = Number(payload.cache_write_tokens ?? 0);
+    const uncached = Math.max(0, reportedInput - cacheRead - cacheWrite);
+    inputTokens = Math.round(uncached + cacheWrite * 1.25 + cacheRead * 0.1);
+    outputTokens = reportedOutput;
+  } else {
+    estimated = true;
+    let usage;
+    for (const delay of SETTLE_RETRIES2) {
+      try {
+        usage = readGlassTranscriptUsage(payload.transcript_path, watermark);
+        if (usage.newEntries > 0) break;
+      } catch (err) {
+        log(`[cursor] transcript read failed: ${String(err)}`);
+      }
+      await new Promise((r) => setTimeout(r, delay));
+    }
+    if (!usage || usage.newEntries === 0) {
+      log(`[cursor] no new usage for conv=${convId}, skipping`);
+      return;
+    }
+    inputTokens = usage.inputTokens;
+    outputTokens = usage.outputTokens;
+  }
+  try {
+    const snapshot = readGlassTranscriptUsage(payload.transcript_path, { seenCount: 0 });
+    state.watermarks[key] = { lastTs: 0, seenCount: snapshot.seenCount };
+  } catch {
+    state.watermarks[key] = watermark;
+  }
+  const cost = costUsd(model, inputTokens, outputTokens);
+  const promptId = crypto4.randomUUID();
+  let verified = false;
+  if (config.adsOptIn && cost > 0) {
+    verified = await redeemAgainstAd2(
+      config.serverUrl,
+      config.deviceId,
+      promptId,
+      cost,
+      resolveEmail(config)
+    );
+  }
+  state.prompts.unshift({
+    id: promptId,
+    ts: Date.now(),
+    agent: "cursor",
+    sessionId: convId,
+    model,
+    inputTokens,
+    outputTokens,
+    costUsd: cost,
+    verified,
+    estimated
+  });
+  saveState(state);
+  log(
+    `[cursor] settled conv=${convId} model=${model} in=${inputTokens} out=${outputTokens} cost=$${cost}${estimated ? " (estimated)" : ""} verified=${verified}`
+  );
+}
+async function redeemAgainstAd2(serverUrl, deviceId, promptId, cost, email) {
+  try {
+    const { sessions } = await listVerifiedSessions(serverUrl, deviceId);
+    if (sessions.length === 0) {
+      log(`[cursor] no verified ad session available for prompt ${promptId}`);
+      return false;
+    }
+    await redeemCredit(serverUrl, {
+      sessionId: sessions[0].sessionId,
+      deviceId,
+      promptId,
+      amountUsd: Math.min(cost, MAX_CREDIT_PER_AD_USD2),
+      email: email || void 0
+    });
+    return true;
+  } catch (err) {
+    log(`[cursor] credit redeem failed for prompt ${promptId}: ${String(err)}`);
+    return false;
+  }
+}
+
 // src/index.ts
 var HELP = `promptai - ad-subsidized prompt credits for terminal agents
 
 Usage:
   promptai install claude     Wire hooks into ~/.claude/settings.json
-  promptai uninstall claude   Remove our hooks (other hooks untouched)
+  promptai install cursor     Wire hooks into ~/.cursor/hooks.json (Agents Window)
+  promptai uninstall <agent>  Remove our hooks (other hooks untouched)
   promptai status             Device, balance, banked ad credits, recent prompts
   promptai watch              Open a rewarded ad in the browser now
-  promptai claim [address]    Claim your verified balance as USDC (Base Sepolia)
+  promptai claim [address]    Claim your verified balance as USDC (Base)
   promptai set wallet 0x...   Set the payout wallet
+  promptai set email <email>  Link your email (required for USDC claims; groups devices)
   promptai set server <url>   Point at a different API server
   promptai set ads on|off     Toggle the rewarded-ads opt-in
   promptai hook               (internal) invoked by agent hooks, JSON on stdin
@@ -404,15 +798,31 @@ function readStdin() {
   });
 }
 async function cmdHook() {
+  const raw = await readStdin();
   let payload = {};
   try {
-    payload = JSON.parse(await readStdin());
+    payload = JSON.parse(raw);
   } catch {
     return;
   }
-  const event = payload.hook_event_name ?? "";
+  const event = String(payload.hook_event_name ?? "");
+  if (process.env.PROMPTAI_DUMP === "1" || fs6.existsSync(path5.join(promptaiDir(), "debug"))) {
+    try {
+      const dir = path5.join(promptaiDir(), "dump");
+      fs6.mkdirSync(dir, { recursive: true });
+      fs6.writeFileSync(path5.join(dir, `${Date.now()}-${event || "unknown"}.json`), raw);
+    } catch {
+    }
+  }
   try {
-    if (event === "UserPromptSubmit") {
+    if (isCursorPayload(payload)) {
+      const cursorPayload = payload;
+      if (event === "beforeSubmitPrompt" || event === "UserPromptSubmit") {
+        handleCursorPromptSubmitted(cursorPayload);
+      } else if (event === "stop" || event === "Stop") {
+        await handleCursorStop(cursorPayload);
+      }
+    } else if (event === "UserPromptSubmit") {
       handleUserPromptSubmit(payload);
     } else if (event === "Stop") {
       await handleStop(payload);
@@ -424,10 +834,13 @@ async function cmdHook() {
 async function cmdStatus() {
   const config = loadConfig();
   const state = loadState();
+  const email = resolveEmail(config);
   console.log(`device   ${config.deviceId}`);
   console.log(`server   ${config.serverUrl}`);
   console.log(`wallet   ${config.wallet || "(not set - promptai set wallet 0x...)"}`);
+  console.log(`email    ${email || "(not detected - promptai set email you@example.com)"}`);
   console.log(`ads      ${config.adsOptIn ? "opted in" : "opted out"}`);
+  console.log(`watch    ${watchUrl(config.serverUrl, config.deviceId, "manual")}`);
   try {
     const [balance, verified] = await Promise.all([
       fetchBalance(config.serverUrl, config.deviceId),
@@ -436,6 +849,12 @@ async function cmdStatus() {
     console.log(
       `balance  $${balance.balanceUsd.toFixed(4)} (earned $${balance.earnedUsd.toFixed(4)}, claimed $${balance.claimedUsd.toFixed(4)})`
     );
+    console.log(
+      `monthly  device $${balance.monthEarnedDeviceUsd.toFixed(4)} / $${balance.deviceCapUsd}` + (balance.email ? ` \xB7 email $${balance.monthEarnedEmailUsd.toFixed(4)} / $${balance.emailCapUsd}` : "")
+    );
+    console.log(
+      `claims   ${!balance.email ? "blocked (link an email first)" : balance.claimActivated ? "activated" : "blocked (waiting for admin activation)"}`
+    );
     console.log(`banked   ${verified.sessions.length} verified ad watch(es) ready to fund prompts`);
   } catch (err) {
     console.log(`balance  unavailable (${String(err)})`);
@@ -472,6 +891,13 @@ async function cmdClaim(addressArg) {
     process.exitCode = 1;
     return;
   }
+  const email = resolveEmail(config);
+  if (email) {
+    try {
+      await linkEmail(config.serverUrl, { deviceId: config.deviceId, email, source: "auto" });
+    } catch {
+    }
+  }
   const balance = await fetchBalance(config.serverUrl, config.deviceId);
   if (balance.balanceUsd < 1e-6) {
     console.log("Nothing to claim yet - watch an ad (promptai watch) and run some agent prompts first.");
@@ -486,7 +912,7 @@ async function cmdClaim(addressArg) {
   console.log(`Sent: ${result.txHash}`);
   console.log(result.explorerUrl);
 }
-function cmdSet(key, value) {
+async function cmdSet(key, value) {
   const config = loadConfig();
   if (key === "wallet" && value && /^0x[0-9a-fA-F]{40}$/.test(value)) {
     config.wallet = value;
@@ -494,34 +920,101 @@ function cmdSet(key, value) {
     config.serverUrl = value.replace(/\/$/, "");
   } else if (key === "ads" && (value === "on" || value === "off")) {
     config.adsOptIn = value === "on";
+  } else if (key === "email" && value && /^[^\s@]+@[^\s@]+\.[^\s@]{2,}$/.test(value)) {
+    config.email = value.trim().toLowerCase();
   } else {
-    console.error("Usage: promptai set wallet 0x... | set server <url> | set ads on|off");
+    console.error(
+      "Usage: promptai set wallet 0x... | set server <url> | set ads on|off | set email you@example.com"
+    );
     process.exitCode = 1;
     return;
   }
+  if (key === "email") {
+    const email = config.email;
+    try {
+      const result = await linkEmail(config.serverUrl, {
+        deviceId: config.deviceId,
+        email,
+        source: "manual"
+      });
+      if (result.otpRequired) {
+        console.log(result.message ?? `Verification code sent to ${email}.`);
+        const code = (await promptLine("Enter the 6-digit code: ")).trim();
+        if (!/^\d{6}$/.test(code)) {
+          console.error("That doesn't look like a 6-digit code. Run the command again.");
+          process.exitCode = 1;
+          return;
+        }
+        const verified = await verifyEmailLink(config.serverUrl, {
+          deviceId: config.deviceId,
+          email,
+          code
+        });
+        printLinkStatus(verified.claimActivated);
+      } else {
+        printLinkStatus(Boolean(result.claimActivated));
+      }
+      saveConfig(config);
+      console.log("email updated.");
+    } catch (err) {
+      console.error(`Email not linked: ${err instanceof Error ? err.message : String(err)}`);
+      process.exitCode = 1;
+    }
+    return;
+  }
   saveConfig(config);
   console.log(`${key} updated.`);
 }
+function printLinkStatus(claimActivated) {
+  console.log(
+    claimActivated ? "Email linked. Account is activated for USDC claims." : "Email linked. USDC claims stay blocked until an admin activates this account."
+  );
+}
+function promptLine(question) {
+  return new Promise((resolve2) => {
+    process.stdout.write(question);
+    const rl = readline.createInterface({ input: process.stdin });
+    rl.once("line", (line) => {
+      rl.close();
+      resolve2(line);
+    });
+  });
+}
 function cmdInstall(agent) {
-  if (agent !== "claude" && agent !== "claude-code") {
-    console.error("Supported agents: claude (Codex CLI coming next). Usage: promptai install claude");
-    process.exitCode = 1;
+  if (agent === "claude" || agent === "claude-code") {
+    const { changed, settingsPath } = installClaudeHooks();
+    console.log(
+      changed ? `Hooks installed into ${settingsPath}.` : `Hooks already installed in ${settingsPath}.`
+    );
+    console.log("Claude Code picks them up on its next session. Try: promptai watch, then run a prompt.");
     return;
   }
-  const { changed, settingsPath } = installClaudeHooks();
-  console.log(
-    changed ? `Hooks installed into ${settingsPath}.` : `Hooks already installed in ${settingsPath}.`
-  );
-  console.log("Claude Code picks them up on its next session. Try: promptai watch, then run a prompt.");
+  if (agent === "cursor" || agent === "cursor-agents") {
+    const { changed, hooksPath } = installCursorHooks();
+    console.log(
+      changed ? `Hooks installed into ${hooksPath}.` : `Hooks already installed in ${hooksPath}.`
+    );
+    console.log(
+      "Works in the Agents Window and the classic IDE (the CLI stands down when the promptai extension is running). Cursor hot-reloads hooks.json."
+    );
+    return;
+  }
+  console.error("Supported agents: claude, cursor (Codex CLI coming next). Usage: promptai install <agent>");
+  process.exitCode = 1;
 }
 function cmdUninstall(agent) {
-  if (agent !== "claude" && agent !== "claude-code") {
-    console.error("Usage: promptai uninstall claude");
-    process.exitCode = 1;
+  if (agent === "claude" || agent === "claude-code") {
+    const { changed } = uninstallClaudeHooks();
+    console.log(changed ? "Hooks removed." : "No promptai hooks found.");
     return;
   }
-  const { changed } = uninstallClaudeHooks();
-  console.log(changed ? "Hooks removed." : "No promptai hooks found.");
+  if (agent === "cursor" || agent === "cursor-agents") {
+    const { changed } = uninstallCursorHooks();
+    console.log(changed ? "Hooks removed." : "No promptai hooks found.");
+    return;
+  }
+  console.error("Usage: promptai uninstall claude|cursor");
+  process.exitCode = 1;
 }
 var [, , command, ...args] = process.argv;
 try {
@@ -545,7 +1038,7 @@ try {
       await cmdClaim(args[0]);
       break;
     case "set":
-      cmdSet(args[0], args[1]);
+      await cmdSet(args[0], args[1]);
       break;
     default:
       console.log(HELP);

package/package.json

@@ -1,17 +1,12 @@
 {
   "name": "@promptai.credit/cli",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "publishConfig": {
     "access": "public"
   },
   "description": "Earn ad-subsidized prompt credits from terminal AI agents (Claude Code). Watch a dev-tool ad while your agent works; verified watches pay your prompt's token cost in USDC.",
   "type": "module",
   "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Vib-UX/promptai.git",
-    "directory": "product/cli"
-  },
   "homepage": "https://promptai.credit",
   "keywords": [
     "claude-code",