@pixelbyte-software/pixcode 1.53.1 → 1.53.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pixelbyte-software/pixcode",
-  "version": "1.53.1",
+  "version": "1.53.3",
   "description": "Self-hosted AI coding agent control room for Claude Code, Cursor CLI, OpenAI Codex, Gemini CLI, Qwen Code, and OpenCode with chat, files, shell, Git, orchestration, API keys, Telegram, MCP, plugins, themes, and desktop/server deployment.",
   "type": "module",
   "main": "dist-server/server/index.js",

package/server/index.js

@@ -273,6 +273,59 @@ function getActiveUpdateJob() {
     return null;
 }
 
+function countByProvider(items) {
+    return items.reduce((counts, item) => {
+        const provider = item?.provider || 'unknown';
+        counts[provider] = (counts[provider] || 0) + 1;
+        return counts;
+    }, {});
+}
+
+function getActiveProviderWorkSummary() {
+    const sessions = [
+        ...getActiveClaudeSDKSessions().map((id) => ({ id, provider: 'claude' })),
+        ...getActiveCursorSessions().map((session) => ({ ...session, provider: 'cursor' })),
+        ...getActiveCodexSessions().map((session) => ({ ...session, provider: 'codex' })),
+        ...getActiveGeminiSessions().map((session) => ({ ...session, provider: 'gemini' })),
+        ...getActiveQwenSessions().map((session) => ({ ...session, provider: 'qwen' })),
+        ...getActiveOpencodeSessions().map((session) => ({ ...session, provider: 'opencode' })),
+    ];
+
+    return {
+        total: sessions.length,
+        byProvider: countByProvider(sessions),
+    };
+}
+
+function getActivePtyWorkSummary() {
+    const activePtys = Array.from(ptySessionsMap.values())
+        .filter((session) => session?.pty && session.lifecycleState === 'running')
+        .map((session) => ({
+            provider: session.isPlainShell ? 'plain-shell' : (session.provider || 'unknown'),
+            connected: Boolean(session.ws && session.ws.readyState === WebSocket.OPEN),
+        }));
+
+    return {
+        total: activePtys.length,
+        connected: activePtys.filter((session) => session.connected).length,
+        detached: activePtys.filter((session) => !session.connected).length,
+        byProvider: countByProvider(activePtys),
+    };
+}
+
+function getActiveWorkSummary() {
+    const pty = getActivePtyWorkSummary();
+    const agents = getActiveProviderWorkSummary();
+    const total = pty.total + agents.total;
+
+    return {
+        hasActiveWork: total > 0,
+        total,
+        pty,
+        agents,
+    };
+}
+
 async function readLatestPixcodePackageMetadata() {
     const registryRes = await fetch('https://registry.npmjs.org/@pixelbyte-software/pixcode');
     if (!registryRes.ok) throw new Error(`Registry returned HTTP ${registryRes.status}`);
@@ -375,8 +428,10 @@ async function runCommandUpdateJob(job, updateCommand, updateCwd) {
             cwd: updateCwd,
             env: process.env,
             shell: true,
+            detached: true,
             stdio: ['ignore', 'pipe', 'pipe'],
         });
+        try { child.unref(); } catch { /* noop */ }
         child.stdout?.on('data', (data) => appendUpdateJobLog(job, 'stdout', data.toString()));
         child.stderr?.on('data', (data) => appendUpdateJobLog(job, 'stderr', data.toString()));
         child.on('error', reject);
@@ -695,7 +750,108 @@ async function setupProjectsWatcher() {
 // `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 }
+const WORKSPACE_DIFF_SNAPSHOT_MAX_BYTES = 512 * 1024;
+const WORKSPACE_DIFF_SNAPSHOT_MAX_FILES = 800;
+const workspaceWatchers = new Map(); // projectName -> { watcher, subscribers, debounceTimer, pendingEvent, rootPath, fileSnapshots }
+
+function runWorkspaceCommand(command, args, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            cwd,
+            shell: false,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+
+        child.stdout?.on('data', (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr?.on('data', (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on('error', reject);
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve({ stdout, stderr });
+                return;
+            }
+
+            reject(new Error(stderr || `${command} exited with code ${code}`));
+        });
+    });
+}
+
+function parseGitPorcelainZ(output) {
+    const entries = [];
+    const parts = String(output || '').split('\0').filter(Boolean);
+
+    for (let index = 0; index < parts.length; index += 1) {
+        const entry = parts[index];
+        if (entry.length < 4) {
+            continue;
+        }
+
+        const status = entry.slice(0, 2);
+        const filePath = entry.slice(3).replace(/\\/g, '/');
+        if (filePath) {
+            entries.push(filePath);
+        }
+
+        if (status[0] === 'R' || status[0] === 'C') {
+            index += 1;
+        }
+    }
+
+    return entries;
+}
+
+function normalizeWorkspaceRelativePath(rootPath, filePath) {
+    const relativePath = path.relative(rootPath, filePath).replace(/\\/g, '/');
+    if (!relativePath || relativePath.startsWith('../') || relativePath === '..' || path.isAbsolute(relativePath)) {
+        return null;
+    }
+
+    return relativePath;
+}
+
+async function readWorkspaceTextSnapshot(filePath) {
+    try {
+        const stats = await fsPromises.stat(filePath);
+        if (!stats.isFile() || stats.size > WORKSPACE_DIFF_SNAPSHOT_MAX_BYTES) {
+            return null;
+        }
+
+        const buffer = await fsPromises.readFile(filePath);
+        if (buffer.includes(0)) {
+            return null;
+        }
+
+        return buffer.toString('utf8');
+    } catch (error) {
+        if (error?.code === 'ENOENT') {
+            return '';
+        }
+
+        return null;
+    }
+}
+
+async function initializeWorkspaceDirtySnapshots(rootPath, fileSnapshots) {
+    try {
+        const { stdout } = await runWorkspaceCommand('git', ['status', '--porcelain', '-z'], rootPath);
+        const changedPaths = parseGitPorcelainZ(stdout).slice(0, WORKSPACE_DIFF_SNAPSHOT_MAX_FILES);
+
+        await Promise.all(changedPaths.map(async (relativePath) => {
+            const content = await readWorkspaceTextSnapshot(path.join(rootPath, relativePath));
+            if (typeof content === 'string') {
+                fileSnapshots.set(relativePath, content);
+            }
+        }));
+    } catch {
+        // Non-git workspaces still get event-time snapshots after the first change.
+    }
+}
 
 async function subscribeToWorkspace(ws, projectName) {
     if (!projectName || typeof projectName !== 'string') return;
@@ -722,11 +878,48 @@ async function subscribeToWorkspace(ws, projectName) {
         debounceTimer: null,
         pendingEvent: null,
         rootPath,
+        fileSnapshots: new Map(),
     };
     workspaceWatchers.set(projectName, entry);
+    await initializeWorkspaceDirtySnapshots(rootPath, entry.fileSnapshots);
+
+    const broadcastFileUpdate = async (eventType, filePath) => {
+        const relativePath = filePath ? normalizeWorkspaceRelativePath(rootPath, filePath) : null;
+        const previousContent = relativePath ? entry.fileSnapshots.get(relativePath) : undefined;
+        let currentContent;
+
+        if (relativePath && !eventType.endsWith('Dir')) {
+            if (eventType === 'unlink') {
+                currentContent = '';
+                entry.fileSnapshots.delete(relativePath);
+            } else {
+                const snapshot = await readWorkspaceTextSnapshot(filePath);
+                if (typeof snapshot === 'string') {
+                    currentContent = snapshot;
+                    entry.fileSnapshots.set(relativePath, snapshot);
+                }
+            }
+        }
+
+        const nextEvent = {
+            eventType,
+            filePath,
+            changedFile: relativePath,
+            oldContent: typeof previousContent === 'string'
+                ? previousContent
+                : eventType === 'add'
+                    ? ''
+                    : undefined,
+            currentContent,
+        };
+
+        entry.pendingEvent = entry.pendingEvent?.changedFile === relativePath
+            ? {
+                ...nextEvent,
+                oldContent: entry.pendingEvent.oldContent ?? nextEvent.oldContent,
+            }
+            : nextEvent;
 
-    const broadcastFileUpdate = (eventType, filePath) => {
-        entry.pendingEvent = { eventType, filePath };
         if (entry.debounceTimer) {
             clearTimeout(entry.debounceTimer);
         }
@@ -734,11 +927,23 @@ async function subscribeToWorkspace(ws, projectName) {
             entry.debounceTimer = null;
             const pending = entry.pendingEvent || {};
             entry.pendingEvent = null;
+            const hasSnapshotDiff = (
+                typeof pending.oldContent === 'string'
+                && typeof pending.currentContent === 'string'
+                && pending.oldContent !== pending.currentContent
+            );
             const message = JSON.stringify({
                 type: 'project_files_updated',
                 projectName,
                 changeType: pending.eventType || 'change',
-                changedFile: pending.filePath ? path.relative(rootPath, pending.filePath) : null,
+                changedFile: pending.changedFile ?? (pending.filePath ? path.relative(rootPath, pending.filePath) : null),
+                ...(hasSnapshotDiff
+                    ? {
+                        oldContent: pending.oldContent,
+                        currentContent: pending.currentContent,
+                        diffSource: 'workspace-snapshot',
+                    }
+                    : {}),
                 timestamp: new Date().toISOString(),
             });
             entry.subscribers.forEach((client) => {
@@ -764,11 +969,11 @@ async function subscribeToWorkspace(ws, projectName) {
         });
 
         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('add', (filePath) => void broadcastFileUpdate('add', filePath))
+            .on('change', (filePath) => void broadcastFileUpdate('change', filePath))
+            .on('unlink', (filePath) => void broadcastFileUpdate('unlink', filePath))
+            .on('addDir', (dirPath) => void broadcastFileUpdate('addDir', dirPath))
+            .on('unlinkDir', (dirPath) => void broadcastFileUpdate('unlinkDir', dirPath))
             .on('error', (error) => {
                 console.error(`[ERROR] Workspace watcher error for ${projectName}:`, error);
             });
@@ -1485,6 +1690,7 @@ app.get('/api/system/update-state', authenticateToken, (req, res) => {
         success: true,
         state: readSystemUpdateState(),
         activeJob: snapshotUpdateJob(getActiveUpdateJob()),
+        activeWork: getActiveWorkSummary(),
         currentVersion: SERVER_VERSION,
         installMode,
         capabilities: {
@@ -1885,6 +2091,16 @@ app.post('/api/system/update', authenticateToken, requireAdmin, requireApiScope(
 // (systemd/pm2/daemon manager) can bring the server back on the new code.
 // Foreground installs without a wrapper will simply stop; the UI reports this.
 app.post('/api/system/restart', authenticateToken, requireAdmin, requireApiScope('system:restart'), (req, res) => {
+    const forceRestart = req.body?.force === true || req.query.force === 'true';
+    const activeWork = getActiveWorkSummary();
+    if (!forceRestart && activeWork.hasActiveWork) {
+        return res.status(409).json({
+            success: false,
+            error: 'Active terminal or agent sessions are running. Confirm restart to interrupt them.',
+            activeWork,
+        });
+    }
+
     res.json({
         success: true,
         version: SERVER_VERSION,