tokenwait 0.0.0-stage → 0.1.0

package/bin/hook.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+'use strict';
+// Хук агента: hook.js <agent> <start|stop> --twhook
+// Пишет только время, событие, агента и id сессии. Ничего не печатает:
+// у Claude/Codex stdout хука UserPromptSubmit попадает в контекст модели,
+// у Gemini stdout должен быть пустым или JSON.
+const fs = require('fs');
+
+try {
+  const [agent, phase] = process.argv.slice(2);
+  if (!['claude', 'codex', 'gemini'].includes(agent) || !['start', 'stop'].includes(phase)) process.exit(0);
+
+  let input = {};
+  try {
+    input = JSON.parse(fs.readFileSync(0, 'utf8') || '{}');
+  } catch (_) {}
+  const session = String(input.session_id || input.sessionId || process.env.GEMINI_SESSION_ID || process.env.CODEX_SESSION_ID || '').slice(0, 100);
+
+  const { p, readJson } = require('../lib/util');
+  const acc = require('../lib/accounting');
+  const worker = require('../lib/worker');
+  const now = Date.now();
+
+  fs.mkdirSync(p(), { recursive: true });
+  acc.appendLine(p('events.jsonl'), { t: now, e: phase, a: agent, s: session });
+
+  if (phase === 'stop') {
+    const ads = readJson(p('ads.json'), null);
+    const cfg = readJson(p('config.json'), {});
+    const interval = acc.waitInterval(acc.readLines(p('events.jsonl')), agent, session, now);
+    if (ads && interval) {
+      const add = acc.attribute({
+        agent,
+        interval,
+        vis: acc.readLines(p('visibility.jsonl')),
+        ads: ads.ads,
+        rotateSeconds: cfg.rotate_seconds || 30,
+      });
+      if (add.visibleMs > 0) acc.addToPending(add);
+    }
+  }
+  if (worker.adsStale(now) || worker.reportDue(now)) worker.spawnWorker();
+} catch (_) {
+  // хук никогда не должен ломать агента
+}
+process.exit(0);

package/bin/status.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+'use strict';
+// statusLine для Claude Code: status.js --tw [--wrap <base64url(JSON прежней statusLine)>]
+// На stdin — JSON сессии. Транскрипт (transcript_path) НЕ читаем.
+const fs = require('fs');
+const { spawnSync } = require('child_process');
+
+function wrapped() {
+  const i = process.argv.indexOf('--wrap');
+  if (i < 0 || !process.argv[i + 1]) return '';
+  try {
+    const v = JSON.parse(Buffer.from(process.argv[i + 1], 'base64url').toString('utf8'));
+    return typeof v === 'string' ? v : v && typeof v.command === 'string' ? v.command : '';
+  } catch (_) {
+    return '';
+  }
+}
+
+function main() {
+  let raw = '';
+  try {
+    raw = fs.readFileSync(0, 'utf8');
+  } catch (_) {}
+
+  let orig = '';
+  const cmd = wrapped();
+  if (cmd) {
+    const r = spawnSync(cmd, { shell: true, input: raw, encoding: 'utf8', timeout: 2000, maxBuffer: 1 << 20 });
+    orig = (r.stdout || '').replace(/\s+$/, '');
+  }
+
+  const { p, readJson, hostOf } = require('../lib/util');
+  const { pick } = require('../lib/rotation');
+  const worker = require('../lib/worker');
+  const ads = readJson(p('ads.json'), null);
+  const cfg = readJson(p('config.json'), {});
+  let line = '';
+  const ad = ads && pick(ads.ads, Date.now(), cfg.rotate_seconds || 30);
+  if (ad) {
+    const host = hostOf(ad.url);
+    line = 'Sponsored · ' + ad.text + (host ? ' (' + host + ')' : '');
+  }
+  if (worker.adsStale()) worker.spawnWorker();
+
+  let out;
+  if (orig && line) out = orig.includes('\n') ? orig + '\n' + line : orig + ' │ ' + line;
+  else out = orig || line;
+  process.stdout.write(out + '\n');
+}
+
+try {
+  main();
+} catch (_) {
+  process.stdout.write('\n');
+}

package/bin/tokenwait.js

@@ -0,0 +1,248 @@
+#!/usr/bin/env node
+'use strict';
+// TokenWait CLI.
+//   npx tokenwait install [--agents claude,codex,gemini] [--server URL] [--yes] [--no-login]
+//   tokenwait uninstall [--purge]
+//   tokenwait login | logout | status [--json]
+//   tokenwait link-start --json | me --json | sync     (для расширений IDE)
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const readline = require('readline');
+const { spawn } = require('child_process');
+
+const util = require('../lib/util');
+const agents = require('../lib/agents');
+const api = require('../lib/api');
+const worker = require('../lib/worker');
+const { pick } = require('../lib/rotation');
+
+const VERSION = require('../package.json').version;
+const args = process.argv.slice(2);
+const flag = (n) => args.includes('--' + n);
+function opt(n) {
+  const i = args.indexOf('--' + n);
+  return i >= 0 ? args[i + 1] : undefined;
+}
+const json = flag('json');
+const out = (o) => process.stdout.write(JSON.stringify(o) + '\n');
+
+function ask(question) {
+  if (!process.stdin.isTTY) return Promise.resolve('');
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((res) => rl.question(question, (a) => (rl.close(), res(a.trim()))));
+}
+
+function openBrowser(url) {
+  try {
+    const cmd = process.platform === 'darwin' ? ['open', [url]] : process.platform === 'win32' ? ['cmd', ['/c', 'start', '', url]] : ['xdg-open', [url]];
+    spawn(cmd[0], cmd[1], { detached: true, stdio: 'ignore', windowsHide: true }).unref();
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+
+/** Копия пакета в ~/.tokenwait/app: кеш npx может исчезнуть, а хуки должны работать всегда. */
+function copyApp() {
+  const src = path.resolve(__dirname, '..');
+  const dst = util.p('app');
+  if (path.resolve(src) === path.resolve(dst)) return dst;
+  const tmp = util.p('app.new');
+  fs.rmSync(tmp, { recursive: true, force: true });
+  for (const d of ['bin', 'lib']) {
+    fs.mkdirSync(path.join(tmp, d), { recursive: true });
+    for (const f of fs.readdirSync(path.join(src, d))) {
+      if (f.endsWith('.js')) fs.copyFileSync(path.join(src, d, f), path.join(tmp, d, f));
+    }
+  }
+  fs.copyFileSync(path.join(src, 'package.json'), path.join(tmp, 'package.json'));
+  fs.rmSync(dst, { recursive: true, force: true });
+  fs.renameSync(tmp, dst);
+  return dst;
+}
+
+function chooseAgents() {
+  const list = opt('agents');
+  if (list && list !== 'auto') {
+    const ids = list.split(',').map((s) => s.trim()).filter(Boolean);
+    for (const id of ids) if (!agents.AGENTS[id]) throw new Error(`Unknown agent "${id}". Supported: ${Object.keys(agents.AGENTS).join(', ')}`);
+    return ids;
+  }
+  return Object.keys(agents.AGENTS).filter(agents.detected);
+}
+
+const CONSENT = `TokenWait shows a short, clearly labelled sponsored line while your AI coding agent is thinking,
+and pays you a share of the ad revenue.
+
+What it changes:
+  • adds two hooks (prompt start / response end) to each supported agent's config
+  • for Claude Code, adds a status line (your existing status line keeps working)
+  • stores ads, counters and an install key in ~/.tokenwait
+What it never does:
+  • read your code, prompts, responses or transcripts
+  • send anything except ad ids, impression counts, waiting time and the install key
+Undo at any time: npx tokenwait uninstall
+`;
+
+async function cmdInstall() {
+  const ids = chooseAgents();
+  if (!ids.length) throw new Error('No supported agent found (Claude Code, Codex CLI, Gemini CLI). Use --agents claude to install anyway.');
+  if (!flag('yes')) {
+    console.log(CONSENT);
+    console.log('Agents: ' + ids.map((id) => agents.AGENTS[id].name).join(', ') + '\n');
+    const a = await ask('Install TokenWait? [y/N] ');
+    if (!/^y(es)?$/i.test(a)) return console.log('Cancelled. Nothing was changed.');
+  }
+  const cfg = util.readJson(util.p('config.json'), {});
+  if (opt('server')) cfg.server = opt('server').replace(/\/+$/, '');
+  cfg.rotate_seconds = cfg.rotate_seconds || 30;
+  cfg.installed_at = cfg.installed_at || Date.now();
+  util.writeJson(util.p('config.json'), cfg);
+
+  const app = copyApp();
+  const node = process.execPath;
+  const results = [];
+  for (const id of ids) {
+    try {
+      const r = agents.install(id, node, app);
+      results.push({ agent: id, ok: true, file: r.file });
+      if (!json) console.log(`✓ ${agents.AGENTS[id].name}: ${r.file}`);
+      if (!json && agents.AGENTS[id].note) console.log('  ' + agents.AGENTS[id].note);
+    } catch (e) {
+      results.push({ agent: id, ok: false, error: e.message });
+      if (!json) console.log(`✗ ${agents.AGENTS[id].name}: ${e.message}`);
+    }
+  }
+  try {
+    await api.fetchAds();
+  } catch (e) {
+    if (!json) console.log('Could not reach the server yet (' + e.message + '). Ads will load automatically later.');
+  }
+  if (json) return out({ ok: results.every((r) => r.ok), agents: results });
+  console.log('\nRestart your agent sessions to pick up the changes.');
+  if (!flag('no-login') && api.credentials()) {
+    const a = await ask('Sign in now (GitHub, Google or Apple) so earnings go to your account? [Y/n] ');
+    if (!/^n/i.test(a)) await cmdLogin();
+  }
+}
+
+async function cmdUninstall() {
+  const res = [];
+  for (const id of Object.keys(agents.AGENTS)) {
+    try {
+      const r = agents.uninstall(id);
+      if (r.changed) res.push(id);
+    } catch (e) {
+      if (!json) console.log(`✗ ${agents.AGENTS[id].name}: ${e.message}`);
+    }
+  }
+  if (flag('purge')) fs.rmSync(util.home(), { recursive: true, force: true });
+  if (json) return out({ ok: true, removed: res });
+  console.log(res.length ? 'Removed from: ' + res.map((id) => agents.AGENTS[id].name).join(', ') : 'Nothing to remove.');
+  console.log('Restart your agent sessions to apply.');
+}
+
+async function cmdLinkStart() {
+  const r = await api.linkStart();
+  if (!String(r.url).startsWith(api.server() + '/')) throw new Error('Server returned an unexpected URL');
+  return r;
+}
+
+async function cmdLogin() {
+  const r = await cmdLinkStart();
+  console.log(`\nOpening ${r.url}`);
+  console.log(`Sign in with GitHub, Google or Apple, check that the page shows code ${r.code} and press "Link".`);
+  if (!openBrowser(r.url)) console.log('Open the link above in your browser.');
+  const deadline = Date.now() + 10 * 60 * 1000;
+  while (Date.now() < deadline) {
+    await new Promise((res) => setTimeout(res, 3000));
+    try {
+      const m = await api.me();
+      if (m.linked) return console.log(`✓ Signed in as ${m.login}`);
+    } catch (_) {}
+  }
+  console.log('The code expired. Run: npx tokenwait login');
+}
+
+async function cmdLogout() {
+  await api.unlink();
+  await api.me().catch(() => {});
+  json ? out({ ok: true }) : console.log('Signed out. This install is no longer linked to your account.');
+}
+
+function statusData() {
+  const ads = util.readJson(util.p('ads.json'), null);
+  const me = util.readJson(util.p('me.json'), null);
+  const cfg = util.readJson(util.p('config.json'), {});
+  const ad = ads && pick(ads.ads, Date.now(), cfg.rotate_seconds || 30);
+  return {
+    version: VERSION,
+    server: api.server(),
+    registered: !!api.credentials(),
+    agents: Object.fromEntries(Object.keys(agents.AGENTS).map((id) => [id, { detected: agents.detected(id), installed: agents.isInstalled(id) }])),
+    account: me ? { linked: !!me.linked, login: me.login || null } : null,
+    impressions: me ? me.impressions : null,
+    earnings_cents: me ? me.earnings_cents : null,
+    ads: ads ? ads.ads.length : 0,
+    current_ad: ad || null,
+  };
+}
+
+async function cmdStatus() {
+  await worker.run().catch(() => {});
+  const s = statusData();
+  if (json) return out(s);
+  console.log(`TokenWait ${s.version} · server ${s.server}`);
+  for (const [id, a] of Object.entries(s.agents)) {
+    console.log(`  ${agents.AGENTS[id].name.padEnd(12)} ${a.installed ? 'installed' : a.detected ? 'not installed' : 'not found'}`);
+  }
+  console.log(`Account: ${s.account && s.account.linked ? s.account.login : 'not linked (run: npx tokenwait login)'}`);
+  if (s.impressions) {
+    console.log(`Impressions: today ${s.impressions.today}, total ${s.impressions.total}`);
+    console.log(`Earnings: $${(s.earnings_cents.total / 100).toFixed(2)} total`);
+  }
+  console.log(`Ads loaded: ${s.ads}${s.current_ad ? ' · now: ' + s.current_ad.text : ''}`);
+}
+
+function help() {
+  console.log(`TokenWait ${VERSION} — get paid while your AI coding agent thinks.
+
+  npx tokenwait install     set up Claude Code / Codex CLI / Gemini CLI
+  npx tokenwait login       link this machine to your account (GitHub, Google or Apple)
+  npx tokenwait status      what is installed, impressions and earnings
+  npx tokenwait logout      unlink this machine
+  npx tokenwait uninstall   remove everything from agent configs (--purge also deletes ~/.tokenwait)
+
+Options: --agents claude,codex,gemini  --server URL  --yes  --json`);
+}
+
+const commands = {
+  install: cmdInstall,
+  uninstall: cmdUninstall,
+  login: cmdLogin,
+  logout: cmdLogout,
+  status: cmdStatus,
+  'link-start': async () => out(await cmdLinkStart()),
+  me: async () => out(await api.me()),
+  sync: async () => {
+    await worker.run({ forceAds: flag('force-ads') });
+    if (json) out(statusData());
+  },
+  version: () => console.log(VERSION),
+  help,
+};
+
+const cmd = args[0] || 'help';
+if (!commands[cmd]) {
+  help();
+  process.exit(1);
+}
+Promise.resolve()
+  .then(() => commands[cmd]())
+  .then(() => process.exit(0))
+  .catch((e) => {
+    if (json) out({ ok: false, error: e.message });
+    else console.error('Error: ' + e.message);
+    process.exit(1);
+  });

package/bin/worker.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+'use strict';
+require('../lib/worker')
+  .run({ forceAds: process.argv.includes('--force-ads') })
+  .catch(() => {})
+  .finally(() => process.exit(0));

package/lib/accounting.js

@@ -0,0 +1,119 @@
+'use strict';
+// Учёт показов по хукам. Чистые функции + работа с файлами состояния.
+//
+// events.jsonl     {t, e: "start"|"stop", a: agent, s: session}       — пишут хуки
+// visibility.jsonl {t, f: 0|1, tv: 0|1, src}                          — пишут расширения IDE
+//                  f — окно IDE в фокусе (видна нижняя строка IDE с рекламой),
+//                  tv — видна панель терминала (видна statusLine Claude Code).
+//                  IDE пишет при изменении и раз в 15 с как «пульс».
+// pending.json     {ads: {id: ms}, wait_ms, last_report}               — неотправленное
+//
+// Где реклама реально видна:
+//   claude + IDE  -> f && tv  (statusLine в терминале IDE)
+//   claude без IDE -> всё ожидание (терминал без проверки видимости)
+//   codex/gemini + IDE -> f   (реклама в нижней строке IDE)
+//   codex/gemini без IDE -> ничего: показать негде
+
+const fs = require('fs');
+const { p, readJson, writeJson, withLock } = require('./util');
+const { pick } = require('./rotation');
+
+const MAX_WAIT_MS = 10 * 60 * 1000;
+const HEARTBEAT_MS = 20 * 1000;
+const STEP_MS = 500;
+
+function readLines(file, max = 2000) {
+  try {
+    const lines = fs.readFileSync(file, 'utf8').split('\n').filter(Boolean);
+    return lines.slice(-max).map((l) => {
+      try {
+        return JSON.parse(l);
+      } catch (_) {
+        return null;
+      }
+    }).filter(Boolean);
+  } catch (_) {
+    return [];
+  }
+}
+
+function appendLine(file, obj, keep = 1000) {
+  try {
+    if (fs.statSync(file).size > 256 * 1024) {
+      const lines = fs.readFileSync(file, 'utf8').split('\n').filter(Boolean);
+      fs.writeFileSync(file, lines.slice(-keep).join('\n') + '\n');
+    }
+  } catch (_) {}
+  fs.appendFileSync(file, JSON.stringify(obj) + '\n');
+}
+
+/** Интервал ожидания, который закрывается этим stop: последний start той же сессии. */
+function waitInterval(events, agent, session, stopT) {
+  let start = null;
+  for (const e of events) {
+    if (e.a !== agent || e.s !== session || e.t >= stopT) continue; // сам stop уже может быть в журнале
+    if (e.e === 'start') start = e.t;
+    else if (e.e === 'stop') start = null;
+  }
+  if (start === null) return null;
+  const t0 = Math.max(start, stopT - MAX_WAIT_MS);
+  return t0 < stopT ? [t0, stopT] : null;
+}
+
+/** Состояние видимости в момент x: последняя запись не старше HEARTBEAT_MS, иначе null (IDE нет). */
+function visibilityAt(vis, x) {
+  let cur = null;
+  for (const v of vis) {
+    if (v.t > x) break;
+    cur = v;
+  }
+  return cur && x - cur.t <= HEARTBEAT_MS ? cur : null;
+}
+
+/**
+ * Сколько миллисекунд какое объявление было реально видно за интервал ожидания.
+ * Возвращает {ads: {id: ms}, visibleMs}.
+ */
+function attribute({ agent, interval, vis, ads, rotateSeconds }) {
+  const out = { ads: {}, visibleMs: 0 };
+  if (!interval || !ads || !ads.length) return out;
+  const sorted = vis.slice().sort((a, b) => a.t - b.t);
+  for (let x = interval[0]; x < interval[1]; x += STEP_MS) {
+    const dt = Math.min(STEP_MS, interval[1] - x);
+    const v = visibilityAt(sorted, x);
+    let shown;
+    if (agent === 'claude') shown = v ? !!(v.f && v.tv) : true;
+    else shown = v ? !!v.f : false;
+    if (!shown) continue;
+    const ad = pick(ads, x, rotateSeconds);
+    if (!ad) continue;
+    out.ads[ad.id] = (out.ads[ad.id] || 0) + dt;
+    out.visibleMs += dt;
+  }
+  return out;
+}
+
+function addToPending(add) {
+  return withLock('pending', () => {
+    const pend = readJson(p('pending.json'), { ads: {}, wait_ms: 0, last_report: 0 });
+    for (const [id, ms] of Object.entries(add.ads)) pend.ads[id] = (pend.ads[id] || 0) + ms;
+    pend.wait_ms = Math.min((pend.wait_ms || 0) + add.visibleMs, 24 * 3600 * 1000);
+    writeJson(p('pending.json'), pend);
+    return pend;
+  });
+}
+
+/** Целые показы из накопленных миллисекунд; остаток остаётся. */
+function toImpressions(pendAds, impressionSeconds) {
+  const impMs = impressionSeconds * 1000;
+  const counts = {};
+  const rest = {};
+  for (const [id, ms] of Object.entries(pendAds || {})) {
+    const n = Math.floor(ms / impMs);
+    if (n > 0) counts[id] = n;
+    if (ms - n * impMs > 0) rest[id] = ms - n * impMs;
+  }
+  return { counts, rest };
+}
+
+module.exports = { MAX_WAIT_MS, HEARTBEAT_MS, readLines, appendLine, waitInterval, visibilityAt, attribute, addToPending, toImpressions };

package/lib/agents.js

@@ -0,0 +1,194 @@
+'use strict';
+// Адаптеры агентов. Каждый умеет: найти себя, поставить/снять хуки ожидания,
+// и (если есть) поставить свою «витрину» в терминале.
+//
+//   claude  — ~/.claude/settings.json: statusLine (витрина) + хуки UserPromptSubmit/Stop
+//   codex   — ~/.codex/hooks.json: хуки UserPromptSubmit/Stop (витрины в терминале нет;
+//             новые хуки нужно один раз одобрить в Codex командой /hooks)
+//   gemini  — ~/.gemini/settings.json: хуки BeforeAgent/AfterAgent (витрины в терминале нет)
+//
+// Наши записи помечены маркерами (--tw, --twhook), чужие не трогаем.
+// Маркеры прежнего названия (--sl, --slhook) убираются при установке — миграция со Sponsorline.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { readJsonStrict, writeJson, backup, q, p } = require('./util');
+
+const HOOK_MARK = '--twhook';
+const LEGACY_HOOK_MARK = '--slhook';
+const STATUS_RE = / --(tw|sl)(?: --wrap (\S+))?\s*$/;
+
+const AGENTS = {
+  claude: {
+    name: 'Claude Code',
+    dir: () => path.join(os.homedir(), '.claude'),
+    file: () => path.join(os.homedir(), '.claude', 'settings.json'),
+    events: { UserPromptSubmit: 'start', Stop: 'stop' },
+    statusLine: true,
+  },
+  codex: {
+    name: 'Codex CLI',
+    dir: () => path.join(os.homedir(), '.codex'),
+    file: () => path.join(os.homedir(), '.codex', 'hooks.json'),
+    events: { UserPromptSubmit: 'start', Stop: 'stop' },
+    statusLine: false,
+    note: 'Codex runs new hooks only after you approve them: start codex and run /hooks once.',
+  },
+  gemini: {
+    name: 'Gemini CLI',
+    dir: () => path.join(os.homedir(), '.gemini'),
+    file: () => path.join(os.homedir(), '.gemini', 'settings.json'),
+    events: { BeforeAgent: 'start', AfterAgent: 'stop' },
+    statusLine: false,
+  },
+};
+
+function detected(id) {
+  return fs.existsSync(AGENTS[id].dir());
+}
+
+function commandOf(v) {
+  if (typeof v === 'string') return v;
+  if (v && typeof v === 'object' && typeof v.command === 'string') return v.command;
+  return null;
+}
+
+// ---------- statusLine (Claude Code) ----------
+
+function parseStatusLine(v) {
+  const cmd = commandOf(v);
+  if (!cmd) return null;
+  const m = cmd.match(STATUS_RE);
+  if (!m) return null;
+  let wrap;
+  if (m[2]) wrap = JSON.parse(Buffer.from(m[2], 'base64url').toString('utf8'));
+  return { legacy: m[1] === 'sl', wrap };
+}
+
+function buildStatusLine(node, statusJs, wrap) {
+  let c = q(node) + ' ' + q(statusJs) + ' --tw';
+  if (wrap !== undefined) c += ' --wrap ' + Buffer.from(JSON.stringify(wrap)).toString('base64url');
+  return { type: 'command', command: c };
+}
+
+/** Снимает нашу (или старую) statusLine, возвращая чужую. true, если что-то поменялось. */
+function unwrapStatusLine(s) {
+  let changed = false;
+  for (let i = 0; i < 5; i++) {
+    const ours = parseStatusLine(s.statusLine);
+    if (!ours) break;
+    if (ours.wrap === undefined) delete s.statusLine;
+    else s.statusLine = ours.wrap;
+    changed = true;
+  }
+  return changed;
+}
+
+// ---------- хуки (общий формат Claude/Codex/Gemini) ----------
+
+function isOurHookGroup(g, marks) {
+  return (
+    g &&
+    typeof g === 'object' &&
+    Array.isArray(g.hooks) &&
+    g.hooks.some((h) => h && typeof h.command === 'string' && marks.some((m) => h.command.includes(m)))
+  );
+}
+
+function removeHooks(s, events, marks) {
+  if (!s.hooks || typeof s.hooks !== 'object') return false;
+  let changed = false;
+  for (const ev of events) {
+    const arr = s.hooks[ev];
+    if (!Array.isArray(arr)) continue;
+    const kept = arr.filter((g) => !isOurHookGroup(g, marks));
+    if (kept.length !== arr.length) {
+      changed = true;
+      if (kept.length) s.hooks[ev] = kept;
+      else delete s.hooks[ev];
+    }
+  }
+  if (changed && Object.keys(s.hooks).length === 0) delete s.hooks;
+  return changed;
+}
+
+function addHooks(s, agentId, node, hookJs) {
+  const a = AGENTS[agentId];
+  if (!s.hooks || typeof s.hooks !== 'object' || Array.isArray(s.hooks)) s.hooks = {};
+  for (const [ev, phase] of Object.entries(a.events)) {
+    if (!Array.isArray(s.hooks[ev])) s.hooks[ev] = [];
+    const hook = { type: 'command', command: `${q(node)} ${q(hookJs)} ${agentId} ${phase} ${HOOK_MARK}` };
+    if (agentId === 'codex') hook.timeout = 10; // секунды
+    if (agentId === 'gemini') {
+      hook.name = 'tokenwait-' + phase;
+      hook.timeout = 10000; // миллисекунды
+    }
+    s.hooks[ev].push({ hooks: [hook] });
+  }
+}
+
+/** Ставит (или обновляет) интеграцию агента. Возвращает описание изменений. */
+function install(agentId, node, appDir) {
+  const a = AGENTS[agentId];
+  const file = a.file();
+  const { value: s } = readJsonStrict(file);
+  const before = JSON.stringify(s);
+  const events = Object.keys(a.events);
+  // всё старое и наше снимаем, затем ставим заново — так обновляются пути после переустановки
+  removeHooks(s, events, [HOOK_MARK, LEGACY_HOOK_MARK]);
+  addHooks(s, agentId, node, path.join(appDir, 'bin', 'hook.js'));
+  if (a.statusLine) {
+    unwrapStatusLine(s);
+    s.statusLine = buildStatusLine(node, path.join(appDir, 'bin', 'status.js'), s.statusLine);
+  }
+  if (agentId === 'claude') restoreLegacySpinner(s);
+  if (JSON.stringify(s) === before) return { file, changed: false };
+  backup(file);
+  writeJson(file, s);
+  return { file, changed: true };
+}
+
+function uninstall(agentId) {
+  const a = AGENTS[agentId];
+  const file = a.file();
+  if (!fs.existsSync(file)) return { file, changed: false };
+  const { value: s } = readJsonStrict(file);
+  let changed = removeHooks(s, Object.keys(a.events), [HOOK_MARK, LEGACY_HOOK_MARK]);
+  if (a.statusLine && unwrapStatusLine(s)) changed = true;
+  if (agentId === 'claude' && restoreLegacySpinner(s)) changed = true;
+  if (!changed) return { file, changed: false };
+  backup(file);
+  writeJson(file, s);
+  return { file, changed: true };
+}
+
+function isInstalled(agentId) {
+  const a = AGENTS[agentId];
+  let s;
+  try {
+    s = readJsonStrict(a.file()).value;
+  } catch (_) {
+    return false;
+  }
+  const hooksOk = Object.keys(a.events).every((ev) => Array.isArray(s.hooks && s.hooks[ev]) && s.hooks[ev].some((g) => isOurHookGroup(g, [HOOK_MARK])));
+  const slOk = !a.statusLine || (parseStatusLine(s.statusLine) || {}).legacy === false;
+  return hooksOk && slOk;
+}
+
+/** Плагин Sponsorline 0.1–0.2 мог заменить spinnerVerbs; вернём оригинал. */
+function restoreLegacySpinner(s) {
+  const f = path.join(os.homedir(), '.sponsorline', 'spinner-original.json');
+  if (!fs.existsSync(f)) return false;
+  try {
+    const orig = JSON.parse(fs.readFileSync(f, 'utf8')).original;
+    if (orig === null || orig === undefined) delete s.spinnerVerbs;
+    else s.spinnerVerbs = orig;
+    fs.renameSync(f, f + '.restored');
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+
+module.exports = { AGENTS, detected, install, uninstall, isInstalled, parseStatusLine, HOOK_MARK, _p: p };

package/lib/api.js

@@ -0,0 +1,88 @@
+'use strict';
+// Клиент API сервера. Ключ установки — ~/.tokenwait/credentials.json (права 600),
+// общий для CLI и расширений IDE: одна машина = одна установка.
+const { p, readJson, writeJson, DEFAULT_SERVER } = require('./util');
+const { normalizeAds } = require('./rotation');
+
+class HttpError extends Error {
+  constructor(status, body) {
+    super(`HTTP ${status}: ${String(body).slice(0, 200)}`);
+    this.status = status;
+  }
+}
+
+function config() {
+  return readJson(p('config.json'), {});
+}
+
+function server() {
+  return (process.env.TOKENWAIT_SERVER || config().server || DEFAULT_SERVER).replace(/\/+$/, '');
+}
+
+function credentials() {
+  const c = readJson(p('credentials.json'), null);
+  return c && c.server === server() && c.client_id && c.client_secret ? c : null;
+}
+
+async function request(method, path, body, auth = true, timeoutMs = 5000) {
+  const headers = { accept: 'application/json', 'user-agent': 'tokenwait/' + require('../package.json').version };
+  if (body !== undefined) headers['content-type'] = 'application/json';
+  if (auth) {
+    const c = credentials() || (await register());
+    headers.authorization = `Bearer ${c.client_id}.${c.client_secret}`;
+  }
+  const res = await fetch(server() + path, {
+    method,
+    headers,
+    body: body === undefined ? undefined : JSON.stringify(body),
+    signal: AbortSignal.timeout(timeoutMs),
+  });
+  const text = await res.text();
+  if (res.status === 401 && auth) writeJson(p('credentials.json'), {}, 0o600); // ключ не принят — получим новый
+  if (!res.ok) throw new HttpError(res.status, text);
+  try {
+    return JSON.parse(text);
+  } catch (_) {
+    throw new Error('Server returned non-JSON: ' + text.slice(0, 200));
+  }
+}
+
+async function register() {
+  const r = await request('POST', '/v1/register', undefined, false);
+  const c = { server: server(), client_id: r.client_id, client_secret: r.client_secret };
+  writeJson(p('credentials.json'), c, 0o600);
+  return c;
+}
+
+async function fetchAds() {
+  const r = await request('GET', '/v1/ads');
+  const data = {
+    fetched_at: Date.now(),
+    ttl_seconds: Math.min(Math.max(Number(r.ttl_seconds) || 600, 60), 3600),
+    impression_seconds: Math.min(Math.max(Number(r.impression_seconds) || 5, 1), 60),
+    report_seconds: Math.min(Math.max(Number(r.report_seconds) || 60, 30), 3600),
+    ads: normalizeAds(r.ads),
+  };
+  writeJson(p('ads.json'), data);
+  return data;
+}
+
+async function me() {
+  const r = await request('GET', '/v1/me');
+  const data = { ...r, fetched_at: Date.now() };
+  writeJson(p('me.json'), data);
+  return data;
+}
+
+module.exports = {
+  HttpError,
+  server,
+  config,
+  credentials,
+  register,
+  fetchAds,
+  me,
+  reportImpressions: (items, waitMs) => request('POST', '/v1/impressions', { items, wait_ms: waitMs }),
+  linkStart: () => request('POST', '/v1/link/start', {}),
+  unlink: () => request('POST', '/v1/unlink', {}),
+};

package/lib/rotation.js

@@ -0,0 +1,46 @@
+'use strict';
+// Детерминированная ротация: какое объявление показано в момент t, вычисляется
+// одинаково в statusLine, в хуках и в расширениях IDE (Kotlin/TS повторяют этот код).
+// Тестовые векторы: core/test/rotation-vectors.json.
+
+const { sanitizeText, safeUrl } = require('./util');
+
+function mulberry32(seed) {
+  let a = seed | 0;
+  a = (a + 0x6d2b79f5) | 0;
+  let t = Math.imul(a ^ (a >>> 15), 1 | a);
+  t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+  return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+}
+
+function slotOf(t, rotateSeconds) {
+  return Math.floor(t / (rotateSeconds * 1000));
+}
+
+/** ads: [{id, text, url, weight}] в порядке сервера. */
+function pick(ads, t, rotateSeconds) {
+  if (!Array.isArray(ads) || ads.length === 0) return null;
+  const total = ads.reduce((s, a) => s + Math.max(1, a.weight | 0), 0);
+  let r = Math.floor(mulberry32(slotOf(t, rotateSeconds)) * total);
+  for (const a of ads) {
+    r -= Math.max(1, a.weight | 0);
+    if (r < 0) return a;
+  }
+  return ads[ads.length - 1];
+}
+
+/** Очистка списка с сервера. */
+function normalizeAds(list) {
+  if (!Array.isArray(list)) return [];
+  return list
+    .map((a) => ({
+      id: sanitizeText(a && a.id, 64),
+      text: sanitizeText(a && a.text),
+      url: safeUrl(a && a.url),
+      weight: Math.max(1, Math.floor(Number(a && a.weight)) || 1),
+    }))
+    .filter((a) => a.id && a.text)
+    .slice(0, 50);
+}
+
+module.exports = { mulberry32, slotOf, pick, normalizeAds };

package/lib/util.js

@@ -0,0 +1,184 @@
+'use strict';
+// Общие утилиты: пути, атомарная запись JSON, блокировки, очистка текста.
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const DEFAULT_SERVER = 'https://tokenwait.dev-line.workers.dev';
+
+function home() {
+  return process.env.TOKENWAIT_HOME || path.join(os.homedir(), '.tokenwait');
+}
+
+function p(...parts) {
+  return path.join(home(), ...parts);
+}
+
+/** Наши служебные файлы: нет файла или он битый — возвращаем fallback. */
+function readJson(file, fallback) {
+  try {
+    const txt = fs.readFileSync(file, 'utf8').replace(/^/, '');
+    return txt.trim() ? JSON.parse(txt) : fallback;
+  } catch (_) {
+    return fallback;
+  }
+}
+
+/** Строгое чтение: битый JSON -> исключение (для чужих конфигов, которые нельзя портить). */
+function readJsonStrict(file) {
+  let txt;
+  try {
+    txt = fs.readFileSync(file, 'utf8').replace(/^/, '');
+  } catch (e) {
+    if (e.code === 'ENOENT') return { value: {}, existed: false };
+    throw e;
+  }
+  if (!txt.trim()) return { value: {}, existed: true };
+  let v;
+  try {
+    v = JSON.parse(txt);
+  } catch (e) {
+    throw new Error(`Cannot parse ${file}: ${e.message}. File left untouched.`);
+  }
+  if (!v || typeof v !== 'object' || Array.isArray(v)) throw new Error(`${file}: expected a JSON object. File left untouched.`);
+  return { value: v, existed: true };
+}
+
+function writeJson(file, obj, mode) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = file + '.tmp-' + process.pid + '-' + Math.random().toString(36).slice(2);
+  fs.writeFileSync(tmp, JSON.stringify(obj, null, 2) + '\n', mode ? { mode } : undefined);
+  try {
+    if (!mode) fs.chmodSync(tmp, fs.statSync(file).mode & 0o777);
+  } catch (_) {}
+  fs.renameSync(tmp, file);
+}
+
+function backup(file) {
+  if (!fs.existsSync(file)) return null;
+  const dir = p('backups');
+  fs.mkdirSync(dir, { recursive: true });
+  const name = path.basename(path.dirname(file)) + '-' + path.basename(file) + '-' + new Date().toISOString().replace(/[:.]/g, '-') + '.bak';
+  const target = path.join(dir, name);
+  fs.copyFileSync(file, target);
+  return target;
+}
+
+/** Простая межпроцессная блокировка через O_EXCL; протухшая (> staleMs) снимается. */
+function withLock(name, fn, { staleMs = 30000, waitMs = 2000 } = {}) {
+  const file = p(name + '.lock');
+  fs.mkdirSync(home(), { recursive: true });
+  const deadline = Date.now() + waitMs;
+  for (;;) {
+    try {
+      fs.writeFileSync(file, String(process.pid), { flag: 'wx' });
+      break;
+    } catch (e) {
+      if (e.code !== 'EEXIST') throw e;
+      try {
+        if (Date.now() - fs.statSync(file).mtimeMs > staleMs) {
+          fs.unlinkSync(file);
+          continue;
+        }
+      } catch (_) {
+        continue;
+      }
+      if (Date.now() > deadline) return undefined;
+      const until = Date.now() + 25;
+      while (Date.now() < until) {} // короткое ожидание без async
+    }
+  }
+  try {
+    return fn();
+  } finally {
+    try {
+      fs.unlinkSync(file);
+    } catch (_) {}
+  }
+}
+
+async function withLockAsync(name, fn, opts = {}) {
+  const file = p(name + '.lock');
+  fs.mkdirSync(home(), { recursive: true });
+  try {
+    fs.writeFileSync(file, String(process.pid), { flag: 'wx' });
+  } catch (e) {
+    if (e.code !== 'EEXIST') throw e;
+    try {
+      if (Date.now() - fs.statSync(file).mtimeMs <= (opts.staleMs || 60000)) return undefined;
+      fs.unlinkSync(file);
+      fs.writeFileSync(file, String(process.pid), { flag: 'wx' });
+    } catch (_) {
+      return undefined;
+    }
+  }
+  try {
+    return await fn();
+  } finally {
+    try {
+      fs.unlinkSync(file);
+    } catch (_) {}
+  }
+}
+
+// Внешний текст рекламы: никаких управляющих последовательностей терминала.
+const ANSI_OSC = /\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g;
+const ANSI_CSI = /\x1b\[[0-9;?]*[ -\/]*[@-~]/g;
+const BAD = /[\u0000-\u001f\u007f-\u009f​-‏‪-‮⁦-⁩]/g;
+
+function sanitizeText(input, max = 80) {
+  let s = String(input == null ? '' : input)
+    .replace(ANSI_OSC, '')
+    .replace(ANSI_CSI, '')
+    .replace(BAD, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+  const chars = Array.from(s);
+  if (chars.length > max) s = chars.slice(0, max - 1).join('') + '…';
+  return s;
+}
+
+function hostOf(url) {
+  try {
+    const u = new URL(String(url));
+    if (u.protocol !== 'http:' && u.protocol !== 'https:') return '';
+    return sanitizeText(u.host, 40);
+  } catch (_) {
+    return '';
+  }
+}
+
+function safeUrl(url) {
+  try {
+    const u = new URL(String(url));
+    return u.protocol === 'http:' || u.protocol === 'https:' ? u.toString() : '';
+  } catch (_) {
+    return '';
+  }
+}
+
+/** Путь для shell-команды: на Windows Claude Code/Codex запускают команды через bash/cmd, прямые слэши понимают оба. */
+function shellPath(p) {
+  return process.platform === 'win32' ? p.replace(/\\/g, '/') : p;
+}
+
+function q(p) {
+  return '"' + shellPath(p) + '"';
+}
+
+module.exports = {
+  DEFAULT_SERVER,
+  home,
+  p,
+  readJson,
+  readJsonStrict,
+  writeJson,
+  backup,
+  withLock,
+  withLockAsync,
+  sanitizeText,
+  hostOf,
+  safeUrl,
+  shellPath,
+  q,
+};

package/lib/worker.js

@@ -0,0 +1,117 @@
+'use strict';
+// Фоновая синхронизация: обновить рекламу, отправить показы, обновить статистику.
+// Запускается отсоединённым процессом из хуков и statusLine, чтобы не задерживать агента.
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+const { p, readJson, writeJson, withLock, withLockAsync } = require('./util');
+const api = require('./api');
+const { toImpressions } = require('./accounting');
+
+function adsStale(now = Date.now()) {
+  const a = readJson(p('ads.json'), null);
+  return !a || now - (a.fetched_at || 0) > (a.ttl_seconds || 600) * 1000;
+}
+
+function reportDue(now = Date.now()) {
+  const a = readJson(p('ads.json'), {});
+  const pend = readJson(p('pending.json'), null);
+  if (!pend || !pend.ads || !Object.keys(pend.ads).length) return false;
+  return now - (pend.last_report || 0) >= (a.report_seconds || 60) * 1000;
+}
+
+/** Запустить worker в фоне, не чаще раза в 10 секунд. */
+function spawnWorker(force = false) {
+  try {
+    const mark = p('worker.spawned');
+    if (!force) {
+      try {
+        if (Date.now() - fs.statSync(mark).mtimeMs < 10000) return false;
+      } catch (_) {}
+    }
+    fs.mkdirSync(path.dirname(mark), { recursive: true });
+    fs.writeFileSync(mark, String(Date.now()));
+    const child = spawn(process.execPath, [path.join(__dirname, '..', 'bin', 'worker.js')], {
+      detached: true,
+      stdio: 'ignore',
+      windowsHide: true,
+      env: process.env,
+    });
+    child.unref();
+    return true;
+  } catch (_) {
+    return false;
+  }
+}
+
+async function report() {
+  const ads = readJson(p('ads.json'), {});
+  const impSec = ads.impression_seconds || 5;
+  const impMs = impSec * 1000;
+  // забираем целые показы из пачки под блокировкой
+  const taken = withLock('pending', () => {
+    const pend = readJson(p('pending.json'), { ads: {}, wait_ms: 0, last_report: 0 });
+    if (Date.now() - (pend.last_report || 0) < (ads.report_seconds || 60) * 1000) return null;
+    const { counts, rest } = toImpressions(pend.ads, impSec);
+    if (!Object.keys(counts).length) return null;
+    const waitMs = pend.wait_ms || 0;
+    writeJson(p('pending.json'), { ads: rest, wait_ms: 0, last_report: Date.now() });
+    return { counts, waitMs };
+  });
+  if (!taken) return null;
+  const items = Object.entries(taken.counts).map(([ad_id, count]) => ({ ad_id, count }));
+  try {
+    const r = await api.reportImpressions(items, taken.waitMs);
+    log(`report: sent ${items.reduce((s, i) => s + i.count, 0)}, accepted ${r.accepted}`);
+    return r;
+  } catch (e) {
+    // сервер не обработал пачку — возвращаем её; прочие 4xx (например, неизвестная реклама) отбрасываем
+    const retry = !(e instanceof api.HttpError) || e.status === 429 || e.status === 409 || e.status >= 500;
+    if (retry) {
+      withLock('pending', () => {
+        const pend = readJson(p('pending.json'), { ads: {}, wait_ms: 0, last_report: 0 });
+        for (const [id, n] of Object.entries(taken.counts)) pend.ads[id] = (pend.ads[id] || 0) + n * impMs;
+        pend.wait_ms = Math.min((pend.wait_ms || 0) + taken.waitMs, 24 * 3600 * 1000);
+        if (e.status === 429) pend.last_report = Date.now();
+        else pend.last_report = 0;
+        writeJson(p('pending.json'), pend);
+      });
+    }
+    log('report failed: ' + e.message);
+    return null;
+  }
+}
+
+function log(msg) {
+  try {
+    const f = p('worker.log');
+    try {
+      if (fs.statSync(f).size > 64 * 1024) fs.writeFileSync(f, '');
+    } catch (_) {}
+    fs.appendFileSync(f, new Date().toISOString() + ' ' + msg + '\n');
+  } catch (_) {}
+}
+
+async function run({ forceAds = false } = {}) {
+  return withLockAsync('worker', async () => {
+    if (forceAds || adsStale()) {
+      try {
+        const a = await api.fetchAds();
+        log(`ads: ${a.ads.length}`);
+      } catch (e) {
+        log('ads failed: ' + e.message);
+      }
+    }
+    const r = await report();
+    const meFile = readJson(p('me.json'), null);
+    if (r || !meFile || Date.now() - (meFile.fetched_at || 0) > 60000) {
+      try {
+        await api.me();
+      } catch (e) {
+        log('me failed: ' + e.message);
+      }
+    }
+  });
+}
+
+module.exports = { run, report, spawnWorker, adsStale, reportDue, log };

package/package.json

@@ -1,6 +1,26 @@
 {
   "name": "tokenwait",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Get paid while your AI coding agent thinks. A clearly labelled sponsored line for Claude Code, Codex CLI and Gemini CLI.",
+  "bin": {
+    "tokenwait": "bin/tokenwait.js"
+  },
+  "files": [
+    "bin",
+    "lib"
+  ],
+  "engines": {
+    "node": ">=18.17"
+  },
+  "scripts": {
+    "test": "node test/test.js"
+  },
+  "keywords": [
+    "claude-code",
+    "codex",
+    "gemini-cli",
+    "statusline",
+    "ai-agents"
+  ],
+  "license": "UNLICENSED"
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.