@minionry/minion 0.7.36

package/dist/server/services/collab/registry.js

@@ -0,0 +1,408 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { existsSync, readFileSync, realpathSync, statSync, watch } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { getClientId } from '../client-id.js';
+import { writeFile } from '../file-explorer-ops.js';
+import { notifyFileChanged } from '../sdk/file-change-notify.js';
+import { makeSpaceKey } from '../settings.js';
+import { broadcastCollabEvent } from '../websocket/collab-broadcast.js';
+import { isBinaryFile } from '../websocket/file-utils.js';
+import { CollabSession } from './session.js';
+import { COLLAB_DETACH_GRACE_MS, COLLAB_DRAIN_GRACE_MS, COLLAB_MAX_DOC_BYTES, COLLAB_MAX_SESSIONS, COLLAB_WATCH_DEBOUNCE_MS, COLLAB_WATCH_MISSING_GRACE_MS, } from './types.js';
+const SWEEP_INTERVAL_MS = 60_000;
+export class CollabSessionRegistry {
+    ctx;
+    now;
+    sessions = new Map();
+    dirWatches = new Map();
+    deviceSockets = new Map();
+    sweepTimer = null;
+    detachReapTimer = null;
+    constructor(ctx, now = Date.now) {
+        this.ctx = ctx;
+        this.now = now;
+    }
+    noteDevice(viewerId, ws) {
+        if (viewerId)
+            this.deviceSockets.set(viewerId, ws);
+    }
+    join(req, join) {
+        this.noteDevice(req.viewerId, req.ws);
+        const entry = this.sessions.get(req.key) ?? this.createSession(req);
+        if (!entry)
+            return;
+        this.cancelDrain(entry);
+        entry.session.join(join, req.requestPath);
+    }
+    leave(req, clientID) {
+        const entry = this.sessions.get(req.key);
+        if (!entry)
+            return;
+        entry.session.leave(clientID);
+        this.reconcile(req.key);
+    }
+    push(req, clientID, version, updates) {
+        this.noteDevice(req.viewerId, req.ws);
+        const entry = this.sessions.get(req.key);
+        if (!entry) {
+            this.unicast(req.viewerId, 'collabPushRejected', {
+                key: req.key,
+                clientID,
+                reason: 'no_session',
+                version: 0,
+                baseVersion: 0,
+            });
+            return;
+        }
+        entry.session.push(clientID, req.viewerId, version, updates);
+    }
+    cursor(req, clientID, version, selection, active) {
+        this.noteDevice(req.viewerId, req.ws);
+        this.sessions.get(req.key)?.session.cursor(clientID, version, selection, active);
+    }
+    flush(req) {
+        this.sessions.get(req.key)?.session.persist('flush');
+    }
+    noteExternalWrite(absolutePath, content) {
+        if (this.sessions.size === 0)
+            return;
+        const key = safeRealpath(absolutePath);
+        const entry = this.sessions.get(key);
+        if (!entry)
+            return;
+        entry.session.ingestDisk(content);
+    }
+    dropViewer(viewerId) {
+        this.deviceSockets.delete(viewerId);
+        for (const [key, entry] of [...this.sessions]) {
+            if (entry.session.dropViewer(viewerId))
+                this.reconcile(key);
+        }
+    }
+    onTransportDetach() {
+        const cutoff = this.now();
+        if (this.detachReapTimer)
+            clearTimeout(this.detachReapTimer);
+        this.detachReapTimer = setTimeout(() => {
+            this.detachReapTimer = null;
+            for (const [key, entry] of [...this.sessions]) {
+                entry.session.dropSilentSince(cutoff);
+                this.reconcile(key);
+            }
+        }, COLLAB_DETACH_GRACE_MS);
+        this.detachReapTimer.unref?.();
+    }
+    flushAll(reason = 'shutdown') {
+        for (const entry of this.sessions.values()) {
+            try {
+                entry.session.persist(reason === 'shutdown' ? 'shutdown' : 'leave');
+            }
+            catch (err) {
+                console.error('[collab] flushAll persist failed:', err);
+            }
+        }
+    }
+    dispose(reason = 'shutdown') {
+        for (const [key, entry] of [...this.sessions]) {
+            try {
+                entry.session.end(reason, { persist: true });
+            }
+            catch (err) {
+                console.error('[collab] dispose failed:', err);
+            }
+            this.forget(key, entry);
+        }
+        this.sessions.clear();
+        this.deviceSockets.clear();
+        if (this.detachReapTimer) {
+            clearTimeout(this.detachReapTimer);
+            this.detachReapTimer = null;
+        }
+        this.stopSweep();
+    }
+    size() {
+        return this.sessions.size;
+    }
+    get(key) {
+        return this.sessions.get(key)?.session;
+    }
+    createSession(req) {
+        if (this.sessions.size >= COLLAB_MAX_SESSIONS) {
+            this.collabError(req, 'session_limit', 'Too many collaborative sessions on this machine');
+            return null;
+        }
+        if (!existsSync(req.key)) {
+            this.collabError(req, 'not_found', 'File not found');
+            return null;
+        }
+        if (isBinaryFile(req.key)) {
+            this.collabError(req, 'binary', 'Binary files cannot be collaboratively edited');
+            return null;
+        }
+        let stat;
+        let text;
+        try {
+            const stats = statSync(req.key);
+            if (stats.isDirectory()) {
+                this.collabError(req, 'unsupported', 'Cannot open a directory for collaborative editing');
+                return null;
+            }
+            if (stats.size > COLLAB_MAX_DOC_BYTES) {
+                this.collabError(req, 'too_large', 'File exceeds the 1MB collaborative editing limit');
+                return null;
+            }
+            stat = { mtimeMs: stats.mtimeMs, size: stats.size };
+            text = readFileSync(req.key, 'utf-8');
+        }
+        catch (err) {
+            this.collabError(req, 'read_failed', err instanceof Error ? err.message : String(err));
+            return null;
+        }
+        const entry = {
+            session: new CollabSession(req.key, this.makeHost(req.key), {
+                text,
+                stat,
+                modifiedAt: new Date(stat.mtimeMs).toISOString(),
+            }),
+            workingDir: req.workingDir,
+            extraRoots: req.extraRoots,
+            drainTimer: null,
+            watchTimer: null,
+        };
+        this.sessions.set(req.key, entry);
+        this.watchDirectoryOf(req.key);
+        this.startSweep();
+        return entry;
+    }
+    makeHost(key) {
+        return {
+            broadcast: (type, data) => this.broadcast(key, type, data),
+            unicast: (viewerId, type, data) => this.unicast(viewerId, type, data, key),
+            writeToDisk: (text) => this.writeToDisk(key, text),
+            readFromDisk: () => safeRead(key),
+            statFile: () => safeStat(key),
+            now: this.now,
+        };
+    }
+    writeToDisk(key, text) {
+        const entry = this.sessions.get(key);
+        if (!entry)
+            return { success: false, error: 'no session' };
+        const result = writeFile(key, text, entry.workingDir, { extraRoots: entry.extraRoots });
+        if (!result.success)
+            return { success: false, error: result.error };
+        try {
+            notifyFileChanged(makeSpaceKey(getClientId(), entry.workingDir), entry.workingDir, key, 'changed');
+        }
+        catch (err) {
+            console.error('[collab] notifyFileChanged failed:', err);
+        }
+        return {
+            success: true,
+            stat: safeStat(key) ?? undefined,
+            bytes: Buffer.byteLength(text, 'utf-8'),
+        };
+    }
+    reconcile(key) {
+        const entry = this.sessions.get(key);
+        if (!entry)
+            return;
+        if (entry.session.participantCount() > 0) {
+            this.cancelDrain(entry);
+            return;
+        }
+        if (entry.drainTimer)
+            return;
+        entry.drainTimer = setTimeout(() => {
+            entry.drainTimer = null;
+            const current = this.sessions.get(key);
+            if (!current || current.session.participantCount() > 0)
+                return;
+            current.session.persist('leave');
+            this.forget(key, current);
+            this.sessions.delete(key);
+            if (this.sessions.size === 0)
+                this.stopSweep();
+        }, COLLAB_DRAIN_GRACE_MS);
+        entry.drainTimer.unref?.();
+    }
+    cancelDrain(entry) {
+        if (!entry.drainTimer)
+            return;
+        clearTimeout(entry.drainTimer);
+        entry.drainTimer = null;
+    }
+    forget(key, entry) {
+        this.cancelDrain(entry);
+        if (entry.watchTimer) {
+            clearTimeout(entry.watchTimer);
+            entry.watchTimer = null;
+        }
+        this.unwatch(key);
+        this.ctx.collabEventBuffers.delete(key);
+    }
+    endSession(key, reason) {
+        const entry = this.sessions.get(key);
+        if (!entry)
+            return;
+        this.sessions.delete(key);
+        entry.session.end(reason);
+        this.forget(key, entry);
+        if (this.sessions.size === 0)
+            this.stopSweep();
+    }
+    watchDirectoryOf(key) {
+        const dir = dirname(key);
+        const existing = this.dirWatches.get(dir);
+        if (existing) {
+            existing.keys.add(key);
+            return;
+        }
+        let watcher;
+        try {
+            watcher = watch(dir, { recursive: false }, (_event, filename) => {
+                const entry = this.dirWatches.get(dir);
+                if (!entry)
+                    return;
+                const candidates = filename ? [resolve(dir, filename.toString())] : [...entry.keys];
+                for (const candidate of candidates) {
+                    if (entry.keys.has(candidate))
+                        this.scheduleDiskCheck(candidate);
+                }
+            });
+        }
+        catch (err) {
+            console.error(`[collab] watch failed dir=${dir}:`, err);
+            return;
+        }
+        watcher.on('error', (err) => {
+            console.error(`[collab] watcher error dir=${dir}:`, err);
+        });
+        watcher.unref?.();
+        this.dirWatches.set(dir, { watcher, keys: new Set([key]) });
+    }
+    unwatch(key) {
+        const dir = dirname(key);
+        const entry = this.dirWatches.get(dir);
+        if (!entry)
+            return;
+        entry.keys.delete(key);
+        if (entry.keys.size > 0)
+            return;
+        try {
+            entry.watcher.close();
+        }
+        catch {
+        }
+        this.dirWatches.delete(dir);
+    }
+    scheduleDiskCheck(key) {
+        const entry = this.sessions.get(key);
+        if (!entry)
+            return;
+        if (entry.watchTimer)
+            clearTimeout(entry.watchTimer);
+        entry.watchTimer = setTimeout(() => {
+            entry.watchTimer = null;
+            this.checkDisk(key);
+        }, COLLAB_WATCH_DEBOUNCE_MS);
+        entry.watchTimer.unref?.();
+    }
+    checkDisk(key) {
+        const entry = this.sessions.get(key);
+        if (!entry)
+            return;
+        const stat = safeStat(key);
+        if (!stat) {
+            setTimeout(() => {
+                if (!this.sessions.has(key))
+                    return;
+                if (safeStat(key)) {
+                    this.checkDisk(key);
+                    return;
+                }
+                this.endSession(key, 'file_deleted');
+            }, COLLAB_WATCH_MISSING_GRACE_MS).unref?.();
+            return;
+        }
+        if (stat.size > COLLAB_MAX_DOC_BYTES) {
+            this.endSession(key, 'too_large');
+            return;
+        }
+        const known = entry.session.lastStat();
+        if (known && stat.mtimeMs === known.mtimeMs && stat.size === known.size)
+            return;
+        const text = safeRead(key);
+        if (text === null || text === entry.session.persistedContent())
+            return;
+        entry.session.ingestDisk(text);
+    }
+    startSweep() {
+        if (this.sweepTimer)
+            return;
+        this.sweepTimer = setInterval(() => {
+            for (const [key, entry] of [...this.sessions]) {
+                entry.session.sweep();
+                this.reconcile(key);
+            }
+        }, SWEEP_INTERVAL_MS);
+        this.sweepTimer.unref?.();
+    }
+    stopSweep() {
+        if (!this.sweepTimer)
+            return;
+        clearInterval(this.sweepTimer);
+        this.sweepTimer = null;
+    }
+    broadcast(key, type, data) {
+        return broadcastCollabEvent(this.ctx, key, type, data);
+    }
+    unicast(viewerId, type, data, key) {
+        const ws = this.deviceSockets.get(viewerId);
+        if (!ws)
+            return;
+        this.ctx.send(ws, {
+            type,
+            data,
+            ...(key ? { collabKey: key } : {}),
+            _target: viewerId,
+        });
+    }
+    collabError(req, code, error) {
+        this.noteDevice(req.viewerId, req.ws);
+        this.unicast(req.viewerId, 'collabError', {
+            path: req.requestPath,
+            operation: 'collabJoin',
+            code,
+            error,
+        });
+    }
+}
+function safeStat(path) {
+    try {
+        const stats = statSync(path);
+        if (stats.isDirectory())
+            return null;
+        return { mtimeMs: stats.mtimeMs, size: stats.size };
+    }
+    catch {
+        return null;
+    }
+}
+function safeRead(path) {
+    try {
+        return readFileSync(path, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+export function safeRealpath(path) {
+    try {
+        return realpathSync(path);
+    }
+    catch {
+        return path;
+    }
+}