diff-easy 0.1.0

package/dist/server/server.js

@@ -0,0 +1,1283 @@
+import { execFileSync, spawn } from 'child_process';
+import { createHash } from 'crypto';
+import { existsSync, readdirSync } from 'fs';
+import { basename, join, dirname, isAbsolute, resolve, sep } from 'path';
+import { fileURLToPath } from 'url';
+import express from 'express';
+import open from 'open';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+import { DiffMode } from '../types/watch.js';
+import { formatCommentsOutput } from '../utils/commentFormatting.js';
+import { mergeCommentImports, mergeCommentThreads, normalizeCommentImports, serializeCommentImports, } from '../utils/commentImports.js';
+import { buildEditorSpawnSpec, CUSTOM_EDITOR_ID, NONE_EDITOR_ID, resolveEditorOption, } from '../utils/editorOptions.js';
+import { getFileExtension } from '../utils/fileUtils.js';
+import { countTurnsSince, deleteHubInfo, deleteServerInfo, latestTurnTimestamp, readTurnLog, writeHubInfo, writeServerInfo, } from '../utils/turnLog.js';
+import { pushRecentFolder, readHubConfig, writeHubConfig, } from '../utils/hubConfig.js';
+import { getPrCommentImports, getPrDetails, getPrPatch } from '../cli/github.js';
+import { FileWatcherService } from './file-watcher.js';
+import { GitDiffParser } from './git-diff.js';
+import { groupWithClaude } from './grouping/claudeCli.js';
+import { readCache, writeCache } from './grouping/cache.js';
+import { groupSmart } from '../shared/grouping.js';
+import { createDiffSelection, diffSelectionsEqual, getDiffSelectionKey, isWorkingTreeTarget, } from '../utils/diffSelection.js';
+const GENERATED_STATUS_CACHE_TTL_MS = 60_000;
+const MAX_DIFF_CACHE_ENTRIES = 8;
+function createDiffCacheKey(selection, ignoreWhitespace) {
+    return `${getDiffSelectionKey(selection)}\u0000${ignoreWhitespace ? '1' : '0'}`;
+}
+function getCachedDiffResponse(cache, key) {
+    const cached = cache.get(key);
+    if (!cached) {
+        return undefined;
+    }
+    // Refresh insertion order to keep the most recently used entry.
+    cache.delete(key);
+    cache.set(key, cached);
+    return cached;
+}
+function setCachedDiffResponse(cache, key, value) {
+    if (cache.has(key)) {
+        cache.delete(key);
+    }
+    cache.set(key, value);
+    while (cache.size > MAX_DIFF_CACHE_ENTRIES) {
+        const oldestKey = cache.keys().next().value;
+        if (typeof oldestKey !== 'string') {
+            break;
+        }
+        cache.delete(oldestKey);
+    }
+}
+function createResolvedCommentSelection(responseDiffData, fallbackSelection, stdinDiff) {
+    const baseCommitish = responseDiffData.baseCommitish ?? (stdinDiff ? 'stdin' : fallbackSelection.baseCommitish);
+    const targetCommitish = responseDiffData.targetCommitish ?? (stdinDiff ? 'stdin' : fallbackSelection.targetCommitish);
+    const baseMode = responseDiffData.requestedBaseMode ?? fallbackSelection.baseMode;
+    return createDiffSelection(baseCommitish, targetCommitish, baseMode);
+}
+function createCommentSessionKey(selection) {
+    return getDiffSelectionKey(selection);
+}
+/**
+ * Disable git's optional index-refresh lock for every git child this process
+ * spawns. Read commands (git status/diff) otherwise opportunistically rewrite
+ * `.git/index`'s stat cache; the file watcher treats that as a change and
+ * triggers an endless reload loop (fetch → index rewrite → reload → fetch …).
+ * `??=` respects an explicit operator override.
+ */
+export function disableGitOptionalLocks() {
+    process.env.GIT_OPTIONAL_LOCKS ??= '0';
+}
+export async function startServer(options) {
+    // Set once at the server entry — before any GitDiffParser or the file watcher
+    // is created — rather than as a per-instance constructor side effect.
+    disableGitOptionalLocks();
+    const app = express();
+    const initialCommentImports = options.commentImports || [];
+    const initialSelection = options.selection ?? createDiffSelection('', '');
+    const commentImportId = initialCommentImports.length > 0
+        ? createHash('sha256').update(serializeCommentImports(initialCommentImports)).digest('hex')
+        : undefined;
+    // diff-easy: the active workspace. In hub mode it starts null (the UI picks a
+    // source at runtime); otherwise it's the repo fixed at startup. All readers go
+    // through `currentWorkspace` so the runtime swap is a localized change.
+    let currentWorkspace = null;
+    if (!options.hub) {
+        const repositoryPath = resolve(options.repoPath ?? process.cwd());
+        const repositoryId = createHash('sha256').update(repositoryPath).digest('hex');
+        currentWorkspace = {
+            repoPath: repositoryPath,
+            repoId: repositoryId,
+            parser: new GitDiffParser(repositoryPath),
+            // stdin / --pr launch is a static-patch workspace.
+            patch: options.stdinDiff,
+            commentImports: initialCommentImports.length > 0 ? initialCommentImports : undefined,
+            commentImportId,
+            prTitle: options.prTitle,
+            prBody: options.prBody,
+        };
+    }
+    const fileWatcher = new FileWatcherService();
+    const generatedStatusCache = new Map();
+    const diffDataCache = new Map();
+    const initialIgnoreWhitespace = options.ignoreWhitespace || false;
+    const parseBaseMode = (value) => {
+        if (value === 'merge-base') {
+            return 'merge-base';
+        }
+        return undefined;
+    };
+    app.use(express.json());
+    app.use(express.text()); // For sendBeacon text/plain requests
+    app.use((_req, res, next) => {
+        res.header('Access-Control-Allow-Origin', 'http://localhost:*');
+        res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+        res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept');
+        next();
+    });
+    // Generate initial diff data for the isEmpty check. In hub mode there is no
+    // workspace yet, so there is nothing to validate or pre-render.
+    let initialDiffData = null;
+    if (currentWorkspace) {
+        const workspace = currentWorkspace; // non-null; survives await narrowing
+        // Skip validation for a static-patch (stdin/PR) workspace.
+        if (!workspace.patch) {
+            const isValidCommit = await workspace.parser.validateCommit(initialSelection.targetCommitish);
+            if (!isValidCommit) {
+                throw new Error(`Invalid or non-existent commit: ${initialSelection.targetCommitish}`);
+            }
+        }
+        if (workspace.patch) {
+            // Parse the static patch directly
+            initialDiffData = workspace.parser.parseStdinDiff(workspace.patch);
+        }
+        else {
+            initialDiffData = await workspace.parser.parseDiff(initialSelection, initialIgnoreWhitespace, options.contextLines);
+            setCachedDiffResponse(diffDataCache, createDiffCacheKey(initialSelection, initialIgnoreWhitespace), initialDiffData);
+        }
+    }
+    // Function to invalidate cache when file changes are detected
+    const invalidateCache = () => {
+        diffDataCache.clear();
+        generatedStatusCache.clear();
+        currentWorkspace?.parser.clearResolvedCommitCache();
+    };
+    // Track current revisions for cache invalidation
+    let currentSelection = initialSelection;
+    let currentCommentSelection = initialDiffData
+        ? createResolvedCommentSelection(initialDiffData, initialSelection, Boolean(currentWorkspace?.patch))
+        : initialSelection;
+    function parseRepositoryRelativePath(filepath) {
+        if (!currentWorkspace) {
+            return { ok: false, error: 'File path outside repository' };
+        }
+        if (typeof filepath !== 'string' || filepath.length === 0) {
+            return { ok: false, error: 'Invalid file path' };
+        }
+        const normalizedFilepath = filepath.replace(/\\/g, '/');
+        const hasParentTraversal = normalizedFilepath.split('/').some((segment) => segment === '..');
+        if (isAbsolute(filepath) || normalizedFilepath.startsWith('/') || hasParentTraversal) {
+            return { ok: false, error: 'File path outside repository' };
+        }
+        const resolvedPath = resolve(currentWorkspace.repoPath, normalizedFilepath);
+        if (resolvedPath !== currentWorkspace.repoPath &&
+            !resolvedPath.startsWith(`${currentWorkspace.repoPath}${sep}`)) {
+            return { ok: false, error: 'File path outside repository' };
+        }
+        return { ok: true, path: normalizedFilepath };
+    }
+    function parseEditorRequest(value) {
+        if (!value || typeof value !== 'object') {
+            return { id: undefined, command: undefined, argsTemplate: undefined };
+        }
+        const candidate = value;
+        return {
+            id: typeof candidate.id === 'string' ? candidate.id : undefined,
+            command: typeof candidate.command === 'string' ? candidate.command : undefined,
+            argsTemplate: typeof candidate.argsTemplate === 'string' ? candidate.argsTemplate : undefined,
+        };
+    }
+    const commentSessions = new Map();
+    const initialCommentThreads = mergeCommentImports([], initialCommentImports).threads;
+    if (initialCommentThreads.length > 0) {
+        commentSessions.set(createCommentSessionKey(currentCommentSelection), {
+            threads: initialCommentThreads,
+            version: 1,
+        });
+    }
+    function getCommentSelectionFromQuery(query) {
+        const hasBase = typeof query.base === 'string';
+        const hasTarget = typeof query.target === 'string';
+        const hasBaseMode = typeof query.baseMode === 'string';
+        if (!hasBase && !hasTarget && !hasBaseMode) {
+            return currentCommentSelection;
+        }
+        return createDiffSelection(hasBase ? query.base : currentCommentSelection.baseCommitish, hasTarget ? query.target : currentCommentSelection.targetCommitish, hasBaseMode
+            ? parseBaseMode(query.baseMode)
+            : hasBase || hasTarget
+                ? undefined
+                : currentCommentSelection.baseMode);
+    }
+    function getOrCreateCommentSession(selection) {
+        const key = createCommentSessionKey(selection);
+        const existing = commentSessions.get(key);
+        if (existing) {
+            return existing;
+        }
+        const nextSession = {
+            threads: [],
+            version: 0,
+        };
+        commentSessions.set(key, nextSession);
+        return nextSession;
+    }
+    app.get('/api/diff', async (req, res) => {
+        const workspace = currentWorkspace;
+        if (!workspace) {
+            res.json({ needsWorkspace: true });
+            return;
+        }
+        const ignoreWhitespace = req.query.ignoreWhitespace === 'true';
+        const hasBase = typeof req.query.base === 'string';
+        const hasTarget = typeof req.query.target === 'string';
+        const hasBaseMode = typeof req.query.baseMode === 'string';
+        const requestedSelection = createDiffSelection(hasBase ? req.query.base : currentSelection.baseCommitish, hasTarget ? req.query.target : currentSelection.targetCommitish, hasBaseMode
+            ? parseBaseMode(req.query.baseMode)
+            : hasBase || hasTarget
+                ? undefined
+                : currentSelection.baseMode);
+        const isStatic = Boolean(workspace.patch);
+        const wsImports = workspace.commentImports ?? [];
+        const shouldIncludeCommentImports = wsImports.length > 0 &&
+            (isStatic || diffSelectionsEqual(requestedSelection, initialSelection));
+        currentSelection = requestedSelection;
+        let responseDiffData;
+        let diffError;
+        if (isStatic) {
+            // Static patch (stdin / PR): the diff is the workspace's patch.
+            responseDiffData = workspace.parser.parseStdinDiff(workspace.patch);
+        }
+        else {
+            const cacheKey = createDiffCacheKey(requestedSelection, ignoreWhitespace);
+            // Working-tree targets ('.'/'working'/'staged') are mutable: the same
+            // selection yields a different diff as the tree/index/HEAD change. The
+            // diff cache is keyed by the selection string and only evicted by the file
+            // watcher, so a single missed event (e.g. a commit) would strand a stale
+            // diff until a server restart. Never cache them — re-parsing is cheap and
+            // correctness beats the micro-optimization. Immutable ranges still cache.
+            const mutableTarget = isWorkingTreeTarget(requestedSelection.targetCommitish);
+            const cached = mutableTarget ? null : getCachedDiffResponse(diffDataCache, cacheKey);
+            if (cached) {
+                responseDiffData = cached;
+            }
+            else {
+                try {
+                    responseDiffData = await workspace.parser.parseDiff(requestedSelection, ignoreWhitespace, options.contextLines);
+                    if (!mutableTarget)
+                        setCachedDiffResponse(diffDataCache, cacheKey, responseDiffData);
+                    generatedStatusCache.clear();
+                }
+                catch (error) {
+                    // diff-easy: degrade gracefully instead of 500-ing the page. A common
+                    // cause is a turn snapshot commit that was pruned by `git gc`.
+                    diffError = error instanceof Error ? error.message : 'Failed to load diff';
+                    responseDiffData = {
+                        commit: 'Unable to load diff',
+                        files: [],
+                        isEmpty: true,
+                        baseCommitish: requestedSelection.baseCommitish,
+                        targetCommitish: requestedSelection.targetCommitish,
+                        requestedBaseCommitish: requestedSelection.baseCommitish,
+                        requestedTargetCommitish: requestedSelection.targetCommitish,
+                        requestedBaseMode: requestedSelection.baseMode,
+                    };
+                }
+            }
+        }
+        if (!responseDiffData) {
+            res.json({ needsWorkspace: true });
+            return;
+        }
+        currentCommentSelection = createResolvedCommentSelection(responseDiffData, requestedSelection, isStatic);
+        const baseCommitish = responseDiffData.baseCommitish ?? (isStatic ? 'stdin' : undefined);
+        const targetCommitish = responseDiffData.targetCommitish ?? (isStatic ? 'stdin' : undefined);
+        const requestedBaseCommitish = responseDiffData.requestedBaseCommitish ??
+            (requestedSelection.baseCommitish || (isStatic ? 'stdin' : undefined));
+        const requestedTargetCommitish = responseDiffData.requestedTargetCommitish ??
+            (requestedSelection.targetCommitish || (isStatic ? 'stdin' : undefined));
+        const requestedBaseMode = responseDiffData.requestedBaseMode ?? requestedSelection.baseMode;
+        res.json({
+            ...responseDiffData,
+            ignoreWhitespace,
+            openInEditorAvailable: !isStatic,
+            baseCommitish,
+            targetCommitish,
+            requestedBaseCommitish,
+            requestedTargetCommitish,
+            requestedBaseMode,
+            clearComments: options.clearComments,
+            repositoryId: workspace.repoId,
+            repoName: isStatic ? undefined : basename(workspace.repoPath),
+            repoPath: isStatic ? undefined : workspaceLabel(workspace.repoPath),
+            commentImports: shouldIncludeCommentImports ? wsImports : undefined,
+            commentImportId: shouldIncludeCommentImports ? workspace.commentImportId : undefined,
+            prTitle: isStatic ? workspace.prTitle : undefined,
+            prBody: isStatic ? workspace.prBody : undefined,
+            diffError,
+        });
+    });
+    app.get(/^\/api\/generated-status\/(.*)$/, async (req, res) => {
+        if (currentWorkspace?.patch) {
+            res.status(400).json({ error: 'Generated status is not available for stdin diff' });
+            return;
+        }
+        const workspace = currentWorkspace;
+        if (!workspace) {
+            res.status(409).json({ error: 'No workspace selected' });
+            return;
+        }
+        try {
+            const filepathResult = parseRepositoryRelativePath(req.params[0]);
+            if (!filepathResult.ok) {
+                res.status(400).json({ error: filepathResult.error });
+                return;
+            }
+            const normalizedFilepath = filepathResult.path;
+            const ref = req.query.ref || currentSelection.targetCommitish || 'HEAD';
+            const cacheKey = `${ref}:${normalizedFilepath}`;
+            const now = Date.now();
+            const cached = generatedStatusCache.get(cacheKey);
+            if (cached && cached.expiresAt > now) {
+                res.json(cached.value);
+                return;
+            }
+            const status = await workspace.parser.getGeneratedStatus(normalizedFilepath, ref);
+            const response = {
+                path: normalizedFilepath,
+                ref,
+                ...status,
+            };
+            generatedStatusCache.set(cacheKey, {
+                value: response,
+                expiresAt: now + GENERATED_STATUS_CACHE_TTL_MS,
+            });
+            res.json(response);
+        }
+        catch (error) {
+            console.error('Error fetching generated status:', error);
+            res.status(500).json({ error: 'Failed to get generated status' });
+        }
+    });
+    // Get available revisions for revision selector
+    app.get('/api/revisions', async (_req, res) => {
+        if (currentWorkspace?.patch) {
+            res.status(400).json({ error: 'Revision selection not available for stdin diff' });
+            return;
+        }
+        const workspace = currentWorkspace;
+        if (!workspace) {
+            res.json({ needsWorkspace: true });
+            return;
+        }
+        try {
+            const { branches, commits, originDefaultBranch, resolvedBase, resolvedTarget, currentBranch, pgitParent, branchBase, branchBaseSource, } = await workspace.parser.getRevisionOptions(currentSelection.baseCommitish, currentSelection.targetCommitish);
+            const response = {
+                specialOptions: [
+                    { value: '.', label: 'All Uncommitted Changes' },
+                    { value: 'staged', label: 'Staging Area' },
+                    { value: 'working', label: 'Working Directory' },
+                ],
+                branches,
+                commits,
+                originDefaultBranch,
+                resolvedBase,
+                resolvedTarget,
+                currentBranch,
+                pgitParent,
+                branchBase,
+                branchBaseSource,
+                repositoryId: workspace.repoId,
+            };
+            res.json(response);
+        }
+        catch (error) {
+            console.error('Error fetching revisions:', error);
+            res.status(500).json({ error: 'Failed to fetch revisions' });
+        }
+    });
+    app.get('/api/commits', async (req, res) => {
+        const workspace = currentWorkspace;
+        if (!workspace || workspace.patch) {
+            res.status(400).json({ error: 'Commits not available' });
+            return;
+        }
+        const target = typeof req.query.target === 'string' ? req.query.target : '';
+        const base = typeof req.query.base === 'string' && req.query.base ? req.query.base : undefined;
+        if (!target) {
+            res.status(400).json({ error: 'target is required' });
+            return;
+        }
+        try {
+            const commits = await workspace.parser.getCommitsInRange(base, target);
+            res.json({ commits });
+        }
+        catch (error) {
+            console.error('Error fetching commits:', error);
+            res.status(500).json({ error: 'Failed to fetch commits' });
+        }
+    });
+    app.get(/^\/api\/line-count\/(.*)$/, async (req, res) => {
+        try {
+            if (currentWorkspace?.patch) {
+                res.status(404).json({ error: 'Line count not available for stdin diff' });
+                return;
+            }
+            const workspace = currentWorkspace;
+            if (!workspace) {
+                res.status(409).json({ error: 'No workspace selected' });
+                return;
+            }
+            const filepathResult = parseRepositoryRelativePath(req.params[0]);
+            if (!filepathResult.ok) {
+                res.status(400).json({ error: filepathResult.error });
+                return;
+            }
+            const filepath = filepathResult.path;
+            const oldRef = req.query.oldRef;
+            const oldPathResult = req.query.oldPath
+                ? parseRepositoryRelativePath(req.query.oldPath)
+                : { ok: true, path: filepath };
+            if (!oldPathResult.ok) {
+                res.status(400).json({ error: oldPathResult.error });
+                return;
+            }
+            const newRef = req.query.newRef;
+            const oldPath = oldPathResult.path;
+            const result = {};
+            if (oldRef) {
+                try {
+                    result.oldLineCount = await workspace.parser.getLineCount(oldPath, oldRef);
+                }
+                catch {
+                    result.oldLineCount = 0;
+                }
+            }
+            if (newRef) {
+                try {
+                    result.newLineCount = await workspace.parser.getLineCount(filepath, newRef);
+                }
+                catch {
+                    result.newLineCount = 0;
+                }
+            }
+            res.json(result);
+        }
+        catch (error) {
+            console.error('Error fetching line count:', error);
+            res.status(500).json({ error: 'Failed to get line count' });
+        }
+    });
+    app.get(/^\/api\/blob\/(.*)$/, async (req, res) => {
+        try {
+            // If using stdin diff, blob content is not available
+            if (currentWorkspace?.patch) {
+                res.status(404).json({ error: 'Blob content not available for stdin diff' });
+                return;
+            }
+            const workspace = currentWorkspace;
+            if (!workspace) {
+                res.status(409).json({ error: 'No workspace selected' });
+                return;
+            }
+            const filepathResult = parseRepositoryRelativePath(req.params[0]);
+            if (!filepathResult.ok) {
+                res.status(400).json({ error: filepathResult.error });
+                return;
+            }
+            const filepath = filepathResult.path;
+            const ref = req.query.ref || 'HEAD';
+            const blob = await workspace.parser.getBlobContent(filepath, ref);
+            // Determine content type based on file extension
+            const ext = getFileExtension(filepath);
+            const contentTypes = {
+                jpg: 'image/jpeg',
+                jpeg: 'image/jpeg',
+                png: 'image/png',
+                gif: 'image/gif',
+                bmp: 'image/bmp',
+                svg: 'image/svg+xml',
+                webp: 'image/webp',
+                ico: 'image/x-icon',
+                tiff: 'image/tiff',
+                tif: 'image/tiff',
+                avif: 'image/avif',
+                heic: 'image/heic',
+                heif: 'image/heif',
+            };
+            const contentType = contentTypes[ext || ''] || 'application/octet-stream';
+            res.setHeader('Content-Type', contentType);
+            res.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate');
+            res.setHeader('Pragma', 'no-cache');
+            res.setHeader('Expires', '0');
+            res.send(blob);
+        }
+        catch (error) {
+            console.error('Error fetching blob:', error);
+            res.status(404).json({ error: 'File not found' });
+        }
+    });
+    function normalizeLineValue(line) {
+        if (Array.isArray(line) && line.length === 2) {
+            const start = line[0];
+            const end = line[1];
+            if (typeof start === 'number' &&
+                typeof end === 'number' &&
+                Number.isInteger(start) &&
+                Number.isInteger(end) &&
+                start > 0 &&
+                end > 0 &&
+                start <= end) {
+                return { start, end };
+            }
+        }
+        if (typeof line === 'number' && Number.isInteger(line) && line > 0) {
+            return line;
+        }
+        return 1;
+    }
+    function normalizeComment(comment) {
+        const now = new Date().toISOString();
+        const timestamp = typeof comment.timestamp === 'string' ? comment.timestamp : now;
+        const threadId = typeof comment.id === 'string' && comment.id.length > 0
+            ? comment.id
+            : createHash('sha256').update(JSON.stringify(comment)).digest('hex').slice(0, 12);
+        const filePath = typeof comment.file === 'string' && comment.file.length > 0 ? comment.file : '<unknown file>';
+        return {
+            id: threadId,
+            filePath,
+            createdAt: timestamp,
+            updatedAt: timestamp,
+            position: {
+                side: comment.side ?? 'new',
+                line: normalizeLineValue(comment.line),
+            },
+            codeSnapshot: typeof comment.codeContent === 'string'
+                ? {
+                    content: comment.codeContent,
+                }
+                : undefined,
+            messages: [
+                {
+                    id: threadId,
+                    body: comment.body,
+                    author: comment.author,
+                    createdAt: timestamp,
+                    updatedAt: timestamp,
+                },
+            ],
+        };
+    }
+    function toCommentThread(thread) {
+        return {
+            id: thread.id,
+            file: thread.filePath,
+            line: typeof thread.position.line === 'number'
+                ? thread.position.line
+                : [thread.position.line.start, thread.position.line.end],
+            side: thread.position.side,
+            createdAt: thread.createdAt,
+            updatedAt: thread.updatedAt,
+            codeContent: thread.codeSnapshot?.content,
+            messages: thread.messages,
+        };
+    }
+    function normalizeThreadPayload(thread) {
+        if ('filePath' in thread && 'position' in thread) {
+            return thread;
+        }
+        const threadId = typeof thread.id === 'string' && thread.id.length > 0
+            ? thread.id
+            : createHash('sha256').update(JSON.stringify(thread)).digest('hex').slice(0, 12);
+        const now = new Date().toISOString();
+        const messages = Array.isArray(thread.messages) && thread.messages.length > 0
+            ? thread.messages.map((message, index) => ({
+                id: typeof message.id === 'string' && message.id.length > 0
+                    ? message.id
+                    : `${threadId}:${index}`,
+                body: message.body,
+                author: message.author,
+                createdAt: message.createdAt || thread.createdAt || now,
+                updatedAt: message.updatedAt || message.createdAt || thread.updatedAt || now,
+            }))
+            : [
+                {
+                    id: threadId,
+                    body: '',
+                    createdAt: thread.createdAt || now,
+                    updatedAt: thread.updatedAt || thread.createdAt || now,
+                },
+            ];
+        const firstMessage = messages[0];
+        const lastMessage = messages[messages.length - 1];
+        return {
+            id: threadId,
+            filePath: typeof thread.file === 'string' && thread.file.length > 0 ? thread.file : '<unknown file>',
+            createdAt: thread.createdAt || firstMessage?.createdAt || now,
+            updatedAt: thread.updatedAt || lastMessage?.updatedAt || thread.createdAt || now,
+            position: {
+                side: thread.side ?? 'new',
+                line: normalizeLineValue(thread.line),
+            },
+            codeSnapshot: typeof thread.codeContent === 'string'
+                ? {
+                    content: thread.codeContent,
+                }
+                : undefined,
+            messages,
+        };
+    }
+    function parseCommentsPayload(body) {
+        const payload = typeof body === 'string'
+            ? JSON.parse(body)
+            : body;
+        if (Array.isArray(payload.threads)) {
+            return payload.threads.map(normalizeThreadPayload);
+        }
+        if (Array.isArray(payload.comments)) {
+            return payload.comments.map(normalizeComment);
+        }
+        return [];
+    }
+    // Version the client based its push on (omitted by older clients).
+    function parseBaseVersion(payload) {
+        if (!payload || typeof payload !== 'object')
+            return undefined;
+        const value = payload.baseVersion;
+        return typeof value === 'number' && Number.isInteger(value) && value >= 0 ? value : undefined;
+    }
+    function parseCommentImportsPayload(body) {
+        if (typeof body === 'string') {
+            return normalizeCommentImports(JSON.parse(body));
+        }
+        return normalizeCommentImports(body);
+    }
+    function updateCommentSession(selection, nextThreads) {
+        const session = getOrCreateCommentSession(selection);
+        const previous = JSON.stringify(session.threads);
+        const next = JSON.stringify(nextThreads);
+        session.threads = nextThreads;
+        if (previous === next) {
+            return false;
+        }
+        session.version += 1;
+        fileWatcher.broadcast({
+            type: 'commentsChanged',
+            version: session.version,
+            timestamp: new Date().toISOString(),
+        });
+        return true;
+    }
+    app.post('/api/comments', (req, res) => {
+        try {
+            const selection = getCommentSelectionFromQuery(req.query);
+            const body = typeof req.body === 'string' ? JSON.parse(req.body) : req.body;
+            const nextThreads = parseCommentsPayload(body);
+            const baseVersion = parseBaseVersion(body);
+            const session = getOrCreateCommentSession(selection);
+            // Stale baseVersion means another writer (e.g. an agent) changed comments since the
+            // client's last read, so merge rather than overwrite. A matching/absent version replaces.
+            const isStale = typeof baseVersion === 'number' && baseVersion !== session.version;
+            const resolvedThreads = isStale
+                ? mergeCommentThreads(session.threads, nextThreads).threads
+                : nextThreads;
+            updateCommentSession(selection, resolvedThreads);
+            res.json({
+                success: true,
+                merged: isStale,
+                version: session.version,
+                threads: session.threads,
+            });
+        }
+        catch (error) {
+            console.error('Error parsing comments:', error);
+            res.status(400).json({ error: 'Invalid comment data' });
+        }
+    });
+    app.post('/api/comment-imports', (req, res) => {
+        try {
+            const selection = getCommentSelectionFromQuery(req.query);
+            const session = getOrCreateCommentSession(selection);
+            const commentImports = parseCommentImportsPayload(req.body);
+            const importId = createHash('sha256')
+                .update(serializeCommentImports(commentImports))
+                .digest('hex');
+            const merged = mergeCommentImports(session.threads, commentImports);
+            const changed = updateCommentSession(selection, merged.threads);
+            res.json({
+                success: true,
+                changed,
+                count: commentImports.length,
+                importId,
+                warnings: merged.warnings,
+            });
+        }
+        catch (error) {
+            console.error('Error parsing comment imports:', error);
+            res.status(400).json({ error: 'Invalid comment import data' });
+        }
+    });
+    app.get('/api/comments-json', (req, res) => {
+        const selection = getCommentSelectionFromQuery(req.query);
+        const session = getOrCreateCommentSession(selection);
+        res.json({
+            version: session.version,
+            threads: session.threads,
+        });
+    });
+    app.get('/api/comments-output', (req, res) => {
+        const selection = getCommentSelectionFromQuery(req.query);
+        const session = getOrCreateCommentSession(selection);
+        res.type('text/plain');
+        if (session.threads.length > 0) {
+            const output = formatCommentsOutput(session.threads.map(toCommentThread));
+            res.send(output);
+        }
+        else {
+            res.send('');
+        }
+    });
+    app.post('/api/open-in-editor', async (req, res) => {
+        if (currentWorkspace?.patch) {
+            res.status(400).json({ error: 'Open in editor is not available for stdin diff' });
+            return;
+        }
+        const { filePath, line, editor } = (req.body ?? {});
+        if (typeof filePath !== 'string') {
+            res.status(400).json({ error: 'Invalid request payload' });
+            return;
+        }
+        const filepathResult = parseRepositoryRelativePath(filePath);
+        if (!filepathResult.ok) {
+            res.status(400).json({ error: filepathResult.error });
+            return;
+        }
+        if (!currentWorkspace) {
+            res.status(409).json({ error: 'No workspace selected' });
+            return;
+        }
+        const resolvedPath = resolve(currentWorkspace.repoPath, filepathResult.path);
+        const editorRequest = parseEditorRequest(editor);
+        const editorId = editorRequest.id ?? process.env.DIFIT_EDITOR ?? process.env.EDITOR ?? undefined;
+        if (editorId?.toLowerCase() === NONE_EDITOR_ID) {
+            res.status(400).json({ error: 'Open in editor is disabled' });
+            return;
+        }
+        // The browser always sends command + argsTemplate in the body, so we use
+        // those directly. We only fall back to the preset table when neither is
+        // provided (for example, when DIFIT_EDITOR is set and there's no body).
+        let command;
+        let argsTemplate;
+        if (editorRequest.command !== undefined || editorRequest.argsTemplate !== undefined) {
+            command = (editorRequest.command ?? '').trim();
+            argsTemplate = (editorRequest.argsTemplate ?? '').trim();
+        }
+        else {
+            const preset = resolveEditorOption(editorId);
+            command = preset.command;
+            argsTemplate = preset.argsTemplate;
+        }
+        if (!command || !argsTemplate) {
+            const isCustom = editorId?.toLowerCase() === CUSTOM_EDITOR_ID;
+            res.status(400).json({
+                error: isCustom
+                    ? 'Custom editor is not configured. Set a command and arguments in Settings > System.'
+                    : 'Open in editor is not configured',
+            });
+            return;
+        }
+        const lineNumber = (() => {
+            const parsed = Number.parseInt(String(line ?? ''), 10);
+            return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+        })();
+        const spawnSpec = buildEditorSpawnSpec({
+            command,
+            argsTemplate,
+            filePath: resolvedPath,
+            lineNumber,
+        });
+        if (!spawnSpec) {
+            res.status(500).json({ error: 'Invalid editor configuration' });
+            return;
+        }
+        const launched = await new Promise((resolvePromise) => {
+            const child = spawn(spawnSpec.command, [...spawnSpec.args], {
+                stdio: 'ignore',
+                detached: true,
+            });
+            child.once('error', (error) => {
+                const code = error.code;
+                if (code && code !== 'ENOENT') {
+                    console.error('Failed to launch editor CLI:', error);
+                }
+                resolvePromise(false);
+            });
+            child.once('spawn', () => {
+                child.unref();
+                resolvePromise(true);
+            });
+        });
+        if (!launched) {
+            res.status(500).json({
+                error: `Failed to launch editor: command "${spawnSpec.command}" is not available on PATH`,
+            });
+            return;
+        }
+        res.json({ success: true });
+    });
+    app.post('/api/grouping', async (req, res) => {
+        const workspace = currentWorkspace;
+        if (!workspace) {
+            res.json({ needsWorkspace: true });
+            return;
+        }
+        const body = (req.body ?? {});
+        if (typeof body.base !== 'string' || typeof body.target !== 'string') {
+            res.status(400).json({ error: 'base and target are required' });
+            return;
+        }
+        const model = typeof body.model === 'string' && body.model ? body.model : 'haiku';
+        const intent = typeof body.intent === 'string' ? body.intent : null;
+        try {
+            // Honor baseMode so grouping parses the SAME diff the client is showing.
+            // Omitting it turns a merge-base view into a direct base..target diff, which
+            // in a repo whose base branch has diverged pulls in hundreds of unrelated files.
+            const selection = createDiffSelection(body.base, body.target, body.baseMode);
+            const diff = await workspace.parser.parseDiff(selection);
+            // diff-easy: grouping results are cached under the repo's turns dir,
+            // alongside the agent-turn log (`.difit-turns/`) — see src/utils/turnLog.ts.
+            const turnsDir = join(workspace.repoPath, '.difit-turns');
+            // Only AI results are cached: they're the expensive ones, and caching a
+            // deterministic `smart`/`module` response under this (mode-less) key would
+            // let a non-AI request poison a later AI read. Deterministic modes run
+            // client-side anyway and are cheap to recompute.
+            const cacheable = body.mode === 'ai' &&
+                body.target !== '.' &&
+                body.target !== 'working' &&
+                body.target !== 'staged';
+            // Cache per diff, not per target: `HEAD^..HEAD` and `main..HEAD` are
+            // different diffs, so the base must be part of the key or they collide.
+            const resolveRef = (ref) => Promise.resolve()
+                .then(() => workspace.parser.resolveCommitish(ref))
+                .catch(() => ref);
+            const [baseHash, targetHash] = await Promise.all([
+                resolveRef(body.base),
+                resolveRef(body.target),
+            ]);
+            const cacheKey = `${baseHash}..${targetHash}${body.baseMode === 'merge-base' ? '-mb' : ''}`;
+            if (cacheable && !body.force) {
+                const cached = readCache(turnsDir, cacheKey, model);
+                if (cached) {
+                    res.json(cached);
+                    return;
+                }
+            }
+            const aiDisabled = process.env.DIFIT_GROUPING_NO_AI === '1';
+            const result = aiDisabled || body.mode !== 'ai'
+                ? groupSmart(diff.files)
+                : await groupWithClaude(diff, intent, { model });
+            if (cacheable)
+                writeCache(turnsDir, cacheKey, model, result);
+            res.json(result);
+        }
+        catch (error) {
+            res.status(500).json({ error: error instanceof Error ? error.message : 'grouping failed' });
+        }
+    });
+    // Function to output comments when server shuts down
+    function outputFinalComments() {
+        const session = getOrCreateCommentSession(currentCommentSelection);
+        if (session.threads.length > 0) {
+            console.log(formatCommentsOutput(session.threads.map(toCommentThread)));
+        }
+    }
+    // diff-easy: list captured agent turns (newest first), grouped by session.
+    app.get('/api/turns', (req, res) => {
+        if (!currentWorkspace) {
+            res.json({ sessions: [], activeSession: null, turns: [], needsWorkspace: true });
+            return;
+        }
+        const all = readTurnLog(currentWorkspace.repoPath);
+        const sessionFilter = typeof req.query.session === 'string' ? req.query.session : undefined;
+        // Order sessions by most-recent activity.
+        const lastActivity = new Map();
+        for (const turn of all) {
+            const ts = turn.endedAt ?? turn.startedAt;
+            lastActivity.set(turn.sessionId, Math.max(lastActivity.get(turn.sessionId) ?? 0, ts));
+        }
+        const sessions = [...lastActivity.entries()].sort((a, b) => b[1] - a[1]).map(([id]) => id);
+        // Fall back to the newest session when the requested filter isn't present in
+        // this repo — e.g. a hub tab still pinned to another repo's session. Filtering
+        // by a session that doesn't exist here would blank the timeline.
+        const activeSession = sessionFilter && sessions.includes(sessionFilter) ? sessionFilter : sessions[0];
+        const turns = all
+            .filter((t) => (activeSession ? t.sessionId === activeSession : true))
+            // Completed turns diff commitBefore→commitAfter; the in-progress (open)
+            // turn is reviewable live as commitBefore→working tree, so a session
+            // that's mid-turn isn't shown as empty. Drop only malformed records.
+            .filter((t) => t.commitAfter || t.status === 'open')
+            .sort((a, b) => (b.endedAt ?? b.startedAt) - (a.endedAt ?? a.startedAt));
+        res.json({ sessions, activeSession: activeSession ?? null, turns });
+    });
+    // diff-easy: best-effort live-refresh ping from the capture hook.
+    app.post('/events/turn-complete', (_req, res) => {
+        fileWatcher.broadcast({ type: 'turn-complete', timestamp: new Date().toISOString() });
+        res.json({ ok: true });
+    });
+    // ---- diff-easy hub: runtime workspace swapping + picker data ----
+    let swapping = false;
+    const workspaceLabel = (repoPath) => {
+        const home = process.env.HOME || '';
+        return home && repoPath.startsWith(`${home}/`) ? `~${repoPath.slice(home.length)}` : repoPath;
+    };
+    const isGitWorkTree = (repoPath) => {
+        try {
+            return (execFileSync('git', ['-C', repoPath, 'rev-parse', '--is-inside-work-tree'], {
+                stdio: ['ignore', 'pipe', 'ignore'],
+            })
+                .toString()
+                .trim() === 'true');
+        }
+        catch {
+            return false;
+        }
+    };
+    // Re-point the single view at a different repo: fresh parser, restart the
+    // watcher, clear per-workspace caches/comments, default to uncommitted, and
+    // tell every open tab to re-sync.
+    const applyRepoWorkspace = async (repoPath) => {
+        const abs = resolve(repoPath);
+        const repoId = createHash('sha256').update(abs).digest('hex');
+        // Hub-opened repos can't show difit's interactive untracked-file prompt, so
+        // enable read-only synthesis (no index mutation) to surface new files.
+        const workspace = {
+            repoPath: abs,
+            repoId,
+            parser: new GitDiffParser(abs, { includeUntracked: true }),
+        };
+        await fileWatcher.stop();
+        diffDataCache.clear();
+        generatedStatusCache.clear();
+        commentSessions.clear();
+        currentSelection = createDiffSelection('HEAD', '.');
+        currentCommentSelection = currentSelection;
+        currentWorkspace = workspace;
+        try {
+            await fileWatcher.start(DiffMode.DOT, abs, 300, invalidateCache);
+        }
+        catch {
+            // watcher is best-effort
+        }
+        fileWatcher.broadcast({ type: 'workspace-changed', timestamp: new Date().toISOString() });
+        return workspace;
+    };
+    // Re-point the view at a GitHub PR: a static-patch workspace from `gh pr diff`,
+    // with the PR's review comments imported. No watcher (nothing local to watch).
+    const applyPrWorkspace = async (url) => {
+        const patch = getPrPatch(url); // throws (surfaces gh auth errors)
+        let commentImports = [];
+        try {
+            commentImports = await getPrCommentImports(url);
+        }
+        catch (error) {
+            // best-effort — the patch is the core; comments are a bonus. Log it so a
+            // silent failure isn't mistaken for "this PR has no review comments".
+            console.warn(`difit: could not import review comments for ${url}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        let prDetails = null;
+        try {
+            prDetails = await getPrDetails(url);
+        }
+        catch (error) {
+            // best-effort — title/body only enrich grouping intent; the diff still works without them.
+            console.warn(`difit: could not load PR title/body for ${url}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const workspace = {
+            repoPath: process.cwd(), // placeholder; static workspaces never touch it
+            repoId: createHash('sha256').update(`pr:${url}`).digest('hex'),
+            parser: new GitDiffParser(process.cwd()),
+            patch,
+            commentImports: commentImports.length > 0 ? commentImports : undefined,
+            commentImportId: commentImports.length > 0
+                ? createHash('sha256').update(serializeCommentImports(commentImports)).digest('hex')
+                : undefined,
+            prTitle: prDetails?.title || undefined,
+            prBody: prDetails?.body || undefined,
+        };
+        await fileWatcher.stop();
+        diffDataCache.clear();
+        generatedStatusCache.clear();
+        commentSessions.clear();
+        currentSelection = createDiffSelection('', '');
+        currentCommentSelection = currentSelection;
+        currentWorkspace = workspace;
+        fileWatcher.broadcast({ type: 'workspace-changed', timestamp: new Date().toISOString() });
+        return workspace;
+    };
+    app.post('/api/workspace', async (req, res) => {
+        const body = (req.body ?? {});
+        if (swapping) {
+            res.status(409).json({ error: 'A workspace switch is already in progress' });
+            return;
+        }
+        swapping = true;
+        try {
+            if (body.type === 'repo') {
+                if (typeof body.path !== 'string' || !body.path) {
+                    res.status(400).json({ error: 'Missing folder path' });
+                    return;
+                }
+                const abs = resolve(body.path);
+                if (!isGitWorkTree(abs)) {
+                    res.status(400).json({ error: `Not a git repository: ${abs}` });
+                    return;
+                }
+                const ws = await applyRepoWorkspace(abs);
+                const config = readHubConfig();
+                const folder = { repoId: ws.repoId, path: abs, name: basename(abs) };
+                pushRecentFolder(config, folder);
+                // Opening a repo clears its activity badge: mark its newest turn as seen.
+                const seen = latestTurnTimestamp(readTurnLog(abs));
+                if (seen > 0)
+                    config.lastSeen[ws.repoId] = seen;
+                writeHubConfig(config);
+                res.json({ active: { kind: 'repo', repoId: ws.repoId, label: workspaceLabel(abs) } });
+            }
+            else if (body.type === 'pr') {
+                if (typeof body.url !== 'string' || !body.url) {
+                    res.status(400).json({ error: 'Missing PR URL' });
+                    return;
+                }
+                const ws = await applyPrWorkspace(body.url);
+                const label = body.url.replace(/^https?:\/\/github\.com\//, '');
+                const config = readHubConfig();
+                config.recentPrs = [
+                    { url: body.url, label, repoId: ws.repoId },
+                    ...config.recentPrs.filter((p) => p.url !== body.url),
+                ].slice(0, 20);
+                writeHubConfig(config);
+                res.json({ active: { kind: 'pr', repoId: ws.repoId, label } });
+            }
+            else {
+                res.status(400).json({ error: 'Unknown workspace type' });
+            }
+        }
+        catch (error) {
+            res
+                .status(400)
+                .json({ error: error instanceof Error ? error.message : 'Failed to switch workspace' });
+        }
+        finally {
+            swapping = false;
+        }
+    });
+    // Picker data: configured roots scanned for repos, recents, and the active source.
+    app.get('/api/workspaces', (_req, res) => {
+        const config = readHubConfig();
+        const roots = config.roots.map((root) => {
+            let repos = [];
+            try {
+                repos = readdirSync(root, { withFileTypes: true })
+                    .filter((e) => e.isDirectory())
+                    .map((e) => join(root, e.name))
+                    .filter((p) => existsSync(join(p, '.git')))
+                    .map((p) => ({
+                    repoId: createHash('sha256').update(p).digest('hex'),
+                    path: p,
+                    name: basename(p),
+                }));
+            }
+            catch {
+                repos = [];
+            }
+            return { root, repos };
+        });
+        // Per-repo "new turns since you last opened it" counts for the picker badges.
+        // Map repoId → path across every known repo (scanned roots + recents), then
+        // count completed turns newer than the repo's lastSeen marker.
+        const repoPaths = new Map();
+        for (const { repos } of roots) {
+            for (const repo of repos)
+                repoPaths.set(repo.repoId, repo.path);
+        }
+        for (const recent of config.recents)
+            repoPaths.set(recent.repoId, recent.path);
+        const activity = {};
+        for (const [repoId, path] of repoPaths) {
+            const count = countTurnsSince(readTurnLog(path), config.lastSeen[repoId] ?? 0);
+            if (count > 0)
+                activity[repoId] = count;
+        }
+        res.json({
+            active: currentWorkspace
+                ? {
+                    kind: 'repo',
+                    repoId: currentWorkspace.repoId,
+                    label: workspaceLabel(currentWorkspace.repoPath),
+                }
+                : null,
+            roots,
+            recents: config.recents,
+            recentPrs: config.recentPrs,
+            activity,
+        });
+    });
+    // SSE endpoint for file watching
+    app.get('/api/watch', (req, res) => {
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            Connection: 'keep-alive',
+            'Access-Control-Allow-Origin': '*',
+        });
+        fileWatcher.addClient(res);
+        req.on('close', () => {
+            fileWatcher.removeClient(res);
+        });
+    });
+    // SSE endpoint to detect when tab is closed
+    app.get('/api/heartbeat', (req, res) => {
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            Connection: 'keep-alive',
+            'Access-Control-Allow-Origin': '*',
+        });
+        // Send initial heartbeat
+        res.write('data: connected\n\n');
+        // Send heartbeat every 5 seconds
+        const heartbeatInterval = setInterval(() => {
+            res.write('data: heartbeat\n\n');
+        }, 5000);
+        // When client disconnects (tab closed, navigation, etc.)
+        req.on('close', () => {
+            clearInterval(heartbeatInterval);
+            if (options.keepAlive) {
+                console.log('Client disconnected, but server is staying alive (--keep-alive)');
+                console.log('Press Ctrl+C to stop the server');
+            }
+            else {
+                // Add a small delay to ensure any pending sendBeacon requests are processed
+                setTimeout(async () => {
+                    console.log('Client disconnected, shutting down server...');
+                    // Stop file watcher
+                    await fileWatcher.stop();
+                    // Drop the advertised server/hub info so the capture hook never pings
+                    // a recycled port after we're gone.
+                    if (options.hub)
+                        deleteHubInfo();
+                    else if (currentWorkspace)
+                        deleteServerInfo(currentWorkspace.repoPath);
+                    if (!options.hub)
+                        outputFinalComments();
+                    process.exit(0);
+                }, 100);
+            }
+        });
+    });
+    // Always runs in production mode when distributed as a CLI tool
+    const isProduction = process.env.NODE_ENV === 'production' || process.env.NODE_ENV !== 'development';
+    if (isProduction) {
+        // Find client files relative to the CLI executable location
+        const distPath = join(__dirname, '..', 'client');
+        app.use(express.static(distPath));
+    }
+    else {
+        app.get('/', (_req, res) => {
+            res.send(`
+        <!DOCTYPE html>
+        <html>
+          <head>
+            <title>difit - Dev Mode</title>
+          </head>
+          <body>
+            <div id="root"></div>
+            <script>
+              console.log('difit development mode');
+              console.log('Diff data available at /api/diff');
+            </script>
+          </body>
+        </html>
+      `);
+        });
+    }
+    const { port, url, server } = await startServerWithFallback(app, options.preferredPort || 4966, options.host || 'localhost');
+    // diff-easy: advertise this server's port so the capture hook can ping it for
+    // live refresh. Hub mode advertises globally (hub.json); a fixed server
+    // advertises per-repo (server.json). Best-effort; capture works regardless.
+    try {
+        const info = { port, pid: process.pid, startedAt: Date.now() };
+        if (options.hub)
+            writeHubInfo(info);
+        else if (currentWorkspace)
+            writeServerInfo(currentWorkspace.repoPath, info);
+    }
+    catch {
+        // ignore — live refresh is optional
+    }
+    // A keep-alive server never auto-shuts-down on tab close, so a Ctrl+C / kill
+    // is its normal exit. Clean up its advertised port on the way out so a later
+    // process reusing that port doesn't receive stray turn-complete pings.
+    // (Non-keep-alive servers clean up in the heartbeat-close path above; only
+    // keep-alive registers signal handlers, to avoid accumulating listeners when
+    // many servers are started in one process, e.g. tests.)
+    if (options.keepAlive) {
+        const shutdown = () => {
+            if (options.hub)
+                deleteHubInfo();
+            else if (currentWorkspace)
+                deleteServerInfo(currentWorkspace.repoPath);
+            void fileWatcher.stop().finally(() => process.exit(0));
+        };
+        process.once('SIGINT', shutdown);
+        process.once('SIGTERM', shutdown);
+    }
+    // Security warning for non-localhost binding
+    if (options.host && options.host !== '127.0.0.1' && options.host !== 'localhost') {
+        console.warn('\n⚠️  WARNING: Server is accessible from external network!');
+        console.warn(`   Binding to: ${options.host}:${port}`);
+        console.warn('   Make sure this is intended and your network is secure.\n');
+    }
+    // Start file watcher (only when a repo workspace is active)
+    if (options.diffMode && currentWorkspace) {
+        try {
+            await fileWatcher.start(options.diffMode, currentWorkspace.repoPath, 300, invalidateCache);
+        }
+        catch (error) {
+            console.warn('⚠️  File watcher failed to start:', error);
+            console.warn('   Continuing without file watching...');
+        }
+    }
+    // Open the browser. In hub mode there's no diff yet (the picker loads), so
+    // open regardless; otherwise skip when the diff is empty.
+    const shouldOpen = options.openBrowser && (options.hub || (initialDiffData != null && !initialDiffData.isEmpty));
+    if (shouldOpen) {
+        try {
+            await open(url);
+        }
+        catch {
+            console.warn('Failed to open browser automatically');
+        }
+    }
+    return { port, url, isEmpty: initialDiffData?.isEmpty ?? true, server };
+}
+async function startServerWithFallback(app, preferredPort, host) {
+    return new Promise((resolve, reject) => {
+        // express's listen() method uses listen() method in node:net Server instance internally
+        // https://expressjs.com/en/5x/api.html#app.listen
+        // so, an error will be an instance of NodeJS.ErrnoException
+        const server = app.listen(preferredPort, host, (err) => {
+            const displayHost = host === '0.0.0.0' ? 'localhost' : host;
+            const url = `http://${displayHost}:${preferredPort}`;
+            if (!err) {
+                resolve({ port: preferredPort, url, server });
+                return;
+            }
+            // Handling errors when failed to launch a server
+            switch (err.code) {
+                // Try another port until it succeeds
+                case 'EADDRINUSE': {
+                    console.log(`Port ${preferredPort} is busy, trying ${preferredPort + 1}...`);
+                    return startServerWithFallback(app, preferredPort + 1, host)
+                        .then(({ port, url, server }) => {
+                        resolve({ port, url, server });
+                    })
+                        .catch(reject);
+                }
+                // Unexpected error
+                default: {
+                    reject(new Error(`Failed to launch a server: ${err.message}`));
+                }
+            }
+        });
+    });
+}