@henryz2004/agency 1.0.0

package/README.md

@@ -0,0 +1,106 @@
+# 🏢 Agency
+
+A live pixel-art office sim of your Claude Code, Codex, and opencode workforce.
+
+You're a one-person startup — but your AI coding agents do the work of *many*.
+Agency reads your **real, local** Claude Code data (from `~/.claude/`),
+Codex data (from `~/.codex/`), and opencode data (from `~/.local/share/opencode/`) and visualizes it as a tiny
+retro office: every running session is a pixel worker at a desk (typing
+when busy, monitor glowing by model tier), and your token throughput gets
+translated into **manpower** — effective team size, engineer-years shipped, and
+the payroll you'd be paying humans to match it.
+
+Nothing leaves your machine — unless you explicitly opt into the [leaderboard](#leaderboard-opt-in). No dependencies.
+
+![Agency](docs/screenshot.png)
+
+## Run it
+
+```bash
+npx @henryz2004/agency
+# → opens http://localhost:4313 in your browser
+```
+
+That's it — no install, no build, no dependencies. (From a checkout, `node server.js`
+does the same.) Set a different port with `PORT=8080`, and `AGENCY_NO_OPEN=1` to skip
+auto-opening the browser. State (your roster + usage cache) lives in `~/.agency`.
+
+Leave it open on a second monitor and start some `claude`, `codex`, or
+`opencode` sessions — workers appear at desks within ~3 seconds, busy ones
+start typing, and uptimes tick live.
+
+## What it shows
+
+**The floor** — one desk per *running* session (Claude Code, Codex, or opencode), discovered from
+`~/.claude/sessions/<pid>.json` (validated against live PIDs), `~/.codex/process_manager/chat_processes.json` joined with `~/.codex/state_5.sqlite`, or the opencode SQLite database. Each agent gets:
+- a stable name + job title (Intern → Principal, keyed to its model tier),
+- a glowing monitor colored by model (Opus = gold, Sonnet = cyan, Haiku = green),
+- a "typing" animation while `busy`, and a live uptime counter.
+
+Co-located agents (same project) cluster together on a shared **team rug**
+labeled with the repo name, so you read the floor as teams, not a scattered grid.
+
+**Effective team size** — your recent daily output tokens divided by what one
+human engineer would produce. Drag the **Assumptions** sliders (tokens per
+engineer-hour, hours/day, days/year, salary) to re-rate everything instantly:
+- *engineer-years shipped* (lifetime output),
+- *payroll equivalent* (what the humans would cost),
+- *engineer-days today*.
+
+**Comparison** — a row of pixel people: you (gold) vs. the team you operate like.
+
+**Panels** — model mix by output, top "departments" (projects) by output, a
+30-day daily-output chart, and an all-time ledger (tokens, tool actions,
+subagents hired, sessions, active days).
+
+## Walk the floor
+
+Press **`g`** (or click the walk button) to drop in a controllable **player
+character**. Drive it with **WASD / arrows**; the camera follows you. Walk up to
+a desk and that agent's chat surfaces in the peek panel (it reuses the same
+selection event a click does), so you can wander the floor and read what each
+agent is doing. Press `g` again to return to free pan/zoom. A cat roams the
+lounge for company.
+
+## How it works
+
+Zero dependencies — just Node's `http` + `fs` and a vanilla-JS canvas frontend.
+
+| File | Role |
+|------|------|
+| `server.js` | HTTP server; single `/api/state` endpoint fusing live + usage |
+| `lib/live.js` | running sessions, uptime, status, per-session model |
+| `lib/usage.js` | parses `~/.claude/projects/**/*.jsonl` plus Codex/opencode usage, cached by mtime+size |
+| `lib/opencode.js` | reads opencode SQLite DB for live sessions + usage stats |
+| `lib/codex.js` | reads Codex local state for live sessions + usage stats |
+| `lib/roster.js` | stable name/title/palette per session (persisted) |
+| `public/office.js` | the pixel office: project desk clusters, team rugs, decor, camera, animation |
+| `public/sprites.js` | procedural pixel-art drawing (every glyph; no sprite sheet) |
+| `public/avatar.js` | the walkable user avatar + wandering cat (`g` to toggle, WASD/arrows) |
+| `public/app.js` | data polling, manpower math, panels, ticker |
+
+Usage stats are cached in `~/.agency/usage-cache.json` and `~/.agency/opencode-usage-cache.json`
+(only changed transcripts/DB state are re-parsed on refresh; the main cache now includes Claude, Codex, and opencode usage); agent identities persist in `~/.agency/roster.json`. Override the location with `AGENCY_DATA_DIR`.
+
+Codex live sessions come from `~/.codex/process_manager/chat_processes.json`
+and `~/.codex/state_5.sqlite`.
+
+> The manpower numbers are a deliberately fun heuristic, not a benchmark — they
+> exist to make a one-person shop *feel like more*. Tune the sliders to taste.
+
+## Leaderboard (opt-in)
+
+Agency ships with an **optional** public leaderboard that ranks installs by
+*standardized engineer-years* — the same eng-years figure as the personal card,
+but with the assumption sliders **frozen to fixed constants** so everyone's
+number is comparable (and not gameable by tuning your own dials).
+
+It is **off by default and opt-in**. Nothing is uploaded until you open the 🏆
+panel and click *Join*, and even then the only data sent is **a display name and
+your standardized eng-years number** — never your code, transcripts, repo names,
+or project names. *Stop sharing* deletes your row.
+
+The backend is a tiny Cloudflare Worker + D1 database under [`worker/`](worker/) —
+see [`worker/README.md`](worker/README.md) to deploy your own and point the
+dashboard at it (set `LEADERBOARD_API` in `public/leaderboard.js`). Until that
+URL is set, the leaderboard UI stays hidden and Agency runs exactly as before.

package/lib/codex.js

@@ -0,0 +1,211 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { execFileSync } from 'node:child_process';
+
+const HOME = os.homedir();
+const PROCESS_PATH = path.join(HOME, '.codex', 'process_manager', 'chat_processes.json');
+const DB_PATH = path.join(HOME, '.codex', 'state_5.sqlite');
+
+function isAlive(pid) {
+  if (!pid || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code === 'EPERM';
+  }
+}
+
+function dbExists() {
+  try {
+    fs.accessSync(DB_PATH);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function query(sql) {
+  if (!dbExists()) return [];
+  try {
+    const out = execFileSync('sqlite3', [DB_PATH, '-cmd', '.timeout 3000', '-json', sql], {
+      timeout: 4000,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    if (!out.trim()) return [];
+    return JSON.parse(out);
+  } catch {
+    return [];
+  }
+}
+
+function readJson(file, fallback) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return fallback;
+  }
+}
+
+function parseModel(raw) {
+  if (!raw) return { id: null, provider: null };
+  if (typeof raw === 'object') {
+    return {
+      id: raw.id || raw.name || null,
+      provider: raw.providerID || raw.provider || null,
+    };
+  }
+  const trimmed = String(raw).trim();
+  if (!trimmed) return { id: null, provider: null };
+  if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+    try {
+      return parseModel(JSON.parse(trimmed));
+    } catch {
+      return { id: trimmed, provider: null };
+    }
+  }
+  return { id: trimmed, provider: null };
+}
+
+function localDay(ts) {
+  const d = new Date(ts);
+  if (Number.isNaN(d.getTime())) return null;
+  return d.toLocaleDateString('en-CA');
+}
+
+function emptyDay() {
+  return { out: 0, in: 0, cr: 0, cc: 0, tools: 0, msgs: 0, agents: 0 };
+}
+
+function openSubagentCount(id) {
+  const rows = query(
+    `SELECT count(*) AS n FROM thread_spawn_edges ` +
+    `WHERE parent_thread_id = '${String(id).replace(/'/g, "''")}' AND status = 'open'`
+  );
+  return rows.length ? Number(rows[0].n || 0) : 0;
+}
+
+export function getCodexLive() {
+  const now = Date.now();
+  const processes = readJson(PROCESS_PATH, []);
+  const procById = new Map(
+    Array.isArray(processes)
+      ? processes.map((p) => [p.conversationId || null, p]).filter(([id]) => id)
+      : []
+  );
+
+  const cutoff = now - 30 * 60 * 1000;
+  const rows = query(
+    `SELECT id, title, preview, model, cwd, tokens_used, created_at_ms, updated_at_ms, model_provider, thread_source, agent_nickname, agent_role ` +
+    `FROM threads WHERE archived = 0 AND updated_at_ms > ${cutoff} ORDER BY updated_at_ms DESC`
+  );
+
+  const agents = rows
+    .map((thread) => {
+      const p = procById.get(thread.id) || {};
+      const pid = p.osPid || p.pid || null;
+      if (pid && !isAlive(pid)) return null;
+
+      const model = parseModel(thread.model);
+      const startedAt = thread.created_at_ms || p.startedAtMs || null;
+      const updatedAt = thread.updated_at_ms || p.updatedAtMs || startedAt || null;
+      const staleMs = updatedAt ? now - updatedAt : Number.POSITIVE_INFINITY;
+      const activity = staleMs <= 2 * 60 * 1000 ? 'working' : 'idle';
+      const cwd = thread.cwd || p.cwd || null;
+      const project = cwd ? path.basename(cwd) : 'unknown';
+      const subagents = openSubagentCount(thread.id);
+
+      return {
+        pid,
+        sessionId: thread.id,
+        source: 'codex',
+        cwd,
+        project,
+        kind: 'interactive',
+        activity,
+        status: activity === 'working' ? 'busy' : 'idle',
+        state: null,
+        needsYou: false,
+        task: thread.title || p.command || null,
+        chatName: thread.title || p.chatTitle || null,
+        lastPrompt: thread.preview || p.command || null,
+        subagents: Array.from({ length: subagents }, () => ({ type: 'agent' })),
+        startedAt,
+        uptimeMs: startedAt ? Math.max(0, now - startedAt) : null,
+        model: model.id || null,
+        modelSlug: typeof thread.model === 'string' ? thread.model : model.id || null,
+        provider: model.provider || thread.model_provider || null,
+        title: thread.agent_role || thread.agent_nickname || null,
+      };
+    })
+    .filter(Boolean)
+    .sort((a, b) => (b.uptimeMs || 0) - (a.uptimeMs || 0));
+
+  return { agents, now };
+}
+
+export function getCodexUsage() {
+  if (!dbExists()) return null;
+
+  const rows = query(
+    `SELECT id, cwd, title, preview, model, tokens_used, created_at_ms, updated_at_ms, ` +
+    `(SELECT count(*) FROM thread_spawn_edges e WHERE e.parent_thread_id = threads.id AND e.status = 'open') AS open_children ` +
+    `FROM threads ORDER BY updated_at_ms ASC`
+  );
+
+  const lifetime = { out: 0, in: 0, cr: 0, cc: 0, tools: 0, msgs: 0, agents: 0, sessions: 0 };
+  const dayMap = {};
+  const byModel = {};
+  const byProject = {};
+
+  for (const row of rows) {
+    const out = Number(row.tokens_used || 0);
+    const startedAt = row.created_at_ms || row.updated_at_ms || null;
+    const day = startedAt ? localDay(startedAt) : null;
+    const model = parseModel(row.model).id || 'unknown';
+    const project = row.cwd ? path.basename(row.cwd) : 'unknown';
+    const agents = Number(row.open_children || 0);
+
+    lifetime.out += out;
+    lifetime.msgs += 1;
+    lifetime.agents += agents;
+    lifetime.sessions += 1;
+
+    if (day) {
+      const d = (dayMap[day] ||= emptyDay());
+      d.out += out;
+      d.msgs += 1;
+      d.agents += agents;
+    }
+
+    if (!byModel[model]) byModel[model] = { out: 0, in: 0, msgs: 0 };
+    byModel[model].out += out;
+    byModel[model].msgs += 1;
+
+    const p = (byProject[project] ||= { out: 0, msgs: 0, tools: 0, agents: 0, sessions: 0, lastTs: null });
+    p.out += out;
+    p.msgs += 1;
+    p.agents += agents;
+    p.sessions += 1;
+    if (row.updated_at_ms && (!p.lastTs || row.updated_at_ms > p.lastTs)) p.lastTs = row.updated_at_ms;
+  }
+
+  const daily = Object.entries(dayMap)
+    .map(([date, v]) => ({ date, ...v }))
+    .sort((a, b) => (a.date < b.date ? -1 : 1));
+
+  const today = new Date().toLocaleDateString('en-CA');
+  const todayStats = dayMap[today] ? { date: today, ...dayMap[today] } : { date: today, ...emptyDay() };
+
+  return {
+    lifetime,
+    today: todayStats,
+    daily,
+    byModel,
+    byProject,
+    firstDay: daily.length ? daily[0].date : null,
+    activeDays: daily.length,
+  };
+}

package/lib/control.js

@@ -0,0 +1,168 @@
+// control.js — in-memory registry of Claude Code agents paused on a Stop hook,
+// waiting for a typed reply from the dashboard.
+//
+// THE MECHANISM: a Claude Code Stop hook of type "http" BLOCKS the agent until
+// our server responds, and FAILS OPEN (timeout / refused / non-2xx → the agent
+// just stops normally). server.js holds that connection open and registers the
+// pending request here, keyed by session_id. When the user types a reply in the
+// chat panel (POST /api/reply), we resolve(sessionId, text) → server sends the
+// decision:"block" JSON that resumes the agent with the user's instruction. If
+// no reply arrives before the soft deadline, we resolve with null → server
+// sends an empty 200 and the agent stops normally (staying under the 120s hook
+// timeout). This module owns ONLY in-memory state — no persistence, no fs writes
+// (the app's read-only charter: the hook endpoint is a control surface, like
+// /api/resume, not a writer of ~/.claude data).
+
+// sessionId -> { cwd, transcriptPath, since, timer, settle }
+const pending = new Map();
+
+// Soft deadline: resolve the held connection with null (→ empty 200, agent
+// stops) before the hook's own timeout fires. The default Stop hook timeout we
+// install is 120s; 110s leaves headroom so WE decide the outcome, not the CLI.
+export const DEADLINE_MS = 110_000;
+
+// Register a paused agent. `settle(text)` is the server's resolver for the held
+// response: settle(string) resumes the agent with that instruction; settle(null)
+// lets it stop. A second register() for the same session supersedes the first
+// (settles the old one as a timeout) — the latest Stop is the live one.
+export function register(sessionId, { cwd, transcriptPath, settle }, deadlineMs = DEADLINE_MS) {
+  if (!sessionId || typeof settle !== 'function') return;
+  // Supersede any existing entry for this session.
+  const prior = pending.get(sessionId);
+  if (prior) {
+    clearTimeout(prior.timer);
+    pending.delete(sessionId);
+    try {
+      prior.settle(null); // let the stale hold stop normally
+    } catch {
+      /* ignore */
+    }
+  }
+  const entry = {
+    cwd: cwd || null,
+    transcriptPath: transcriptPath || null,
+    since: Date.now(),
+    settle,
+    timer: null,
+  };
+  entry.timer = setTimeout(() => {
+    // Deadline hit with no reply: drop the entry and let the agent stop.
+    if (pending.get(sessionId) === entry) pending.delete(sessionId);
+    try {
+      settle(null);
+    } catch {
+      /* ignore */
+    }
+  }, deadlineMs);
+  // Let the process exit even if a hold is outstanding (don't keep Node alive).
+  if (entry.timer.unref) entry.timer.unref();
+  pending.set(sessionId, entry);
+}
+
+// Resolve a pending request with the user's reply text. `entry.settle` returns
+// true only if it actually delivered (the held socket was still open); a hold
+// whose client already hung up returns false, so a late reply is reported as
+// "not delivered" rather than a false success. Returns true iff the reply was
+// delivered to a live hold.
+export function resolve(sessionId, text) {
+  const entry = pending.get(sessionId);
+  if (!entry) return false;
+  clearTimeout(entry.timer);
+  pending.delete(sessionId);
+  try {
+    return entry.settle(String(text == null ? '' : text)) === true;
+  } catch {
+    return false;
+  }
+}
+
+// Drop a pending entry without resuming the agent — used when the held hook
+// connection closes (agent killed / its hook timed out). Entry-scoped: only
+// removes the entry if `settle` still matches the current one, so a stale
+// connection closing after it was superseded can't delete the new hold.
+export function cancel(sessionId, settle) {
+  const entry = pending.get(sessionId);
+  if (!entry || (settle && entry.settle !== settle)) return false;
+  clearTimeout(entry.timer);
+  pending.delete(sessionId);
+  return true;
+}
+
+// Snapshot of who is currently waiting, for buildState() to fold into the live
+// agents (awaitingReply / pendingSince). Returns a Map-like plain object keyed
+// by sessionId so the caller can look up by agent id.
+export function list() {
+  const out = {};
+  for (const [sessionId, e] of pending) {
+    out[sessionId] = { cwd: e.cwd, transcriptPath: e.transcriptPath, since: e.since };
+  }
+  return out;
+}
+
+// Is a given session currently paused & waiting? (cheap point lookup)
+export function isPending(sessionId) {
+  return pending.has(sessionId);
+}
+
+// ---- self-check (node lib/control.js) -------------------------------------
+// Tiny asserts exercising register→resolve (correct decision text) and the
+// deadline path. No framework — just throws on failure, prints OK on success.
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const assert = (cond, msg) => {
+    if (!cond) throw new Error('control self-check FAILED: ' + msg);
+  };
+
+  // A live-hold stub: records the text it was settled with and returns true
+  // (mimics server.js settle writing to an open socket).
+  const liveHold = (sink) => (t) => { sink.text = t; return true; };
+
+  // 1) register → resolve returns true and delivers the user's text.
+  const a = {};
+  register('sess-A', { cwd: '/tmp', transcriptPath: '/t.jsonl', settle: liveHold(a) });
+  assert(isPending('sess-A'), 'sess-A should be pending after register');
+  assert(list()['sess-A'], 'list() should include sess-A');
+  const hit = resolve('sess-A', 'please run the tests');
+  assert(hit === true, 'resolve should return true for a delivered reply');
+  assert(a.text === 'please run the tests', 'settle should receive the reply text, got: ' + a.text);
+  assert(!isPending('sess-A'), 'sess-A should be cleared after resolve');
+
+  // 2) resolve with no pending entry returns false.
+  assert(resolve('nope', 'x') === false, 'resolve of unknown session should be false');
+
+  // 3) a dead hold (settle returns false) makes resolve report not-delivered.
+  register('sess-D', { cwd: '/tmp', settle: () => false });
+  assert(resolve('sess-D', 'late') === false, 'resolve of a dead hold should be false');
+
+  // 4) cancel drops the entry (entry-scoped) without resuming.
+  const c = {};
+  const cSettle = liveHold(c);
+  register('sess-E', { cwd: '/tmp', settle: cSettle });
+  assert(cancel('sess-E', cSettle) === true, 'cancel should drop the matching entry');
+  assert(!isPending('sess-E'), 'sess-E should be gone after cancel');
+  // cancel with a non-matching settle must NOT delete a re-registered entry.
+  const e2 = {};
+  register('sess-E', { cwd: '/tmp', settle: liveHold(e2) });
+  assert(cancel('sess-E', cSettle) === false, 'stale cancel must not drop a superseding hold');
+  assert(isPending('sess-E'), 'superseding hold should survive a stale cancel');
+  resolve('sess-E', 'ok'); // tidy up
+
+  // 5) deadline path: a short deadline settles with null and clears the entry.
+  const b = { text: 'unset' };
+  register('sess-B', { cwd: '/tmp', settle: (t) => { b.text = t; return true; } }, 20);
+  setTimeout(() => {
+    assert(b.text === null, 'deadline should settle with null, got: ' + b.text);
+    assert(!isPending('sess-B'), 'sess-B should be cleared after deadline');
+
+    // 6) superseding: a second register settles the first as a timeout (null)
+    //    and the new one resolves with text.
+    const f = { text: 'unset' }, s = { text: 'unset' };
+    register('sess-C', { cwd: '/tmp', settle: (t) => { f.text = t; return true; } });
+    register('sess-C', { cwd: '/tmp', settle: liveHold(s) });
+    assert(f.text === null, 'superseded hold should settle with null, got: ' + f.text);
+    resolve('sess-C', 'go');
+    assert(s.text === 'go', 'new hold should resolve with text, got: ' + s.text);
+
+    console.log('control.js self-check OK');
+    process.exit(0);
+  }, 60);
+}