relay-ide 0.1.0

package/dist/server/watcher.js

@@ -0,0 +1,661 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { EventEmitter } from 'node:events';
+import { createLogger } from './logger.js';
+const execFileAsync = promisify(execFile);
+const logger = createLogger('watcher');
+export const WORKTREE_DIRS = ['.worktrees', '.claude/worktrees'];
+function closeWatchers(watchers) {
+    for (const w of watchers) {
+        try {
+            w.close();
+        }
+        catch (_) { }
+    }
+}
+export function isValidWorktreePath(worktreePath) {
+    const resolved = path.resolve(worktreePath);
+    return WORKTREE_DIRS.some(function (dir) {
+        return resolved.includes(path.sep + dir + path.sep);
+    });
+}
+function parseWorktreeBlocks(stdout) {
+    return stdout
+        .split('\n\n')
+        .filter(Boolean)
+        .map((block) => {
+        let path = '';
+        let branch = '';
+        let bare = false;
+        for (const line of block.split('\n')) {
+            if (line.startsWith('worktree '))
+                path = line.slice(9);
+            else if (line.startsWith('branch refs/heads/'))
+                branch = line.slice(18);
+            else if (line === 'bare')
+                bare = true;
+        }
+        return { path, branch, bare };
+    });
+}
+/**
+ * Parse `git worktree list --porcelain` output into ALL entries (including main worktree).
+ * Skips bare entries. Detached HEAD entries get empty branch string.
+ */
+export function parseAllWorktrees(stdout, repoPath) {
+    return parseWorktreeBlocks(stdout)
+        .filter((b) => b.path && !b.bare)
+        .map((b) => ({
+        path: b.path,
+        branch: b.branch,
+        isMain: b.path === repoPath,
+    }));
+}
+/**
+ * Parse `git worktree list --porcelain` output into structured entries.
+ * Skips the main worktree (matching repoPath) and bare/detached entries.
+ */
+export function parseWorktreeListPorcelain(stdout, repoPath) {
+    return parseWorktreeBlocks(stdout)
+        .filter((b) => b.path && b.path !== repoPath && !b.bare && b.branch)
+        .map((b) => ({ path: b.path, branch: b.branch }));
+}
+/**
+ * Find an existing worktree for a branch, or create a new one.
+ * Prevents "fatal: branch is already used by worktree" errors by
+ * checking `git worktree list` before attempting `git worktree add`.
+ * Throws branch_checked_out_in_main error if the branch is checked out
+ * in the main worktree (caller should open a repo-root session instead).
+ */
+export async function findOrCreateWorktreeForBranch(repoPath, branch, execFn) {
+    // Check if branch is already checked out in ANY worktree (including the main repo)
+    try {
+        const { stdout } = await execFn('git', ['worktree', 'list', '--porcelain'], { cwd: repoPath });
+        const allWorktrees = parseAllWorktrees(stdout, repoPath);
+        const match = allWorktrees.find((wt) => wt.branch === branch);
+        if (match) {
+            return {
+                worktreePath: match.path,
+                branchName: match.branch,
+                dirName: match.path.split('/').pop() || '',
+                existing: true,
+                isMain: match.isMain,
+            };
+        }
+    }
+    catch (err) {
+        // git worktree list failed — proceed with creation attempt
+        logger.warn('[watcher] git worktree list failed, proceeding with creation attempt:', err instanceof Error ? err.message : err);
+    }
+    // Sanitize branch name for directory
+    const dirName = branch.replace(/\//g, '-').replace(/[^a-zA-Z0-9._-]/g, '');
+    const worktreePath = path.join(repoPath, '.worktrees', dirName);
+    // Ensure .worktrees/ is in .gitignore (best-effort — skip if directory doesn't exist)
+    try {
+        const gitignorePath = path.join(repoPath, '.gitignore');
+        try {
+            const content = fs.readFileSync(gitignorePath, 'utf8');
+            if (!content.includes('.worktrees/')) {
+                fs.appendFileSync(gitignorePath, '\n.worktrees/\n');
+            }
+        }
+        catch {
+            fs.writeFileSync(gitignorePath, '.worktrees/\n');
+        }
+    }
+    catch {
+        // Directory may not exist in test environments
+    }
+    await execFn('git', ['worktree', 'add', worktreePath, branch], {
+        cwd: repoPath,
+    });
+    return {
+        worktreePath,
+        branchName: branch,
+        dirName,
+        existing: false,
+        isMain: false,
+    };
+}
+export class WorktreeWatcher extends EventEmitter {
+    _watchers;
+    _debounceTimer;
+    constructor() {
+        super();
+        this._watchers = [];
+        this._debounceTimer = null;
+    }
+    rebuild(rootDirs) {
+        this._closeAll();
+        for (const rootDir of rootDirs) {
+            let entries;
+            try {
+                entries = fs.readdirSync(rootDir, { withFileTypes: true });
+            }
+            catch (_) {
+                continue;
+            }
+            for (const entry of entries) {
+                if (!entry.isDirectory() || entry.name.startsWith('.'))
+                    continue;
+                const repoPath = path.join(rootDir, entry.name);
+                if (!fs.existsSync(path.join(repoPath, '.git')))
+                    continue;
+                this._watchRepo(repoPath);
+            }
+        }
+    }
+    _watchRepo(repoPath) {
+        let anyWatched = false;
+        for (const dir of WORKTREE_DIRS) {
+            const worktreeDir = path.join(repoPath, dir);
+            if (fs.existsSync(worktreeDir)) {
+                this._addWatch(worktreeDir);
+                anyWatched = true;
+            }
+        }
+        if (!anyWatched) {
+            // Watch repo root so we detect when either dir is first created
+            this._addWatch(repoPath);
+        }
+    }
+    _addWatch(dirPath) {
+        try {
+            const watcher = fs.watch(dirPath, { persistent: false }, () => {
+                this._debouncedEmit();
+            });
+            watcher.on('error', () => { });
+            this._watchers.push(watcher);
+        }
+        catch (_) { }
+    }
+    _debouncedEmit() {
+        if (this._debounceTimer)
+            clearTimeout(this._debounceTimer);
+        this._debounceTimer = setTimeout(() => {
+            this.emit('worktrees-changed');
+        }, 500);
+    }
+    _closeAll() {
+        closeWatchers(this._watchers);
+        this._watchers = [];
+        if (this._debounceTimer) {
+            clearTimeout(this._debounceTimer);
+            this._debounceTimer = null;
+        }
+    }
+    close() {
+        this._closeAll();
+    }
+}
+export class BranchWatcher {
+    // Map headPath → { watcher, cwdPath } so we can recreate individual watchers
+    // after detection (git's atomic checkout can change the inode, killing kqueue watchers)
+    _watcherMap = new Map();
+    _debounceTimers = new Map();
+    _lastBranch = new Map();
+    _callback;
+    /** Monotonic generation counter. Incremented on rebuild()/close() so that
+     *  in-flight async _readAndEmit calls from a prior generation don't
+     *  recreate watchers into the new (or cleared) _watcherMap. */
+    _generation = 0;
+    constructor(callback) {
+        this._callback = callback;
+    }
+    rebuild(rootDirs) {
+        this._closeAll();
+        for (const rootDir of rootDirs) {
+            let entries;
+            try {
+                entries = fs.readdirSync(rootDir, { withFileTypes: true });
+            }
+            catch (_) {
+                continue;
+            }
+            for (const entry of entries) {
+                if (!entry.isDirectory() || entry.name.startsWith('.'))
+                    continue;
+                const repoPath = path.join(rootDir, entry.name);
+                if (!fs.existsSync(path.join(repoPath, '.git')))
+                    continue;
+                this._watchRepoHeads(repoPath);
+            }
+        }
+    }
+    _watchRepoHeads(repoPath) {
+        // Watch main repo HEAD
+        const mainHead = path.join(repoPath, '.git', 'HEAD');
+        this._watchHeadFile(mainHead, repoPath);
+        // Watch worktree HEADs: <repoPath>/.git/worktrees/*/HEAD
+        const worktreesGitDir = path.join(repoPath, '.git', 'worktrees');
+        let wtEntries;
+        try {
+            wtEntries = fs.readdirSync(worktreesGitDir, { withFileTypes: true });
+        }
+        catch (_) {
+            return; // No worktrees
+        }
+        for (const entry of wtEntries) {
+            if (!entry.isDirectory())
+                continue;
+            const wtGitDir = path.join(worktreesGitDir, entry.name);
+            const headFile = path.join(wtGitDir, 'HEAD');
+            if (!fs.existsSync(headFile))
+                continue;
+            // Map worktree git dir back to checkout path via gitdir file
+            const gitdirFile = path.join(wtGitDir, 'gitdir');
+            let checkoutPath;
+            try {
+                const gitdirContent = fs.readFileSync(gitdirFile, 'utf-8').trim();
+                // gitdir contains <checkoutPath>/.git — strip the /.git suffix
+                checkoutPath = gitdirContent.replace(/\/\.git\/?$/, '');
+            }
+            catch (_) {
+                continue;
+            }
+            this._watchHeadFile(headFile, checkoutPath);
+        }
+    }
+    _watchHeadFile(headPath, cwdPath) {
+        // Seed initial branch to avoid false-positive on first change detection
+        try {
+            const content = fs.readFileSync(headPath, 'utf-8').trim();
+            const match = content.match(/^ref: refs\/heads\/(.+)$/);
+            if (match)
+                this._lastBranch.set(cwdPath, match[1]);
+        }
+        catch (_) { }
+        this._createWatcher(headPath, cwdPath);
+    }
+    /**
+     * Create (or recreate) an fs.watch() for a HEAD file. Tracked by headPath
+     * so we can close and recreate after detection — git's atomic checkout
+     * (write HEAD.lock, rename to HEAD) can change the file's inode, which
+     * silently kills kqueue-based watchers on macOS.
+     */
+    _createWatcher(headPath, cwdPath) {
+        // Close existing watcher for this path if any
+        const existing = this._watcherMap.get(headPath);
+        if (existing) {
+            try {
+                existing.watcher.close();
+            }
+            catch (_) { }
+        }
+        try {
+            const watcher = fs.watch(headPath, { persistent: false }, () => {
+                this._debouncedCheck(headPath, cwdPath);
+            });
+            watcher.on('error', () => { });
+            this._watcherMap.set(headPath, { watcher, cwdPath });
+        }
+        catch (_) { }
+    }
+    _debouncedCheck(headPath, cwdPath) {
+        const existing = this._debounceTimers.get(cwdPath);
+        if (existing)
+            clearTimeout(existing);
+        // Capture generation so the async callback can detect stale invocations
+        const gen = this._generation;
+        this._debounceTimers.set(cwdPath, setTimeout(() => {
+            this._debounceTimers.delete(cwdPath);
+            this._readAndEmit(headPath, cwdPath, gen);
+        }, 300));
+    }
+    async _readAndEmit(headPath, cwdPath, gen) {
+        try {
+            const { stdout } = await execFileAsync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: cwdPath });
+            const newBranch = stdout.trim();
+            const lastBranch = this._lastBranch.get(cwdPath);
+            if (newBranch && newBranch !== lastBranch) {
+                this._lastBranch.set(cwdPath, newBranch);
+                this._callback(cwdPath, newBranch);
+            }
+        }
+        catch (_) {
+            // Non-fatal — repo may be in detached HEAD or mid-rebase
+        }
+        // Recreate the watcher — the inode may have changed due to atomic rename.
+        // Only recreate if the generation hasn't changed (rebuild/close didn't happen
+        // while git rev-parse was in flight).
+        if (this._generation === gen) {
+            this._createWatcher(headPath, cwdPath);
+        }
+    }
+    _closeAll() {
+        this._generation++;
+        for (const { watcher } of this._watcherMap.values()) {
+            try {
+                watcher.close();
+            }
+            catch (_) { }
+        }
+        this._watcherMap.clear();
+        for (const timer of this._debounceTimers.values()) {
+            clearTimeout(timer);
+        }
+        this._debounceTimers.clear();
+        this._lastBranch.clear();
+    }
+    close() {
+        this._closeAll();
+    }
+}
+/**
+ * Resolve the git directory for a checkout path, handling both regular repos
+ * and worktrees. For worktrees, follows the `commondir` file to find the main
+ * repo's git dir (where remote refs live).
+ */
+export function resolveGitDir(cwdPath) {
+    const dotGit = path.join(cwdPath, '.git');
+    let stat;
+    try {
+        stat = fs.statSync(dotGit, { throwIfNoEntry: false });
+    }
+    catch (_) {
+        return null; // EACCES, ENOTDIR, etc.
+    }
+    if (!stat)
+        return null;
+    if (stat.isDirectory())
+        return dotGit;
+    // Worktree: .git is a file containing "gitdir: <path>"
+    let content;
+    try {
+        content = fs.readFileSync(dotGit, 'utf-8').trim();
+    }
+    catch (_) {
+        return null;
+    }
+    const match = content.match(/^gitdir:\s*(.+)$/);
+    if (!match)
+        return null;
+    const worktreeGitDir = path.resolve(cwdPath, match[1]);
+    // Follow commondir to find the main repo's git dir (where refs/remotes/ lives)
+    const commondirFile = path.join(worktreeGitDir, 'commondir');
+    try {
+        const commondir = fs.readFileSync(commondirFile, 'utf-8').trim();
+        return path.resolve(worktreeGitDir, commondir);
+    }
+    catch (_) {
+        // No commondir — fall back to the worktree git dir itself
+        return worktreeGitDir;
+    }
+}
+export class RefWatcher {
+    _watchers = [];
+    _debounceTimers = new Map();
+    _lastSha = new Map();
+    _entries = new Map();
+    _callback;
+    constructor(callback) {
+        this._callback = callback;
+    }
+    async rebuild(entries) {
+        this._closeAll();
+        // Dedupe entries — multiple sessions can share the same cwdPath:branch
+        const seen = new Set();
+        for (const { cwdPath, branch } of entries) {
+            const dedupeKey = `${cwdPath}:${branch}`;
+            if (seen.has(dedupeKey))
+                continue;
+            seen.add(dedupeKey);
+            // Resolve the upstream tracking ref
+            let upstreamRef;
+            try {
+                const { stdout } = await execFileAsync('git', ['rev-parse', '--symbolic-full-name', '@{u}'], { cwd: cwdPath });
+                upstreamRef = stdout.trim();
+                if (!upstreamRef)
+                    continue;
+            }
+            catch (_) {
+                // No upstream (detached HEAD, unpushed branch) — skip
+                continue;
+            }
+            const key = `${cwdPath}:${branch}`;
+            this._entries.set(key, { cwdPath, branch, upstreamRef });
+            // Seed last known SHA
+            try {
+                const { stdout } = await execFileAsync('git', ['rev-parse', upstreamRef], { cwd: cwdPath });
+                this._lastSha.set(key, stdout.trim());
+            }
+            catch (_) {
+                this._lastSha.set(key, null);
+            }
+            // Resolve git dir (handles worktrees via commondir)
+            const gitDir = resolveGitDir(cwdPath);
+            if (!gitDir)
+                continue;
+            // Watch the loose ref file if it exists (e.g. refs/remotes/origin/feature-x)
+            // upstreamRef is like "refs/remotes/origin/feature-x"
+            const refFile = path.join(gitDir, upstreamRef);
+            this._addWatch(refFile, key);
+            // Watch the remote's ref directory to catch new ref creation
+            const refDir = path.dirname(refFile);
+            this._addWatch(refDir, key);
+        }
+    }
+    _addWatch(target, key) {
+        try {
+            if (!fs.existsSync(target))
+                return;
+            const watcher = fs.watch(target, { persistent: false }, () => {
+                this._debouncedCheck(key);
+            });
+            watcher.on('error', () => { });
+            this._watchers.push(watcher);
+        }
+        catch (_) { }
+    }
+    _debouncedCheck(key) {
+        const existing = this._debounceTimers.get(key);
+        if (existing)
+            clearTimeout(existing);
+        this._debounceTimers.set(key, setTimeout(() => {
+            this._debounceTimers.delete(key);
+            this._checkAndEmit(key);
+        }, 300));
+    }
+    async _checkAndEmit(key) {
+        const entry = this._entries.get(key);
+        if (!entry)
+            return;
+        let newSha;
+        try {
+            const { stdout } = await execFileAsync('git', ['rev-parse', entry.upstreamRef], { cwd: entry.cwdPath });
+            newSha = stdout.trim();
+        }
+        catch (_) {
+            newSha = null; // Ref deleted or pruned
+        }
+        const lastSha = this._lastSha.get(key);
+        if (newSha !== lastSha) {
+            this._lastSha.set(key, newSha);
+            this._callback(entry.cwdPath, entry.branch);
+        }
+    }
+    _closeAll() {
+        closeWatchers(this._watchers);
+        this._watchers = [];
+        for (const timer of this._debounceTimers.values()) {
+            clearTimeout(timer);
+        }
+        this._debounceTimers.clear();
+        this._lastSha.clear();
+        this._entries.clear();
+    }
+    close() {
+        this._closeAll();
+    }
+}
+// Directories to ignore when watching the working tree.
+// These never contain user-authored source files worth diffing.
+const IGNORED_DIRS = new Set([
+    '.git',
+    'node_modules',
+    '.next',
+    '.nuxt',
+    '.svelte-kit',
+    'dist',
+    'build',
+    'out',
+    '.output',
+    'coverage',
+    '__pycache__',
+    '.pytest_cache',
+    '.venv',
+    'venv',
+    '.turbo',
+    '.cache',
+    '.parcel-cache',
+]);
+export class GitWatcher extends EventEmitter {
+    _watchers = new Map();
+    _debounceTimers = new Map();
+    watch(workspacePath) {
+        const existing = this._watchers.get(workspacePath);
+        if (existing) {
+            existing.refCount++;
+            return;
+        }
+        let treeWatcher;
+        let headWatcher;
+        // 1. Watch the working tree recursively for file edits.
+        //    macOS uses FSEvents (single kernel subscription). Linux uses inotify
+        //    (one watch per directory, can hit fs.inotify.max_user_watches limit).
+        //    .git/ changes are filtered out so git-status calls never cause feedback loops.
+        try {
+            treeWatcher = fs.watch(workspacePath, { persistent: false, recursive: true }, (_event, filename) => {
+                if (!filename)
+                    return;
+                const firstSegment = filename.split(path.sep)[0] ?? '';
+                if (IGNORED_DIRS.has(firstSegment))
+                    return;
+                this._debouncedEmit(workspacePath);
+            });
+            treeWatcher.on('error', (err) => {
+                logger.warn('[GitWatcher] working-tree watch failed for', workspacePath, '—', err.message);
+                logger.warn('[GitWatcher] changed-files will not auto-refresh for this workspace. On Linux, try: sysctl fs.inotify.max_user_watches=524288');
+            });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            logger.warn('[GitWatcher] could not watch working tree for', workspacePath, '—', msg);
+        }
+        // 2. Watch .git/HEAD for commits and branch switches.
+        //    Single-file watch, no feedback loop risk (HEAD only changes on checkout/commit).
+        const gitDir = path.join(workspacePath, '.git');
+        try {
+            const stat = fs.statSync(gitDir);
+            let headPath;
+            if (stat.isFile()) {
+                // Worktree: .git is a file pointing to the real git dir
+                const content = fs.readFileSync(gitDir, 'utf-8').trim();
+                const match = content.match(/^gitdir:\s*(.+)$/);
+                headPath = match
+                    ? path.join(path.resolve(workspacePath, match[1]), 'HEAD')
+                    : '';
+            }
+            else {
+                headPath = path.join(gitDir, 'HEAD');
+            }
+            if (headPath && fs.existsSync(headPath)) {
+                headWatcher = fs.watch(headPath, { persistent: false }, () => {
+                    this._debouncedEmit(workspacePath);
+                });
+                headWatcher.on('error', () => {
+                    /* HEAD watch is best-effort */
+                });
+            }
+        }
+        catch {
+            // .git doesn't exist or isn't readable — skip HEAD watching
+        }
+        if (!treeWatcher && !headWatcher)
+            return;
+        this._watchers.set(workspacePath, {
+            treeWatcher: treeWatcher ?? headWatcher,
+            headWatcher: treeWatcher ? headWatcher : undefined,
+            refCount: 1,
+        });
+    }
+    unwatch(workspacePath) {
+        const entry = this._watchers.get(workspacePath);
+        if (!entry)
+            return;
+        entry.refCount--;
+        if (entry.refCount <= 0) {
+            try {
+                entry.treeWatcher.close();
+            }
+            catch { }
+            if (entry.headWatcher)
+                try {
+                    entry.headWatcher.close();
+                }
+                catch { }
+            this._watchers.delete(workspacePath);
+            const timer = this._debounceTimers.get(workspacePath);
+            if (timer) {
+                clearTimeout(timer);
+                this._debounceTimers.delete(workspacePath);
+            }
+        }
+    }
+    _debouncedEmit(workspacePath) {
+        const existing = this._debounceTimers.get(workspacePath);
+        if (existing)
+            clearTimeout(existing);
+        this._debounceTimers.set(workspacePath, setTimeout(async () => {
+            this._debounceTimers.delete(workspacePath);
+            // Collect changed file paths via git status for the sidebar's blue-dot tracking
+            let changedFiles = [];
+            try {
+                const { stdout } = await execFileAsync('git', ['status', '--porcelain=v1', '-z'], {
+                    cwd: workspacePath,
+                    timeout: 5000,
+                });
+                const parts = stdout.split('\0').filter(Boolean);
+                for (let i = 0; i < parts.length; i++) {
+                    const entry = parts[i];
+                    const code = entry.slice(0, 2);
+                    const filePath = entry.slice(3);
+                    if (code.startsWith('R')) {
+                        // Rename: porcelain -z gives [newPath]\0[oldPath]
+                        // filePath is the new name (the one on disk), next part is the old name
+                        if (filePath)
+                            changedFiles.push(filePath);
+                        i++; // skip old path
+                        continue;
+                    }
+                    if (filePath)
+                        changedFiles.push(filePath);
+                }
+            }
+            catch {
+                // git status failed — emit without file list
+            }
+            this.emit('files-changed', { workspacePath, changedFiles });
+        }, 1000));
+    }
+    close() {
+        for (const entry of this._watchers.values()) {
+            try {
+                entry.treeWatcher.close();
+            }
+            catch { }
+            if (entry.headWatcher)
+                try {
+                    entry.headWatcher.close();
+                }
+                catch { }
+        }
+        this._watchers.clear();
+        for (const timer of this._debounceTimers.values()) {
+            clearTimeout(timer);
+        }
+        this._debounceTimers.clear();
+    }
+}