Restore workspace watchers on server startup

Author: pallyoung

packages/server/src/__tests__/workspace-watcher-hydrate-restart.test.ts

@@ -0,0 +1,84 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import chokidar, { type FSWatcher } from "chokidar";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { createServer, type Server } from "../server.js";
+import { dispatch } from "../ws/dispatch.js";
+
+import "../commands/workspace.js";
+
+describe("workspace watcher hydrate restart", () => {
+  let server: Server | undefined;
+  let dataDir: string;
+  let dbPath: string;
+  let workspaceDir: string;
+  let watchSpy: ReturnType<typeof vi.spyOn<typeof chokidar, "watch">>;
+
+  beforeEach(() => {
+    dataDir = mkdtempSync(join(tmpdir(), "coder-studio-data-"));
+    dbPath = join(dataDir, "coder-studio.db");
+    workspaceDir = mkdtempSync(join(tmpdir(), "coder-studio-workspace-"));
+    mkdirSync(join(workspaceDir, ".git"), { recursive: true });
+    writeFileSync(join(workspaceDir, ".git", "HEAD"), "ref: refs/heads/main\n");
+
+    watchSpy = vi.spyOn(chokidar, "watch").mockReturnValue({
+      on() {
+        return this;
+      },
+      close: vi.fn().mockResolvedValue(undefined),
+    } as unknown as FSWatcher);
+  });
+
+  afterEach(async () => {
+    if (server) {
+      await server.stop();
+      server = undefined;
+    }
+    watchSpy.mockRestore();
+    rmSync(dataDir, { recursive: true, force: true });
+    rmSync(workspaceDir, { recursive: true, force: true });
+  });
+
+  it("restores persisted workspace watchers after server restart", async () => {
+    server = await createServer({
+      dataDir: dbPath,
+      host: "127.0.0.1",
+      port: 0,
+    });
+
+    const firstCtx = server.__test__!.commandContext;
+
+    const openResult = await dispatch(
+      {
+        kind: "command",
+        id: "workspace-open",
+        op: "workspace.open",
+        args: { path: workspaceDir },
+      },
+      firstCtx
+    );
+
+    expect(openResult.ok).toBe(true);
+    expect(watchSpy).toHaveBeenCalledTimes(1);
+
+    await server.stop();
+    server = undefined;
+    watchSpy.mockClear();
+
+    server = await createServer({
+      dataDir: dbPath,
+      host: "127.0.0.1",
+      port: 0,
+    });
+
+    expect(watchSpy).toHaveBeenCalledTimes(1);
+    expect(watchSpy).toHaveBeenCalledWith(
+      workspaceDir,
+      expect.objectContaining({
+        ignoreInitial: true,
+        persistent: true,
+      })
+    );
+  });
+});

packages/server/src/__tests__/workspace/manager.test.ts

@@ -4,6 +4,7 @@
 
 import { DatabaseSync } from "node:sqlite";
 import type { DomainEvent } from "@coder-studio/core";
+import chokidar, { type FSWatcher } from "chokidar";
 import { mkdir, rmdir } from "fs/promises";
 import { tmpdir } from "os";
 import { join } from "path";
@@ -20,6 +21,7 @@ describe("WorkspaceManager", () => {
     emit: (event: DomainEvent) => void;
     on: () => () => void;
   };
+  let watchSpy: ReturnType<typeof vi.spyOn<typeof chokidar, "watch">>;
 
   beforeEach(async () => {
     // Create test directory
@@ -53,10 +55,18 @@ describe("WorkspaceManager", () => {
       on: () => () => {},
     };
 
+    watchSpy = vi.spyOn(chokidar, "watch").mockReturnValue({
+      on() {
+        return this;
+      },
+      close: vi.fn().mockResolvedValue(undefined),
+    } as unknown as FSWatcher);
+
     manager = new WorkspaceManager({ db, eventBus });
   });
 
   afterEach(async () => {
+    watchSpy.mockRestore();
     try {
       db.close();
       await rmdir(testDir);
@@ -224,6 +234,46 @@ describe("WorkspaceManager", () => {
     });
   });
 
+  describe("hydrateWatchers", () => {
+    it("starts file watchers for persisted workspaces", async () => {
+      const persisted = await manager.open({ path: testDir });
+      const broadcaster = { broadcast: vi.fn() };
+      const restoredManager = new WorkspaceManager({ db, eventBus, broadcaster });
+
+      restoredManager.hydrateWatchers();
+
+      expect(watchSpy).toHaveBeenCalledTimes(1);
+      expect(watchSpy).toHaveBeenCalledWith(
+        testDir,
+        expect.objectContaining({
+          ignoreInitial: true,
+          persistent: true,
+        })
+      );
+      expect(
+        (restoredManager as unknown as { watchers: Map<string, unknown> }).watchers.has(
+          persisted.id
+        )
+      ).toBe(true);
+    });
+
+    it("does not create duplicate watchers when called multiple times", async () => {
+      const persisted = await manager.open({ path: testDir });
+      const broadcaster = { broadcast: vi.fn() };
+      const restoredManager = new WorkspaceManager({ db, eventBus, broadcaster });
+
+      restoredManager.hydrateWatchers();
+      restoredManager.hydrateWatchers();
+
+      expect(watchSpy).toHaveBeenCalledTimes(1);
+      expect(
+        (restoredManager as unknown as { watchers: Map<string, unknown> }).watchers.has(
+          persisted.id
+        )
+      ).toBe(true);
+    });
+  });
+
   describe("updateUiState", () => {
     it("updates workspace pane layout and emits workspace meta changed", async () => {
       const workspace = await manager.open({ path: testDir });

packages/server/src/server.ts

@@ -136,6 +136,7 @@ export async function createServer(
         console.warn("[uploads] cascade cleanup failed", { wsId: workspaceId, err })
       ),
   });
+  workspaceMgr.hydrateWatchers();
 
   const authSessionRepo = new AuthSessionRepo(db);
   const authLoginBlockRepo = new AuthLoginBlockRepo(db);

packages/server/src/workspace/manager.ts

@@ -60,6 +60,12 @@ export class WorkspaceManager {
     );
   }
 
+  hydrateWatchers(): void {
+    for (const workspace of this.list()) {
+      this.startWatcher(workspace.id, workspace.path);
+    }
+  }
+
   updateUiState(workspaceId: string, uiState: Workspace["uiState"]): void {
     const workspace = this.get(workspaceId);
     if (!workspace) {