claude-code-runner 0.1.0

package/dist/web-server.js

@@ -0,0 +1,812 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebUIServer = void 0;
+const node_buffer_1 = require("node:buffer");
+const node_child_process_1 = require("node:child_process");
+const node_http_1 = require("node:http");
+const node_path_1 = __importDefault(require("node:path"));
+const node_process_1 = __importDefault(require("node:process"));
+const node_util_1 = require("node:util");
+const chalk_1 = __importDefault(require("chalk"));
+const express_1 = __importDefault(require("express"));
+const fs = __importStar(require("fs-extra"));
+const socket_io_1 = require("socket.io");
+const docker_config_1 = require("./docker-config");
+const shadow_repository_1 = require("./git/shadow-repository");
+const execAsync = (0, node_util_1.promisify)(node_child_process_1.exec);
+class WebUIServer {
+    app;
+    httpServer;
+    io;
+    docker;
+    sessions = new Map(); // container -> session mapping
+    port = 3456;
+    shadowRepos = new Map(); // container -> shadow repo
+    syncInProgress = new Set(); // Track containers currently syncing
+    originalRepo = '';
+    currentBranch = 'main';
+    fileWatchers = new Map(); // container -> monitor (inotify stream or interval)
+    containerCmd; // 'docker' or 'podman'
+    constructor(docker, containerRuntime) {
+        this.docker = docker;
+        this.containerCmd = containerRuntime || (0, docker_config_1.getContainerRuntimeCmd)();
+        this.app = (0, express_1.default)();
+        this.httpServer = (0, node_http_1.createServer)(this.app);
+        this.io = new socket_io_1.Server(this.httpServer, {
+            cors: {
+                origin: '*',
+                methods: ['GET', 'POST'],
+            },
+        });
+        this.setupRoutes();
+        this.setupSocketHandlers();
+    }
+    setupRoutes() {
+        // Serve static files
+        this.app.use(express_1.default.static(node_path_1.default.join(__dirname, '../public')));
+        // Health check endpoint
+        this.app.get('/api/health', (_req, res) => {
+            res.json({ status: 'ok' });
+        });
+        // Container info endpoint
+        this.app.get('/api/containers', async (_req, res) => {
+            try {
+                const containers = await this.docker.listContainers();
+                const claudeContainers = containers.filter(c => c.Names.some(name => name.includes('claude-code-runner')));
+                res.json(claudeContainers);
+            }
+            catch (error) {
+                res.status(500).json({ error: 'Failed to list containers' });
+            }
+        });
+        // Git info endpoint - get current branch and PRs
+        this.app.get('/api/git/info', async (req, res) => {
+            try {
+                const containerId = req.query.containerId;
+                let currentBranch = 'loading...';
+                const workingDir = this.originalRepo || node_process_1.default.cwd();
+                // If containerId is provided, try to get branch from shadow repo
+                if (containerId && this.shadowRepos.has(containerId)) {
+                    const shadowRepo = this.shadowRepos.get(containerId);
+                    const shadowPath = shadowRepo.getPath();
+                    if (shadowPath) {
+                        try {
+                            const branchResult = await execAsync('git rev-parse --abbrev-ref HEAD', {
+                                cwd: shadowPath,
+                            });
+                            currentBranch = branchResult.stdout.trim();
+                            // Use original repo for PR lookup (PRs are created against the main repo)
+                        }
+                        catch (error) {
+                            // Shadow repo might not be fully initialized yet, fall back to original repo
+                            try {
+                                const branchResult = await execAsync('git rev-parse --abbrev-ref HEAD', {
+                                    cwd: workingDir,
+                                });
+                                currentBranch = branchResult.stdout.trim();
+                            }
+                            catch (fallbackError) {
+                                // Keep default "loading..."
+                            }
+                        }
+                    }
+                }
+                else {
+                    // Fallback to original repo
+                    try {
+                        const branchResult = await execAsync('git rev-parse --abbrev-ref HEAD', {
+                            cwd: workingDir,
+                        });
+                        currentBranch = branchResult.stdout.trim();
+                    }
+                    catch (error) {
+                        // Keep default "loading..."
+                    }
+                }
+                // Get repository remote URL for branch links
+                let repoUrl = '';
+                let isGitHub = false;
+                try {
+                    const remoteResult = await execAsync('git remote get-url origin', {
+                        cwd: this.originalRepo || node_process_1.default.cwd(),
+                    });
+                    const remoteUrl = remoteResult.stdout.trim();
+                    // Convert SSH URLs to HTTPS for web links and detect GitHub
+                    if (remoteUrl.startsWith('git@github.com:')) {
+                        repoUrl = remoteUrl
+                            .replace('git@github.com:', 'https://github.com/')
+                            .replace('.git', '');
+                        isGitHub = true;
+                    }
+                    else if (remoteUrl.includes('github.com')) {
+                        repoUrl = remoteUrl.replace('.git', '');
+                        isGitHub = true;
+                    }
+                    else if (remoteUrl.startsWith('https://')) {
+                        repoUrl = remoteUrl.replace('.git', '');
+                    }
+                }
+                catch (error) {
+                    console.warn('Could not get repository URL:', error);
+                }
+                // Get PR info using GitHub CLI (only for GitHub repositories)
+                let prs = [];
+                if (isGitHub) {
+                    try {
+                        const prResult = await execAsync(`gh pr list --head "${currentBranch}" --json number,title,state,url,isDraft,mergeable`, {
+                            cwd: this.originalRepo || node_process_1.default.cwd(),
+                        });
+                        prs = JSON.parse(prResult.stdout || '[]');
+                    }
+                    catch (error) {
+                        // GitHub CLI might not be installed or not authenticated
+                        // Only log this in debug mode to avoid spam
+                    }
+                }
+                const branchUrl = repoUrl ? `${repoUrl}/tree/${currentBranch}` : '';
+                res.json({
+                    currentBranch,
+                    branchUrl,
+                    repoUrl,
+                    prs,
+                });
+            }
+            catch (error) {
+                console.error('Failed to get git info:', error);
+                res.status(500).json({ error: 'Failed to get git info' });
+            }
+        });
+    }
+    setupSocketHandlers() {
+        this.io.on('connection', (socket) => {
+            console.log(chalk_1.default.blue('✓ Client connected to web UI'));
+            socket.on('attach', async (data) => {
+                const { containerId } = data;
+                try {
+                    const container = this.docker.getContainer(containerId);
+                    // Check if we already have a session for this container
+                    let session = this.sessions.get(containerId);
+                    if (!session || !session.stream) {
+                        // No existing session, create a new one
+                        console.log(chalk_1.default.blue('Creating new Claude session...'));
+                        const exec = await container.exec({
+                            AttachStdin: true,
+                            AttachStdout: true,
+                            AttachStderr: true,
+                            Tty: true,
+                            Cmd: ['/home/claude/start-session.sh'],
+                            WorkingDir: '/workspace',
+                            User: 'claude',
+                            Env: ['TERM=xterm-256color', 'COLORTERM=truecolor'],
+                        });
+                        const stream = await exec.start({
+                            hijack: true,
+                            stdin: true,
+                        });
+                        session = {
+                            containerId,
+                            exec,
+                            stream,
+                            connectedSockets: new Set([socket.id]),
+                            outputHistory: [],
+                        };
+                        this.sessions.set(containerId, session);
+                        // Set up stream handlers that broadcast to all connected sockets
+                        stream.on('data', (chunk) => {
+                            // Process and broadcast to all connected sockets for this session
+                            let dataToSend;
+                            if (chunk.length > 8) {
+                                const firstByte = chunk[0];
+                                if (firstByte >= 1 && firstByte <= 3) {
+                                    dataToSend = chunk.slice(8);
+                                }
+                                else {
+                                    dataToSend = chunk;
+                                }
+                            }
+                            else {
+                                dataToSend = chunk;
+                            }
+                            if (dataToSend.length > 0) {
+                                // Store in history (limit to last 100KB)
+                                if (session.outputHistory) {
+                                    session.outputHistory.push(node_buffer_1.Buffer.from(dataToSend));
+                                    let totalSize = session.outputHistory.reduce((sum, buf) => sum + buf.length, 0);
+                                    while (totalSize > 100000
+                                        && session.outputHistory.length > 1) {
+                                        const removed = session.outputHistory.shift();
+                                        if (removed) {
+                                            totalSize -= removed.length;
+                                        }
+                                    }
+                                }
+                                // Broadcast to all connected sockets for this container
+                                for (const socketId of session.connectedSockets) {
+                                    const connectedSocket = this.io.sockets.sockets.get(socketId);
+                                    if (connectedSocket) {
+                                        connectedSocket.emit('output', new Uint8Array(dataToSend));
+                                    }
+                                }
+                            }
+                        });
+                        stream.on('error', (err) => {
+                            console.error(chalk_1.default.red('Stream error:'), err);
+                            // Notify all connected sockets
+                            for (const socketId of session.connectedSockets) {
+                                const connectedSocket = this.io.sockets.sockets.get(socketId);
+                                if (connectedSocket) {
+                                    connectedSocket.emit('error', { message: err.message });
+                                }
+                            }
+                        });
+                        stream.on('end', () => {
+                            // Notify all connected sockets
+                            for (const socketId of session.connectedSockets) {
+                                const connectedSocket = this.io.sockets.sockets.get(socketId);
+                                if (connectedSocket) {
+                                    connectedSocket.emit('container-disconnected');
+                                }
+                            }
+                            // Stop continuous monitoring
+                            this.stopContinuousMonitoring(containerId);
+                            // Clean up session and shadow repo
+                            this.sessions.delete(containerId);
+                            if (this.shadowRepos.has(containerId)) {
+                                this.shadowRepos.get(containerId)?.cleanup();
+                                this.shadowRepos.delete(containerId);
+                            }
+                        });
+                        console.log(chalk_1.default.green('New Claude session started'));
+                        // Start continuous monitoring for this container
+                        this.startContinuousMonitoring(containerId);
+                    }
+                    else {
+                        // Add this socket to the existing session
+                        console.log(chalk_1.default.blue('Reconnecting to existing Claude session'));
+                        session.connectedSockets.add(socket.id);
+                        // Replay output history to the reconnecting client
+                        if (session.outputHistory && session.outputHistory.length > 0) {
+                            console.log(chalk_1.default.blue(`Replaying ${session.outputHistory.length} output chunks`));
+                            // Send a clear screen first
+                            socket.emit('output', new Uint8Array(node_buffer_1.Buffer.from('\x1B[2J\x1B[H')));
+                            // Then replay the history
+                            for (const chunk of session.outputHistory) {
+                                socket.emit('output', new Uint8Array(chunk));
+                            }
+                        }
+                    }
+                    // Confirm attachment
+                    socket.emit('attached', { containerId });
+                    // Send initial resize after a small delay
+                    if (session.exec && data.cols && data.rows) {
+                        setTimeout(async () => {
+                            try {
+                                await session.exec.resize({ w: data.cols, h: data.rows });
+                            }
+                            catch (e) {
+                                // Ignore resize errors
+                            }
+                        }, 100);
+                    }
+                }
+                catch (error) {
+                    console.error(chalk_1.default.red('Failed to attach to container:'), error);
+                    socket.emit('error', { message: error.message });
+                }
+            });
+            socket.on('resize', async (data) => {
+                const { cols, rows } = data;
+                // Find which session this socket belongs to
+                for (const [, session] of this.sessions) {
+                    if (session.connectedSockets.has(socket.id) && session.exec) {
+                        try {
+                            await session.exec.resize({ w: cols, h: rows });
+                        }
+                        catch (error) {
+                            // Ignore HTTP 201 from Podman (it's actually a success response)
+                            if (error.statusCode === 201) {
+                                continue;
+                            }
+                            console.error(chalk_1.default.yellow('Failed to resize terminal:'), error);
+                        }
+                        break;
+                    }
+                }
+            });
+            socket.on('input', (data) => {
+                // Find which session this socket belongs to
+                for (const [, session] of this.sessions) {
+                    if (session.connectedSockets.has(socket.id) && session.stream) {
+                        session.stream.write(data);
+                        break;
+                    }
+                }
+            });
+            // Test handler to verify socket connectivity
+            socket.on('test-sync', (data) => {
+                console.log(chalk_1.default.yellow(`[TEST] Received test-sync event:`, data));
+            });
+            // input-needed handler removed - now using continuous monitoring
+            // Handle commit operation
+            socket.on('commit-changes', async (data) => {
+                const { containerId, commitMessage } = data;
+                try {
+                    const shadowRepo = this.shadowRepos.get(containerId);
+                    if (!shadowRepo) {
+                        throw new Error('Shadow repository not found');
+                    }
+                    // Perform final sync before commit to ensure we have latest changes
+                    console.log(chalk_1.default.blue('🔄 Final sync before commit...'));
+                    await shadowRepo.syncFromContainer(containerId);
+                    const shadowPath = shadowRepo.getPath();
+                    // Stage all changes
+                    await execAsync('git add .', { cwd: shadowPath });
+                    // Create commit
+                    await execAsync(`git commit -m "${commitMessage.replace(/"/g, '\\"')}"`, {
+                        cwd: shadowPath,
+                    });
+                    console.log(chalk_1.default.green('✓ Changes committed'));
+                    socket.emit('commit-success', {
+                        message: 'Changes committed successfully',
+                    });
+                }
+                catch (error) {
+                    console.error(chalk_1.default.red('Commit failed:'), error);
+                    socket.emit('commit-error', { message: error.message });
+                }
+            });
+            // Handle push operation
+            socket.on('push-changes', async (data) => {
+                const { containerId, branchName } = data;
+                try {
+                    const shadowRepo = this.shadowRepos.get(containerId);
+                    if (!shadowRepo) {
+                        throw new Error('Shadow repository not found');
+                    }
+                    // Perform final sync before push to ensure we have latest changes
+                    console.log(chalk_1.default.blue('🔄 Final sync before push...'));
+                    await shadowRepo.syncFromContainer(containerId);
+                    const shadowPath = shadowRepo.getPath();
+                    // Create and switch to new branch if specified
+                    if (branchName && branchName !== 'main') {
+                        try {
+                            await execAsync(`git checkout -b ${branchName}`, {
+                                cwd: shadowPath,
+                            });
+                        }
+                        catch (error) {
+                            // Branch might already exist, try to switch
+                            await execAsync(`git checkout ${branchName}`, {
+                                cwd: shadowPath,
+                            });
+                        }
+                    }
+                    // Push to remote
+                    const { stdout: remoteOutput } = await execAsync('git remote -v', {
+                        cwd: shadowPath,
+                    });
+                    if (remoteOutput.includes('origin')) {
+                        // Get current branch name if not specified
+                        const pushBranch = branchName
+                            || (await execAsync('git branch --show-current', {
+                                cwd: shadowPath,
+                            }).then(r => r.stdout.trim()));
+                        await execAsync(`git push -u origin ${pushBranch}`, {
+                            cwd: shadowPath,
+                        });
+                        console.log(chalk_1.default.green('✓ Changes pushed to remote'));
+                        socket.emit('push-success', {
+                            message: 'Changes pushed successfully',
+                        });
+                    }
+                    else {
+                        throw new Error('No remote origin configured');
+                    }
+                }
+                catch (error) {
+                    console.error(chalk_1.default.red('Push failed:'), error);
+                    socket.emit('push-error', { message: error.message });
+                }
+            });
+            socket.on('disconnect', () => {
+                console.log(chalk_1.default.yellow('Client disconnected from web UI'));
+                // Remove socket from all sessions
+                for (const [, session] of this.sessions) {
+                    session.connectedSockets.delete(socket.id);
+                }
+            });
+        });
+    }
+    async performSync(containerId) {
+        if (this.syncInProgress.has(containerId)) {
+            return; // Skip if sync already in progress
+        }
+        this.syncInProgress.add(containerId);
+        try {
+            // Initialize shadow repo if not exists
+            let isNewShadowRepo = false;
+            if (!this.shadowRepos.has(containerId)) {
+                const shadowRepo = new shadow_repository_1.ShadowRepository({
+                    originalRepo: this.originalRepo || node_process_1.default.cwd(),
+                    claudeBranch: this.currentBranch || 'claude-changes',
+                    sessionId: containerId.substring(0, 12),
+                    containerRuntime: this.containerCmd,
+                });
+                this.shadowRepos.set(containerId, shadowRepo);
+                isNewShadowRepo = true;
+                // Reset shadow repo to match container's branch (important for PR/remote branch scenarios)
+                await shadowRepo.resetToContainerBranch(containerId);
+            }
+            // Sync files from container (inotify already told us there are changes)
+            const shadowRepo = this.shadowRepos.get(containerId);
+            await shadowRepo.syncFromContainer(containerId);
+            // If this is a new shadow repo, establish a clean baseline after the first sync
+            if (isNewShadowRepo) {
+                console.log(chalk_1.default.blue('🔄 Establishing clean baseline for new shadow repo...'));
+                const shadowPath = shadowRepo.getPath();
+                try {
+                    // Stage all synced files and create a baseline commit
+                    await execAsync('git add -A', { cwd: shadowPath });
+                    await execAsync('git commit -m "Establish baseline from container content" --allow-empty', { cwd: shadowPath });
+                    console.log(chalk_1.default.green('✓ Clean baseline established'));
+                    // Now do one more sync to see if there are any actual changes
+                    await shadowRepo.syncFromContainer(containerId);
+                }
+                catch (baselineError) {
+                    console.warn(chalk_1.default.yellow('Warning: Could not establish baseline'), baselineError);
+                }
+            }
+            // Check if shadow repo actually has git initialized
+            const shadowPath = shadowRepo.getPath();
+            const gitPath = node_path_1.default.join(shadowPath, '.git');
+            if (!(await fs.pathExists(gitPath))) {
+                console.log(chalk_1.default.yellow('Shadow repository .git directory missing - skipping sync'));
+                return;
+            }
+            // Get changes summary and diff data
+            const changes = await shadowRepo.getChanges();
+            console.log(chalk_1.default.gray(`[MONITOR] Shadow repo changes: ${changes.summary}`));
+            let diffData = null;
+            if (changes.hasChanges) {
+                // Get detailed file status and diffs
+                const { stdout: statusOutput } = await execAsync('git status --porcelain', {
+                    cwd: shadowPath,
+                });
+                // Try git diff HEAD first, fallback to git diff if no HEAD
+                let diffOutput = '';
+                try {
+                    const { stdout } = await execAsync('git diff HEAD', {
+                        cwd: shadowPath,
+                        maxBuffer: 10 * 1024 * 1024, // 10MB limit
+                    });
+                    diffOutput = stdout;
+                }
+                catch (headError) {
+                    try {
+                        // Fallback to git diff (shows unstaged changes)
+                        const { stdout } = await execAsync('git diff', {
+                            cwd: shadowPath,
+                            maxBuffer: 10 * 1024 * 1024, // 10MB limit
+                        });
+                        diffOutput = stdout;
+                    }
+                    catch (diffError) {
+                        console.log(chalk_1.default.gray('  Could not generate diff, skipping...'));
+                        diffOutput = 'Could not generate diff';
+                    }
+                }
+                // Get list of untracked files with their content
+                const untrackedFiles = [];
+                const statusLines = statusOutput
+                    .split('\n')
+                    .filter(line => line.startsWith('??'));
+                for (const line of statusLines) {
+                    const filename = line.substring(3);
+                    untrackedFiles.push(filename);
+                }
+                // Calculate diff statistics
+                const diffStats = this.calculateDiffStats(diffOutput);
+                diffData = {
+                    status: statusOutput,
+                    diff: diffOutput,
+                    untrackedFiles,
+                    stats: diffStats,
+                };
+                console.log(chalk_1.default.cyan(`[MONITOR] Changes detected: ${changes.summary}`));
+                console.log(chalk_1.default.cyan(`[MONITOR] Diff stats:`, diffStats));
+            }
+            const syncCompleteData = {
+                hasChanges: changes.hasChanges,
+                summary: changes.summary,
+                shadowPath,
+                diffData,
+                containerId,
+            };
+            // Send to all connected sockets for this container
+            const session = this.sessions.get(containerId);
+            if (session) {
+                for (const socketId of session.connectedSockets) {
+                    const connectedSocket = this.io.sockets.sockets.get(socketId);
+                    if (connectedSocket) {
+                        connectedSocket.emit('sync-complete', syncCompleteData);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('[MONITOR] Sync failed:'), error);
+            const session = this.sessions.get(containerId);
+            if (session) {
+                for (const socketId of session.connectedSockets) {
+                    const connectedSocket = this.io.sockets.sockets.get(socketId);
+                    if (connectedSocket) {
+                        connectedSocket.emit('sync-error', { message: error.message });
+                    }
+                }
+            }
+        }
+        finally {
+            this.syncInProgress.delete(containerId);
+        }
+    }
+    async startContinuousMonitoring(containerId) {
+        // Clear existing monitoring if any
+        this.stopContinuousMonitoring(containerId);
+        console.log(chalk_1.default.blue(`[MONITOR] Starting inotify-based monitoring for container ${containerId.substring(0, 12)}`));
+        // Do initial sync
+        await this.performSync(containerId);
+        // Install inotify-tools if not present
+        try {
+            await execAsync(`${this.containerCmd} exec ${containerId} which inotifywait`);
+        }
+        catch {
+            console.log(chalk_1.default.yellow('  Installing inotify-tools in container...'));
+            try {
+                // Try different package managers
+                const installCommands = [
+                    'dnf install -y inotify-tools',
+                    'yum install -y inotify-tools',
+                    'apt-get update && apt-get install -y inotify-tools',
+                    'apk add --no-cache inotify-tools',
+                ];
+                let installed = false;
+                for (const cmd of installCommands) {
+                    try {
+                        // Try as root user first, then fallback to regular exec
+                        try {
+                            await execAsync(`${this.containerCmd} exec --user root ${containerId} sh -c "${cmd}"`);
+                            installed = true;
+                            break;
+                        }
+                        catch (rootError) {
+                            // If --user root fails, try without it (container might already be running as root)
+                            await execAsync(`${this.containerCmd} exec ${containerId} sh -c "${cmd}"`);
+                            installed = true;
+                            break;
+                        }
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+                if (!installed) {
+                    console.log(chalk_1.default.red('  Could not install inotify-tools, falling back to basic monitoring'));
+                    return;
+                }
+            }
+            catch (error) {
+                console.log(chalk_1.default.red('  Could not install inotify-tools:', error));
+                return;
+            }
+        }
+        // Start inotifywait process in container
+        const inotifyExec = await this.docker.getContainer(containerId).exec({
+            Cmd: [
+                'sh',
+                '-c',
+                `inotifywait -m -r -e modify,create,delete,move --format '%w%f %e' /workspace --exclude '(\.git|node_modules|\.next|__pycache__|\.venv)'`,
+            ],
+            AttachStdout: true,
+            AttachStderr: true,
+            Tty: false,
+        });
+        const stream = await inotifyExec.start({ hijack: true, stdin: false });
+        // Debounce sync to avoid too many rapid syncs
+        let syncTimeout = null;
+        const debouncedSync = () => {
+            if (syncTimeout)
+                clearTimeout(syncTimeout);
+            syncTimeout = setTimeout(async () => {
+                console.log(chalk_1.default.gray('[INOTIFY] Changes detected, syncing...'));
+                await this.performSync(containerId);
+            }, 500); // Wait 500ms after last change before syncing
+        };
+        // Process inotify events
+        stream.on('data', (chunk) => {
+            // Handle docker exec stream format (may have header bytes)
+            let data;
+            if (chunk.length > 8) {
+                const firstByte = chunk[0];
+                if (firstByte >= 1 && firstByte <= 3) {
+                    data = chunk.slice(8);
+                }
+                else {
+                    data = chunk;
+                }
+            }
+            else {
+                data = chunk;
+            }
+            const events = data.toString().trim().split('\n');
+            for (const event of events) {
+                if (event.trim()) {
+                    console.log(chalk_1.default.gray(`[INOTIFY] ${event}`));
+                    debouncedSync();
+                }
+            }
+        });
+        stream.on('error', (err) => {
+            console.error(chalk_1.default.red('[INOTIFY] Stream error:'), err);
+        });
+        stream.on('end', () => {
+            console.log(chalk_1.default.yellow('[INOTIFY] Monitoring stopped'));
+        });
+        // Store the stream for cleanup
+        this.fileWatchers.set(containerId, { stream, exec: inotifyExec });
+    }
+    stopContinuousMonitoring(containerId) {
+        const monitor = this.fileWatchers.get(containerId);
+        if (monitor) {
+            // If it's an inotify monitor, close the stream
+            if (monitor.stream) {
+                monitor.stream.destroy();
+            }
+            else {
+                // Old interval-based monitoring
+                clearInterval(monitor);
+            }
+            this.fileWatchers.delete(containerId);
+            console.log(chalk_1.default.blue(`[MONITOR] Stopped monitoring for container ${containerId.substring(0, 12)}`));
+        }
+    }
+    calculateDiffStats(diffOutput) {
+        if (!diffOutput)
+            return { additions: 0, deletions: 0, files: 0 };
+        let additions = 0;
+        let deletions = 0;
+        const files = new Set();
+        const lines = diffOutput.split('\n');
+        for (const line of lines) {
+            if (line.startsWith('+') && !line.startsWith('+++')) {
+                additions++;
+            }
+            else if (line.startsWith('-') && !line.startsWith('---')) {
+                deletions++;
+            }
+            else if (line.startsWith('diff --git')) {
+                // Extract filename from diff header
+                const match = line.match(/diff --git a\/(.*?) b\//);
+                if (match) {
+                    files.add(match[1]);
+                }
+            }
+        }
+        return { additions, deletions, files: files.size };
+    }
+    async start() {
+        return new Promise((resolve, reject) => {
+            this.httpServer.listen(this.port, () => {
+                const url = `http://localhost:${this.port}`;
+                console.log(chalk_1.default.green(`✓ Web UI server started at ${url}`));
+                resolve(url);
+            });
+            this.httpServer.on('error', (err) => {
+                if (err.code === 'EADDRINUSE') {
+                    // Try next port
+                    this.port++;
+                    this.httpServer.listen(this.port, () => {
+                        const url = `http://localhost:${this.port}`;
+                        console.log(chalk_1.default.green(`✓ Web UI server started at ${url}`));
+                        resolve(url);
+                    });
+                }
+                else {
+                    reject(err);
+                }
+            });
+        });
+    }
+    setRepoInfo(originalRepo, branch) {
+        this.originalRepo = originalRepo;
+        this.currentBranch = branch;
+    }
+    async stop() {
+        // Clean up shadow repos
+        for (const [, shadowRepo] of this.shadowRepos) {
+            await shadowRepo.cleanup();
+        }
+        // Clean up all sessions
+        for (const [, session] of this.sessions) {
+            if (session.stream) {
+                session.stream.end();
+            }
+        }
+        this.sessions.clear();
+        // Close socket.io connections
+        this.io.close();
+        // Close HTTP server
+        return new Promise((resolve) => {
+            this.httpServer.close(() => {
+                console.log(chalk_1.default.yellow('Web UI server stopped'));
+                resolve();
+            });
+        });
+    }
+    async openInBrowser(url) {
+        try {
+            // Try the open module first
+            const open = (await Promise.resolve().then(() => __importStar(require('open')))).default;
+            await open(url);
+            console.log(chalk_1.default.blue('✓ Opened browser'));
+        }
+        catch (error) {
+            // Fallback to platform-specific commands
+            try {
+                const platform = node_process_1.default.platform;
+                if (platform === 'darwin') {
+                    (0, node_child_process_1.execSync)(`open "${url}"`, { stdio: 'ignore' });
+                }
+                else if (platform === 'win32') {
+                    (0, node_child_process_1.execSync)(`start "" "${url}"`, { stdio: 'ignore' });
+                }
+                else {
+                    // Linux/Unix
+                    (0, node_child_process_1.execSync)(`xdg-open "${url}" || firefox "${url}" || google-chrome "${url}"`, { stdio: 'ignore' });
+                }
+                console.log(chalk_1.default.blue('✓ Opened browser'));
+            }
+            catch (fallbackError) {
+                console.log(chalk_1.default.yellow('Could not open browser automatically'));
+                console.log(chalk_1.default.yellow(`Please open ${url} in your browser`));
+            }
+        }
+    }
+}
+exports.WebUIServer = WebUIServer;
+//# sourceMappingURL=web-server.js.map