@ruvnet/open-claude-code 2.0.0

package/src/tools/bash.mjs

@@ -0,0 +1,148 @@
+/**
+ * Bash Tool — matches Claude Code's exact behavior.
+ *
+ * Features:
+ * - Timeout with SIGTERM -> SIGKILL escalation
+ * - run_in_background option
+ * - description parameter
+ * - 1MB output limit
+ * - ANSI code stripping by default
+ */
+import { spawn } from 'child_process';
+
+// Strip ANSI escape sequences
+function stripAnsi(str) {
+    // eslint-disable-next-line no-control-regex
+    return str.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '');
+}
+
+const MAX_OUTPUT_BYTES = 1024 * 1024; // 1MB
+
+export const BashTool = {
+    name: 'Bash',
+    description: 'Execute a bash command and return its output.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            command: { type: 'string', description: 'The command to execute' },
+            timeout: { type: 'number', description: 'Timeout in ms (max 600000)', default: 120000 },
+            description: { type: 'string', description: 'Description of what this command does' },
+            run_in_background: { type: 'boolean', description: 'Run in background', default: false },
+        },
+        required: ['command'],
+    },
+    validateInput(input) {
+        const errors = [];
+        if (!input.command) errors.push('command is required');
+        return errors;
+    },
+    async call(input) {
+        const timeout = Math.min(input.timeout || 120000, 600000);
+
+        if (input.run_in_background) {
+            return runBackground(input.command);
+        }
+
+        return new Promise((resolve) => {
+            let stdout = '';
+            let stderr = '';
+            let killed = false;
+            let exitCode = null;
+
+            const proc = spawn('bash', ['-c', input.command], {
+                env: { ...process.env },
+                stdio: ['pipe', 'pipe', 'pipe'],
+                timeout: 0, // we handle timeout ourselves
+            });
+
+            proc.stdout.on('data', (chunk) => {
+                if (stdout.length < MAX_OUTPUT_BYTES) {
+                    stdout += chunk.toString();
+                }
+            });
+
+            proc.stderr.on('data', (chunk) => {
+                if (stderr.length < MAX_OUTPUT_BYTES) {
+                    stderr += chunk.toString();
+                }
+            });
+
+            // Timeout: SIGTERM first, then SIGKILL after 5s
+            const timer = setTimeout(() => {
+                killed = true;
+                proc.kill('SIGTERM');
+                setTimeout(() => {
+                    try { proc.kill('SIGKILL'); } catch { /* already dead */ }
+                }, 5000);
+            }, timeout);
+
+            proc.on('close', (code) => {
+                clearTimeout(timer);
+                exitCode = code;
+
+                // Truncate if over limit
+                if (stdout.length > MAX_OUTPUT_BYTES) {
+                    stdout = stdout.slice(0, MAX_OUTPUT_BYTES) + '\n[output truncated at 1MB]';
+                }
+                if (stderr.length > MAX_OUTPUT_BYTES) {
+                    stderr = stderr.slice(0, MAX_OUTPUT_BYTES) + '\n[output truncated at 1MB]';
+                }
+
+                // Strip ANSI by default
+                stdout = stripAnsi(stdout);
+                stderr = stripAnsi(stderr);
+
+                if (killed) {
+                    resolve(`Error: Command timed out after ${timeout}ms\n${stdout}\n${stderr}`.trim());
+                    return;
+                }
+
+                const output = (stdout + (stderr ? '\n' + stderr : '')).trim();
+                if (code !== 0) {
+                    resolve(`Exit code: ${code}\n${output}`.trim());
+                } else {
+                    resolve(output || '(no output)');
+                }
+            });
+
+            proc.on('error', (err) => {
+                clearTimeout(timer);
+                resolve(`Error: ${err.message}`);
+            });
+
+            // Close stdin
+            proc.stdin.end();
+        });
+    },
+};
+
+// Background jobs store
+const backgroundJobs = new Map();
+let bgJobId = 0;
+
+function runBackground(command) {
+    const id = ++bgJobId;
+    const proc = spawn('bash', ['-c', command], {
+        detached: true,
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+    proc.stdout.on('data', (d) => { stdout += d.toString(); });
+    proc.stderr.on('data', (d) => { stderr += d.toString(); });
+
+    const job = { id, pid: proc.pid, command, status: 'running', stdout: '', stderr: '' };
+    backgroundJobs.set(id, job);
+
+    proc.on('close', (code) => {
+        job.status = code === 0 ? 'completed' : `exited(${code})`;
+        job.stdout = stripAnsi(stdout.slice(0, MAX_OUTPUT_BYTES));
+        job.stderr = stripAnsi(stderr.slice(0, MAX_OUTPUT_BYTES));
+    });
+
+    proc.unref();
+    return `Background job started: id=${id}, pid=${proc.pid}`;
+}
+
+export { backgroundJobs };

package/src/tools/cron-create.mjs

@@ -0,0 +1,120 @@
+/**
+ * CronCreate Tool — create a scheduled task.
+ *
+ * Stores cron definitions in memory and optionally persists them
+ * to ~/.claude/cron.json. Uses setTimeout-based scheduling for
+ * the duration of the session.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+// Shared cron store
+export const cronStore = new Map();
+let cronIdCounter = 1;
+
+export const CronCreateTool = {
+    name: 'CronCreate',
+    description: 'Create a scheduled task that runs on a cron schedule.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            name: { type: 'string', description: 'Name for the scheduled task' },
+            schedule: {
+                type: 'string',
+                description: 'Cron expression (e.g., "*/5 * * * *") or interval (e.g., "5m", "1h")',
+            },
+            command: {
+                type: 'string',
+                description: 'Command or prompt to execute on schedule',
+            },
+            type: {
+                type: 'string',
+                enum: ['command', 'prompt'],
+                description: 'Whether to run as shell command or agent prompt',
+            },
+        },
+        required: ['name', 'schedule', 'command'],
+    },
+
+    validateInput(input) {
+        const errors = [];
+        if (!input.name) errors.push('name is required');
+        if (!input.schedule) errors.push('schedule is required');
+        if (!input.command) errors.push('command is required');
+        return errors;
+    },
+
+    async call(input) {
+        if (process.env.CLAUDE_CODE_DISABLE_CRON === '1') {
+            return 'Cron tasks are disabled (CLAUDE_CODE_DISABLE_CRON=1)';
+        }
+
+        const id = `cron_${cronIdCounter++}`;
+        const intervalMs = parseSchedule(input.schedule);
+
+        const job = {
+            id,
+            name: input.name,
+            schedule: input.schedule,
+            command: input.command,
+            type: input.type || 'command',
+            intervalMs,
+            createdAt: new Date().toISOString(),
+            lastRun: null,
+            runCount: 0,
+            timer: null,
+        };
+
+        // Set up interval timer
+        if (intervalMs > 0) {
+            job.timer = setInterval(() => {
+                job.lastRun = new Date().toISOString();
+                job.runCount++;
+                // Execution is handled by the cron runner in the main loop
+            }, intervalMs);
+        }
+
+        cronStore.set(id, job);
+        persistCronJobs();
+
+        return `Created scheduled task:\n  ID: ${id}\n  Name: ${input.name}\n  Schedule: ${input.schedule}\n  Interval: ${intervalMs}ms\n  Type: ${job.type}`;
+    },
+};
+
+/**
+ * Parse a schedule string into milliseconds.
+ * Supports cron shorthand: "5m", "1h", "30s", "1d"
+ */
+function parseSchedule(schedule) {
+    const match = schedule.match(/^(\d+)(s|m|h|d)$/);
+    if (match) {
+        const value = parseInt(match[1], 10);
+        const units = { s: 1000, m: 60000, h: 3600000, d: 86400000 };
+        return value * (units[match[2]] || 60000);
+    }
+    // Default: treat as minutes for simple numbers
+    const num = parseInt(schedule, 10);
+    if (!isNaN(num)) return num * 60000;
+    // For full cron expressions, default to 5 minutes
+    return 300000;
+}
+
+function persistCronJobs() {
+    try {
+        const cronDir = path.join(os.homedir(), '.claude');
+        fs.mkdirSync(cronDir, { recursive: true });
+        const jobs = [];
+        for (const [, job] of cronStore) {
+            const { timer, ...rest } = job;
+            jobs.push(rest);
+        }
+        fs.writeFileSync(
+            path.join(cronDir, 'cron.json'),
+            JSON.stringify(jobs, null, 2)
+        );
+    } catch {
+        // Best effort
+    }
+}

package/src/tools/cron-delete.mjs

@@ -0,0 +1,49 @@
+/**
+ * CronDelete Tool — delete a scheduled task.
+ */
+
+import { cronStore } from './cron-create.mjs';
+
+export const CronDeleteTool = {
+    name: 'CronDelete',
+    description: 'Delete a scheduled task by ID or name.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            id: { type: 'string', description: 'Cron job ID to delete' },
+            name: { type: 'string', description: 'Cron job name to delete (alternative to id)' },
+        },
+        required: [],
+    },
+
+    validateInput(input) {
+        if (!input.id && !input.name) return ['Either id or name is required'];
+        return [];
+    },
+
+    async call(input) {
+        let target = null;
+
+        if (input.id) {
+            target = cronStore.get(input.id);
+        } else if (input.name) {
+            for (const [, job] of cronStore) {
+                if (job.name === input.name) {
+                    target = job;
+                    break;
+                }
+            }
+        }
+
+        if (!target) {
+            return `No cron job found matching ${input.id || input.name}`;
+        }
+
+        if (target.timer) {
+            clearInterval(target.timer);
+        }
+        cronStore.delete(target.id);
+
+        return `Deleted cron job: ${target.id} (${target.name})`;
+    },
+};

package/src/tools/cron-list.mjs

@@ -0,0 +1,37 @@
+/**
+ * CronList Tool — list all scheduled tasks.
+ */
+
+import { cronStore } from './cron-create.mjs';
+
+export const CronListTool = {
+    name: 'CronList',
+    description: 'List all scheduled tasks.',
+    inputSchema: {
+        type: 'object',
+        properties: {},
+        required: [],
+    },
+
+    validateInput() { return []; },
+
+    async call() {
+        if (cronStore.size === 0) {
+            return 'No scheduled tasks.';
+        }
+
+        const lines = [];
+        for (const [, job] of cronStore) {
+            lines.push(
+                `  ${job.id}: ${job.name}\n` +
+                `    Schedule: ${job.schedule} (${job.intervalMs}ms)\n` +
+                `    Type: ${job.type}\n` +
+                `    Runs: ${job.runCount}\n` +
+                `    Last: ${job.lastRun || 'never'}\n` +
+                `    Created: ${job.createdAt}`
+            );
+        }
+
+        return `Scheduled tasks (${cronStore.size}):\n${lines.join('\n\n')}`;
+    },
+};

package/src/tools/edit.mjs

@@ -0,0 +1,82 @@
+/**
+ * Edit Tool — matches Claude Code's exact behavior.
+ *
+ * Features:
+ * - replace_all parameter for global replacement
+ * - Verify old_string is unique (error if not)
+ * - Require file was Read first (track read files)
+ * - Preserve exact indentation
+ */
+import fs from 'fs';
+import path from 'path';
+import { hasBeenRead, markRead } from './read.mjs';
+
+export const EditTool = {
+    name: 'Edit',
+    description: 'Performs exact string replacements in files.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            file_path: { type: 'string', description: 'Absolute path to the file' },
+            old_string: { type: 'string', description: 'The text to replace' },
+            new_string: { type: 'string', description: 'The replacement text' },
+            replace_all: { type: 'boolean', description: 'Replace all occurrences', default: false },
+        },
+        required: ['file_path', 'old_string', 'new_string'],
+    },
+    validateInput(input) {
+        const errors = [];
+        if (!input.file_path) errors.push('file_path required');
+        if (!input.old_string && input.old_string !== '') errors.push('old_string required');
+        if (input.old_string === input.new_string) errors.push('old_string must differ from new_string');
+        return errors;
+    },
+    async call(input) {
+        const filePath = path.resolve(input.file_path);
+
+        // Check file exists
+        if (!fs.existsSync(filePath)) {
+            return `Error: File not found: ${filePath}`;
+        }
+
+        // Require file was read first
+        if (!hasBeenRead(filePath)) {
+            return `Error: You must Read ${filePath} before editing it. Use the Read tool first.`;
+        }
+
+        let content;
+        try {
+            content = fs.readFileSync(filePath, 'utf-8');
+        } catch (e) {
+            return `Error: ${e.message}`;
+        }
+
+        if (!content.includes(input.old_string)) {
+            return 'Error: old_string not found in file. Make sure the string matches exactly, including whitespace and indentation.';
+        }
+
+        if (input.replace_all) {
+            // Replace all occurrences
+            const escaped = input.old_string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            content = content.replace(new RegExp(escaped, 'g'), input.new_string);
+        } else {
+            // Check uniqueness: old_string must appear exactly once
+            const firstIdx = content.indexOf(input.old_string);
+            const secondIdx = content.indexOf(input.old_string, firstIdx + 1);
+            if (secondIdx !== -1) {
+                const count = content.split(input.old_string).length - 1;
+                return `Error: old_string is not unique in the file (found ${count} occurrences). Provide more context to make it unique, or use replace_all to replace all occurrences.`;
+            }
+            content = content.replace(input.old_string, input.new_string);
+        }
+
+        try {
+            fs.writeFileSync(filePath, content);
+            // Keep it marked as read
+            markRead(filePath);
+            return `File updated: ${filePath}`;
+        } catch (e) {
+            return `Error writing file: ${e.message}`;
+        }
+    },
+};

package/src/tools/enter-worktree.mjs

@@ -0,0 +1,69 @@
+/**
+ * EnterWorktree Tool — create and enter a git worktree for isolation.
+ *
+ * Creates a temporary worktree branch so edits do not affect the main branch.
+ */
+
+import { execSync } from 'child_process';
+import path from 'path';
+import os from 'os';
+
+export const EnterWorktreeTool = {
+    name: 'EnterWorktree',
+    description: 'Create a git worktree for isolated file editing.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            branch: {
+                type: 'string',
+                description: 'Branch name for the worktree (auto-generated if omitted)',
+            },
+            path: {
+                type: 'string',
+                description: 'Directory for the worktree (temp dir if omitted)',
+            },
+        },
+        required: [],
+    },
+
+    // Shared state for active worktree
+    _activeWorktree: null,
+
+    validateInput() { return []; },
+
+    async call(input) {
+        if (this._activeWorktree) {
+            return `Already in worktree at ${this._activeWorktree.path}. Use ExitWorktree first.`;
+        }
+
+        try {
+            // Verify we are in a git repo
+            execSync('git rev-parse --is-inside-work-tree', { encoding: 'utf-8' });
+        } catch {
+            return 'Error: not inside a git repository';
+        }
+
+        const branch = input.branch || `occ-worktree-${Date.now()}`;
+        const worktreePath = input.path || path.join(os.tmpdir(), `occ-wt-${Date.now()}`);
+        const originalCwd = process.cwd();
+
+        try {
+            execSync(`git worktree add -b "${branch}" "${worktreePath}"`, {
+                encoding: 'utf-8',
+                stdio: 'pipe',
+            });
+
+            this._activeWorktree = {
+                path: worktreePath,
+                branch,
+                originalCwd,
+            };
+
+            process.chdir(worktreePath);
+
+            return `Entered worktree:\n  Branch: ${branch}\n  Path: ${worktreePath}\n  Original: ${originalCwd}`;
+        } catch (err) {
+            return `Error creating worktree: ${err.message}`;
+        }
+    },
+};

package/src/tools/exit-worktree.mjs

@@ -0,0 +1,57 @@
+/**
+ * ExitWorktree Tool — exit and clean up a git worktree.
+ */
+
+import { execSync } from 'child_process';
+
+export const ExitWorktreeTool = {
+    name: 'ExitWorktree',
+    description: 'Exit the current git worktree and return to the original directory.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            cleanup: {
+                type: 'boolean',
+                description: 'Remove the worktree branch after exiting (default: true)',
+            },
+        },
+        required: [],
+    },
+
+    validateInput() { return []; },
+
+    async call(input) {
+        const { EnterWorktreeTool } = await import('./enter-worktree.mjs');
+        const wt = EnterWorktreeTool._activeWorktree;
+
+        if (!wt) {
+            return 'Not currently in a worktree.';
+        }
+
+        const cleanup = input.cleanup !== false;
+
+        try {
+            process.chdir(wt.originalCwd);
+
+            if (cleanup) {
+                try {
+                    execSync(`git worktree remove "${wt.path}" --force`, {
+                        encoding: 'utf-8',
+                        stdio: 'pipe',
+                    });
+                    execSync(`git branch -D "${wt.branch}"`, {
+                        encoding: 'utf-8',
+                        stdio: 'pipe',
+                    });
+                } catch {
+                    // Best effort cleanup
+                }
+            }
+
+            EnterWorktreeTool._activeWorktree = null;
+            return `Exited worktree. Returned to ${wt.originalCwd}${cleanup ? ' (cleaned up)' : ''}`;
+        } catch (err) {
+            return `Error exiting worktree: ${err.message}`;
+        }
+    },
+};

package/src/tools/glob.mjs

@@ -0,0 +1,117 @@
+/**
+ * Glob Tool — matches Claude Code's exact behavior.
+ *
+ * Features:
+ * - Proper glob matching (not shell find)
+ * - Sort by modification time
+ * - path parameter for directory scoping
+ */
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Minimal glob implementation without external dependencies.
+ * Supports *, **, and ? wildcards.
+ */
+function globMatch(pattern, str) {
+    const regex = globToRegex(pattern);
+    return regex.test(str);
+}
+
+function globToRegex(pattern) {
+    let regex = '';
+    let i = 0;
+    while (i < pattern.length) {
+        const ch = pattern[i];
+        if (ch === '*') {
+            if (pattern[i + 1] === '*') {
+                // ** matches everything including /
+                regex += '.*';
+                i += 2;
+                if (pattern[i] === '/') i++; // skip trailing /
+                continue;
+            }
+            regex += '[^/]*';
+        } else if (ch === '?') {
+            regex += '[^/]';
+        } else if (ch === '.') {
+            regex += '\\.';
+        } else if (ch === '{') {
+            regex += '(';
+        } else if (ch === '}') {
+            regex += ')';
+        } else if (ch === ',') {
+            regex += '|';
+        } else {
+            regex += ch;
+        }
+        i++;
+    }
+    return new RegExp('^' + regex + '$');
+}
+
+function walkDir(dir, maxDepth = 20, depth = 0) {
+    const results = [];
+    if (depth > maxDepth) return results;
+    try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            // Skip hidden dirs and node_modules
+            if (entry.name.startsWith('.') && depth > 0) continue;
+            if (entry.name === 'node_modules') continue;
+
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                results.push(...walkDir(full, maxDepth, depth + 1));
+            } else {
+                results.push(full);
+            }
+        }
+    } catch {
+        // Permission denied or other error
+    }
+    return results;
+}
+
+export const GlobTool = {
+    name: 'Glob',
+    description: 'Find files matching a glob pattern, sorted by modification time.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            pattern: { type: 'string', description: 'Glob pattern (e.g. "**/*.js")' },
+            path: { type: 'string', description: 'Directory to search in' },
+        },
+        required: ['pattern'],
+    },
+    validateInput(input) { return input.pattern ? [] : ['pattern required']; },
+    async call(input) {
+        try {
+            const baseDir = path.resolve(input.path || '.');
+            if (!fs.existsSync(baseDir)) {
+                return `Error: Directory not found: ${baseDir}`;
+            }
+
+            const allFiles = walkDir(baseDir);
+
+            // Match against pattern
+            const matches = allFiles.filter(f => {
+                const rel = path.relative(baseDir, f);
+                return globMatch(input.pattern, rel) || globMatch(input.pattern, path.basename(f));
+            });
+
+            if (matches.length === 0) return 'No matches found.';
+
+            // Sort by modification time (newest first)
+            matches.sort((a, b) => {
+                try {
+                    return fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs;
+                } catch { return 0; }
+            });
+
+            return matches.join('\n');
+        } catch (e) {
+            return `Error: ${e.message}`;
+        }
+    },
+};