snow-ai 0.2.19 → 0.2.21

package/dist/utils/vscodeConnection.d.ts

@@ -16,34 +16,48 @@ interface Diagnostic {
     code?: string | number;
 }
 declare class VSCodeConnectionManager {
-    private server;
     private client;
+    private reconnectTimer;
+    private reconnectAttempts;
+    private readonly MAX_RECONNECT_ATTEMPTS;
+    private readonly BASE_RECONNECT_DELAY;
+    private readonly MAX_RECONNECT_DELAY;
+    private readonly VSCODE_BASE_PORT;
+    private readonly VSCODE_MAX_PORT;
+    private readonly JETBRAINS_BASE_PORT;
+    private readonly JETBRAINS_MAX_PORT;
     private port;
     private editorContext;
     private listeners;
+    private currentWorkingDirectory;
     start(): Promise<void>;
+    /**
+     * Find the correct port for the current workspace
+     */
+    private findPortForWorkspace;
+    /**
+     * Check if we should handle this message based on workspace folder
+     */
+    private shouldHandleMessage;
+    private scheduleReconnect;
     stop(): void;
     isConnected(): boolean;
-    isServerRunning(): boolean;
+    isClientRunning(): boolean;
     getContext(): EditorContext;
     onContextUpdate(listener: (context: EditorContext) => void): () => void;
     private handleMessage;
     private notifyListeners;
     getPort(): number;
     /**
-     * Request diagnostics for a specific file from VS Code
+     * Request diagnostics for a specific file from IDE
      * @param filePath - The file path to get diagnostics for
      * @returns Promise that resolves with diagnostics array
      */
     requestDiagnostics(filePath: string): Promise<Diagnostic[]>;
     /**
-     * Request DIFF+APPLY view for file changes in VS Code
-     * @param filePath - The file path for the diff
-     * @param oldContent - Original content with line numbers
-     * @param newContent - Modified content with line numbers
-     * @returns Promise that resolves with user's approval response
+     * Reset reconnection attempts (e.g., when user manually triggers reconnect)
      */
-    requestDiffApply(filePath: string, oldContent: string, newContent: string): Promise<'approve' | 'approve_always' | 'reject'>;
+    resetReconnectAttempts(): void;
 }
 export declare const vscodeConnection: VSCodeConnectionManager;
 export type { EditorContext, Diagnostic };

package/dist/utils/vscodeConnection.js

@@ -1,18 +1,70 @@
-import { WebSocketServer, WebSocket } from 'ws';
+import { WebSocket } from 'ws';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
 class VSCodeConnectionManager {
     constructor() {
-        Object.defineProperty(this, "server", {
+        Object.defineProperty(this, "client", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: null
         });
-        Object.defineProperty(this, "client", {
+        Object.defineProperty(this, "reconnectTimer", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: null
         });
+        Object.defineProperty(this, "reconnectAttempts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "MAX_RECONNECT_ATTEMPTS", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 10
+        });
+        Object.defineProperty(this, "BASE_RECONNECT_DELAY", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 2000
+        }); // 2 seconds
+        Object.defineProperty(this, "MAX_RECONNECT_DELAY", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 30000
+        }); // 30 seconds
+        // Port ranges: VSCode uses 9527-9537, JetBrains uses 9538-9548
+        Object.defineProperty(this, "VSCODE_BASE_PORT", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 9527
+        });
+        Object.defineProperty(this, "VSCODE_MAX_PORT", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 9537
+        });
+        Object.defineProperty(this, "JETBRAINS_BASE_PORT", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 9538
+        });
+        Object.defineProperty(this, "JETBRAINS_MAX_PORT", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 9548
+        });
         Object.defineProperty(this, "port", {
             enumerable: true,
             configurable: true,
@@ -31,66 +83,147 @@ class VSCodeConnectionManager {
             writable: true,
             value: []
         });
+        Object.defineProperty(this, "currentWorkingDirectory", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: process.cwd()
+        });
     }
     async start() {
-        // If already running, just return success
-        if (this.server) {
+        // If already connected, just return success
+        if (this.client?.readyState === WebSocket.OPEN) {
             return Promise.resolve();
         }
+        // Try to find the correct port for this workspace
+        const targetPort = this.findPortForWorkspace();
         return new Promise((resolve, reject) => {
-            try {
-                this.server = new WebSocketServer({ port: this.port });
-                this.server.on('connection', (ws) => {
-                    // Close old client if exists
-                    if (this.client && this.client !== ws) {
-                        this.client.close();
-                    }
-                    this.client = ws;
-                    ws.on('message', (message) => {
+            const tryConnect = (port) => {
+                // Check both VSCode and JetBrains port ranges
+                if (port > this.VSCODE_MAX_PORT && port < this.JETBRAINS_BASE_PORT) {
+                    // Jump from VSCode range to JetBrains range
+                    tryConnect(this.JETBRAINS_BASE_PORT);
+                    return;
+                }
+                if (port > this.JETBRAINS_MAX_PORT) {
+                    reject(new Error(`Failed to connect: no IDE server found on ports ${this.VSCODE_BASE_PORT}-${this.VSCODE_MAX_PORT} or ${this.JETBRAINS_BASE_PORT}-${this.JETBRAINS_MAX_PORT}`));
+                    return;
+                }
+                try {
+                    this.client = new WebSocket(`ws://localhost:${port}`);
+                    this.client.on('open', () => {
+                        // Reset reconnect attempts on successful connection
+                        this.reconnectAttempts = 0;
+                        this.port = port;
+                        resolve();
+                    });
+                    this.client.on('message', message => {
                         try {
                             const data = JSON.parse(message.toString());
-                            this.handleMessage(data);
+                            // Filter messages by workspace folder
+                            if (this.shouldHandleMessage(data)) {
+                                this.handleMessage(data);
+                            }
                         }
                         catch (error) {
                             // Ignore invalid JSON
                         }
                     });
-                    ws.on('close', () => {
-                        if (this.client === ws) {
+                    this.client.on('close', () => {
+                        this.client = null;
+                        this.scheduleReconnect();
+                    });
+                    this.client.on('error', _error => {
+                        // On initial connection, try next port
+                        if (this.reconnectAttempts === 0) {
                             this.client = null;
+                            tryConnect(port + 1);
                         }
+                        // For reconnections, silently handle and let close event trigger reconnect
                     });
-                    ws.on('error', () => {
-                        // Silently handle errors
-                    });
-                });
-                this.server.on('listening', () => {
-                    resolve();
-                });
-                this.server.on('error', (error) => {
-                    reject(error);
-                });
-            }
-            catch (error) {
-                reject(error);
-            }
+                }
+                catch (error) {
+                    tryConnect(port + 1);
+                }
+            };
+            tryConnect(targetPort);
         });
     }
+    /**
+     * Find the correct port for the current workspace
+     */
+    findPortForWorkspace() {
+        try {
+            const portInfoPath = path.join(os.tmpdir(), 'snow-cli-ports.json');
+            if (fs.existsSync(portInfoPath)) {
+                const portInfo = JSON.parse(fs.readFileSync(portInfoPath, 'utf8'));
+                // Try to match current working directory
+                const cwd = this.currentWorkingDirectory;
+                // Direct match
+                if (portInfo[cwd]) {
+                    return portInfo[cwd];
+                }
+                // Check if cwd is within any of the workspace folders
+                for (const [workspace, port] of Object.entries(portInfo)) {
+                    if (cwd.startsWith(workspace)) {
+                        return port;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Ignore errors, will fall back to VSCODE_BASE_PORT
+        }
+        // Start with VSCode port range by default
+        return this.VSCODE_BASE_PORT;
+    }
+    /**
+     * Check if we should handle this message based on workspace folder
+     */
+    shouldHandleMessage(data) {
+        // If no workspace folder in message, accept it (backwards compatibility)
+        if (!data.workspaceFolder) {
+            return true;
+        }
+        // Check if message's workspace folder matches our current working directory
+        const cwd = this.currentWorkingDirectory;
+        // Bidirectional check: either cwd is within IDE workspace, or IDE workspace is within cwd
+        const cwdInWorkspace = cwd.startsWith(data.workspaceFolder);
+        const workspaceInCwd = data.workspaceFolder.startsWith(cwd);
+        const matches = cwdInWorkspace || workspaceInCwd;
+        return matches;
+    }
+    scheduleReconnect() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+        }
+        this.reconnectAttempts++;
+        if (this.reconnectAttempts >= this.MAX_RECONNECT_ATTEMPTS) {
+            return;
+        }
+        const delay = Math.min(this.BASE_RECONNECT_DELAY * Math.pow(1.5, this.reconnectAttempts - 1), this.MAX_RECONNECT_DELAY);
+        this.reconnectTimer = setTimeout(() => {
+            this.start().catch(() => {
+                // Silently handle reconnection failures
+            });
+        }, delay);
+    }
     stop() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
         if (this.client) {
             this.client.close();
             this.client = null;
         }
-        if (this.server) {
-            this.server.close();
-            this.server = null;
-        }
+        this.reconnectAttempts = 0;
     }
     isConnected() {
-        return this.client !== null && this.client.readyState === WebSocket.OPEN;
+        return this.client?.readyState === WebSocket.OPEN;
     }
-    isServerRunning() {
-        return this.server !== null;
+    isClientRunning() {
+        return this.client !== null;
     }
     getContext() {
         return { ...this.editorContext };
@@ -98,7 +231,7 @@ class VSCodeConnectionManager {
     onContextUpdate(listener) {
         this.listeners.push(listener);
         return () => {
-            this.listeners = this.listeners.filter((l) => l !== listener);
+            this.listeners = this.listeners.filter(l => l !== listener);
         };
     }
     handleMessage(data) {
@@ -107,7 +240,7 @@ class VSCodeConnectionManager {
                 activeFile: data.activeFile,
                 selectedText: data.selectedText,
                 cursorPosition: data.cursorPosition,
-                workspaceFolder: data.workspaceFolder
+                workspaceFolder: data.workspaceFolder,
             };
             this.notifyListeners();
         }
@@ -121,12 +254,12 @@ class VSCodeConnectionManager {
         return this.port;
     }
     /**
-     * Request diagnostics for a specific file from VS Code
+     * Request diagnostics for a specific file from IDE
      * @param filePath - The file path to get diagnostics for
      * @returns Promise that resolves with diagnostics array
      */
     async requestDiagnostics(filePath) {
-        return new Promise((resolve) => {
+        return new Promise(resolve => {
             if (!this.client || this.client.readyState !== WebSocket.OPEN) {
                 resolve([]); // Return empty array if not connected
                 return;
@@ -156,53 +289,15 @@ class VSCodeConnectionManager {
             this.client.send(JSON.stringify({
                 type: 'getDiagnostics',
                 requestId,
-                filePath
+                filePath,
             }));
         });
     }
     /**
-     * Request DIFF+APPLY view for file changes in VS Code
-     * @param filePath - The file path for the diff
-     * @param oldContent - Original content with line numbers
-     * @param newContent - Modified content with line numbers
-     * @returns Promise that resolves with user's approval response
+     * Reset reconnection attempts (e.g., when user manually triggers reconnect)
      */
-    async requestDiffApply(filePath, oldContent, newContent) {
-        return new Promise((resolve) => {
-            if (!this.client || this.client.readyState !== WebSocket.OPEN) {
-                resolve('approve'); // If not connected, default to approve (fallback to CLI confirmation)
-                return;
-            }
-            const requestId = Math.random().toString(36).substring(7);
-            const timeout = setTimeout(() => {
-                cleanup();
-                resolve('approve'); // Timeout, default to approve
-            }, 30000); // 30 second timeout for user decision
-            const handler = (message) => {
-                try {
-                    const data = JSON.parse(message.toString());
-                    if (data.type === 'diffApplyResult' && data.requestId === requestId) {
-                        cleanup();
-                        resolve(data.result || 'approve');
-                    }
-                }
-                catch (error) {
-                    // Ignore invalid JSON
-                }
-            };
-            const cleanup = () => {
-                clearTimeout(timeout);
-                this.client?.removeListener('message', handler);
-            };
-            this.client.on('message', handler);
-            this.client.send(JSON.stringify({
-                type: 'diffApply',
-                requestId,
-                filePath,
-                oldContent,
-                newContent
-            }));
-        });
+    resetReconnectAttempts() {
+        this.reconnectAttempts = 0;
     }
 }
 export const vscodeConnection = new VSCodeConnectionManager();

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "snow-ai",
-	"version": "0.2.19",
+	"version": "0.2.21",
 	"description": "Intelligent Command Line Assistant powered by AI",
 	"license": "MIT",
 	"bin": {