ocwatch 0.4.0 → 0.5.0

package/src/server/watcher.ts

@@ -1,32 +1,38 @@
-/**
- * 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, 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 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 +42,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 +54,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 +65,138 @@ 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 (this.dbWatcher) {
+      this.dbWatcher.close();
+      this.dbWatcher = null;
+      this.dbWatcherTarget = null;
+    }
+
+    if (!existsSync(preferredTarget)) {
+      return;
+    }
+
+    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;
     }
 
-    if (!filename.endsWith(".json")) {
+    this.emitDebouncedChange(eventType, basename(watchedTarget));
+
+    if (eventType === "rename" || !existsSync(watchedTarget)) {
+      this.rebindDbWatcherSafe();
       return;
     }
 
-    if (!filename.includes(".sisyphus") && !filename.includes("boulder")) {
+    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.handleChange(eventType, filename);
+    this.boulderWatcher = watch(preferredTarget, (eventType, filename) => {
+      this.handleBoulderEvent(eventType, filename);
+    });
+    this.boulderWatcherTarget = preferredTarget;
+  }
+
+  private handleBoulderEvent(eventType: string, filename: string | null): void {
+    if (this.boulderWatcherTarget === this.boulderDirPath) {
+      if (!filename || filename !== "boulder.json") {
+        return;
+      }
+    }
+
+    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 startRebindLoop(): void {
+    if (this.rebindTimer) {
+      clearInterval(this.rebindTimer);
+    }
+
+    this.rebindTimer = setInterval(() => {
+      if (!this.isRunning) {
+        return;
+      }
+
+      this.rebindDbWatcherSafe();
+      this.rebindBoulderWatcherSafe();
+    }, 1000);
+  }
+
+  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 +209,57 @@ 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.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

@@ -10,6 +10,7 @@ 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

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
  */
@@ -229,6 +259,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
  */
@@ -316,13 +353,10 @@ 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;
 }
 

package/src/server/storage/messageParser.ts

@@ -1,169 +0,0 @@
-/**
- * Message Parser - Parse OpenCode message JSON files
- * Reads from ~/.local/share/opencode/storage/message/{sessionID}/{messageID}.json
- */
-
-import { readdir, readFile } from "node:fs/promises";
-import { join } from "node:path";
-import type { MessageMeta } from "../../shared/types";
-import { getStoragePath } from "./sessionParser";
-
-/**
- * Internal JSON structure from OpenCode storage
- */
-interface MessageJSON {
-  id: string;
-  sessionID: string;
-  role: string;
-  time: {
-    created: number;
-    completed?: number;
-  };
-  parentID?: string;
-  modelID?: string;
-  model?: {
-    modelID?: string;
-    providerID?: string;
-  };
-  providerID?: string;
-  mode?: string;
-  agent?: string;
-  path?: {
-    cwd: string;
-    root: string;
-  };
-  cost?: number;
-  tokens?: {
-    input: number;
-    output: number;
-    reasoning?: number;
-    cache?: {
-      read: number;
-      write: number;
-    };
-  };
-  finish?: string;
-}
-
-/**
- * Parse a single message JSON file
- * @param filePath - Absolute path to message JSON file
- * @returns MessageMeta or null if file doesn't exist or is invalid
- */
-export async function parseMessage(
-  filePath: string
-): Promise<MessageMeta | null> {
-  try {
-    const content = await readFile(filePath, "utf-8");
-    const json: MessageJSON = JSON.parse(content);
-
-    const totalTokens = json.tokens
-      ? json.tokens.input + json.tokens.output
-      : undefined;
-
-    return {
-      id: json.id,
-      sessionID: json.sessionID,
-      role: json.role,
-      agent: json.agent,
-      mode: json.mode,
-      modelID: json.modelID || json.model?.modelID,
-      providerID: json.providerID || json.model?.providerID,
-      parentID: json.parentID,
-      tokens: totalTokens,
-      cost: json.cost,
-      createdAt: new Date(json.time.created),
-      finish: json.finish,
-    };
-  } catch (error) {
-    if (error instanceof SyntaxError) {
-      console.warn(`Corrupted JSON file: ${filePath}`);
-    }
-    return null;
-  }
-}
-
-/**
- * Get a specific message by messageID and sessionID
- * @param messageID - Message ID
- * @param sessionID - Session ID
- * @param storagePath - Optional custom storage path (defaults to XDG path)
- * @returns MessageMeta or null if not found
- */
-export async function getMessage(
-  messageID: string,
-  sessionID: string,
-  storagePath?: string
-): Promise<MessageMeta | null> {
-  const basePath = storagePath || getStoragePath();
-  const filePath = join(
-    basePath,
-    "opencode",
-    "storage",
-    "message",
-    sessionID,
-    `${messageID}.json`
-  );
-
-  return parseMessage(filePath);
-}
-
-/**
- * List all messages for a given session
- * @param sessionID - Session ID to filter by
- * @param storagePath - Optional custom storage path (defaults to XDG path)
- * @returns Array of MessageMeta (empty array if directory doesn't exist)
- */
-export async function listMessages(
-  sessionID: string,
-  storagePath?: string
-): Promise<MessageMeta[]> {
-  const basePath = storagePath || getStoragePath();
-  const messageDir = join(basePath, "opencode", "storage", "message", sessionID);
-
-  try {
-    const entries = await readdir(messageDir);
-    const messages: MessageMeta[] = [];
-
-    for (const entry of entries) {
-      if (!entry.endsWith(".json")) {
-        continue;
-      }
-
-      const messageID = entry.slice(0, -5);
-      const message = await getMessage(messageID, sessionID, storagePath);
-
-      if (message) {
-        messages.push(message);
-      }
-    }
-
-    return messages;
-  } catch (error) {
-    return [];
-  }
-}
-
-/**
- * Get the first assistant message in a session
- * @param sessionID - Session ID to search
- * @param storagePath - Optional custom storage path (defaults to XDG path)
- * @returns First assistant message or null if none found
- */
-export async function getFirstAssistantMessage(
-  sessionID: string,
-  storagePath?: string
-): Promise<MessageMeta | null> {
-  const messages = await listMessages(sessionID, storagePath);
-  const sorted = messages.sort(
-    (a, b) => b.createdAt.getTime() - a.createdAt.getTime()
-  );
-
-  for (const message of sorted) {
-    if (message.role === "assistant") {
-      return message;
-    }
-  }
-
-  return null;
-}