costpilot-scanner 0.1.0

package/dist/api.d.ts

@@ -0,0 +1,24 @@
+import type { ScannerConfig } from './config.js';
+export interface IngestPayload {
+    source: 'local-scanner';
+    model: string;
+    eventId: string;
+    inputTokens: number;
+    outputTokens: number;
+    cacheCreationTokens?: number;
+    cacheReadTokens?: number;
+    sessionId?: string;
+    agentTool?: string;
+    timestamp?: string;
+}
+export interface HeartbeatPayload {
+    source: 'local-scanner';
+    version: string;
+    hostname: string;
+    toolsDetected: string[];
+    eventsLast24h: number;
+    errorsLast24h: number;
+}
+export declare function ingest(cfg: ScannerConfig, payload: IngestPayload): Promise<boolean>;
+export declare function heartbeat(cfg: ScannerConfig, payload: HeartbeatPayload): Promise<boolean>;
+export declare function validateKey(cfg: ScannerConfig): Promise<boolean>;

package/dist/api.js

@@ -0,0 +1,45 @@
+async function post(cfg, path, body) {
+    return fetch(`${cfg.apiUrl}${path}`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${cfg.key}`,
+        },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(10_000),
+    });
+}
+export async function ingest(cfg, payload) {
+    try {
+        const res = await post(cfg, '/v1/ingest', payload);
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+export async function heartbeat(cfg, payload) {
+    try {
+        const res = await post(cfg, '/v1/scanner/heartbeat', payload);
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+export async function validateKey(cfg) {
+    try {
+        const res = await post(cfg, '/v1/scanner/heartbeat', {
+            source: 'local-scanner',
+            version: '0.1.0',
+            hostname: 'setup-check',
+            toolsDetected: [],
+            eventsLast24h: 0,
+            errorsLast24h: 0,
+        });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/commands/setup.d.ts

@@ -0,0 +1,4 @@
+export declare function setupCommand({ key, apiUrl, }: {
+    key?: string;
+    apiUrl?: string;
+}): Promise<void>;

package/dist/commands/setup.js

@@ -0,0 +1,31 @@
+import { saveConfig } from '../config.js';
+import { validateKey } from '../api.js';
+export async function setupCommand({ key, apiUrl, }) {
+    if (!key) {
+        console.error('Error: --key is required\n');
+        console.error('Usage: costpilot-scanner setup --key pilot_live_...');
+        console.error('\nGet a scanner key from:');
+        console.error('  https://app.aicostpilot.online → Developer Hub → Local Scanner');
+        process.exit(1);
+    }
+    if (!key.startsWith('pilot_live_')) {
+        console.error('Error: key must start with pilot_live_');
+        process.exit(1);
+    }
+    const cfg = {
+        key,
+        apiUrl: apiUrl ?? 'https://api.aicostpilot.online',
+    };
+    process.stdout.write('Validating key with CostPilot API...\n');
+    const valid = await validateKey(cfg);
+    if (!valid) {
+        console.error('\nError: key validation failed — check the key and try again.');
+        process.exit(1);
+    }
+    saveConfig(cfg);
+    console.log('\n✓ Scanner configured successfully');
+    console.log('\nTo start scanning, run:');
+    console.log('  costpilot-scanner start\n');
+    console.log('Claude Code usage will sync to CostPilot automatically.');
+    console.log('Keep the process running (use PM2, tmux, or a startup script).');
+}

package/dist/commands/start.d.ts

@@ -0,0 +1 @@
+export declare function startCommand(): Promise<void>;

package/dist/commands/start.js

@@ -0,0 +1,11 @@
+import { loadConfig } from '../config.js';
+import { startWatcher } from '../watcher.js';
+export async function startCommand() {
+    const cfg = loadConfig();
+    if (!cfg) {
+        console.error('Scanner not configured. Run first:');
+        console.error('  costpilot-scanner setup --key pilot_live_...\n');
+        process.exit(1);
+    }
+    await startWatcher(cfg);
+}

package/dist/config.d.ts

@@ -0,0 +1,16 @@
+export interface ScannerConfig {
+    key: string;
+    apiUrl: string;
+}
+export interface FileState {
+    bytesRead: number;
+    lineIndex: number;
+}
+export interface ScannerState {
+    files: Record<string, FileState>;
+}
+export declare function loadConfig(): ScannerConfig | null;
+export declare function saveConfig(cfg: ScannerConfig): void;
+export declare function loadState(): ScannerState;
+export declare function saveState(state: ScannerState): void;
+export declare function getClaudeProjectsDir(): string;

package/dist/config.js

@@ -0,0 +1,41 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+const COSTPILOT_DIR = join(homedir(), '.costpilot');
+const CONFIG_PATH = join(COSTPILOT_DIR, 'scanner.json');
+const STATE_PATH = join(COSTPILOT_DIR, 'scanner-state.json');
+function ensureDir() {
+    if (!existsSync(COSTPILOT_DIR))
+        mkdirSync(COSTPILOT_DIR, { recursive: true });
+}
+export function loadConfig() {
+    if (!existsSync(CONFIG_PATH))
+        return null;
+    try {
+        return JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function saveConfig(cfg) {
+    ensureDir();
+    writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2), 'utf-8');
+}
+export function loadState() {
+    if (!existsSync(STATE_PATH))
+        return { files: {} };
+    try {
+        return JSON.parse(readFileSync(STATE_PATH, 'utf-8'));
+    }
+    catch {
+        return { files: {} };
+    }
+}
+export function saveState(state) {
+    ensureDir();
+    writeFileSync(STATE_PATH, JSON.stringify(state), 'utf-8');
+}
+export function getClaudeProjectsDir() {
+    return join(homedir(), '.claude', 'projects');
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+import { parseArgs } from 'node:util';
+const { values, positionals } = parseArgs({
+    args: process.argv.slice(2),
+    options: {
+        key: { type: 'string', short: 'k' },
+        'api-url': { type: 'string' },
+        help: { type: 'boolean', short: 'h' },
+    },
+    allowPositionals: true,
+    strict: false,
+});
+const command = (positionals[0] ?? 'help');
+async function main() {
+    if (values.help || command === 'help') {
+        console.log(`
+costpilot-scanner — local AI usage scanner for CostPilot
+
+Commands:
+  setup --key <pilot_live_...>   Configure with your CostPilot scanner key
+  start                          Start watching for AI usage (foreground process)
+
+Options:
+  --key, -k       CostPilot scanner key (from Developer Hub → Local Scanner)
+  --api-url       Override API base (default: https://api.aicostpilot.online)
+  --help, -h      Show this message
+
+Examples:
+  npx costpilot-scanner setup --key pilot_live_abc123
+  npx costpilot-scanner start
+`);
+        return;
+    }
+    if (command === 'setup') {
+        const { setupCommand } = await import('./commands/setup.js');
+        await setupCommand({
+            key: values.key,
+            apiUrl: values['api-url'],
+        });
+        return;
+    }
+    if (command === 'start') {
+        const { startCommand } = await import('./commands/start.js');
+        await startCommand();
+        return;
+    }
+    console.error(`Unknown command: "${command}". Run costpilot-scanner help`);
+    process.exit(1);
+}
+main().catch((err) => {
+    console.error('Fatal:', err.message);
+    process.exit(1);
+});

package/dist/parsers/claude-code.d.ts

@@ -0,0 +1,11 @@
+export interface ClaudeCodeEvent {
+    model: string;
+    sessionId: string;
+    lineIndex: number;
+    inputTokens: number;
+    outputTokens: number;
+    cacheCreationTokens: number;
+    cacheReadTokens: number;
+    timestamp?: string;
+}
+export declare function parseClaudeCodeLine(line: string, sessionId: string, lineIndex: number): ClaudeCodeEvent | null;

package/dist/parsers/claude-code.js

@@ -0,0 +1,35 @@
+export function parseClaudeCodeLine(line, sessionId, lineIndex) {
+    let entry;
+    try {
+        entry = JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+    if (entry.type !== 'assistant')
+        return null;
+    const message = entry.message;
+    if (!message)
+        return null;
+    const model = message.model ?? 'unknown';
+    const usage = message.usage;
+    if (!usage)
+        return null;
+    const inputTokens = usage.input_tokens ?? 0;
+    const outputTokens = usage.output_tokens ?? 0;
+    const cacheCreationTokens = usage.cache_creation_input_tokens ?? 0;
+    const cacheReadTokens = usage.cache_read_input_tokens ?? 0;
+    // Skip entries with no useful token data
+    if (inputTokens === 0 && outputTokens === 0)
+        return null;
+    return {
+        model,
+        sessionId,
+        lineIndex,
+        inputTokens,
+        outputTokens,
+        cacheCreationTokens,
+        cacheReadTokens,
+        timestamp: entry.timestamp,
+    };
+}

package/dist/watcher.d.ts

@@ -0,0 +1,2 @@
+import { type ScannerConfig } from './config.js';
+export declare function startWatcher(cfg: ScannerConfig): Promise<void>;

package/dist/watcher.js

@@ -0,0 +1,104 @@
+import { readdirSync, statSync, readFileSync, existsSync } from 'node:fs';
+import { join, basename } from 'node:path';
+import { hostname } from 'node:os';
+import { loadState, saveState, getClaudeProjectsDir, } from './config.js';
+import { parseClaudeCodeLine } from './parsers/claude-code.js';
+import { ingest, heartbeat } from './api.js';
+const POLL_MS = 30_000; // scan every 30s
+const HEARTBEAT_MS = 2 * 60_000; // heartbeat every 2min
+const VERSION = '0.1.0';
+function findJsonlFiles(dir) {
+    if (!existsSync(dir))
+        return [];
+    const files = [];
+    try {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+            if (!entry.isDirectory())
+                continue;
+            const sub = join(dir, entry.name);
+            for (const f of readdirSync(sub)) {
+                if (f.endsWith('.jsonl'))
+                    files.push(join(sub, f));
+            }
+        }
+    }
+    catch { /* unreadable dir */ }
+    return files;
+}
+async function processFile(filePath, state, cfg, counters) {
+    let size;
+    try {
+        size = statSync(filePath).size;
+    }
+    catch {
+        return;
+    }
+    const prev = state.files[filePath] ?? { bytesRead: 0, lineIndex: 0 };
+    if (size <= prev.bytesRead)
+        return; // no new bytes
+    const sessionId = basename(filePath, '.jsonl');
+    let content;
+    try {
+        content = readFileSync(filePath, 'utf-8');
+    }
+    catch {
+        return;
+    }
+    const lines = content.split('\n');
+    for (let i = prev.lineIndex; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (!line)
+            continue;
+        const event = parseClaudeCodeLine(line, sessionId, i);
+        if (!event)
+            continue;
+        const ok = await ingest(cfg, {
+            source: 'local-scanner',
+            model: event.model,
+            eventId: `${sessionId}:${i}`,
+            inputTokens: event.inputTokens,
+            outputTokens: event.outputTokens,
+            cacheCreationTokens: event.cacheCreationTokens || undefined,
+            cacheReadTokens: event.cacheReadTokens || undefined,
+            sessionId,
+            agentTool: 'claude-code',
+            timestamp: event.timestamp,
+        });
+        if (ok)
+            counters.sent++;
+        else
+            counters.errors++;
+    }
+    state.files[filePath] = { bytesRead: size, lineIndex: lines.length };
+}
+export async function startWatcher(cfg) {
+    const projectsDir = getClaudeProjectsDir();
+    const counters = { sent: 0, errors: 0 };
+    let lastHeartbeat = 0;
+    console.log(`[costpilot-scanner] v${VERSION} — watching ${projectsDir}`);
+    console.log('[costpilot-scanner] Press Ctrl+C to stop\n');
+    async function poll() {
+        const state = loadState();
+        for (const file of findJsonlFiles(projectsDir)) {
+            await processFile(file, state, cfg, counters);
+        }
+        saveState(state);
+        const now = Date.now();
+        if (now - lastHeartbeat > HEARTBEAT_MS) {
+            lastHeartbeat = now;
+            const tools = existsSync(projectsDir) ? ['claude-code'] : [];
+            await heartbeat(cfg, {
+                source: 'local-scanner',
+                version: VERSION,
+                hostname: hostname(),
+                toolsDetected: tools,
+                eventsLast24h: counters.sent,
+                errorsLast24h: counters.errors,
+            });
+            process.stdout.write(`[costpilot-scanner] heartbeat — ${counters.sent} events sent, ${counters.errors} errors\n`);
+        }
+    }
+    // Run immediately on start
+    await poll();
+    setInterval(() => { poll().catch(console.error); }, POLL_MS);
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "costpilot-scanner",
+  "version": "0.1.0",
+  "description": "CostPilot local scanner — watches Claude Code, Cursor, and Windsurf usage and syncs to CostPilot",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "costpilot-scanner": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/solemn-cap/ai-cost-pilot.git"
+  },
+  "homepage": "https://aicostpilot.online",
+  "keywords": ["claude-code", "ai", "cost", "scanner", "tracking", "costpilot"],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.12",
+    "tsx": "^4.16.2",
+    "typescript": "^5.5.4"
+  }
+}