shine-code-submit 0.2.0

package/src/daemon/store.ts

@@ -0,0 +1,147 @@
+// SQLite 存储：单库 + cwd 字段（按 cwd 过滤实现隔离，便于查看页跨项目聚合）。
+// 幂等：PRIMARY KEY (session_id, event_id) + INSERT OR IGNORE。
+import { Database } from "bun:sqlite";
+import { DB_FILE } from "../shared/paths";
+import { deriveStableEventId } from "../shared/id";
+import type { HookEvent, HookEventType, SessionSummary } from "../shared/types";
+
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS events (
+  event_id    TEXT NOT NULL,
+  session_id  TEXT NOT NULL,
+  type        TEXT NOT NULL,
+  timestamp   INTEGER NOT NULL,
+  cwd         TEXT NOT NULL,
+  pid         INTEGER NOT NULL,
+  payload     TEXT NOT NULL,
+  ingested_at INTEGER NOT NULL,
+  PRIMARY KEY (session_id, event_id)
+);
+CREATE INDEX IF NOT EXISTS idx_events_time ON events(timestamp DESC);
+CREATE INDEX IF NOT EXISTS idx_events_session ON events(session_id, timestamp DESC);
+CREATE INDEX IF NOT EXISTS idx_events_cwd ON events(cwd, timestamp DESC);
+`;
+
+const INSERT = `
+INSERT OR IGNORE INTO events (event_id, session_id, type, timestamp, cwd, pid, payload, ingested_at)
+VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+`;
+
+export interface QueryOpts {
+  cwd?: string;
+  sessionId?: string;
+  type?: string;
+  since?: number;
+  limit?: number;
+}
+
+export class Store {
+  private db: Database;
+
+  constructor() {
+    this.db = new Database(DB_FILE, { create: true });
+    this.db.exec("PRAGMA journal_mode = WAL;");
+    this.db.exec("PRAGMA synchronous = NORMAL;");
+    this.db.exec(SCHEMA);
+  }
+
+  /** 幂等插入。true=新插入，false=已存在（被去重）。
+   *  eventId 在此由内容派生（sessionId+type+payload），忽略客户端/hook 传入的随机 id——
+   *  这样即使同一事件被多个 hook 进程采集，派生主键相同，INSERT OR IGNORE 仍能去重。
+   *  入库点统一在此，HTTP 热路径与 spool 回捞共享，互为兜底。 */
+  insert(ev: HookEvent): boolean {
+    const id = deriveStableEventId(ev);
+    const r = this.db
+      .prepare(INSERT)
+      .run(
+        id,
+        ev.sessionId,
+        ev.type,
+        ev.timestamp,
+        ev.cwd,
+        ev.pid,
+        JSON.stringify(ev.payload ?? null),
+        Date.now(),
+      );
+    return r.changes > 0;
+  }
+
+  query(opts: QueryOpts): HookEvent[] {
+    const where: string[] = [];
+    const params: Array<string | number> = [];
+    if (opts.cwd) { where.push("cwd = ?"); params.push(opts.cwd); }
+    if (opts.sessionId) { where.push("session_id = ?"); params.push(opts.sessionId); }
+    if (opts.type) { where.push("type = ?"); params.push(opts.type); }
+    if (typeof opts.since === "number") { where.push("timestamp >= ?"); params.push(opts.since); }
+    const clause = where.length ? `WHERE ${where.join(" AND ")}` : "";
+    const limit = Math.min(Math.max(opts.limit ?? 200, 1), 2000);
+    const rows = this.db
+      .prepare(
+        `SELECT event_id, session_id, type, timestamp, cwd, pid, payload FROM events ${clause} ORDER BY timestamp DESC LIMIT ?`,
+      )
+      .all(...params, limit);
+    return rows.map(rowToEvent);
+  }
+
+  sessions(): SessionSummary[] {
+    const rows = this.db
+      .prepare(
+        `SELECT session_id, cwd, MAX(timestamp) AS last_active, COUNT(*) AS event_count,
+                (SELECT type FROM events e2 WHERE e2.session_id = e.session_id ORDER BY timestamp DESC LIMIT 1) AS last_type
+         FROM events e
+         GROUP BY session_id, cwd
+         ORDER BY last_active DESC
+         LIMIT 500`,
+      )
+      .all() as Array<{
+        session_id: string;
+        cwd: string;
+        last_active: number;
+        event_count: number;
+        last_type: HookEventType | null;
+      }>;
+    return rows.map((r) => ({
+      sessionId: r.session_id,
+      cwd: r.cwd,
+      lastActive: r.last_active,
+      eventCount: r.event_count,
+      lastType: r.last_type,
+    }));
+  }
+
+  count(): number {
+    const row = this.db.prepare("SELECT COUNT(*) AS n FROM events").get() as { n: number };
+    return row.n;
+  }
+
+  close(): void {
+    this.db.close();
+  }
+}
+
+function rowToEvent(row: unknown): HookEvent {
+  const r = row as {
+    event_id: string;
+    session_id: string;
+    type: HookEventType;
+    timestamp: number;
+    cwd: string;
+    pid: number;
+    payload: string;
+  };
+  let payload: unknown = null;
+  try {
+    payload = JSON.parse(r.payload);
+  } catch {
+    /* payload 损坏则置 null */
+  }
+  return {
+    eventId: r.event_id,
+    sessionId: r.session_id,
+    type: r.type,
+    timestamp: r.timestamp,
+    cwd: r.cwd,
+    pid: r.pid,
+    payload,
+  };
+}

package/src/daemon/token-cache.ts

@@ -0,0 +1,35 @@
+// 会话级 token 总量的 mtime 缓存。
+// /api/sessions 每 2s 被查看页轮询，逐 session 读 transcript 汇总 usage 会很重。
+// 这里按 transcriptPath 缓存「mtime → tokenTotal」：文件没变就直接返回，变了才重读重算。
+// 冷启动逐步填充，稳态全命中。任何异常返回 null（不影响 sessions 列表渲染）。
+import { statSync } from "node:fs";
+import { homedir } from "node:os";
+import { parseTranscript, sumUsage } from "./transcript";
+import type { TokenUsage } from "../shared/types";
+
+interface Entry {
+  mtimeMs: number;
+  total: TokenUsage;
+}
+
+const cache = new Map<string, Entry>();
+
+/** 返回某 transcript 的会话级 token 总量（带 mtime 缓存）；读不到/解析失败返回 null。 */
+export function getSessionTokenTotal(transcriptPath: string): TokenUsage | null {
+  const realPath = transcriptPath.replace(/^~/, homedir());
+  let mtimeMs: number;
+  try {
+    mtimeMs = statSync(realPath).mtimeMs;
+  } catch {
+    return null;
+  }
+  const hit = cache.get(transcriptPath);
+  if (hit && hit.mtimeMs === mtimeMs) return hit.total;
+  try {
+    const total = sumUsage(parseTranscript(transcriptPath));
+    cache.set(transcriptPath, { mtimeMs, total });
+    return total;
+  } catch {
+    return null;
+  }
+}

package/src/daemon/transcript.ts

@@ -0,0 +1,130 @@
+// 解析 Claude Code transcript jsonl（~/.claude/projects/<project>/<session>.jsonl）为对话消息。
+// 用于「对话视图」：完整还原用户提问 + Claude 回复 + 工具调用。
+// （事件流里若 Stop 未采集，这里仍能拿到完整记录，因为 transcript 由 Claude Code 自己持续写入。）
+// assistant 消息额外提取 message.usage（token 用量），供对话明细与会话级汇总。
+import { readFileSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import type { TokenUsage, TranscriptMessage } from "../shared/types";
+
+// TranscriptMessage 已移至 shared/types（前端 React 也复用同一契约）；此处 re-export 保持向后兼容。
+export type { TranscriptMessage };
+
+/** 读 transcript jsonl，解析成对话消息（跳过 thinking、tool_result 等非对话内容）。 */
+export function parseTranscript(transcriptPath: string): TranscriptMessage[] {
+  const path = transcriptPath.replace(/^~/, homedir());
+  if (!existsSync(path)) throw new Error(`transcript not found: ${path}`);
+  const lines = readFileSync(path, "utf8").split("\n").filter(Boolean);
+  const messages: TranscriptMessage[] = [];
+  const toolUseNames = new Map<string, string>(); // tool_use_id -> name，供 tool_result 关联工具名
+  for (const line of lines) {
+    let obj: Record<string, unknown>;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const message = obj.message as Record<string, unknown> | undefined;
+    if (!message) continue;
+    const role = message.role;
+    const content = message.content;
+    const ts = typeof obj.timestamp === "string"
+      ? Date.parse(obj.timestamp)
+      : (obj.timestamp as number | undefined);
+
+    if (role === "user") {
+      // string = 用户提问；array 多含 tool_result（作为独立「工具结果」消息）+ 可能的 text 段
+      if (typeof content === "string") {
+        if (content.trim()) messages.push({ role: "user", text: content, tools: [], ts });
+      } else if (Array.isArray(content)) {
+        const text = content
+          .filter((c) => (c as Record<string, unknown>).type === "text")
+          .map((c) => (c as Record<string, unknown>).text as string)
+          .join("\n");
+        if (text) messages.push({ role: "user", text, tools: [], ts });
+        for (const c of content) {
+          const ce = c as Record<string, unknown>;
+          if (ce.type !== "tool_result") continue;
+          const rc = ce.content;
+          let rText: string;
+          if (typeof rc === "string") rText = rc;
+          else if (Array.isArray(rc)) {
+            rText = rc
+              .filter((x) => (x as Record<string, unknown>).type === "text")
+              .map((x) => (x as Record<string, unknown>).text as string)
+              .join("\n");
+          } else rText = "";
+          const id = typeof ce.tool_use_id === "string" ? ce.tool_use_id : "";
+          messages.push({
+            role: "tool",
+            text: rText,
+            tools: [],
+            toolName: id ? toolUseNames.get(id) : undefined,
+            isError: ce.is_error === true,
+            ts,
+          });
+        }
+      }
+    } else if (role === "assistant") {
+      const usage = readUsage(message.usage);
+      if (Array.isArray(content)) {
+        const text = content
+          .filter((c) => (c as Record<string, unknown>).type === "text")
+          .map((c) => (c as Record<string, unknown>).text as string)
+          .join("\n");
+        const thinking = content
+          .filter((c) => (c as Record<string, unknown>).type === "thinking")
+          .map((c) => (c as Record<string, unknown>).thinking as string)
+          .join("\n\n");
+        const tools = content
+          .filter((c) => (c as Record<string, unknown>).type === "tool_use")
+          .map((c) => {
+            const ce = c as Record<string, unknown>;
+            const id = typeof ce.id === "string" ? ce.id : "";
+            const name = ce.name as string;
+            if (id && name) toolUseNames.set(id, name);
+            return { name, input: ce.input };
+          });
+        if (text || thinking || tools.length)
+          messages.push({ role: "assistant", text, thinking, tools, ts, usage });
+      }
+    }
+  }
+  return messages;
+}
+
+/** 从 message.usage（Anthropic 扁平四字段）提取 token 用量；无任何数值字段则 undefined。 */
+function readUsage(raw: unknown): TokenUsage | undefined {
+  if (!raw || typeof raw !== "object") return undefined;
+  const u = raw as Record<string, unknown>;
+  const num = (k: string): number => {
+    const v = u[k];
+    return typeof v === "number" && Number.isFinite(v) ? v : 0;
+  };
+  const has = [
+    "input_tokens",
+    "output_tokens",
+    "cache_creation_input_tokens",
+    "cache_read_input_tokens",
+  ].some((k) => typeof u[k] === "number");
+  if (!has) return undefined;
+  return {
+    input: num("input_tokens"),
+    output: num("output_tokens"),
+    cacheCreation: num("cache_creation_input_tokens"),
+    cacheRead: num("cache_read_input_tokens"),
+  };
+}
+
+/** 累加所有 assistant 消息的 usage（会话级 token 总量）；无 usage 则全 0。 */
+export function sumUsage(messages: TranscriptMessage[]): TokenUsage {
+  const total: TokenUsage = { input: 0, output: 0, cacheCreation: 0, cacheRead: 0 };
+  for (const m of messages) {
+    if (m.usage) {
+      total.input += m.usage.input;
+      total.output += m.usage.output;
+      total.cacheCreation += m.usage.cacheCreation;
+      total.cacheRead += m.usage.cacheRead;
+    }
+  }
+  return total;
+}