npm - @opencode-trace/viewer - Versions diffs - 0.0.3 → 0.0.5 - Mend

@opencode-trace/viewer 0.0.3 → 0.0.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (23) hide show

package/README.md +17 -2
package/dist/cli.js +20 -6
package/dist/cli.js.map +1 -1
package/dist/cli.test.d.ts +2 -0
package/dist/cli.test.d.ts.map +1 -0
package/dist/cli.test.js +110 -0
package/dist/cli.test.js.map +1 -0
package/dist/index.test.d.ts +2 -0
package/dist/index.test.d.ts.map +1 -0
package/dist/index.test.js +21 -0
package/dist/index.test.js.map +1 -0
package/dist/public/assets/index-BAtN_fgH.css +1 -0
package/dist/public/assets/index-DgiS5drt.js +91 -0
package/dist/public/index.html +2 -2
package/dist/server.d.ts +5 -0
package/dist/server.d.ts.map +1 -1
package/dist/server.js +418 -45
package/dist/server.js.map +1 -1
package/dist/server.test.js +1275 -81
package/dist/server.test.js.map +1 -1
package/package.json +5 -3
package/dist/public/assets/index-DoL5ISmB.js +0 -91
package/dist/public/assets/index-idry_N9R.css +0 -1

package/dist/public/index.html CHANGED Viewed

@@ -19,8 +19,8 @@
       font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
     }
   </style>
-  <script type="module" crossorigin src="/assets/index-DoL5ISmB.js"></script>
-  <link rel="stylesheet" crossorigin href="/assets/index-idry_N9R.css">
+  <script type="module" crossorigin src="/assets/index-DgiS5drt.js"></script>
+  <link rel="stylesheet" crossorigin href="/assets/index-BAtN_fgH.css">
 </head>
 <body>

package/dist/server.d.ts CHANGED Viewed

@@ -1,12 +1,17 @@
+import { type FastifyInstance } from "fastify";
 export interface ViewerOptions {
     port?: number;
     traceDir?: string;
+    globalDir?: string;
+    localDir?: string;
     open?: boolean;
     corsOrigin?: string | string[] | RegExp | boolean;
+    noListen?: boolean;
 }
 export interface ViewerInstance {
     url: string;
     close: () => Promise<void>;
+    app?: FastifyInstance;
 }
 export declare function createViewer(options?: ViewerOptions): Promise<ViewerInstance>;
 //# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"~~AAuCA~~,MAAM,WAAW,aAAa;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,MAAM,GAAG,OAAO,CAAC;~~CACnD~~;AAED,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;~~CAC5B~~;~~AAED~~,wBAAsB,YAAY,~~CAAC~~,OAAO,CAAC,EAAE,aAAa,~~GAAG~~,OAAO,CAAC,cAAc,CAAC,~~CAqWnF~~"}
1	+ {"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAGA,OAAgB,EAAE,KAAK,eAAe,EAAE,MAAM,SAAS,CAAC;AAqDxD,MAAM,WAAW,aAAa;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,MAAM,GAAG,OAAO,CAAC;IAClD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3B,GAAG,CAAC,EAAE,eAAe,CAAC;CACvB;AAOD,wBAAsB,YAAY,CAChC,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,cAAc,CAAC,CAsxBzB"}

package/dist/server.js CHANGED Viewed

@@ -1,4 +1,4 @@
-import { readFileSync, existsSync } from "node:fs";
+import { readFileSync, readdirSync, existsSync, writeFileSync, promises as fs } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import Fastify from "fastify";
@@ -6,10 +6,14 @@ import cors from "@fastify/cors";
 import rateLimit from "@fastify/rate-limit";
 import multipart from "@fastify/multipart";
 import fastifyStatic from "@fastify/static";
-import { store, parse, query, transform, record } from "@opencode-trace/core";
+import chokidar from "chokidar";
+import { store, parse, query, transform, record, getTraceDir, } from "@opencode-trace/core";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 function validateSessionId(sessionId) {
-    return typeof sessionId === "string" && sessionId.length > 0 && sessionId.length <= 256 && /^[a-zA-Z0-9_-]+$/.test(sessionId);
+    return (typeof sessionId === "string" &&
+        sessionId.length > 0 &&
+        sessionId.length <= 256 &&
+        /^[a-zA-Z0-9_-]+$/.test(sessionId));
 }
 function validateRecordId(recordId) {
     const num = parseInt(recordId, 10);
@@ -34,8 +38,68 @@ function validateParams(reply, sessionId, recordId) {
 }
 export async function createViewer(options) {
     const port = options?.port ?? 3210;
-    const traceDir = options?.traceDir;
-    const storeOpts = traceDir ? { traceDir } : undefined;
+    const globalDir = options?.globalDir ?? options?.traceDir ?? getTraceDir();
+    const localDir = options?.localDir ?? options?.traceDir;
+    const bothDirsOpts = { globalDir, localDir };
+    const sseClients = new Set();
+    // SSE keep-alive heartbeat — prevents proxies from closing idle connections
+    const sseKeepAlive = setInterval(() => {
+        for (const client of sseClients) {
+            try {
+                client.reply.raw.write(": heartbeat\n\n");
+            }
+            catch {
+                sseClients.delete(client);
+            }
+        }
+    }, 15000);
+    let clientIdCounter = 0;
+    function broadcastSSE(event, data) {
+        const payload = `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+        for (const client of sseClients) {
+            try {
+                client.reply.raw.write(payload);
+            }
+            catch {
+                sseClients.delete(client);
+            }
+        }
+    }
+    function findSessionTraceDir(sessionId) {
+        if (localDir) {
+            const localMeta = store.readSessionMetadata(sessionId, localDir);
+            if (localMeta)
+                return localDir;
+            const localRecords = store.getSessionRecords(sessionId, {
+                traceDir: localDir,
+            });
+            if (localRecords.length > 0)
+                return localDir;
+        }
+        const globalMeta = store.readSessionMetadata(sessionId, globalDir);
+        if (globalMeta)
+            return globalDir;
+        const globalRecords = store.getSessionRecords(sessionId, {
+            traceDir: globalDir,
+        });
+        if (globalRecords.length > 0)
+            return globalDir;
+        return null;
+    }
+    function validateSessionAndFindDir(reply, sessionId) {
+        if (!validateSessionId(sessionId)) {
+            reply.code(400);
+            reply.send({ error: "Invalid session ID format" });
+            return null;
+        }
+        const sessionTraceDir = findSessionTraceDir(sessionId);
+        if (!sessionTraceDir) {
+            reply.code(404);
+            reply.send({ error: "Session not found" });
+            return null;
+        }
+        return sessionTraceDir;
+    }
     const app = Fastify({ logger: false });
     await app.register(cors, {
         origin: options?.corsOrigin ?? [/^https?:\/\/localhost(:\d+)?$/],
@@ -56,18 +120,20 @@ export async function createViewer(options) {
     app.setNotFoundHandler(async (_req, reply) => {
         const indexPath = join(publicDir, "index.html");
         if (existsSync(indexPath)) {
-            reply.type("text/html; charset=utf-8").send(readFileSync(indexPath, "utf-8"));
+            reply
+                .type("text/html; charset=utf-8")
+                .send(readFileSync(indexPath, "utf-8"));
         }
         else {
             reply.code(404).send({ error: "Not found" });
         }
     });
     app.get("/api/sessions", async (_req, reply) => {
-        const sessions = store.listSessions(storeOpts);
+        const sessions = store.listSessionsFromBothDirs(bothDirsOpts);
         return sessions;
     });
     app.get("/api/sessions/tree", async (_req, reply) => {
-        const tree = store.listSessionsTree(storeOpts);
+        const tree = store.listSessionsTreeFromBothDirs(bothDirsOpts);
         return tree;
     });
     app.get("/api/sessions/:sessionId/timeline", async (req, reply) => {
@@ -76,7 +142,52 @@ export async function createViewer(options) {
             reply.code(400);
             return { error: "Invalid session ID format" };
         }
-        const records = store.getSessionRecords(sessionId, storeOpts);
+        const sessionTraceDir = findSessionTraceDir(sessionId);
+        if (!sessionTraceDir) {
+            reply.code(404);
+            return { error: "Session not found" };
+        }
+        const timelineEntries = store.readTimelineIndex(sessionId, {
+            traceDir: sessionTraceDir,
+        });
+        if (timelineEntries.length > 0) {
+            const timelineRecords = [];
+            for (const entry of timelineEntries) {
+                const cached = store.getCachedParsed(sessionId, entry.seq, {
+                    traceDir: sessionTraceDir,
+                });
+                if (cached) {
+                    timelineRecords.push({
+                        id: entry.seq,
+                        requestAt: entry.requestAt,
+                        parsed: cached,
+                    });
+                }
+                else {
+                    const rec = store.getRecord(sessionId, entry.seq, {
+                        traceDir: sessionTraceDir,
+                    });
+                    if (rec) {
+                        const parsed = parse.detectAndParse(rec);
+                        timelineRecords.push({
+                            id: rec.id,
+                            requestAt: rec.requestAt,
+                            parsed,
+                        });
+                    }
+                }
+            }
+            const timeline = query.buildSessionTimeline(sessionId, timelineRecords);
+            const recordMeta = timelineRecords.map((r) => ({
+                id: r.id,
+                model: r.parsed.model,
+                provider: r.parsed.provider,
+            }));
+            return { ...timeline, recordMeta };
+        }
+        const records = store.getSessionRecords(sessionId, {
+            traceDir: sessionTraceDir,
+        });
         const parsedRecords = records
             .map((rec) => {
             const parsed = parse.detectAndParse(rec);
@@ -102,6 +213,41 @@ export async function createViewer(options) {
             };
         })
             .filter((c) => c.parsed.provider !== "unknown" || c.parsed.msgs.length > 0);
+        // Fire-and-forget rebuild timeline.ndjson from full-parse results
+        // so subsequent requests use the fast ndjson path
+        const ndjsonSessionDir = join(sessionTraceDir, sessionId);
+        const ndjsonLines = [];
+        for (const rec of records) {
+            try {
+                ndjsonLines.push(JSON.stringify({
+                    seq: rec.id,
+                    url: rec.request.url,
+                    method: rec.request.method,
+                    purpose: rec.purpose,
+                    requestAt: rec.requestAt,
+                    responseAt: rec.responseAt,
+                    status: rec.response?.status ?? 0,
+                    provider: parse.detectProvider(rec.request.url, rec.request.body),
+                    model: null,
+                    inputTokens: null,
+                    outputTokens: null,
+                    totalDurationMs: null,
+                }));
+            }
+            catch {
+                // skip records that can't be serialized
+            }
+        }
+        setImmediate(async () => {
+            try {
+                if (ndjsonLines.length > 0) {
+                    await fs.writeFile(join(ndjsonSessionDir, "timeline.ndjson"), ndjsonLines.join("\n") + "\n");
+                }
+            }
+            catch {
+                // rebuild is optional
+            }
+        });
         const timeline = query.buildSessionTimeline(sessionId, parsedRecords);
         const recordMeta = parsedRecords.map((r) => ({
             id: r.id,
@@ -116,23 +262,60 @@ export async function createViewer(options) {
             reply.code(400);
             return { error: "Invalid session ID format" };
         }
-        const records = store.getSessionRecords(sessionId, storeOpts);
-        const parsedRecords = records
-            .map((rec) => ({
-            id: rec.id,
-            record: rec,
-            parsed: parse.detectAndParse(rec),
-        }))
-            .filter((c) => c.parsed.provider !== "unknown" || c.parsed.msgs.length > 0);
-        const sessions = store.listSessions(storeOpts);
+        const sessionTraceDir = findSessionTraceDir(sessionId);
+        if (!sessionTraceDir) {
+            reply.code(404);
+            return { error: "Session not found" };
+        }
+        // Read timeline.ndjson for record list + basic timing data
+        const timelineEntries = store.readTimelineIndex(sessionId, {
+            traceDir: sessionTraceDir,
+        });
+        const metaRecords = [];
+        if (timelineEntries.length > 0) {
+            // Use ndjson + parsed cache — no full JSON scan + parse
+            for (const entry of timelineEntries) {
+                const cached = store.getCachedParsed(sessionId, entry.seq, {
+                    traceDir: sessionTraceDir,
+                });
+                if (cached) {
+                    metaRecords.push({
+                        id: entry.seq,
+                        record: undefined,
+                        parsed: cached,
+                    });
+                }
+                else {
+                    const rec = store.getRecord(sessionId, entry.seq, {
+                        traceDir: sessionTraceDir,
+                    });
+                    if (rec) {
+                        const parsed = parse.detectAndParse(rec);
+                        metaRecords.push({ id: entry.seq, record: rec, parsed });
+                    }
+                }
+            }
+        }
+        else {
+            // No ndjson — full fallback (legacy sessions before this upgrade)
+            const records = store.getSessionRecords(sessionId, {
+                traceDir: sessionTraceDir,
+            });
+            for (const rec of records) {
+                const parsed = parse.detectAndParse(rec);
+                metaRecords.push({ id: rec.id, record: rec, parsed });
+            }
+        }
+        const filtered = metaRecords.filter((r) => r.parsed.provider !== "unknown" || r.parsed.msgs.length > 0);
+        const sessions = store.listSessionsFromBothDirs(bothDirsOpts);
         const sessionMeta = sessions.find((s) => s.id === sessionId);
-        const tree = store.listSessionsTree(storeOpts);
+        const tree = store.listSessionsTreeFromBothDirs(bothDirsOpts);
         const node = tree.find((n) => n.id === sessionId);
-        const metadata = query.buildSessionMetadata(sessionId, parsedRecords, sessionMeta?.folderPath);
+        const metadata = query.buildSessionMetadata(sessionId, filtered, sessionMeta?.folderPath);
         if (sessionMeta) {
             metadata.createdAt = sessionMeta.createdAt;
             metadata.updatedAt = sessionMeta.updatedAt;
-            metadata.subSessions = node?.children?.map(c => c.id) ?? [];
+            metadata.subSessions = node?.children?.map((c) => c.id) ?? [];
             metadata.parentSession = sessionMeta.parentID ?? null;
         }
         return metadata;
@@ -142,7 +325,17 @@ export async function createViewer(options) {
         const rid = validateParams(reply, sessionId, recordId);
         if (rid === null)
             return;
-        const rec = store.getRecord(sessionId, rid, storeOpts);
+        const sessionTraceDir = validateSessionAndFindDir(reply, sessionId);
+        if (sessionTraceDir === null)
+            return;
+        const cached = store.getCachedParsed(sessionId, rid, {
+            traceDir: sessionTraceDir,
+        });
+        if (cached)
+            return cached;
+        const rec = store.getRecord(sessionId, rid, {
+            traceDir: sessionTraceDir,
+        });
         if (!rec) {
             reply.code(404);
             return { error: "Record not found" };
@@ -155,7 +348,12 @@ export async function createViewer(options) {
         const rid = validateParams(reply, sessionId, recordId);
         if (rid === null)
             return;
-        const rec = store.getRecord(sessionId, rid, storeOpts);
+        const sessionTraceDir = validateSessionAndFindDir(reply, sessionId);
+        if (sessionTraceDir === null)
+            return;
+        const rec = store.getRecord(sessionId, rid, {
+            traceDir: sessionTraceDir,
+        });
         if (!rec) {
             reply.code(404);
             return { error: "Record not found" };
@@ -168,7 +366,12 @@ export async function createViewer(options) {
         const rid = validateParams(reply, sessionId, recordId);
         if (rid === null)
             return;
-        const rec = store.getRecord(sessionId, rid, storeOpts);
+        const sessionTraceDir = validateSessionAndFindDir(reply, sessionId);
+        if (sessionTraceDir === null)
+            return;
+        const rec = store.getRecord(sessionId, rid, {
+            traceDir: sessionTraceDir,
+        });
         if (!rec) {
             reply.code(404);
             return { error: "Record not found" };
@@ -181,12 +384,19 @@ export async function createViewer(options) {
         const rid = validateParams(reply, sessionId, recordId);
         if (rid === null)
             return;
-        const sseData = store.getSSEStream(sessionId, rid, storeOpts);
+        const sessionTraceDir = validateSessionAndFindDir(reply, sessionId);
+        if (sessionTraceDir === null)
+            return;
+        const sseData = store.getSSEStream(sessionId, rid, {
+            traceDir: sessionTraceDir,
+        });
         if (!sseData) {
             reply.code(404);
             return { error: "No SSE data found" };
         }
-        const rec = store.getRecord(sessionId, rid, storeOpts);
+        const rec = store.getRecord(sessionId, rid, {
+            traceDir: sessionTraceDir,
+        });
         const provider = rec?.request
             ? parse.detectProvider(rec.request.url, rec.request.body)
             : null;
@@ -207,7 +417,12 @@ export async function createViewer(options) {
         const rid = validateParams(reply, sessionId, recordId);
         if (rid === null)
             return;
-        const rec = store.getRecord(sessionId, rid, storeOpts);
+        const sessionTraceDir = validateSessionAndFindDir(reply, sessionId);
+        if (sessionTraceDir === null)
+            return;
+        const rec = store.getRecord(sessionId, rid, {
+            traceDir: sessionTraceDir,
+        });
         if (!rec) {
             reply.code(404);
             return { error: "Record not found" };
@@ -220,9 +435,12 @@ export async function createViewer(options) {
             reply.code(400);
             return { error: "Invalid session ID format" };
         }
-        const sessions = store.listSessions(storeOpts);
+        const sessionTraceDir = findSessionTraceDir(sessionId);
+        const sessions = store.listSessionsFromBothDirs(bothDirsOpts);
         const sessionMeta = sessions.find((s) => s.id === sessionId);
-        const records = store.getSessionRecords(sessionId, storeOpts);
+        const records = sessionTraceDir
+            ? store.getSessionRecords(sessionId, { traceDir: sessionTraceDir })
+            : [];
         const enriched = records.map((rec) => ({
             ...rec,
             provider: rec?.request
@@ -241,19 +459,34 @@ export async function createViewer(options) {
         };
     });
     app.get("/api/trace/status", async (_req, reply) => {
-        const enabled = record.getGlobalTraceEnabled(traceDir);
+        const enabled = record.getGlobalTraceEnabled(globalDir);
         return { globalEnabled: enabled };
     });
     app.get("/api/trace/enable", async (_req, reply) => {
-        record.setGlobalTraceEnabled(true, traceDir);
+        record.setGlobalTraceEnabled(true, globalDir);
         return { success: true, globalEnabled: true };
     });
     app.get("/api/trace/disable", async (_req, reply) => {
-        record.setGlobalTraceEnabled(false, traceDir);
+        record.setGlobalTraceEnabled(false, globalDir);
         return { success: true, globalEnabled: false };
     });
     app.get("/api/trace-dir", async (_req, reply) => {
-        return { traceDir: store.getTraceDir(storeOpts) };
+        return { traceDir: globalDir, localDir };
+    });
+    app.get("/api/events", async (req, reply) => {
+        const clientId = String(++clientIdCounter);
+        const client = { id: clientId, reply };
+        reply.raw.writeHead(200, {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+            "X-Accel-Buffering": "no",
+        });
+        reply.raw.write(`event: connected\ndata: {"clientId":"${clientId}"}\n\n`);
+        sseClients.add(client);
+        req.raw.on("close", () => {
+            sseClients.delete(client);
+        });
     });
     app.post("/api/sessions/:sessionId/export", async (req, reply) => {
         try {
@@ -262,11 +495,18 @@ export async function createViewer(options) {
                 reply.code(400);
                 return { error: "Invalid session ID format" };
             }
-            const stream = await store.exportSessionZip(sessionId, storeOpts);
+            const sessionTraceDir = findSessionTraceDir(sessionId);
+            if (!sessionTraceDir) {
+                reply.code(404);
+                return { error: "Session not found" };
+            }
+            const buffer = await store.exportSessionZip(sessionId, {
+                traceDir: sessionTraceDir,
+            });
             reply
                 .type("application/zip")
                 .header("Content-Disposition", `attachment; filename="session-${sessionId}.zip"`)
-                .send(stream);
+                .send(buffer);
         }
         catch (e) {
             const err = e;
@@ -290,10 +530,12 @@ export async function createViewer(options) {
             const validStrategies = ["prompt", "rename", "skip", "overwrite"];
             if (!validStrategies.includes(conflictStrategy)) {
                 reply.code(400);
-                return { error: `Invalid conflict strategy: ${conflictStrategy}. Valid: ${validStrategies.join(", ")}` };
+                return {
+                    error: `Invalid conflict strategy: ${conflictStrategy}. Valid: ${validStrategies.join(", ")}`,
+                };
             }
             const result = await store.importSessionZip(fileBuffer, {
-                ...storeOpts,
+                traceDir: globalDir,
                 conflictStrategy: conflictStrategy,
             });
             return result;
@@ -315,21 +557,147 @@ export async function createViewer(options) {
                 reply.code(400);
                 return { error: "Invalid session ID format" };
             }
-            await store.deleteSession(sessionId, storeOpts);
+            const sessionTraceDir = findSessionTraceDir(sessionId);
+            if (!sessionTraceDir) {
+                reply.code(404);
+                return { error: "Session not found" };
+            }
+            await store.deleteSession(sessionId, { traceDir: sessionTraceDir });
             return { success: true, sessionId };
         }
         catch (e) {
             const err = e;
-            if (err.message === "Session not found") {
-                reply.code(404);
-                return { error: "Session not found" };
-            }
             reply.code(500);
             return { error: "Delete failed: " + err.message };
         }
     });
-    await app.listen({ port, host: "0.0.0.0" });
-    const addr = `http://localhost:${port}`;
+    app.post("/api/sessions/batch-delete", async (req, reply) => {
+        try {
+            const body = req.body;
+            if (!body ||
+                !Array.isArray(body.sessionIds) ||
+                body.sessionIds.length === 0) {
+                reply.code(400);
+                return { error: "sessionIds must be a non-empty array" };
+            }
+            const deleted = [];
+            const errors = [];
+            for (const sessionId of body.sessionIds) {
+                try {
+                    const sessionTraceDir = findSessionTraceDir(sessionId);
+                    if (sessionTraceDir) {
+                        await store.deleteSession(sessionId, { traceDir: sessionTraceDir });
+                        deleted.push(sessionId);
+                    }
+                    else {
+                        errors.push({ sessionId, error: "Session not found" });
+                    }
+                }
+                catch (e) {
+                    errors.push({ sessionId, error: e.message });
+                }
+            }
+            return { success: true, deleted, errors };
+        }
+        catch (e) {
+            reply.code(500);
+            return { error: "Batch delete failed: " + e.message };
+        }
+    });
+    const watchDirs = [globalDir];
+    if (localDir && localDir !== globalDir) {
+        watchDirs.push(localDir);
+    }
+    const watcher = chokidar.watch(watchDirs, {
+        ignored: /(\.tmp$|\.parsed$)/,
+        persistent: true,
+        ignoreInitial: true,
+        depth: 2,
+    });
+    watcher.on("add", (filePath) => {
+        const match = filePath.match(/\/([^/]+)\/(\d+)\.json$/);
+        if (match) {
+            const sessionId = match[1];
+            const seq = parseInt(match[2], 10);
+            broadcastSSE("record:added", { sessionId, seq });
+        }
+    });
+    watcher.on("change", (filePath) => {
+        const match = filePath.match(/\/([^/]+)\/(\d+)\.json$/);
+        if (match) {
+            const sessionId = match[1];
+            const seq = parseInt(match[2], 10);
+            broadcastSSE("record:updated", { sessionId, seq });
+        }
+    });
+    watcher.on("unlink", (filePath) => {
+        const match = filePath.match(/\/([^/]+)\/(\d+)\.json$/);
+        if (match) {
+            const sessionId = match[1];
+            const seq = parseInt(match[2], 10);
+            // Clean up the ndjinx entry so the timeline fast path doesn't show ghost
+            // records pointing to deleted JSON files.
+            const sessionDir = dirname(filePath);
+            const ndjinxPath = join(sessionDir, "timeline.ndjinx");
+            try {
+                if (existsSync(ndjinxPath)) {
+                    const raw = readFileSync(ndjinxPath, "utf-8");
+                    const lines = raw
+                        .split("\n")
+                        .filter((l) => {
+                        if (!l.trim())
+                            return false;
+                        try {
+                            return JSON.parse(l).seq !== seq;
+                        }
+                        catch {
+                            return false;
+                        }
+                    });
+                    writeFileSync(ndjinxPath, lines.join("\n") + "\n");
+                }
+            }
+            catch {
+                // ndjinx cleanup is best-effort
+            }
+            broadcastSSE("record:deleted", { sessionId, seq });
+        }
+    });
+    watcher.on("addDir", (dirPath) => {
+        const match = dirPath.match(/\/([^/]+)$/);
+        if (match) {
+            const sessionId = match[1];
+            // Validate it's a real session dir (has at least one JSON file or metadata)
+            if (/^\d+\.json$/.test(sessionId))
+                return; // not a session dir (it's a record number match)
+            try {
+                const files = readdirSync(dirPath);
+                const hasRecord = files.some((f) => /^\d+\.json$/.test(f));
+                const hasMeta = files.some((f) => f === "metadata.json");
+                if (hasRecord || hasMeta) {
+                    broadcastSSE("session:created", { sessionId });
+                }
+            }
+            catch {
+                // best-effort validation
+            }
+        }
+    });
+    watcher.on("unlinkDir", (dirPath) => {
+        const match = dirPath.match(/\/([^/]+)$/);
+        if (match) {
+            const sessionId = match[1];
+            broadcastSSE("session:deleted", { sessionId });
+        }
+    });
+    let addr;
+    if (options?.noListen) {
+        addr = "http://localhost:0";
+    }
+    else {
+        await app.listen({ port, host: "0.0.0.0" });
+        addr = `http://localhost:${port}`;
+    }
     if (options?.open) {
         import("node:child_process").then(({ exec }) => {
             const cmd = process.platform === "darwin"
@@ -342,7 +710,12 @@ export async function createViewer(options) {
     }
     return {
         url: addr,
-        close: () => app.close(),
+        app,
+        close: async () => {
+            clearInterval(sseKeepAlive);
+            await watcher.close();
+            await app.close();
+        },
     };
 }
 //# sourceMappingURL=server.js.map