@pixelbyte-software/pixcode 1.53.1 → 1.53.3

package/dist-server/server/index.js

@@ -231,6 +231,52 @@ 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)
@@ -329,8 +375,13 @@ 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);
@@ -624,7 +675,94 @@ 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;
@@ -650,10 +788,44 @@ async function subscribeToWorkspace(ws, projectName) {
         debounceTimer: null,
         pendingEvent: null,
         rootPath,
+        fileSnapshots: new Map(),
     };
     workspaceWatchers.set(projectName, entry);
-    const broadcastFileUpdate = (eventType, filePath) => {
-        entry.pendingEvent = { eventType, filePath };
+    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;
         if (entry.debounceTimer) {
             clearTimeout(entry.debounceTimer);
         }
@@ -661,11 +833,21 @@ 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) => {
@@ -689,11 +871,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);
         });
@@ -1296,6 +1478,7 @@ app.get('/api/system/update-state', authenticateToken, (req, res) => {
         success: true,
         state: readSystemUpdateState(),
         activeJob: snapshotUpdateJob(getActiveUpdateJob()),
+        activeWork: getActiveWorkSummary(),
         currentVersion: SERVER_VERSION,
         installMode,
         capabilities: {
@@ -1684,6 +1867,15 @@ 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,