loopers-token-cli 0.1.0

package/dist/api.js

@@ -0,0 +1,26 @@
+import { IngestPayload } from './schema.js';
+export const CLI_VERSION = '0.1.0';
+/** 전송 직전 페이로드를 스키마로 build(검증 + 스키마 외 필드 제거) */
+export function buildPayload(config, stats) {
+    // parse는 스키마에 정의된 필드만 남기고 나머지를 제거한다 → 개인정보 차단.
+    return IngestPayload.parse({
+        schemaVersion: 1,
+        deviceId: config.deviceId,
+        nickname: config.nickname,
+        team: config.team,
+        cliVersion: CLI_VERSION,
+        stats,
+    });
+}
+export async function sendPayload(config, payload) {
+    const res = await fetch(config.endpoint, {
+        method: 'POST',
+        headers: {
+            'content-type': 'application/json',
+            'x-enroll-key': config.enrollKey,
+        },
+        body: JSON.stringify(payload),
+    });
+    const body = await res.text();
+    return { ok: res.ok, status: res.status, body };
+}

package/dist/collect.js

@@ -0,0 +1,96 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { readdir, stat } from 'node:fs/promises';
+import { aggregateFile, mergeBuckets } from './scanner.js';
+export const CLAUDE_PROJECTS_DIR = join(homedir(), '.claude', 'projects');
+/** 오늘(UTC) 일자 'YYYY-MM-DD'. Claude Code timestamp가 UTC이므로 UTC 기준으로 맞춘다. */
+export function todayUtc(now) {
+    return now.toISOString().slice(0, 10);
+}
+/** ~/.claude/projects/**\/*.jsonl 전체 경로 수집 */
+async function findSessionFiles() {
+    const out = [];
+    let entries;
+    try {
+        entries = await readdir(CLAUDE_PROJECTS_DIR);
+    }
+    catch {
+        return out; // projects 디렉토리 없음
+    }
+    for (const dir of entries) {
+        const full = join(CLAUDE_PROJECTS_DIR, dir);
+        let files;
+        try {
+            files = await readdir(full);
+        }
+        catch {
+            continue;
+        }
+        for (const f of files) {
+            if (f.endsWith('.jsonl'))
+                out.push(join(full, f));
+        }
+    }
+    return out;
+}
+/**
+ * 스캔으로 stats 배열을 만든다.
+ *
+ * 전략(단순·견고):
+ *  1. mtime이 state와 같은 파일은 스킵(이미 처리됨).
+ *  2. 변경(또는 신규) 파일은 항상 처음부터(offset 0) 전체 재집계한다.
+ *     세션 파일은 보통 작아 재파싱 비용이 미미하고, 파일이 날짜 경계를 넘겨도
+ *     과거 일자 데이터가 누락되지 않는다.
+ *  3. dedupe는 파일(세션) 단위 Set으로 수행(message.id는 세션 단위 유일).
+ *
+ * 멱등성은 서버의 (device,date,model) 절대값 upsert가 보장한다. 같은 파일을
+ * N번 재집계해 보내도 결과는 동일하다.
+ *
+ * byteOffset 필드는 스키마 호환을 위해 유지하되 항상 0으로 둔다(전체 재집계 방식).
+ */
+export async function collect(prevState, now) {
+    const files = await findSessionFiles();
+    const aggregated = new Map();
+    const nextFiles = { ...prevState.files };
+    let filesChanged = 0;
+    for (const filePath of files) {
+        let st;
+        try {
+            st = await stat(filePath);
+        }
+        catch {
+            continue;
+        }
+        const prev = prevState.files[filePath];
+        if (prev && prev.mtimeMs === st.mtimeMs)
+            continue; // 변경 없음
+        filesChanged++;
+        const seen = new Set();
+        const res = await aggregateFile(filePath, 0, seen);
+        mergeBuckets(aggregated, res.buckets);
+        nextFiles[filePath] = { byteOffset: 0, mtimeMs: st.mtimeMs };
+    }
+    const stats = [];
+    for (const [key, sums] of aggregated) {
+        const [date, model] = key.split('|');
+        stats.push({
+            date,
+            model,
+            inputTokens: sums.inputTokens,
+            outputTokens: sums.outputTokens,
+            cacheCreationInputTokens: sums.cacheCreationInputTokens,
+            cacheReadInputTokens: sums.cacheReadInputTokens,
+            messageCount: sums.messageCount,
+        });
+    }
+    return {
+        stats,
+        nextState: {
+            version: 1,
+            files: nextFiles,
+            lastSyncedAt: now.toISOString(),
+        },
+        filesScanned: files.length,
+        filesChanged,
+    };
+}

package/dist/commands/init.js

@@ -0,0 +1,43 @@
+import { randomUUID } from 'node:crypto';
+import { createInterface } from 'node:readline/promises';
+import { stdin, stdout } from 'node:process';
+import { loadConfig, saveConfig, CONFIG_PATH } from '../config.js';
+const DEFAULT_ENDPOINT = 'https://loopers-token-dashboard.vercel.app/api/ingest';
+/** 비대화형(플래그) 또는 대화형으로 config를 생성/갱신한다. deviceId는 1회 생성 후 고정. */
+export async function runInit(opts) {
+    const existing = await loadConfig();
+    const rl = createInterface({ input: stdin, output: stdout });
+    const ask = async (q, fallback) => {
+        const suffix = fallback ? ` [${fallback}]` : '';
+        const ans = (await rl.question(`${q}${suffix}: `)).trim();
+        return ans || fallback || '';
+    };
+    try {
+        console.log('\n루퍼스 토큰 대시보드 — 초기 설정');
+        console.log('⚠️  닉네임/팀에 실명·이메일 등 개인정보를 넣지 마세요. 자유 라벨만 사용합니다.\n');
+        const nickname = opts.nickname ?? (await ask('닉네임', existing?.nickname));
+        const team = opts.team ?? (await ask('팀', existing?.team));
+        const endpoint = opts.endpoint ??
+            (await ask('서버 endpoint', existing?.endpoint ?? DEFAULT_ENDPOINT));
+        const enrollKey = opts.enrollKey ?? (await ask('등록 키(enroll key)', existing?.enrollKey));
+        if (!nickname || !team || !endpoint || !enrollKey) {
+            console.error('\n❌ 닉네임/팀/endpoint/등록 키는 모두 필요합니다.');
+            process.exitCode = 1;
+            return;
+        }
+        const config = {
+            deviceId: existing?.deviceId ?? randomUUID(),
+            nickname,
+            team,
+            endpoint,
+            enrollKey,
+        };
+        await saveConfig(config);
+        console.log(`\n✅ 설정 저장 완료: ${CONFIG_PATH}`);
+        console.log(`   deviceId: ${config.deviceId}`);
+        console.log('   이제 `loopers-token sync` 로 전송하세요.\n');
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/commands/sync.js

@@ -0,0 +1,47 @@
+import { loadConfig } from '../config.js';
+import { loadState, saveState } from '../state.js';
+import { collect } from '../collect.js';
+import { buildPayload, sendPayload } from '../api.js';
+import { totalTokens } from '../schema.js';
+export async function runSync(opts) {
+    const config = await loadConfig();
+    if (!config) {
+        console.error('❌ 설정이 없습니다. 먼저 `loopers-token init` 을 실행하세요.');
+        process.exitCode = 1;
+        return;
+    }
+    const log = (...a) => {
+        if (!opts.quiet)
+            console.log(...a);
+    };
+    const prevState = await loadState();
+    const now = new Date();
+    const { stats, nextState, filesScanned, filesChanged } = await collect(prevState, now);
+    if (stats.length === 0) {
+        log(`변경된 데이터 없음 (파일 ${filesScanned}개 스캔, ${filesChanged}개 변경). 전송 생략.`);
+        // 변경 파일이 있었으면(빈 결과여도) 커서는 갱신
+        if (filesChanged > 0)
+            await saveState(nextState);
+        return;
+    }
+    const payload = buildPayload(config, stats);
+    const grandTotal = stats.reduce((acc, s) => acc + totalTokens(s), 0);
+    const outTotal = stats.reduce((acc, s) => acc + s.outputTokens, 0);
+    log(`집계: ${stats.length} 버킷, 총 토큰 ${grandTotal.toLocaleString()} (output ${outTotal.toLocaleString()})`);
+    if (opts.dryRun) {
+        console.log('\n--- DRY RUN: 아래 페이로드를 전송할 예정입니다 (실제 전송 안 함) ---');
+        console.log(JSON.stringify(payload, null, 2));
+        console.log('--- 위 내용에 대화 원문/이름/이메일/cwd 가 없는지 확인하세요 ---\n');
+        return; // dry-run 은 state를 갱신하지 않는다
+    }
+    log(`전송 → ${config.endpoint}`);
+    const res = await sendPayload(config, payload);
+    if (res.ok) {
+        log(`✅ 전송 성공 (HTTP ${res.status}). ${res.body}`);
+        await saveState(nextState);
+    }
+    else {
+        console.error(`❌ 전송 실패 (HTTP ${res.status}). ${res.body}`);
+        process.exitCode = 1;
+    }
+}

package/dist/config.js

@@ -0,0 +1,23 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { mkdir, readFile, writeFile, chmod } from 'node:fs/promises';
+export const CONFIG_DIR = join(homedir(), '.config', 'loopers-token');
+export const CONFIG_PATH = join(CONFIG_DIR, 'config.json');
+export const STATE_PATH = join(CONFIG_DIR, 'state.json');
+export async function ensureConfigDir() {
+    await mkdir(CONFIG_DIR, { recursive: true, mode: 0o700 });
+}
+export async function loadConfig() {
+    try {
+        const raw = await readFile(CONFIG_PATH, 'utf8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export async function saveConfig(c) {
+    await ensureConfigDir();
+    await writeFile(CONFIG_PATH, JSON.stringify(c, null, 2), 'utf8');
+    await chmod(CONFIG_PATH, 0o600);
+}

package/dist/index.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { runInit } from './commands/init.js';
+import { runSync } from './commands/sync.js';
+import { CLI_VERSION } from './api.js';
+const program = new Command();
+program
+    .name('loopers-token')
+    .description('루퍼스 토큰 대시보드 수집 CLI — ~/.claude 세션의 토큰 집계값만 전송')
+    .version(CLI_VERSION);
+program
+    .command('init')
+    .description('닉네임/팀/서버 설정 (deviceId는 1회 생성 후 고정)')
+    .option('--nickname <name>', '닉네임 (실명/이메일 금지)')
+    .option('--team <team>', '팀 라벨')
+    .option('--endpoint <url>', '서버 ingest endpoint')
+    .option('--enroll-key <key>', '부트캠프 공통 등록 키')
+    .action((opts) => runInit({
+    nickname: opts.nickname,
+    team: opts.team,
+    endpoint: opts.endpoint,
+    enrollKey: opts.enrollKey,
+}));
+program
+    .command('sync')
+    .description('~/.claude 세션을 스캔해 집계값을 서버로 전송')
+    .option('--dry-run', '전송하지 않고 페이로드만 출력 (프라이버시 확인용)')
+    .option('--quiet', '로그 최소화 (자동 스케줄용)')
+    .action((opts) => runSync({ dryRun: opts.dryRun, quiet: opts.quiet }));
+program.parseAsync(process.argv);

package/dist/scanner.js

@@ -0,0 +1,94 @@
+import { createReadStream } from 'node:fs';
+import { createInterface } from 'node:readline';
+import { stat } from 'node:fs/promises';
+function zero() {
+    return {
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheCreationInputTokens: 0,
+        cacheReadInputTokens: 0,
+        messageCount: 0,
+    };
+}
+/**
+ * 한 .jsonl 세션 파일을 fromByteOffset부터 읽어 토큰을 집계한다.
+ *
+ * 핵심 규칙:
+ *  - type === 'assistant' 줄의 message.usage 만 본다.
+ *  - message.content 는 절대 파싱/접근하지 않는다 (프라이버시).
+ *  - message.id(없으면 requestId) 기준 dedupe — 동일 id 줄은 usage 값이
+ *    완전히 동일하게 복제되므로 한 번만 집계한다. (안 하면 ~1.9배 과다 집계)
+ *  - model === '<synthetic>' 줄은 제외.
+ *
+ * @param seenMessageIds 이 파일(세션) 내 이미 집계한 message.id 집합. 호출자가
+ *        파일 단위로 새로 만들어 넘긴다 (message.id는 세션 단위 유일).
+ */
+export async function aggregateFile(filePath, fromByteOffset, seenMessageIds) {
+    const buckets = new Map();
+    let maxTimestamp = null;
+    const { size } = await stat(filePath);
+    if (fromByteOffset >= size) {
+        return { buckets, newByteOffset: size, maxTimestamp };
+    }
+    const stream = createReadStream(filePath, {
+        start: fromByteOffset,
+        encoding: 'utf8',
+    });
+    const rl = createInterface({ input: stream, crlfDelay: Infinity });
+    for await (const line of rl) {
+        if (!line.trim())
+            continue;
+        let o;
+        try {
+            o = JSON.parse(line);
+        }
+        catch {
+            continue; // 잘린/손상된 줄 무시
+        }
+        if (o?.type !== 'assistant')
+            continue;
+        const m = o.message;
+        if (!m?.usage || !m.model)
+            continue;
+        if (m.model === '<synthetic>')
+            continue;
+        const id = m.id ?? o.requestId;
+        if (!id || seenMessageIds.has(id))
+            continue; // ★ dedupe
+        seenMessageIds.add(id);
+        const ts = o.timestamp;
+        const date = typeof ts === 'string' ? ts.slice(0, 10) : null;
+        if (!date)
+            continue;
+        if (!maxTimestamp || (ts && ts > maxTimestamp))
+            maxTimestamp = ts;
+        const key = `${date}|${m.model}`;
+        let b = buckets.get(key);
+        if (!b) {
+            b = zero();
+            buckets.set(key, b);
+        }
+        const u = m.usage;
+        b.inputTokens += u.input_tokens ?? 0;
+        b.outputTokens += u.output_tokens ?? 0;
+        b.cacheCreationInputTokens += u.cache_creation_input_tokens ?? 0;
+        b.cacheReadInputTokens += u.cache_read_input_tokens ?? 0;
+        b.messageCount += 1;
+    }
+    return { buckets, newByteOffset: size, maxTimestamp };
+}
+/** 두 버킷맵을 합산(in-place로 target에 source를 더한다) */
+export function mergeBuckets(target, source) {
+    for (const [key, s] of source) {
+        let t = target.get(key);
+        if (!t) {
+            t = zero();
+            target.set(key, t);
+        }
+        t.inputTokens += s.inputTokens;
+        t.outputTokens += s.outputTokens;
+        t.cacheCreationInputTokens += s.cacheCreationInputTokens;
+        t.cacheReadInputTokens += s.cacheReadInputTokens;
+        t.messageCount += s.messageCount;
+    }
+}

package/dist/schema.js

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+/**
+ * 수집 페이로드 스키마 — 프라이버시 차단의 구조적 근간.
+ * (apps/web 의 동일 스키마와 동기화 유지. CLI 단독 퍼블리시를 위해 인라인 복사본.)
+ *
+ * 여기에는 의도적으로 다음 필드가 존재하지 않는다:
+ *   - 원본 대화 내용(message.content)
+ *   - 이름 / 이메일 / API 키 / 토큰 등 개인·인증 정보
+ *   - cwd / gitBranch / sessionId 등 작업 맥락
+ */
+/** 'YYYY-MM-DD' 형식의 UTC 일자 */
+export const dateString = z
+    .string()
+    .regex(/^\d{4}-\d{2}-\d{2}$/, 'date must be YYYY-MM-DD');
+/** (날짜, 모델) 단위의 토큰 집계값 — 숫자만 담는다 */
+export const DailyModelStat = z.object({
+    date: dateString,
+    model: z.string().min(1).max(64),
+    inputTokens: z.number().int().nonnegative(),
+    outputTokens: z.number().int().nonnegative(),
+    cacheCreationInputTokens: z.number().int().nonnegative(),
+    cacheReadInputTokens: z.number().int().nonnegative(),
+    messageCount: z.number().int().nonnegative(),
+});
+/** 닉네임/팀 — 자유 라벨. 실명/이메일 입력 금지 */
+export const labelString = z.string().trim().min(1).max(32);
+/** CLI가 중앙 서버 POST /api/ingest 로 보내는 전체 페이로드 */
+export const IngestPayload = z.object({
+    schemaVersion: z.literal(1),
+    deviceId: z.string().uuid(),
+    nickname: labelString,
+    team: labelString,
+    cliVersion: z.string().max(20),
+    stats: z.array(DailyModelStat).max(2000),
+});
+/** 한 stat의 "총 토큰"(input + output + cacheCreation + cacheRead) */
+export function totalTokens(s) {
+    return (s.inputTokens +
+        s.outputTokens +
+        s.cacheCreationInputTokens +
+        s.cacheReadInputTokens);
+}
+export const SCHEMA_VERSION = 1;

package/dist/state.js

@@ -0,0 +1,22 @@
+import { readFile, writeFile, chmod } from 'node:fs/promises';
+import { STATE_PATH, ensureConfigDir } from './config.js';
+export function emptyState() {
+    return { version: 1, files: {}, lastSyncedAt: null };
+}
+export async function loadState() {
+    try {
+        const raw = await readFile(STATE_PATH, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (parsed?.version === 1 && parsed.files)
+            return parsed;
+        return emptyState();
+    }
+    catch {
+        return emptyState();
+    }
+}
+export async function saveState(s) {
+    await ensureConfigDir();
+    await writeFile(STATE_PATH, JSON.stringify(s), 'utf8');
+    await chmod(STATE_PATH, 0o600);
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "loopers-token-cli",
+  "version": "0.1.0",
+  "description": "루퍼스 토큰 대시보드 수집 CLI — ~/.claude 세션의 토큰 집계값만 전송",
+  "type": "module",
+  "bin": {
+    "loopers-token": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Loopers-dev-lab/loopers-token-dashboard.git",
+    "directory": "packages/cli"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "token",
+    "usage",
+    "dashboard",
+    "loopers"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "npm run build",
+    "start": "node --experimental-strip-types src/index.ts",
+    "dev": "node --experimental-strip-types src/index.ts"
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^22.5.0",
+    "typescript": "^5.5.4"
+  }
+}