@ugurcandede/cc-cost 0.1.0

package/dist/setup.js

@@ -0,0 +1,226 @@
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { claudeDirs } from "./paths.js";
+const HOME = os.homedir();
+export const SCHEDULE_TIME = '10:23';
+const [HOUR, MINUTE] = SCHEDULE_TIME.split(':').map(Number);
+// Overridable so tests never touch a real task of the same name
+const TASK = process.env.CC_COST_TASK || 'cc-cost';
+const LAUNCHD_LABEL = 'com.cc-cost.sync';
+export const currentRunner = () => ({ node: process.execPath, script: fs.realpathSync(process.argv[1]) });
+// npx, yarn dlx and pnpm dlx run from temporary or cache folders that get cleaned; a scheduled path
+// there would break silently.
+export const isEphemeral = (r) => /[\\/](_npx|dlx(-\d+)?)[\\/]/.test(r.script);
+// ---------- shared folder
+function exists(p) {
+    try {
+        return fs.statSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+// Sync-service folders on this machine, most likely first
+export function syncFolders() {
+    const found = [];
+    // Dropbox records its folders (personal and business) in info.json
+    const dropboxInfo = [
+        path.join(process.env.LOCALAPPDATA ?? '', 'Dropbox', 'info.json'),
+        path.join(process.env.APPDATA ?? '', 'Dropbox', 'info.json'),
+        path.join(HOME, '.dropbox', 'info.json'),
+    ];
+    for (const f of dropboxInfo) {
+        try {
+            for (const v of Object.values(JSON.parse(fs.readFileSync(f, 'utf8'))))
+                if (v?.path)
+                    found.push(v.path);
+        }
+        catch {
+            // no Dropbox, or not at this location
+        }
+    }
+    found.push(path.join(HOME, 'Dropbox'));
+    for (const v of [process.env.OneDrive, process.env.OneDriveConsumer, process.env.OneDriveCommercial])
+        if (v)
+            found.push(v);
+    found.push(path.join(HOME, 'OneDrive'));
+    if (process.platform === 'darwin') {
+        found.push(path.join(HOME, 'Library', 'Mobile Documents', 'com~apple~CloudDocs'));
+        try {
+            for (const e of fs.readdirSync(path.join(HOME, 'Library', 'CloudStorage')))
+                found.push(path.join(HOME, 'Library', 'CloudStorage', e, e.startsWith('GoogleDrive-') ? 'My Drive' : ''));
+        }
+        catch {
+            // no File Provider mounts
+        }
+    }
+    if (process.platform === 'win32')
+        found.push(path.join(HOME, 'iCloudDrive'), 'G:\\My Drive');
+    found.push(path.join(HOME, 'Google Drive'));
+    return [...new Set(found.map((p) => path.resolve(p)))].filter(exists);
+}
+// Where to keep the data inside a sync folder: reuse an existing cc-cost folder (including one
+// made by the original script, "claude-cost"), otherwise a new "cc-cost" folder.
+export function dataFolderIn(root) {
+    for (const name of ['cc-cost', 'claude-cost'])
+        if (exists(path.join(root, name)))
+            return path.join(root, name);
+    return path.join(root, 'cc-cost');
+}
+// ---------- scheduler
+const psQuote = (s) => `'${s.replace(/'/g, "''")}'`;
+const xml = (s) => s.replace(/[&<>"']/g, (c) => `&#${c.charCodeAt(0)};`);
+const run = (cmd, args) => spawnSync(cmd, args, { encoding: 'utf8' });
+const powershell = (script) => run('powershell.exe', ['-NoProfile', '-NonInteractive', '-EncodedCommand', Buffer.from(script, 'utf16le').toString('base64')]);
+const launchdPlist = () => path.join(HOME, 'Library', 'LaunchAgents', `${LAUNCHD_LABEL}.plist`);
+const systemdDir = () => path.join(process.env.XDG_CONFIG_HOME || path.join(HOME, '.config'), 'systemd', 'user');
+export function plistFor(r) {
+    const args = [r.node, r.script, 'sync', '--quiet'].map((a) => `    <string>${xml(a)}</string>`).join('\n');
+    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>${LAUNCHD_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+${args}
+  </array>
+  <key>StartCalendarInterval</key>
+  <dict>
+    <key>Hour</key>
+    <integer>${HOUR}</integer>
+    <key>Minute</key>
+    <integer>${MINUTE}</integer>
+  </dict>
+</dict>
+</plist>
+`;
+}
+export function systemdUnits(r) {
+    return {
+        service: `[Unit]\nDescription=cc-cost sync\n\n[Service]\nType=oneshot\nExecStart="${r.node}" "${r.script}" sync --quiet\n`,
+        // Persistent: a run missed while the machine was off happens at the next boot
+        timer: `[Unit]\nDescription=Daily cc-cost sync\n\n[Timer]\nOnCalendar=*-*-* ${SCHEDULE_TIME}:00\nPersistent=true\n\n[Install]\nWantedBy=timers.target\n`,
+    };
+}
+// PowerShell that registers the Windows task. The task starts a hidden PowerShell that runs node,
+// so no console window flashes; StartWhenAvailable catches up on a run missed while powered off.
+export function windowsTaskScript(r) {
+    const argument = `-NoProfile -WindowStyle Hidden -Command "& ${psQuote(r.node)} ${psQuote(r.script)} sync --quiet"`;
+    return [
+        `$a = New-ScheduledTaskAction -Execute 'powershell.exe' -Argument ${psQuote(argument)}`,
+        `$t = New-ScheduledTaskTrigger -Daily -At '${SCHEDULE_TIME}'`,
+        '$s = New-ScheduledTaskSettingsSet -StartWhenAvailable -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -ExecutionTimeLimit (New-TimeSpan -Minutes 15)',
+        `Register-ScheduledTask -TaskName ${psQuote(TASK)} -Action $a -Trigger $t -Settings $s -Description 'cc-cost daily sync' -Force | Out-Null`,
+    ].join('\n');
+}
+export function installSchedule(r) {
+    if (process.platform === 'win32') {
+        const res = powershell(windowsTaskScript(r));
+        return res.status === 0 ? { ok: true, what: `Task Scheduler "${TASK}", ${SCHEDULE_TIME}` } : { ok: false, what: (res.stderr || res.stdout || '').trim() };
+    }
+    if (process.platform === 'darwin') {
+        const plist = launchdPlist();
+        fs.mkdirSync(path.dirname(plist), { recursive: true });
+        fs.writeFileSync(plist, plistFor(r));
+        const domain = `gui/${process.getuid()}`;
+        run('launchctl', ['bootout', `${domain}/${LAUNCHD_LABEL}`]); // not loaded yet is fine
+        const res = run('launchctl', ['bootstrap', domain, plist]);
+        if (res.status === 0)
+            return { ok: true, what: `${plist}, ${SCHEDULE_TIME}` };
+        fs.rmSync(plist, { force: true }); // a plist left behind would read as installed
+        return { ok: false, what: (res.stderr || '').trim() };
+    }
+    const units = systemdUnits(r), dir = systemdDir();
+    if (run('systemctl', ['--user', '--version']).status !== 0)
+        return { ok: false, what: 'systemctl --user is not available' };
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, 'cc-cost.service'), units.service);
+    fs.writeFileSync(path.join(dir, 'cc-cost.timer'), units.timer);
+    run('systemctl', ['--user', 'daemon-reload']);
+    const res = run('systemctl', ['--user', 'enable', '--now', 'cc-cost.timer']);
+    if (res.status === 0)
+        return { ok: true, what: `${path.join(dir, 'cc-cost.timer')}, ${SCHEDULE_TIME}` };
+    // e.g. no user session bus; unit files left behind would read as installed
+    for (const f of ['cc-cost.timer', 'cc-cost.service'])
+        fs.rmSync(path.join(dir, f), { force: true });
+    return { ok: false, what: (res.stderr || '').trim() };
+}
+export function scheduleInstalled() {
+    if (process.platform === 'win32')
+        return run('schtasks', ['/Query', '/TN', TASK]).status === 0;
+    if (process.platform === 'darwin')
+        return fs.existsSync(launchdPlist());
+    return fs.existsSync(path.join(systemdDir(), 'cc-cost.timer'));
+}
+export function removeSchedule() {
+    if (!scheduleInstalled())
+        return undefined;
+    if (process.platform === 'win32') {
+        run('schtasks', ['/Delete', '/TN', TASK, '/F']);
+        return `Task Scheduler "${TASK}"`;
+    }
+    if (process.platform === 'darwin') {
+        run('launchctl', ['bootout', `gui/${process.getuid()}/${LAUNCHD_LABEL}`]);
+        fs.rmSync(launchdPlist(), { force: true });
+        return launchdPlist();
+    }
+    run('systemctl', ['--user', 'disable', '--now', 'cc-cost.timer']);
+    for (const f of ['cc-cost.timer', 'cc-cost.service'])
+        fs.rmSync(path.join(systemdDir(), f), { force: true });
+    run('systemctl', ['--user', 'daemon-reload']);
+    return path.join(systemdDir(), 'cc-cost.timer');
+}
+export const claudeSettingsFile = () => path.join(claudeDirs()[0] ?? process.env.CLAUDE_CONFIG_DIR?.split(',')[0] ?? path.join(HOME, '.claude'), 'settings.json');
+// Forward slashes work in every shell Claude Code may run hooks with, Git Bash included.
+export const hookCommand = (r) => [r.node, r.script].map((p) => `"${p.replace(/\\/g, '/')}"`).join(' ') + ' sync --quiet';
+const isOurs = (h) => /cc-cost/.test(h.command ?? '') && /\bsync --quiet\b/.test(h.command ?? '');
+function readSettings(file) {
+    return fs.existsSync(file) ? JSON.parse(fs.readFileSync(file, 'utf8')) : {};
+}
+function writeSettings(file, s) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    // one-time copy of the user's file before we first change it
+    if (fs.existsSync(file) && !fs.existsSync(file + '.cc-cost.bak'))
+        fs.copyFileSync(file, file + '.cc-cost.bak');
+    fs.writeFileSync(file, JSON.stringify(s, null, 2) + '\n');
+}
+export function hookInstalled(file = claudeSettingsFile()) {
+    return (readSettings(file).hooks?.SessionEnd ?? []).some((e) => e.hooks?.some(isOurs));
+}
+// Adds the SessionEnd hook, or updates its command if cc-cost moved. Returns false if it was already current.
+export function installHook(r, file = claudeSettingsFile()) {
+    const s = readSettings(file);
+    const entries = ((s.hooks ??= {}).SessionEnd ??= []);
+    const command = hookCommand(r);
+    const ours = entries.flatMap((e) => e.hooks ?? []).find(isOurs);
+    if (ours?.command === command)
+        return false;
+    if (ours)
+        ours.command = command;
+    // Synchronous with a short timeout: a sync takes about a second, and a background hook
+    // may be killed when Claude Code exits.
+    else
+        entries.push({ hooks: [{ type: 'command', command, timeout: 60 }] });
+    writeSettings(file, s);
+    return true;
+}
+export function removeHook(file = claudeSettingsFile()) {
+    if (!hookInstalled(file))
+        return false;
+    const s = readSettings(file);
+    const kept = (s.hooks.SessionEnd ?? [])
+        .map((e) => ({ ...e, hooks: e.hooks?.filter((h) => !isOurs(h)) }))
+        .filter((e) => e.hooks?.length);
+    if (kept.length)
+        s.hooks.SessionEnd = kept;
+    else
+        delete s.hooks.SessionEnd;
+    if (!Object.keys(s.hooks).length)
+        delete s.hooks;
+    writeSettings(file, s);
+    return true;
+}

package/dist/snapshot.js

@@ -0,0 +1,97 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { localClock } from "./scan.js";
+import { T_LEN, UNKNOWN } from "./types.js";
+// One file per machine: each machine only writes its own, so a sync service never sees two
+// writers on the same file and can't produce conflicted copies.
+export const machinesDir = (syncDir) => path.join(syncDir, 'machines');
+const fileFor = (syncDir, machine) => path.join(machinesDir(syncDir), `${machine}.json`);
+export const emptySnapshot = (machine, timezone) => ({
+    schema: 2, machine, updated: '', timezone, rows: [], hourly: [], sessions: {}, limits: [],
+});
+const isLegacy = (v) => typeof v === 'object' && v !== null && !('schema' in v) && typeof v.days === 'object';
+export function fromLegacy(v1, machine) {
+    const snap = emptySnapshot(v1.host ?? machine, UNKNOWN);
+    snap.updated = v1.updated ?? '';
+    for (const [d, models] of Object.entries(v1.days))
+        for (const [key, t] of Object.entries(models)) {
+            const fast = key.endsWith('-fast');
+            const counters = [...t.slice(0, 6), ...new Array(T_LEN - 6).fill(0)];
+            snap.rows.push({ d, p: UNKNOWN, s: UNKNOWN, m: fast ? key.slice(0, -5) : key, ...(fast && { f: 1 }), t: counters });
+        }
+    return snap;
+}
+function readJson(file) {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+}
+// All machines in the sync folder. Legacy files count only for machines not yet on schema 2.
+export function loadAll(syncDir) {
+    const byMachine = new Map();
+    if (fs.existsSync(machinesDir(syncDir)))
+        for (const f of fs.readdirSync(machinesDir(syncDir)).filter((f) => f.endsWith('.json'))) {
+            const snap = readJson(path.join(machinesDir(syncDir), f));
+            if (snap.schema === 2)
+                byMachine.set(snap.machine, snap);
+        }
+    if (fs.existsSync(syncDir))
+        for (const f of fs.readdirSync(syncDir).filter((f) => f.endsWith('.json'))) {
+            const v = readJson(path.join(syncDir, f));
+            if (!isLegacy(v))
+                continue;
+            const snap = fromLegacy(v, f.replace(/\.json$/, ''));
+            if (!byMachine.has(snap.machine))
+                byMachine.set(snap.machine, snap);
+        }
+    return [...byMachine.values()];
+}
+export function loadOwn(syncDir, machine, timezone) {
+    const file = fileFor(syncDir, machine);
+    if (fs.existsSync(file))
+        return readJson(file);
+    const legacy = path.join(syncDir, `${machine}.json`);
+    if (fs.existsSync(legacy)) {
+        const v = readJson(legacy);
+        if (isLegacy(v))
+            return fromLegacy(v, machine);
+    }
+    return emptySnapshot(machine, timezone);
+}
+// A scanned day replaces the stored one only when all of its transcripts must still be on disk,
+// i.e. it is newer than `safeFrom`. Older scanned days can be partial (short sessions of that day
+// already cleaned up, a long session reaching into it still there), so they only fill gaps.
+export function merge(prev, scan, safeFrom, meta) {
+    const stored = new Set(prev.rows.map((r) => r.d));
+    const take = new Set([...scan.rows, ...scan.hourly].map((r) => r.d).filter((d) => d >= safeFrom || !stored.has(d)));
+    const sessions = { ...prev.sessions };
+    for (const [id, s] of Object.entries(scan.sessions)) {
+        const old = sessions[id];
+        sessions[id] = old ? { p: s.p, first: s.first < old.first ? s.first : old.first, last: s.last > old.last ? s.last : old.last } : s;
+    }
+    const limits = new Map();
+    // Like rows, a replaced day's limit events come from the scan only.
+    const day = localClock(meta.timezone);
+    for (const l of [...prev.limits.filter((x) => !take.has(day(x.ts).d)), ...scan.limits]) {
+        const key = `${l.type}|${l.status}|${l.resetsAt ?? l.ts}`;
+        const seen = limits.get(key);
+        if (!seen || l.ts < seen.ts)
+            limits.set(key, l);
+    }
+    return {
+        schema: 2,
+        machine: meta.machine,
+        updated: new Date().toISOString(),
+        timezone: meta.timezone,
+        rows: [...prev.rows.filter((r) => !take.has(r.d)), ...scan.rows.filter((r) => take.has(r.d))],
+        hourly: [...prev.hourly.filter((r) => !take.has(r.d)), ...scan.hourly.filter((r) => take.has(r.d))],
+        sessions,
+        limits: [...limits.values()].sort((a, b) => a.ts.localeCompare(b.ts)),
+    };
+}
+export function save(syncDir, snap) {
+    const file = fileFor(syncDir, snap.machine);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    // write-then-rename so the sync client never uploads a half-written file
+    fs.writeFileSync(file + '.tmp', JSON.stringify(snap));
+    fs.renameSync(file + '.tmp', file);
+    return file;
+}

package/dist/sync.js

@@ -0,0 +1,17 @@
+import path from 'node:path';
+import { claudeDirs, retentionDays } from "./paths.js";
+import { localClock, scan } from "./scan.js";
+import { loadOwn, merge, save } from "./snapshot.js";
+export const dashboardPath = (s) => path.join(s.syncDir, 'dashboard.html');
+// Scan this machine's transcripts into its snapshot in the sync folder.
+export async function sync(s) {
+    const dirs = claudeDirs();
+    const result = await scan(dirs, { timezone: s.timezone, anonymize: s.anonymize });
+    const prev = loadOwn(s.syncDir, s.machine, s.timezone);
+    const safeFrom = localClock(s.timezone)(new Date(Date.now() - (retentionDays(dirs) - 1) * 864e5).toISOString()).d;
+    const next = merge(prev, result, safeFrom, { machine: s.machine, timezone: s.timezone });
+    const file = save(s.syncDir, next);
+    const fromPrev = new Set(prev.rows);
+    const kept = new Set(next.rows.filter((r) => fromPrev.has(r)).map((r) => r.d)).size;
+    return { scan: result, file, kept };
+}

package/dist/types.js

@@ -0,0 +1,23 @@
+// Snapshot format, schema 2. Everything here is synced between machines and outlives the
+// transcripts it came from, so fields are append-only: never repurpose an index or a key.
+// Positions in a token counter array (Row.t, HourRow.t).
+export const T = {
+    input: 0,
+    write5m: 1,
+    write1h: 2,
+    read: 3,
+    output: 4,
+    calls: 5,
+    thinking: 6,
+    webSearch: 7,
+    webFetch: 8,
+    maxContext: 9, // largest single-call context (input + cache write + cache read)
+    // calls by context size: < 50K, 50K-200K, 200K-500K, >= 500K tokens
+    ctx50k: 10,
+    ctx200k: 11,
+    ctx500k: 12,
+    ctxOver500k: 13,
+};
+export const T_LEN = 14;
+export const CTX_BOUNDS = [50_000, 200_000, 500_000];
+export const UNKNOWN = '(unknown)';

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@ugurcandede/cc-cost",
+  "version": "0.1.0",
+  "description": "API-equivalent cost of your Claude Code usage across all your machines, with an archive that outlives transcript cleanup and an offline dashboard.",
+  "keywords": [
+    "claude",
+    "claude-code",
+    "anthropic",
+    "cost",
+    "usage",
+    "tokens",
+    "pricing",
+    "prompt-caching",
+    "subscription",
+    "cli",
+    "dashboard",
+    "analytics"
+  ],
+  "homepage": "https://github.com/ugurcandede/cc-cost#readme",
+  "bugs": {
+    "url": "https://github.com/ugurcandede/cc-cost/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ugurcandede/cc-cost.git"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "Ugurcan Dede",
+    "email": "ugurcan.dede@outlook.com.tr",
+    "url": "https://ugurcandede.github.io"
+  },
+  "contributors": [
+    {
+      "name": "Claude",
+      "email": "noreply@anthropic.com",
+      "url": "https://claude.com/claude-code"
+    }
+  ],
+  "type": "module",
+  "bin": {
+    "cc-cost": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc",
+    "dev": "node src/cli.ts",
+    "test": "node --test \"test/**/*.test.ts\"",
+    "typecheck": "tsc --noEmit",
+    "prepack": "yarn typecheck && yarn test && yarn build"
+  },
+  "devDependencies": {
+    "@types/node": "^22.20.3",
+    "typescript": "^6.0.3"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "devEngines": {
+    "runtime": {
+      "name": "node",
+      "version": ">=22.18"
+    }
+  },
+  "os": [
+    "win32",
+    "darwin",
+    "linux"
+  ],
+  "packageManager": "yarn@4.13.0"
+}