@gmickel/gno 0.28.2 → 0.29.1

package/src/serve/watch-service.ts

@@ -8,35 +8,76 @@ import type { EmbedScheduler } from "./embed-scheduler";
 
 import { defaultSyncService } from "../ingestion";
 
+export interface CollectionWatchState {
+  expectedCollections: string[];
+  activeCollections: string[];
+  failedCollections: Array<{ collection: string; reason: string }>;
+  queuedCollections: string[];
+  syncingCollections: string[];
+  lastEventAt: string | null;
+  lastSyncAt: string | null;
+}
+
 interface CollectionWatchServiceOptions {
   collections: Collection[];
   store: SqliteAdapter;
   scheduler: EmbedScheduler | null;
   eventBus: DocumentEventBus;
+  watchFactory?: typeof watch;
 }
 
 export class CollectionWatchService {
-  readonly #collections: Collection[];
+  #collections: Collection[];
   readonly #store: SqliteAdapter;
   readonly #scheduler: EmbedScheduler | null;
   readonly #eventBus: DocumentEventBus;
-  readonly #watchers: FSWatcher[] = [];
+  readonly #watchers = new Map<string, FSWatcher>();
   readonly #pendingByCollection = new Map<string, Set<string>>();
   readonly #timers = new Map<string, ReturnType<typeof setTimeout>>();
   readonly #syncing = new Set<string>();
   readonly #suppressedPaths = new Map<string, number>();
+  readonly #watchFactory: typeof watch;
+  readonly #failedCollections = new Map<string, string>();
+  #lastEventAt: string | null = null;
+  #lastSyncAt: string | null = null;
 
   constructor(options: CollectionWatchServiceOptions) {
     this.#collections = options.collections;
     this.#store = options.store;
     this.#scheduler = options.scheduler;
     this.#eventBus = options.eventBus;
+    this.#watchFactory = options.watchFactory ?? watch;
   }
 
   start(): void {
+    this.updateCollections(this.#collections);
+  }
+
+  updateCollections(collections: Collection[]): void {
+    this.#collections = collections;
+    const nextNames = new Set(collections.map((collection) => collection.name));
+
+    for (const [collectionName, watcher] of this.#watchers) {
+      if (!nextNames.has(collectionName)) {
+        watcher.close();
+        this.#watchers.delete(collectionName);
+        this.#failedCollections.delete(collectionName);
+        this.#pendingByCollection.delete(collectionName);
+        const timer = this.#timers.get(collectionName);
+        if (timer) {
+          clearTimeout(timer);
+          this.#timers.delete(collectionName);
+        }
+        this.#syncing.delete(collectionName);
+      }
+    }
+
     for (const collection of this.#collections) {
+      if (this.#watchers.has(collection.name)) {
+        continue;
+      }
       try {
-        const watcher = watch(
+        const watcher = this.#watchFactory(
           collection.path,
           { recursive: true },
           (_eventType, filename) => {
@@ -47,12 +88,17 @@ export class CollectionWatchService {
             if (suppressedUntil && suppressedUntil > Date.now()) {
               return;
             }
+            this.#lastEventAt = new Date().toISOString();
             this.#queueChange(collection.name, relPath);
           }
         );
-        this.#watchers.push(watcher);
-      } catch {
-        // Best-effort watch support; unsupported platforms can still rely on manual sync.
+        this.#watchers.set(collection.name, watcher);
+        this.#failedCollections.delete(collection.name);
+      } catch (error) {
+        this.#failedCollections.set(
+          collection.name,
+          error instanceof Error ? error.message : "watch unavailable"
+        );
       }
     }
   }
@@ -65,15 +111,33 @@ export class CollectionWatchService {
     for (const timer of this.#timers.values()) {
       clearTimeout(timer);
     }
-    for (const watcher of this.#watchers) {
+    for (const watcher of this.#watchers.values()) {
       watcher.close();
     }
     this.#timers.clear();
-    this.#watchers.length = 0;
+    this.#watchers.clear();
     this.#pendingByCollection.clear();
     this.#syncing.clear();
   }
 
+  getState(): CollectionWatchState {
+    return {
+      expectedCollections: this.#collections.map(
+        (collection) => collection.name
+      ),
+      activeCollections: [...this.#watchers.keys()],
+      failedCollections: [...this.#failedCollections.entries()].map(
+        ([collection, reason]) => ({ collection, reason })
+      ),
+      queuedCollections: [...this.#pendingByCollection.entries()]
+        .filter(([, relPaths]) => relPaths.size > 0)
+        .map(([collectionName]) => collectionName),
+      syncingCollections: [...this.#syncing],
+      lastEventAt: this.#lastEventAt,
+      lastSyncAt: this.#lastSyncAt,
+    };
+  }
+
   #queueChange(collectionName: string, relPath: string): void {
     const pending =
       this.#pendingByCollection.get(collectionName) ?? new Set<string>();
@@ -132,6 +196,7 @@ export class CollectionWatchService {
       return;
     }
 
+    this.#lastSyncAt = new Date().toISOString();
     this.#scheduler?.notifySyncComplete(relPaths);
 
     for (const relPath of relPaths) {

package/src/types/electrobun-shell.d.ts

@@ -0,0 +1,43 @@
+declare module "electrobun" {
+  export interface ElectrobunConfig {
+    app: {
+      name: string;
+      identifier: string;
+      version: string;
+      urlSchemes?: string[];
+    };
+    runtime?: Record<string, unknown>;
+    build?: Record<string, unknown>;
+  }
+}
+
+declare module "electrobun/bun" {
+  export const ApplicationMenu: {
+    setApplicationMenu(menu: unknown): void;
+  };
+
+  export const BuildConfig: {
+    get(): Promise<{ runtime?: Record<string, unknown> }>;
+  };
+
+  export class BrowserWindow {
+    constructor(options: unknown);
+    show(): void;
+    focus(): void;
+    webview: {
+      loadURL(url: string): void;
+    };
+  }
+
+  export const GlobalShortcut: {
+    register(shortcut: string, handler: () => void): boolean;
+  };
+
+  const Electrobun: {
+    events: {
+      on(name: string, handler: (event: unknown) => void): void;
+    };
+  };
+
+  export default Electrobun;
+}