ocwatch 0.4.0 → 0.6.0

package/src/server/utils/sessionStatus.ts

@@ -3,100 +3,17 @@
  * Determines session status based on message timestamps and tool call state
  */
 
-import type { MessageMeta, SessionStatus } from "../../shared/types";
-import { isPendingToolCall } from "../storage/partParser";
+import type { SessionStatus } from "../../shared/types";
+import { isPendingToolCall } from "../logic/activityLogic";
+import { getSessionStatusInfo } from "../logic/sessionLogic";
 
 export type { SessionStatus };
-export { isPendingToolCall };
-export type WaitingReason = "user" | "children";
-
-export interface SessionStatusInfo {
-  status: SessionStatus;
-  waitingReason?: WaitingReason;
-}
+export { isPendingToolCall, getSessionStatusInfo };
+export type { WaitingReason, SessionStatusInfo } from "../logic/sessionLogic";
 
 // Thresholds in milliseconds
 const WORKING_THRESHOLD = 30 * 1000; // 30 seconds
 const COMPLETED_THRESHOLD = 5 * 60 * 1000; // 5 minutes
-const GRACE_PERIOD = 5 * 1000; // 5 seconds
-
-export function getSessionStatus(
-  messages: MessageMeta[],
-  hasPendingToolCall: boolean = false,
-  lastToolCompletedAt?: Date,
-  workingChildCount?: number,
-  lastAssistantFinished?: boolean,
-  isSubagent: boolean = false
-): SessionStatus {
-  return getSessionStatusInfo(
-    messages,
-    hasPendingToolCall,
-    lastToolCompletedAt,
-    workingChildCount,
-    lastAssistantFinished,
-    isSubagent
-  ).status;
-}
-
-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" };
-  }
-
-  // Calculate time since last message early (needed for multiple checks)
-  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();
-  }
-
-  // Assistant finished turn - only applies for RECENT sessions (< 5 min)
-  // Old sessions (>= 5 min) fall through to time-based status instead of showing "waiting"
-  if (lastAssistantFinished && timeSinceLastMessage < COMPLETED_THRESHOLD) {
-    if (isSubagent) {
-      return { status: "completed" };
-    }
-    return { status: "waiting", waitingReason: "user" };
-  }
-
-  // Grace period after tool completion
-  if (lastToolCompletedAt) {
-    const now = Date.now();
-    const timeSinceToolCompleted = now - lastToolCompletedAt.getTime();
-    if (timeSinceToolCompleted < GRACE_PERIOD) {
-      return { status: "working" };
-    }
-  }
-
-  // Time-based status from message timestamps
-  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" };
-  }
-}
-
-
-
 /**
  * Get status from timestamp directly (for simpler cases)
  * Used when you only have the updatedAt timestamp
@@ -120,4 +37,3 @@ export function getStatusFromTimestamp(
     return "completed";
   }
 }
-

package/src/server/validation.ts

@@ -5,14 +5,12 @@ export const sessionIdSchema = z.string().regex(/^ses_[a-zA-Z0-9]+$/, 'Invalid s
 
 export const partIdSchema = z.string().min(1, 'Part ID required');
 
+export const projectIdSchema = z.string().regex(/^[a-zA-Z0-9_-]+$/, 'Invalid project ID format');
+
 export const pollQuerySchema = z.object({
   sessionId: sessionIdSchema.optional(),
 });
 
-export function validateParam<T>(schema: z.ZodSchema<T>, value: unknown): T {
-  return schema.parse(value);
-}
-
 export type ValidationResult<T> = { success: true; value: T } | { success: false; response: Response };
 
 export function validateWithResponse<T>(

package/src/server/watcher.ts

@@ -1,32 +1,39 @@
-/**
- * Watcher - File system watcher for OpenCode storage directories
- * Uses fs.watch() to detect changes and trigger cache invalidation
- */
-
-import { watch, type FSWatcher } from "node:fs";
-import { join } from "node:path";
+import { existsSync, statSync, watch, type FSWatcher } from "node:fs";
+import { basename, join } from "node:path";
 import { EventEmitter } from "node:events";
-import { getStoragePath } from "./storage/sessionParser";
+import { homedir } from "node:os";
 
 export interface WatcherOptions {
+  dbPath?: string;
   storagePath?: string;
   projectPath?: string;
   debounceMs?: number;
 }
 
 export class Watcher extends EventEmitter {
-  private watchers: FSWatcher[] = [];
+  private dbWatcher: FSWatcher | null = null;
+  private boulderWatcher: FSWatcher | null = null;
   private debounceTimer: Timer | null = null;
+  private rebindTimer: Timer | null = null;
   private readonly debounceMs: number;
-  private readonly storagePath: string;
+  private readonly dbPath: string;
+  private readonly walPath: string;
+  private readonly boulderPath: string;
+  private readonly boulderDirPath: string;
   private readonly projectPath: string;
+  private dbWatcherTarget: string | null = null;
+  private boulderWatcherTarget: string | null = null;
+  private lastKnownBoulderSignature: string | null = null;
   private isRunning: boolean = false;
 
   constructor(options: WatcherOptions = {}) {
     super();
-    this.storagePath = options.storagePath || getStoragePath();
+    this.dbPath = resolveDbPath(options);
+    this.walPath = `${this.dbPath}-wal`;
     this.projectPath = options.projectPath || process.cwd();
-    this.debounceMs = options.debounceMs || 100;
+    this.boulderPath = join(this.projectPath, ".sisyphus", "boulder.json");
+    this.boulderDirPath = join(this.projectPath, ".sisyphus");
+    this.debounceMs = options.debounceMs ?? 100;
   }
 
   start(): void {
@@ -36,58 +43,10 @@ export class Watcher extends EventEmitter {
 
     this.isRunning = true;
 
-    const sessionDir = join(this.storagePath, "opencode", "storage", "session");
-    const messageDir = join(this.storagePath, "opencode", "storage", "message");
-
     try {
-      const sessionWatcher = watch(
-        sessionDir,
-        { recursive: true },
-        this.handleChange.bind(this)
-      );
-      this.watchers.push(sessionWatcher);
-
-      const messageWatcher = watch(
-        messageDir,
-        { recursive: true },
-        this.handleChange.bind(this)
-      );
-      this.watchers.push(messageWatcher);
-
-      const partDir = join(this.storagePath, "opencode", "storage", "part");
-      try {
-        const partWatcher = watch(
-          partDir,
-          { recursive: true },
-          this.handleChange.bind(this)
-        );
-        this.watchers.push(partWatcher);
-      } catch {
-        // part directory may not exist yet
-      }
-
-      const boulderDir = join(this.projectPath, ".sisyphus");
-      try {
-        const boulderWatcher = watch(
-          boulderDir,
-          { recursive: true },
-          this.handleChange.bind(this)
-        );
-        this.watchers.push(boulderWatcher);
-      } catch {
-        // boulder directory may not exist yet
-      }
-
-      try {
-        const projectWatcher = watch(
-          this.projectPath,
-          { recursive: true },
-          this.handleProjectChange.bind(this)
-        );
-        this.watchers.push(projectWatcher);
-      } catch {
-        // project watcher may fail on unsupported environments
-      }
+      this.rebindDbWatcher();
+      this.rebindBoulderWatcher();
+      this.startRebindLoop();
 
       this.emit("started");
     } catch (error) {
@@ -96,15 +55,7 @@ export class Watcher extends EventEmitter {
     }
   }
 
-  private handleChange(eventType: string, filename: string | null): void {
-    if (!filename) {
-      return;
-    }
-
-    if (!filename.endsWith(".json")) {
-      return;
-    }
-
+  private emitDebouncedChange(eventType: string, filename: string): void {
     if (this.debounceTimer) {
       clearTimeout(this.debounceTimer);
     }
@@ -115,20 +66,174 @@ export class Watcher extends EventEmitter {
     }, this.debounceMs);
   }
 
-  private handleProjectChange(eventType: string, filename: string | null): void {
-    if (!filename) {
+  private getPreferredDbWatchTarget(): string {
+    if (existsSync(this.walPath)) {
+      return this.walPath;
+    }
+
+    return this.dbPath;
+  }
+
+  private rebindDbWatcher(): void {
+    const preferredTarget = this.getPreferredDbWatchTarget();
+    if (this.dbWatcher && this.dbWatcherTarget === preferredTarget) {
       return;
     }
 
-    if (!filename.endsWith(".json")) {
+    if (this.dbWatcher) {
+      this.dbWatcher.close();
+      this.dbWatcher = null;
+      this.dbWatcherTarget = null;
+    }
+
+    if (!existsSync(preferredTarget)) {
       return;
     }
 
-    if (!filename.includes(".sisyphus") && !filename.includes("boulder")) {
+    try {
+      this.dbWatcher = watch(preferredTarget, (eventType, filename) => {
+        this.handleDbEvent(eventType, filename);
+      });
+      this.dbWatcherTarget = preferredTarget;
+    } catch (error) {
+      const code = (error as NodeJS.ErrnoException).code;
+      if (code === "ENOENT") {
+        return;
+      }
+      throw error;
+    }
+  }
+
+  private handleDbEvent(eventType: string, _filename: string | null): void {
+    const watchedTarget = this.dbWatcherTarget;
+    if (!watchedTarget) {
       return;
     }
 
-    this.handleChange(eventType, filename);
+    this.emitDebouncedChange(eventType, basename(watchedTarget));
+
+    if (eventType === "rename" || !existsSync(watchedTarget)) {
+      this.rebindDbWatcherSafe();
+      return;
+    }
+
+    if (this.getPreferredDbWatchTarget() !== watchedTarget) {
+      this.rebindDbWatcherSafe();
+    }
+  }
+
+  private rebindBoulderWatcher(): void {
+    const preferredTarget = existsSync(this.boulderPath)
+      ? this.boulderPath
+      : this.boulderDirPath;
+
+    if (this.boulderWatcher && this.boulderWatcherTarget === preferredTarget) {
+      return;
+    }
+
+    if (this.boulderWatcher) {
+      this.boulderWatcher.close();
+      this.boulderWatcher = null;
+      this.boulderWatcherTarget = null;
+    }
+
+    if (!existsSync(preferredTarget)) {
+      return;
+    }
+
+    this.boulderWatcher = watch(preferredTarget, (eventType, filename) => {
+      this.handleBoulderEvent(eventType, filename);
+    });
+    this.boulderWatcherTarget = preferredTarget;
+    this.lastKnownBoulderSignature = this.getBoulderSignature();
+  }
+
+  private handleBoulderEvent(eventType: string, filename: string | null): void {
+    const currentSignature = this.getBoulderSignature();
+    const signatureChanged = currentSignature !== this.lastKnownBoulderSignature;
+
+    if (this.boulderWatcherTarget === this.boulderDirPath) {
+      if (filename && filename !== "boulder.json" && !signatureChanged) {
+        return;
+      }
+
+      if (!filename && !signatureChanged) {
+        return;
+      }
+    }
+
+    this.lastKnownBoulderSignature = currentSignature;
+    this.emitDebouncedChange(eventType, ".sisyphus/boulder.json");
+
+    if (eventType === "rename") {
+      this.rebindBoulderWatcherSafe();
+      return;
+    }
+
+    const preferredTarget = existsSync(this.boulderPath)
+      ? this.boulderPath
+      : this.boulderDirPath;
+    if (preferredTarget !== this.boulderWatcherTarget) {
+      this.rebindBoulderWatcherSafe();
+    }
+  }
+
+  private getBoulderSignature(): string | null {
+    try {
+      const stats = statSync(this.boulderPath);
+      return `${stats.size}:${stats.mtimeMs}`;
+    } catch {
+      return null;
+    }
+  }
+
+  private pollForBoulderChanges(): void {
+    const currentSignature = this.getBoulderSignature();
+    if (currentSignature === this.lastKnownBoulderSignature) {
+      return;
+    }
+
+    this.lastKnownBoulderSignature = currentSignature;
+    this.emitDebouncedChange("change", ".sisyphus/boulder.json");
+
+    const preferredTarget = existsSync(this.boulderPath)
+      ? this.boulderPath
+      : this.boulderDirPath;
+    if (preferredTarget !== this.boulderWatcherTarget) {
+      this.rebindBoulderWatcherSafe();
+    }
+  }
+
+  private startRebindLoop(): void {
+    if (this.rebindTimer) {
+      clearInterval(this.rebindTimer);
+    }
+
+    this.rebindTimer = setInterval(() => {
+      if (!this.isRunning) {
+        return;
+      }
+
+      this.pollForBoulderChanges();
+      this.rebindDbWatcherSafe();
+      this.rebindBoulderWatcherSafe();
+    }, 100);
+  }
+
+  private rebindDbWatcherSafe(): void {
+    try {
+      this.rebindDbWatcher();
+    } catch (error) {
+      console.warn('[watcher] Failed to rebind DB watcher:', error instanceof Error ? error.message : error);
+    }
+  }
+
+  private rebindBoulderWatcherSafe(): void {
+    try {
+      this.rebindBoulderWatcher();
+    } catch (error) {
+      console.warn('[watcher] Failed to rebind boulder watcher:', error instanceof Error ? error.message : error);
+    }
   }
 
   stop(): void {
@@ -141,20 +246,58 @@ export class Watcher extends EventEmitter {
       this.debounceTimer = null;
     }
 
-    for (const watcher of this.watchers) {
-      watcher.close();
+    if (this.rebindTimer) {
+      clearInterval(this.rebindTimer);
+      this.rebindTimer = null;
+    }
+
+    if (this.dbWatcher) {
+      this.dbWatcher.close();
+      this.dbWatcher = null;
+      this.dbWatcherTarget = null;
+    }
+
+    if (this.boulderWatcher) {
+      this.boulderWatcher.close();
+      this.boulderWatcher = null;
+      this.boulderWatcherTarget = null;
     }
 
-    this.watchers = [];
+    this.lastKnownBoulderSignature = null;
     this.isRunning = false;
     this.emit("stopped");
   }
 
+  close(): void {
+    this.stop();
+  }
+
   getIsRunning(): boolean {
     return this.isRunning;
   }
 }
 
-export function createWatcher(storagePath?: string, projectPath?: string): Watcher {
-  return new Watcher({ storagePath, projectPath });
+function resolveDbPath(options: WatcherOptions): string {
+  if (options.dbPath) {
+    return normalizeDbPathInput(options.dbPath);
+  }
+
+  if (options.storagePath) {
+    return join(options.storagePath, "opencode", "opencode.db");
+  }
+
+  const storageRoot = process.env.XDG_DATA_HOME || join(homedir(), ".local", "share");
+  return join(storageRoot, "opencode", "opencode.db");
+}
+
+function normalizeDbPathInput(dbPathOrStoragePath: string): string {
+  if (dbPathOrStoragePath.endsWith(".db")) {
+    return dbPathOrStoragePath;
+  }
+
+  return join(dbPathOrStoragePath, "opencode", "opencode.db");
+}
+
+export function createWatcher(dbPath?: string, projectPath?: string): Watcher {
+  return new Watcher({ dbPath, projectPath });
 }

package/src/shared/constants.ts

@@ -5,11 +5,9 @@
 export const DEFAULT_PORT = 50234 as const;
 export const API_BASE_URL = `http://localhost:${DEFAULT_PORT}`;
 
-// Time constants
-export const TWENTY_FOUR_HOURS_MS = 86400000 as const;
-
 // API limits
 export const MAX_SESSIONS_LIMIT = 20 as const;
+/** Messages returned per session in API responses (client-facing limit) */
 export const MAX_MESSAGES_LIMIT = 100 as const;
 
 // Cache TTL
@@ -20,3 +18,10 @@ export const RINGBUFFER_CAPACITY = 1000 as const;
 
 // Session hierarchy depth limit
 export const MAX_RECURSION_DEPTH = 10 as const;
+
+/** Internal upper bound for session queries (not client-facing) */
+export const SESSION_SCAN_LIMIT = 50_000 as const;
+/** Internal upper bound for message queries per session (not client-facing) */
+export const MESSAGE_SCAN_LIMIT = 10_000 as const;
+/** Cooldown between notifications for the same session (ms) */
+export const NOTIFICATION_COOLDOWN_MS = 10_000 as const;

package/src/shared/index.ts

@@ -1,2 +1,5 @@
 export const VERSION = "0.1.0";
 export const PROJECT_NAME = "OCWatch";
+
+export { synthesizeActivityItems } from './utils/activityUtils';
+export { RingBuffer } from './utils/RingBuffer';

package/src/shared/types/index.ts

@@ -21,6 +21,36 @@ export interface SessionMetadata {
   updatedAt: Date;
 }
 
+/**
+ * SessionSummary is a lightweight session representation used in poll responses
+ * and as the summary field in SessionDetail
+ */
+export interface SessionSummary {
+  id: string;
+  projectID: string;
+  title: string;
+  status?: SessionStatus;
+  activityType?: SessionActivityType;
+  currentAction?: string | null;
+  agent?: string | null;
+  modelID?: string | null;
+  providerID?: string | null;
+  updatedAt: Date;
+  createdAt: Date;
+}
+
+/**
+ * SessionDetail is the full detail response for a single session
+ * Contains summary, messages, activity tree, todos, and optional stats
+ */
+export interface SessionDetail {
+  session: SessionSummary;
+  messages: MessageMeta[];
+  activity: ActivitySession[];
+  todos: TodoItem[];
+  stats?: SessionStats;
+}
+
 /**
  * MessageMeta represents a message in a session
  */
@@ -44,11 +74,13 @@ export interface MessageMeta {
  * Includes agent info and hierarchy
  */
 export type SessionActivityType = "tool" | "reasoning" | "patch" | "waiting-tools" | "waiting-user" | "idle";
+export type ActivityNodeKind = "session" | "phase";
 
 export interface ActivitySession {
   id: string;
   title: string;
   agent: string;
+  nodeKind?: ActivityNodeKind;
   modelID?: string;
   providerID?: string;
   parentID?: string;
@@ -96,17 +128,6 @@ export interface PartMeta {
   patchFiles?: string[];
 }
 
-/**
- * AgentInfo represents an active agent
- */
-export interface AgentInfo {
-  name: string;
-  mode: string;
-  modelID: string;
-  active: boolean;
-  sessionID: string;
-}
-
 /**
  * ToolCall represents a tool invocation
  */
@@ -184,41 +205,6 @@ export type ActivityItem =
   | AgentSpawnActivity
   | AgentCompleteActivity;
 
-/**
- * BurstEntry represents a burst of tool call activity
- * Groups consecutive tool calls from the same agent with aggregated metrics
- */
-export interface BurstEntry {
-  id: string;
-  type: "burst";
-  agentName: string;
-  items: ToolCallActivity[];
-  toolBreakdown: Record<string, number>;
-  durationMs: number;
-  firstTimestamp: Date;
-  lastTimestamp: Date;
-  pendingCount: number;
-  errorCount: number;
-}
-
-/**
- * MilestoneEntry represents a significant event in the activity stream
- * (agent spawn or agent complete)
- */
-export interface MilestoneEntry {
-  id: string;
-  type: "milestone";
-  item: AgentSpawnActivity | AgentCompleteActivity;
-}
-
-/**
- * StreamEntry is a union type for activity stream entries
- * Represents either a burst of tool calls or a milestone event
- */
-export type StreamEntry = BurstEntry | MilestoneEntry;
-
-export { synthesizeActivityItems } from '../utils/activityUtils';
-
 /**
  * PlanProgress represents progress on a plan
  */
@@ -229,6 +215,13 @@ export interface PlanProgress {
   tasks: Array<{ description: string; completed: boolean }>;
 }
 
+export interface TodoItem {
+  content: string;
+  status: string;
+  priority: string;
+  position: number;
+}
+
 /**
  * ModelTokens represents token usage for a specific model
  */
@@ -247,6 +240,13 @@ export interface SessionStats {
   modelBreakdown: ModelTokens[];
 }
 
+export interface SessionActivityResponse {
+  session: SessionSummary;
+  activity: ActivitySession[];
+  stats: SessionStats | null;
+  revision: number;
+}
+
 /**
  * Boulder represents the current plan state
  */
@@ -316,14 +316,9 @@ export interface AgentPhase {
  * Contains current session state, plan progress, and activity data
  */
 export interface PollResponse {
-  sessions: SessionMetadata[];
-  activeSession: SessionMetadata | null;
+  sessions: SessionSummary[];
+  activeSessionId: string | null;
   planProgress: PlanProgress | null;
   planName?: string;
-  messages: MessageMeta[];
-  activitySessions: ActivitySession[];
-  sessionStats?: SessionStats;
   lastUpdate: number;
 }
-
-export { RingBuffer } from '../utils/RingBuffer';

package/src/shared/utils/activityUtils.ts

@@ -12,8 +12,9 @@ export function synthesizeActivityItems(
   });
 
   sessions.forEach((session) => {
-    if (session.parentID && sessionMap.has(session.parentID)) {
-      const parent = sessionMap.get(session.parentID)!;
+    if (session.parentID) {
+      const parent = sessionMap.get(session.parentID);
+      if (!parent) return;
       items.push({
         id: `spawn-${session.id}`,
         type: "agent-spawn",