@pixelbyte-software/pixcode 1.51.8 → 1.52.0

package/server/gemini-response-handler.js

@@ -1,79 +1,79 @@
-// Gemini Response Handler - JSON Stream processing
-import { sessionsService } from './modules/providers/services/sessions.service.js';
-
-class GeminiResponseHandler {
-  constructor(ws, options = {}) {
-    this.ws = ws;
-    this.buffer = '';
-    this.onContentFragment = options.onContentFragment || null;
-    this.onInit = options.onInit || null;
-    this.onToolUse = options.onToolUse || null;
-    this.onToolResult = options.onToolResult || null;
-  }
-
-  // Process incoming raw data from Gemini stream-json
-  processData(data) {
-    this.buffer += data;
-
-    // Split by newline
-    const lines = this.buffer.split('\n');
-
-    // Keep the last incomplete line in the buffer
-    this.buffer = lines.pop() || '';
-
-    for (const line of lines) {
-      if (!line.trim()) continue;
-
-      try {
-        const event = JSON.parse(line);
-        this.handleEvent(event);
-      } catch (err) {
-        // Not a JSON line, probably debug output or CLI warnings
-      }
-    }
-  }
-
-  handleEvent(event) {
-    const sid = typeof this.ws.getSessionId === 'function' ? this.ws.getSessionId() : null;
-
-    if (event.type === 'init') {
-      if (this.onInit) {
-        this.onInit(event);
-      }
-      return;
-    }
-
-    // Invoke per-type callbacks for session tracking
-    if (event.type === 'message' && event.role === 'assistant') {
-      const content = event.content || '';
-      if (this.onContentFragment && content) {
-        this.onContentFragment(content);
-      }
-    } else if (event.type === 'tool_use' && this.onToolUse) {
-      this.onToolUse(event);
-    } else if (event.type === 'tool_result' && this.onToolResult) {
-      this.onToolResult(event);
-    }
-
-    // Normalize via adapter and send all resulting messages
-    const normalized = sessionsService.normalizeMessage('gemini', event, sid);
-    for (const msg of normalized) {
-      this.ws.send(msg);
-    }
-  }
-
-  forceFlush() {
-    if (this.buffer.trim()) {
-      try {
-        const event = JSON.parse(this.buffer);
-        this.handleEvent(event);
-      } catch (err) { }
-    }
-  }
-
-  destroy() {
-    this.buffer = '';
-  }
-}
-
-export default GeminiResponseHandler;
+// Gemini Response Handler - JSON Stream processing
+import { sessionsService } from './modules/providers/services/sessions.service.js';
+
+class GeminiResponseHandler {
+  constructor(ws, options = {}) {
+    this.ws = ws;
+    this.buffer = '';
+    this.onContentFragment = options.onContentFragment || null;
+    this.onInit = options.onInit || null;
+    this.onToolUse = options.onToolUse || null;
+    this.onToolResult = options.onToolResult || null;
+  }
+
+  // Process incoming raw data from Gemini stream-json
+  processData(data) {
+    this.buffer += data;
+
+    // Split by newline
+    const lines = this.buffer.split('\n');
+
+    // Keep the last incomplete line in the buffer
+    this.buffer = lines.pop() || '';
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+
+      try {
+        const event = JSON.parse(line);
+        this.handleEvent(event);
+      } catch (err) {
+        // Not a JSON line, probably debug output or CLI warnings
+      }
+    }
+  }
+
+  handleEvent(event) {
+    const sid = typeof this.ws.getSessionId === 'function' ? this.ws.getSessionId() : null;
+
+    if (event.type === 'init') {
+      if (this.onInit) {
+        this.onInit(event);
+      }
+      return;
+    }
+
+    // Invoke per-type callbacks for session tracking
+    if (event.type === 'message' && event.role === 'assistant') {
+      const content = event.content || '';
+      if (this.onContentFragment && content) {
+        this.onContentFragment(content);
+      }
+    } else if (event.type === 'tool_use' && this.onToolUse) {
+      this.onToolUse(event);
+    } else if (event.type === 'tool_result' && this.onToolResult) {
+      this.onToolResult(event);
+    }
+
+    // Normalize via adapter and send all resulting messages
+    const normalized = sessionsService.normalizeMessage('gemini', event, sid);
+    for (const msg of normalized) {
+      this.ws.send(msg);
+    }
+  }
+
+  forceFlush() {
+    if (this.buffer.trim()) {
+      try {
+        const event = JSON.parse(this.buffer);
+        this.handleEvent(event);
+      } catch (err) { }
+    }
+  }
+
+  destroy() {
+    this.buffer = '';
+  }
+}
+
+export default GeminiResponseHandler;

package/server/index.js

@@ -3283,8 +3283,78 @@ function handleShellConnection(ws, request) {
     let shellProcess = null;
     let ptySessionKey = null;
     let urlDetectionBuffer = '';
+    let outputBuffer = '';
+    let outputFlushTimer = null;
     const announcedAuthUrls = new Set();
 
+    function flushOutputBuffer() {
+        if (!outputBuffer || !ptySessionKey) {
+            outputFlushTimer = null;
+            return;
+        }
+        const rawData = outputBuffer;
+        outputBuffer = '';
+        outputFlushTimer = null;
+
+        const session = ptySessionsMap.get(ptySessionKey);
+        if (!session) return;
+        session.updatedAt = Date.now();
+
+        appendPtySessionBuffer(session, rawData);
+
+        if (session.ws && session.ws.readyState === WebSocket.OPEN) {
+            let outputData = rawData;
+
+            const cleanChunk = stripAnsiSequences(rawData);
+            urlDetectionBuffer = `${urlDetectionBuffer}${cleanChunk}`.slice(-SHELL_URL_PARSE_BUFFER_LIMIT);
+
+            outputData = outputData.replace(
+                /OPEN_URL:\s*(https?:\/\/[^\s\x1b\x07]+)/g,
+                '[INFO] Opening in browser: $1'
+            );
+            outputData = hideProviderApprovalChoiceLines(outputData);
+
+            const emitAuthUrl = (detectedUrl, autoOpen = false) => {
+                const normalizedUrl = normalizeDetectedUrl(detectedUrl);
+                if (!normalizedUrl) return;
+
+                const isNewUrl = !announcedAuthUrls.has(normalizedUrl);
+                if (isNewUrl) {
+                    announcedAuthUrls.add(normalizedUrl);
+                    session.ws.send(JSON.stringify({
+                        type: 'auth_url',
+                        url: normalizedUrl,
+                        autoOpen
+                    }));
+                }
+            };
+
+            const normalizedDetectedUrls = extractUrlsFromText(urlDetectionBuffer)
+                .map((url) => normalizeDetectedUrl(url))
+                .filter(Boolean);
+
+            const dedupedDetectedUrls = Array.from(new Set(normalizedDetectedUrls)).filter((url, _, urls) =>
+                !urls.some((otherUrl) => otherUrl !== url && otherUrl.startsWith(url))
+            );
+
+            dedupedDetectedUrls.forEach((url) => emitAuthUrl(url, false));
+
+            if (shouldAutoOpenUrlFromOutput(cleanChunk) && dedupedDetectedUrls.length > 0) {
+                const bestUrl = dedupedDetectedUrls.reduce((longest, current) =>
+                    current.length > longest.length ? current : longest
+                );
+                emitAuthUrl(bestUrl, true);
+            }
+
+            if (outputData) {
+                session.ws.send(JSON.stringify({
+                    type: 'output',
+                    data: outputData
+                }));
+            }
+        }
+    }
+
     ws.on('message', async (message) => {
         try {
             const data = JSON.parse(message);
@@ -3353,18 +3423,17 @@ function handleShellConnection(ws, request) {
                     initialCommand.includes('auth login')
                 );
 
-                // Include command hash in session key so different commands get separate sessions
-                const commandSuffix = isPlainShell && initialCommand
-                    ? `_cmd_${Buffer.from(initialCommand).toString('base64').slice(0, 16)}`
-                    : '';
-                // Include provider in the key so a fresh "new session" in OpenCode
-                // doesn't reattach to a cached Claude PTY for the same project (or
-                // vice versa). Before this, the key was just `${path}_default`,
-                // which collided across providers and made every disconnect →
-                // switch-provider flow reopen the previously-running CLI.
-                const providerSuffix = isPlainShell ? '' : `_${provider}`;
+                // Every UI shell instance gets a unique tabId. This guarantees that
+                // multiple tabs of the same provider (e.g. two OpenCode windows) do
+                // not share or overwrite the same PTY session. If the client does not
+                // send a tabId (legacy callers), generate one on the backend so the
+                // key is still unique for this connection.
+                const tabId = typeof data.tabId === 'string' && data.tabId.trim()
+                    ? data.tabId.trim()
+                    : `tab_${crypto.randomUUID()}`;
+                const providerKey = isPlainShell ? 'plain' : provider;
                 const ownerUserId = request.user?.id ?? request.user?.userId ?? 'anonymous';
-                ptySessionKey = `${ownerUserId}_${projectPath}_${sessionId || 'default'}${providerSuffix}${commandSuffix}`;
+                ptySessionKey = `${ownerUserId}_${projectPath}_${providerKey}_${tabId}_${sessionId || 'new'}`;
 
                 // Kill any existing login session before starting fresh
                 if (isLoginCommand) {
@@ -3373,16 +3442,12 @@ function handleShellConnection(ws, request) {
                         terminatePtySession(ptySessionKey, oldSession, 'fresh login');
                     }
                 } else if (forceNewSession) {
-                    if (isPlainShell) {
-                        const oldSession = ptySessionsMap.get(ptySessionKey);
-                        if (oldSession) {
-                            terminatePtySession(ptySessionKey, oldSession, 'fresh plain shell session');
-                        }
-                    } else {
-                        const killedSessions = killProviderPtySessions(projectPath, provider, ownerUserId);
-                        if (killedSessions > 0) {
-                            console.log(`🧹 Fresh ${provider} session requested; terminated ${killedSessions} cached PTY session(s).`);
-                        }
+                    // Only terminate the PTY that belongs to this exact tabId, not
+                    // every session for the same provider. This lets users run
+                    // multiple OpenCode/Claude/etc. instances side-by-side.
+                    const oldSession = ptySessionsMap.get(ptySessionKey);
+                    if (oldSession) {
+                        terminatePtySession(ptySessionKey, oldSession, `fresh ${isPlainShell ? 'plain shell' : provider} session`);
                     }
                 }
 
@@ -3618,6 +3683,7 @@ function handleShellConnection(ws, request) {
                         userId: ownerUserId,
                         projectPath,
                         sessionId,
+                        tabId,
                         hermesLaunchId,
                         provider,
                         isPlainShell,
@@ -3635,73 +3701,24 @@ function handleShellConnection(ws, request) {
                         writeTerminalStartupInput(createdSession, terminalStartupInput, 'new provider session', 4500);
                     }
 
-                    // Handle data output
+                    // Handle data output — batch rapid chunks so high-volume CLI
+                    // output does not flood the WebSocket with one JSON frame per
+                    // keystroke-sized chunk.
                     shellProcess.onData((data) => {
-                        const session = ptySessionsMap.get(ptySessionKey);
-                        if (!session) return;
-                        session.updatedAt = Date.now();
-
-                        appendPtySessionBuffer(session, data);
-
-                        if (session.ws && session.ws.readyState === WebSocket.OPEN) {
-                            let outputData = data;
-
-                            const cleanChunk = stripAnsiSequences(data);
-                            urlDetectionBuffer = `${urlDetectionBuffer}${cleanChunk}`.slice(-SHELL_URL_PARSE_BUFFER_LIMIT);
-
-                            outputData = outputData.replace(
-                                /OPEN_URL:\s*(https?:\/\/[^\s\x1b\x07]+)/g,
-                                '[INFO] Opening in browser: $1'
-                            );
-                            outputData = hideProviderApprovalChoiceLines(outputData);
-
-                            const emitAuthUrl = (detectedUrl, autoOpen = false) => {
-                                const normalizedUrl = normalizeDetectedUrl(detectedUrl);
-                                if (!normalizedUrl) return;
-
-                                const isNewUrl = !announcedAuthUrls.has(normalizedUrl);
-                                if (isNewUrl) {
-                                    announcedAuthUrls.add(normalizedUrl);
-                                    session.ws.send(JSON.stringify({
-                                        type: 'auth_url',
-                                        url: normalizedUrl,
-                                        autoOpen
-                                    }));
-                                }
-
-                            };
-
-                            const normalizedDetectedUrls = extractUrlsFromText(urlDetectionBuffer)
-                                .map((url) => normalizeDetectedUrl(url))
-                                .filter(Boolean);
-
-                            // Prefer the most complete URL if shorter prefix variants are also present.
-                            const dedupedDetectedUrls = Array.from(new Set(normalizedDetectedUrls)).filter((url, _, urls) =>
-                                !urls.some((otherUrl) => otherUrl !== url && otherUrl.startsWith(url))
-                            );
-
-                            dedupedDetectedUrls.forEach((url) => emitAuthUrl(url, false));
-
-                            if (shouldAutoOpenUrlFromOutput(cleanChunk) && dedupedDetectedUrls.length > 0) {
-                                const bestUrl = dedupedDetectedUrls.reduce((longest, current) =>
-                                    current.length > longest.length ? current : longest
-                                );
-                                emitAuthUrl(bestUrl, true);
-                            }
-
-                            // Send regular output
-                            if (outputData) {
-                                session.ws.send(JSON.stringify({
-                                    type: 'output',
-                                    data: outputData
-                                }));
-                            }
+                        outputBuffer += data;
+                        if (!outputFlushTimer) {
+                            outputFlushTimer = setTimeout(flushOutputBuffer, 8);
                         }
                     });
 
                     // Handle process exit
                     shellProcess.onExit((exitCode) => {
                         console.log('🔚 Shell process exited with code:', exitCode.exitCode, 'signal:', exitCode.signal);
+                        if (outputFlushTimer) {
+                            clearTimeout(outputFlushTimer);
+                            outputFlushTimer = null;
+                        }
+                        flushOutputBuffer();
                         const session = ptySessionsMap.get(ptySessionKey);
                         if (session?.pty && session.pty !== shellProcess) {
                             console.log('↩️  Ignoring stale PTY exit for replacement session:', ptySessionKey);
@@ -3794,6 +3811,11 @@ function handleShellConnection(ws, request) {
     ws.on('close', () => {
         console.log('🔌 Shell client disconnected');
 
+        if (outputFlushTimer) {
+            clearTimeout(outputFlushTimer);
+            outputFlushTimer = null;
+        }
+
         if (ptySessionKey) {
             const session = ptySessionsMap.get(ptySessionKey);
             if (session) {
@@ -3803,6 +3825,14 @@ function handleShellConnection(ws, request) {
                     return;
                 }
 
+                // Plain shells are cheap to recreate, so terminate them immediately
+                // instead of keeping a 30-minute zombie PTY around.
+                if (session.isPlainShell) {
+                    console.log('🧹 Terminating plain shell PTY on disconnect:', ptySessionKey);
+                    terminatePtySession(ptySessionKey, session, 'plain shell disconnect');
+                    return;
+                }
+
                 console.log('⏳ PTY session kept alive, will timeout in 30 minutes:', ptySessionKey);
                 session.ws = null;
 

package/server/load-env.js

@@ -1,35 +1,35 @@
-// Load environment variables from .env before other imports execute.
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-
-import { findAppRoot, getModuleDir } from './utils/runtime-paths.js';
-
-const __dirname = getModuleDir(import.meta.url);
-// Resolve the repo/app root via the nearest /server folder so this file keeps finding the
-// same top-level .env file from both /server/load-env.js and /dist-server/server/load-env.js.
-const APP_ROOT = findAppRoot(__dirname);
-
-try {
-  const envPath = path.join(APP_ROOT, '.env');
-  const envFile = fs.readFileSync(envPath, 'utf8');
-  envFile.split('\n').forEach(line => {
-    const trimmedLine = line.trim();
-    if (trimmedLine && !trimmedLine.startsWith('#')) {
-      const [key, ...valueParts] = trimmedLine.split('=');
-      if (key && valueParts.length > 0 && !process.env[key]) {
-        process.env[key] = valueParts.join('=').trim();
-      }
-    }
-  });
-} catch (e) {
-  console.log('No .env file found or error reading it:', e.message);
-}
-
-// Keep the default database in a stable user-level location so rebuilding dist-server
-// never changes where the backend stores auth.db when DATABASE_PATH is not set explicitly.
-const DEFAULT_DATABASE_PATH = path.join(os.homedir(), '.pixcode', 'auth.db');
-
-if (!process.env.DATABASE_PATH) {
-  process.env.DATABASE_PATH = DEFAULT_DATABASE_PATH;
-}
+// Load environment variables from .env before other imports execute.
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+import { findAppRoot, getModuleDir } from './utils/runtime-paths.js';
+
+const __dirname = getModuleDir(import.meta.url);
+// Resolve the repo/app root via the nearest /server folder so this file keeps finding the
+// same top-level .env file from both /server/load-env.js and /dist-server/server/load-env.js.
+const APP_ROOT = findAppRoot(__dirname);
+
+try {
+  const envPath = path.join(APP_ROOT, '.env');
+  const envFile = fs.readFileSync(envPath, 'utf8');
+  envFile.split('\n').forEach(line => {
+    const trimmedLine = line.trim();
+    if (trimmedLine && !trimmedLine.startsWith('#')) {
+      const [key, ...valueParts] = trimmedLine.split('=');
+      if (key && valueParts.length > 0 && !process.env[key]) {
+        process.env[key] = valueParts.join('=').trim();
+      }
+    }
+  });
+} catch (e) {
+  console.log('No .env file found or error reading it:', e.message);
+}
+
+// Keep the default database in a stable user-level location so rebuilding dist-server
+// never changes where the backend stores auth.db when DATABASE_PATH is not set explicitly.
+const DEFAULT_DATABASE_PATH = path.join(os.homedir(), '.pixcode', 'auth.db');
+
+if (!process.env.DATABASE_PATH) {
+  process.env.DATABASE_PATH = DEFAULT_DATABASE_PATH;
+}