@orchagent/cli 0.2.10 → 0.2.12

package/dist/lib/doctor/checks/environment.js

@@ -0,0 +1,151 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkNodeVersion = checkNodeVersion;
+exports.checkCliVersion = checkCliVersion;
+exports.checkGitAvailable = checkGitAvailable;
+exports.runEnvironmentChecks = runEnvironmentChecks;
+const child_process_1 = require("child_process");
+const package_json_1 = __importDefault(require("../../../../package.json"));
+const REQUIRED_NODE_MAJOR = 18;
+/**
+ * Check if Node.js version is 18+.
+ */
+async function checkNodeVersion() {
+    const version = process.version;
+    const major = parseInt(version.slice(1).split('.')[0], 10);
+    if (major >= REQUIRED_NODE_MAJOR) {
+        return {
+            category: 'environment',
+            name: 'node_version',
+            status: 'success',
+            message: `Node.js ${version} (${REQUIRED_NODE_MAJOR}+ required)`,
+            details: { version, required: `${REQUIRED_NODE_MAJOR}.0.0` },
+        };
+    }
+    return {
+        category: 'environment',
+        name: 'node_version',
+        status: 'error',
+        message: `Node.js ${version} is too old (${REQUIRED_NODE_MAJOR}+ required)`,
+        fix: `Install Node.js ${REQUIRED_NODE_MAJOR}+ from https://nodejs.org`,
+        details: { version, required: `${REQUIRED_NODE_MAJOR}.0.0` },
+    };
+}
+/**
+ * Check if CLI is up to date by comparing with npm registry.
+ */
+async function checkCliVersion() {
+    const installedVersion = package_json_1.default.version;
+    try {
+        // Fetch latest version from npm registry
+        const response = await fetch('https://registry.npmjs.org/@orchagent/cli/latest', { signal: AbortSignal.timeout(5000) });
+        if (!response.ok) {
+            return {
+                category: 'environment',
+                name: 'cli_version',
+                status: 'warning',
+                message: `CLI v${installedVersion} (could not check for updates)`,
+                details: { installed: installedVersion, error: 'npm registry unreachable' },
+            };
+        }
+        const data = (await response.json());
+        const latestVersion = data.version;
+        if (installedVersion === latestVersion) {
+            return {
+                category: 'environment',
+                name: 'cli_version',
+                status: 'success',
+                message: `CLI v${installedVersion} (up to date)`,
+                details: { installed: installedVersion, latest: latestVersion },
+            };
+        }
+        // Compare versions (simple semver comparison)
+        const installedParts = installedVersion.split('.').map(Number);
+        const latestParts = latestVersion.split('.').map(Number);
+        let isOutdated = false;
+        for (let i = 0; i < 3; i++) {
+            if ((latestParts[i] || 0) > (installedParts[i] || 0)) {
+                isOutdated = true;
+                break;
+            }
+            if ((latestParts[i] || 0) < (installedParts[i] || 0)) {
+                break;
+            }
+        }
+        if (isOutdated) {
+            return {
+                category: 'environment',
+                name: 'cli_version',
+                status: 'warning',
+                message: `CLI v${installedVersion} (v${latestVersion} available)`,
+                fix: 'Run `npm update -g @orchagent/cli` to update',
+                details: { installed: installedVersion, latest: latestVersion },
+            };
+        }
+        return {
+            category: 'environment',
+            name: 'cli_version',
+            status: 'success',
+            message: `CLI v${installedVersion}`,
+            details: { installed: installedVersion, latest: latestVersion },
+        };
+    }
+    catch (err) {
+        return {
+            category: 'environment',
+            name: 'cli_version',
+            status: 'warning',
+            message: `CLI v${installedVersion} (could not check for updates)`,
+            details: {
+                installed: installedVersion,
+                error: err instanceof Error ? err.message : 'unknown error',
+            },
+        };
+    }
+}
+/**
+ * Check if git is available in PATH.
+ * Note: Uses execSync with hardcoded command string - no user input, safe from injection.
+ */
+async function checkGitAvailable() {
+    try {
+        const output = (0, child_process_1.execSync)('git --version', {
+            encoding: 'utf-8',
+            timeout: 5000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        const versionMatch = output.match(/git version (\S+)/);
+        const version = versionMatch ? versionMatch[1] : 'unknown';
+        return {
+            category: 'environment',
+            name: 'git_available',
+            status: 'success',
+            message: `Git available (${version})`,
+            details: { version },
+        };
+    }
+    catch {
+        return {
+            category: 'environment',
+            name: 'git_available',
+            status: 'warning',
+            message: 'Git not found in PATH',
+            fix: 'Install git from https://git-scm.com',
+            details: { available: false },
+        };
+    }
+}
+/**
+ * Run all environment checks.
+ */
+async function runEnvironmentChecks() {
+    const results = await Promise.all([
+        checkNodeVersion(),
+        checkCliVersion(),
+        checkGitAvailable(),
+    ]);
+    return results;
+}

package/dist/lib/doctor/checks/llm.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkServerLlmKeys = checkServerLlmKeys;
+exports.checkLocalLlmEnvVars = checkLocalLlmEnvVars;
+exports.runLlmChecks = runLlmChecks;
+const config_1 = require("../../config");
+const api_1 = require("../../api");
+// Common LLM provider environment variables
+const LLM_ENV_VARS = [
+    { name: 'OPENAI_API_KEY', provider: 'OpenAI' },
+    { name: 'ANTHROPIC_API_KEY', provider: 'Anthropic' },
+    { name: 'GOOGLE_API_KEY', provider: 'Google' },
+    { name: 'GEMINI_API_KEY', provider: 'Gemini' },
+];
+/**
+ * Check if LLM keys are configured on the server.
+ */
+async function checkServerLlmKeys() {
+    const config = await (0, config_1.getResolvedConfig)();
+    if (!config.apiKey) {
+        return {
+            category: 'llm',
+            name: 'server_llm_keys',
+            status: 'warning',
+            message: 'Cannot check server LLM keys (not logged in)',
+            details: { reason: 'no api key' },
+        };
+    }
+    try {
+        const keys = await (0, api_1.fetchLlmKeys)(config);
+        if (keys.length === 0) {
+            return {
+                category: 'llm',
+                name: 'server_llm_keys',
+                status: 'warning',
+                message: 'No LLM keys configured on server',
+                fix: 'Run `orch llm-config` or add keys at orchagent.io/settings',
+                details: { count: 0, providers: [] },
+            };
+        }
+        const providers = keys.map((k) => k.provider);
+        return {
+            category: 'llm',
+            name: 'server_llm_keys',
+            status: 'success',
+            message: `Server LLM keys configured (${providers.join(', ')})`,
+            details: { count: keys.length, providers },
+        };
+    }
+    catch (err) {
+        if (err instanceof api_1.ApiError && err.status === 401) {
+            return {
+                category: 'llm',
+                name: 'server_llm_keys',
+                status: 'warning',
+                message: 'Cannot check server LLM keys (auth failed)',
+                details: { error: err.message },
+            };
+        }
+        return {
+            category: 'llm',
+            name: 'server_llm_keys',
+            status: 'warning',
+            message: 'Could not check server LLM keys',
+            details: { error: err instanceof Error ? err.message : 'unknown error' },
+        };
+    }
+}
+/**
+ * Check if common LLM provider API keys are set in environment.
+ */
+async function checkLocalLlmEnvVars() {
+    const configuredProviders = [];
+    const details = {};
+    for (const { name, provider } of LLM_ENV_VARS) {
+        const isSet = !!process.env[name];
+        details[name] = isSet;
+        if (isSet) {
+            configuredProviders.push(provider);
+        }
+    }
+    if (configuredProviders.length === 0) {
+        return {
+            category: 'llm',
+            name: 'local_llm_env',
+            status: 'warning',
+            message: 'No local LLM API keys found in environment',
+            fix: 'Set OPENAI_API_KEY, ANTHROPIC_API_KEY, or similar for local runs',
+            details,
+        };
+    }
+    // Deduplicate (Google and Gemini might both be set)
+    const uniqueProviders = [...new Set(configuredProviders)];
+    return {
+        category: 'llm',
+        name: 'local_llm_env',
+        status: 'success',
+        message: `Local LLM keys found (${uniqueProviders.join(', ')})`,
+        details,
+    };
+}
+/**
+ * Run all LLM configuration checks.
+ */
+async function runLlmChecks() {
+    const results = await Promise.all([checkServerLlmKeys(), checkLocalLlmEnvVars()]);
+    return results;
+}

package/dist/lib/doctor/index.js

@@ -0,0 +1,19 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./runner"), exports);
+__exportStar(require("./output"), exports);

package/dist/lib/doctor/output.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printHumanOutput = printHumanOutput;
+exports.formatJsonOutput = formatJsonOutput;
+const chalk_1 = __importDefault(require("chalk"));
+// Status symbols
+const SYMBOLS = {
+    success: chalk_1.default.green('\u2713'), // checkmark
+    warning: chalk_1.default.yellow('\u26a0'), // warning sign
+    error: chalk_1.default.red('\u2717'), // X mark
+};
+// Category display names
+const CATEGORY_NAMES = {
+    environment: 'Environment',
+    configuration: 'Configuration',
+    connectivity: 'Connectivity',
+    authentication: 'Authentication',
+    llm: 'LLM Configuration',
+};
+/**
+ * Group check results by category.
+ */
+function groupByCategory(results) {
+    const groups = new Map();
+    // Define category order
+    const categoryOrder = [
+        'environment',
+        'configuration',
+        'connectivity',
+        'authentication',
+        'llm',
+    ];
+    // Initialize groups in order
+    for (const cat of categoryOrder) {
+        groups.set(cat, []);
+    }
+    // Add results to groups
+    for (const result of results) {
+        const existing = groups.get(result.category) || [];
+        existing.push(result);
+        groups.set(result.category, existing);
+    }
+    // Remove empty groups
+    for (const [key, value] of groups) {
+        if (value.length === 0) {
+            groups.delete(key);
+        }
+    }
+    return groups;
+}
+/**
+ * Print human-readable output to stdout.
+ */
+function printHumanOutput(results, summary, verbose) {
+    // Header
+    process.stdout.write('\n');
+    process.stdout.write(chalk_1.default.bold('OrchAgent Doctor\n'));
+    process.stdout.write('================\n\n');
+    // Group and print results
+    const groups = groupByCategory(results);
+    for (const [category, checks] of groups) {
+        const displayName = CATEGORY_NAMES[category] || category;
+        process.stdout.write(chalk_1.default.bold(`${displayName}\n`));
+        for (const check of checks) {
+            const symbol = SYMBOLS[check.status];
+            process.stdout.write(`  ${symbol} ${check.message}\n`);
+            // Show fix suggestion for warnings/errors
+            if (check.fix && check.status !== 'success') {
+                process.stdout.write(chalk_1.default.dim(`    \u2192 ${check.fix}\n`));
+            }
+            // Show details in verbose mode
+            if (verbose && check.details) {
+                for (const [key, value] of Object.entries(check.details)) {
+                    const displayValue = typeof value === 'object' ? JSON.stringify(value) : String(value);
+                    process.stdout.write(chalk_1.default.dim(`    ${key}: ${displayValue}\n`));
+                }
+            }
+        }
+        process.stdout.write('\n');
+    }
+    // Summary line
+    const summaryParts = [];
+    if (summary.passed > 0) {
+        summaryParts.push(chalk_1.default.green(`${summary.passed} passed`));
+    }
+    if (summary.warnings > 0) {
+        summaryParts.push(chalk_1.default.yellow(`${summary.warnings} warning${summary.warnings > 1 ? 's' : ''}`));
+    }
+    if (summary.errors > 0) {
+        summaryParts.push(chalk_1.default.red(`${summary.errors} error${summary.errors > 1 ? 's' : ''}`));
+    }
+    process.stdout.write(`Summary: ${summaryParts.join(', ')}\n`);
+}
+/**
+ * Format results as JSON output.
+ */
+function formatJsonOutput(results, summary) {
+    return {
+        summary,
+        checks: results,
+    };
+}

package/dist/lib/doctor/runner.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAllChecks = runAllChecks;
+exports.calculateSummary = calculateSummary;
+const environment_1 = require("./checks/environment");
+const config_1 = require("./checks/config");
+const auth_1 = require("./checks/auth");
+const connectivity_1 = require("./checks/connectivity");
+const llm_1 = require("./checks/llm");
+/**
+ * Run all diagnostic checks in order.
+ * Checks are organized by category and run in a logical sequence.
+ */
+async function runAllChecks() {
+    const results = [];
+    // Environment checks (no dependencies)
+    const envResults = await (0, environment_1.runEnvironmentChecks)();
+    results.push(...envResults);
+    // Config checks (no dependencies)
+    const configResults = await (0, config_1.runConfigChecks)();
+    results.push(...configResults);
+    // Connectivity checks (test gateway before auth)
+    const connectivityResults = await (0, connectivity_1.runConnectivityChecks)();
+    results.push(...connectivityResults);
+    // Check if gateway is reachable before running auth/LLM checks
+    const gatewayOk = connectivityResults.some((r) => r.name === 'gateway_reachable' && r.status === 'success');
+    if (gatewayOk) {
+        // Auth checks (requires gateway)
+        const authResults = await (0, auth_1.runAuthChecks)();
+        results.push(...authResults);
+        // LLM checks (requires auth for server keys)
+        const llmResults = await (0, llm_1.runLlmChecks)();
+        results.push(...llmResults);
+    }
+    else {
+        // Add placeholder results when gateway is unreachable
+        results.push({
+            category: 'authentication',
+            name: 'api_key_present',
+            status: 'warning',
+            message: 'Skipped (gateway unreachable)',
+            details: { skipped: true, reason: 'gateway unreachable' },
+        });
+        results.push({
+            category: 'llm',
+            name: 'server_llm_keys',
+            status: 'warning',
+            message: 'Skipped (gateway unreachable)',
+            details: { skipped: true, reason: 'gateway unreachable' },
+        });
+        // Still check local LLM env vars since they don't require network
+        const localLlmCheck = (await (0, llm_1.runLlmChecks)()).find((r) => r.name === 'local_llm_env');
+        if (localLlmCheck) {
+            results.push(localLlmCheck);
+        }
+    }
+    return results;
+}
+/**
+ * Calculate summary statistics from check results.
+ */
+function calculateSummary(results) {
+    return {
+        passed: results.filter((r) => r.status === 'success').length,
+        warnings: results.filter((r) => r.status === 'warning').length,
+        errors: results.filter((r) => r.status === 'error').length,
+    };
+}

package/dist/lib/doctor/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/llm-errors.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseLlmError = parseLlmError;
+const errors_1 = require("./errors");
+// Safe fallback messages by status code
+const FALLBACKS = {
+    openai: {
+        401: 'Invalid OpenAI API key. Check your OPENAI_API_KEY.',
+        403: 'Access denied. Your API key may not have permission for this model.',
+        429: 'Rate limit exceeded. Wait a moment and try again.',
+        500: 'OpenAI service error. Try again later.',
+        502: 'OpenAI is temporarily unavailable.',
+        503: 'OpenAI is overloaded. Try again later.',
+    },
+    anthropic: {
+        401: 'Invalid Anthropic API key. Check your ANTHROPIC_API_KEY.',
+        403: 'Access denied. Your API key may not have permission for this model.',
+        429: 'Rate limit exceeded. Wait a moment and try again.',
+        500: 'Anthropic service error. Try again later.',
+        502: 'Anthropic is temporarily unavailable.',
+        503: 'Anthropic is overloaded. Try again later.',
+    },
+    gemini: {
+        401: 'Invalid Gemini API key. Check your GEMINI_API_KEY.',
+        403: 'Access denied. Your API key may not have permission for this model.',
+        429: 'Rate limit exceeded. Wait a moment and try again.',
+        500: 'Gemini service error. Try again later.',
+        502: 'Gemini is temporarily unavailable.',
+        503: 'Gemini is overloaded. Try again later.',
+    },
+};
+const DEFAULT = 'LLM provider error. Check your API key and try again.';
+function isHtml(text) {
+    const t = text.trim().toLowerCase();
+    return t.startsWith('<!doctype') || t.startsWith('<html');
+}
+function sanitize(msg) {
+    if (msg.length > 200)
+        msg = msg.slice(0, 200) + '...';
+    return msg.replace(/https?:\/\/[^\s]+/g, '[URL]').trim();
+}
+function parseOpenAI(text, status) {
+    try {
+        const p = JSON.parse(text);
+        if (p.error?.message)
+            return sanitize(p.error.message);
+    }
+    catch { }
+    return FALLBACKS.openai[status] || DEFAULT;
+}
+function parseAnthropic(text, status) {
+    try {
+        const p = JSON.parse(text);
+        const msg = p.error?.message || p.message;
+        if (msg)
+            return sanitize(msg);
+    }
+    catch { }
+    return FALLBACKS.anthropic[status] || DEFAULT;
+}
+function parseGemini(text, status) {
+    try {
+        const p = JSON.parse(text);
+        if (p.error?.message)
+            return sanitize(p.error.message);
+    }
+    catch { }
+    return FALLBACKS.gemini[status] || DEFAULT;
+}
+function parseLlmError(provider, text, status) {
+    if (isHtml(text)) {
+        return new errors_1.CliError(`${provider} error: ${FALLBACKS[provider][status] || DEFAULT}`);
+    }
+    const msg = provider === 'openai' ? parseOpenAI(text, status)
+        : provider === 'anthropic' ? parseAnthropic(text, status)
+            : parseGemini(text, status);
+    const display = provider.charAt(0).toUpperCase() + provider.slice(1);
+    return new errors_1.CliError(`${display} API error: ${msg}`);
+}

package/dist/lib/llm.js

@@ -47,6 +47,7 @@ exports.buildPrompt = buildPrompt;
 exports.callLlm = callLlm;
 exports.validateProvider = validateProvider;
 const errors_1 = require("./errors");
+const llm_errors_1 = require("./llm-errors");
 // Environment variable names for each provider
 exports.PROVIDER_ENV_VARS = {
     openai: 'OPENAI_API_KEY',
@@ -181,7 +182,7 @@ async function callOpenAI(apiKey, model, prompt, outputSchema) {
     });
     if (!response.ok) {
         const text = await response.text();
-        throw new errors_1.CliError(`OpenAI API error: ${text}`);
+        throw (0, llm_errors_1.parseLlmError)('openai', text, response.status);
     }
     const data = (await response.json());
     const content = data.choices?.[0]?.message?.content || '';
@@ -208,7 +209,7 @@ async function callAnthropic(apiKey, model, prompt, _outputSchema) {
     });
     if (!response.ok) {
         const text = await response.text();
-        throw new errors_1.CliError(`Anthropic API error: ${text}`);
+        throw (0, llm_errors_1.parseLlmError)('anthropic', text, response.status);
     }
     const data = (await response.json());
     const content = data.content?.[0]?.text || '';
@@ -230,7 +231,7 @@ async function callGemini(apiKey, model, prompt, _outputSchema) {
     });
     if (!response.ok) {
         const text = await response.text();
-        throw new errors_1.CliError(`Gemini API error: ${text}`);
+        throw (0, llm_errors_1.parseLlmError)('gemini', text, response.status);
     }
     const data = (await response.json());
     const content = data.candidates?.[0]?.content?.parts?.[0]?.text || '';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orchagent/cli",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "description": "Command-line interface for the OrchAgent AI agent marketplace",
   "license": "MIT",
   "author": "OrchAgent <hello@orchagent.io>",