shine-code-submit 0.2.0

package/src/daemon/auth.ts

@@ -0,0 +1,7 @@
+// token 鉴权。token 为 Daemon 启动时生成的随机串，写 pid 文件，Hook/查看页带上。
+import type { PidFile } from "../shared/types";
+
+export function checkToken(authHeader: string | null, pid: PidFile): boolean {
+  if (!authHeader) return false;
+  return authHeader === `Bearer ${pid.token}`;
+}

package/src/daemon/bus.ts

@@ -0,0 +1,25 @@
+// 进程内事件总线：热路径与回捞入库后都向其 emit，WS 与 stats 订阅。
+import type { HookEvent } from "../shared/types";
+
+export type EventListener = (event: HookEvent) => void;
+
+export class EventBus {
+  private listeners = new Set<EventListener>();
+
+  on(fn: EventListener): () => void {
+    this.listeners.add(fn);
+    return () => {
+      this.listeners.delete(fn);
+    };
+  }
+
+  emit(event: HookEvent): void {
+    for (const fn of this.listeners) {
+      try {
+        fn(event);
+      } catch {
+        /* 单个订阅者失败不影响其他 */
+      }
+    }
+  }
+}

package/src/daemon/git.ts

@@ -0,0 +1,118 @@
+// 在某 cwd 跑 git log 解析为提交列表（查看页「提交」视图用）。
+// 容错优先：非 git 仓库 / git 未装 / 超时 → commits 空数组 + error，绝不抛。
+import { GIT_TIMEOUT_MS } from "../shared/config";
+import type { CommitFile, CommitLog, CommitsResponse } from "../shared/types";
+
+const SEP = "\x1f"; // unit separator，分隔 pretty 各字段，避免与 subject 内容冲突
+
+/**
+ * 拉取最近 N 条非 merge 提交及其 +新增/-删除 行数。
+ *
+ * git log --numstat --pretty=format:... 的输出形如：
+ *   <hash>\x1f<iso>\x1f<author>\x1f<subject>   ← pretty 行（含 SEP）开启一条 commit
+ *   <added>\t<deleted>\t<path>                  ← 0..N 行 numstat，二进制文件为 -\t-\t<path>
+ *   <hash>\x1f...
+ */
+export async function getCommits(cwd: string, limit = 200): Promise<CommitsResponse> {
+  const safeLimit = Math.min(Math.max(Math.floor(limit) || 200, 1), 1000);
+  let stdout: string;
+  try {
+    stdout = await runGit(cwd, [
+      "log",
+      "--no-merges",
+      `-n`,
+      `${safeLimit}`,
+      "--numstat",
+      `--pretty=format:%H${SEP}%cI${SEP}%an${SEP}%s`,
+    ]);
+  } catch (e) {
+    return { cwd, commits: [], error: friendlyErr(e) };
+  }
+  return { cwd, commits: parseLog(stdout) };
+}
+
+/** 跑 git 子进程，超时或非 0 退出 reject；stdout 文本 resolve。 */
+function runGit(cwd: string, args: string[]): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const proc = Bun.spawn({
+      cmd: ["git", "-C", cwd, ...args],
+      stdout: "pipe",
+      stderr: "pipe",
+      windowsHide: true,
+    });
+    const timer = setTimeout(() => {
+      proc.kill();
+      reject(new Error(`git timed out after ${GIT_TIMEOUT_MS}ms`));
+    }, GIT_TIMEOUT_MS);
+    void proc.exited
+      .then(async (code) => {
+        clearTimeout(timer);
+        if (code !== 0) {
+          const err = await new Response(proc.stderr).text();
+          reject(new Error(`git exit ${code}: ${err.trim()}`));
+          return;
+        }
+        resolve(await new Response(proc.stdout).text());
+      })
+      .catch((e) => {
+        clearTimeout(timer);
+        reject(e);
+      });
+  });
+}
+
+function parseLog(stdout: string): CommitLog[] {
+  const commits: CommitLog[] = [];
+  let cur: CommitLog | null = null;
+  for (const line of stdout.split("\n")) {
+    if (!line) continue;
+    if (line.includes(SEP)) {
+      if (cur) commits.push(cur);
+      const i1 = line.indexOf(SEP);
+      const i2 = line.indexOf(SEP, i1 + 1);
+      const i3 = line.indexOf(SEP, i2 + 1);
+      cur = {
+        hash: line.slice(0, i1),
+        time: parseIso(line.slice(i1 + 1, i2)),
+        author: line.slice(i2 + 1, i3),
+        subject: line.slice(i3 + 1),
+        files: [],
+        added: 0,
+        deleted: 0,
+      };
+    } else if (cur) {
+      const f = parseNumstat(line);
+      if (f) {
+        cur.files.push(f);
+        cur.added += f.added;
+        cur.deleted += f.deleted;
+      }
+    }
+  }
+  if (cur) commits.push(cur);
+  return commits;
+}
+
+/** numstat 行：<added>\t<deleted>\t<path>；二进制为 -\t-\t<path>（计 0）。 */
+function parseNumstat(line: string): CommitFile | null {
+  const m = line.match(/^(\d+|-)\t(\d+|-)\t(.+)$/);
+  if (!m) return null;
+  const a = m[1] ?? "-";
+  const d = m[2] ?? "-";
+  const p = m[3] ?? "";
+  if (!p) return null;
+  return { path: p, added: a === "-" ? 0 : parseInt(a, 10), deleted: d === "-" ? 0 : parseInt(d, 10) };
+}
+
+function parseIso(s: string): number {
+  const t = Date.parse(s);
+  return Number.isFinite(t) ? t : 0;
+}
+
+/** 把底层错误翻译成查看页可直接展示的中文提示。 */
+function friendlyErr(e: unknown): string {
+  const s = e instanceof Error ? e.message : String(e);
+  if (/not a git repository|fatal:.*repository/i.test(s)) return "当前目录不是 git 仓库";
+  if (/ENOENT|spawn|not found|no such file/i.test(s)) return "未找到 git，请确认 git 已安装并在 PATH";
+  return s;
+}

package/src/daemon/logger.ts

@@ -0,0 +1,66 @@
+// 文件日志 + 按大小轮转 + tail。detached Daemon 同时写文件与 stdout
+// （stdout 由启动者重定向到同一文件或控制台）。
+import { appendFileSync, statSync, renameSync, readFileSync, existsSync } from "node:fs";
+import { LOG_FILE } from "../shared/paths";
+import { LOG_ROTATE_BYTES } from "../shared/config";
+
+export class Logger {
+  constructor(private tag = "daemon") {}
+
+  private write(level: string, msg: string, extra?: unknown): void {
+    const line = `[${localIso()}] [${level}] [${this.tag}] ${msg}${extra !== undefined ? " " + safeStringify(extra) : ""}\n`;
+    this.maybeRotate();
+    try {
+      appendFileSync(LOG_FILE, line);
+    } catch {
+      /* 磁盘满等：跳过文件，避免抛出影响主流程 */
+    }
+    process.stdout.write(line);
+  }
+
+  info(m: string, e?: unknown) { this.write("INFO", m, e); }
+  warn(m: string, e?: unknown) { this.write("WARN", m, e); }
+  error(m: string, e?: unknown) { this.write("ERROR", m, e); }
+  debug(m: string, e?: unknown) { if (process.env.SHINE_CODE_SUBMIT_DEBUG) this.write("DEBUG", m, e); }
+
+  private maybeRotate(): void {
+    try {
+      if (existsSync(LOG_FILE) && statSync(LOG_FILE).size > LOG_ROTATE_BYTES) {
+        renameSync(LOG_FILE, `${LOG_FILE}.${Date.now()}`);
+      }
+    } catch {
+      /* ignore */
+    }
+  }
+
+  tail(lines: number): string[] {
+    try {
+      const raw = readFileSync(LOG_FILE, "utf8");
+      return raw.split("\n").filter(Boolean).slice(-lines);
+    } catch {
+      return [];
+    }
+  }
+}
+
+function safeStringify(v: unknown): string {
+  if (v instanceof Error) return JSON.stringify({ name: v.name, message: v.message, stack: v.stack });
+  try {
+    return JSON.stringify(v);
+  } catch {
+    return String(v);
+  }
+}
+
+/** 本地时间 ISO 风格（带本地时区偏移）。toISOString() 恒为 UTC（Z），日志会与本地差 8 小时，故用此。 */
+function localIso(d = new Date()): string {
+  const pad = (n: number, w = 2) => String(n).padStart(w, "0");
+  const off = -d.getTimezoneOffset(); // 分钟；东八区为 +480
+  const sign = off >= 0 ? "+" : "-";
+  const abs = Math.abs(off);
+  return (
+    `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}` +
+    `T${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}.${pad(d.getMilliseconds(), 3)}` +
+    `${sign}${pad(Math.floor(abs / 60))}:${pad(abs % 60)}`
+  );
+}

package/src/daemon/main.ts

@@ -0,0 +1,95 @@
+// Daemon 入口：组装 store/bus/stats/logger/spool/ws/server，写 pid 文件，启动并回捞一次。
+import { ensureDirs } from "../shared/paths";
+import { writePidFile, readPidFile, removePidFile } from "../shared/pidfile";
+import { SERVICE_NAME, SERVICE_VERSION, PORT, SPOOL_SCAN_INTERVAL_MS, LISTEN_HOST } from "../shared/config";
+import { isOursAlive } from "../shared/daemonctl";
+import { Store } from "./store";
+import { EventBus } from "./bus";
+import { Stats } from "./stats";
+import { Logger } from "./logger";
+import { SpoolConsumer } from "./spool-consumer";
+import { WebSocketPool } from "./ws";
+import { startServer } from "./server";
+import { serveUi } from "./ui";
+
+async function main(): Promise<void> {
+  ensureDirs();
+  const log = new Logger("daemon");
+
+  // 已有自己人的 daemon 在跑 → 复用，不重复启动。
+  // 防止 hook/CLI 因瞬时探活失败重复拉起时，第二个实例端口冲突 crash 并误删 pid 文件。
+  if (await isOursAlive()) {
+    log.info("another shine-code-submit daemon already running; exit without starting");
+    process.exit(0);
+  }
+
+  const existing = readPidFile();
+  if (existing) {
+    log.warn("stale pid file on startup", existing);
+  }
+
+  const startedAt = Date.now();
+  const pid = {
+    pid: process.pid,
+    port: PORT,
+    token: crypto.randomUUID(),
+    startedAt,
+  };
+  const store = new Store();
+  const bus = new EventBus();
+  const stats = new Stats();
+  const spool = new SpoolConsumer(store, bus, stats, log);
+  const wsPool = new WebSocketPool(bus, stats);
+
+  // 启动即回捞（处理上次崩溃遗留的 spool）
+  const recovered = spool.drain();
+  if (recovered > 0) log.info(`recovered ${recovered} events from spool on startup`);
+  spool.start(SPOOL_SCAN_INTERVAL_MS);
+  wsPool.attach();
+
+  // 只清理属于自己的 pid 文件（防止误删他人）
+  const ownsPidFile = (): boolean => readPidFile()?.pid === process.pid;
+
+  let server: ReturnType<typeof startServer>;
+  const shutdown = (reason: string) => {
+    log.info(`shutdown: ${reason}`);
+    try { wsPool.dispose(); } catch { /* noop */ }
+    try { server.stop(true); } catch { /* noop */ }
+    try { store.close(); } catch { /* noop */ }
+    if (ownsPidFile()) removePidFile();
+    process.exit(0);
+  };
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("exit", () => {
+    if (ownsPidFile()) removePidFile();
+    try { store.close(); } catch { /* noop */ }
+  });
+
+  server = startServer({
+    pid,
+    startedAt,
+    store,
+    bus,
+    stats,
+    log,
+    serveUi,
+    onWsOpen: (ws) => wsPool.add(ws),
+    onWsClose: (ws) => wsPool.remove(ws),
+    shutdown: () => shutdown("api"),
+  });
+
+  // 端口绑定成功后才写 pid 文件：hook 与 cli 可能并发拉起 daemon，isOursAlive 存在竞态，
+  // 若先写 pid 文件再 bind，bind 失败的实例会覆盖/删除 pid 文件，导致 listening 实例与 pid 文件
+  // 不一致（cli stop/restart/ui 据此取 token 会失效）。bind 成功才意味着本实例胜出。
+  writePidFile(pid);
+
+  log.info(`${SERVICE_NAME} v${SERVICE_VERSION} listening http://${LISTEN_HOST}:${PORT} pid=${process.pid} token=${pid.token}`);
+}
+
+try {
+  await main();
+} catch (err) {
+  console.error("fatal:", err);
+  process.exit(1);
+}

package/src/daemon/server.ts

@@ -0,0 +1,208 @@
+// HTTP/WS 路由与鉴权。组装 Bun.serve。
+// 健康端点与静态页不鉴权；其余端点（事件接收、stats、events、sessions、ws、shutdown）需 token。
+import type { ServerWebSocket } from "bun";
+import { LISTEN_HOST, PORT, SERVICE_NAME, SERVICE_VERSION, LOG_TAIL_LINES, SESSION_TOKEN_ENRICH_LIMIT } from "../shared/config";
+import type { HookEvent, HookEventType, PidFile } from "../shared/types";
+import { deriveStableEventId } from "../shared/id";
+import { checkToken } from "./auth";
+import { parseTranscript, sumUsage } from "./transcript";
+import { getSessionTokenTotal } from "./token-cache";
+import { getCommits } from "./git";
+import type { Store } from "./store";
+import type { EventBus } from "./bus";
+import type { Stats } from "./stats";
+import type { Logger } from "./logger";
+
+export interface ServerDeps {
+  pid: PidFile;
+  startedAt: number;
+  store: Store;
+  bus: EventBus;
+  stats: Stats;
+  log: Logger;
+  serveUi: (req: Request, url: URL) => Response | Promise<Response>;
+  onWsOpen?: (ws: ServerWebSocket<unknown>) => void;
+  onWsClose?: (ws: ServerWebSocket<unknown>) => void;
+  shutdown: () => void;
+}
+
+export function startServer(deps: ServerDeps) {
+  const { pid, store, bus, stats, log } = deps;
+
+  const authed = (req: Request) => checkToken(req.headers.get("authorization"), pid);
+
+  const json = (body: unknown, status = 200) =>
+    new Response(JSON.stringify(body), {
+      status,
+      headers: { "content-type": "application/json; charset=utf-8" },
+    });
+
+  return Bun.serve({
+    hostname: LISTEN_HOST,
+    port: PORT,
+    async fetch(req, server) {
+      const url = new URL(req.url);
+      const path = url.pathname;
+
+      // ---- health（无鉴权）：Hook「认自己人」用 ----
+      if (path === "/api/health" && req.method === "GET") {
+        return json({
+          service: SERVICE_NAME,
+          version: SERVICE_VERSION,
+          pid: pid.pid,
+          uptime: Date.now() - deps.startedAt,
+        });
+      }
+
+      // ---- 静态页（无鉴权；数据接口仍鉴权）----
+      if (path === "/" || path === "/ui" || path.startsWith("/ui/")) {
+        return await deps.serveUi(req, url);
+      }
+
+      // ---- WS 升级（鉴权；浏览器无法设 header，故支持 ?t= 查询参数）----
+      if (path === "/api/ws" && req.method === "GET") {
+        const q = url.searchParams.get("t");
+        const authHeader = q ? `Bearer ${q}` : req.headers.get("authorization");
+        if (!checkToken(authHeader, pid)) return json({ error: "unauthorized" }, 401);
+        if (server.upgrade(req, { data: { tokenOk: true } })) {
+          return new Response(null, { status: 101 });
+        }
+        return json({ error: "upgrade failed" }, 400);
+      }
+
+      // ---- 以下均需鉴权 ----
+      if (!authed(req)) return json({ error: "unauthorized" }, 401);
+
+      // 事件接收（热路径）
+      const m = path.match(/^\/api\/hook\/(\w+)$/);
+      if (m && req.method === "POST") {
+        const type = m[1] as HookEventType;
+        let body: unknown;
+        try {
+          body = await req.json();
+        } catch {
+          return json({ error: "bad json" }, 400);
+        }
+        const event = normalizeEvent(type, body);
+        if (!event) return json({ error: "missing required fields (cwd, sessionId)" }, 400);
+        const inserted = store.insert(event);
+        if (inserted) {
+          bus.emit(event);
+          stats.recordEvent();
+          log.info(`ingest http ${event.type}`);
+        }
+        return json({ status: "ok", inserted });
+      }
+
+      if (path === "/api/stats" && req.method === "GET") {
+        return json({
+          service: SERVICE_NAME,
+          version: SERVICE_VERSION,
+          pid: pid.pid,
+          uptime: Date.now() - deps.startedAt,
+          spoolBacklog: stats.backlog(),
+          eventsPerSec: stats.rate(),
+          totalEvents: store.count(),
+          lastError: stats.lastError,
+          logTail: log.tail(LOG_TAIL_LINES),
+        });
+      }
+
+      if (path === "/api/events" && req.method === "GET") {
+        const sp = url.searchParams;
+        return json({
+          events: store.query({
+            cwd: sp.get("cwd") ?? undefined,
+            sessionId: sp.get("sessionId") ?? undefined,
+            type: sp.get("type") ?? undefined,
+            since: num(sp.get("since")),
+            limit: num(sp.get("limit")) ?? 200,
+          }),
+        });
+      }
+
+      if (path === "/api/sessions" && req.method === "GET") {
+        const sessions = store.sessions();
+        // 仅对最近 N 个 session enrich tokenTotal（读 transcript 较重，走 mtime 缓存）；
+        // 更老的留 undefined，避免每 2s 轮询时重读大量旧 transcript。
+        for (let i = 0; i < Math.min(sessions.length, SESSION_TOKEN_ENRICH_LIMIT); i++) {
+          const s = sessions[i];
+          if (!s) continue;
+          const tp = findTranscriptPath(store, s.sessionId);
+          s.tokenTotal = tp ? getSessionTokenTotal(tp) : null;
+        }
+        return json({ sessions });
+      }
+
+      // 对话视图：从该 session 任一事件的 payload.transcript_path 读完整 transcript
+      if (path === "/api/transcript" && req.method === "GET") {
+        const sessionId = url.searchParams.get("sessionId");
+        if (!sessionId) return json({ error: "missing sessionId" }, 400);
+        const tp = findTranscriptPath(store, sessionId);
+        if (!tp) return json({ error: "no transcript_path found for session" }, 404);
+        try {
+          const messages = parseTranscript(tp);
+          return json({ transcriptPath: tp, messages, tokenTotal: sumUsage(messages) });
+        } catch (err) {
+          return json({ error: "read transcript failed", detail: String(err) }, 500);
+        }
+      }
+
+      // 提交视图：在某 cwd 跑 git log 取最近提交 + 行数（容错，非 git 目录返回空 + error）
+      if (path === "/api/commits" && req.method === "GET") {
+        const cwd = url.searchParams.get("cwd");
+        if (!cwd) return json({ error: "missing cwd" }, 400);
+        const limit = num(url.searchParams.get("limit")) ?? 200;
+        return json(await getCommits(cwd, limit));
+      }
+
+      if (path === "/api/shutdown" && req.method === "POST") {
+        log.info("shutdown requested via api");
+        setTimeout(() => deps.shutdown(), 50); // 先响应再退
+        return json({ status: "shutting down" });
+      }
+
+      return json({ error: "not found" }, 404);
+    },
+    websocket: {
+      open: (ws: ServerWebSocket<unknown>) => deps.onWsOpen?.(ws),
+      message: () => {
+        /* 查看页不发消息 */
+      },
+      close: (ws: ServerWebSocket<unknown>) => deps.onWsClose?.(ws),
+    },
+  });
+}
+
+function num(v: string | null): number | undefined {
+  if (v == null) return undefined;
+  const n = Number(v);
+  return Number.isFinite(n) ? n : undefined;
+}
+
+/** 从某 session 的事件 payload 里找 transcript_path（取最近 50 条里第一个带值的）。 */
+function findTranscriptPath(store: Store, sessionId: string): string | null {
+  for (const e of store.query({ sessionId, limit: 50 })) {
+    const p = e.payload as Record<string, unknown> | null;
+    if (p && typeof p.transcript_path === "string") return p.transcript_path;
+  }
+  return null;
+}
+
+function normalizeEvent(type: HookEventType, body: unknown): HookEvent | null {
+  if (typeof body !== "object" || body === null) return null;
+  const b = body as Record<string, unknown>;
+  const cwd = typeof b.cwd === "string" ? b.cwd : "";
+  const sessionId = typeof b.sessionId === "string" ? b.sessionId : "";
+  if (!cwd || !sessionId) return null;
+  const payload = "payload" in b ? b.payload : b;
+  return {
+    eventId: deriveStableEventId({ type, sessionId, payload }), // 内容派生，保证多路采集幂等
+    type,
+    timestamp: typeof b.timestamp === "number" ? b.timestamp : Date.now(),
+    cwd,
+    sessionId,
+    pid: typeof b.pid === "number" ? b.pid : 0,
+    payload,
+  };
+}

package/src/daemon/spool-consumer.ts

@@ -0,0 +1,52 @@
+// spool 消费器（回捞路径）：扫目录 → 幂等入库 → 推总线 → 删除（删除即确认）。
+// 与 HTTP 热路径共享 store.insert 幂等逻辑，互为兜底。
+import { listSpool, removeSpoolFile } from "../shared/spool";
+import type { Store } from "./store";
+import type { EventBus } from "./bus";
+import type { Stats } from "./stats";
+import type { Logger } from "./logger";
+
+export class SpoolConsumer {
+  constructor(
+    private store: Store,
+    private bus: EventBus,
+    private stats: Stats,
+    private log: Logger,
+  ) {}
+
+  /** 扫描并消费全部 spool。返回本次新入库条数。 */
+  drain(): number {
+    const entries = listSpool((name, err) =>
+      this.log.warn(`spool corrupt, skipping ${name}`, err),
+    );
+    let n = 0;
+    for (const { name, event } of entries) {
+      try {
+        if (this.store.insert(event)) {
+          this.bus.emit(event);
+          this.stats.recordEvent();
+          n++;
+          this.log.info(`ingest spool ${event.type} ${name}`);
+        } else {
+          this.log.debug(`dedup spool ${name}`);
+        }
+      } catch (err) {
+        this.stats.recordError(`spool ingest failed: ${name}`);
+        this.log.error(`spool ingest failed ${name}`, err);
+      }
+      removeSpoolFile(name); // 无论新插入还是去重，都已确认
+    }
+    return n;
+  }
+
+  start(intervalMs: number): void {
+    const tick = () => {
+      try {
+        this.drain();
+      } catch (err) {
+        this.log.error("spool tick failed", err);
+      }
+    };
+    setInterval(tick, intervalMs);
+  }
+}

package/src/daemon/stats.ts

@@ -0,0 +1,33 @@
+// 运行指标：滑动窗口算 events/sec、累计总数、最近错误、spool 积压。
+import { STATS_WINDOW_MS } from "../shared/config";
+import { countSpool } from "../shared/spool";
+
+export class Stats {
+  private stamps: number[] = [];
+  total = 0;
+  lastError: { time: number; message: string } | null = null;
+
+  recordEvent(now = Date.now()): void {
+    this.stamps.push(now);
+    this.total++;
+    this.gc(now);
+  }
+
+  recordError(message: string, now = Date.now()): void {
+    this.lastError = { time: now, message };
+  }
+
+  private gc(now: number): void {
+    const cutoff = now - STATS_WINDOW_MS;
+    while (this.stamps.length && (this.stamps[0] ?? 0) < cutoff) this.stamps.shift();
+  }
+
+  rate(now = Date.now()): number {
+    this.gc(now);
+    return this.stamps.length / (STATS_WINDOW_MS / 1000);
+  }
+
+  backlog(): number {
+    return countSpool();
+  }
+}