snow-ai 0.2.20 → 0.2.21

package/dist/hooks/useVSCodeState.js

@@ -34,18 +34,18 @@ export function useVSCodeState() {
         if (vscodeConnectionStatus !== 'connecting') {
             return;
         }
-        // Set timeout for connecting state (30 seconds to allow for VSCode extension reconnection)
+        // Set timeout for connecting state (30 seconds to allow for IDE plugin reconnection)
         const connectingTimeout = setTimeout(() => {
             const isConnected = vscodeConnection.isConnected();
-            const isServerRunning = vscodeConnection.isServerRunning();
+            const isClientRunning = vscodeConnection.isClientRunning();
             // Only set error if still not connected after timeout
             if (!isConnected) {
-                if (isServerRunning) {
-                    // Server is running but no connection - show error with helpful message
+                if (isClientRunning) {
+                    // Client is running but no connection - show error with helpful message
                     setVscodeConnectionStatus('error');
                 }
                 else {
-                    // Server not running - go back to disconnected
+                    // Client not running - go back to disconnected
                     setVscodeConnectionStatus('disconnected');
                 }
             }

package/dist/ui/components/FileList.js

@@ -177,7 +177,7 @@ const FileList = memo(forwardRef(({ query, selectedIndex, visible, maxItems = 10
     return (React.createElement(Box, { paddingX: 1, marginTop: 1, flexDirection: "column" },
         React.createElement(Box, { marginBottom: 1 },
             React.createElement(Text, { color: "blue", bold: true },
-                "\uD83D\uDDD0 Files",
+                "\u2261 Files",
                 ' ',
                 allFilteredFiles.length > effectiveMaxItems &&
                     `(${selectedIndex + 1}/${allFilteredFiles.length})`)),

package/dist/ui/pages/ChatScreen.js

@@ -691,12 +691,12 @@ export default function ChatScreen({}) {
                     "\u25CF",
                     ' ',
                     vscodeState.vscodeConnectionStatus === 'connecting'
-                        ? 'Waiting for VSCode extension to connect...'
+                        ? 'Connecting to IDE...'
                         : vscodeState.vscodeConnectionStatus === 'connected'
-                            ? 'VSCode Connected'
+                            ? 'IDE Connected'
                             : vscodeState.vscodeConnectionStatus === 'error'
-                                ? 'Connection Failed - Make sure Snow CLI extension is installed and active in VSCode'
-                                : 'VSCode',
+                                ? 'Connection Failed - Make sure Snow CLI plugin is installed and active in your IDE'
+                                : 'IDE',
                     vscodeState.vscodeConnectionStatus === 'connected' &&
                         vscodeState.editorContext.activeFile &&
                         ` | ${vscodeState.editorContext.activeFile}`,

package/dist/utils/commands/ide.js

@@ -3,42 +3,30 @@ import { vscodeConnection } from '../vscodeConnection.js';
 // IDE connection command handler
 registerCommand('ide', {
     execute: async () => {
-        // Check if server is already running in THIS process (allow multiple clients to connect)
-        if (vscodeConnection.isServerRunning()) {
-            const isConnected = vscodeConnection.isConnected();
+        // Check if already connected to IDE plugin
+        if (vscodeConnection.isConnected()) {
             return {
                 success: true,
                 action: 'info',
-                alreadyConnected: isConnected, // Add this flag to indicate connection status
-                message: isConnected
-                    ? `Connected to VSCode (server running on port ${vscodeConnection.getPort()})`
-                    : `VSCode connection server is running on port ${vscodeConnection.getPort()}\nWaiting for VSCode extension to connect...`
+                alreadyConnected: true,
+                message: `Already connected to IDE (port ${vscodeConnection.getPort()})`
             };
         }
-        // Start the server
+        // Try to connect to IDE plugin server
         try {
             await vscodeConnection.start();
             return {
                 success: true,
                 action: 'info',
-                message: `VSCode connection server started on port ${vscodeConnection.getPort()}\nWaiting for VSCode extension to connect...`
+                message: `Connected to IDE on port ${vscodeConnection.getPort()}\nMake sure your IDE plugin (VSCode/JetBrains) is active and running.`
             };
         }
         catch (error) {
-            // Handle EADDRINUSE error specifically
-            if (error instanceof Error && 'code' in error && error.code === 'EADDRINUSE') {
-                // Port is in use by another Snow CLI process - this is OK!
-                // Return success and indicate already connected
-                return {
-                    success: true,
-                    action: 'info',
-                    alreadyConnected: true, // Treat as already connected since another terminal has the connection
-                    message: `VSCode connection is already active in another Snow CLI terminal.\nNo additional connection needed - context will be shared through VSCode extension.`
-                };
-            }
             return {
                 success: false,
-                message: error instanceof Error ? error.message : 'Failed to start IDE connection'
+                message: error instanceof Error
+                    ? `Failed to connect to IDE: ${error.message}\nMake sure your IDE plugin is installed and active.`
+                    : 'Failed to connect to IDE. Make sure your IDE plugin is installed and active.'
             };
         }
     }

package/dist/utils/vscodeConnection.d.ts

@@ -16,26 +16,48 @@ interface Diagnostic {
     code?: string | number;
 }
 declare class VSCodeConnectionManager {
-    private server;
-    private clients;
+    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[]>;
+    /**
+     * Reset reconnection attempts (e.g., when user manually triggers reconnect)
+     */
+    resetReconnectAttempts(): void;
 }
 export declare const vscodeConnection: VSCodeConnectionManager;
 export type { EditorContext, Diagnostic };

package/dist/utils/vscodeConnection.js

@@ -1,17 +1,69 @@
-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, "clients", {
+        Object.defineProperty(this, "reconnectTimer", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new Set()
+            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,
@@ -31,64 +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 => {
-                    // Add new client to the set (allow multiple connections)
-                    this.clients.add(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', () => {
-                        this.clients.delete(ws);
+                    this.client.on('close', () => {
+                        this.client = null;
+                        this.scheduleReconnect();
                     });
-                    ws.on('error', () => {
-                        // Silently handle errors
-                        this.clients.delete(ws);
+                    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
                     });
-                });
-                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() {
-        // Close all connected clients
-        for (const client of this.clients) {
-            client.close();
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
         }
-        this.clients.clear();
-        if (this.server) {
-            this.server.close();
-            this.server = null;
+        if (this.client) {
+            this.client.close();
+            this.client = null;
         }
+        this.reconnectAttempts = 0;
     }
     isConnected() {
-        return (this.clients.size > 0 &&
-            Array.from(this.clients).some(client => client.readyState === WebSocket.OPEN));
+        return this.client?.readyState === WebSocket.OPEN;
     }
-    isServerRunning() {
-        return this.server !== null;
+    isClientRunning() {
+        return this.client !== null;
     }
     getContext() {
         return { ...this.editorContext };
@@ -119,15 +254,13 @@ 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 => {
-            // Get first connected client
-            const client = Array.from(this.clients).find(c => c.readyState === WebSocket.OPEN);
-            if (!client) {
+            if (!this.client || this.client.readyState !== WebSocket.OPEN) {
                 resolve([]); // Return empty array if not connected
                 return;
             }
@@ -150,15 +283,21 @@ class VSCodeConnectionManager {
             };
             const cleanup = () => {
                 clearTimeout(timeout);
-                client?.removeListener('message', handler);
+                this.client?.removeListener('message', handler);
             };
-            client.on('message', handler);
-            client.send(JSON.stringify({
+            this.client.on('message', handler);
+            this.client.send(JSON.stringify({
                 type: 'getDiagnostics',
                 requestId,
                 filePath,
             }));
         });
     }
+    /**
+     * Reset reconnection attempts (e.g., when user manually triggers reconnect)
+     */
+    resetReconnectAttempts() {
+        this.reconnectAttempts = 0;
+    }
 }
 export const vscodeConnection = new VSCodeConnectionManager();

package/package.json

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