ocwatch 0.4.0 → 0.5.0

package/src/server/routes/poll.ts

@@ -1,54 +1,46 @@
 import type { Hono } from "hono";
 import { z } from "zod";
-import { 
-  generateETag, 
-  fetchPollData, 
-  getPollCache, 
-  setPollCache, 
+import {
+  generateETag,
+  fetchPollData,
+  getPollCache,
+  setPollCache,
   getPollCacheEpoch,
-  getPollInProgress, 
+  getPollInProgress,
   setPollInProgress,
-  getPollCacheTTL
+  getPollCacheTTL,
 } from "../services/pollService";
-import { sessionIdSchema, validateWithResponse } from "../validation";
 
 const projectIdSchema = z.string().regex(/^[a-zA-Z0-9_-]+$/, "Invalid project ID format");
 
 export function registerPollRoute(app: Hono) {
   app.get("/api/poll", async (c) => {
     const clientETag = c.req.header("If-None-Match");
-    const rawSessionId = c.req.query('sessionId');
     const rawProjectId = c.req.query("projectId");
-    
-    let sessionId: string | undefined;
-    let projectId: string | undefined;
 
-    if (rawSessionId) {
-      const validation = validateWithResponse(sessionIdSchema, rawSessionId, c);
-      if (!validation.success) return validation.response;
-      sessionId = validation.value;
-    }
+    let projectId: string | undefined;
 
     if (rawProjectId) {
-      const validation = validateWithResponse(projectIdSchema, rawProjectId, c);
-      if (!validation.success) return validation.response;
-      projectId = validation.value;
+      const result = projectIdSchema.safeParse(rawProjectId);
+      if (!result.success) {
+        return c.json({ error: "INVALID_PROJECT_ID", message: "Invalid project ID format" }, 400);
+      }
+      projectId = result.data;
     }
-    
+
     const POLL_CACHE_TTL = getPollCacheTTL();
-    const scopeProjectId = sessionId ? undefined : projectId;
-    
-    const cached = getPollCache(scopeProjectId);
-    if (!sessionId && cached && Date.now() - cached.timestamp < POLL_CACHE_TTL) {
+
+    const cached = getPollCache(projectId);
+    if (cached && Date.now() - cached.timestamp < POLL_CACHE_TTL) {
       if (clientETag === cached.etag) {
         return new Response(null, { status: 304, headers: { ETag: cached.etag } });
       }
       c.header("ETag", cached.etag);
       return c.json(cached.data);
     }
-    
-    const inProgress = getPollInProgress(scopeProjectId);
-    if (!sessionId && inProgress) {
+
+    const inProgress = getPollInProgress(projectId);
+    if (inProgress) {
       try {
         const data = await inProgress;
         const etag = generateETag(data);
@@ -58,28 +50,25 @@ export function registerPollRoute(app: Hono) {
         c.header("ETag", etag);
         return c.json(data);
       } catch {
-        setPollInProgress(null, scopeProjectId);
+        setPollInProgress(null, projectId);
       }
     }
-    
+
+    const cacheEpochAtStart = getPollCacheEpoch();
+    const promise = fetchPollData(projectId);
+    setPollInProgress(promise, projectId);
+
     let pollData: Awaited<ReturnType<typeof fetchPollData>>;
-    if (!sessionId) {
-      const cacheEpochAtStart = getPollCacheEpoch();
-      const promise = fetchPollData(undefined, projectId);
-      setPollInProgress(promise, scopeProjectId);
-      try {
-        pollData = await promise;
-        const etag = generateETag(pollData);
-        if (cacheEpochAtStart === getPollCacheEpoch()) {
-          setPollCache({ data: pollData, etag, timestamp: Date.now() }, scopeProjectId);
-        }
-      } finally {
-        setPollInProgress(null, scopeProjectId);
+    try {
+      pollData = await promise;
+      const etag = generateETag(pollData);
+      if (cacheEpochAtStart === getPollCacheEpoch()) {
+        setPollCache({ data: pollData, etag, timestamp: Date.now() }, projectId);
       }
-    } else {
-      pollData = await fetchPollData(sessionId, projectId);
+    } finally {
+      setPollInProgress(null, projectId);
     }
-    
+
     const etag = generateETag(pollData);
     if (clientETag === etag) {
       return new Response(null, { status: 304, headers: { ETag: etag } });

package/src/server/routes/projects.ts

@@ -1,10 +1,10 @@
 import type { Hono } from "hono";
-import { listProjects, listAllSessions } from "../storage/sessionParser";
+import { listProjects, listAllSessions } from "../storage";
 
 export function registerProjectRoutes(app: Hono) {
-  app.get("/api/projects", async (c) => {
-    const projectIDs = await listProjects();
-    const allSessions = await listAllSessions();
+  app.get("/api/projects", (c) => {
+    const projectIDs = listProjects();
+    const allSessions = listAllSessions();
 
     const projectsWithDetails = projectIDs.map((projectID) => {
       const projectSessions = allSessions.filter((s) => s.projectID === projectID);

package/src/server/routes/sessions.ts

@@ -1,58 +1,62 @@
 import type { Hono } from "hono";
-import { listAllSessions, checkStorageExists } from "../storage/sessionParser";
-import { listMessages } from "../storage/messageParser";
-import { isAssistantFinished, buildAgentHierarchy, buildSessionTree } from "../services/sessionService";
-import { getSessionStatus } from "../utils/sessionStatus";
+import { checkDbExists } from "../storage";
+import {
+  querySessions,
+  querySession,
+  queryMessages,
+  queryTodos,
+} from "../storage/queries";
+import type { DbSessionRow } from "../storage/queries";
+import { fetchSessionDetail } from "../services/pollService";
+import { toMessageMeta } from "../services/parsing";
+import { buildSessionTree } from "../services/sessionService";
 import { sessionIdSchema, validateWithResponse } from "../validation";
 import { MAX_SESSIONS_LIMIT, MAX_MESSAGES_LIMIT, TWENTY_FOUR_HOURS_MS } from "../../shared/constants";
+import type { SessionMetadata } from "../../shared/types";
+
+const SESSION_SCAN_LIMIT = 50_000;
+
+function dbRowToSessionBase(row: DbSessionRow) {
+  return {
+    id: row.id,
+    projectID: row.projectID,
+    title: row.title,
+    parentID: row.parentID ?? undefined,
+    updatedAt: new Date(row.timeUpdated),
+    createdAt: new Date(row.timeCreated),
+  };
+}
+
+function dbRowToSessionMeta(row: DbSessionRow): SessionMetadata {
+  return {
+    id: row.id,
+    projectID: row.projectID,
+    directory: row.directory,
+    title: row.title,
+    parentID: row.parentID ?? undefined,
+    createdAt: new Date(row.timeCreated),
+    updatedAt: new Date(row.timeUpdated),
+  };
+}
 
 export function registerSessionRoutes(app: Hono) {
-  app.get("/api/sessions", async (c) => {
-    const storageExists = await checkStorageExists();
-    if (!storageExists) {
-      return c.json({ 
+  app.get("/api/sessions", (c) => {
+    if (!checkDbExists()) {
+      return c.json({
         error: "OpenCode storage not found",
         message: "OpenCode storage directory does not exist. Please ensure OpenCode is installed.",
-        sessions: []
+        sessions: [],
       }, 200);
     }
 
-    const allSessions = await listAllSessions();
-
     const now = Date.now();
     const twentyFourHoursAgo = now - TWENTY_FOUR_HOURS_MS;
 
-    const recentSessions = allSessions.filter(
-      (s) => s.updatedAt.getTime() >= twentyFourHoursAgo
-    );
-
-    const sortedSessions = recentSessions.sort(
-      (a, b) => b.updatedAt.getTime() - a.updatedAt.getTime()
-    );
-
-    const limitedSessions = sortedSessions.slice(0, MAX_SESSIONS_LIMIT);
-    const rootSessions = limitedSessions.filter(s => !s.parentID);
-
-    const sessionsWithActivity = await Promise.all(
-      rootSessions.map(async (session) => {
-        const messages = await listMessages(session.id);
-        const lastAssistantFinished = isAssistantFinished(messages);
-        const status = getSessionStatus(messages, false, undefined, undefined, lastAssistantFinished);
-
-        return {
-          id: session.id,
-          title: session.title,
-          projectID: session.projectID,
-          parentID: session.parentID,
-          createdAt: session.createdAt,
-          updatedAt: session.updatedAt,
-          status,
-          isActive: status === "working" || status === "idle",
-        };
-      })
-    );
-
-    return c.json(sessionsWithActivity);
+    const sessions = querySessions(undefined, twentyFourHoursAgo, MAX_SESSIONS_LIMIT)
+      .filter((row) => !row.parentID)
+      .map(dbRowToSessionBase);
+
+    return c.json(sessions);
   });
 
   app.get("/api/sessions/:id", async (c) => {
@@ -60,59 +64,94 @@ export function registerSessionRoutes(app: Hono) {
     if (!validation.success) return validation.response;
     const sessionID = validation.value;
 
-    const allSessions = await listAllSessions();
-    const session = allSessions.find((s) => s.id === sessionID);
-
-    if (!session) {
+    if (!checkDbExists()) {
       return c.json({ error: "SESSION_NOT_FOUND", message: `Session '${sessionID}' not found`, status: 404 }, 404);
     }
 
-    const messages = await listMessages(sessionID);
-    const agentHierarchy = buildAgentHierarchy(messages);
+    const sessionRow = querySession(sessionID);
+    if (!sessionRow) {
+      return c.json({ error: "SESSION_NOT_FOUND", message: `Session '${sessionID}' not found`, status: 404 }, 404);
+    }
 
-    return c.json({
-      ...session,
-      agentHierarchy,
-    });
+    const detail = await fetchSessionDetail(sessionID);
+    return c.json(detail);
   });
 
-  app.get("/api/sessions/:id/messages", async (c) => {
+  app.get("/api/sessions/:id/messages", (c) => {
     const validation = validateWithResponse(sessionIdSchema, c.req.param("id"), c);
     if (!validation.success) return validation.response;
     const sessionID = validation.value;
 
-    const allSessions = await listAllSessions();
-    const session = allSessions.find((s) => s.id === sessionID);
+    if (!checkDbExists()) {
+      return c.json({ error: "SESSION_NOT_FOUND", message: `Session '${sessionID}' not found`, status: 404 }, 404);
+    }
 
-    if (!session) {
+    const sessionRow = querySession(sessionID);
+    if (!sessionRow) {
       return c.json({ error: "SESSION_NOT_FOUND", message: `Session '${sessionID}' not found`, status: 404 }, 404);
     }
 
-    const messages = await listMessages(sessionID);
+    const messages = queryMessages(sessionID, MAX_MESSAGES_LIMIT).map(toMessageMeta);
+    return c.json(messages);
+  });
 
-    const sortedMessages = messages.sort(
-      (a, b) => b.createdAt.getTime() - a.createdAt.getTime()
-    );
+  app.get("/api/sessions/:id/tree", async (c) => {
+    const validation = validateWithResponse(sessionIdSchema, c.req.param("id"), c);
+    if (!validation.success) return validation.response;
+    const sessionID = validation.value;
 
-    const limitedMessages = sortedMessages.slice(0, MAX_MESSAGES_LIMIT);
+    if (!checkDbExists()) {
+      return c.json({ error: "SESSION_NOT_FOUND", message: `Session '${sessionID}' not found`, status: 404 }, 404);
+    }
 
-    return c.json(limitedMessages);
+    const sessionRow = querySession(sessionID);
+    if (!sessionRow) {
+      return c.json({ error: "SESSION_NOT_FOUND", message: `Session '${sessionID}' not found`, status: 404 }, 404);
+    }
+
+    const allSessions = querySessions(undefined, undefined, SESSION_SCAN_LIMIT).map(dbRowToSessionMeta);
+    const tree = await buildSessionTree(sessionID, allSessions);
+    return c.json(tree);
   });
 
-  app.get("/api/sessions/:id/tree", async (c) => {
+  app.get("/api/sessions/:id/activity", async (c) => {
     const validation = validateWithResponse(sessionIdSchema, c.req.param("id"), c);
     if (!validation.success) return validation.response;
     const sessionID = validation.value;
 
-    const allSessions = await listAllSessions();
-    const session = allSessions.find((s) => s.id === sessionID);
+    if (!checkDbExists()) {
+      return c.json({ error: "SESSION_NOT_FOUND", message: `Session '${sessionID}' not found`, status: 404 }, 404);
+    }
 
-    if (!session) {
+    const sessionRow = querySession(sessionID);
+    if (!sessionRow) {
       return c.json({ error: "SESSION_NOT_FOUND", message: `Session '${sessionID}' not found`, status: 404 }, 404);
     }
 
-    const tree = await buildSessionTree(sessionID, allSessions);
+    const detail = await fetchSessionDetail(sessionID);
+    return c.json({ activity: detail.activity });
+  });
 
-    return c.json(tree);
+  app.get("/api/sessions/:id/todos", (c) => {
+    const validation = validateWithResponse(sessionIdSchema, c.req.param("id"), c);
+    if (!validation.success) return validation.response;
+    const sessionID = validation.value;
+
+    if (!checkDbExists()) {
+      return c.json([], 200);
+    }
+
+    const sessionRow = querySession(sessionID);
+    if (!sessionRow) {
+      return c.json({ error: "SESSION_NOT_FOUND", message: `Session '${sessionID}' not found`, status: 404 }, 404);
+    }
+
+    const todos = queryTodos(sessionID).map((row) => ({
+      content: row.content,
+      status: row.status,
+      priority: row.priority,
+      position: row.position,
+    }));
+    return c.json(todos);
   });
 }

package/src/server/routes/sse.ts

@@ -47,8 +47,11 @@ export function registerSSERoute(app: Hono) {
             data: JSON.stringify({ timestamp: Date.now() }),
             event: "heartbeat",
           });
-        } catch {
-          // Ignore errors when stream is closed
+        } catch (error) {
+          // Stream closed — expected during disconnect
+          if (error instanceof Error && error.message !== 'The stream has been aborted') {
+            console.debug('[sse] Heartbeat write failed:', error.message);
+          }
         }
       }, 30000);
 
@@ -72,8 +75,11 @@ export function registerSSERoute(app: Hono) {
             }),
             event: eventType,
           });
-        } catch {
-          // Ignore errors when stream is closed
+        } catch (error) {
+          // Stream closed — expected during disconnect
+          if (error instanceof Error && error.message !== 'The stream has been aborted') {
+            console.debug('[sse] Change event write failed:', error.message);
+          }
         }
       };
 

package/src/server/services/parsing.ts

@@ -0,0 +1,211 @@
+/**
+ * Shared parsing functions for converting database rows to domain types.
+ *
+ * This module is the SINGLE SOURCE OF TRUTH for DB row → domain object mapping.
+ * Both pollService and sessionService import from here — never duplicate these functions.
+ */
+
+import type {
+  SessionMetadata,
+  MessageMeta,
+  PartMeta,
+} from "../../shared/types";
+import type { DbSessionRow, DbMessageRow, DbPartRow } from "../storage/queries";
+import { isPendingToolCall } from "../logic";
+
+// ---------------------------------------------------------------------------
+// JSON shapes (internal to this module)
+// ---------------------------------------------------------------------------
+
+interface MessageJSON {
+  role?: string;
+  agent?: string;
+  mode?: string;
+  modelID?: string;
+  providerID?: string;
+  model?: {
+    modelID?: string;
+    providerID?: string;
+  };
+  parentID?: string;
+  cost?: number;
+  tokens?: {
+    input?: number;
+    output?: number;
+  };
+  finish?: string;
+  time?: {
+    created?: number;
+  };
+}
+
+interface PartStateJSON {
+  status?: string;
+  input?: Record<string, unknown>;
+  output?: string;
+  error?: string;
+  title?: string;
+  time?: {
+    start?: number;
+    end?: number;
+  };
+}
+
+interface PartJSON {
+  type?: string;
+  callID?: string;
+  tool?: string;
+  state?: string | PartStateJSON;
+  text?: string;
+  title?: string;
+  reason?: string;
+  files?: unknown;
+  input?: Record<string, unknown>;
+  time?: {
+    start?: number;
+    end?: number;
+  };
+  snapshot?: string;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+export function parseJsonData<T>(raw: unknown): T | null {
+  if (typeof raw === "string") {
+    try {
+      return JSON.parse(raw) as T;
+    } catch {
+      return null;
+    }
+  }
+
+  if (raw && typeof raw === "object") {
+    return raw as T;
+  }
+
+  return null;
+}
+
+function toStringOrUndefined(value: unknown): string | undefined {
+  return typeof value === "string" ? value : undefined;
+}
+
+function toDate(value: unknown): Date | undefined {
+  return typeof value === "number" ? new Date(value) : undefined;
+}
+
+function toStringArrayOrUndefined(value: unknown): string[] | undefined {
+  if (!Array.isArray(value)) {
+    return undefined;
+  }
+  const items = value.filter((item): item is string => typeof item === "string");
+  return items.length > 0 ? items : undefined;
+}
+
+// ---------------------------------------------------------------------------
+// Row → Domain converters
+// ---------------------------------------------------------------------------
+
+export function toSessionMetadata(row: DbSessionRow): SessionMetadata {
+  return {
+    id: row.id,
+    projectID: row.projectID,
+    directory: row.directory,
+    title: row.title,
+    parentID: row.parentID ?? undefined,
+    createdAt: new Date(row.timeCreated),
+    updatedAt: new Date(row.timeUpdated),
+  };
+}
+
+export function toMessageMeta(row: DbMessageRow): MessageMeta {
+  const json = parseJsonData<MessageJSON>(row.data) ?? {};
+  const tokenInput = json.tokens?.input;
+  const tokenOutput = json.tokens?.output;
+  const hasTokens = typeof tokenInput === "number" || typeof tokenOutput === "number";
+
+  return {
+    id: row.id,
+    sessionID: row.sessionID,
+    role: json.role ?? row.role ?? "unknown",
+    agent: toStringOrUndefined(json.agent),
+    mode: toStringOrUndefined(json.mode),
+    modelID: toStringOrUndefined(json.modelID) ?? toStringOrUndefined(json.model?.modelID),
+    providerID: toStringOrUndefined(json.providerID) ?? toStringOrUndefined(json.model?.providerID),
+    parentID: toStringOrUndefined(json.parentID),
+    tokens: hasTokens ? (tokenInput ?? 0) + (tokenOutput ?? 0) : undefined,
+    cost: typeof json.cost === "number" ? json.cost : undefined,
+    createdAt: new Date(json.time?.created ?? row.timeCreated),
+    finish: toStringOrUndefined(json.finish),
+  };
+}
+
+export function toPartMeta(row: DbPartRow): PartMeta {
+  const json = parseJsonData<PartJSON>(row.data) ?? {};
+
+  const stateObject = (typeof json.state === "object" && json.state !== null)
+    ? json.state as PartStateJSON
+    : undefined;
+
+  const state = toStringOrUndefined(json.state) ?? toStringOrUndefined(stateObject?.status) ?? row.state ?? undefined;
+
+  const nestedInput = (stateObject?.input && typeof stateObject.input === "object")
+    ? stateObject.input as Record<string, unknown>
+    : undefined;
+  const rootInput = (json.input && typeof json.input === "object")
+    ? json.input as Record<string, unknown>
+    : undefined;
+  const input = nestedInput ?? rootInput;
+
+  const title = toStringOrUndefined(stateObject?.title) ?? toStringOrUndefined(json.title);
+
+  const time = (json.time && typeof json.time === "object") ? json.time : stateObject?.time;
+  const startedAt = toDate(time?.start);
+  const completedAt = toDate(time?.end);
+
+  const errorRaw = toStringOrUndefined(stateObject?.error) ?? toStringOrUndefined(stateObject?.output);
+  const error = (state === "error" || state === "failed") && errorRaw
+    ? errorRaw.slice(0, 500)
+    : undefined;
+
+  const reason = json.reason;
+  const stepFinishReason = reason === "stop" || reason === "tool-calls" ? reason : undefined;
+  const type = toStringOrUndefined(json.type) ?? row.type ?? "unknown";
+
+  return {
+    id: row.id,
+    sessionID: row.sessionID,
+    messageID: row.messageID,
+    type,
+    callID: toStringOrUndefined(json.callID),
+    tool: toStringOrUndefined(json.tool) ?? row.tool ?? undefined,
+    state,
+    input,
+    title,
+    error,
+    startedAt,
+    completedAt,
+    stepSnapshot: toStringOrUndefined(json.snapshot),
+    stepFinishReason,
+    reasoningText: type === "reasoning" ? toStringOrUndefined(json.text) : undefined,
+    patchFiles: toStringArrayOrUndefined(json.files),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Common query helpers (used by both pollService and sessionService)
+// ---------------------------------------------------------------------------
+
+export function getLatestAssistantMessage(messages: MessageMeta[]): MessageMeta | undefined {
+  return messages
+    .filter((message) => message.role === "assistant")
+    .sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime())[0];
+}
+
+export function getMostRecentPendingPart(parts: PartMeta[]): PartMeta | undefined {
+  return parts
+    .filter((part) => isPendingToolCall(part))
+    .sort((a, b) => (b.startedAt?.getTime() || 0) - (a.startedAt?.getTime() || 0))[0];
+}