difit 4.0.5 → 4.0.7

package/dist/server/file-watcher.d.ts

@@ -1,5 +1,5 @@
 import { type Response } from 'express';
-import { DiffMode } from '../types/watch.js';
+import { DiffMode, type WatchEvent } from '../types/watch.js';
 export declare class FileWatcherService {
     private subscriptions;
     private clients;
@@ -21,6 +21,7 @@ export declare class FileWatcherService {
     stop(): Promise<void>;
     addClient(res: Response): void;
     removeClient(res: Response): void;
+    broadcast(event: WatchEvent): void;
     private broadcastChange;
     private sendToClient;
     private determineChangeType;

package/dist/server/file-watcher.js

@@ -198,6 +198,14 @@ export class FileWatcherService {
             this.clients.splice(index, 1);
         }
     }
+    broadcast(event) {
+        if (this.clients.length === 0) {
+            return;
+        }
+        this.clients.forEach((client) => {
+            this.sendToClient(client, event);
+        });
+    }
     broadcastChange() {
         if (this.clients.length === 0 || !this.config) {
             return;
@@ -210,9 +218,7 @@ export class FileWatcherService {
             timestamp: new Date().toISOString(),
             message: `Changes detected in ${this.config.diffMode} mode`,
         };
-        this.clients.forEach((client) => {
-            this.sendToClient(client, event);
-        });
+        this.broadcast(event);
     }
     sendToClient(client, event) {
         try {

package/dist/server/git-diff.d.ts

@@ -5,11 +5,16 @@ export declare class GitDiffParser {
     private readonly resolvedCommitCache;
     private static readonly RESOLVED_COMMIT_CACHE_TTL_MS;
     private static readonly GENERATED_HEADER_SCAN_BYTES;
+    private static readonly GITATTRIBUTES_CHECK_CHUNK_SIZE;
     constructor(repoPath?: string);
     private normalizeRepositoryRelativePath;
     private resolveBaseCommitish;
     parseDiff(selection: DiffSelection, ignoreWhitespace?: boolean, contextLines?: number): Promise<DiffResponse>;
     private parseUnifiedDiff;
+    private getGitattributesSourceArgs;
+    private parseGitattributesGeneratedOutput;
+    private getGitattributesGeneratedPaths;
+    private markGitattributesGeneratedFiles;
     private decodeGitPath;
     private extractPathFromLine;
     private parseDiffHeaderPaths;

package/dist/server/git-diff.js

@@ -9,6 +9,7 @@ export class GitDiffParser {
     resolvedCommitCache = new Map();
     static RESOLVED_COMMIT_CACHE_TTL_MS = 5_000;
     static GENERATED_HEADER_SCAN_BYTES = 4 * 1024;
+    static GITATTRIBUTES_CHECK_CHUNK_SIZE = 200;
     constructor(repoPath = process.cwd()) {
         this.repoPath = repoPath;
         this.git = simpleGit(repoPath);
@@ -51,6 +52,7 @@ export class GitDiffParser {
             let diffArgs;
             let resolvedBaseCommitish = effectiveBaseCommitish;
             let resolvedTargetCommitish = targetCommitish;
+            let attributesRef = targetCommitish;
             // Handle target special chars (base is always a regular commit)
             if (targetCommitish === 'working') {
                 // Show unstaged changes (working vs staged)
@@ -78,6 +80,7 @@ export class GitDiffParser {
                 resolvedCommit = createCommitRangeString(shortHash(baseHash), shortHash(targetHash));
                 resolvedBaseCommitish = shortHash(baseHash);
                 resolvedTargetCommitish = shortHash(targetHash);
+                attributesRef = targetHash;
                 diffArgs = [baseHash, targetHash];
             }
             if (ignoreWhitespace) {
@@ -91,7 +94,7 @@ export class GitDiffParser {
             diffArgs.push('--no-ext-diff', '--color=never');
             // Single git invocation for better startup latency on large repositories.
             const diffRaw = await this.git.diff(diffArgs);
-            const files = this.parseUnifiedDiff(diffRaw);
+            const files = await this.markGitattributesGeneratedFiles(this.parseUnifiedDiff(diffRaw), attributesRef);
             return {
                 commit: resolvedCommit,
                 files,
@@ -119,6 +122,63 @@ export class GitDiffParser {
         }
         return files;
     }
+    getGitattributesSourceArgs(ref) {
+        if (ref === 'working' || ref === '.') {
+            return [];
+        }
+        if (ref === 'staged') {
+            return ['--cached'];
+        }
+        return ['--source', ref];
+    }
+    parseGitattributesGeneratedOutput(output) {
+        const generatedPaths = new Set();
+        const fields = output.split('\0');
+        for (let i = 0; i + 2 < fields.length; i += 3) {
+            const [path, attribute, value] = fields.slice(i, i + 3);
+            if (attribute === 'linguist-generated' && value === 'true') {
+                generatedPaths.add(path);
+            }
+        }
+        return generatedPaths;
+    }
+    async getGitattributesGeneratedPaths(filepaths, ref) {
+        if (filepaths.length === 0) {
+            return new Set();
+        }
+        const generatedPaths = new Set();
+        try {
+            for (let i = 0; i < filepaths.length; i += GitDiffParser.GITATTRIBUTES_CHECK_CHUNK_SIZE) {
+                const chunk = filepaths.slice(i, i + GitDiffParser.GITATTRIBUTES_CHECK_CHUNK_SIZE);
+                const output = await this.git.raw([
+                    'check-attr',
+                    '-z',
+                    ...this.getGitattributesSourceArgs(ref),
+                    'linguist-generated',
+                    '--',
+                    ...chunk,
+                ]);
+                if (typeof output !== 'string') {
+                    continue;
+                }
+                for (const path of this.parseGitattributesGeneratedOutput(output)) {
+                    generatedPaths.add(path);
+                }
+            }
+            return generatedPaths;
+        }
+        catch {
+            return new Set();
+        }
+    }
+    async markGitattributesGeneratedFiles(files, ref) {
+        const candidates = files.filter((file) => !file.isGenerated).map((file) => file.path);
+        const generatedPaths = await this.getGitattributesGeneratedPaths(candidates, ref);
+        if (generatedPaths.size === 0) {
+            return files;
+        }
+        return files.map((file) => generatedPaths.has(file.path) ? { ...file, isGenerated: true } : file);
+    }
     decodeGitPath(rawPath) {
         if (typeof rawPath !== 'string') {
             return undefined;
@@ -454,6 +514,10 @@ export class GitDiffParser {
         if (pathResult.isGenerated) {
             return { isGenerated: true, source: 'path' };
         }
+        const gitattributesResult = await this.getGitattributesGeneratedPaths([filepath], ref);
+        if (gitattributesResult.has(filepath)) {
+            return { isGenerated: true, source: 'path' };
+        }
         try {
             const buffer = await this.getBlobContent(filepath, ref);
             const lines = this.extractHeaderLines(buffer);

package/dist/server/git-diff.test.js

@@ -985,6 +985,23 @@ index abc123..def456 100644
             expect(generatedStatus).toEqual({ isGenerated: true, source: 'path' });
             expect(getBlobContentSpy).not.toHaveBeenCalled();
         });
+        it('returns source=path for .gitattributes linguist-generated files without reading content', async () => {
+            const gitRaw = parser.git.raw;
+            gitRaw.mockResolvedValue('apps/app/web/src/api/index.tsx\0linguist-generated\0true\0');
+            const getBlobContentSpy = vi.spyOn(parser, 'getBlobContent');
+            const generatedStatus = await parser.getGeneratedStatus('apps/app/web/src/api/index.tsx', 'HEAD');
+            expect(gitRaw).toHaveBeenCalledWith([
+                'check-attr',
+                '-z',
+                '--source',
+                'HEAD',
+                'linguist-generated',
+                '--',
+                'apps/app/web/src/api/index.tsx',
+            ]);
+            expect(generatedStatus).toEqual({ isGenerated: true, source: 'path' });
+            expect(getBlobContentSpy).not.toHaveBeenCalled();
+        });
         it('returns false when content cannot be read for content-based generated detection', async () => {
             const getBlobContentSpy = vi.spyOn(parser, 'getBlobContent');
             getBlobContentSpy.mockRejectedValue(new Error('missing blob'));
@@ -1075,6 +1092,39 @@ index abc123..def456 100644
         });
     });
     describe('parseDiff', () => {
+        it('marks files with .gitattributes linguist-generated=true as generated', async () => {
+            const file = 'apps/app/web/src/api/index.tsx';
+            const gitDiff = parser.git.diff;
+            const gitRevparse = parser.git.revparse;
+            const gitRaw = parser.git.raw;
+            gitRevparse
+                .mockResolvedValueOnce('1234567890abcdef1234567890abcdef12345678')
+                .mockResolvedValueOnce('abcdef1234567890abcdef1234567890abcdef12');
+            gitDiff.mockResolvedValue([
+                `diff --git a/${file} b/${file}`,
+                `index abc123..def456 100644`,
+                `--- a/${file}`,
+                `+++ b/${file}`,
+                `@@ -1 +1 @@`,
+                `-old`,
+                `+new`,
+            ].join('\n'));
+            gitRaw.mockResolvedValue(`${file}\0linguist-generated\0true\0`);
+            const response = await parser.parseDiff({
+                targetCommitish: 'HEAD',
+                baseCommitish: 'HEAD~1',
+            });
+            expect(gitRaw).toHaveBeenCalledWith([
+                'check-attr',
+                '-z',
+                '--source',
+                '1234567890abcdef1234567890abcdef12345678',
+                'linguist-generated',
+                '--',
+                file,
+            ]);
+            expect(response.files[0].isGenerated).toBe(true);
+        });
         it('passes context lines through to git diff', async () => {
             const gitDiff = parser.git.diff;
             const gitRevparse = parser.git.revparse;

package/dist/server/server.js

@@ -7,9 +7,9 @@ import open from 'open';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 import { formatCommentsOutput } from '../utils/commentFormatting.js';
-import { serializeCommentImports } from '../utils/commentImports.js';
+import { mergeCommentImports, normalizeCommentImports, serializeCommentImports, } from '../utils/commentImports.js';
 import { normalizeDiffViewMode } from '../utils/diffMode.js';
-import { resolveEditorOption } from '../utils/editorOptions.js';
+import { buildEditorSpawnSpec, CUSTOM_EDITOR_ID, NONE_EDITOR_ID, resolveEditorOption, } from '../utils/editorOptions.js';
 import { getFileExtension } from '../utils/fileUtils.js';
 import { FileWatcherService } from './file-watcher.js';
 import { GitDiffParser } from './git-diff.js';
@@ -42,6 +42,15 @@ function setCachedDiffResponse(cache, key, value) {
         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);
+}
 export async function startServer(options) {
     const app = express();
     const repositoryPath = resolve(options.repoPath ?? process.cwd());
@@ -96,6 +105,7 @@ export async function startServer(options) {
     };
     // Track current revisions for cache invalidation
     let currentSelection = initialSelection;
+    let currentCommentSelection = createResolvedCommentSelection(initialDiffData, initialSelection, Boolean(options.stdinDiff));
     function parseRepositoryRelativePath(filepath) {
         if (typeof filepath !== 'string' || filepath.length === 0) {
             return { ok: false, error: 'Invalid file path' };
@@ -111,6 +121,51 @@ export async function startServer(options) {
         }
         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 ignoreWhitespace = req.query.ignoreWhitespace === 'true';
         const hasBase = typeof req.query.base === 'string';
@@ -137,6 +192,7 @@ export async function startServer(options) {
                 generatedStatusCache.clear();
             }
         }
+        currentCommentSelection = createResolvedCommentSelection(responseDiffData, requestedSelection, Boolean(options.stdinDiff));
         const baseCommitish = responseDiffData.baseCommitish ?? (options.stdinDiff ? 'stdin' : undefined);
         const targetCommitish = responseDiffData.targetCommitish ?? (options.stdinDiff ? 'stdin' : undefined);
         const requestedBaseCommitish = responseDiffData.requestedBaseCommitish ??
@@ -314,31 +370,58 @@ export async function startServer(options) {
             res.status(404).json({ error: 'File not found' });
         }
     });
-    let finalThreads = [];
+    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: comment.id,
-            file: comment.file,
-            line: comment.line,
-            side: comment.side,
-            createdAt: comment.timestamp,
-            updatedAt: comment.timestamp,
-            codeContent: comment.codeContent,
+            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: comment.id,
+                    id: threadId,
                     body: comment.body,
                     author: comment.author,
-                    createdAt: comment.timestamp,
-                    updatedAt: comment.timestamp,
+                    createdAt: timestamp,
+                    updatedAt: timestamp,
                 },
             ],
         };
     }
-    function normalizeThreadPayload(thread) {
-        if ('file' in thread && 'line' in thread) {
-            return thread;
-        }
+    function toCommentThread(thread) {
         return {
             id: thread.id,
             file: thread.filePath,
@@ -352,6 +435,51 @@ export async function startServer(options) {
             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)
@@ -364,9 +492,33 @@ export async function startServer(options) {
         }
         return [];
     }
+    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 {
-            finalThreads = parseCommentsPayload(req.body);
+            const selection = getCommentSelectionFromQuery(req.query);
+            const nextThreads = parseCommentsPayload(req.body);
+            updateCommentSession(selection, nextThreads);
             res.json({ success: true });
         }
         catch (error) {
@@ -374,10 +526,43 @@ export async function startServer(options) {
             res.status(400).json({ error: 'Invalid comment data' });
         }
     });
-    app.get('/api/comments-output', (_req, res) => {
+    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 (finalThreads.length > 0) {
-            const output = formatCommentsOutput(finalThreads);
+        if (session.threads.length > 0) {
+            const output = formatCommentsOutput(session.threads.map(toCommentThread));
             res.send(output);
         }
         else {
@@ -400,67 +585,79 @@ export async function startServer(options) {
             return;
         }
         const resolvedPath = resolve(repositoryPath, filepathResult.path);
-        const editorInput = typeof editor === 'string' ? editor : (process.env.DIFIT_EDITOR ?? process.env.EDITOR);
-        const resolvedEditor = resolveEditorOption(editorInput);
-        if (resolvedEditor.protocol === null) {
+        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 tryOpenWithCli = async () => {
-            if (!resolvedEditor.cliCommand)
-                return false;
-            const args = [...resolvedEditor.cliArgs];
-            if (lineNumber !== null) {
-                const fileWithLine = `${resolvedPath}:${lineNumber}`;
-                if (resolvedEditor.lineFormat === 'goto-flag') {
-                    args.push('-g', fileWithLine);
-                }
-                else {
-                    args.push(fileWithLine);
+        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);
                 }
-            }
-            else {
-                args.push(resolvedPath);
-            }
-            args.push(repositoryPath);
-            return await new Promise((resolvePromise) => {
-                const child = spawn(resolvedEditor.cliCommand, 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);
-                });
+                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`,
             });
-        };
-        if (await tryOpenWithCli()) {
-            res.json({ success: true });
             return;
         }
-        const lineSuffix = lineNumber !== null ? `:${lineNumber}` : '';
-        const fileUri = `${resolvedEditor.protocol}://file${encodeURI(resolvedPath)}${lineSuffix}`;
-        try {
-            await open(fileUri);
-            res.json({ success: true });
-        }
-        catch (error) {
-            console.error('Failed to open file in editor:', error);
-            res.status(500).json({ error: 'Failed to open file in editor' });
-        }
+        res.json({ success: true });
     });
     // Function to output comments when server shuts down
     function outputFinalComments() {
-        if (finalThreads.length > 0) {
-            console.log(formatCommentsOutput(finalThreads));
+        const session = getOrCreateCommentSession(currentCommentSelection);
+        if (session.threads.length > 0) {
+            console.log(formatCommentsOutput(session.threads.map(toCommentThread)));
         }
     }
     // SSE endpoint for file watching