ocwatch 0.4.0 → 0.6.0

package/src/server/logic/sessionLogic.ts

@@ -0,0 +1,107 @@
+import type { AgentPhase, MessageMeta, SessionStatus } from "../../shared/types";
+
+export type WaitingReason = "user" | "children";
+
+export interface SessionStatusInfo {
+  status: SessionStatus;
+  waitingReason?: WaitingReason;
+}
+
+const WORKING_THRESHOLD = 30 * 1000;
+const COMPLETED_THRESHOLD = 5 * 60 * 1000;
+const GRACE_PERIOD = 5 * 1000;
+
+export function isAssistantFinished(messages: MessageMeta[]): boolean {
+  if (messages.length === 0) {
+    return false;
+  }
+
+  const lastMessage = messages.reduce((latest, current) =>
+    current.createdAt.getTime() > latest.createdAt.getTime() ? current : latest
+  );
+
+  return lastMessage.role === "assistant" && lastMessage.finish === "stop";
+}
+
+export function detectAgentPhases(messages: MessageMeta[]): AgentPhase[] {
+  const sorted = messages
+    .filter(m => m.role === "assistant" && m.agent)
+    .sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+
+  if (sorted.length === 0) return [];
+
+  const phases: AgentPhase[] = [];
+  let currentPhase: AgentPhase | null = null;
+
+  for (const msg of sorted) {
+    if (!currentPhase || currentPhase.agent !== msg.agent) {
+      if (currentPhase) phases.push(currentPhase);
+      currentPhase = {
+        agent: msg.agent!,
+        startTime: msg.createdAt,
+        endTime: msg.createdAt,
+        tokens: msg.tokens || 0,
+        messageCount: 1,
+      };
+    } else {
+      currentPhase.endTime = msg.createdAt;
+      currentPhase.tokens += msg.tokens || 0;
+      currentPhase.messageCount++;
+    }
+  }
+  if (currentPhase) phases.push(currentPhase);
+
+  return phases;
+}
+
+export function getSessionStatusInfo(
+  messages: MessageMeta[],
+  hasPendingToolCall: boolean = false,
+  lastToolCompletedAt?: Date,
+  workingChildCount?: number,
+  lastAssistantFinished?: boolean,
+  isSubagent: boolean = false
+): SessionStatusInfo {
+  if (hasPendingToolCall) {
+    return { status: "working" };
+  }
+
+  if (workingChildCount && workingChildCount > 0) {
+    return { status: "waiting", waitingReason: "children" };
+  }
+
+  let timeSinceLastMessage = Infinity;
+  if (messages && messages.length > 0) {
+    const lastMessage = messages.reduce((latest, msg) =>
+      msg.createdAt.getTime() > latest.createdAt.getTime() ? msg : latest
+    );
+    timeSinceLastMessage = Date.now() - lastMessage.createdAt.getTime();
+  }
+
+  if (lastAssistantFinished && timeSinceLastMessage < COMPLETED_THRESHOLD) {
+    if (isSubagent) {
+      return { status: "completed" };
+    }
+    return { status: "waiting", waitingReason: "user" };
+  }
+
+  if (lastToolCompletedAt) {
+    const now = Date.now();
+    const timeSinceToolCompleted = now - lastToolCompletedAt.getTime();
+    if (timeSinceToolCompleted < GRACE_PERIOD) {
+      return { status: "working" };
+    }
+  }
+
+  if (!messages || messages.length === 0) {
+    return { status: "completed" };
+  }
+
+  if (timeSinceLastMessage < WORKING_THRESHOLD) {
+    return { status: "working" };
+  } else if (timeSinceLastMessage < COMPLETED_THRESHOLD) {
+    return { status: "idle" };
+  } else {
+    return { status: "completed" };
+  }
+}

package/src/server/routes/parts.ts

@@ -1,19 +1,21 @@
 import type { Hono } from "hono";
-import { getPart } from "../storage/partParser";
+import { queryPart } from "../storage/queries";
+import { toPartMeta } from "../services/parsing";
 import { partIdSchema, validateWithResponse } from "../validation";
 
 export function registerPartRoutes(app: Hono) {
-  app.get("/api/parts/:id", async (c) => {
+  app.get("/api/parts/:id", (c) => {
     const validation = validateWithResponse(partIdSchema, c.req.param("id"), c);
     if (!validation.success) return validation.response;
     const partID = validation.value;
-    
-    const part = await getPart(partID);
-    
-    if (!part) {
+
+    const row = queryPart(partID);
+
+    if (!row) {
       return c.json({ error: "PART_NOT_FOUND", message: `Part '${partID}' not found`, status: 404 }, 404);
     }
-    
+
+    const part = toPartMeta(row);
     return c.json(part);
   });
 }

package/src/server/routes/poll.ts

@@ -1,54 +1,42 @@
 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");
+import { projectIdSchema, validateWithResponse } from "../validation";
 
 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 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);
@@ -57,29 +45,27 @@ export function registerPollRoute(app: Hono) {
         }
         c.header("ETag", etag);
         return c.json(data);
-      } catch {
-        setPollInProgress(null, scopeProjectId);
+      } catch (err) {
+        console.warn("Poll request failed, retrying:", err instanceof Error ? err.message : err);
+        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,34 +1,17 @@
 import type { Hono } from "hono";
-import { listProjects, listAllSessions } from "../storage/sessionParser";
+import { queryProjectSummaries } 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 summaries = queryProjectSummaries();
 
-    const projectsWithDetails = projectIDs.map((projectID) => {
-      const projectSessions = allSessions.filter((s) => s.projectID === projectID);
-      const directory = projectSessions[0]?.directory || "";
+    const projects = summaries.map((row) => ({
+      id: row.id,
+      directory: row.worktree,
+      sessionCount: row.sessionCount,
+      lastActivityAt: new Date(row.lastActivityAt),
+    }));
 
-      const lastActivityAt =
-        projectSessions.length > 0
-          ? new Date(
-              Math.max(...projectSessions.map((s) => s.updatedAt.getTime()))
-            )
-          : new Date(0);
-
-      return {
-        id: projectID,
-        directory,
-        sessionCount: projectSessions.length,
-        lastActivityAt,
-      };
-    });
-
-    projectsWithDetails.sort(
-      (a, b) => b.lastActivityAt.getTime() - a.lastActivityAt.getTime()
-    );
-
-    return c.json(projectsWithDetails);
+    return c.json(projects);
   });
 }

package/src/server/routes/sessions.ts

@@ -1,118 +1,209 @@
 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 {
+  fetchSessionActivity,
+  fetchSessionDetail,
+  generateSessionActivityETag,
+  getPollCacheEpoch,
+  getSessionActivityCache,
+  getSessionActivityInProgress,
+  setSessionActivityCache,
+  setSessionActivityInProgress,
+} from "../services/pollService";
+import { toMessageMeta } from "../services/parsing";
+import { selectRecentRootSessions } from "../services/recentSessions";
+import { buildSessionTree } from "../services/sessionTree";
 import { sessionIdSchema, validateWithResponse } from "../validation";
-import { MAX_SESSIONS_LIMIT, MAX_MESSAGES_LIMIT, TWENTY_FOUR_HOURS_MS } from "../../shared/constants";
+import { MAX_SESSIONS_LIMIT, MAX_MESSAGES_LIMIT, SESSION_SCAN_LIMIT } from "../../shared/constants";
+import type { SessionActivityResponse, SessionMetadata } from "../../shared/types";
+
+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 sessions = selectRecentRootSessions(
+      querySessions(undefined, undefined, SESSION_SCAN_LIMIT).map(dbRowToSessionBase),
+      MAX_SESSIONS_LIMIT,
+    );
 
-    const now = Date.now();
-    const twentyFourHoursAgo = now - TWENTY_FOUR_HOURS_MS;
+    return c.json(sessions);
+  });
 
-    const recentSessions = allSessions.filter(
-      (s) => s.updatedAt.getTime() >= twentyFourHoursAgo
-    );
+  app.get("/api/sessions/:id", async (c) => {
+    const validation = validateWithResponse(sessionIdSchema, c.req.param("id"), c);
+    if (!validation.success) return validation.response;
+    const sessionID = validation.value;
 
-    const sortedSessions = recentSessions.sort(
-      (a, b) => b.updatedAt.getTime() - a.updatedAt.getTime()
-    );
+    if (!checkDbExists()) {
+      return c.json({ error: "SESSION_NOT_FOUND", message: `Session '${sessionID}' not found`, status: 404 }, 404);
+    }
 
-    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",
-        };
-      })
-    );
+    const sessionRow = querySession(sessionID);
+    if (!sessionRow) {
+      return c.json({ error: "SESSION_NOT_FOUND", message: `Session '${sessionID}' not found`, status: 404 }, 404);
+    }
 
-    return c.json(sessionsWithActivity);
+    const detail = await fetchSessionDetail(sessionID);
+    return c.json(detail);
   });
 
-  app.get("/api/sessions/:id", 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);
+    }
+
+    const sessionRow = querySession(sessionID);
+    if (!sessionRow) {
+      return c.json({ error: "SESSION_NOT_FOUND", message: `Session '${sessionID}' not found`, status: 404 }, 404);
+    }
+
+    const messages = queryMessages(sessionID, MAX_MESSAGES_LIMIT).map(toMessageMeta);
+    return c.json(messages);
+  });
+
+  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;
 
-    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 allSessions = querySessions(undefined, undefined, SESSION_SCAN_LIMIT).map(dbRowToSessionMeta);
+    const tree = await buildSessionTree(sessionID, allSessions);
+    return c.json(tree);
   });
 
-  app.get("/api/sessions/:id/messages", 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 clientETag = c.req.header("If-None-Match");
 
-    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 cached = getSessionActivityCache(sessionID);
+    if (cached) {
+      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 sortedMessages = messages.sort(
-      (a, b) => b.createdAt.getTime() - a.createdAt.getTime()
-    );
+    const inProgress = getSessionActivityInProgress(sessionID);
+    if (inProgress) {
+      try {
+        const data = await inProgress;
+        const etag = generateSessionActivityETag(data);
+        if (clientETag === etag) {
+          return new Response(null, { status: 304, headers: { ETag: etag } });
+        }
+        c.header("ETag", etag);
+        return c.json(data);
+      } catch (err) {
+        console.warn("Session activity request failed, retrying:", err instanceof Error ? err.message : err);
+        setSessionActivityInProgress(sessionID, null);
+      }
+    }
 
-    const limitedMessages = sortedMessages.slice(0, MAX_MESSAGES_LIMIT);
+    const cacheEpochAtStart = getPollCacheEpoch();
+    const promise = fetchSessionActivity(sessionID);
+    setSessionActivityInProgress(sessionID, promise);
+
+    let data: SessionActivityResponse;
+    try {
+      data = await promise;
+      const etag = generateSessionActivityETag(data);
+      if (cacheEpochAtStart === getPollCacheEpoch()) {
+        setSessionActivityCache(sessionID, { data, etag });
+      }
+    } finally {
+      setSessionActivityInProgress(sessionID, null);
+    }
+
+    const etag = generateSessionActivityETag(data);
+    if (clientETag === etag) {
+      return new Response(null, { status: 304, headers: { ETag: etag } });
+    }
 
-    return c.json(limitedMessages);
+    c.header("ETag", etag);
+    return c.json(data);
   });
 
-  app.get("/api/sessions/:id/tree", async (c) => {
+  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;
 
-    const allSessions = await listAllSessions();
-    const session = allSessions.find((s) => s.id === sessionID);
+    if (!checkDbExists()) {
+      return c.json([], 200);
+    }
 
-    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);
-
-    return c.json(tree);
+    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);
+          }
         }
       };