muonroi-cli 1.3.4 → 1.4.1

package/src/cli/cost-forensics.ts

@@ -1,264 +0,0 @@
-/**
- * src/cli/cost-forensics.ts
- *
- * `muonroi-cli usage forensics <session-id-prefix>` — per-event cost
- * breakdown for a single session, joining usage_events with
- * interaction_logs to surface which user prompt triggered which billed
- * input. Built to verify Phase A/B/C cost-optimization wins — e.g.
- * confirm that sub-agent context no longer balloons past 80k input
- * after the cumulative cap kicks in.
- */
-
-import { getProviderCapabilities } from "../providers/capabilities.js";
-import { detectProviderForModel } from "../providers/runtime.js";
-import { getDatabase } from "../storage/db.js";
-
-export interface CostForensicsRow {
-  id: number;
-  source: string;
-  model: string;
-  messageSeq: number | null;
-  inputTokens: number;
-  outputTokens: number;
-  cacheReadTokens: number;
-  cacheCreationTokens: number;
-  costMicros: number;
-  createdAt: string;
-  /** Phase O1 — JSON-shape of providerOptions on this call (types only). */
-  providerOptionsShape: string | null;
-}
-
-export interface CostForensicsSummary {
-  sessionId: string;
-  rowCount: number;
-  userPromptCount: number;
-  toolCallCount: number;
-  totalInput: number;
-  totalOutput: number;
-  totalCacheRead: number;
-  totalCacheCreation: number;
-  totalCostUsd: number;
-  cacheHitRatio: number;
-  peakSingleCallInput: number;
-  events: CostForensicsRow[];
-}
-
-interface UsageRow {
-  id: number;
-  source: string;
-  model: string;
-  message_seq: number | null;
-  input_tokens: number;
-  output_tokens: number;
-  cache_read_tokens: number;
-  cache_creation_tokens: number;
-  cost_micros: number;
-  created_at: string;
-  provider_options_shape: string | null;
-}
-
-interface SessionRow {
-  id: string;
-  model: string;
-  created_at: string;
-}
-
-interface InteractionCountRow {
-  event_type: string;
-  c: number;
-}
-
-function resolveSessionId(prefix: string): string | null {
-  const rows = getDatabase()
-    .prepare(`SELECT id FROM sessions WHERE id LIKE ? ORDER BY created_at DESC LIMIT 5`)
-    .all(`${prefix}%`) as Array<{ id: string }>;
-  if (rows.length === 0) return null;
-  if (rows.length === 1) return rows[0]!.id;
-  process.stderr.write(`Ambiguous prefix '${prefix}' matched ${rows.length} sessions:\n`);
-  for (const r of rows) process.stderr.write(`  ${r.id}\n`);
-  return null;
-}
-
-export function collectCostForensics(sessionId: string): CostForensicsSummary {
-  const db = getDatabase();
-
-  const session = db.prepare(`SELECT id, model, created_at FROM sessions WHERE id = ?`).get(sessionId) as
-    | SessionRow
-    | undefined;
-  if (!session) throw new Error(`Session not found: ${sessionId}`);
-
-  const rows = db
-    .prepare(`
-    SELECT id, source, model, message_seq, input_tokens, output_tokens,
-           cache_read_tokens, cache_creation_tokens, cost_micros, created_at,
-           provider_options_shape
-    FROM usage_events
-    WHERE session_id = ?
-    ORDER BY id ASC
-  `)
-    .all(sessionId) as UsageRow[];
-
-  const counts = db
-    .prepare(`
-    SELECT event_type, COUNT(*) AS c
-    FROM interaction_logs
-    WHERE session_id = ?
-    GROUP BY event_type
-  `)
-    .all(sessionId) as InteractionCountRow[];
-
-  const countMap = new Map(counts.map((r) => [r.event_type, r.c]));
-
-  const events: CostForensicsRow[] = rows.map((r) => ({
-    id: r.id,
-    source: r.source,
-    model: r.model,
-    messageSeq: r.message_seq,
-    inputTokens: r.input_tokens,
-    outputTokens: r.output_tokens,
-    cacheReadTokens: r.cache_read_tokens,
-    cacheCreationTokens: r.cache_creation_tokens,
-    costMicros: r.cost_micros,
-    createdAt: r.created_at,
-    providerOptionsShape: r.provider_options_shape,
-  }));
-
-  let totalInput = 0;
-  let totalOutput = 0;
-  let totalCacheRead = 0;
-  let totalCacheCreation = 0;
-  let totalCostMicros = 0;
-  let peakSingleCallInput = 0;
-  for (const e of events) {
-    totalInput += e.inputTokens;
-    totalOutput += e.outputTokens;
-    totalCacheRead += e.cacheReadTokens;
-    totalCacheCreation += e.cacheCreationTokens;
-    totalCostMicros += e.costMicros;
-    if (e.inputTokens > peakSingleCallInput) peakSingleCallInput = e.inputTokens;
-  }
-  const cacheable = totalInput;
-  const cacheHitRatio = cacheable > 0 ? totalCacheRead / cacheable : 0;
-
-  return {
-    sessionId,
-    rowCount: events.length,
-    userPromptCount: countMap.get("user_message") ?? 0,
-    toolCallCount: countMap.get("tool_call") ?? 0,
-    totalInput,
-    totalOutput,
-    totalCacheRead,
-    totalCacheCreation,
-    totalCostUsd: totalCostMicros / 1_000_000,
-    cacheHitRatio,
-    peakSingleCallInput,
-    events,
-  };
-}
-
-function formatNum(n: number): string {
-  return n.toLocaleString("en-US");
-}
-
-function formatPct(n: number): string {
-  return `${(n * 100).toFixed(1)}%`;
-}
-
-export function printCostForensics(summary: CostForensicsSummary, opts: { json?: boolean } = {}): void {
-  if (opts.json) {
-    process.stdout.write(`${JSON.stringify(summary, null, 2)}\n`);
-    return;
-  }
-
-  const w = (s: string) => process.stdout.write(`${s}\n`);
-  w(``);
-  w(`Cost forensics — session ${summary.sessionId}`);
-  w(`${"─".repeat(72)}`);
-  w(`User prompts:        ${summary.userPromptCount}`);
-  w(`Tool calls (log):    ${summary.toolCallCount}`);
-  w(`LLM events:          ${summary.rowCount}`);
-  w(``);
-  w(`Total input tokens:  ${formatNum(summary.totalInput)}`);
-  w(`Total output tokens: ${formatNum(summary.totalOutput)}`);
-  w(`Cache read tokens:   ${formatNum(summary.totalCacheRead)} (${formatPct(summary.cacheHitRatio)} of input)`);
-  w(`Cache create tokens: ${formatNum(summary.totalCacheCreation)}`);
-  w(`Peak single call:    ${formatNum(summary.peakSingleCallInput)} input`);
-  w(`Estimated cost:      $${summary.totalCostUsd.toFixed(4)}`);
-  w(``);
-  w(`Per-event breakdown:`);
-  w(
-    `${"seq".padEnd(5)}${"src".padEnd(10)}${"input".padStart(9)}${"out".padStart(7)}${"cacheR".padStart(9)}${"cacheC".padStart(8)}  ts`,
-  );
-  for (const e of summary.events) {
-    const seq = e.messageSeq === null ? "-" : String(e.messageSeq);
-    w(
-      `${seq.padEnd(5)}${e.source.padEnd(10)}${formatNum(e.inputTokens).padStart(9)}${formatNum(e.outputTokens).padStart(7)}${formatNum(e.cacheReadTokens).padStart(9)}${formatNum(e.cacheCreationTokens).padStart(8)}  ${e.createdAt}`,
-    );
-  }
-  w(``);
-
-  // Phase O1 — providerOptions shapes per event (types only, no values).
-  // Surface so post-mortem can answer "what providerOptions did this call carry?"
-  const shapedEvents = summary.events.filter((e) => e.providerOptionsShape);
-  if (shapedEvents.length > 0) {
-    w(`providerOptions shape (types only):`);
-    for (const e of shapedEvents) {
-      const seq = e.messageSeq === null ? "-" : String(e.messageSeq);
-      w(`  [seq=${seq.padEnd(4)} src=${e.source.padEnd(8)}] ${e.providerOptionsShape}`);
-    }
-    w(``);
-  }
-
-  // Acceptance hints — surface anomalies relative to Phase A/B/C targets.
-  const anomalies: string[] = [];
-  if (summary.peakSingleCallInput > 80_000) {
-    anomalies.push(
-      `peak single-call input ${formatNum(summary.peakSingleCallInput)} > 80,000 — sub-agent cap may not have kicked in (Phase B target breach)`,
-    );
-  }
-  if (summary.events.some((e) => e.messageSeq === null && e.source === "message")) {
-    anomalies.push(
-      `some 'message' events have NULL message_seq — Phase A5 message write-ahead bypassed (check persistMessageWriteAhead wiring)`,
-    );
-  }
-  // C1 acceptance check: only count DeepSeek-cache-layout events. Earlier
-  // versions fired whenever ANY event in the session was deepseek
-  // (council/compaction side-calls could trigger the warning on otherwise-pure
-  // OAuth sessions). Now we scope the check to providers whose cache metric
-  // layout matches DeepSeek's (`promptCacheHitTokens` read field, no
-  // creation_tokens emitted) — currently deepseek + siliconflow.
-  // Phase 12.2-G5: replaces literal `model.startsWith("deepseek")` with
-  // capability-driven detection so adding a new DeepSeek-shaped provider
-  // wires through automatically.
-  const deepseekCacheLayoutEvents = summary.events.filter((e) => {
-    const provider = detectProviderForModel(e.model);
-    return getProviderCapabilities(provider).cacheMetricLayout().readField === "promptCacheHitTokens";
-  });
-  if (deepseekCacheLayoutEvents.length > 0) {
-    const deepseekInput = deepseekCacheLayoutEvents.reduce((acc, e) => acc + (e.inputTokens ?? 0), 0);
-    const deepseekCacheCreate = deepseekCacheLayoutEvents.reduce((acc, e) => acc + (e.cacheCreationTokens ?? 0), 0);
-    if (deepseekInput > 50_000 && deepseekCacheCreate === 0) {
-      anomalies.push(
-        `deepseek route has zero cache_creation_tokens across ${formatNum(deepseekInput)} deepseek input tokens — DeepSeek does not emit cache_creation (cache reads only); if this fires on a non-deepseek-dominant session, ignore`,
-      );
-    }
-  }
-  if (anomalies.length > 0) {
-    w(`Anomalies:`);
-    for (const a of anomalies) w(`  ⚠ ${a}`);
-    w(``);
-  } else {
-    w(`✓ No acceptance-target anomalies detected.`);
-    w(``);
-  }
-}
-
-export async function runCostForensics(opts: { prefix: string; json?: boolean }): Promise<void> {
-  const sessionId = resolveSessionId(opts.prefix);
-  if (!sessionId) {
-    process.exitCode = 1;
-    return;
-  }
-  const summary = collectCostForensics(sessionId);
-  printCostForensics(summary, { json: opts.json });
-}

package/src/cli/keys-bundle.ts

@@ -1,91 +0,0 @@
-/**
- * Portable encrypted key bundle (Option B from UX redesign 2026-05-21).
- *
- * Goal: move all provider keys between devices via a single passphrase-encrypted
- * file. No Bitwarden, no cloud, no extra deps — just Node crypto.
- *
- * Format (JSON):
- *   { v:1, kdf:"scrypt", salt:hex, iv:hex, tag:hex, ct:base64 }
- *
- * Plaintext payload (JSON): { providers: { deepseek: "sk-...", siliconflow: "sf-..." } }
- *
- * Crypto:
- *   - scrypt(passphrase, salt, 32) → 256-bit key
- *   - aes-256-gcm, 12-byte iv, 16-byte tag
- */
-
-import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from "node:crypto";
-
-export interface KeyBundleV1 {
-  v: 1;
-  kdf: "scrypt";
-  salt: string; // hex
-  iv: string; // hex
-  tag: string; // hex
-  ct: string; // base64 ciphertext
-}
-
-export interface BundlePayload {
-  providers: Record<string, string>;
-}
-
-const SCRYPT_N = 1 << 15; // 32768 — moderate cost, ~50ms
-const SCRYPT_R = 8;
-const SCRYPT_P = 1;
-const KEY_LEN = 32;
-const IV_LEN = 12;
-
-function deriveKey(passphrase: string, salt: Buffer): Buffer {
-  // Memory cost = 128 * N * r ≈ 33MB with these params; bump maxmem above
-  // Node's 32MB default so scryptSync doesn't throw on Windows/Linux.
-  return scryptSync(passphrase, salt, KEY_LEN, {
-    N: SCRYPT_N,
-    r: SCRYPT_R,
-    p: SCRYPT_P,
-    maxmem: 64 * 1024 * 1024,
-  });
-}
-
-export function encryptBundle(payload: BundlePayload, passphrase: string): KeyBundleV1 {
-  if (!passphrase || passphrase.length < 8) {
-    throw new Error("Passphrase must be at least 8 characters.");
-  }
-  const salt = randomBytes(16);
-  const iv = randomBytes(IV_LEN);
-  const key = deriveKey(passphrase, salt);
-  const cipher = createCipheriv("aes-256-gcm", key, iv);
-  const plaintext = Buffer.from(JSON.stringify(payload), "utf8");
-  const ct = Buffer.concat([cipher.update(plaintext), cipher.final()]);
-  const tag = cipher.getAuthTag();
-  return {
-    v: 1,
-    kdf: "scrypt",
-    salt: salt.toString("hex"),
-    iv: iv.toString("hex"),
-    tag: tag.toString("hex"),
-    ct: ct.toString("base64"),
-  };
-}
-
-export function decryptBundle(bundle: KeyBundleV1, passphrase: string): BundlePayload {
-  if (bundle.v !== 1) throw new Error(`Unsupported bundle version: ${bundle.v}`);
-  if (bundle.kdf !== "scrypt") throw new Error(`Unsupported KDF: ${bundle.kdf}`);
-  const salt = Buffer.from(bundle.salt, "hex");
-  const iv = Buffer.from(bundle.iv, "hex");
-  const tag = Buffer.from(bundle.tag, "hex");
-  const ct = Buffer.from(bundle.ct, "base64");
-  const key = deriveKey(passphrase, salt);
-  const decipher = createDecipheriv("aes-256-gcm", key, iv);
-  decipher.setAuthTag(tag);
-  let pt: Buffer;
-  try {
-    pt = Buffer.concat([decipher.update(ct), decipher.final()]);
-  } catch {
-    throw new Error("Decryption failed — wrong passphrase or corrupted bundle.");
-  }
-  const parsed = JSON.parse(pt.toString("utf8")) as BundlePayload;
-  if (!parsed || typeof parsed !== "object" || !parsed.providers) {
-    throw new Error("Invalid bundle payload shape.");
-  }
-  return parsed;
-}

package/src/cli/keys.test.ts

@@ -1,104 +0,0 @@
-import { promises as fs } from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-describe("runKeysCleanupSettings", () => {
-  let tmpHome: string;
-  let originalHome: string | undefined;
-  let originalUserprofile: string | undefined;
-
-  beforeEach(async () => {
-    tmpHome = await fs.mkdtemp(path.join(os.tmpdir(), "muonroi-keys-"));
-    await fs.mkdir(path.join(tmpHome, ".muonroi-cli"), { recursive: true });
-    originalHome = process.env.HOME;
-    originalUserprofile = process.env.USERPROFILE;
-    process.env.HOME = tmpHome;
-    process.env.USERPROFILE = tmpHome;
-    vi.resetModules();
-  });
-
-  afterEach(async () => {
-    if (originalHome === undefined) delete process.env.HOME;
-    else process.env.HOME = originalHome;
-    if (originalUserprofile === undefined) delete process.env.USERPROFILE;
-    else process.env.USERPROFILE = originalUserprofile;
-    await fs.rm(tmpHome, { recursive: true, force: true });
-    vi.restoreAllMocks();
-  });
-
-  it("strips top-level apiKey and providers.*.apiKey, drops empty provider blocks", async () => {
-    const settingsPath = path.join(tmpHome, ".muonroi-cli", "user-settings.json");
-    await fs.writeFile(
-      settingsPath,
-      JSON.stringify(
-        {
-          apiKey: "sk-leaked-top",
-          defaultModel: "deepseek-v4-flash",
-          providers: {
-            deepseek: { apiKey: "sk-leaked-ds" },
-            anthropic: { apiKey: "sk-leaked-an", baseURL: "https://example" },
-          },
-          mcp: { servers: [] },
-        },
-        null,
-        2,
-      ),
-    );
-
-    const { runKeysCleanupSettings } = await import("./keys.js");
-    // Capture stdout — runKeysCleanupSettings writes the backup path which we don't want in test output.
-    const logSpy = vi.spyOn(console, "log").mockImplementation(() => {});
-    await runKeysCleanupSettings();
-    logSpy.mockRestore();
-
-    const cleaned = JSON.parse(await fs.readFile(settingsPath, "utf8"));
-    expect(cleaned.apiKey).toBeUndefined();
-    expect(cleaned.providers?.deepseek).toBeUndefined(); // empty block dropped
-    expect(cleaned.providers?.anthropic?.apiKey).toBeUndefined();
-    expect(cleaned.providers?.anthropic?.baseURL).toBe("https://example");
-    expect(cleaned.defaultModel).toBe("deepseek-v4-flash");
-    expect(cleaned.mcp).toBeDefined();
-
-    // A backup with timestamp suffix should exist.
-    const dirEntries = await fs.readdir(path.join(tmpHome, ".muonroi-cli"));
-    expect(dirEntries.some((f) => f.startsWith("user-settings.json.bak."))).toBe(true);
-  });
-
-  it("drops the providers map entirely when all provider blocks become empty", async () => {
-    const settingsPath = path.join(tmpHome, ".muonroi-cli", "user-settings.json");
-    await fs.writeFile(
-      settingsPath,
-      JSON.stringify({
-        defaultModel: "x",
-        providers: {
-          deepseek: { apiKey: "sk-1234567890123456789012" },
-          anthropic: { apiKey: "sk-ant-1234567890123456789012" },
-        },
-      }),
-    );
-
-    const { runKeysCleanupSettings } = await import("./keys.js");
-    const logSpy = vi.spyOn(console, "log").mockImplementation(() => {});
-    await runKeysCleanupSettings();
-    logSpy.mockRestore();
-
-    const cleaned = JSON.parse(await fs.readFile(settingsPath, "utf8"));
-    expect(cleaned.providers).toBeUndefined();
-    expect(cleaned.defaultModel).toBe("x");
-  });
-
-  it("is a no-op if the settings file is already clean", async () => {
-    const settingsPath = path.join(tmpHome, ".muonroi-cli", "user-settings.json");
-    const original = { defaultModel: "y", roleModels: { leader: "y" } };
-    await fs.writeFile(settingsPath, JSON.stringify(original));
-
-    const { runKeysCleanupSettings } = await import("./keys.js");
-    const logSpy = vi.spyOn(console, "log").mockImplementation(() => {});
-    await runKeysCleanupSettings();
-    logSpy.mockRestore();
-
-    const cleaned = JSON.parse(await fs.readFile(settingsPath, "utf8"));
-    expect(cleaned).toEqual(original);
-  });
-});