storyforge 0.4.12 → 0.4.14

package/dist/cli-usage-OFFQXJQN.js

@@ -0,0 +1,237 @@
+#!/usr/bin/env node
+
+// src/cli-usage.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+var PRICES = {
+  // Anthropic — per claude.com/pricing (April 2026)
+  "claude-opus-4-7": { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
+  "claude-opus-4-6": { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
+  "claude-opus-4-5": { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
+  "claude-sonnet-4-6": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  "claude-sonnet-4-5": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  "claude-haiku-4-5": { input: 1, output: 5, cacheRead: 0.1, cacheWrite: 1.25 },
+  // OpenAI — per platform.openai.com/pricing (April 2026)
+  "gpt-5.5": { input: 5, output: 30 },
+  "gpt-5.4": { input: 2.5, output: 15 },
+  "gpt-5.4-mini": { input: 0.75, output: 4.5 },
+  "gpt-5.4-nano": { input: 0.2, output: 1.25 },
+  "gpt-5": { input: 2.5, output: 15 },
+  "gpt-5-codex": { input: 2.5, output: 15 },
+  // alias of gpt-5
+  "gpt-4o": { input: 2.5, output: 10 }
+};
+function priceFor(model) {
+  const lower = model.toLowerCase();
+  if (PRICES[lower]) return PRICES[lower];
+  for (const key of Object.keys(PRICES)) {
+    if (lower.startsWith(key)) return PRICES[key];
+  }
+  return null;
+}
+function emptyModelUsage(model) {
+  return { model, inputTokens: 0, cachedReadTokens: 0, cacheCreateTokens: 0, outputTokens: 0, costUsd: 0 };
+}
+function addUsage(target, model, delta) {
+  const row = target[model] ??= emptyModelUsage(model);
+  if (delta.inputTokens) row.inputTokens += delta.inputTokens;
+  if (delta.cachedReadTokens) row.cachedReadTokens += delta.cachedReadTokens;
+  if (delta.cacheCreateTokens) row.cacheCreateTokens += delta.cacheCreateTokens;
+  if (delta.outputTokens) row.outputTokens += delta.outputTokens;
+}
+function recompute(usage) {
+  const price = priceFor(usage.model);
+  if (!price) return { ...usage, costUsd: 0 };
+  const inputCost = usage.inputTokens / 1e6 * price.input;
+  const cacheReadCost = price.cacheRead != null ? usage.cachedReadTokens / 1e6 * price.cacheRead : 0;
+  const cacheWriteCost = price.cacheWrite != null ? usage.cacheCreateTokens / 1e6 * price.cacheWrite : 0;
+  const outputCost = usage.outputTokens / 1e6 * price.output;
+  return { ...usage, costUsd: inputCost + cacheReadCost + cacheWriteCost + outputCost };
+}
+function listJsonlFiles(rootDir) {
+  const out = [];
+  if (!fs.existsSync(rootDir)) return out;
+  const stack = [rootDir];
+  while (stack.length > 0) {
+    const cur = stack.pop();
+    let entries;
+    try {
+      entries = fs.readdirSync(cur, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const e of entries) {
+      const full = path.join(cur, e.name);
+      if (e.isDirectory()) stack.push(full);
+      else if (e.isFile() && e.name.endsWith(".jsonl")) out.push(full);
+    }
+  }
+  return out;
+}
+function parseClaudeFile(file) {
+  let content;
+  try {
+    content = fs.readFileSync(file, "utf-8");
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const raw of content.split(/\r?\n/)) {
+    if (!raw.trim()) continue;
+    let obj;
+    try {
+      obj = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+    const usage = obj?.message?.usage;
+    if (!usage) continue;
+    const model = String(obj?.message?.model ?? "").toLowerCase();
+    if (!model) continue;
+    const tsRaw = obj?.timestamp ?? obj?.ts;
+    const ts = tsRaw ? new Date(tsRaw).getTime() : Date.now();
+    if (!Number.isFinite(ts)) continue;
+    out.push({
+      ts,
+      model,
+      delta: {
+        inputTokens: usage.input_tokens ?? 0,
+        cachedReadTokens: usage.cache_read_input_tokens ?? 0,
+        cacheCreateTokens: usage.cache_creation_input_tokens ?? 0,
+        outputTokens: usage.output_tokens ?? 0
+      }
+    });
+  }
+  return out;
+}
+function parseCodexFile(file) {
+  let content;
+  try {
+    content = fs.readFileSync(file, "utf-8");
+  } catch {
+    return [];
+  }
+  const out = [];
+  let prev = { input: 0, cachedInput: 0, output: 0, total: 0 };
+  let model = "gpt-5";
+  for (const raw of content.split(/\r?\n/)) {
+    if (!raw.trim()) continue;
+    let obj;
+    try {
+      obj = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+    const modelHint = obj?.event_msg?.payload?.turn_context?.model ?? obj?.payload?.turn_context?.model ?? obj?.message?.model;
+    if (typeof modelHint === "string" && modelHint) model = modelHint.toLowerCase();
+    const payload = obj?.event_msg?.payload ?? obj?.payload;
+    if (!payload) continue;
+    if (payload.type !== "token_count") continue;
+    const t = payload;
+    const cur = {
+      input: t.input_tokens ?? 0,
+      cachedInput: t.cached_input_tokens ?? 0,
+      output: t.output_tokens ?? 0,
+      total: t.total_tokens ?? 0
+    };
+    const delta = {
+      inputTokens: Math.max(0, cur.input - prev.input),
+      cachedReadTokens: Math.max(0, cur.cachedInput - prev.cachedInput),
+      outputTokens: Math.max(0, cur.output - prev.output)
+    };
+    prev = cur;
+    const tsRaw = obj?.timestamp ?? obj?.event_msg?.timestamp ?? obj?.event_msg?.event_ts;
+    const ts = tsRaw ? new Date(tsRaw).getTime() : Date.now();
+    if (!Number.isFinite(ts)) continue;
+    out.push({ ts, model, delta });
+  }
+  return out;
+}
+function startOfTodayMs(now = Date.now()) {
+  const d = new Date(now);
+  d.setHours(0, 0, 0, 0);
+  return d.getTime();
+}
+async function gatherCliUsage() {
+  const home = os.homedir();
+  const claudeDir = path.join(home, ".claude", "projects");
+  const codexDir = path.join(home, ".codex", "sessions");
+  const claudeFiles = listJsonlFiles(claudeDir);
+  const codexFiles = listJsonlFiles(codexDir);
+  let skipped = 0;
+  const lines = [];
+  for (const f of claudeFiles) {
+    const parsed = parseClaudeFile(f);
+    if (parsed.length === 0) skipped++;
+    else lines.push(...parsed);
+  }
+  for (const f of codexFiles) {
+    const parsed = parseCodexFile(f);
+    if (parsed.length === 0) skipped++;
+    else lines.push(...parsed);
+  }
+  const now = Date.now();
+  const cutoff5h = now - 5 * 60 * 60 * 1e3;
+  const cutoff24h = now - 24 * 60 * 60 * 1e3;
+  const cutoff7d = now - 7 * 24 * 60 * 60 * 1e3;
+  const startToday = startOfTodayMs(now);
+  const messageCounts = { last5h: 0, last24h: 0, last7d: 0, today: 0, lifetime: 0 };
+  const buckets = {
+    last5h: {},
+    last24h: {},
+    last7d: {},
+    today: {},
+    lifetime: {}
+  };
+  for (const ln of lines) {
+    addUsage(buckets.lifetime, ln.model, ln.delta);
+    messageCounts.lifetime++;
+    if (ln.ts >= cutoff7d) {
+      addUsage(buckets.last7d, ln.model, ln.delta);
+      messageCounts.last7d++;
+    }
+    if (ln.ts >= cutoff24h) {
+      addUsage(buckets.last24h, ln.model, ln.delta);
+      messageCounts.last24h++;
+    }
+    if (ln.ts >= cutoff5h) {
+      addUsage(buckets.last5h, ln.model, ln.delta);
+      messageCounts.last5h++;
+    }
+    if (ln.ts >= startToday) {
+      addUsage(buckets.today, ln.model, ln.delta);
+      messageCounts.today++;
+    }
+  }
+  function finalise(rec) {
+    return Object.values(rec).map(recompute).sort((a, b) => b.costUsd - a.costUsd);
+  }
+  const last5h = finalise(buckets.last5h);
+  const last24h = finalise(buckets.last24h);
+  const last7d = finalise(buckets.last7d);
+  const today = finalise(buckets.today);
+  const lifetime = finalise(buckets.lifetime);
+  function sum(rows, messages) {
+    return {
+      tokens: rows.reduce((s, r) => s + r.inputTokens + r.cachedReadTokens + r.cacheCreateTokens + r.outputTokens, 0),
+      costUsd: rows.reduce((s, r) => s + r.costUsd, 0),
+      messages
+    };
+  }
+  return {
+    generatedAt: new Date(now).toISOString(),
+    windows: { last5h, last24h, last7d, today, lifetime },
+    totals: {
+      last5h: sum(last5h, messageCounts.last5h),
+      last24h: sum(last24h, messageCounts.last24h),
+      last7d: sum(last7d, messageCounts.last7d),
+      today: sum(today, messageCounts.today),
+      lifetime: sum(lifetime, messageCounts.lifetime)
+    },
+    sources: { claudeFiles: claudeFiles.length, codexFiles: codexFiles.length, skipped }
+  };
+}
+export {
+  gatherCliUsage
+};

package/dist/index.js

@@ -864,6 +864,18 @@ async function devCommand(options) {
     }
     const url = new URL(req.url || "/", `http://localhost:${port}`);
     const pathname = url.pathname;
+    if (pathname === "/api/cli-usage") {
+      try {
+        const { gatherCliUsage } = await import("./cli-usage-OFFQXJQN.js");
+        const report = await gatherCliUsage();
+        res.writeHead(200, { ...CORS_HEADERS, "Content-Type": "application/json" });
+        res.end(JSON.stringify(report));
+      } catch (err) {
+        res.writeHead(500, { ...CORS_HEADERS, "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: err.message }));
+      }
+      return;
+    }
     if (pathname === "/api/health") {
       const probeCli = (binary) => {
         try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "storyforge",
-  "version": "0.4.12",
+  "version": "0.4.14",
   "description": "StoryForge — local bridge for the Forge video production web app. Zero runtime dependencies.",
   "type": "module",
   "bin": {