@syntero/orca-cli 1.3.2 → 1.3.3

package/dist/tools.js

@@ -1,774 +0,0 @@
-import { exec } from 'child_process';
-import { promisify } from 'util';
-const execAsync = promisify(exec);
-import * as fs from 'fs';
-import * as path from 'path';
-import Database from 'better-sqlite3';
-import { getDeploymentDir, saveDeploymentDir, getStoredDeploymentDir } from './settings.js';
-import { redactSecrets, isSecretKey } from './utils.js';
-import { dockerLoginGHCR, listDeploymentFiles, downloadDeploymentFile, isAuthenticated, loadCredentials, getSelectedCloudProvider, cloudRequest, } from './auth.js';
-// Re-export dangerous command detection for use by other modules
-export { detectDangerousCommand, checkCommand, allCategoriesApproved, } from './confirmation/index.js';
-// Tool definitions for Anthropic format
-export const TOOLS_ANTHROPIC = [
-    {
-        name: 'run_command',
-        description: `Execute a shell command and return output. Use for:
-- Docker commands: docker ps, docker logs, docker inspect, docker stats, docker network ls
-- System info: df -h, free -m, uname -a, whoami, id
-- File listing: ls -la <path>
-- Process info: ps aux | grep <pattern>
-- Network: netstat -tlnp, curl -I <url>
-
-Commands run with a 30-second timeout. For docker logs, use --tail to limit output.`,
-        input_schema: {
-            type: 'object',
-            properties: {
-                command: { type: 'string', description: 'The shell command to execute' },
-                gist: { type: 'string', description: 'A human-readable explanation of what this command does, written in 2-3 sentences. Explain the purpose, what it affects, and any important side effects. Example: "This command removes all Docker volumes with \'orca\' in the name. Any data stored in these volumes will be permanently deleted. This is typically used for a clean reinstall."' },
-            },
-            required: ['command', 'gist'],
-        },
-    },
-    {
-        name: 'read_file',
-        description: `Read the contents of a file. Use for config files, logs, etc.
-Paths can be absolute or relative to the deployment directory.
-Do not read .env directly - use inspect_env instead.`,
-        input_schema: {
-            type: 'object',
-            properties: {
-                path: { type: 'string', description: 'Path to the file' },
-                tail: { type: 'integer', description: 'Only return the last N lines' },
-            },
-            required: ['path'],
-        },
-    },
-    {
-        name: 'list_directory',
-        description: 'List contents of a directory with details.',
-        input_schema: {
-            type: 'object',
-            properties: {
-                path: { type: 'string', description: 'Directory path' },
-            },
-            required: ['path'],
-        },
-    },
-    {
-        name: 'inspect_env',
-        description: 'Safely inspect .env configuration with secrets redacted.',
-        input_schema: {
-            type: 'object',
-            properties: {
-                show_all: { type: 'boolean', description: 'Show all variables (secrets still redacted)' },
-            },
-        },
-    },
-    {
-        name: 'query_database',
-        description: 'Execute a READ-ONLY SQL query on the main SQLite database. Only SELECT allowed.',
-        input_schema: {
-            type: 'object',
-            properties: {
-                query: { type: 'string', description: 'SQL SELECT query to execute' },
-            },
-            required: ['query'],
-        },
-    },
-    {
-        name: 'search_logs',
-        description: 'Search through docker logs for a pattern.',
-        input_schema: {
-            type: 'object',
-            properties: {
-                container: { type: 'string', description: 'Container name' },
-                pattern: { type: 'string', description: 'Grep pattern to search for' },
-                case_insensitive: { type: 'boolean', description: 'Case insensitive search' },
-                context_lines: { type: 'integer', description: 'Context lines before/after match' },
-            },
-            required: ['container', 'pattern'],
-        },
-    },
-    {
-        name: 'check_container_health',
-        description: 'Get a comprehensive health report for Orca containers.',
-        input_schema: {
-            type: 'object',
-            properties: {
-                container: { type: 'string', description: "Container name or 'all'" },
-            },
-        },
-    },
-    {
-        name: 'grep_file',
-        description: `Search for a pattern in a file or directory using grep.
-Use for searching through:
-- Log files for errors or patterns
-- Config files for specific settings
-- Documentation like TROUBLESHOOTING.md for known issues
-- Any text file
-
-Returns matching lines with line numbers and optional context.`,
-        input_schema: {
-            type: 'object',
-            properties: {
-                pattern: { type: 'string', description: 'Regex pattern to search for' },
-                path: { type: 'string', description: 'File or directory path to search' },
-                case_insensitive: { type: 'boolean', description: 'Case insensitive search (default: true)' },
-                context_lines: { type: 'integer', description: 'Lines of context before and after each match' },
-            },
-            required: ['pattern', 'path'],
-        },
-    },
-    {
-        name: 'docker_login_ghcr',
-        description: `Authenticate with GitHub Container Registry (ghcr.io) to pull Orca images.
-This tool fetches GHCR credentials from the server and runs docker login.
-IMPORTANT: The user must be authenticated (/token) before this will work.
-Use this before pulling Orca images during installation.`,
-        input_schema: {
-            type: 'object',
-            properties: {},
-        },
-    },
-    {
-        name: 'download_deployment_files',
-        description: `Download Orca deployment files from the server for local installation.
-Downloads docker-compose.yml, .env.example, and other necessary configuration files.
-IMPORTANT: The user must be authenticated (/token) before this will work.
-Files are saved to the specified target directory.`,
-        input_schema: {
-            type: 'object',
-            properties: {
-                target_dir: { type: 'string', description: 'Directory to save deployment files (e.g., ~/orca or /opt/orca)' },
-            },
-            required: ['target_dir'],
-        },
-    },
-    {
-        name: 'check_auth_status',
-        description: 'Check if the user is authenticated with the Orca cloud platform. Returns authentication status, user email, organization ID (org_id), and the cloud provider being used. IMPORTANT: When creating users with manage_users.py, always use the org_id from this tool to ensure correct organization assignment.',
-        input_schema: {
-            type: 'object',
-            properties: {},
-            required: [],
-        },
-    },
-    {
-        name: 'save_deployment_dir',
-        description: `Save the Orca deployment directory path to settings.
-Use this after successful installation to remember where Orca is installed.
-This allows future update commands to find the installation automatically.`,
-        input_schema: {
-            type: 'object',
-            properties: {
-                path: { type: 'string', description: 'Absolute path to the Orca deployment directory (e.g., /home/user/orca or /opt/orca)' },
-            },
-            required: ['path'],
-        },
-    },
-    {
-        name: 'get_deployment_dir',
-        description: `Get the stored Orca deployment directory path from settings.
-Use this to find where Orca was previously installed.
-Returns the path if set, or a message indicating it's not set.
-If not set, ask the user for the deployment path.`,
-        input_schema: {
-            type: 'object',
-            properties: {},
-            required: [],
-        },
-    },
-    {
-        name: 'log_deployment_event',
-        description: `Log a deployment event (install, update, or rollback) to release_history.json in the deployment directory.
-Creates the file if it doesn't exist. Entries are stored newest-first.
-Call this after every successful or failed install/update/rollback.`,
-        input_schema: {
-            type: 'object',
-            properties: {
-                event: { type: 'string', enum: ['install', 'update', 'rollback'], description: 'Type of deployment event' },
-                version: { type: 'string', description: 'The version being deployed (e.g., "1.3.0" or "latest")' },
-                previous_version: { type: 'string', description: 'The version before this change (for updates/rollbacks)' },
-                status: { type: 'string', enum: ['success', 'failed', 'partial'], description: 'Outcome of the deployment' },
-                notes: { type: 'string', description: 'Free-text notes: issues encountered, manual steps taken, etc.' },
-            },
-            required: ['event', 'version', 'status'],
-        },
-    },
-    {
-        name: 'get_deployment_history',
-        description: `Read the deployment release history from release_history.json.
-Returns recent deployment events (install, update, rollback) with timestamps, versions, and notes.
-Use this before updates to identify the current version, or to review past deployments.`,
-        input_schema: {
-            type: 'object',
-            properties: {
-                limit: { type: 'integer', description: 'Maximum number of entries to return (default: 10)' },
-            },
-        },
-    },
-    {
-        name: 'recreate_containers',
-        description: `Recreate ALL containers (sandbox, runtime-data, neo4j) for a single organization.
-Removes and recreates all containers fresh. Preserves volumes (user data).
-Call this once per organization after updating Orca to pick up the new images.
-IMPORTANT: The user must be authenticated (/token) before this will work.`,
-        input_schema: {
-            type: 'object',
-            properties: {
-                org_id: {
-                    type: 'string',
-                    description: 'The organization ID to recreate containers for.',
-                },
-            },
-            required: ['org_id'],
-        },
-    },
-];
-// Convert to OpenAI format
-export const TOOLS_OPENAI = TOOLS_ANTHROPIC.map((tool) => ({
-    type: 'function',
-    function: {
-        name: tool.name,
-        description: tool.description,
-        parameters: tool.input_schema,
-    },
-}));
-/**
- * Resolve a path relative to deployment directory.
- */
-function resolvePath(filePath) {
-    const p = path.isAbsolute(filePath) ? filePath : path.join(getDeploymentDir(), filePath);
-    return p;
-}
-/**
- * Execute a shell command with timeout.
- *
- * Note: Dangerous command detection is now handled at a higher level
- * (assistant.ts/ChatApp.tsx) via the confirmation system. This function
- * executes commands directly - callers are responsible for confirming
- * dangerous commands before calling this.
- */
-export async function runCommand(command, timeout = 30000, signal) {
-    try {
-        const { stdout, stderr } = await execAsync(command, {
-            timeout,
-            encoding: 'utf-8',
-            cwd: getDeploymentDir(),
-            maxBuffer: 10 * 1024 * 1024,
-            signal,
-        });
-        let output = (stdout || '') + (stderr || '');
-        if (output.length > 50000) {
-            output = output.slice(0, 50000) + '\n... [truncated]';
-        }
-        return redactSecrets(output) || '(no output)';
-    }
-    catch (e) {
-        // Re-throw abort errors so they propagate up to end the turn
-        if (e instanceof Error && e.name === 'AbortError') {
-            throw e;
-        }
-        if (e && typeof e === 'object' && 'killed' in e && e.killed) {
-            return `Error: Command timed out after ${timeout / 1000} seconds`;
-        }
-        if (e && typeof e === 'object' && 'stderr' in e && 'stdout' in e) {
-            const execError = e;
-            const stderr = execError.stderr
-                ? typeof execError.stderr === 'string'
-                    ? execError.stderr
-                    : execError.stderr.toString()
-                : '';
-            const stdout = execError.stdout
-                ? typeof execError.stdout === 'string'
-                    ? execError.stdout
-                    : execError.stdout.toString()
-                : '';
-            const output = stdout + stderr;
-            return redactSecrets(output) || `Error: ${e instanceof Error ? e.message : String(e)}`;
-        }
-        return `Error: ${e instanceof Error ? e.message : String(e)}`;
-    }
-}
-/**
- * Read a file's contents.
- */
-export function readFile(filePath, tail) {
-    const resolved = resolvePath(filePath);
-    if (path.basename(resolved) === '.env' && !resolved.includes('.template')) {
-        return 'Error: Use inspect_env tool to safely view environment variables.';
-    }
-    try {
-        let content = fs.readFileSync(resolved, 'utf-8');
-        if (tail) {
-            const lines = content.split('\n');
-            content = lines.slice(-tail).join('\n');
-        }
-        if (content.length > 100000) {
-            content = content.slice(0, 100000) + '\n... [truncated]';
-        }
-        return content;
-    }
-    catch (e) {
-        if (e && typeof e === 'object' && 'code' in e && e.code === 'ENOENT') {
-            return `Error: File not found: ${resolved}`;
-        }
-        return `Error: ${e instanceof Error ? e.message : String(e)}`;
-    }
-}
-/**
- * Format file mode (permissions) as a string like 'drwxr-xr-x'.
- */
-function formatMode(mode, isDir, isLink) {
-    const typeChar = isLink ? 'l' : isDir ? 'd' : '-';
-    const perms = [
-        (mode & 0o400) ? 'r' : '-',
-        (mode & 0o200) ? 'w' : '-',
-        (mode & 0o100) ? 'x' : '-',
-        (mode & 0o040) ? 'r' : '-',
-        (mode & 0o020) ? 'w' : '-',
-        (mode & 0o010) ? 'x' : '-',
-        (mode & 0o004) ? 'r' : '-',
-        (mode & 0o002) ? 'w' : '-',
-        (mode & 0o001) ? 'x' : '-',
-    ].join('');
-    return typeChar + perms;
-}
-/**
- * Format file size in human-readable format.
- */
-function formatSize(size) {
-    return size.toString().padStart(8);
-}
-/**
- * Format date in ls-like format.
- */
-function formatDate(date) {
-    const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
-    const month = months[date.getMonth()];
-    const day = date.getDate().toString().padStart(2);
-    const hours = date.getHours().toString().padStart(2, '0');
-    const mins = date.getMinutes().toString().padStart(2, '0');
-    return `${month} ${day} ${hours}:${mins}`;
-}
-/**
- * List directory contents using Node.js fs APIs (cross-platform).
- */
-export function listDirectory(dirPath) {
-    const resolved = resolvePath(dirPath);
-    try {
-        const stats = fs.statSync(resolved);
-        if (!stats.isDirectory()) {
-            return `Error: Not a directory: ${resolved}`;
-        }
-        const entries = fs.readdirSync(resolved, { withFileTypes: true });
-        const lines = [];
-        lines.push(`total ${entries.length}`);
-        // Sort entries: directories first, then alphabetically
-        const sortedEntries = entries.sort((a, b) => {
-            if (a.isDirectory() && !b.isDirectory())
-                return -1;
-            if (!a.isDirectory() && b.isDirectory())
-                return 1;
-            return a.name.localeCompare(b.name);
-        });
-        for (const entry of sortedEntries) {
-            const fullPath = path.join(resolved, entry.name);
-            try {
-                const entryStats = fs.lstatSync(fullPath);
-                const mode = formatMode(entryStats.mode, entry.isDirectory(), entry.isSymbolicLink());
-                const size = formatSize(entryStats.size);
-                const date = formatDate(entryStats.mtime);
-                const name = entry.isSymbolicLink()
-                    ? `${entry.name} -> ${fs.readlinkSync(fullPath)}`
-                    : entry.name;
-                lines.push(`${mode}  ${size} ${date} ${name}`);
-            }
-            catch {
-                // If we can't stat the entry, show minimal info
-                lines.push(`??????????         ? ??? ?? ??:?? ${entry.name}`);
-            }
-        }
-        return lines.join('\n');
-    }
-    catch (e) {
-        if (e && typeof e === 'object' && 'code' in e && e.code === 'ENOENT') {
-            return `Error: Directory not found: ${resolved}`;
-        }
-        return `Error: ${e instanceof Error ? e.message : String(e)}`;
-    }
-}
-/**
- * Inspect .env file with secrets redacted.
- */
-export function inspectEnv(showAll = false) {
-    const envPath = path.join(getDeploymentDir(), '.env');
-    if (!fs.existsSync(envPath)) {
-        return `No .env file found at ${envPath}`;
-    }
-    const result = [];
-    const content = fs.readFileSync(envPath, 'utf-8');
-    for (const line of content.split('\n')) {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith('#')) {
-            result.push(trimmed);
-            continue;
-        }
-        if (trimmed.includes('=')) {
-            const [key, ...valueParts] = trimmed.split('=');
-            const value = valueParts.join('=').trim();
-            const keyTrimmed = key.trim();
-            if (isSecretKey(keyTrimmed)) {
-                if (value) {
-                    result.push(`${keyTrimmed}=[REDACTED - ${value.length} chars]`);
-                }
-                else {
-                    result.push(`${keyTrimmed}=[NOT SET]`);
-                }
-            }
-            else if (showAll || !isSecretKey(keyTrimmed)) {
-                result.push(`${keyTrimmed}=${value}`);
-            }
-        }
-    }
-    return result.join('\n');
-}
-/**
- * Find the SQLite database path.
- */
-async function findDatabasePath() {
-    const deploymentDir = getDeploymentDir();
-    const candidates = [
-        path.join(deploymentDir, 'data', 'main.db'),
-        path.join(deploymentDir, 'backend-data', 'main.db'),
-    ];
-    try {
-        const { stdout } = await execAsync('docker volume inspect backend-data --format "{{.Mountpoint}}"', { encoding: 'utf-8', timeout: 5000 });
-        const result = stdout.trim();
-        if (result) {
-            candidates.unshift(path.join(result, 'main.db'));
-        }
-    }
-    catch {
-        // Ignore errors
-    }
-    for (const dbPath of candidates) {
-        if (fs.existsSync(dbPath)) {
-            return dbPath;
-        }
-    }
-    return null;
-}
-/**
- * Execute a read-only SQL query.
- */
-export async function queryDatabase(query, signal) {
-    const queryUpper = query.trim().toUpperCase();
-    if (!queryUpper.startsWith('SELECT')) {
-        return 'Error: Only SELECT queries are allowed.';
-    }
-    const dangerous = ['DROP', 'DELETE', 'INSERT', 'UPDATE', 'ALTER', 'CREATE', 'TRUNCATE'];
-    for (const d of dangerous) {
-        if (queryUpper.includes(d)) {
-            return `Error: Query contains blocked keyword: ${d}`;
-        }
-    }
-    const dbPath = await findDatabasePath();
-    if (!dbPath) {
-        // Try via docker
-        return runCommand(`docker exec orca-backend sqlite3 /app/backend/data/main.db "${query}"`, undefined, signal);
-    }
-    try {
-        const db = new Database(dbPath, { readonly: true });
-        const stmt = db.prepare(query);
-        const rows = stmt.all();
-        if (rows.length === 0) {
-            db.close();
-            return '(no results)';
-        }
-        const columns = Object.keys(rows[0]);
-        const result = [columns.join('\t'), '-'.repeat(40)];
-        for (const row of rows.slice(0, 100)) {
-            result.push(columns.map((col) => String(row[col])).join('\t'));
-        }
-        if (rows.length > 100) {
-            result.push(`... (${rows.length - 100} more rows)`);
-        }
-        db.close();
-        return result.join('\n');
-    }
-    catch (e) {
-        return `Error: ${e instanceof Error ? e.message : String(e)}`;
-    }
-}
-/**
- * Search container logs for a pattern.
- */
-export async function searchLogs(container, pattern, caseInsensitive = true, contextLines = 2, signal) {
-    let grepFlags = caseInsensitive ? '-i' : '';
-    if (contextLines) {
-        grepFlags += ` -C ${contextLines}`;
-    }
-    return runCommand(`docker logs ${container} 2>&1 | grep ${grepFlags} "${pattern}" | tail -100`, undefined, signal);
-}
-/**
- * Search for a pattern in a file or directory using grep.
- */
-export async function grepFile(pattern, filePath, caseInsensitive = true, contextLines = 0, signal) {
-    const resolved = resolvePath(filePath);
-    const flags = [
-        '-n', // line numbers
-        caseInsensitive ? '-i' : '',
-        contextLines > 0 ? `-C ${contextLines}` : '',
-    ].filter(Boolean).join(' ');
-    return runCommand(`grep ${flags} -E "${pattern}" "${resolved}"`, undefined, signal);
-}
-/**
- * Check health of Orca containers.
- */
-export async function checkContainerHealth(container = 'all', signal) {
-    const result = [];
-    let containers;
-    if (container === 'all') {
-        containers = ['orca-backend', 'orca-frontend', 'orca-redis'];
-        const psResult = await runCommand('docker ps -a --filter "name=orca-" --format "{{.Names}}"', undefined, signal);
-        for (const name of psResult.trim().split('\n')) {
-            if (name && !containers.includes(name)) {
-                containers.push(name);
-            }
-        }
-    }
-    else {
-        containers = [container];
-    }
-    for (const c of containers) {
-        result.push(`\n${'='.repeat(60)}\nContainer: ${c}\n${'='.repeat(60)}`);
-        result.push(await runCommand(`docker inspect ${c} --format "Status: {{.State.Status}}, Restarts: {{.RestartCount}}"`, undefined, signal));
-        const stats = await runCommand(`docker stats ${c} --no-stream --format "CPU: {{.CPUPerc}}, Mem: {{.MemUsage}}"`, undefined, signal);
-        if (!stats.includes('Error')) {
-            result.push(stats);
-        }
-        result.push('\nRecent logs (last 10 lines):');
-        result.push(await runCommand(`docker logs ${c} --tail 10 2>&1`, undefined, signal));
-    }
-    return result.join('\n');
-}
-/**
- * Log a deployment event to release_history.json.
- */
-export function logDeploymentEvent(event, version, status, previousVersion, notes) {
-    const historyPath = path.join(getDeploymentDir(), 'release_history.json');
-    let history = [];
-    if (fs.existsSync(historyPath)) {
-        try {
-            history = JSON.parse(fs.readFileSync(historyPath, 'utf-8'));
-        }
-        catch {
-            history = [];
-        }
-    }
-    const entry = {
-        timestamp: new Date().toISOString(),
-        event,
-        version,
-        previous_version: previousVersion || null,
-        status,
-        notes: notes || null,
-    };
-    history.unshift(entry);
-    fs.writeFileSync(historyPath, JSON.stringify(history, null, 2), 'utf-8');
-    return `Logged ${event} event: version=${version}, status=${status}`;
-}
-/**
- * Read deployment history from release_history.json.
- */
-export function getDeploymentHistory(limit = 10) {
-    const historyPath = path.join(getDeploymentDir(), 'release_history.json');
-    if (!fs.existsSync(historyPath)) {
-        return 'No deployment history found. No installs, updates, or rollbacks have been recorded yet.';
-    }
-    let history;
-    try {
-        history = JSON.parse(fs.readFileSync(historyPath, 'utf-8'));
-    }
-    catch {
-        return 'Error: Could not parse release_history.json.';
-    }
-    if (history.length === 0) {
-        return 'Deployment history is empty.';
-    }
-    const entries = history.slice(0, limit);
-    const lines = entries.map((e, i) => {
-        const parts = [
-            `${i + 1}. [${e.timestamp}] ${String(e.event).toUpperCase()} → v${e.version}`,
-            `   Status: ${e.status}`,
-        ];
-        if (e.previous_version) {
-            parts.push(`   Previous: v${e.previous_version}`);
-        }
-        if (e.notes) {
-            parts.push(`   Notes: ${e.notes}`);
-        }
-        return parts.join('\n');
-    });
-    const header = `Deployment History (showing ${entries.length} of ${history.length}):`;
-    return [header, '', ...lines].join('\n');
-}
-/**
- * Handle downloading deployment files.
- */
-async function handleDownloadDeploymentFiles(targetDir) {
-    // Expand ~ to home directory
-    const expandedDir = targetDir.replace(/^~/, process.env.HOME || process.env.USERPROFILE || '');
-    const resolvedDir = path.resolve(expandedDir);
-    // Get list of available files
-    const files = await listDeploymentFiles();
-    if (!files || files.length === 0) {
-        return 'Error: Could not fetch deployment files list from server. Make sure you are authenticated (/token).';
-    }
-    // Create target directory if it doesn't exist
-    if (!fs.existsSync(resolvedDir)) {
-        fs.mkdirSync(resolvedDir, { recursive: true });
-    }
-    const results = [];
-    let successCount = 0;
-    let failCount = 0;
-    for (const filename of files) {
-        const targetPath = path.join(resolvedDir, filename);
-        const success = await downloadDeploymentFile(filename, targetPath);
-        if (success) {
-            results.push(`✓ ${filename}`);
-            successCount++;
-        }
-        else {
-            results.push(`✗ ${filename} (failed)`);
-            failCount++;
-        }
-    }
-    const summary = failCount === 0
-        ? `Successfully downloaded ${successCount} deployment files to ${resolvedDir}`
-        : `Downloaded ${successCount} files, ${failCount} failed`;
-    return `${summary}\n\nFiles:\n${results.join('\n')}\n\nNext steps:\n1. cd ${resolvedDir}\n2. cp .env.example .env\n3. Edit .env with your configuration\n4. docker compose up -d`;
-}
-/**
- * Handle a tool call and return the result.
- */
-export async function handleToolCall(name, inputData, signal) {
-    // Async handlers
-    if (name === 'docker_login_ghcr') {
-        const success = await dockerLoginGHCR();
-        return success
-            ? 'Successfully authenticated with GHCR. You can now pull Orca images.'
-            : 'Failed to authenticate with GHCR. Make sure you are authenticated (/token) and the server has GHCR configured.';
-    }
-    if (name === 'download_deployment_files') {
-        return handleDownloadDeploymentFiles(inputData.target_dir);
-    }
-    if (name === 'check_auth_status') {
-        const authenticated = isAuthenticated();
-        if (!authenticated) {
-            return JSON.stringify({
-                authenticated: false,
-                message: 'Not authenticated. Use /token command to authenticate.',
-            });
-        }
-        const creds = loadCredentials();
-        const provider = getSelectedCloudProvider();
-        return JSON.stringify({
-            authenticated: true,
-            email: creds?.user?.email || 'unknown',
-            org_id: creds?.org_id || 'unknown',
-            provider: provider || 'none',
-        });
-    }
-    if (name === 'save_deployment_dir') {
-        const deployPath = inputData.path;
-        // Expand ~ to home directory
-        const expandedPath = deployPath.replace(/^~/, process.env.HOME || process.env.USERPROFILE || '');
-        const resolvedPath = path.resolve(expandedPath);
-        // Verify the directory exists and has docker-compose.yml
-        const composePath = path.join(resolvedPath, 'docker-compose.yml');
-        if (!fs.existsSync(composePath)) {
-            return `Error: docker-compose.yml not found at ${resolvedPath}. Please verify the path is correct.`;
-        }
-        saveDeploymentDir(resolvedPath);
-        return `Deployment directory saved: ${resolvedPath}`;
-    }
-    if (name === 'recreate_containers') {
-        if (!isAuthenticated()) {
-            return 'Error: Not authenticated. Use /token command to authenticate first.';
-        }
-        const orgId = String(inputData.org_id ?? '').trim();
-        if (!orgId) {
-            return 'Error: org_id is required.';
-        }
-        try {
-            // Step 1: Delete all containers for the org
-            const delResp = await cloudRequest('DELETE', `/api/v1/super-admin/workspaces/${orgId}?force=true`);
-            const deleteOk = delResp.status >= 200 && delResp.status < 300;
-            if (!deleteOk) {
-                return JSON.stringify({ org_id: orgId, success: false, error: `delete failed (status ${delResp.status}): ${JSON.stringify(delResp.data)}` });
-            }
-            // Step 2: Recreate containers
-            const createResp = await cloudRequest('POST', `/api/v1/super-admin/workspaces/${orgId}`);
-            const createOk = createResp.status >= 200 && createResp.status < 300;
-            if (!createOk) {
-                return JSON.stringify({ org_id: orgId, success: false, delete_ok: true, error: `create failed (status ${createResp.status}): ${JSON.stringify(createResp.data)}` });
-            }
-            return JSON.stringify({ org_id: orgId, success: true, message: `Containers recreated for ${orgId}.` });
-        }
-        catch (e) {
-            return `Error: ${e instanceof Error ? e.message : String(e)}`;
-        }
-    }
-    if (name === 'log_deployment_event') {
-        return logDeploymentEvent(inputData.event, inputData.version, inputData.status, inputData.previous_version, inputData.notes);
-    }
-    if (name === 'get_deployment_history') {
-        return getDeploymentHistory(inputData.limit ?? 10);
-    }
-    if (name === 'get_deployment_dir') {
-        const storedDir = getStoredDeploymentDir();
-        if (storedDir) {
-            // Verify the directory still exists
-            const composePath = path.join(storedDir, 'docker-compose.yml');
-            if (fs.existsSync(composePath)) {
-                return JSON.stringify({
-                    found: true,
-                    path: storedDir,
-                    message: `Deployment directory: ${storedDir}`,
-                });
-            }
-            else {
-                return JSON.stringify({
-                    found: false,
-                    stale_path: storedDir,
-                    message: `Previously stored path ${storedDir} no longer contains docker-compose.yml. Ask user for the correct path.`,
-                });
-            }
-        }
-        return JSON.stringify({
-            found: false,
-            message: 'Deployment directory not set. Ask user where Orca is installed.',
-        });
-    }
-    // Tool handlers
-    const handlers = {
-        run_command: () => runCommand(inputData.command, undefined, signal),
-        read_file: () => readFile(inputData.path, inputData.tail),
-        list_directory: () => listDirectory(inputData.path),
-        inspect_env: () => inspectEnv(inputData.show_all || false),
-        query_database: () => queryDatabase(inputData.query, signal),
-        search_logs: () => searchLogs(inputData.container, inputData.pattern, inputData.case_insensitive ?? true, inputData.context_lines ?? 2, signal),
-        check_container_health: () => checkContainerHealth(inputData.container || 'all', signal),
-        grep_file: () => grepFile(inputData.pattern, inputData.path, inputData.case_insensitive ?? true, inputData.context_lines ?? 0, signal),
-    };
-    const handler = handlers[name];
-    if (handler) {
-        return handler();
-    }
-    return `Unknown tool: ${name}`;
-}
-//# sourceMappingURL=tools.js.map