@promptai.credit/cli 0.1.0 → 0.2.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,14 @@ 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 wallet 0x...    # payout address
-promptai claim               # USDC on Base Sepolia
+promptai claim               # USDC on Base
 promptai set ads off         # opt out any time
 ```
 

package/dist/index.js

@@ -1,5 +1,9 @@
 #!/usr/bin/env node
 
+// src/index.ts
+import * as fs5 from "node:fs";
+import * as path4 from "node:path";
+
 // src/claude.ts
 import * as crypto3 from "node:crypto";
 import * as fs3 from "node:fs";
@@ -208,6 +212,34 @@ function readTranscriptUsage(transcriptPath, watermark) {
     seenCount: entries.length
   };
 }
+function readGlassTranscriptUsage(transcriptPath, watermark) {
+  const raw = fs2.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";
@@ -382,15 +414,248 @@ async function redeemAgainstAd(serverUrl, deviceId, promptId, cost) {
   }
 }
 
+// src/cursor.ts
+import * as crypto4 from "node:crypto";
+import * as fs4 from "node:fs";
+import * as os3 from "node:os";
+import * as path3 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 path3.join(os3.homedir(), ".cursor", "hooks.json");
+}
+function installCursorHooks() {
+  const hooksPath = cursorHooksJsonPath();
+  fs4.mkdirSync(path3.dirname(hooksPath), { recursive: true });
+  let config = {};
+  if (fs4.existsSync(hooksPath)) {
+    try {
+      config = JSON.parse(fs4.readFileSync(hooksPath, "utf8"));
+    } catch {
+      fs4.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 || !fs4.existsSync(hooksPath)) {
+    fs4.writeFileSync(hooksPath, JSON.stringify(config, null, 2) + "\n");
+  }
+  return { changed, hooksPath };
+}
+function uninstallCursorHooks() {
+  const hooksPath = cursorHooksJsonPath();
+  if (!fs4.existsSync(hooksPath)) return { changed: false };
+  let config;
+  try {
+    config = JSON.parse(fs4.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) {
+    fs4.writeFileSync(hooksPath, JSON.stringify(config, null, 2) + "\n");
+  }
+  return { changed };
+}
+function extensionIsActive() {
+  const infoPath = path3.join(os3.homedir(), ".cursor", "promptai-listener.json");
+  try {
+    const info = JSON.parse(fs4.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 = path3.join(promptaiDir(), "locks");
+  fs4.mkdirSync(dir, { recursive: true });
+  try {
+    const cutoff = Date.now() - 24 * 60 * 60 * 1e3;
+    for (const name of fs4.readdirSync(dir)) {
+      const p = path3.join(dir, name);
+      if (fs4.statSync(p).mtimeMs < cutoff) fs4.rmSync(p, { recursive: true, force: true });
+    }
+  } catch {
+  }
+  try {
+    fs4.mkdirSync(path3.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);
+  }
+  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) {
+  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)
+    });
+    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 server <url>   Point at a different API server
   promptai set ads on|off     Toggle the rewarded-ads opt-in
@@ -404,15 +669,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" || fs5.existsSync(path4.join(promptaiDir(), "debug"))) {
+    try {
+      const dir = path4.join(promptaiDir(), "dump");
+      fs5.mkdirSync(dir, { recursive: true });
+      fs5.writeFileSync(path4.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);
@@ -428,6 +709,7 @@ async function cmdStatus() {
   console.log(`server   ${config.serverUrl}`);
   console.log(`wallet   ${config.wallet || "(not set - promptai set wallet 0x...)"}`);
   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),
@@ -503,25 +785,40 @@ function cmdSet(key, value) {
   console.log(`${key} updated.`);
 }
 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;
+  }
+  if (agent === "cursor" || agent === "cursor-agents") {
+    const { changed } = uninstallCursorHooks();
+    console.log(changed ? "Hooks removed." : "No promptai hooks found.");
     return;
   }
-  const { changed } = uninstallClaudeHooks();
-  console.log(changed ? "Hooks removed." : "No promptai hooks found.");
+  console.error("Usage: promptai uninstall claude|cursor");
+  process.exitCode = 1;
 }
 var [, , command, ...args] = process.argv;
 try {

package/package.json

@@ -1,17 +1,12 @@
 {
   "name": "@promptai.credit/cli",
-  "version": "0.1.0",
+  "version": "0.2.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",