@pixelbyte-software/pixcode 1.51.1 → 1.51.3

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

@@ -111,6 +111,7 @@ import {
   GeminiA2AAdapter,
   OpenCodeA2AAdapter,
   QwenA2AAdapter,
+  JsonEventA2AAdapter,
   createPreviewProxyRouter,
   createOrchestrationTaskRouter,
   createHermesRouter,
@@ -302,6 +303,117 @@ async function setupProjectsWatcher() {
     }
 }
 
+// ── Per-project workspace watchers (file explorer live refresh) ─────────────
+// setupProjectsWatcher() above only watches provider metadata folders
+// (~/.claude/projects etc.), so the file explorer never learned about changes
+// inside the actual project working directory. These watchers are created on
+// demand when a client sends `watch-project` over /ws and broadcast debounced
+// `project_files_updated` events to subscribed clients only, letting the
+// explorer refresh automatically without HTTP polling.
+const WORKSPACE_WATCHER_DEBOUNCE_MS = 800;
+const workspaceWatchers = new Map(); // projectName -> { watcher, subscribers, debounceTimer, pendingEvent, rootPath }
+
+async function subscribeToWorkspace(ws, projectName) {
+    if (!projectName || typeof projectName !== 'string') return;
+
+    const existing = workspaceWatchers.get(projectName);
+    if (existing) {
+        existing.subscribers.add(ws);
+        return;
+    }
+
+    let rootPath;
+    try {
+        rootPath = await extractProjectDirectory(projectName);
+        await fsPromises.access(rootPath);
+    } catch (error) {
+        console.warn(`[watcher] Cannot watch workspace for ${projectName}:`, error.message);
+        return;
+    }
+
+    const entry = {
+        watcher: null,
+        subscribers: new Set([ws]),
+        debounceTimer: null,
+        pendingEvent: null,
+        rootPath,
+    };
+    workspaceWatchers.set(projectName, entry);
+
+    const broadcastFileUpdate = (eventType, filePath) => {
+        entry.pendingEvent = { eventType, filePath };
+        if (entry.debounceTimer) {
+            clearTimeout(entry.debounceTimer);
+        }
+        entry.debounceTimer = setTimeout(() => {
+            entry.debounceTimer = null;
+            const pending = entry.pendingEvent || {};
+            entry.pendingEvent = null;
+            const message = JSON.stringify({
+                type: 'project_files_updated',
+                projectName,
+                changeType: pending.eventType || 'change',
+                changedFile: pending.filePath ? path.relative(rootPath, pending.filePath) : null,
+                timestamp: new Date().toISOString(),
+            });
+            entry.subscribers.forEach((client) => {
+                if (client.readyState === WebSocket.OPEN) {
+                    client.send(message);
+                }
+            });
+        }, WORKSPACE_WATCHER_DEBOUNCE_MS);
+    };
+
+    try {
+        const chokidar = (await import('chokidar')).default;
+        const watcher = chokidar.watch(rootPath, {
+            ignored: WATCHER_IGNORED_PATTERNS,
+            persistent: true,
+            ignoreInitial: true,
+            followSymlinks: false,
+            depth: 10,
+            awaitWriteFinish: {
+                stabilityThreshold: 500,
+                pollInterval: 250
+            }
+        });
+
+        watcher
+            .on('add', (filePath) => broadcastFileUpdate('add', filePath))
+            .on('change', (filePath) => broadcastFileUpdate('change', filePath))
+            .on('unlink', (filePath) => broadcastFileUpdate('unlink', filePath))
+            .on('addDir', (dirPath) => broadcastFileUpdate('addDir', dirPath))
+            .on('unlinkDir', (dirPath) => broadcastFileUpdate('unlinkDir', dirPath))
+            .on('error', (error) => {
+                console.error(`[ERROR] Workspace watcher error for ${projectName}:`, error);
+            });
+
+        entry.watcher = watcher;
+    } catch (error) {
+        workspaceWatchers.delete(projectName);
+        console.error(`[ERROR] Failed to watch workspace for ${projectName}:`, error);
+    }
+}
+
+function unsubscribeFromWorkspace(ws, projectName = null) {
+    const entries = projectName
+        ? (workspaceWatchers.has(projectName) ? [[projectName, workspaceWatchers.get(projectName)]] : [])
+        : Array.from(workspaceWatchers.entries());
+
+    for (const [name, entry] of entries) {
+        entry.subscribers.delete(ws);
+        if (entry.subscribers.size === 0) {
+            if (entry.debounceTimer) {
+                clearTimeout(entry.debounceTimer);
+            }
+            workspaceWatchers.delete(name);
+            entry.watcher?.close().catch((error) => {
+                console.warn(`[watcher] Failed to close workspace watcher for ${name}:`, error?.message || error);
+            });
+        }
+    }
+}
+
 
 const app = express();
 const server = http.createServer(app);
@@ -598,7 +710,9 @@ function buildProviderShellPermissionFlags(provider, permissionMode, skipPermiss
         if (mode === 'plan') {
             return ['--agent', 'plan'];
         }
-        return bypass ? ['--dangerously-skip-permissions'] : [];
+        // OpenCode's interactive TUI rejects the headless run-only bypass
+        // option; passing it makes the CLI print help and exit before opening.
+        return [];
     }
 
     if (provider === 'claude') {
@@ -984,6 +1098,7 @@ adapterRegistry.register(new CursorA2AAdapter());
 adapterRegistry.register(new GeminiA2AAdapter());
 adapterRegistry.register(new QwenA2AAdapter());
 adapterRegistry.register(new OpenCodeA2AAdapter());
+adapterRegistry.register(new JsonEventA2AAdapter());
 app.use('/hermes', createHermesTaskRouter());
 app.use('/preview', authenticateToken, createPreviewProxyRouter());
 app.use('/api/orchestration', authenticateToken, createOrchestrationTaskRouter());
@@ -1872,8 +1987,12 @@ app.get('/api/projects/:projectName/files', authenticateToken, async (req, res)
             actualPath = await extractProjectDirectory(req.params.projectName);
         } catch (error) {
             console.error('Error extracting project directory:', error);
-            // Fallback to simple dash replacement
-            actualPath = req.params.projectName.replace(/-/g, '/');
+            // Do NOT fall back to projectName.replace(/-/g, '/') here: on Windows the
+            // dash-encoded name ("C--Users-...") decodes to a garbage path ("C//Users/...")
+            // that can never exist, so the old fallback just produced a confusing 404
+            // with a fabricated path. extractProjectDirectory already handles the
+            // POSIX-style decode internally; if it throws, the project is unknown.
+            return res.status(404).json({ error: `Project not found: ${req.params.projectName}` });
         }
 
         // Check if path exists
@@ -2552,6 +2671,13 @@ function handleChatConnection(ws, request) {
                         data: pending
                     });
                 }
+            } else if (data.type === 'watch-project') {
+                // Subscribe this client to live file-tree updates for a project
+                // workspace. The server pushes debounced `project_files_updated`
+                // events so the explorer refreshes without HTTP polling.
+                await subscribeToWorkspace(ws, data.projectName);
+            } else if (data.type === 'unwatch-project') {
+                unsubscribeFromWorkspace(ws, data.projectName || null);
             } else if (data.type === 'get-active-sessions') {
                 // Get all currently active sessions
                 const activeSessions = {
@@ -2580,6 +2706,8 @@ function handleChatConnection(ws, request) {
         console.log('🔌 Chat client disconnected');
         // Remove from connected clients
         connectedClients.delete(ws);
+        // Drop any workspace watcher subscriptions held by this socket
+        unsubscribeFromWorkspace(ws);
     });
 }
 

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;
+}