@tickrmeter/ai-usage 0.1.0

package/README.md

@@ -0,0 +1,69 @@
+# TickrMeter AI Usage CLI
+
+Privacy-preserving personal subscription monitoring for Codex / ChatGPT and Claude Code.
+
+## Customer flow
+
+1. Open **AI Usage** in TickrMeter and choose **Connect personal usage**.
+2. Copy the one-time command shown by TickrMeter.
+3. Run it on the computer where Codex or Claude Code is installed:
+
+   ```bash
+   npx @tickrmeter/ai-usage connect ABCD-927F
+   ```
+
+4. The helper detects the Codex desktop app, Codex CLI, and Claude Code, uploads normalized limit metadata, and installs a user-scoped five-minute sync using Task Scheduler, launchd, or a systemd user timer (cron fallback).
+
+The initial `npx` command installs a fixed copy under `~/.tickrmeter-ai/app`. Scheduled runs invoke that fixed version, never `npx ...@latest`.
+
+## Commands
+
+```text
+tickrmeter-ai connect <pairing-code> [--server URL]
+tickrmeter-ai sync
+tickrmeter-ai status
+tickrmeter-ai doctor
+tickrmeter-ai disconnect
+```
+
+For an unpublished local build:
+
+```bash
+cd tickrmeter-ai-usage
+npm install
+npm run build
+node dist/cli.js connect ABCD-927F --server https://develop.tickrmeter.io
+```
+
+`TICKRMETER_API_URL` may be used instead of `--server`. The production default is `https://api.tickrmeter.io`.
+
+## Codex
+
+Codex must already be installed and signed in. On Windows, the helper automatically uses the signed-in Codex desktop app when available and falls back to an installed Codex CLI. It starts `codex app-server`, performs the JSON-RPC initialization handshake, calls `account/read` with token refresh disabled, calls `account/rateLimits/read`, and optionally calls `account/usage/read`. It terminates the child process after each sync.
+
+The helper does not read `~/.codex/auth.json`, browser cookies, OAuth tokens, or private ChatGPT endpoints. If setup is incomplete, `tickrmeter-ai doctor` directs the user to `codex login`; it never asks for a token.
+
+## Claude Code
+
+Claude Code 2.1.80 or newer is required. Claude supplies structured `rate_limits.five_hour` and `rate_limits.seven_day` values to its configured status-line command. TickrMeter stores only those percentages, reset timestamps, and `capturedAt` in `~/.tickrmeter-ai/claude-usage.json`.
+
+If a status line already exists, its complete configuration is backed up locally and wrapped. The same input is passed to the existing command and its stdout/stderr are preserved. Disconnect restores the exact prior `statusLine` value. Prompts, conversations, transcript paths, project paths, cookies, and OAuth credentials are neither stored nor uploaded.
+
+Claude data older than 60 minutes is marked stale. The helper does not send dummy prompts to refresh usage.
+
+## Local files
+
+Files live under `~/.tickrmeter-ai/` with restrictive permissions where supported:
+
+```text
+config.json            TickrMeter bridge ID/token and server
+state.json             scheduler and reversible Claude wrapper state
+claude-usage.json      normalized Claude rate-limit snapshot only
+app/                   fixed installed CLI version
+```
+
+The bridge token is scoped to AI usage upload/status/disconnect. It is not a TickrMeter user session and cannot access provider credentials.
+
+## API usage
+
+OpenAI and Anthropic organization API monitoring does not run in this CLI. Admin keys are entered directly in TickrMeter, encrypted by the backend, and used only for official provider usage/cost APIs. They are never returned to this helper.

package/dist/claude-statusline.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const claude_1 = require("./claude");
+const storage_1 = require("./storage");
+const chunks = [];
+process.stdin.on("data", (chunk) => {
+    if (chunks.reduce((sum, item) => sum + item.length, 0) < 2 * 1024 * 1024)
+        chunks.push(chunk);
+});
+process.stdin.on("end", () => {
+    const input = Buffer.concat(chunks).toString("utf8");
+    try {
+        const snapshot = (0, claude_1.extractClaudeSnapshot)(JSON.parse(input));
+        if (snapshot)
+            (0, storage_1.atomicWriteJson)((0, storage_1.getClaudeCapturePath)(), snapshot);
+    }
+    catch {
+        // Claude status output must never be disrupted by capture failures.
+    }
+    const previous = (0, storage_1.readState)().claude?.previousStatusLine;
+    if (previous?.command && typeof previous.command === "string") {
+        const environment = previous.env && typeof previous.env === "object"
+            ? { ...process.env, ...Object.fromEntries(Object.entries(previous.env).map(([key, value]) => [key, String(value)])) }
+            : process.env;
+        const result = (0, child_process_1.spawnSync)(previous.command, {
+            shell: true,
+            input,
+            encoding: "utf8",
+            env: environment,
+            windowsHide: true,
+        });
+        if (result.stdout)
+            process.stdout.write(result.stdout);
+        if (result.stderr)
+            process.stderr.write(result.stderr);
+        process.exitCode = result.status || 0;
+    }
+});
+process.stdin.resume();

package/dist/claude.js

@@ -0,0 +1,151 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getClaudeUsage = exports.uninstallClaudeStatusLine = exports.installClaudeStatusLine = exports.getClaudeWrapperCommand = exports.readClaudeCapture = exports.extractClaudeSnapshot = exports.detectClaudeVersion = exports.isClaudeVersionSupported = exports.getClaudeSettingsPath = exports.MINIMUM_CLAUDE_VERSION = void 0;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const storage_1 = require("./storage");
+exports.MINIMUM_CLAUDE_VERSION = [2, 1, 80];
+const getClaudeSettingsPath = () => process.env.TICKRMETER_CLAUDE_SETTINGS ||
+    path_1.default.join(process.env.CLAUDE_CONFIG_DIR || path_1.default.join(os_1.default.homedir(), ".claude"), "settings.json");
+exports.getClaudeSettingsPath = getClaudeSettingsPath;
+const parseVersion = (value) => {
+    const match = value.match(/(\d+)\.(\d+)\.(\d+)/);
+    return match ? match.slice(1).map(Number) : null;
+};
+const isClaudeVersionSupported = (version) => {
+    const parsed = parseVersion(version);
+    if (!parsed)
+        return false;
+    for (let index = 0; index < exports.MINIMUM_CLAUDE_VERSION.length; index += 1) {
+        if (parsed[index] > exports.MINIMUM_CLAUDE_VERSION[index])
+            return true;
+        if (parsed[index] < exports.MINIMUM_CLAUDE_VERSION[index])
+            return false;
+    }
+    return true;
+};
+exports.isClaudeVersionSupported = isClaudeVersionSupported;
+const detectClaudeVersion = () => {
+    const result = (0, child_process_1.spawnSync)("claude", ["--version"], { encoding: "utf8", windowsHide: true });
+    if (result.error || result.status !== 0)
+        return null;
+    return result.stdout.trim() || result.stderr.trim() || null;
+};
+exports.detectClaudeVersion = detectClaudeVersion;
+const finitePercent = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 100 ? value : undefined;
+const resetIso = (value) => {
+    if (typeof value !== "string" && typeof value !== "number")
+        return undefined;
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? undefined : date.toISOString();
+};
+const extractClaudeSnapshot = (input, capturedAt = new Date()) => {
+    const limits = input?.rate_limits;
+    if (!limits || typeof limits !== "object")
+        return null;
+    const windows = [
+        { id: "five_hour", label: "5 hour", duration: 300, value: limits.five_hour },
+        { id: "seven_day", label: "Weekly", duration: 10080, value: limits.seven_day },
+    ]
+        .map(({ id, label, duration, value }) => {
+        const usedPercent = finitePercent(value?.used_percentage);
+        if (usedPercent === undefined)
+            return null;
+        return {
+            id,
+            label,
+            usedPercent,
+            remainingPercent: 100 - usedPercent,
+            windowDurationMins: duration,
+            resetsAt: resetIso(value?.resets_at),
+        };
+    })
+        .filter((value) => Boolean(value));
+    if (!windows.length)
+        return null;
+    return {
+        source: "claude",
+        billingMode: "subscription",
+        windows,
+        capturedAt: capturedAt.toISOString(),
+    };
+};
+exports.extractClaudeSnapshot = extractClaudeSnapshot;
+const readClaudeCapture = () => {
+    const snapshot = (0, storage_1.readJson)((0, storage_1.getClaudeCapturePath)());
+    if (!snapshot || snapshot.source !== "claude" || Number.isNaN(Date.parse(snapshot.capturedAt)))
+        return null;
+    return { ...snapshot, stale: Date.now() - Date.parse(snapshot.capturedAt) > 60 * 60 * 1000 };
+};
+exports.readClaudeCapture = readClaudeCapture;
+const quote = (value) => `"${value.replace(/"/g, '\\"')}"`;
+const getClaudeWrapperCommand = () => `${quote(process.execPath)} ${quote((0, storage_1.getInstalledStatusLinePath)())}`;
+exports.getClaudeWrapperCommand = getClaudeWrapperCommand;
+const installClaudeStatusLine = (detectedVersion) => {
+    const version = detectedVersion === undefined ? (0, exports.detectClaudeVersion)() : detectedVersion;
+    if (!version)
+        return { installed: false, code: "CLAUDE_NOT_INSTALLED" };
+    if (!(0, exports.isClaudeVersionSupported)(version))
+        return { installed: false, code: "CLAUDE_VERSION_UNSUPPORTED", version };
+    const settingsPath = (0, exports.getClaudeSettingsPath)();
+    const settings = (0, storage_1.readJson)(settingsPath) || {};
+    const state = (0, storage_1.readState)();
+    const wrapperCommand = (0, exports.getClaudeWrapperCommand)();
+    if (settings.statusLine?.command === wrapperCommand && state.claude) {
+        return { installed: true, idempotent: true, version };
+    }
+    fs_1.default.mkdirSync(path_1.default.dirname(settingsPath), { recursive: true });
+    (0, storage_1.atomicWriteJson)(path_1.default.join((0, storage_1.getDataDir)(), "claude-settings.backup.json"), settings);
+    const hadStatusLine = Object.prototype.hasOwnProperty.call(settings, "statusLine");
+    const previousStatusLine = hadStatusLine ? settings.statusLine : undefined;
+    const nextStatusLine = {
+        ...(previousStatusLine && typeof previousStatusLine === "object" ? previousStatusLine : {}),
+        type: "command",
+        command: wrapperCommand,
+    };
+    (0, storage_1.atomicWriteJson)(settingsPath, { ...settings, statusLine: nextStatusLine });
+    (0, storage_1.writeState)({
+        ...state,
+        claude: { settingsPath, hadStatusLine, previousStatusLine, wrapperCommand, installedAt: new Date().toISOString() },
+    });
+    return { installed: true, idempotent: false, version };
+};
+exports.installClaudeStatusLine = installClaudeStatusLine;
+const uninstallClaudeStatusLine = () => {
+    const state = (0, storage_1.readState)();
+    const claude = state.claude;
+    if (!claude)
+        return { removed: false, idempotent: true };
+    const settings = (0, storage_1.readJson)(claude.settingsPath) || {};
+    if (settings.statusLine?.command === claude.wrapperCommand) {
+        const next = { ...settings };
+        if (claude.hadStatusLine)
+            next.statusLine = claude.previousStatusLine;
+        else
+            delete next.statusLine;
+        (0, storage_1.atomicWriteJson)(claude.settingsPath, next);
+    }
+    const { claude: _removed, ...rest } = state;
+    (0, storage_1.writeState)(rest);
+    return { removed: true, idempotent: false };
+};
+exports.uninstallClaudeStatusLine = uninstallClaudeStatusLine;
+const getClaudeUsage = () => {
+    const version = (0, exports.detectClaudeVersion)();
+    if (!version)
+        return { ok: false, code: "CLAUDE_NOT_INSTALLED", message: "Claude Code is not installed." };
+    if (!(0, exports.isClaudeVersionSupported)(version)) {
+        return { ok: false, code: "CLAUDE_VERSION_UNSUPPORTED", message: "Update Claude Code to version 2.1.80 or newer.", version };
+    }
+    const snapshot = (0, exports.readClaudeCapture)();
+    if (!snapshot) {
+        return { ok: false, code: "CLAUDE_NOT_AVAILABLE", message: "No Claude rate-limit capture is available yet. Start Claude Code normally once.", version };
+    }
+    return { ok: true, snapshot, version };
+};
+exports.getClaudeUsage = getClaudeUsage;

package/dist/cli.js

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const claude_1 = require("./claude");
+const codex_1 = require("./codex");
+const http_1 = require("./http");
+const scheduler_1 = require("./scheduler");
+const storage_1 = require("./storage");
+const sync_1 = require("./sync");
+const DEFAULT_SERVER = "https://api.tickrmeter.io";
+const parseArguments = () => {
+    const args = process.argv.slice(2);
+    let server = process.env.TICKRMETER_API_URL || DEFAULT_SERVER;
+    const serverIndex = args.indexOf("--server");
+    if (serverIndex >= 0) {
+        if (!args[serverIndex + 1])
+            throw new Error("--server requires a URL");
+        server = args[serverIndex + 1];
+        args.splice(serverIndex, 2);
+    }
+    return { command: args[0] || "help", values: args.slice(1), server };
+};
+const printProvider = (provider) => {
+    if (!provider.ok) {
+        console.log(`- ${provider.code}: ${provider.message}`);
+        return;
+    }
+    const windows = provider.snapshot.windows || [];
+    console.log(`- ${provider.snapshot.source}${provider.version ? ` (${provider.version})` : ""}`);
+    if (provider.snapshot.plan)
+        console.log(`  Plan: ${provider.snapshot.plan}`);
+    for (const window of windows) {
+        const remaining = window.remainingPercent === undefined ? "unavailable" : `${window.remainingPercent.toFixed(0)}% remaining`;
+        console.log(`  ${window.label || window.id}: ${remaining}${window.resetsAt ? `, resets ${window.resetsAt}` : ""}`);
+    }
+    if (provider.snapshot.stale)
+        console.log(`  Capture is stale (${provider.snapshot.capturedAt})`);
+};
+const connect = async (code, server) => {
+    if (!code)
+        throw new Error("Usage: tickrmeter-ai connect <pairing-code> [--server URL]");
+    const exchanged = await (0, http_1.exchangePairingCode)(server, code, storage_1.CLI_VERSION);
+    if (!exchanged?.bridgeId || !exchanged?.bridgeToken)
+        throw new Error("AI_USAGE_PAIRING_INVALID");
+    (0, storage_1.writeConfig)({
+        server,
+        bridgeId: String(exchanged.bridgeId),
+        bridgeToken: exchanged.bridgeToken,
+        cliVersion: storage_1.CLI_VERSION,
+        connectedAt: new Date().toISOString(),
+    });
+    (0, storage_1.installFixedCliCopy)();
+    const claudeInstall = (0, claude_1.installClaudeStatusLine)();
+    const scheduler = (0, scheduler_1.installScheduler)();
+    console.log("TickrMeter AI Usage connected.");
+    console.log(`Bridge: ${exchanged.bridgeId}`);
+    console.log(`Scheduled sync: every 5 minutes (${scheduler.kind})`);
+    if (claudeInstall.installed)
+        console.log(`Claude Code capture installed (${claudeInstall.version}).`);
+    else
+        console.log(`Claude Code capture not installed: ${claudeInstall.code}`);
+    const report = await (0, sync_1.syncPersonalUsage)();
+    report.providers.forEach(printProvider);
+    if (!report.uploaded.length)
+        console.log("No provider snapshot was available yet. Run tickrmeter-ai doctor for setup help.");
+};
+const sync = async () => {
+    if ((0, storage_1.readConfig)())
+        (0, storage_1.installFixedCliCopy)();
+    const report = await (0, sync_1.syncPersonalUsage)();
+    console.log(report.uploaded.length ? `Uploaded: ${report.uploaded.join(", ")}` : "No snapshots available to upload.");
+    report.providers.filter((provider) => !provider.ok).forEach(printProvider);
+};
+const status = async () => {
+    const result = await (0, sync_1.getLocalStatus)();
+    console.log("TickrMeter AI Usage");
+    console.log(`Connection: ${result.connected ? result.bridge?.status || "connected" : "not connected"}`);
+    if (result.bridgeId)
+        console.log(`Bridge: ${result.bridgeId}`);
+    result.providers.forEach(printProvider);
+};
+const doctor = async () => {
+    if ((0, storage_1.readConfig)())
+        (0, storage_1.installFixedCliCopy)();
+    const codex = (0, codex_1.detectCodexVersion)();
+    const claude = (0, claude_1.detectClaudeVersion)();
+    console.log("TickrMeter AI Usage doctor");
+    console.log(codex
+        ? `Codex detected: ${codex}`
+        : "Codex app or CLI not detected. Install Codex and sign in with ChatGPT.");
+    if (!claude)
+        console.log("Claude Code not installed.");
+    else if (!(0, claude_1.isClaudeVersionSupported)(claude))
+        console.log(`Claude Code ${claude} is too old. Update to 2.1.80 or newer.`);
+    else
+        console.log(`Claude Code detected: ${claude}`);
+    console.log((0, storage_1.readConfig)() ? "TickrMeter bridge credential is installed." : "Not paired. Create a pairing code in TickrMeter first.");
+    if ((0, storage_1.readConfig)()) {
+        try {
+            const report = await (0, sync_1.syncPersonalUsage)();
+            report.providers.forEach(printProvider);
+        }
+        catch (error) {
+            console.log(`Bridge check failed: ${error instanceof Error ? error.message : "unknown error"}`);
+        }
+    }
+};
+const disconnect = async () => {
+    const config = (0, storage_1.readConfig)();
+    if (config) {
+        try {
+            await (0, http_1.revokeBridge)(config);
+        }
+        catch {
+            console.log("Bridge could not be revoked online; local credentials will still be removed.");
+        }
+    }
+    (0, scheduler_1.uninstallScheduler)();
+    (0, claude_1.uninstallClaudeStatusLine)();
+    (0, storage_1.removeLocalBridgeCredential)();
+    console.log("TickrMeter AI Usage disconnected. Codex and Claude Code were left installed and untouched.");
+};
+const help = () => {
+    console.log(`TickrMeter AI Usage ${storage_1.CLI_VERSION}
+
+Commands:
+  tickrmeter-ai connect <pairing-code> [--server URL]
+  tickrmeter-ai sync
+  tickrmeter-ai status
+  tickrmeter-ai doctor
+  tickrmeter-ai disconnect
+
+TICKRMETER_API_URL may be used instead of --server.`);
+};
+const main = async () => {
+    const { command, values, server } = parseArguments();
+    if (command === "connect")
+        return connect(values[0], server);
+    if (command === "sync")
+        return sync();
+    if (command === "status")
+        return status();
+    if (command === "doctor")
+        return doctor();
+    if (command === "disconnect")
+        return disconnect();
+    return help();
+};
+main().catch((error) => {
+    console.error(error instanceof Error ? error.message : "TickrMeter AI Usage failed.");
+    process.exitCode = 1;
+});

package/dist/codex.js

@@ -0,0 +1,279 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectCodexUsage = exports.detectCodexVersion = exports.normalizeCodexSnapshot = exports.findWindowsCodexDesktopExecutable = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const windowLabel = (duration) => {
+    if (duration === 300)
+        return "5 hour";
+    if (duration === 10080)
+        return "Weekly";
+    if (Number.isFinite(duration))
+        return `${duration} minutes`;
+    return undefined;
+};
+const parseReset = (value) => {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        const date = new Date(value < 10_000_000_000 ? value * 1000 : value);
+        return Number.isNaN(date.getTime()) ? undefined : date.toISOString();
+    }
+    if (typeof value === "string" && !Number.isNaN(Date.parse(value)))
+        return new Date(value).toISOString();
+    return undefined;
+};
+const normalizeWindow = (id, value) => {
+    const used = value?.usedPercent;
+    if (typeof used !== "number" || !Number.isFinite(used) || used < 0 || used > 100)
+        return null;
+    const duration = value?.windowDurationMins;
+    const windowDurationMins = typeof duration === "number" && Number.isFinite(duration) && duration > 0 ? duration : undefined;
+    return {
+        id,
+        label: windowLabel(windowDurationMins) || (typeof value?.label === "string" ? value.label.slice(0, 40) : undefined),
+        usedPercent: used,
+        remainingPercent: 100 - used,
+        windowDurationMins,
+        resetsAt: parseReset(value?.resetsAt),
+    };
+};
+const collectWindows = (rateResponse) => {
+    const candidates = [];
+    const addRateLimits = (prefix, limits) => {
+        if (!limits || typeof limits !== "object" || Array.isArray(limits))
+            return;
+        for (const [key, value] of Object.entries(limits)) {
+            if (value && typeof value === "object" && "usedPercent" in value)
+                candidates.push([`${prefix}${key}`, value]);
+        }
+    };
+    addRateLimits("", rateResponse?.rateLimits);
+    const byId = rateResponse?.rateLimitsByLimitId;
+    if (byId && typeof byId === "object") {
+        for (const [limitId, entry] of Object.entries(byId)) {
+            if (entry && typeof entry === "object" && "usedPercent" in entry)
+                candidates.push([limitId, entry]);
+            addRateLimits(`${limitId}:`, entry?.rateLimits || entry);
+        }
+    }
+    const seen = new Set();
+    return candidates
+        .map(([id, value]) => normalizeWindow(id, value))
+        .filter((window) => {
+        if (!window)
+            return false;
+        const identity = `${window.windowDurationMins || "unknown"}:${window.resetsAt || window.id}`;
+        if (seen.has(identity))
+            return false;
+        seen.add(identity);
+        return true;
+    });
+};
+const safeCount = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
+const findWindowsCodexDesktopExecutable = (rootDirectory) => {
+    try {
+        const candidates = fs_1.default
+            .readdirSync(rootDirectory, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => path_1.default.join(rootDirectory, entry.name, "codex.exe"))
+            .filter((candidate) => fs_1.default.existsSync(candidate))
+            .map((candidate) => ({ candidate, modifiedAt: fs_1.default.statSync(candidate).mtimeMs }))
+            .sort((left, right) => right.modifiedAt - left.modifiedAt);
+        return candidates[0]?.candidate || null;
+    }
+    catch {
+        return null;
+    }
+};
+exports.findWindowsCodexDesktopExecutable = findWindowsCodexDesktopExecutable;
+const resolveCodexInvocation = () => {
+    const explicitPath = process.env.TICKRMETER_CODEX_PATH?.trim();
+    if (explicitPath) {
+        return explicitPath.toLowerCase().endsWith(".js")
+            ? { command: process.execPath, prefixArgs: [explicitPath] }
+            : { command: explicitPath, prefixArgs: [] };
+    }
+    if (process.platform !== "win32")
+        return { command: "codex", prefixArgs: [] };
+    const desktopExecutable = process.env.LOCALAPPDATA
+        ? (0, exports.findWindowsCodexDesktopExecutable)(path_1.default.join(process.env.LOCALAPPDATA, "OpenAI", "Codex", "bin"))
+        : null;
+    if (desktopExecutable)
+        return { command: desktopExecutable, prefixArgs: [] };
+    const searchDirectories = [
+        path_1.default.dirname(process.execPath),
+        ...(process.env.PATH || "").split(path_1.default.delimiter).filter(Boolean),
+    ];
+    if (process.env.APPDATA)
+        searchDirectories.push(path_1.default.join(process.env.APPDATA, "npm"));
+    const fnmDirectory = process.env.FNM_DIR || path_1.default.join(os_1.default.homedir(), "AppData", "Roaming", "fnm");
+    const fnmVersionsDirectory = path_1.default.join(fnmDirectory, "node-versions");
+    try {
+        for (const version of fs_1.default.readdirSync(fnmVersionsDirectory)) {
+            searchDirectories.push(path_1.default.join(fnmVersionsDirectory, version, "installation"));
+        }
+    }
+    catch {
+        // FNM is optional; ordinary PATH/npm resolution still applies.
+    }
+    for (const directory of [...new Set(searchDirectories)]) {
+        const javascriptLauncher = path_1.default.join(directory, "node_modules", "@openai", "codex", "bin", "codex.js");
+        if (fs_1.default.existsSync(javascriptLauncher)) {
+            return { command: process.execPath, prefixArgs: [javascriptLauncher] };
+        }
+    }
+    // npm exposes Codex as a batch shim on Windows. Avoid the extensionless
+    // POSIX shim, which child_process cannot execute on Windows.
+    return { command: "codex.cmd", prefixArgs: [] };
+};
+const normalizeCodexSnapshot = (accountResponse, rateResponse, usageResponse, capturedAt = new Date()) => {
+    const account = accountResponse?.account || accountResponse;
+    const usage = usageResponse?.usage || usageResponse?.totals || usageResponse || {};
+    const availableCount = rateResponse?.rateLimitResetCredits?.availableCount ?? account?.rateLimitResetCredits?.availableCount;
+    return {
+        source: "codex",
+        billingMode: "subscription",
+        plan: account?.planType || rateResponse?.planType,
+        windows: collectWindows(rateResponse),
+        resetCreditsAvailable: safeCount(availableCount),
+        inputTokens: safeCount(usage?.inputTokens),
+        outputTokens: safeCount(usage?.outputTokens),
+        cachedInputTokens: safeCount(usage?.cachedInputTokens),
+        requests: safeCount(usage?.requests),
+        capturedAt: capturedAt.toISOString(),
+    };
+};
+exports.normalizeCodexSnapshot = normalizeCodexSnapshot;
+class CodexRpcClient {
+    child;
+    nextId = 1;
+    buffer = "";
+    pending = new Map();
+    constructor(child) {
+        this.child = child;
+        child.stdout.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => this.receive(chunk));
+        child.on("exit", () => this.rejectAll(new Error("CODEX_APP_SERVER_EXITED")));
+    }
+    receive(chunk) {
+        this.buffer += chunk;
+        let newline = this.buffer.indexOf("\n");
+        while (newline >= 0) {
+            const line = this.buffer.slice(0, newline).trim();
+            this.buffer = this.buffer.slice(newline + 1);
+            newline = this.buffer.indexOf("\n");
+            if (!line)
+                continue;
+            let message;
+            try {
+                message = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (typeof message.id !== "number")
+                continue;
+            const request = this.pending.get(message.id);
+            if (!request)
+                continue;
+            clearTimeout(request.timer);
+            this.pending.delete(message.id);
+            if (message.error)
+                request.reject(new Error(message.error.message || "CODEX_RPC_ERROR"));
+            else
+                request.resolve(message.result);
+        }
+    }
+    rejectAll(error) {
+        for (const request of this.pending.values()) {
+            clearTimeout(request.timer);
+            request.reject(error);
+        }
+        this.pending.clear();
+    }
+    request(method, params = {}, timeoutMs = 15_000) {
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`CODEX_RPC_TIMEOUT:${method}`));
+            }, timeoutMs);
+            this.pending.set(id, { resolve, reject, timer });
+            this.child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}\n`);
+        });
+    }
+    notify(method, params = {}) {
+        this.child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method, params })}\n`);
+    }
+}
+const detectCodexVersion = () => {
+    const invocation = resolveCodexInvocation();
+    const result = (0, child_process_1.spawnSync)(invocation.command, [...invocation.prefixArgs, "--version"], {
+        encoding: "utf8",
+        windowsHide: true,
+    });
+    if (result.error || result.status !== 0)
+        return null;
+    return result.stdout.trim() || result.stderr.trim() || null;
+};
+exports.detectCodexVersion = detectCodexVersion;
+const collectCodexUsage = async () => {
+    const version = (0, exports.detectCodexVersion)();
+    if (!version)
+        return { ok: false, code: "CODEX_NOT_INSTALLED", message: "Codex is not installed." };
+    const invocation = resolveCodexInvocation();
+    const child = (0, child_process_1.spawn)(invocation.command, [...invocation.prefixArgs, "app-server"], {
+        stdio: ["pipe", "pipe", "pipe"],
+        windowsHide: true,
+    });
+    let stderr = "";
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => {
+        if (stderr.length < 1000)
+            stderr += chunk;
+    });
+    const rpc = new CodexRpcClient(child);
+    try {
+        await rpc.request("initialize", {
+            clientInfo: { name: "tickrmeter_ai_usage", title: "TickrMeter AI Usage", version: "0.1.0" },
+            capabilities: {},
+        });
+        rpc.notify("initialized");
+        const account = await rpc.request("account/read", { refreshToken: false });
+        if (!account?.account && !account?.authMode && !account?.planType) {
+            return { ok: false, code: "CODEX_NOT_LOGGED_IN", message: "Codex is installed but not signed in. Run: codex login", version };
+        }
+        const rateLimits = await rpc.request("account/rateLimits/read");
+        let usage;
+        try {
+            usage = await rpc.request("account/usage/read", {}, 8_000);
+        }
+        catch {
+            // Usage activity is optional; subscription limits remain useful without it.
+        }
+        const snapshot = (0, exports.normalizeCodexSnapshot)(account, rateLimits, usage);
+        if (!snapshot.windows?.length) {
+            return { ok: false, code: "CODEX_RATE_LIMITS_UNAVAILABLE", message: "Codex did not return subscription limit windows.", version };
+        }
+        return { ok: true, snapshot, version };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "CODEX_APP_SERVER_FAILED";
+        const code = /login|account|unauth/i.test(message) ? "CODEX_NOT_LOGGED_IN" : "CODEX_APP_SERVER_FAILED";
+        return { ok: false, code, message: code === "CODEX_NOT_LOGGED_IN" ? "Run: codex login" : "Codex app-server could not be queried.", version };
+    }
+    finally {
+        try {
+            child.stdin.end();
+            child.kill();
+        }
+        catch {
+            // Process may already have exited.
+        }
+    }
+};
+exports.collectCodexUsage = collectCodexUsage;

package/dist/http.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.revokeBridge = exports.fetchBridgeStatus = exports.uploadSnapshots = exports.exchangePairingCode = void 0;
+const apiUrl = (server, path) => `${server.replace(/\/$/, "")}/api${path}`;
+const parseResponse = async (response) => {
+    const body = await response.json().catch(() => null);
+    if (!response.ok || body?.success === false)
+        throw new Error(body?.message || `HTTP_${response.status}`);
+    return body?.data ?? body;
+};
+const exchangePairingCode = async (server, code, cliVersion) => {
+    const response = await fetch(apiUrl(server, "/integrations/ai-usage/bridge/exchange"), {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ code, cliVersion, deviceName: process.env.COMPUTERNAME || process.env.HOSTNAME || "Personal computer" }),
+    });
+    return parseResponse(response);
+};
+exports.exchangePairingCode = exchangePairingCode;
+const uploadSnapshots = async (config, snapshots) => {
+    const response = await fetch(apiUrl(config.server, "/integrations/ai-usage/bridge/snapshot"), {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: `Bridge ${config.bridgeToken}` },
+        body: JSON.stringify({ snapshots }),
+    });
+    return parseResponse(response);
+};
+exports.uploadSnapshots = uploadSnapshots;
+const fetchBridgeStatus = async (config) => {
+    const response = await fetch(apiUrl(config.server, "/integrations/ai-usage/bridge/status"), {
+        headers: { Authorization: `Bridge ${config.bridgeToken}` },
+    });
+    return parseResponse(response);
+};
+exports.fetchBridgeStatus = fetchBridgeStatus;
+const revokeBridge = async (config) => {
+    const response = await fetch(apiUrl(config.server, "/integrations/ai-usage/bridge/current"), {
+        method: "DELETE",
+        headers: { Authorization: `Bridge ${config.bridgeToken}` },
+    });
+    return parseResponse(response);
+};
+exports.revokeBridge = revokeBridge;

package/dist/scheduler.js

@@ -0,0 +1,175 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uninstallScheduler = exports.installScheduler = exports.buildCronLine = exports.buildSystemdTimer = exports.buildSystemdService = exports.buildLaunchAgentPlist = exports.buildWindowsTaskArgs = exports.getWindowsTaskCommand = exports.buildWindowsSyncScript = exports.getFixedSyncCommand = exports.CRON_MARKER = exports.SYSTEMD_NAME = exports.LAUNCH_AGENT_LABEL = exports.WINDOWS_TASK_NAME = void 0;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const storage_1 = require("./storage");
+exports.WINDOWS_TASK_NAME = "TickrMeter AI Usage Sync";
+exports.LAUNCH_AGENT_LABEL = "com.tickrmeter.ai-usage";
+exports.SYSTEMD_NAME = "tickrmeter-ai-usage";
+exports.CRON_MARKER = "# TickrMeter AI Usage Sync";
+const quoteShell = (value) => `"${value.replace(/"/g, '\\"')}"`;
+const getFixedSyncCommand = (nodePath = process.execPath, cliPath = (0, storage_1.getInstalledCliPath)()) => `${quoteShell(nodePath)} ${quoteShell(cliPath)} sync`;
+exports.getFixedSyncCommand = getFixedSyncCommand;
+const quoteVbsString = (value) => `"${value.replace(/"/g, '""')}"`;
+const windowsSyncScriptPath = () => path_1.default.join((0, storage_1.getDataDir)(), "sync-hidden.vbs");
+const buildWindowsSyncScript = (nodePath = process.execPath, cliPath = (0, storage_1.getInstalledCliPath)()) => {
+    const command = `${quoteShell(nodePath)} ${quoteShell(cliPath)} sync`;
+    return [
+        'Set shell = CreateObject("WScript.Shell")',
+        `command = ${quoteVbsString(command)}`,
+        "exitCode = shell.Run(command, 0, True)",
+        "WScript.Quit exitCode",
+        "",
+    ].join("\r\n");
+};
+exports.buildWindowsSyncScript = buildWindowsSyncScript;
+const getWindowsTaskCommand = (scriptPath = windowsSyncScriptPath()) => {
+    const windowsDirectory = process.env.SystemRoot || "C:\\Windows";
+    const wscriptPath = path_1.default.join(windowsDirectory, "System32", "wscript.exe");
+    return `${quoteShell(wscriptPath)} //B //NoLogo ${quoteShell(scriptPath)}`;
+};
+exports.getWindowsTaskCommand = getWindowsTaskCommand;
+const buildWindowsTaskArgs = (command = (0, exports.getWindowsTaskCommand)()) => [
+    "/Create",
+    "/TN",
+    exports.WINDOWS_TASK_NAME,
+    "/TR",
+    command,
+    "/SC",
+    "MINUTE",
+    "/MO",
+    "5",
+    "/F",
+];
+exports.buildWindowsTaskArgs = buildWindowsTaskArgs;
+const buildLaunchAgentPlist = (nodePath = process.execPath, cliPath = (0, storage_1.getInstalledCliPath)()) => `<?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>${exports.LAUNCH_AGENT_LABEL}</string>
+  <key>ProgramArguments</key><array><string>${nodePath}</string><string>${cliPath}</string><string>sync</string></array>
+  <key>StartInterval</key><integer>300</integer>
+  <key>RunAtLoad</key><true/>
+</dict></plist>
+`;
+exports.buildLaunchAgentPlist = buildLaunchAgentPlist;
+const buildSystemdService = (nodePath = process.execPath, cliPath = (0, storage_1.getInstalledCliPath)()) => `[Unit]
+Description=TickrMeter AI Usage sync
+
+[Service]
+Type=oneshot
+ExecStart=${quoteShell(nodePath)} ${quoteShell(cliPath)} sync
+`;
+exports.buildSystemdService = buildSystemdService;
+const buildSystemdTimer = () => `[Unit]
+Description=Sync TickrMeter AI Usage every five minutes
+
+[Timer]
+OnBootSec=1min
+OnUnitActiveSec=5min
+Persistent=true
+
+[Install]
+WantedBy=timers.target
+`;
+exports.buildSystemdTimer = buildSystemdTimer;
+const buildCronLine = (command = (0, exports.getFixedSyncCommand)()) => `*/5 * * * * ${command} >/dev/null 2>&1 ${exports.CRON_MARKER}`;
+exports.buildCronLine = buildCronLine;
+const run = (command, args, input) => {
+    const result = (0, child_process_1.spawnSync)(command, args, { encoding: "utf8", input, windowsHide: true });
+    return {
+        status: result.status,
+        stdout: result.stdout || "",
+        stderr: result.stderr || "",
+        error: result.error,
+    };
+};
+const launchAgentPath = () => path_1.default.join(os_1.default.homedir(), "Library", "LaunchAgents", `${exports.LAUNCH_AGENT_LABEL}.plist`);
+const systemdDirectory = () => path_1.default.join(os_1.default.homedir(), ".config", "systemd", "user");
+const systemdServicePath = () => path_1.default.join(systemdDirectory(), `${exports.SYSTEMD_NAME}.service`);
+const systemdTimerPath = () => path_1.default.join(systemdDirectory(), `${exports.SYSTEMD_NAME}.timer`);
+const installCron = (runner = run) => {
+    const existingResult = runner("crontab", ["-l"]);
+    const existing = existingResult.status === 0 ? existingResult.stdout : "";
+    const retained = existing
+        .split(/\r?\n/)
+        .filter((line) => line && !line.includes(exports.CRON_MARKER));
+    retained.push((0, exports.buildCronLine)());
+    const installed = runner("crontab", ["-"], `${retained.join("\n")}\n`);
+    if (installed.status !== 0)
+        throw new Error("AI_USAGE_SCHEDULER_INSTALL_FAILED");
+    return "cron";
+};
+const installScheduler = (platform = process.platform, runner = run) => {
+    let kind;
+    if (platform === "win32") {
+        const scriptPath = windowsSyncScriptPath();
+        (0, storage_1.atomicWriteFile)(scriptPath, (0, exports.buildWindowsSyncScript)());
+        const result = runner("schtasks", (0, exports.buildWindowsTaskArgs)((0, exports.getWindowsTaskCommand)(scriptPath)));
+        if (result.status !== 0) {
+            fs_1.default.rmSync(scriptPath, { force: true });
+            throw new Error("AI_USAGE_SCHEDULER_INSTALL_FAILED");
+        }
+        kind = "windows-task";
+    }
+    else if (platform === "darwin") {
+        const file = launchAgentPath();
+        (0, storage_1.atomicWriteFile)(file, (0, exports.buildLaunchAgentPlist)(), 0o600);
+        runner("launchctl", ["unload", file]);
+        const result = runner("launchctl", ["load", file]);
+        if (result.status !== 0)
+            throw new Error("AI_USAGE_SCHEDULER_INSTALL_FAILED");
+        kind = "launch-agent";
+    }
+    else {
+        fs_1.default.mkdirSync(systemdDirectory(), { recursive: true, mode: 0o700 });
+        (0, storage_1.atomicWriteFile)(systemdServicePath(), (0, exports.buildSystemdService)());
+        (0, storage_1.atomicWriteFile)(systemdTimerPath(), (0, exports.buildSystemdTimer)());
+        const reload = runner("systemctl", ["--user", "daemon-reload"]);
+        const enable = reload.status === 0 ? runner("systemctl", ["--user", "enable", "--now", `${exports.SYSTEMD_NAME}.timer`]) : reload;
+        if (enable.status === 0)
+            kind = "systemd-user";
+        else {
+            fs_1.default.rmSync(systemdServicePath(), { force: true });
+            fs_1.default.rmSync(systemdTimerPath(), { force: true });
+            kind = installCron(runner);
+        }
+    }
+    const state = (0, storage_1.readState)();
+    (0, storage_1.writeState)({ ...state, scheduler: { platform, kind, installedAt: new Date().toISOString() } });
+    return { kind };
+};
+exports.installScheduler = installScheduler;
+const uninstallScheduler = (runner = run) => {
+    const state = (0, storage_1.readState)();
+    const kind = state.scheduler?.kind;
+    if (kind === "windows-task") {
+        runner("schtasks", ["/Delete", "/TN", exports.WINDOWS_TASK_NAME, "/F"]);
+        fs_1.default.rmSync(windowsSyncScriptPath(), { force: true });
+    }
+    if (kind === "launch-agent") {
+        runner("launchctl", ["unload", launchAgentPath()]);
+        fs_1.default.rmSync(launchAgentPath(), { force: true });
+    }
+    if (kind === "systemd-user") {
+        runner("systemctl", ["--user", "disable", "--now", `${exports.SYSTEMD_NAME}.timer`]);
+        fs_1.default.rmSync(systemdServicePath(), { force: true });
+        fs_1.default.rmSync(systemdTimerPath(), { force: true });
+        runner("systemctl", ["--user", "daemon-reload"]);
+    }
+    if (kind === "cron") {
+        const existing = runner("crontab", ["-l"]);
+        const source = existing.status === 0 ? existing.stdout : "";
+        const retained = source.split(/\r?\n/).filter((line) => line && !line.includes(exports.CRON_MARKER));
+        runner("crontab", ["-"], retained.length ? `${retained.join("\n")}\n` : "");
+    }
+    const { scheduler: _removed, ...rest } = state;
+    (0, storage_1.writeState)(rest);
+    return { removed: Boolean(kind) };
+};
+exports.uninstallScheduler = uninstallScheduler;

package/dist/storage.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeLocalBridgeCredential = exports.installFixedCliCopy = exports.writeState = exports.readState = exports.writeConfig = exports.readConfig = exports.readJson = exports.atomicWriteJson = exports.atomicWriteFile = exports.ensureDataDir = exports.getInstalledStatusLinePath = exports.getInstalledCliPath = exports.getStatePath = exports.getClaudeCapturePath = exports.getConfigPath = exports.getDataDir = exports.CLI_VERSION = void 0;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+exports.CLI_VERSION = "0.1.0";
+const getDataDir = () => process.env.TICKRMETER_AI_HOME || path_1.default.join(os_1.default.homedir(), ".tickrmeter-ai");
+exports.getDataDir = getDataDir;
+const getConfigPath = () => path_1.default.join((0, exports.getDataDir)(), "config.json");
+exports.getConfigPath = getConfigPath;
+const getClaudeCapturePath = () => path_1.default.join((0, exports.getDataDir)(), "claude-usage.json");
+exports.getClaudeCapturePath = getClaudeCapturePath;
+const getStatePath = () => path_1.default.join((0, exports.getDataDir)(), "state.json");
+exports.getStatePath = getStatePath;
+const getInstalledCliPath = () => path_1.default.join((0, exports.getDataDir)(), "app", "dist", "cli.js");
+exports.getInstalledCliPath = getInstalledCliPath;
+const getInstalledStatusLinePath = () => path_1.default.join((0, exports.getDataDir)(), "app", "dist", "claude-statusline.js");
+exports.getInstalledStatusLinePath = getInstalledStatusLinePath;
+const ensureDataDir = () => fs_1.default.mkdirSync((0, exports.getDataDir)(), { recursive: true, mode: 0o700 });
+exports.ensureDataDir = ensureDataDir;
+const atomicWriteFile = (file, contents, mode = 0o600) => {
+    (0, exports.ensureDataDir)();
+    fs_1.default.mkdirSync(path_1.default.dirname(file), { recursive: true, mode: 0o700 });
+    const temporary = `${file}.${process.pid}.${Date.now()}.tmp`;
+    fs_1.default.writeFileSync(temporary, contents, { mode });
+    fs_1.default.renameSync(temporary, file);
+    try {
+        fs_1.default.chmodSync(file, mode);
+    }
+    catch {
+        // Windows ACLs are managed by the current user profile.
+    }
+};
+exports.atomicWriteFile = atomicWriteFile;
+const atomicWriteJson = (file, value) => {
+    (0, exports.atomicWriteFile)(file, `${JSON.stringify(value, null, 2)}\n`);
+};
+exports.atomicWriteJson = atomicWriteJson;
+const readJson = (file) => {
+    try {
+        return JSON.parse(fs_1.default.readFileSync(file, "utf8"));
+    }
+    catch {
+        return null;
+    }
+};
+exports.readJson = readJson;
+const readConfig = () => (0, exports.readJson)((0, exports.getConfigPath)());
+exports.readConfig = readConfig;
+const writeConfig = (config) => (0, exports.atomicWriteJson)((0, exports.getConfigPath)(), config);
+exports.writeConfig = writeConfig;
+const readState = () => (0, exports.readJson)((0, exports.getStatePath)()) || {};
+exports.readState = readState;
+const writeState = (state) => (0, exports.atomicWriteJson)((0, exports.getStatePath)(), state);
+exports.writeState = writeState;
+const installFixedCliCopy = () => {
+    const packageRoot = path_1.default.resolve(__dirname, "..");
+    const destination = path_1.default.join((0, exports.getDataDir)(), "app");
+    if (path_1.default.resolve(packageRoot) === path_1.default.resolve(destination))
+        return;
+    fs_1.default.rmSync(destination, { recursive: true, force: true });
+    fs_1.default.mkdirSync(destination, { recursive: true, mode: 0o700 });
+    fs_1.default.cpSync(path_1.default.join(packageRoot, "dist"), path_1.default.join(destination, "dist"), { recursive: true });
+    for (const file of ["package.json", "README.md"]) {
+        const source = path_1.default.join(packageRoot, file);
+        if (fs_1.default.existsSync(source))
+            fs_1.default.copyFileSync(source, path_1.default.join(destination, file));
+    }
+    return (0, exports.getInstalledCliPath)();
+};
+exports.installFixedCliCopy = installFixedCliCopy;
+const removeLocalBridgeCredential = () => {
+    try {
+        fs_1.default.rmSync((0, exports.getConfigPath)(), { force: true });
+    }
+    catch {
+        // Idempotent disconnect.
+    }
+};
+exports.removeLocalBridgeCredential = removeLocalBridgeCredential;

package/dist/sync.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLocalStatus = exports.syncPersonalUsage = exports.collectPersonalUsage = void 0;
+const claude_1 = require("./claude");
+const codex_1 = require("./codex");
+const http_1 = require("./http");
+const storage_1 = require("./storage");
+const collectPersonalUsage = async (codexCollector = codex_1.collectCodexUsage, claudeCollector = claude_1.getClaudeUsage) => {
+    const codexPromise = codexCollector().catch(() => ({ ok: false, code: "CODEX_APP_SERVER_FAILED", message: "Codex app-server could not be queried." }));
+    const claudePromise = Promise.resolve().then(claudeCollector).catch(() => ({ ok: false, code: "CLAUDE_NOT_AVAILABLE", message: "Claude usage capture could not be read." }));
+    return Promise.all([codexPromise, claudePromise]);
+};
+exports.collectPersonalUsage = collectPersonalUsage;
+const syncPersonalUsage = async () => {
+    const config = (0, storage_1.readConfig)();
+    if (!config)
+        throw new Error("AI_USAGE_NOT_CONNECTED");
+    const providers = await (0, exports.collectPersonalUsage)();
+    const snapshots = providers.filter((result) => result.ok).map((result) => result.snapshot);
+    if (snapshots.length)
+        await (0, http_1.uploadSnapshots)(config, snapshots);
+    return { uploaded: snapshots.map((snapshot) => snapshot.source), providers };
+};
+exports.syncPersonalUsage = syncPersonalUsage;
+const getLocalStatus = async () => {
+    const config = (0, storage_1.readConfig)();
+    if (!config)
+        return { connected: false, providers: await (0, exports.collectPersonalUsage)() };
+    let bridge = null;
+    try {
+        bridge = await (0, http_1.fetchBridgeStatus)(config);
+    }
+    catch {
+        bridge = { status: "offline" };
+    }
+    return { connected: true, bridgeId: config.bridgeId, bridge, providers: await (0, exports.collectPersonalUsage)() };
+};
+exports.getLocalStatus = getLocalStatus;

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@tickrmeter/ai-usage",
+  "version": "0.1.0",
+  "description": "Privacy-preserving TickrMeter personal AI usage bridge",
+  "license": "UNLICENSED",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "commonjs",
+  "bin": {
+    "tickrmeter-ai": "dist/cli.js"
+  },
+  "files": [
+    "dist/*.js",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
+    "build": "npm run clean && tsc",
+    "test": "npm run build && node --test dist/tests/*.test.js"
+  },
+  "devDependencies": {
+    "@types/node": "^18.19.0",
+    "typescript": "^5.0.2"
+  }
+}