renote-server 1.0.1

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,17 @@
+"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)();
+exports.CONFIG = {
+    port: parseInt(process.env.PORT || '8080'),
+    authToken: process.env.AUTH_TOKEN || '',
+    claudeHome: 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: process.env.LOG_LEVEL || 'info',
+};
+if (!exports.CONFIG.authToken) {
+    console.warn('WARNING: AUTH_TOKEN not set. Generate: openssl rand -hex 32');
+}

package/dist/files/browser.js

@@ -0,0 +1,127 @@
+"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
+     */
+    async generateTree(rootPath, maxDepth = 5) {
+        return this.buildTree(rootPath, rootPath, 0, maxDepth);
+    }
+    async buildTree(rootPath, currentPath, depth, maxDepth) {
+        const stats = await (0, promises_1.stat)(currentPath);
+        const name = currentPath === rootPath ? '.' : (0, path_1.relative)(rootPath, currentPath).split('/').pop() || '.';
+        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
+        if (depth >= maxDepth) {
+            return node;
+        }
+        try {
+            const entries = await (0, promises_1.readdir)(currentPath);
+            const children = [];
+            for (const entry of entries) {
+                // 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);
+                    children.push(childNode);
+                }
+                catch (error) {
+                    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) {
+            logger_1.logger.error(`Failed to read directory ${currentPath}:`, error);
+        }
+        return node;
+    }
+    /**
+     * 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();

package/dist/files/search.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchService = exports.SearchService = void 0;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const config_1 = require("../config");
+const logger_1 = require("../utils/logger");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+class SearchService {
+    /**
+     * Search for text in files using ripgrep
+     */
+    async search(query, searchPath, options = {}) {
+        if (!query || query.trim().length === 0) {
+            throw new Error('Search query cannot be empty');
+        }
+        try {
+            const args = this.buildRipgrepArgs(query, options);
+            const command = `rg ${args.join(' ')} "${query}" "${searchPath}"`;
+            logger_1.logger.debug(`Executing search: ${command}`);
+            const { stdout, stderr } = await execAsync(command, {
+                timeout: config_1.CONFIG.searchTimeout,
+                maxBuffer: 10 * 1024 * 1024, // 10MB
+            });
+            if (stderr && !stderr.includes('No such file or directory')) {
+                logger_1.logger.warn('Ripgrep stderr:', stderr);
+            }
+            return this.parseRipgrepOutput(stdout, options.maxResults);
+        }
+        catch (error) {
+            // ripgrep returns exit code 1 when no matches found
+            if (error.code === 1) {
+                return [];
+            }
+            // ripgrep not installed
+            if (error.code === 127 || error.message.includes('command not found')) {
+                logger_1.logger.error('ripgrep not installed');
+                throw new Error('ripgrep is not installed. Please install it: https://github.com/BurntSushi/ripgrep');
+            }
+            // Timeout
+            if (error.killed) {
+                logger_1.logger.error('Search timeout');
+                throw new Error('Search timeout exceeded');
+            }
+            logger_1.logger.error('Search failed:', error);
+            throw new Error(`Search failed: ${error.message}`);
+        }
+    }
+    /**
+     * Build ripgrep command arguments
+     */
+    buildRipgrepArgs(query, options) {
+        const args = [
+            '--json', // JSON output for easier parsing
+            '--line-number',
+            '--column',
+            '--no-heading',
+            '--with-filename',
+        ];
+        // Case sensitivity
+        if (!options.caseSensitive) {
+            args.push('--ignore-case');
+        }
+        // Regex mode
+        if (!options.regex) {
+            args.push('--fixed-strings');
+        }
+        // File type filter
+        if (options.fileType) {
+            args.push(`--type=${options.fileType}`);
+        }
+        // Max results
+        if (options.maxResults) {
+            args.push(`--max-count=${options.maxResults}`);
+        }
+        return args;
+    }
+    /**
+     * Parse ripgrep JSON output
+     */
+    parseRipgrepOutput(output, maxResults) {
+        const results = [];
+        const lines = output.split('\n').filter(l => l.trim());
+        for (const line of lines) {
+            try {
+                const json = JSON.parse(line);
+                // Only process match entries
+                if (json.type === 'match') {
+                    const data = json.data;
+                    const result = {
+                        file: data.path.text,
+                        line: data.line_number,
+                        column: data.submatches[0]?.start || 0,
+                        content: data.lines.text.trim(),
+                        match: data.submatches[0]?.match?.text || '',
+                    };
+                    results.push(result);
+                    // Stop if we've reached max results
+                    if (maxResults && results.length >= maxResults) {
+                        break;
+                    }
+                }
+            }
+            catch (error) {
+                logger_1.logger.warn('Failed to parse ripgrep line:', line, error);
+            }
+        }
+        return results;
+    }
+    /**
+     * Check if ripgrep is installed
+     */
+    async isRipgrepInstalled() {
+        try {
+            await execAsync('rg --version');
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+}
+exports.SearchService = SearchService;
+exports.searchService = new SearchService();