codebot-ai 1.3.0 → 1.4.0

package/dist/tools/database.js

@@ -0,0 +1,129 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseTool = void 0;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const BLOCKED_SQL = [
+    /\bDROP\s+(TABLE|DATABASE|INDEX|VIEW)\b/i,
+    /\bDELETE\s+FROM\b/i,
+    /\bTRUNCATE\b/i,
+    /\bALTER\s+TABLE\s+.*\bDROP\b/i,
+];
+class DatabaseTool {
+    name = 'database';
+    description = 'Query SQLite databases. Actions: query, tables, schema, info. Blocks DROP/DELETE/TRUNCATE for safety.';
+    permission = 'prompt';
+    parameters = {
+        type: 'object',
+        properties: {
+            action: { type: 'string', description: 'Action: query, tables, schema, info' },
+            db: { type: 'string', description: 'Path to SQLite database file' },
+            sql: { type: 'string', description: 'SQL query to execute (for "query" action)' },
+            table: { type: 'string', description: 'Table name (for "schema" action)' },
+        },
+        required: ['action', 'db'],
+    };
+    async execute(args) {
+        const action = args.action;
+        const dbPath = args.db;
+        if (!action)
+            return 'Error: action is required';
+        if (!dbPath)
+            return 'Error: db path is required';
+        if (!fs.existsSync(dbPath))
+            return `Error: database not found: ${dbPath}`;
+        switch (action) {
+            case 'query': return this.runQuery(dbPath, args);
+            case 'tables': return this.listTables(dbPath);
+            case 'schema': return this.showSchema(dbPath, args);
+            case 'info': return this.dbInfo(dbPath);
+            default: return `Error: unknown action "${action}". Use: query, tables, schema, info`;
+        }
+    }
+    runQuery(dbPath, args) {
+        const sql = args.sql;
+        if (!sql)
+            return 'Error: sql is required for query';
+        // Block destructive queries
+        for (const pattern of BLOCKED_SQL) {
+            if (pattern.test(sql)) {
+                return `Error: destructive SQL blocked for safety. Pattern matched: ${pattern.source}`;
+            }
+        }
+        return this.sqlite(dbPath, sql);
+    }
+    listTables(dbPath) {
+        return this.sqlite(dbPath, ".tables");
+    }
+    showSchema(dbPath, args) {
+        const table = args.table;
+        if (table) {
+            // Sanitize table name
+            if (!/^[a-zA-Z_]\w*$/.test(table))
+                return 'Error: invalid table name';
+            return this.sqlite(dbPath, `.schema ${table}`);
+        }
+        return this.sqlite(dbPath, ".schema");
+    }
+    dbInfo(dbPath) {
+        const stat = fs.statSync(dbPath);
+        const sizeMB = (stat.size / (1024 * 1024)).toFixed(2);
+        const tables = this.sqlite(dbPath, "SELECT name FROM sqlite_master WHERE type='table' ORDER BY name;");
+        return `Database: ${dbPath}\nSize: ${sizeMB} MB\nModified: ${stat.mtime.toISOString()}\n\nTables:\n${tables}`;
+    }
+    sqlite(dbPath, command) {
+        try {
+            // Try sqlite3 CLI first
+            const output = (0, child_process_1.execSync)(`sqlite3 "${dbPath}" "${command.replace(/"/g, '\\"')}"`, {
+                timeout: 15_000,
+                maxBuffer: 1024 * 1024,
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            return output.trim() || '(no results)';
+        }
+        catch (err) {
+            const e = err;
+            const msg = (e.stderr || '').trim();
+            if (msg.includes('not found')) {
+                return 'Error: sqlite3 is not installed. Install it with: brew install sqlite (macOS) or apt install sqlite3 (Linux)';
+            }
+            return `Error: ${msg || 'query failed'}`;
+        }
+    }
+}
+exports.DatabaseTool = DatabaseTool;
+//# sourceMappingURL=database.js.map

package/dist/tools/diff-viewer.d.ts

@@ -0,0 +1,39 @@
+import { Tool } from '../types';
+export declare class DiffViewerTool implements Tool {
+    name: string;
+    description: string;
+    permission: Tool['permission'];
+    parameters: {
+        type: string;
+        properties: {
+            action: {
+                type: string;
+                description: string;
+            };
+            file_a: {
+                type: string;
+                description: string;
+            };
+            file_b: {
+                type: string;
+                description: string;
+            };
+            path: {
+                type: string;
+                description: string;
+            };
+            ref: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(args: Record<string, unknown>): Promise<string>;
+    private diffFiles;
+    private gitDiff;
+    private gitStaged;
+    private gitCommitDiff;
+    private runGit;
+}
+//# sourceMappingURL=diff-viewer.d.ts.map

package/dist/tools/diff-viewer.js

@@ -0,0 +1,145 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiffViewerTool = void 0;
+const fs = __importStar(require("fs"));
+const child_process_1 = require("child_process");
+class DiffViewerTool {
+    name = 'diff_viewer';
+    description = 'View diffs. Actions: files (compare two files), git_diff (working tree changes), staged (staged changes), commit (show a commit diff).';
+    permission = 'auto';
+    parameters = {
+        type: 'object',
+        properties: {
+            action: { type: 'string', description: 'Action: files, git_diff, staged, commit' },
+            file_a: { type: 'string', description: 'First file path (for "files" action)' },
+            file_b: { type: 'string', description: 'Second file path (for "files" action)' },
+            path: { type: 'string', description: 'File or directory to diff (for git_diff/staged)' },
+            ref: { type: 'string', description: 'Commit hash or ref (for "commit" action)' },
+        },
+        required: ['action'],
+    };
+    async execute(args) {
+        const action = args.action;
+        if (!action)
+            return 'Error: action is required';
+        switch (action) {
+            case 'files': return this.diffFiles(args);
+            case 'git_diff': return this.gitDiff(args);
+            case 'staged': return this.gitStaged(args);
+            case 'commit': return this.gitCommitDiff(args);
+            default: return `Error: unknown action "${action}". Use: files, git_diff, staged, commit`;
+        }
+    }
+    diffFiles(args) {
+        const fileA = args.file_a;
+        const fileB = args.file_b;
+        if (!fileA || !fileB)
+            return 'Error: file_a and file_b are required';
+        let contentA, contentB;
+        try {
+            contentA = fs.readFileSync(fileA, 'utf-8');
+        }
+        catch {
+            return `Error: cannot read ${fileA}`;
+        }
+        try {
+            contentB = fs.readFileSync(fileB, 'utf-8');
+        }
+        catch {
+            return `Error: cannot read ${fileB}`;
+        }
+        const linesA = contentA.split('\n');
+        const linesB = contentB.split('\n');
+        const diff = [`--- ${fileA}`, `+++ ${fileB}`];
+        // Simple line-by-line diff
+        const maxLen = Math.max(linesA.length, linesB.length);
+        let changes = 0;
+        for (let i = 0; i < maxLen; i++) {
+            const a = linesA[i];
+            const b = linesB[i];
+            if (a === undefined && b !== undefined) {
+                diff.push(`+${i + 1}: ${b}`);
+                changes++;
+            }
+            else if (b === undefined && a !== undefined) {
+                diff.push(`-${i + 1}: ${a}`);
+                changes++;
+            }
+            else if (a !== b) {
+                diff.push(`-${i + 1}: ${a}`);
+                diff.push(`+${i + 1}: ${b}`);
+                changes++;
+            }
+        }
+        if (changes === 0)
+            return 'Files are identical.';
+        return `${changes} line(s) differ:\n${diff.join('\n')}`;
+    }
+    gitDiff(args) {
+        const target = args.path || '';
+        return this.runGit(`diff ${target}`.trim());
+    }
+    gitStaged(args) {
+        const target = args.path || '';
+        return this.runGit(`diff --staged ${target}`.trim());
+    }
+    gitCommitDiff(args) {
+        const ref = args.ref;
+        if (!ref)
+            return 'Error: ref (commit hash) is required';
+        // Sanitize ref
+        if (!/^[a-zA-Z0-9_\-./~^]+$/.test(ref))
+            return 'Error: invalid ref format';
+        return this.runGit(`show --stat --patch ${ref}`);
+    }
+    runGit(cmd) {
+        try {
+            const output = (0, child_process_1.execSync)(`git ${cmd}`, {
+                timeout: 15_000,
+                maxBuffer: 1024 * 1024,
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            return output.trim() || 'No changes.';
+        }
+        catch (err) {
+            const e = err;
+            return `Error: ${(e.stderr || 'git command failed').trim()}`;
+        }
+    }
+}
+exports.DiffViewerTool = DiffViewerTool;
+//# sourceMappingURL=diff-viewer.js.map

package/dist/tools/docker.d.ts

@@ -0,0 +1,26 @@
+import { Tool } from '../types';
+export declare class DockerTool implements Tool {
+    name: string;
+    description: string;
+    permission: Tool['permission'];
+    parameters: {
+        type: string;
+        properties: {
+            action: {
+                type: string;
+                description: string;
+            };
+            args: {
+                type: string;
+                description: string;
+            };
+            cwd: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(args: Record<string, unknown>): Promise<string>;
+}
+//# sourceMappingURL=docker.d.ts.map

package/dist/tools/docker.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DockerTool = void 0;
+const child_process_1 = require("child_process");
+const ALLOWED_ACTIONS = [
+    'ps', 'images', 'run', 'stop', 'rm', 'build', 'logs', 'exec',
+    'compose_up', 'compose_down', 'compose_ps', 'inspect', 'pull',
+];
+class DockerTool {
+    name = 'docker';
+    description = 'Run Docker operations. Actions: ps, images, run, stop, rm, build, logs, exec, compose_up, compose_down, compose_ps, inspect, pull.';
+    permission = 'prompt';
+    parameters = {
+        type: 'object',
+        properties: {
+            action: { type: 'string', description: 'Docker action to perform' },
+            args: { type: 'string', description: 'Additional arguments (image name, container ID, etc.)' },
+            cwd: { type: 'string', description: 'Working directory for compose commands' },
+        },
+        required: ['action'],
+    };
+    async execute(args) {
+        const action = args.action;
+        if (!action)
+            return 'Error: action is required';
+        if (!ALLOWED_ACTIONS.includes(action)) {
+            return `Error: unknown action "${action}". Allowed: ${ALLOWED_ACTIONS.join(', ')}`;
+        }
+        const extra = args.args || '';
+        const cwd = args.cwd || process.cwd();
+        // Build the command
+        let cmd;
+        switch (action) {
+            case 'ps':
+                cmd = `docker ps ${extra}`;
+                break;
+            case 'images':
+                cmd = `docker images ${extra}`;
+                break;
+            case 'run':
+                cmd = `docker run ${extra}`;
+                break;
+            case 'stop':
+                cmd = `docker stop ${extra}`;
+                break;
+            case 'rm':
+                cmd = `docker rm ${extra}`;
+                break;
+            case 'build':
+                cmd = `docker build ${extra}`;
+                break;
+            case 'logs':
+                cmd = `docker logs --tail 100 ${extra}`;
+                break;
+            case 'exec':
+                cmd = `docker exec ${extra}`;
+                break;
+            case 'inspect':
+                cmd = `docker inspect ${extra}`;
+                break;
+            case 'pull':
+                cmd = `docker pull ${extra}`;
+                break;
+            case 'compose_up':
+                cmd = `docker compose up -d ${extra}`;
+                break;
+            case 'compose_down':
+                cmd = `docker compose down ${extra}`;
+                break;
+            case 'compose_ps':
+                cmd = `docker compose ps ${extra}`;
+                break;
+            default: return `Error: unhandled action "${action}"`;
+        }
+        // Safety: block --privileged and dangerous volume mounts
+        if (/--privileged/.test(cmd))
+            return 'Error: --privileged flag is blocked for safety.';
+        if (/-v\s+\/:\//i.test(cmd))
+            return 'Error: mounting root filesystem is blocked for safety.';
+        try {
+            const output = (0, child_process_1.execSync)(cmd, {
+                cwd,
+                timeout: 60_000,
+                maxBuffer: 2 * 1024 * 1024,
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            return output.trim() || '(no output)';
+        }
+        catch (err) {
+            const e = err;
+            const msg = (e.stderr || e.stdout || 'command failed').trim();
+            if (msg.includes('not found') || msg.includes('Cannot connect')) {
+                return 'Error: Docker is not installed or not running. Install Docker Desktop or start the Docker daemon.';
+            }
+            return `Exit ${e.status || 1}: ${msg}`;
+        }
+    }
+}
+exports.DockerTool = DockerTool;
+//# sourceMappingURL=docker.js.map

package/dist/tools/git.d.ts

@@ -0,0 +1,26 @@
+import { Tool } from '../types';
+export declare class GitTool implements Tool {
+    name: string;
+    description: string;
+    permission: Tool['permission'];
+    parameters: {
+        type: string;
+        properties: {
+            action: {
+                type: string;
+                description: string;
+            };
+            args: {
+                type: string;
+                description: string;
+            };
+            cwd: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(args: Record<string, unknown>): Promise<string>;
+}
+//# sourceMappingURL=git.d.ts.map

package/dist/tools/git.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitTool = void 0;
+const child_process_1 = require("child_process");
+const ALLOWED_ACTIONS = [
+    'status', 'diff', 'log', 'commit', 'branch', 'checkout',
+    'stash', 'push', 'pull', 'merge', 'blame', 'tag', 'add', 'reset',
+];
+class GitTool {
+    name = 'git';
+    description = 'Run git operations. Actions: status, diff, log, commit, branch, checkout, stash, push, pull, merge, blame, tag, add, reset.';
+    permission = 'prompt';
+    parameters = {
+        type: 'object',
+        properties: {
+            action: { type: 'string', description: 'Git action (status, diff, log, commit, branch, checkout, stash, push, pull, merge, blame, tag, add, reset)' },
+            args: { type: 'string', description: 'Additional arguments (e.g., file path, branch name, commit message)' },
+            cwd: { type: 'string', description: 'Working directory (defaults to current)' },
+        },
+        required: ['action'],
+    };
+    async execute(args) {
+        const action = args.action;
+        if (!action)
+            return 'Error: action is required';
+        if (!ALLOWED_ACTIONS.includes(action)) {
+            return `Error: unknown action "${action}". Allowed: ${ALLOWED_ACTIONS.join(', ')}`;
+        }
+        const extra = args.args || '';
+        const cwd = args.cwd || process.cwd();
+        // Block destructive force operations
+        const fullCmd = `git ${action} ${extra}`.trim();
+        if (/--force\s+.*(main|master)/i.test(fullCmd)) {
+            return 'Error: force push to main/master is blocked for safety.';
+        }
+        if (/clean\s+-[a-z]*f/i.test(fullCmd)) {
+            return 'Error: git clean -f is blocked for safety.';
+        }
+        try {
+            const output = (0, child_process_1.execSync)(fullCmd, {
+                cwd,
+                timeout: 30_000,
+                maxBuffer: 1024 * 1024,
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            return output.trim() || '(no output)';
+        }
+        catch (err) {
+            const e = err;
+            const stderr = (e.stderr || '').trim();
+            const stdout = (e.stdout || '').trim();
+            return `Exit ${e.status || 1}${stdout ? `\n${stdout}` : ''}${stderr ? `\nError: ${stderr}` : ''}`;
+        }
+    }
+}
+exports.GitTool = GitTool;
+//# sourceMappingURL=git.js.map

package/dist/tools/http-client.d.ts

@@ -0,0 +1,39 @@
+import { Tool } from '../types';
+export declare class HttpClientTool implements Tool {
+    name: string;
+    description: string;
+    permission: Tool['permission'];
+    parameters: {
+        type: string;
+        properties: {
+            method: {
+                type: string;
+                description: string;
+            };
+            url: {
+                type: string;
+                description: string;
+            };
+            headers: {
+                type: string;
+                description: string;
+            };
+            body: {
+                type: string;
+                description: string;
+            };
+            auth: {
+                type: string;
+                description: string;
+            };
+            timeout: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(args: Record<string, unknown>): Promise<string>;
+    private isBlocked;
+}
+//# sourceMappingURL=http-client.d.ts.map

package/dist/tools/http-client.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClientTool = void 0;
+class HttpClientTool {
+    name = 'http_client';
+    description = 'Make HTTP requests. Supports GET, POST, PUT, DELETE, PATCH with headers, auth, and body.';
+    permission = 'prompt';
+    parameters = {
+        type: 'object',
+        properties: {
+            method: { type: 'string', description: 'HTTP method: GET, POST, PUT, DELETE, PATCH, HEAD (default: GET)' },
+            url: { type: 'string', description: 'Full URL to request' },
+            headers: { type: 'object', description: 'Request headers as key-value pairs' },
+            body: { type: 'string', description: 'Request body (JSON string or plain text)' },
+            auth: { type: 'string', description: 'Authorization header value (e.g., "Bearer token123")' },
+            timeout: { type: 'number', description: 'Timeout in ms (default: 30000)' },
+        },
+        required: ['url'],
+    };
+    async execute(args) {
+        const url = args.url;
+        if (!url)
+            return 'Error: url is required';
+        // Validate URL
+        let parsedUrl;
+        try {
+            parsedUrl = new URL(url);
+        }
+        catch {
+            return `Error: invalid URL: ${url}`;
+        }
+        // Block private IPs and file protocol
+        if (this.isBlocked(parsedUrl)) {
+            return 'Error: requests to private/local addresses are blocked for security.';
+        }
+        const method = (args.method || 'GET').toUpperCase();
+        const timeoutMs = args.timeout || 30_000;
+        const headers = {};
+        // Set headers
+        if (args.headers && typeof args.headers === 'object') {
+            for (const [k, v] of Object.entries(args.headers)) {
+                headers[k] = String(v);
+            }
+        }
+        if (args.auth) {
+            headers['Authorization'] = args.auth;
+        }
+        // Auto-set content type for body
+        const body = args.body;
+        if (body && !headers['Content-Type'] && !headers['content-type']) {
+            try {
+                JSON.parse(body);
+                headers['Content-Type'] = 'application/json';
+            }
+            catch { /* leave as-is */ }
+        }
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const res = await fetch(url, {
+                method,
+                headers,
+                body: ['GET', 'HEAD'].includes(method) ? undefined : body,
+                signal: controller.signal,
+            });
+            const contentType = res.headers.get('content-type') || '';
+            let responseBody;
+            try {
+                responseBody = await res.text();
+            }
+            finally {
+                clearTimeout(timer);
+            }
+            // Try to pretty-print JSON
+            if (contentType.includes('json') || responseBody.startsWith('{') || responseBody.startsWith('[')) {
+                try {
+                    const parsed = JSON.parse(responseBody);
+                    responseBody = JSON.stringify(parsed, null, 2);
+                }
+                catch { /* keep raw */ }
+            }
+            // Truncate huge responses
+            if (responseBody.length > 10_000) {
+                responseBody = responseBody.substring(0, 10_000) + '\n...(truncated)';
+            }
+            const headerLines = Array.from(res.headers.entries())
+                .slice(0, 10)
+                .map(([k, v]) => `  ${k}: ${v}`)
+                .join('\n');
+            return `${res.status} ${res.statusText}\n\nHeaders:\n${headerLines}\n\nBody:\n${responseBody}`;
+        }
+        catch (err) {
+            clearTimeout(timer);
+            const msg = err instanceof Error ? err.message : String(err);
+            if (msg.includes('abort'))
+                return `Error: request timed out after ${timeoutMs}ms`;
+            return `Error: ${msg}`;
+        }
+    }
+    isBlocked(url) {
+        const host = url.hostname.toLowerCase();
+        if (url.protocol === 'file:')
+            return true;
+        if (host === 'localhost' || host === '127.0.0.1' || host === '::1' || host === '0.0.0.0')
+            return true;
+        if (host === '169.254.169.254')
+            return true; // cloud metadata
+        if (/^10\./.test(host) || /^192\.168\./.test(host) || /^172\.(1[6-9]|2\d|3[01])\./.test(host))
+            return true;
+        return false;
+    }
+}
+exports.HttpClientTool = HttpClientTool;
+//# sourceMappingURL=http-client.js.map