@rizzmo/tokochi-cli 0.1.1

package/README.md

@@ -0,0 +1,17 @@
+# @tokochi/cli
+
+Connect local Codex, Claude Code, and GitHub Copilot token usage to your Tokochi.
+
+```bash
+npx @tokochi/cli connect --url https://your-tokochi.app
+```
+
+The browser handles GitHub authentication and device approval. No token copying is required.
+
+```bash
+npx @tokochi/cli sync
+npx @tokochi/cli status
+npx @tokochi/cli disconnect
+```
+
+Only event IDs, timestamps, agent/model names, and token counts are uploaded. Prompts and responses remain on the computer.

package/dist/api.d.ts

@@ -0,0 +1,15 @@
+import type { UsageEvent } from "./types.js";
+export type DeviceStart = {
+    device_code: string;
+    user_code: string;
+    verification_uri: string;
+    verification_uri_complete: string;
+    expires_in: number;
+    interval: number;
+};
+export declare function startDeviceFlow(baseUrl: string): Promise<DeviceStart>;
+export declare function pollForToken(baseUrl: string, deviceCode: string): Promise<string | null>;
+export declare function uploadEvents(baseUrl: string, token: string, events: UsageEvent[]): Promise<{
+    accepted: number;
+    inserted: number;
+}>;

package/dist/api.js

@@ -0,0 +1,40 @@
+export async function startDeviceFlow(baseUrl) {
+    return requestJson(`${baseUrl}/api/device/start`, { method: "POST" });
+}
+export async function pollForToken(baseUrl, deviceCode) {
+    const response = await fetch(`${baseUrl}/api/device/token`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ device_code: deviceCode }),
+    });
+    const body = await response.json();
+    if (response.status === 202 && body.error === "authorization_pending")
+        return null;
+    if (!response.ok || !body.access_token)
+        throw new Error(body.error ?? `Connection failed (${response.status})`);
+    return body.access_token;
+}
+export async function uploadEvents(baseUrl, token, events) {
+    return requestJson(`${baseUrl}/api/usage/sync`, {
+        method: "POST",
+        headers: {
+            authorization: `Bearer ${token}`,
+            "content-type": "application/json",
+            "user-agent": "@tokochi/cli",
+        },
+        body: JSON.stringify({ events }),
+    });
+}
+async function requestJson(url, init) {
+    let response;
+    try {
+        response = await fetch(url, init);
+    }
+    catch (error) {
+        throw new Error(`Could not reach ${new URL(url).origin}: ${error instanceof Error ? error.message : "network error"}`);
+    }
+    const body = await response.json().catch(() => ({}));
+    if (!response.ok)
+        throw new Error(body.error ?? `Request failed (${response.status})`);
+    return body;
+}

package/dist/browser.d.ts

@@ -0,0 +1 @@
+export declare function openBrowser(url: string): boolean;

package/dist/browser.js

@@ -0,0 +1,16 @@
+import { spawn } from "node:child_process";
+export function openBrowser(url) {
+    const command = process.platform === "darwin"
+        ? { file: "open", args: [url] }
+        : process.platform === "win32"
+            ? { file: "cmd", args: ["/c", "start", "", url] }
+            : { file: "xdg-open", args: [url] };
+    try {
+        const child = spawn(command.file, command.args, { detached: true, stdio: "ignore" });
+        child.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/collectors.d.ts

@@ -0,0 +1,6 @@
+import type { UsageEvent } from "./types.js";
+export declare function collectUsageEvents(): Promise<UsageEvent[]>;
+export declare function readCodexEvents(path: string): Promise<UsageEvent[]>;
+export declare function readClaudeEvents(path: string): Promise<UsageEvent[]>;
+export declare function readCopilotEvents(path: string): Promise<UsageEvent[]>;
+export declare function extractJsonAfterMarker(body: string, marker: string): Record<string, unknown> | null;

package/dist/collectors.js

@@ -0,0 +1,181 @@
+import { readFile, readdir, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+export async function collectUsageEvents() {
+    const [codex, claude, copilot] = await Promise.all([
+        readCodexEvents(process.env.TOKOCHI_CODEX_LOGS_PATH ?? join(homedir(), ".codex", "logs_2.sqlite")),
+        readClaudeEvents(process.env.TOKOCHI_CLAUDE_PROJECTS_PATH ?? join(homedir(), ".claude", "projects")),
+        readCopilotEvents(process.env.TOKOCHI_COPILOT_SESSION_PATH ?? join(homedir(), ".copilot", "session-state")),
+    ]);
+    return [...codex, ...claude, ...copilot];
+}
+export async function readCodexEvents(path) {
+    if (!(await exists(path)))
+        return [];
+    const events = new Map();
+    let database;
+    try {
+        database = new DatabaseSync(path, { readOnly: true });
+        const rows = database.prepare(`
+      select ts, feedback_log_body
+      from logs
+      where feedback_log_body like '%response.completed%'
+        and feedback_log_body like '%"usage"%'
+      order by ts asc
+    `).all();
+        for (const [index, row] of rows.entries()) {
+            const payload = extractJsonAfterMarker(row.feedback_log_body, "websocket event: ") ??
+                extractJsonAfterMarker(row.feedback_log_body, "Received message ");
+            if (payload?.type !== "response.completed" || !isRecord(payload.response))
+                continue;
+            const response = payload.response;
+            if (!isRecord(response.usage))
+                continue;
+            const eventId = text(response.id) || `codex:${row.ts}:${index}`;
+            if (events.has(eventId))
+                continue;
+            events.set(eventId, eventFromUsage("codex", eventId, timestampFrom(response.completed_at ?? response.created_at ?? row.ts), text(response.model) || "unknown", response.usage));
+        }
+    }
+    catch {
+        return [];
+    }
+    finally {
+        database?.close();
+    }
+    return [...events.values()];
+}
+export async function readClaudeEvents(path) {
+    const files = await jsonlFiles(path, (name) => name.endsWith(".jsonl"));
+    const events = new Map();
+    for (const file of files) {
+        for (const [index, record] of (await records(file)).entries()) {
+            if (!isRecord(record.message) || record.message.role !== "assistant" || !isRecord(record.message.usage))
+                continue;
+            const eventId = text(record.message.id) || text(record.uuid) || `${file}:${index}`;
+            if (events.has(eventId))
+                continue;
+            const timestamp = timestampFrom(record.timestamp);
+            if (!timestamp)
+                continue;
+            events.set(eventId, eventFromUsage("claude", eventId, timestamp, text(record.message.model) || text(record.model) || "unknown", record.message.usage));
+        }
+    }
+    return [...events.values()];
+}
+export async function readCopilotEvents(path) {
+    const files = await jsonlFiles(path, (name) => name === "events.jsonl");
+    const events = new Map();
+    for (const file of files) {
+        for (const [index, record] of (await records(file)).entries()) {
+            if (record.type !== "session.shutdown" || !isRecord(record.data) || !isRecord(record.data.modelMetrics))
+                continue;
+            const timestamp = timestampFrom(record.timestamp);
+            if (!timestamp)
+                continue;
+            const rootId = text(record.id) || `${file}:${index}`;
+            for (const [model, metrics] of Object.entries(record.data.modelMetrics)) {
+                if (!isRecord(metrics) || !isRecord(metrics.usage))
+                    continue;
+                const eventId = `${rootId}:${model}`;
+                if (events.has(eventId))
+                    continue;
+                events.set(eventId, {
+                    source: "copilot",
+                    event_id: eventId,
+                    timestamp,
+                    model,
+                    input_tokens: token(metrics.usage.inputTokens),
+                    output_tokens: token(metrics.usage.outputTokens),
+                    cache_creation_input_tokens: token(metrics.usage.cacheWriteTokens),
+                    cache_read_input_tokens: token(metrics.usage.cacheReadTokens),
+                    reasoning_tokens: token(metrics.usage.reasoningTokens),
+                });
+            }
+        }
+    }
+    return [...events.values()];
+}
+export function extractJsonAfterMarker(body, marker) {
+    const index = body.indexOf(marker);
+    if (index < 0)
+        return null;
+    try {
+        const value = JSON.parse(body.slice(index + marker.length).trim());
+        return isRecord(value) ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+function eventFromUsage(source, eventId, timestamp, model, usage) {
+    return {
+        source,
+        event_id: eventId,
+        timestamp: timestamp ?? new Date(0).toISOString(),
+        model,
+        input_tokens: token(usage.input_tokens),
+        output_tokens: token(usage.output_tokens),
+        cache_creation_input_tokens: token(usage.cache_creation_input_tokens),
+        cache_read_input_tokens: token(usage.cache_read_input_tokens),
+        reasoning_tokens: token(usage.reasoning_tokens),
+    };
+}
+function token(value) {
+    return typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.trunc(value)) : 0;
+}
+function timestampFrom(value) {
+    const date = typeof value === "number" ? new Date(value * 1000) : typeof value === "string" ? new Date(value) : null;
+    return date && !Number.isNaN(date.valueOf()) ? date.toISOString() : null;
+}
+function text(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function records(path) {
+    try {
+        return (await readFile(path, "utf8"))
+            .split(/\r?\n/)
+            .filter(Boolean)
+            .flatMap((line) => {
+            try {
+                const value = JSON.parse(line);
+                return isRecord(value) ? [value] : [];
+            }
+            catch {
+                return [];
+            }
+        });
+    }
+    catch {
+        return [];
+    }
+}
+async function jsonlFiles(path, include) {
+    if (!(await exists(path)))
+        return [];
+    if ((await stat(path)).isFile())
+        return [path];
+    const found = [];
+    const entries = await readdir(path, { withFileTypes: true });
+    for (const entry of entries) {
+        const child = join(path, entry.name);
+        if (entry.isDirectory())
+            found.push(...await jsonlFiles(child, include));
+        else if (entry.isFile() && include(entry.name))
+            found.push(child);
+    }
+    return found.sort();
+}
+async function exists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,5 @@
+import type { CliConfig } from "./types.js";
+export declare function configPath(): string;
+export declare function loadConfig(): Promise<CliConfig | null>;
+export declare function saveConfig(config: CliConfig): Promise<void>;
+export declare function deleteConfig(): Promise<void>;

package/dist/config.js

@@ -0,0 +1,22 @@
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+export function configPath() {
+    return process.env.TOKOCHI_CLI_CONFIG ?? join(homedir(), ".tokochi", "cli.json");
+}
+export async function loadConfig() {
+    try {
+        return JSON.parse(await readFile(configPath(), "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+export async function saveConfig(config) {
+    const path = configPath();
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    await writeFile(path, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
+}
+export async function deleteConfig() {
+    await rm(configPath(), { force: true });
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+import { startDeviceFlow, pollForToken, uploadEvents } from "./api.js";
+import { openBrowser } from "./browser.js";
+import { collectUsageEvents } from "./collectors.js";
+import { deleteConfig, loadConfig, saveConfig } from "./config.js";
+const DEFAULT_URL = "https://tokochi.app";
+const command = process.argv[2] ?? "help";
+try {
+    if (command === "connect")
+        await connect();
+    else if (command === "sync")
+        await sync();
+    else if (command === "status")
+        await status();
+    else if (command === "disconnect")
+        await disconnect();
+    else if (command === "help" || command === "--help" || command === "-h")
+        help();
+    else
+        throw new Error(`Unknown command: ${command}`);
+}
+catch (error) {
+    console.error(`\nTokochi: ${error instanceof Error ? error.message : String(error)}`);
+    process.exitCode = 1;
+}
+async function connect() {
+    const existing = await loadConfig();
+    const baseUrl = normalizeUrl(option("--url") ?? process.env.TOKOCHI_WEB_URL ?? existing?.baseUrl ?? DEFAULT_URL);
+    console.log("Requesting a feeding link…");
+    const device = await startDeviceFlow(baseUrl);
+    console.log(`\nYour device code is: ${device.user_code}`);
+    console.log(`Open: ${device.verification_uri_complete}\n`);
+    if (openBrowser(device.verification_uri_complete)) {
+        console.log("A browser window was opened. Approve this device to continue.");
+    }
+    else {
+        console.log("Open the link above in your browser to continue.");
+    }
+    const deadline = Date.now() + device.expires_in * 1000;
+    let token = null;
+    while (Date.now() < deadline) {
+        await sleep(device.interval * 1000);
+        token = await pollForToken(baseUrl, device.device_code);
+        if (token)
+            break;
+        process.stdout.write(".");
+    }
+    if (!token)
+        throw new Error("The device code expired. Run `tokochi connect` again.");
+    const config = {
+        baseUrl,
+        token,
+        syncedEventKeys: existing?.baseUrl === baseUrl ? existing.syncedEventKeys : [],
+        connectedAt: new Date().toISOString(),
+    };
+    await saveConfig(config);
+    console.log("\n\nConnected. Feeding your Tokochi for the first time…");
+    await runSync(config);
+}
+async function sync() {
+    const config = await requireConfig();
+    await runSync(config);
+}
+async function runSync(config) {
+    const allEvents = await collectUsageEvents();
+    const synced = new Set(config.syncedEventKeys);
+    const pending = allEvents.filter((event) => !synced.has(eventKey(event)));
+    if (!pending.length) {
+        console.log(`Already fed. ${allEvents.length.toLocaleString()} local events are up to date.`);
+        return;
+    }
+    let inserted = 0;
+    for (let start = 0; start < pending.length; start += 5000) {
+        const batch = pending.slice(start, start + 5000);
+        const result = await uploadEvents(config.baseUrl, config.token, batch);
+        inserted += result.inserted;
+        for (const event of batch)
+            synced.add(eventKey(event));
+        config.syncedEventKeys = [...synced];
+        config.lastSyncAt = new Date().toISOString();
+        await saveConfig(config);
+    }
+    console.log(`Fed ${pending.length.toLocaleString()} events to your Tokochi (${inserted.toLocaleString()} new).`);
+}
+async function status() {
+    const config = await loadConfig();
+    if (!config) {
+        console.log("Not connected. Run `npx @tokochi/cli connect --url https://your-tokochi.app`.");
+        return;
+    }
+    const events = await collectUsageEvents();
+    const synced = new Set(config.syncedEventKeys);
+    const pending = events.filter((event) => !synced.has(eventKey(event))).length;
+    console.log(`Connected to: ${config.baseUrl}`);
+    console.log(`Local events: ${events.length.toLocaleString()}`);
+    console.log(`Waiting to feed: ${pending.toLocaleString()}`);
+    console.log(`Last feeding: ${config.lastSyncAt ? new Date(config.lastSyncAt).toLocaleString() : "never"}`);
+}
+async function disconnect() {
+    const config = await loadConfig();
+    if (!config) {
+        console.log("This computer is not connected.");
+        return;
+    }
+    await fetch(`${config.baseUrl}/api/device/revoke`, {
+        method: "DELETE",
+        headers: { authorization: `Bearer ${config.token}` },
+    }).catch(() => undefined);
+    await deleteConfig();
+    console.log("Disconnected. This computer will no longer feed your Tokochi.");
+}
+function help() {
+    console.log(`
+Tokochi CLI
+
+  tokochi connect [--url URL]  Connect this computer in the browser
+  tokochi sync                 Feed new local token events
+  tokochi status               Show connection and feeding status
+  tokochi disconnect           Remove this computer's connection
+
+Run without installing:
+  npx @tokochi/cli connect --url http://localhost:3000
+`.trim());
+}
+async function requireConfig() {
+    const config = await loadConfig();
+    if (!config)
+        throw new Error("This computer is not connected. Run `tokochi connect` first.");
+    return config;
+}
+function option(name) {
+    const index = process.argv.indexOf(name);
+    return index >= 0 ? process.argv[index + 1] : undefined;
+}
+function normalizeUrl(value) {
+    const url = new URL(value);
+    return url.toString().replace(/\/$/, "");
+}
+function eventKey(event) {
+    return `${event.source}:${event.event_id}`;
+}
+function sleep(milliseconds) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}

package/dist/types.d.ts

@@ -0,0 +1,18 @@
+export type UsageEvent = {
+    source: "codex" | "claude" | "copilot";
+    event_id: string;
+    timestamp: string;
+    model: string;
+    input_tokens: number;
+    output_tokens: number;
+    cache_creation_input_tokens: number;
+    cache_read_input_tokens: number;
+    reasoning_tokens: number;
+};
+export type CliConfig = {
+    baseUrl: string;
+    token: string;
+    syncedEventKeys: string[];
+    connectedAt: string;
+    lastSyncAt?: string;
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@rizzmo/tokochi-cli",
+  "version": "0.1.1",
+  "description": "Feed your Tokochi from local AI coding token usage.",
+  "type": "module",
+  "bin": {
+    "tokochi": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "prepack": "npm run build"
+  },
+  "engines": {
+    "node": ">=22.13"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "typescript": "^5.9.0",
+    "vitest": "^3.2.0"
+  },
+  "overrides": {
+    "esbuild": "0.28.1"
+  },
+  "license": "MIT"
+}