orc-server 1.0.5

package/dist/claude/watcher.js

@@ -0,0 +1,242 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeWatcher = void 0;
+const events_1 = require("events");
+const chokidar_1 = __importDefault(require("chokidar"));
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const config_1 = require("../config");
+const logger_1 = require("../utils/logger");
+class ClaudeWatcher extends events_1.EventEmitter {
+    constructor() {
+        super();
+        this.historyWatcher = null;
+        this.sessionWatcher = null;
+        this.lastHistorySize = 0;
+        this.lastSessionSize = 0;
+        this.activeSessionId = null;
+        this.activeProjectPath = null;
+        // Queue mechanism for handling rapid updates
+        this.messageQueue = [];
+        this.isProcessing = false;
+        this.historyPath = (0, path_1.join)(config_1.CONFIG.claudeHome, 'history.jsonl');
+    }
+    async start() {
+        logger_1.logger.info('Starting Claude Code watcher');
+        await this.watchHistory();
+        this.on('user_input', (data) => {
+            if (data.sessionId !== this.activeSessionId) {
+                this.activeSessionId = data.sessionId;
+                this.activeProjectPath = this.projectPathToDir(data.project);
+                this.watchSession();
+            }
+        });
+    }
+    stop() {
+        logger_1.logger.info('Stopping Claude Code watcher');
+        if (this.historyWatcher) {
+            this.historyWatcher.close();
+        }
+        if (this.sessionWatcher) {
+            this.sessionWatcher.close();
+        }
+    }
+    async watchHistory() {
+        this.historyWatcher = chokidar_1.default.watch(this.historyPath, {
+            persistent: true,
+            usePolling: false,
+            awaitWriteFinish: {
+                stabilityThreshold: 100,
+                pollInterval: 50
+            }
+        });
+        this.historyWatcher.on('change', async () => {
+            await this.processHistoryChanges();
+        });
+        this.historyWatcher.on('error', (error) => {
+            logger_1.logger.error('History watcher error:', error);
+        });
+        logger_1.logger.info(`Watching history: ${this.historyPath}`);
+    }
+    async processHistoryChanges() {
+        try {
+            const content = await (0, promises_1.readFile)(this.historyPath, 'utf-8');
+            const lines = content.split('\n').filter(l => l.trim());
+            if (lines.length > this.lastHistorySize) {
+                const newLines = lines.slice(this.lastHistorySize);
+                // Add to queue instead of processing immediately
+                this.messageQueue.push(...newLines.map(line => ({ type: 'history', line })));
+                // Start processing if not already processing
+                if (!this.isProcessing) {
+                    this.isProcessing = true;
+                    await this.processQueue();
+                    this.isProcessing = false;
+                }
+                this.lastHistorySize = lines.length;
+            }
+        }
+        catch (error) {
+            logger_1.logger.error('Error processing history changes:', error);
+        }
+    }
+    projectPathToDir(path) {
+        return path.replace(/\//g, '-').replace(/^-/, '');
+    }
+    watchSession() {
+        if (!this.activeSessionId || !this.activeProjectPath)
+            return;
+        if (this.sessionWatcher) {
+            this.sessionWatcher.close();
+        }
+        const sessionPath = (0, path_1.join)(config_1.CONFIG.claudeHome, 'projects', this.activeProjectPath, `${this.activeSessionId}.jsonl`);
+        this.lastSessionSize = 0;
+        this.sessionWatcher = chokidar_1.default.watch(sessionPath, {
+            persistent: true,
+            usePolling: false,
+            awaitWriteFinish: {
+                stabilityThreshold: 100,
+                pollInterval: 50
+            }
+        });
+        this.sessionWatcher.on('change', async () => {
+            await this.processSessionChanges(sessionPath);
+        });
+        this.sessionWatcher.on('error', (error) => {
+            logger_1.logger.error('Session watcher error:', error);
+        });
+        logger_1.logger.info(`Watching session: ${sessionPath}`);
+    }
+    async processSessionChanges(sessionPath) {
+        try {
+            const content = await (0, promises_1.readFile)(sessionPath, 'utf-8');
+            const lines = content.split('\n').filter(l => l.trim());
+            if (lines.length > this.lastSessionSize) {
+                const newLines = lines.slice(this.lastSessionSize);
+                // Add to queue
+                this.messageQueue.push(...newLines.map(line => ({ type: 'session', line })));
+                // Start processing if not already processing
+                if (!this.isProcessing) {
+                    this.isProcessing = true;
+                    await this.processQueue();
+                    this.isProcessing = false;
+                }
+                this.lastSessionSize = lines.length;
+            }
+        }
+        catch (error) {
+            logger_1.logger.error('Error processing session changes:', error);
+        }
+    }
+    async processQueue() {
+        while (this.messageQueue.length > 0) {
+            const batch = this.messageQueue.splice(0, 10);
+            for (const item of batch) {
+                try {
+                    if (item.type === 'history') {
+                        const entry = JSON.parse(item.line);
+                        this.emit('user_input', {
+                            message: entry.display,
+                            timestamp: entry.timestamp,
+                            sessionId: entry.sessionId,
+                            project: entry.project
+                        });
+                        logger_1.logger.debug(`User input: ${entry.display.substring(0, 50)}...`);
+                    }
+                    else if (item.type === 'session') {
+                        const entry = JSON.parse(item.line);
+                        await this.processSessionEntry(entry);
+                    }
+                }
+                catch (error) {
+                    logger_1.logger.error('Error processing queue item:', error);
+                }
+            }
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+    }
+    async processSessionEntry(entry) {
+        switch (entry.type) {
+            case 'assistant':
+                this.handleAssistantMessage(entry);
+                break;
+            case 'system':
+                this.handleSystemMessage(entry);
+                break;
+            case 'progress':
+                this.emit('progress', {
+                    message: entry.data?.message,
+                    timestamp: entry.timestamp
+                });
+                break;
+        }
+    }
+    handleAssistantMessage(entry) {
+        const content = entry.message?.content || [];
+        for (const block of content) {
+            if (block.type === 'text') {
+                this.emit('assistant_message', {
+                    content: block.text,
+                    timestamp: entry.timestamp,
+                    messageId: entry.message.id
+                });
+                logger_1.logger.debug(`Assistant: ${block.text.substring(0, 50)}...`);
+            }
+            else if (block.type === 'tool_use') {
+                this.emit('tool_call', {
+                    toolName: block.name,
+                    toolId: block.id,
+                    input: block.input,
+                    timestamp: entry.timestamp
+                });
+                logger_1.logger.debug(`Tool: ${block.name}`);
+                if (['Edit', 'Write'].includes(block.name)) {
+                    this.handleFileOperation(block, entry.timestamp);
+                }
+            }
+        }
+    }
+    handleSystemMessage(entry) {
+        if (entry.data?.type === 'tool_result') {
+            this.emit('tool_result', {
+                toolId: entry.data.tool_use_id,
+                content: entry.data.content,
+                timestamp: entry.timestamp
+            });
+        }
+    }
+    async handleFileOperation(toolUse, timestamp) {
+        const { name, input } = toolUse;
+        const filePath = input.file_path;
+        if (!filePath)
+            return;
+        try {
+            const oldContent = await (0, promises_1.readFile)(filePath, 'utf-8').catch(() => '');
+            let newContent = '';
+            if (name === 'Edit') {
+                newContent = oldContent.replace(input.old_string, input.new_string);
+            }
+            else if (name === 'Write') {
+                newContent = input.content;
+            }
+            this.emit('file_change', {
+                filePath,
+                operation: name.toLowerCase(),
+                oldContent,
+                newContent,
+                timestamp
+            });
+        }
+        catch (error) {
+            logger_1.logger.error('Error handling file operation:', error);
+        }
+    }
+    computeSimpleDiff(oldContent, newContent) {
+        const oldLines = oldContent.split('\n');
+        const newLines = newContent.split('\n');
+        return `+${newLines.length - oldLines.length} lines`;
+    }
+}
+exports.ClaudeWatcher = ClaudeWatcher;

package/dist/config.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG = void 0;
+const dotenv_1 = require("dotenv");
+const os_1 = require("os");
+(0, dotenv_1.config)();
+/**
+ * Parse CLI arguments: --port, --host, --token, --claude-home
+ * These take precedence over environment variables.
+ */
+function parseArgs() {
+    const args = {};
+    const argv = process.argv.slice(2);
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg.startsWith('--') && i + 1 < argv.length && !argv[i + 1].startsWith('--')) {
+            const key = arg.slice(2);
+            args[key] = argv[i + 1];
+            i++;
+        }
+        else if (arg.startsWith('--') && arg.includes('=')) {
+            const [key, value] = arg.slice(2).split('=');
+            args[key] = value;
+        }
+    }
+    return args;
+}
+const args = parseArgs();
+exports.CONFIG = {
+    host: args['host'] || process.env.HOST || '0.0.0.0',
+    port: parseInt(args['port'] || process.env.PORT || '9080'),
+    authToken: args['token'] || process.env.AUTH_TOKEN || '',
+    claudeHome: args['claude-home'] || process.env.CLAUDE_HOME || `${(0, os_1.homedir)()}/.claude`,
+    maxFileSize: parseInt(process.env.MAX_FILE_SIZE || '10485760'),
+    searchTimeout: parseInt(process.env.SEARCH_TIMEOUT || '5000'),
+    logLevel: args['log-level'] || process.env.LOG_LEVEL || 'info',
+    // File tree limits to prevent OOM on large directories
+    fileTreeMaxDepth: parseInt(process.env.FILE_TREE_MAX_DEPTH || '3'),
+    fileTreeMaxNodes: parseInt(process.env.FILE_TREE_MAX_NODES || '5000'),
+    fileTreeExpandMaxNodes: parseInt(process.env.FILE_TREE_EXPAND_MAX_NODES || '500'),
+};
+if (!exports.CONFIG.authToken) {
+    console.warn('WARNING: AUTH_TOKEN not set. Generate: openssl rand -hex 32');
+}

package/dist/files/browser.js

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileBrowser = exports.FileBrowser = void 0;
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const logger_1 = require("../utils/logger");
+class FileBrowser {
+    constructor() {
+        this.ignoredDirs = new Set([
+            'node_modules',
+            '.git',
+            'dist',
+            'build',
+            '.next',
+            'coverage',
+            '.cache',
+            '__pycache__',
+            '.venv',
+            'venv',
+        ]);
+        this.ignoredFiles = new Set([
+            '.DS_Store',
+            'Thumbs.db',
+            '.env',
+            '.env.local',
+        ]);
+    }
+    /**
+     * Generate file tree structure for a given directory
+     * @param rootPath - Root directory to scan
+     * @param maxDepth - Maximum depth to traverse (default: 3)
+     * @param maxNodes - Maximum number of nodes to return (default: 5000)
+     * @returns FileTreeResult with tree, totalNodes, truncated flag, and accessErrors
+     */
+    async generateTree(rootPath, maxDepth = 3, maxNodes = 5000) {
+        const context = {
+            nodeCount: 0,
+            truncated: false,
+            accessErrors: [],
+        };
+        const tree = await this.buildTree(rootPath, rootPath, 0, maxDepth, maxNodes, context);
+        return {
+            tree,
+            totalNodes: context.nodeCount,
+            truncated: context.truncated,
+            accessErrors: context.accessErrors,
+        };
+    }
+    async buildTree(rootPath, currentPath, depth, maxDepth, maxNodes, context) {
+        // Check if we've hit the node limit
+        if (context.nodeCount >= maxNodes) {
+            context.truncated = true;
+            return {
+                name: '.',
+                path: '.',
+                type: 'directory',
+                hasChildren: true,
+            };
+        }
+        const stats = await (0, promises_1.stat)(currentPath);
+        const name = currentPath === rootPath ? '.' : (0, path_1.relative)(rootPath, currentPath).split('/').pop() || '.';
+        context.nodeCount++;
+        if (stats.isFile()) {
+            return {
+                name,
+                path: (0, path_1.relative)(rootPath, currentPath),
+                type: 'file',
+                size: stats.size,
+            };
+        }
+        // Directory
+        const node = {
+            name,
+            path: (0, path_1.relative)(rootPath, currentPath) || '.',
+            type: 'directory',
+            children: [],
+        };
+        // Stop at max depth but indicate there might be children
+        if (depth >= maxDepth) {
+            // Check if directory has children without reading all of them
+            try {
+                const entries = await (0, promises_1.readdir)(currentPath);
+                const hasVisibleChildren = entries.some(e => !this.ignoredDirs.has(e) && !this.ignoredFiles.has(e));
+                node.hasChildren = hasVisibleChildren;
+            }
+            catch {
+                node.hasChildren = false;
+            }
+            delete node.children;
+            return node;
+        }
+        try {
+            const entries = await (0, promises_1.readdir)(currentPath);
+            const children = [];
+            for (const entry of entries) {
+                // Check node limit before processing each child
+                if (context.nodeCount >= maxNodes) {
+                    context.truncated = true;
+                    break;
+                }
+                // Skip ignored directories and files
+                if (this.ignoredDirs.has(entry) || this.ignoredFiles.has(entry)) {
+                    continue;
+                }
+                const entryPath = (0, path_1.join)(currentPath, entry);
+                try {
+                    const childNode = await this.buildTree(rootPath, entryPath, depth + 1, maxDepth, maxNodes, context);
+                    children.push(childNode);
+                }
+                catch (error) {
+                    // Handle permission errors specifically
+                    if (error?.code === 'EACCES' || error?.code === 'EPERM') {
+                        const relativePath = (0, path_1.relative)(rootPath, entryPath);
+                        context.accessErrors.push(relativePath);
+                        // Add node with accessDenied flag
+                        try {
+                            const entryStat = await (0, promises_1.stat)(entryPath).catch(() => null);
+                            children.push({
+                                name: entry,
+                                path: relativePath,
+                                type: entryStat?.isDirectory() ? 'directory' : 'file',
+                                accessDenied: true,
+                            });
+                            context.nodeCount++;
+                        }
+                        catch {
+                            // If we can't even stat it, still add as directory with access denied
+                            children.push({
+                                name: entry,
+                                path: relativePath,
+                                type: 'directory',
+                                accessDenied: true,
+                            });
+                            context.nodeCount++;
+                        }
+                    }
+                    else {
+                        logger_1.logger.warn(`Failed to process ${entryPath}:`, error);
+                    }
+                }
+            }
+            // Sort: directories first, then files, alphabetically
+            node.children = children.sort((a, b) => {
+                if (a.type !== b.type) {
+                    return a.type === 'directory' ? -1 : 1;
+                }
+                return a.name.localeCompare(b.name);
+            });
+        }
+        catch (error) {
+            if (error?.code === 'EACCES' || error?.code === 'EPERM') {
+                const relativePath = (0, path_1.relative)(rootPath, currentPath) || '.';
+                context.accessErrors.push(relativePath);
+                node.accessDenied = true;
+                delete node.children;
+            }
+            else {
+                logger_1.logger.error(`Failed to read directory ${currentPath}:`, error);
+            }
+        }
+        return node;
+    }
+    /**
+     * Expand a single directory and return its immediate children
+     * Used for lazy loading in the client
+     * @param rootPath - The root path of the file tree
+     * @param dirPath - The directory path to expand (relative to rootPath)
+     * @param maxDepth - How many levels deep to scan (default: 1)
+     * @param maxNodes - Maximum nodes to return (default: 500)
+     */
+    async expandDirectory(rootPath, dirPath, maxDepth = 1, maxNodes = 500) {
+        const absolutePath = dirPath === '.' ? rootPath : (0, path_1.join)(rootPath, dirPath);
+        const context = {
+            nodeCount: 0,
+            truncated: false,
+            accessErrors: [],
+        };
+        const node = await this.buildTree(rootPath, absolutePath, 0, maxDepth, maxNodes, context);
+        return {
+            tree: node,
+            totalNodes: context.nodeCount,
+            truncated: context.truncated,
+            accessErrors: context.accessErrors,
+        };
+    }
+    /**
+     * Get directory listing (non-recursive)
+     */
+    async listDirectory(dirPath) {
+        try {
+            const entries = await (0, promises_1.readdir)(dirPath);
+            const nodes = [];
+            for (const entry of entries) {
+                // Skip ignored items
+                if (this.ignoredDirs.has(entry) || this.ignoredFiles.has(entry)) {
+                    continue;
+                }
+                const entryPath = (0, path_1.join)(dirPath, entry);
+                try {
+                    const stats = await (0, promises_1.stat)(entryPath);
+                    nodes.push({
+                        name: entry,
+                        path: entryPath,
+                        type: stats.isDirectory() ? 'directory' : 'file',
+                        size: stats.isFile() ? stats.size : undefined,
+                    });
+                }
+                catch (error) {
+                    logger_1.logger.warn(`Failed to stat ${entryPath}:`, error);
+                }
+            }
+            // Sort: directories first, then files
+            return nodes.sort((a, b) => {
+                if (a.type !== b.type) {
+                    return a.type === 'directory' ? -1 : 1;
+                }
+                return a.name.localeCompare(b.name);
+            });
+        }
+        catch (error) {
+            logger_1.logger.error(`Failed to list directory ${dirPath}:`, error);
+            throw new Error(`Failed to list directory: ${error}`);
+        }
+    }
+}
+exports.FileBrowser = FileBrowser;
+exports.fileBrowser = new FileBrowser();

package/dist/files/reader.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileReader = exports.FileReader = void 0;
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const config_1 = require("../config");
+const logger_1 = require("../utils/logger");
+class FileReader {
+    constructor() {
+        this.languageMap = {
+            '.js': 'javascript',
+            '.jsx': 'javascript',
+            '.ts': 'typescript',
+            '.tsx': 'typescript',
+            '.py': 'python',
+            '.rb': 'ruby',
+            '.go': 'go',
+            '.rs': 'rust',
+            '.java': 'java',
+            '.c': 'c',
+            '.cpp': 'cpp',
+            '.h': 'c',
+            '.hpp': 'cpp',
+            '.cs': 'csharp',
+            '.php': 'php',
+            '.swift': 'swift',
+            '.kt': 'kotlin',
+            '.scala': 'scala',
+            '.sh': 'bash',
+            '.bash': 'bash',
+            '.zsh': 'bash',
+            '.fish': 'fish',
+            '.ps1': 'powershell',
+            '.html': 'html',
+            '.htm': 'html',
+            '.xml': 'xml',
+            '.css': 'css',
+            '.scss': 'scss',
+            '.sass': 'sass',
+            '.less': 'less',
+            '.json': 'json',
+            '.yaml': 'yaml',
+            '.yml': 'yaml',
+            '.toml': 'toml',
+            '.ini': 'ini',
+            '.md': 'markdown',
+            '.sql': 'sql',
+            '.graphql': 'graphql',
+            '.gql': 'graphql',
+            '.vue': 'vue',
+            '.svelte': 'svelte',
+            '.dockerfile': 'dockerfile',
+            '.Dockerfile': 'dockerfile',
+        };
+        this.binaryExtensions = new Set([
+            '.png', '.jpg', '.jpeg', '.gif', '.bmp', '.ico', '.svg',
+            '.pdf', '.zip', '.tar', '.gz', '.rar', '.7z',
+            '.exe', '.dll', '.so', '.dylib',
+            '.mp3', '.mp4', '.avi', '.mov', '.wav',
+            '.ttf', '.otf', '.woff', '.woff2',
+            '.bin', '.dat', '.db', '.sqlite',
+        ]);
+    }
+    /**
+     * Read file content with size limit
+     */
+    async readFile(filePath) {
+        try {
+            const stats = await (0, promises_1.stat)(filePath);
+            const ext = (0, path_1.extname)(filePath).toLowerCase();
+            const isBinary = this.isBinaryFile(ext);
+            // Check if file is too large
+            if (stats.size > config_1.CONFIG.maxFileSize) {
+                logger_1.logger.warn(`File too large: ${filePath} (${stats.size} bytes)`);
+                return {
+                    path: filePath,
+                    content: '',
+                    size: stats.size,
+                    language: this.detectLanguage(ext),
+                    isBinary,
+                    truncated: true,
+                };
+            }
+            // Don't read binary files
+            if (isBinary) {
+                return {
+                    path: filePath,
+                    content: '[Binary file]',
+                    size: stats.size,
+                    language: 'binary',
+                    isBinary: true,
+                    truncated: false,
+                };
+            }
+            // Read file content
+            const content = await (0, promises_1.readFile)(filePath, 'utf-8');
+            return {
+                path: filePath,
+                content,
+                size: stats.size,
+                language: this.detectLanguage(ext),
+                isBinary: false,
+                truncated: false,
+            };
+        }
+        catch (error) {
+            logger_1.logger.error(`Failed to read file ${filePath}:`, error);
+            throw new Error(`Failed to read file: ${error}`);
+        }
+    }
+    /**
+     * Read file with line range
+     */
+    async readFileLines(filePath, startLine, endLine) {
+        const fileContent = await this.readFile(filePath);
+        if (fileContent.isBinary || fileContent.truncated) {
+            return fileContent;
+        }
+        const lines = fileContent.content.split('\n');
+        const selectedLines = lines.slice(startLine - 1, endLine);
+        return {
+            ...fileContent,
+            content: selectedLines.join('\n'),
+        };
+    }
+    /**
+     * Detect file language from extension
+     */
+    detectLanguage(ext) {
+        return this.languageMap[ext] || 'plaintext';
+    }
+    /**
+     * Check if file is binary based on extension
+     */
+    isBinaryFile(ext) {
+        return this.binaryExtensions.has(ext);
+    }
+    /**
+     * Get file metadata without reading content
+     */
+    async getFileInfo(filePath) {
+        try {
+            const stats = await (0, promises_1.stat)(filePath);
+            const ext = (0, path_1.extname)(filePath).toLowerCase();
+            return {
+                path: filePath,
+                size: stats.size,
+                language: this.detectLanguage(ext),
+                isBinary: this.isBinaryFile(ext),
+            };
+        }
+        catch (error) {
+            logger_1.logger.error(`Failed to get file info ${filePath}:`, error);
+            throw new Error(`Failed to get file info: ${error}`);
+        }
+    }
+}
+exports.FileReader = FileReader;
+exports.fileReader = new FileReader();