valistry 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,58 @@
-# Temporary Holding Version
+# valistry
 
-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.
+Sets up the AI tools on your computer to send their use to [Valistry](https://valistry.ai). Counts only.
+
+```sh
+npx valistry setup --key <your key> --email you@company.com --desktop
+```
+
+Your key is on Connect → OpenTelemetry in Valistry. It needs Node 18 or later.
+
+If Claude Code already sends to Valistry, you can leave out `--key`. Setup then uses the key and address already in `~/.claude/settings.json`, or else in Codex's `[otel]` table, and says which, with the key's last four characters only. A regional address, such as `/in/api/otlp`, is kept. If neither file has a key, it says so and changes nothing.
+
+**It shows every change first and makes none.** Run the same command with `--apply` to make them.
+
+## What it changes
+
+| Tool | File | Change |
+|---|---|---|
+| Claude Code | `~/.claude/settings.json` | Adds the telemetry settings to `"env"` and two hooks (a limit stopped a turn, a session ended). Keeps every other setting. A copy is saved first. |
+| Codex | `~/.codex/config.toml` | Adds an `[otel]` table at the end, with prompts off. Keeps every other line. A copy is saved first. |
+| Desktop apps (`--desktop`) | macOS: `~/Library/LaunchAgents/ai.valistry.desktop.plist`. Windows: a Scheduled Task, "Valistry desktop" | Runs a small observer once a minute. Its files are in `~/.valistry`. |
+
+A tool that is not on the computer is skipped. Telemetry that already goes to another address is not replaced unless you add `--force`.
+
+Options: `--team <name>` names your team. `--endpoint <url>` sends to another Valistry address (the default is the address found with the key, else `https://app.valistry.ai/api/otlp`). `--no-claude` and `--no-codex` leave a tool alone.
+
+## The desktop observer
+
+Each minute it asks the computer which app is in front. If it is the Claude desktop app, the ChatGPT desktop app or the Microsoft Copilot app, and the keyboard or mouse was used in the last five minutes, that app gets one minute.
+
+It reads:
+
+- the front app's bundle id and name (macOS `lsappinfo`), or its process name (Windows);
+- the seconds since the last key or mouse input, as one number (macOS `ioreg`, Windows `GetLastInputInfo`).
+
+It sends, every 15 minutes, to `<endpoint>/v1/metrics` with your key:
+
+- per day and app, the active minutes (`valistry.desktop.active_minutes`);
+- you, as a code: a hash of your email, made on your computer;
+- your team, if you named one.
+
+**Never read or sent:** window titles, what is on the screen, which keys you type, prompts, replies, files, and your email itself.
+
+Windows support is written but not yet run on Windows.
+
+## Status and undo
+
+```sh
+npx valistry status          # what is set up, and the last send
+npx valistry remove          # shows what it would undo
+npx valistry remove --apply  # stops the observer, deletes its files, puts your settings files back
+```
+
+A settings file you have not changed since setup gets its copy back as it was. A file you changed since loses only what setup added.
+
+## Read it before you run it
+
+`bin/valistry.mjs` is one file, not minified, with no dependencies. It is built from `packages/cli/src` in the Valistry repository.

package/bin/valistry.mjs

@@ -0,0 +1,839 @@
+#!/usr/bin/env node
+// valistry 0.1.0: sets up this computer's AI tools to send their use to Valistry. Built from packages/cli/src in the
+// Valistry repository by packages/cli/build.mjs: do not edit. Counts only: never prompts, replies, code, window titles,
+// screen contents or keys typed.
+
+// packages/cli/src/main.ts
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+import { execFileSync as execFileSync2 } from "node:child_process";
+import { existsSync as existsSync2, rmSync as rmSync2 } from "node:fs";
+
+// packages/cli/src/setup.ts
+import { createHash as createHash2 } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, rmSync, copyFileSync, chmodSync } from "node:fs";
+import { basename, dirname, join as join2 } from "node:path";
+
+// packages/connectors/src/adapters/telemetry-env.ts
+var CLAUDE_CODE_ENV = (endpoint, key) => [
+  ["CLAUDE_CODE_ENABLE_TELEMETRY", "1"],
+  ["OTEL_METRICS_EXPORTER", "otlp"],
+  ["OTEL_LOGS_EXPORTER", "otlp"],
+  ["OTEL_EXPORTER_OTLP_PROTOCOL", "http/json"],
+  ["OTEL_EXPORTER_OTLP_ENDPOINT", endpoint],
+  ["OTEL_EXPORTER_OTLP_HEADERS", `Authorization=Bearer ${key}`],
+  ["OTEL_METRICS_INCLUDE_SESSION_ID", "true"]
+];
+var teamAttribute = (team) => `team.id=${team.trim().replace(/[,=\s]+/g, "-").slice(0, 64)}`;
+var CLAUDE_CODE_HOOKS = (endpoint, key) => ({
+  StopFailure: [{ hooks: [{ type: "http", url: `${endpoint}/hooks/claude-code`, headers: { Authorization: `Bearer ${key}` } }] }],
+  SessionEnd: [{ hooks: [{ type: "http", url: `${endpoint}/hooks/claude-code`, headers: { Authorization: `Bearer ${key}` }, timeout: 10 }] }]
+});
+var CODEX_OTEL = (endpoint, key, person) => [
+  "[otel]",
+  "log_user_prompt = false",
+  `exporter = { otlp-http = { endpoint = "${endpoint}/v1/logs", protocol = "json", headers = { "Authorization" = "Bearer ${key}", "x-valistry-person" = "${person}" } } }`,
+  `metrics_exporter = { otlp-http = { endpoint = "${endpoint}/v1/metrics", protocol = "json", headers = { "Authorization" = "Bearer ${key}", "x-valistry-person" = "${person}" } } }`
+].join("\n");
+
+// packages/cli/src/claude.ts
+var ENDPOINT = "OTEL_EXPORTER_OTLP_ENDPOINT";
+var ATTRS = "OTEL_RESOURCE_ATTRIBUTES";
+var isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var OUR_ENV = [...CLAUDE_CODE_ENV("", "").map(([k]) => k), ATTRS];
+function parseSettings(text) {
+  if (text === null || !text.trim()) return {};
+  let v;
+  try {
+    v = JSON.parse(text);
+  } catch {
+    throw new Error("~/.claude/settings.json is not valid JSON. Fix it, then run this again. Nothing was changed.");
+  }
+  if (!isObj(v)) throw new Error("~/.claude/settings.json is not a JSON object. Fix it, then run this again. Nothing was changed.");
+  return v;
+}
+var printSettings = (o) => `${JSON.stringify(o, null, 2)}
+`;
+var ours = (h) => isObj(h) && h.type === "http" && typeof h.url === "string" && /\/hooks\/claude-code$/.test(h.url) && isObj(h.headers) && typeof h.headers.Authorization === "string" && /^Bearer vly_ot_/.test(h.headers.Authorization);
+function withoutOurHooks(hooks) {
+  if (!isObj(hooks)) return hooks === void 0 ? void 0 : hooks;
+  const out = {};
+  for (const [event, groups] of Object.entries(hooks)) {
+    if (!Array.isArray(groups)) {
+      out[event] = groups;
+      continue;
+    }
+    const kept = groups.map((g) => isObj(g) && Array.isArray(g.hooks) ? { ...g, hooks: g.hooks.filter((h) => !ours(h)) } : g).filter((g) => !(isObj(g) && Array.isArray(g.hooks) && g.hooks.length === 0));
+    if (kept.length) out[event] = kept;
+  }
+  return Object.keys(out).length ? out : void 0;
+}
+function withTeam(current, team) {
+  const rest = typeof current === "string" ? current.split(",").map((s) => s.trim()).filter((s) => s && !/^team\.id=/.test(s)) : [];
+  return [...rest, teamAttribute(team)].join(",");
+}
+function mergeClaude(text, o) {
+  const s = parseSettings(text);
+  const env = isObj(s.env) ? { ...s.env } : {};
+  const was = env[ENDPOINT];
+  if (typeof was === "string" && was && was !== o.endpoint && !o.force)
+    return { after: text ?? "", added: [], changed: [], hooks: [], conflict: `Claude Code already sends telemetry to ${was}. Add --force to send it to Valistry instead.` };
+  const added = [], changed = [];
+  const want = [...CLAUDE_CODE_ENV(o.endpoint, o.key).map(([k, v]) => [k, v]), ...o.team ? [[ATTRS, withTeam(env[ATTRS], o.team)]] : []];
+  for (const [k, v] of want) {
+    if (!(k in env)) added.push(k);
+    else if (env[k] !== v) changed.push(k);
+    env[k] = v;
+  }
+  const hooks = withoutOurHooks(s.hooks) ?? {};
+  const mine = CLAUDE_CODE_HOOKS(o.endpoint, o.key);
+  for (const [event, groups] of Object.entries(mine)) hooks[event] = [...Array.isArray(hooks[event]) ? hooks[event] : [], ...groups];
+  const after = printSettings({ ...s, env, hooks });
+  return { after, added, changed, hooks: Object.keys(mine) };
+}
+function unmergeClaude(text, backup) {
+  const s = parseSettings(text);
+  const b = (() => {
+    try {
+      return parseSettings(backup);
+    } catch {
+      return {};
+    }
+  })();
+  const before = isObj(b.env) ? b.env : {};
+  const env = isObj(s.env) ? { ...s.env } : {};
+  for (const k of OUR_ENV) {
+    if (k in before) env[k] = before[k];
+    else delete env[k];
+  }
+  const out = { ...s };
+  if (Object.keys(env).length) out.env = env;
+  else delete out.env;
+  const hadOurs = JSON.stringify(withoutOurHooks(b.hooks) ?? null) !== JSON.stringify(isObj(b.hooks) ? b.hooks : null);
+  const hooks = hadOurs ? s.hooks : withoutOurHooks(s.hooks);
+  if (hooks) out.hooks = hooks;
+  else delete out.hooks;
+  return printSettings(out);
+}
+function claudeConfigured(text, endpoint) {
+  try {
+    const env = parseSettings(text).env;
+    return isObj(env) && env.CLAUDE_CODE_ENABLE_TELEMETRY === "1" && typeof env[ENDPOINT] === "string" && (!endpoint || env[ENDPOINT] === endpoint);
+  } catch {
+    return false;
+  }
+}
+
+// packages/cli/src/codex.ts
+var BEGIN = "# Valistry telemetry, added by npx valistry. Remove it with: npx valistry remove --apply";
+var END = "# End of Valistry telemetry.";
+var lines = (t) => (t ?? "").split(/\r?\n/);
+function withoutOurs(text) {
+  const out = [];
+  let inside = false;
+  for (const l of lines(text)) {
+    if (l === BEGIN) {
+      inside = true;
+      continue;
+    }
+    if (inside) {
+      if (l === END) inside = false;
+      continue;
+    }
+    out.push(l);
+  }
+  return out;
+}
+var header = (l) => /^\s*\[\[?\s*([^\]]+?)\s*\]\]?\s*(#.*)?$/.exec(l)?.[1];
+var isOtel = (name) => name !== void 0 && (name === "otel" || name.startsWith("otel."));
+var otelLines = (ls) => ls.reduce((a, l) => {
+  const h = header(l);
+  if (h !== void 0) a.on = isOtel(h);
+  if (a.on) a.out.push(l);
+  return a;
+}, { on: false, out: [] }).out;
+var isValistrys = (ls) => ls.some((l) => /"Bearer vly_ot_/.test(l));
+var hasOtherOtel = (text) => {
+  const t = otelLines(withoutOurs(text));
+  return t.length > 0 && !isValistrys(t);
+};
+var hasOtel = (text) => otelLines(withoutOurs(text)).length > 0;
+function withoutOtel(ls) {
+  const out = [];
+  let skipping = false;
+  for (const l of ls) {
+    const h = header(l);
+    if (h !== void 0) skipping = isOtel(h);
+    if (!skipping) out.push(l);
+  }
+  return out;
+}
+var tidy = (ls) => {
+  const t = ls.join("\n").replace(/\n{3,}/g, "\n\n").replace(/\s+$/, "");
+  return t ? `${t}
+` : "";
+};
+function addCodex(text, o) {
+  if (hasOtherOtel(text) && !o.force) return { after: text ?? "", replaced: false, conflict: "Codex already has an [otel] table in ~/.codex/config.toml. Add --force to replace it with Valistry's." };
+  const other = hasOtel(text);
+  const base = other ? withoutOtel(withoutOurs(text)) : withoutOurs(text);
+  const head = tidy(base);
+  return { after: `${head}${head ? "\n" : ""}${BEGIN}
+${CODEX_OTEL(o.endpoint, o.key, o.person)}
+${END}
+`, replaced: other };
+}
+function removeCodex(text, backup) {
+  const kept = tidy(withoutOurs(text));
+  const theirs = otelLines(lines(backup));
+  if (!theirs.length || hasOtel(kept)) return kept;
+  return `${kept}${kept ? "\n" : ""}${tidy(theirs)}`;
+}
+var codexConfigured = (text) => lines(text).includes(BEGIN);
+
+// packages/cli/src/desktop.ts
+import { createHash } from "node:crypto";
+
+// packages/core/src/desktopUse.ts
+var DESKTOP_APPS = ["claude", "chatgpt", "copilot"];
+var DESKTOP_METRIC = "valistry.desktop.active_minutes";
+
+// packages/cli/src/desktop.ts
+var IDLE_SECONDS = 300;
+var SEND_EVERY_MS = 15 * 6e4;
+var KEEP_DAYS = 10;
+function appOfMac(bundle = "", name = "") {
+  const b = bundle.toLowerCase(), n = name.trim().toLowerCase();
+  if (b === "com.anthropic.claudefordesktop" || b.startsWith("com.anthropic.") && n === "claude") return "claude";
+  if (b === "com.openai.chat" || b.startsWith("com.openai.") && n === "chatgpt") return "chatgpt";
+  if (b.startsWith("com.microsoft.") && /copilot/.test(`${b} ${n}`)) return "copilot";
+  return null;
+}
+function appOfWindows(process2 = "") {
+  const p = process2.trim().toLowerCase().replace(/\.exe$/, "");
+  if (p === "claude") return "claude";
+  if (p === "chatgpt") return "chatgpt";
+  if (/^(microsoft\.)?(m365)?copilot(\.app)?$/.test(p)) return "copilot";
+  return null;
+}
+function activeApp(s, platform) {
+  const app = platform === "win32" ? appOfWindows(s.process) : appOfMac(s.bundle, s.name);
+  if (!app) return null;
+  return s.idleSeconds !== null && s.idleSeconds >= IDLE_SECONDS ? null : app;
+}
+var personCode = (email) => createHash("sha256").update(email.trim().toLowerCase()).digest("hex").slice(0, 16);
+var localDay = (d) => `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+var emptyState = () => ({ days: {}, sent: {} });
+function record(state, app, now) {
+  if (state.lastSample && now.getTime() - Date.parse(state.lastSample) < 45e3) return state;
+  const day = localDay(now);
+  const d = { ...state.days[day] ?? { watched: 0 } };
+  d.watched += 1;
+  if (app) d[app] = (d[app] ?? 0) + 1;
+  const keepFrom = localDay(new Date(now.getTime() - KEEP_DAYS * 864e5));
+  const days = Object.fromEntries(Object.entries({ ...state.days, [day]: d }).filter(([k]) => k >= keepFrom));
+  const sent = Object.fromEntries(Object.entries(state.sent).filter(([k]) => k >= keepFrom));
+  return { ...state, days, sent, lastSample: now.toISOString() };
+}
+function unsent(state) {
+  const out = [];
+  for (const [day, d] of Object.entries(state.days).sort(([a], [b]) => a.localeCompare(b))) {
+    if (!(d.watched > 0)) continue;
+    for (const app of DESKTOP_APPS) {
+      const minutes = d[app] ?? 0;
+      if (state.sent[day]?.[app] !== minutes) out.push({ day, app, minutes });
+    }
+  }
+  return out;
+}
+function sendDue(state, now) {
+  if (!state.lastTry) return true;
+  return localDay(new Date(state.lastTry)) !== localDay(now) || now.getTime() - Date.parse(state.lastTry) >= SEND_EVERY_MS;
+}
+function markSent(state, points) {
+  const sent = { ...state.sent };
+  for (const p of points) sent[p.day] = { ...sent[p.day] ?? {}, [p.app]: p.minutes };
+  return { ...state, sent };
+}
+var attr = (key, v) => ({ key, value: { stringValue: v } });
+var nano = (ms) => `${BigInt(Math.round(ms)) * 1000000n}`;
+var dayStart = (day) => {
+  const [y, m, d] = day.split("-").map(Number);
+  return new Date(y, m - 1, d).getTime();
+};
+function payload(points, who, now, version) {
+  return {
+    resourceMetrics: [{
+      resource: { attributes: [attr("service.name", "valistry-desktop"), attr("service.version", version)] },
+      scopeMetrics: [{ scope: { name: "valistry-desktop", version }, metrics: [{
+        name: DESKTOP_METRIC,
+        unit: "min",
+        sum: { aggregationTemporality: 2, isMonotonic: true, dataPoints: points.map((p) => ({
+          attributes: [attr("app", p.app), attr("day", p.day), attr("person", who.person), ...who.team ? [attr("team", who.team)] : []],
+          startTimeUnixNano: nano(dayStart(p.day)),
+          timeUnixNano: nano(Math.min(now.getTime(), dayStart(p.day) + 864e5 - 1)),
+          asInt: String(p.minutes)
+        })) }
+      }] }]
+    }]
+  };
+}
+
+// packages/cli/src/system.ts
+import { execFileSync } from "node:child_process";
+import { join } from "node:path";
+var run = (cmd2, args) => execFileSync(cmd2, args, { encoding: "utf8", timeout: 1e4, stdio: ["ignore", "pipe", "ignore"], windowsHide: true });
+function sampleMac(r = run) {
+  let bundle, name, idleSeconds = null;
+  try {
+    const asn = r("lsappinfo", ["front"]).trim();
+    if (/^ASN:/.test(asn)) {
+      const info = r("lsappinfo", ["info", "-only", "bundleid", "-only", "name", asn]);
+      bundle = /"CFBundleIdentifier"="([^"]*)"/.exec(info)?.[1];
+      name = /"LSDisplayName"="([^"]*)"/.exec(info)?.[1];
+    }
+  } catch {
+  }
+  try {
+    const ns = /"HIDIdleTime" = (\d+)/.exec(r("ioreg", ["-c", "IOHIDSystem", "-d", "4"]))?.[1];
+    if (ns) idleSeconds = Math.floor(Number(ns) / 1e9);
+  } catch {
+  }
+  return { bundle, name, idleSeconds };
+}
+var WINDOWS_PROBE = [
+  "Add-Type -TypeDefinition @'",
+  "using System; using System.Runtime.InteropServices;",
+  "public static class ValistryProbe {",
+  '  [DllImport("user32.dll")] public static extern IntPtr GetForegroundWindow();',
+  '  [DllImport("user32.dll")] public static extern uint GetWindowThreadProcessId(IntPtr h, out uint p);',
+  "  [StructLayout(LayoutKind.Sequential)] public struct LastInput { public uint cbSize; public uint dwTime; }",
+  '  [DllImport("user32.dll")] public static extern bool GetLastInputInfo(ref LastInput l);',
+  "}",
+  "'@",
+  "$p = 0; [void][ValistryProbe]::GetWindowThreadProcessId([ValistryProbe]::GetForegroundWindow(), [ref]$p)",
+  "$l = New-Object ValistryProbe+LastInput; $l.cbSize = 8; [void][ValistryProbe]::GetLastInputInfo([ref]$l)",
+  "$idle = [math]::Floor(([uint32][Environment]::TickCount - $l.dwTime) / 1000)",
+  "$n = (Get-Process -Id $p -ErrorAction SilentlyContinue).ProcessName",
+  'Write-Output "$n|$idle"'
+].join("\n");
+function sampleWindows(r = run) {
+  try {
+    const [process2, idle] = r("powershell.exe", ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", WINDOWS_PROBE]).trim().split("|");
+    const n = Number(idle);
+    return { process: process2, idleSeconds: Number.isFinite(n) && idle !== "" ? n : null };
+  } catch {
+    return { idleSeconds: null };
+  }
+}
+var LABEL = "ai.valistry.desktop";
+var TASK = "Valistry desktop";
+var xml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+function launchAgent(node, script, log) {
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${LABEL}</string>
+  <key>ProgramArguments</key>
+  <array><string>${xml(node)}</string><string>${xml(script)}</string><string>observe</string></array>
+  <key>StartInterval</key><integer>60</integer>
+  <key>RunAtLoad</key><true/>
+  <key>ProcessType</key><string>Background</string>
+  <key>LowPriorityIO</key><true/>
+  <key>StandardOutPath</key><string>${xml(log)}</string>
+  <key>StandardErrorPath</key><string>${xml(log)}</string>
+</dict>
+</plist>
+`;
+}
+var launchAgentPath = (home) => join(home, "Library", "LaunchAgents", `${LABEL}.plist`);
+var macStart = (uid, plist) => [["launchctl", ["bootstrap", `gui/${uid}`, plist]]];
+var macStop = (uid) => [["launchctl", ["bootout", `gui/${uid}/${LABEL}`]]];
+var windowsLauncher = (node, script) => `' Starts the Valistry desktop observer with no window. Written by npx valistry.\r
+CreateObject("WScript.Shell").Run """${node}"" ""${script}"" observe", 0, False\r
+`;
+var windowsStart = (vbs) => [["schtasks", ["/Create", "/F", "/SC", "MINUTE", "/MO", "1", "/TN", TASK, "/TR", `wscript.exe "${vbs}"`]]];
+var windowsStop = () => [["schtasks", ["/Delete", "/F", "/TN", TASK]]];
+
+// packages/cli/src/setup.ts
+var DEFAULT_ENDPOINT = "https://app.valistry.ai/api/otlp";
+var pathsOf = (home) => {
+  const dir = join2(home, ".valistry");
+  return {
+    home,
+    dir,
+    backups: join2(dir, "backups"),
+    manifest: join2(dir, "setup.json"),
+    config: join2(dir, "desktop.json"),
+    state: join2(dir, "desktop-state.json"),
+    script: join2(dir, "valistry.mjs"),
+    log: join2(dir, "desktop.log"),
+    vbs: join2(dir, "observer.vbs"),
+    plist: launchAgentPath(home),
+    claudeDir: join2(home, ".claude"),
+    claude: join2(home, ".claude", "settings.json"),
+    codexDir: join2(home, ".codex"),
+    codex: join2(home, ".codex", "config.toml")
+  };
+};
+var tilde = (p, home) => p.startsWith(home) ? `~${p.slice(home.length)}` : p;
+var sha = (t) => createHash2("sha256").update(t).digest("hex");
+var read = (p) => {
+  try {
+    return readFileSync(p, "utf8");
+  } catch {
+    return null;
+  }
+};
+var readJson = (p) => {
+  const t = read(p);
+  if (t === null) return null;
+  try {
+    return JSON.parse(t);
+  } catch {
+    return null;
+  }
+};
+function writeAtomic(p, text, mode) {
+  mkdirSync(dirname(p), { recursive: true });
+  const tmp = `${p}.valistry-${process.pid}`;
+  writeFileSync(tmp, text, mode ? { mode } : void 0);
+  renameSync(tmp, p);
+  if (mode) chmodSync(p, mode);
+}
+var KEY = /^vly_ot_.+_[0-9a-f]{32,}$/;
+var lastFour = (key) => `\u2022\u2022${key.slice(-4)}`;
+function foundKey(home) {
+  const p = pathsOf(home);
+  try {
+    const env = JSON.parse(read(p.claude) ?? "{}").env ?? {};
+    const k2 = /Bearer\s+(vly_ot_\S+)/.exec(String(env.OTEL_EXPORTER_OTLP_HEADERS ?? ""))?.[1];
+    const e = typeof env.OTEL_EXPORTER_OTLP_ENDPOINT === "string" ? env.OTEL_EXPORTER_OTLP_ENDPOINT.trim() : "";
+    if (k2 && KEY.test(k2)) return { key: k2, ...e ? { endpoint: e } : {}, from: "~/.claude/settings.json" };
+  } catch {
+  }
+  const t = read(p.codex) ?? "";
+  const k = /"Authorization"\s*=\s*"Bearer\s+(vly_ot_[^"\s]+)"/.exec(t)?.[1];
+  if (k && KEY.test(k)) {
+    const e = /endpoint\s*=\s*"([^"]+?)\/v1\/(?:logs|metrics|traces)"/.exec(t)?.[1];
+    return { key: k, ...e ? { endpoint: e } : {}, from: "~/.codex/config.toml" };
+  }
+  return null;
+}
+var cmd = ([c, args]) => ({ cmd: c, args });
+function setupPlan(o) {
+  const p = pathsOf(o.home);
+  const changes = [];
+  const notes = [];
+  const errors = [];
+  const found = o.key?.trim() ? null : foundKey(o.home);
+  const key = (o.key ?? found?.key ?? "").trim();
+  if (!key) errors.push("No key found. Make one in Valistry \u2192 Connect \u2192 Claude Code, then pass --key.");
+  else if (!KEY.test(key)) errors.push("That is not a Valistry ingest key. It starts with vly_ot_.");
+  const endpoint = (o.endpoint ?? found?.endpoint ?? DEFAULT_ENDPOINT).trim().replace(/\/+$/, "");
+  if (!/^https:\/\//.test(endpoint) && !/^http:\/\/(localhost|127\.0\.0\.1)(:\d+)?(\/|$)/.test(endpoint)) errors.push("The endpoint must start with https://.");
+  const using = found && !errors.length ? `Using the key already in ${found.from} (${lastFour(key)}), sending to ${endpoint}.` : void 0;
+  const email = (o.email ?? "").trim();
+  const team = o.team?.trim() || void 0;
+  if (errors.length) return { changes, notes, errors };
+  const prior = readJson(p.manifest);
+  if (o.claude !== false) {
+    if (!existsSync(p.claudeDir)) notes.push("Claude Code: not found on this computer (no ~/.claude). Skipped.");
+    else {
+      const before = read(p.claude);
+      try {
+        const m = mergeClaude(before, { endpoint, key, team, force: o.force });
+        if (m.conflict) errors.push(m.conflict);
+        else if (m.after === before) notes.push("Claude Code: already set up. No change.");
+        else changes.push({ kind: "write", path: p.claude, before, after: m.after, theirs: true, title: "Claude Code settings", lines: [
+          ...m.added.length ? [`Adds to "env": ${m.added.join(", ")}.`] : [],
+          ...m.changed.length ? [`Changes in "env": ${m.changed.join(", ")}.`] : [],
+          `Adds the ${m.hooks.join(" and ")} hooks. They send when a limit stops a turn and when a session ends.`,
+          "Keeps every other setting."
+        ] });
+      } catch (e) {
+        errors.push(e.message);
+      }
+    }
+  }
+  if (o.codex !== false) {
+    if (!existsSync(p.codexDir)) notes.push("Codex: not found on this computer (no ~/.codex). Skipped.");
+    else if (!email) notes.push("Codex: skipped. It needs your work email: add --email you@company.com.");
+    else {
+      const before = read(p.codex);
+      const a = addCodex(before, { endpoint, key, person: email, force: o.force });
+      if (a.conflict) errors.push(a.conflict);
+      else if (a.after === before) notes.push("Codex: already set up. No change.");
+      else changes.push({ kind: "write", path: p.codex, before, after: a.after, theirs: true, title: "Codex settings", lines: [
+        `${a.replaced ? "Replaces your [otel] table with" : "Adds"} an [otel] table at the end. Prompts stay off (log_user_prompt = false).`,
+        "Keeps every other line."
+      ] });
+    }
+  }
+  if (o.desktop) {
+    if (o.platform !== "darwin" && o.platform !== "win32") errors.push("The desktop observer runs on macOS and Windows only.");
+    else if (!email) errors.push("The desktop observer needs your work email, to count you as one person: add --email you@company.com.");
+    else {
+      const config = { endpoint, key, person: personCode(email), ...team ? { team } : {}, version: o.version };
+      const shown = `Each minute it checks which app is in front. It counts the Claude, ChatGPT and Microsoft Copilot apps.`;
+      changes.push({ kind: "write", path: p.script, before: read(p.script), after: read(o.self) ?? "", title: "The observer", lines: ["A copy of this command, so it runs after npx is gone."] });
+      changes.push({ kind: "write", path: p.config, before: read(p.config), after: `${JSON.stringify(config, null, 2)}
+`, secret: true, title: "Its settings", lines: [
+        `The address, your key, and your email as a code (${config.person}). Only you can read the file.`
+      ] });
+      if (o.platform === "darwin") {
+        const plist = launchAgent(o.node, p.script, p.log);
+        if (existsSync(p.plist)) changes.push({ kind: "run", ...cmd(macStop(o.uid)[0]), title: "Stops the observer that is running", mayFail: true });
+        changes.push({ kind: "write", path: p.plist, before: read(p.plist), after: plist, title: "A LaunchAgent", lines: [shown, "It starts again when you log in."] });
+        changes.push({ kind: "run", ...cmd(macStart(o.uid, p.plist)[0]), title: "Starts it now" });
+      } else {
+        changes.push({ kind: "write", path: p.vbs, before: read(p.vbs), after: windowsLauncher(o.node, p.script), title: "A launcher with no window", lines: [shown] });
+        changes.push({ kind: "run", ...cmd(windowsStart(p.vbs)[0]), title: "A Scheduled Task, each minute, as you" });
+      }
+    }
+  }
+  if (!changes.length && !errors.length && !notes.length) notes.push("Nothing to set up.");
+  return { changes, notes, errors, manifest: prior ?? void 0, key, endpoint, using };
+}
+var stamp = (d) => d.toISOString().replace(/[-:]/g, "").replace(/\.\d+Z$/, "Z");
+function applyPlan(plan, o) {
+  const p = pathsOf(o.home);
+  const done = [];
+  const prior = readJson(p.manifest);
+  const files = new Map((prior?.files ?? []).map((f) => [f.path, f]));
+  for (const c of plan.changes) {
+    if (c.kind === "write") {
+      const known = files.get(c.path);
+      let backup = known?.backup ?? null;
+      if (!known && c.theirs && c.before !== null) {
+        mkdirSync(p.backups, { recursive: true });
+        backup = join2(p.backups, `${basename(dirname(c.path)).replace(/^\./, "")}-${basename(c.path)}.${stamp(o.now)}`);
+        copyFileSync(c.path, backup);
+        done.push(`Saved a copy of ${tilde(c.path, o.home)} to ${tilde(backup, o.home)}.`);
+      }
+      writeAtomic(c.path, c.after, c.secret ? 384 : void 0);
+      files.set(c.path, { path: c.path, backup: known ? known.backup : backup, sha: sha(c.after), theirs: Boolean(c.theirs) });
+      done.push(`Wrote ${tilde(c.path, o.home)}.`);
+    } else if (c.kind === "delete") {
+      rmSync(c.path, { force: true });
+      done.push(`Removed ${tilde(c.path, o.home)}.`);
+    } else {
+      try {
+        o.run(c.cmd, c.args);
+        done.push(`Ran ${c.cmd} ${c.args.join(" ")}.`);
+      } catch (e) {
+        if (!c.mayFail) throw new Error(`${c.cmd} ${c.args.join(" ")} failed: ${e.message.split("\n")[0]}`);
+      }
+    }
+  }
+  const stop = o.stop ?? prior?.stop ?? [];
+  const manifest = { version: o.version, at: o.now.toISOString(), endpoint: o.endpoint, platform: o.platform, files: [...files.values()], stop };
+  writeAtomic(p.manifest, `${JSON.stringify(manifest, null, 2)}
+`);
+  return done;
+}
+var stopsFor = (plan, o) => plan.changes.some((c) => c.kind === "run" && !c.mayFail) ? o.platform === "darwin" ? macStop(o.uid) : windowsStop() : void 0;
+function removePlan(home) {
+  const p = pathsOf(home);
+  const m = readJson(p.manifest);
+  if (!m) return { changes: [], notes: ["Nothing to remove: this computer has no Valistry setup."], errors: [] };
+  const changes = [];
+  for (const [c, args] of m.stop) changes.push({ kind: "run", cmd: c, args, title: "Stops the observer", mayFail: true });
+  for (const f of m.files) {
+    const now = read(f.path);
+    if (!f.theirs) {
+      if (now !== null) changes.push({ kind: "delete", path: f.path, title: `Deletes ${basename(f.path)}`, lines: [] });
+      continue;
+    }
+    const backup = f.backup ? read(f.backup) : null;
+    const label = f.path.endsWith("config.toml") ? "Codex settings" : "Claude Code settings";
+    if (now === null) continue;
+    if (sha(now) === f.sha) {
+      if (f.backup === null) changes.push({ kind: "delete", path: f.path, title: label, lines: ["Deletes it: there was no file before setup."] });
+      else changes.push({ kind: "write", path: f.path, before: now, after: backup ?? now, title: label, lines: [`Puts back the copy from ${tilde(f.backup, home)}.`] });
+    } else {
+      const after = f.path.endsWith("config.toml") ? removeCodex(now, backup) : unmergeClaude(now, backup);
+      changes.push({ kind: "write", path: f.path, before: now, after, title: label, lines: ["It changed after setup, so only what setup added is taken out. Every other change is kept."] });
+    }
+  }
+  for (const extra of [p.state, p.log]) if (existsSync(extra)) changes.push({ kind: "delete", path: extra, title: `Deletes ${basename(extra)}`, lines: [] });
+  changes.push({ kind: "delete", path: p.manifest, title: "Deletes setup.json", lines: [] });
+  return { changes, notes: m.files.some((f) => f.backup) ? [`The copies stay in ${tilde(p.backups, home)}.`] : [], errors: [] };
+}
+var ago = (iso, now) => {
+  const m = Math.max(0, Math.round((now.getTime() - Date.parse(iso)) / 6e4));
+  return m < 1 ? "just now" : m < 120 ? `${m} min ago` : `${Math.round(m / 60)} hours ago`;
+};
+function status(home, now, running) {
+  const p = pathsOf(home);
+  const m = readJson(p.manifest);
+  const lines2 = [];
+  if (!m) return { lines: ["Not set up on this computer. Run: npx valistry setup --key <your key>"] };
+  lines2.push(`Set up ${m.at.slice(0, 16).replace("T", " ")} UTC, sending to ${m.endpoint}.`);
+  lines2.push(`Claude Code: ${claudeConfigured(read(p.claude), m.endpoint) ? "on" : m.files.some((f) => f.path === p.claude) ? "changed since setup: not sending here" : "not set up"}.`);
+  lines2.push(`Codex: ${codexConfigured(read(p.codex)) ? "on" : "not set up"}.`);
+  const config = readJson(p.config);
+  if (!config) lines2.push("Desktop apps: not set up. Add --desktop to count them.");
+  else {
+    const s = readJson(p.state) ?? emptyState();
+    lines2.push(`Desktop apps: ${running === false ? "set up, but the observer is not running" : "on"}. Your code: ${config.person}${config.team ? `, team ${config.team}` : ""}.`);
+    const today = Object.entries(s.days).sort(([a], [b]) => b.localeCompare(a))[0];
+    if (today) lines2.push(`${today[0]}: Claude ${today[1].claude ?? 0} min, ChatGPT ${today[1].chatgpt ?? 0} min, Copilot ${today[1].copilot ?? 0} min, of ${today[1].watched} min watched.`);
+    const l = s.lastSend;
+    lines2.push(!l ? "Last send: none yet. It sends within 15 minutes." : l.ok ? `Last send: ${ago(l.at, now)}, received.` : `Last send: ${ago(l.at, now)}, failed${l.status ? ` (${l.status})` : ""}${l.message ? `: ${l.message}` : ""}.`);
+  }
+  return { lines: lines2 };
+}
+
+// packages/cli/src/observe.ts
+async function observeOnce(o) {
+  const p = pathsOf(o.home);
+  const config = readJson(p.config);
+  if (!config) return null;
+  const s0 = readJson(p.state) ?? emptyState();
+  const sample = o.sample ?? (o.platform === "win32" ? () => sampleWindows() : () => sampleMac());
+  let s = record(s0, activeApp(sample(), o.platform), o.now);
+  if (o.force || sendDue(s, o.now)) s = await sendNow(s, config, o.now, o.send ?? fetch);
+  writeAtomic(p.state, `${JSON.stringify(s)}
+`);
+  return s;
+}
+async function sendNow(s, config, now, send) {
+  const points = unsent(s);
+  if (!points.length) return { ...s, lastTry: now.toISOString() };
+  const body = JSON.stringify(payload(points, { person: config.person, team: config.team }, now, config.version));
+  try {
+    const r = await send(`${config.endpoint}/v1/metrics`, { method: "POST", headers: { "content-type": "application/json", authorization: `Bearer ${config.key}` }, body });
+    const text = await r.text().catch(() => "");
+    const message = (() => {
+      try {
+        return String(JSON.parse(text)?.partialSuccess?.errorMessage ?? "").slice(0, 200);
+      } catch {
+        return "";
+      }
+    })();
+    const ok = r.status >= 200 && r.status < 300;
+    const next = ok ? markSent(s, points) : s;
+    return { ...next, lastTry: now.toISOString(), lastSend: { at: now.toISOString(), ok, status: r.status, ...message && !ok ? { message } : {} } };
+  } catch (e) {
+    return { ...s, lastTry: now.toISOString(), lastSend: { at: now.toISOString(), ok: false, message: `Could not reach ${config.endpoint}: ${e.message}`.slice(0, 200) } };
+  }
+}
+
+// packages/cli/src/main.ts
+var VERSION = true ? "0.1.0" : "0.0.0";
+var HELP = `valistry ${VERSION}: sets up this computer's AI tools to send their use to Valistry. Counts only.
+
+  npx valistry setup [--key <key>] [--email you@company.com] [--team <name>] [--desktop] [--apply]
+      Claude Code: adds the telemetry settings to ~/.claude/settings.json (a copy is saved first).
+      Codex: adds an [otel] table to ~/.codex/config.toml (a copy is saved first).
+      --desktop: counts the minutes the Claude, ChatGPT and Microsoft Copilot apps are in front (macOS, Windows).
+      Shows every change first. Add --apply to make them.
+      If Claude Code already sends to Valistry, you can leave out --key: its key and address are used.
+      Other options: --endpoint <url> (default ${DEFAULT_ENDPOINT}), --no-claude, --no-codex, --force.
+
+  npx valistry status            What is set up, and the last send.
+  npx valistry remove [--apply]  Undoes everything setup did, and puts your files back.
+
+Never read or sent: prompts, replies, code, window titles, screen contents, keys you type.`;
+function parseArgs(argv) {
+  const [cmd2 = "help", ...rest] = argv;
+  const flags = {};
+  for (let i = 0; i < rest.length; i++) {
+    const a = rest[i];
+    if (!a.startsWith("--")) continue;
+    const [name, inline] = a.slice(2).split(/=(.*)/s, 2);
+    if (inline !== void 0) flags[name] = inline;
+    else if (rest[i + 1] !== void 0 && !rest[i + 1].startsWith("--")) flags[name] = rest[++i];
+    else flags[name] = true;
+  }
+  return { cmd: cmd2, flags };
+}
+var str = (v) => typeof v === "string" ? v : void 0;
+var gitEmail = () => {
+  try {
+    return execFileSync2("git", ["config", "--global", "user.email"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5e3 }).trim() || void 0;
+  } catch {
+    return void 0;
+  }
+};
+var masked = (text, key) => key && key.length > 12 ? text.split(key).join(lastFour(key)) : text;
+function describe(plan, home, key) {
+  const out = [];
+  plan.changes.forEach((c, i) => {
+    const where = c.kind === "run" ? `runs: ${c.cmd} ${c.args.map((a) => tilde(a, home)).map((a) => /\s/.test(a) ? JSON.stringify(a) : a).join(" ")}` : tilde(c.path, home);
+    out.push(`${i + 1}. ${c.title}  ${where}`);
+    if (c.kind === "write" && c.theirs && c.before !== null) out.push("   A copy is saved first, in ~/.valistry/backups.");
+    for (const l of c.kind === "run" ? [] : c.lines) out.push(`   ${l}`);
+  });
+  for (const n of plan.notes) out.push(n);
+  return out.map((l) => masked(l, key));
+}
+var SENDS = [
+  "What is sent: from Claude Code and Codex, counts (tokens, sessions, lines, commits, errors); from the desktop apps, minutes per app per day.",
+  "Never read or sent: prompts, replies, code, window titles, screen contents, keys you type. Your email is sent only as a code."
+];
+async function main(argv, io = { log: console.log, err: console.error }) {
+  const { cmd: cmd2, flags } = parseArgs(argv);
+  const home = str(flags.home) ?? process.env.VALISTRY_HOME ?? homedir();
+  const platform = process.platform;
+  const uid = typeof process.getuid === "function" ? process.getuid() : 0;
+  const now = /* @__PURE__ */ new Date();
+  const apply = flags.apply === true;
+  if (cmd2 === "setup") {
+    const key = str(flags.key) ?? process.env.VALISTRY_INGEST_KEY;
+    const endpoint = str(flags.endpoint)?.replace(/\/+$/, "");
+    const plan = setupPlan({
+      key,
+      endpoint,
+      team: str(flags.team),
+      email: str(flags.email) ?? gitEmail(),
+      desktop: flags.desktop === true,
+      claude: flags["no-claude"] !== true,
+      codex: flags["no-codex"] !== true,
+      force: flags.force === true,
+      home,
+      platform,
+      node: process.execPath,
+      uid,
+      version: VERSION,
+      self: fileURLToPath(import.meta.url)
+    });
+    if (plan.errors.length) {
+      for (const e of plan.errors) io.err(masked(e, key));
+      io.err("Nothing was changed.");
+      return 1;
+    }
+    const say = () => {
+      if (plan.using) io.log(masked(plan.using, plan.key));
+    };
+    if (!plan.changes.length) {
+      say();
+      for (const l of describe(plan, home, plan.key)) io.log(l);
+      return 0;
+    }
+    if (!apply) {
+      io.log("Valistry setup, a dry run. Nothing has changed yet.\n");
+      if (plan.using) {
+        say();
+        io.log("");
+      }
+      for (const l of describe(plan, home, plan.key)) io.log(l);
+      io.log("");
+      for (const l of SENDS) io.log(l);
+      io.log("\nTo make these changes, run the same command with --apply.\nTo undo them later: npx valistry remove --apply");
+      return 0;
+    }
+    say();
+    try {
+      for (const l of applyPlan(plan, { home, run, now, version: VERSION, endpoint: plan.endpoint ?? DEFAULT_ENDPOINT, platform, stop: stopsFor(plan, { platform, uid }) })) io.log(masked(l, plan.key));
+    } catch (e) {
+      io.err(masked(e.message, plan.key));
+      io.err("Run npx valistry status to see what is set up.");
+      return 1;
+    }
+    io.log("\nDone. Start a new Claude Code or Codex session to begin sending.");
+    if (flags.desktop === true && platform === "darwin") io.log("The observer runs each minute. Check it with: npx valistry status");
+    return 0;
+  }
+  if (cmd2 === "remove") {
+    const plan = removePlan(home);
+    if (!plan.changes.length) {
+      for (const n of plan.notes) io.log(n);
+      return 0;
+    }
+    if (!apply) {
+      io.log("Valistry remove, a dry run. Nothing has changed yet.\n");
+      for (const l of describe(plan, home)) io.log(l);
+      io.log("\nTo undo the setup, run: npx valistry remove --apply");
+      return 0;
+    }
+    try {
+      for (const l of applyRemove(plan, home)) io.log(l);
+    } catch (e) {
+      io.err(e.message);
+      return 1;
+    }
+    for (const n of plan.notes) io.log(n);
+    io.log("Done. Start new Claude Code and Codex sessions to stop sending.");
+    return 0;
+  }
+  if (cmd2 === "status") {
+    for (const l of status(home, now, observerRunning(home, platform, uid)).lines) io.log(l);
+    return 0;
+  }
+  if (cmd2 === "observe") {
+    if (flags.print === true) {
+      const s = platform === "win32" ? sampleWindows() : sampleMac();
+      io.log(`In front: ${activeApp(s, platform) ?? "none of the three apps"}. Seconds since last input: ${s.idleSeconds ?? "unknown"}.`);
+      return 0;
+    }
+    try {
+      await observeOnce({ home, platform, now });
+    } catch (e) {
+      io.err(`valistry observe: ${e.message}`);
+    }
+    return 0;
+  }
+  if (cmd2 === "send") {
+    const p = pathsOf(home);
+    const config = readJson(p.config);
+    if (!config) {
+      io.err("The desktop observer is not set up.");
+      return 1;
+    }
+    const s = await sendNow(readJson(p.state) ?? emptyState(), config, now, fetch);
+    writeAtomic(p.state, `${JSON.stringify(s)}
+`);
+    io.log(s.lastSend ? s.lastSend.ok ? "Sent." : `Not sent${s.lastSend.status ? ` (${s.lastSend.status})` : ""}: ${s.lastSend.message ?? ""}` : "Nothing new to send.");
+    return s.lastSend && !s.lastSend.ok ? 1 : 0;
+  }
+  if (cmd2 === "version" || flags.version === true) {
+    io.log(VERSION);
+    return 0;
+  }
+  io.log(HELP);
+  return cmd2 === "help" || flags.help === true ? 0 : 1;
+}
+function applyRemove(plan, home, r = run) {
+  const done = [];
+  for (const c of plan.changes) {
+    if (c.kind === "run") {
+      try {
+        r(c.cmd, c.args);
+        done.push(`Ran ${c.cmd} ${c.args.join(" ")}.`);
+      } catch {
+      }
+    } else if (c.kind === "delete") {
+      rmSync2(c.path, { force: true });
+      done.push(`Removed ${tilde(c.path, home)}.`);
+    } else {
+      writeAtomic(c.path, c.after);
+      done.push(`Put back ${tilde(c.path, home)}.`);
+    }
+  }
+  return done;
+}
+function observerRunning(home, platform, uid) {
+  if (!existsSync2(pathsOf(home).config)) return void 0;
+  try {
+    if (platform === "darwin") {
+      run("launchctl", ["print", `gui/${uid}/${LABEL}`]);
+      return true;
+    }
+    if (platform === "win32") {
+      run("schtasks", ["/Query", "/TN", TASK]);
+      return true;
+    }
+  } catch {
+    return false;
+  }
+  return void 0;
+}
+
+// packages/cli/src/cli.ts
+main(process.argv.slice(2)).then((code) => process.exit(code), (e) => {
+  console.error(e instanceof Error ? e.message : String(e));
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,16 @@
 {
   "name": "valistry",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Sets up Claude Code, Codex and the Claude, ChatGPT and Copilot desktop apps to send their use to Valistry. Counts only: never prompts, replies, window titles, screen contents or keystrokes.",
+  "type": "module",
+  "bin": { "valistry": "bin/valistry.mjs" },
+  "files": ["bin", "README.md"],
+  "engines": { "node": ">=18" },
+  "license": "UNLICENSED",
+  "homepage": "https://valistry.ai",
+  "scripts": {
+    "build": "node build.mjs",
+    "test": "vitest run",
+    "prepack": "node build.mjs --check"
+  }
+}