@promptai.credit/cli 0.1.0

package/README.md

@@ -0,0 +1,49 @@
+# 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.
+
+## How it works
+
+1. `promptai install claude` merges two hooks into `~/.claude/settings.json`:
+   - **UserPromptSubmit**: baselines the session's transcript watermark and (if opted
+     in, at most every 90s, never headless) opens the hosted rewarded-ad page
+     (`/watch`) in your browser. The ad plays while your agent works.
+   - **Stop** (async): reads the session transcript JSONL since the watermark, prices
+     the turn with the shared model price table, and redeems one banked
+     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.
+
+State lives in `~/.promptai/` (`config.json`, `state.json`, `cli.log`).
+
+## Setup
+
+```bash
+npm install -g @promptai.credit/cli
+promptai install claude
+
+# 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 set ads off         # opt out any time
+```
+
+The default server is `https://api.promptai.credit`; point elsewhere with
+`promptai set server <url>`.
+
+Developing from the repo instead: `pnpm --filter @promptai.credit/cli build`, then
+`node product/cli/dist/index.js install claude` (hooks embed the absolute path).
+
+## Notes
+
+- 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).
+- 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
+  preserved.

package/dist/index.js

@@ -0,0 +1,557 @@
+#!/usr/bin/env node
+
+// 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";
+
+// src/api.ts
+import * as crypto from "node:crypto";
+var TIMEOUT_MS = 5e3;
+async function request(url, init) {
+  const response = await fetch(url, {
+    ...init,
+    signal: AbortSignal.timeout(TIMEOUT_MS)
+  });
+  const json = await response.json().catch(() => ({}));
+  if (!response.ok) {
+    throw new Error(json.error ?? `${url} returned ${response.status}`);
+  }
+  return json;
+}
+function post(serverUrl, pathname, body) {
+  return request(`${serverUrl}${pathname}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  });
+}
+function watchUrl(serverUrl, deviceId, source) {
+  return `${serverUrl}/watch?device=${encodeURIComponent(deviceId)}&source=${encodeURIComponent(source)}`;
+}
+function listVerifiedSessions(serverUrl, deviceId) {
+  return request(`${serverUrl}/ads/verified/${deviceId}`);
+}
+function redeemCredit(serverUrl, params) {
+  return post(serverUrl, "/credits", params);
+}
+function fetchBalance(serverUrl, deviceId) {
+  return request(`${serverUrl}/balance/${deviceId}`);
+}
+function claim(serverUrl, params) {
+  return post(serverUrl, "/claim", {
+    ...params,
+    idempotencyKey: crypto.randomUUID()
+  });
+}
+
+// src/browser.ts
+import { spawn } from "node:child_process";
+function hasDisplay() {
+  if (process.platform === "darwin" || process.platform === "win32") return true;
+  return Boolean(process.env.DISPLAY || process.env.WAYLAND_DISPLAY);
+}
+function openInBrowser(url) {
+  if (!hasDisplay()) return false;
+  const [cmd, args2] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
+  try {
+    spawn(cmd, args2, { detached: true, stdio: "ignore" }).unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/config.ts
+import * as crypto2 from "node:crypto";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+var DIR = path.join(os.homedir(), ".promptai");
+var CONFIG_FILE = path.join(DIR, "config.json");
+var STATE_FILE = path.join(DIR, "state.json");
+var LOG_FILE = path.join(DIR, "cli.log");
+var MAX_PROMPTS = 100;
+var MAX_WATERMARKS = 200;
+function promptaiDir() {
+  fs.mkdirSync(DIR, { recursive: true });
+  return DIR;
+}
+function readJson(file, fallback) {
+  try {
+    return { ...fallback, ...JSON.parse(fs.readFileSync(file, "utf8")) };
+  } catch {
+    return fallback;
+  }
+}
+function loadConfig() {
+  const config = readJson(CONFIG_FILE, {
+    deviceId: "",
+    serverUrl: "https://api.promptai.credit",
+    wallet: "",
+    adsOptIn: true
+  });
+  if (!config.deviceId) {
+    config.deviceId = crypto2.randomUUID();
+    saveConfig(config);
+  }
+  return config;
+}
+function saveConfig(config) {
+  promptaiDir();
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n");
+}
+function loadState() {
+  return readJson(STATE_FILE, {
+    watermarks: {},
+    lastAdOpenedAt: 0,
+    prompts: []
+  });
+}
+function saveState(state) {
+  promptaiDir();
+  state.prompts = state.prompts.slice(0, MAX_PROMPTS);
+  const keys = Object.keys(state.watermarks);
+  if (keys.length > MAX_WATERMARKS) {
+    for (const key of keys.slice(0, keys.length - MAX_WATERMARKS)) {
+      delete state.watermarks[key];
+    }
+  }
+  fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2) + "\n");
+}
+function log(message) {
+  promptaiDir();
+  const line = `${(/* @__PURE__ */ new Date()).toISOString()} ${message}
+`;
+  try {
+    fs.appendFileSync(LOG_FILE, line);
+    const { size } = fs.statSync(LOG_FILE);
+    if (size > 512 * 1024) {
+      const tail = fs.readFileSync(LOG_FILE, "utf8").slice(-256 * 1024);
+      fs.writeFileSync(LOG_FILE, tail);
+    }
+  } catch {
+  }
+}
+
+// src/pricing.ts
+var TABLE = [
+  { match: ["fable"], inputPerMtok: 3, outputPerMtok: 15 },
+  { match: ["opus"], inputPerMtok: 15, outputPerMtok: 75 },
+  { match: ["sonnet"], inputPerMtok: 3, outputPerMtok: 15 },
+  { match: ["haiku"], inputPerMtok: 0.8, outputPerMtok: 4 },
+  { match: ["gpt-5", "gpt5", "codex"], inputPerMtok: 1.25, outputPerMtok: 10 },
+  { match: ["gpt-4", "gpt4", "o3-", "o4-"], inputPerMtok: 2, outputPerMtok: 8 },
+  { match: ["gemini"], inputPerMtok: 1.25, outputPerMtok: 10 },
+  { match: ["grok"], inputPerMtok: 3, outputPerMtok: 15 },
+  { match: ["composer"], inputPerMtok: 1.25, outputPerMtok: 10 },
+  { match: ["deepseek", "kimi", "qwen"], inputPerMtok: 0.6, outputPerMtok: 2.5 }
+];
+var DEFAULT_PRICE = { inputPerMtok: 2, outputPerMtok: 8 };
+function priceFor(model) {
+  const m = (model ?? "").toLowerCase();
+  for (const row of TABLE) {
+    if (row.match.some((s) => m.includes(s))) {
+      return { inputPerMtok: row.inputPerMtok, outputPerMtok: row.outputPerMtok };
+    }
+  }
+  return DEFAULT_PRICE;
+}
+function costUsd(model, inputTokens, outputTokens) {
+  const p = priceFor(model);
+  const usd = (inputTokens * p.inputPerMtok + outputTokens * p.outputPerMtok) / 1e6;
+  return Math.round(usd * 1e6) / 1e6;
+}
+
+// src/transcript.ts
+import * as fs2 from "node:fs";
+function readTranscriptUsage(transcriptPath, watermark) {
+  const raw = fs2.readFileSync(transcriptPath, "utf8");
+  const byMessageId = /* @__PURE__ */ new Map();
+  let parsedCount = 0;
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (entry.type !== "assistant") continue;
+    const message = entry.message;
+    const usage = message?.usage;
+    if (!usage) continue;
+    parsedCount += 1;
+    const ts = Date.parse(String(entry.timestamp ?? "")) || 0;
+    const inputTokens = Math.round(
+      (usage.input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0) * 1.25 + (usage.cache_read_input_tokens ?? 0) * 0.1
+    );
+    const id = message?.id ?? `line-${parsedCount}`;
+    byMessageId.set(id, {
+      ts,
+      messageId: id,
+      model: message?.model ?? "unknown",
+      inputTokens,
+      outputTokens: usage.output_tokens ?? 0
+    });
+  }
+  const entries = [...byMessageId.values()].sort((a, b) => a.ts - b.ts);
+  const hasTimestamps = entries.some((e) => e.ts > 0);
+  const fresh = hasTimestamps ? entries.filter((e) => e.ts > watermark.lastTs) : entries.slice(watermark.seenCount);
+  return {
+    inputTokens: fresh.reduce((s, e) => s + e.inputTokens, 0),
+    outputTokens: fresh.reduce((s, e) => s + e.outputTokens, 0),
+    model: fresh.at(-1)?.model ?? entries.at(-1)?.model ?? "unknown",
+    newEntries: fresh.length,
+    lastTs: entries.reduce((m, e) => Math.max(m, e.ts), watermark.lastTs),
+    seenCount: entries.length
+  };
+}
+
+// src/claude.ts
+var SOURCE = "claude-code";
+var HOOK_MARKER = "promptai";
+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");
+}
+function hookCommand() {
+  let script = path2.resolve(process.argv[1] ?? "");
+  if (script.endsWith(".ts")) {
+    const dist = path2.resolve(path2.dirname(script), "..", "dist", "index.js");
+    if (!fs3.existsSync(dist)) {
+      throw new Error(
+        `Build the CLI first (pnpm --filter @promptai.credit/cli build); hooks cannot run ${script} directly.`
+      );
+    }
+    script = dist;
+  }
+  return `"${process.execPath}" "${script}" hook`;
+}
+function installClaudeHooks() {
+  const settingsPath = claudeSettingsPath();
+  fs3.mkdirSync(path2.dirname(settingsPath), { recursive: true });
+  let settings = {};
+  if (fs3.existsSync(settingsPath)) {
+    try {
+      settings = JSON.parse(fs3.readFileSync(settingsPath, "utf8"));
+    } catch {
+      fs3.copyFileSync(settingsPath, settingsPath + ".promptai-backup");
+      settings = {};
+    }
+  }
+  settings.hooks = settings.hooks ?? {};
+  const command2 = hookCommand();
+  let changed = false;
+  for (const event of ["UserPromptSubmit", "Stop"]) {
+    const groups = Array.isArray(settings.hooks[event]) ? settings.hooks[event] : [];
+    let ours = groups.flatMap((g) => g.hooks ?? []).find((h) => typeof h.command === "string" && h.command.includes(HOOK_MARKER));
+    if (!ours) {
+      const hook = event === "Stop" ? { type: "command", command: command2, async: true } : { type: "command", command: command2 };
+      groups.push({ hooks: [hook] });
+      settings.hooks[event] = groups;
+      changed = true;
+    } else if (ours.command !== command2) {
+      ours.command = command2;
+      changed = true;
+    }
+  }
+  if (changed || !fs3.existsSync(settingsPath)) {
+    fs3.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  }
+  return { changed, settingsPath };
+}
+function uninstallClaudeHooks() {
+  const settingsPath = claudeSettingsPath();
+  if (!fs3.existsSync(settingsPath)) return { changed: false };
+  let settings;
+  try {
+    settings = JSON.parse(fs3.readFileSync(settingsPath, "utf8"));
+  } catch {
+    return { changed: false };
+  }
+  if (!settings.hooks) return { changed: false };
+  let changed = false;
+  for (const [event, groups] of Object.entries(settings.hooks)) {
+    if (!Array.isArray(groups)) continue;
+    const kept = groups.map((g) => ({
+      ...g,
+      hooks: (g.hooks ?? []).filter(
+        (h) => !(typeof h.command === "string" && h.command.includes(HOOK_MARKER))
+      )
+    })).filter((g) => (g.hooks?.length ?? 0) > 0 || Object.keys(g).length > 1);
+    if (JSON.stringify(kept) !== JSON.stringify(groups)) {
+      settings.hooks[event] = kept;
+      changed = true;
+    }
+  }
+  if (changed) {
+    fs3.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  }
+  return { changed };
+}
+function handleUserPromptSubmit(payload) {
+  const config = loadConfig();
+  const state = loadState();
+  const sessionId = payload.session_id ?? "unknown";
+  if (!(sessionId in state.watermarks) && payload.transcript_path) {
+    try {
+      const usage = readTranscriptUsage(payload.transcript_path, { lastTs: 0, seenCount: 0 });
+      state.watermarks[sessionId] = { lastTs: usage.lastTs, seenCount: usage.seenCount };
+    } catch {
+      state.watermarks[sessionId] = { lastTs: 0, seenCount: 0 };
+    }
+  }
+  if (config.adsOptIn && Date.now() - state.lastAdOpenedAt >= AD_MIN_INTERVAL_MS) {
+    const url = watchUrl(config.serverUrl, config.deviceId, SOURCE);
+    if (openInBrowser(url)) {
+      state.lastAdOpenedAt = Date.now();
+      log(`[claude] opened ad tab for session=${sessionId}`);
+    } else if (!hasDisplay()) {
+      log(`[claude] headless environment, skipped ad tab`);
+    }
+  }
+  saveState(state);
+}
+async function handleStop(payload) {
+  const config = loadConfig();
+  const sessionId = payload.session_id ?? "unknown";
+  if (!payload.transcript_path) {
+    log(`[claude] stop without transcript_path session=${sessionId}`);
+    return;
+  }
+  const state = loadState();
+  const watermark = state.watermarks[sessionId] ?? { lastTs: 0, seenCount: 0 };
+  let usage;
+  for (const delay of SETTLE_RETRIES) {
+    try {
+      usage = readTranscriptUsage(payload.transcript_path, watermark);
+      if (usage.newEntries > 0) break;
+    } catch (err) {
+      log(`[claude] transcript read failed: ${String(err)}`);
+    }
+    await new Promise((r) => setTimeout(r, delay));
+  }
+  if (!usage || usage.newEntries === 0) {
+    log(`[claude] no new usage for session=${sessionId}, skipping`);
+    return;
+  }
+  state.watermarks[sessionId] = { lastTs: usage.lastTs, seenCount: usage.seenCount };
+  const cost = costUsd(usage.model, usage.inputTokens, usage.outputTokens);
+  const promptId = crypto3.randomUUID();
+  let verified = false;
+  if (config.adsOptIn && cost > 0) {
+    verified = await redeemAgainstAd(config.serverUrl, config.deviceId, promptId, cost);
+  }
+  state.prompts.unshift({
+    id: promptId,
+    ts: Date.now(),
+    agent: SOURCE,
+    sessionId,
+    model: usage.model,
+    inputTokens: usage.inputTokens,
+    outputTokens: usage.outputTokens,
+    costUsd: cost,
+    verified
+  });
+  saveState(state);
+  log(
+    `[claude] settled session=${sessionId} model=${usage.model} in=${usage.inputTokens} out=${usage.outputTokens} cost=$${cost} verified=${verified}`
+  );
+}
+async function redeemAgainstAd(serverUrl, deviceId, promptId, cost) {
+  try {
+    const { sessions } = await listVerifiedSessions(serverUrl, deviceId);
+    if (sessions.length === 0) {
+      log(`[claude] 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_USD)
+    });
+    return true;
+  } catch (err) {
+    log(`[claude] 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 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 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
+  promptai hook               (internal) invoked by agent hooks, JSON on stdin
+`;
+function readStdin() {
+  return new Promise((resolve2) => {
+    const chunks = [];
+    process.stdin.on("data", (c) => chunks.push(c));
+    process.stdin.on("end", () => resolve2(Buffer.concat(chunks).toString("utf8")));
+  });
+}
+async function cmdHook() {
+  let payload = {};
+  try {
+    payload = JSON.parse(await readStdin());
+  } catch {
+    return;
+  }
+  const event = payload.hook_event_name ?? "";
+  try {
+    if (event === "UserPromptSubmit") {
+      handleUserPromptSubmit(payload);
+    } else if (event === "Stop") {
+      await handleStop(payload);
+    }
+  } catch (err) {
+    log(`hook ${event} failed: ${String(err)}`);
+  }
+}
+async function cmdStatus() {
+  const config = loadConfig();
+  const state = loadState();
+  console.log(`device   ${config.deviceId}`);
+  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"}`);
+  try {
+    const [balance, verified] = await Promise.all([
+      fetchBalance(config.serverUrl, config.deviceId),
+      listVerifiedSessions(config.serverUrl, config.deviceId)
+    ]);
+    console.log(
+      `balance  $${balance.balanceUsd.toFixed(4)} (earned $${balance.earnedUsd.toFixed(4)}, claimed $${balance.claimedUsd.toFixed(4)})`
+    );
+    console.log(`banked   ${verified.sessions.length} verified ad watch(es) ready to fund prompts`);
+  } catch (err) {
+    console.log(`balance  unavailable (${String(err)})`);
+  }
+  if (state.prompts.length > 0) {
+    console.log("\nrecent prompts:");
+    for (const p of state.prompts.slice(0, 8)) {
+      const when = new Date(p.ts).toISOString().slice(0, 16).replace("T", " ");
+      const badge = p.verified ? "ad verified" : "no ad";
+      console.log(
+        `  ${when}  ${p.model}  in=${p.inputTokens} out=${p.outputTokens}  $${p.costUsd.toFixed(4)}  [${badge}]`
+      );
+    }
+  }
+}
+async function cmdWatch() {
+  const config = loadConfig();
+  const url = watchUrl(config.serverUrl, config.deviceId, SOURCE);
+  if (openInBrowser(url)) {
+    console.log(`Opened ${url}`);
+    console.log("Watch the full ad; the credit banks automatically once the server verifies it.");
+  } else if (!hasDisplay()) {
+    console.log("No display detected. Open this URL in any browser:");
+    console.log(url);
+  } else {
+    console.log(`Could not launch a browser. Open manually: ${url}`);
+  }
+}
+async function cmdClaim(addressArg) {
+  const config = loadConfig();
+  const address = addressArg ?? config.wallet;
+  if (!/^0x[0-9a-fA-F]{40}$/.test(address)) {
+    console.error("Set a valid wallet first: promptai set wallet 0x... (or pass one as an argument)");
+    process.exitCode = 1;
+    return;
+  }
+  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.");
+    return;
+  }
+  console.log(`Claiming $${balance.balanceUsd.toFixed(6)} USDC to ${address}...`);
+  const result = await claim(config.serverUrl, {
+    address,
+    amountUsd: balance.balanceUsd,
+    deviceId: config.deviceId
+  });
+  console.log(`Sent: ${result.txHash}`);
+  console.log(result.explorerUrl);
+}
+function cmdSet(key, value) {
+  const config = loadConfig();
+  if (key === "wallet" && value && /^0x[0-9a-fA-F]{40}$/.test(value)) {
+    config.wallet = value;
+  } else if (key === "server" && value && /^https?:\/\//.test(value)) {
+    config.serverUrl = value.replace(/\/$/, "");
+  } else if (key === "ads" && (value === "on" || value === "off")) {
+    config.adsOptIn = value === "on";
+  } else {
+    console.error("Usage: promptai set wallet 0x... | set server <url> | set ads on|off");
+    process.exitCode = 1;
+    return;
+  }
+  saveConfig(config);
+  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;
+    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.");
+}
+function cmdUninstall(agent) {
+  if (agent !== "claude" && agent !== "claude-code") {
+    console.error("Usage: promptai uninstall claude");
+    process.exitCode = 1;
+    return;
+  }
+  const { changed } = uninstallClaudeHooks();
+  console.log(changed ? "Hooks removed." : "No promptai hooks found.");
+}
+var [, , command, ...args] = process.argv;
+try {
+  switch (command) {
+    case "hook":
+      await cmdHook();
+      break;
+    case "install":
+      cmdInstall(args[0]);
+      break;
+    case "uninstall":
+      cmdUninstall(args[0]);
+      break;
+    case "status":
+      await cmdStatus();
+      break;
+    case "watch":
+      await cmdWatch();
+      break;
+    case "claim":
+      await cmdClaim(args[0]);
+      break;
+    case "set":
+      cmdSet(args[0], args[1]);
+      break;
+    default:
+      console.log(HELP);
+      if (command && command !== "help" && command !== "--help") process.exitCode = 1;
+  }
+} catch (err) {
+  console.error(err instanceof Error ? err.message : String(err));
+  process.exitCode = 1;
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@promptai.credit/cli",
+  "version": "0.1.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",
+    "ai",
+    "agents",
+    "prompt-credits",
+    "rewarded-ads",
+    "usdc",
+    "promptai"
+  ],
+  "bin": {
+    "promptai": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "build": "esbuild src/index.ts --bundle --platform=node --target=node20 --format=esm --outfile=dist/index.js --banner:js=\"#!/usr/bin/env node\"",
+    "prepublishOnly": "pnpm build",
+    "typecheck": "tsc --noEmit"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "esbuild": "^0.24.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.5.0"
+  }
+}