@orchagent/cli 0.2.11 → 0.2.13

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/errors.js

@@ -33,13 +33,15 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CliError = void 0;
+exports.NetworkError = exports.ExitCodes = exports.CliError = void 0;
 exports.formatError = formatError;
 exports.exitWithError = exitWithError;
+exports.jsonInputError = jsonInputError;
 const Sentry = __importStar(require("@sentry/node"));
 const analytics_1 = require("./analytics");
 class CliError extends Error {
     exitCode;
+    cause;
     constructor(message, exitCode = 1) {
         super(message);
         this.exitCode = exitCode;
@@ -73,3 +75,41 @@ async function exitWithError(err) {
     }
     process.exit(1);
 }
+exports.ExitCodes = {
+    SUCCESS: 0,
+    GENERAL_ERROR: 1,
+    AUTH_ERROR: 2,
+    PERMISSION_DENIED: 3,
+    NOT_FOUND: 4,
+    INVALID_INPUT: 5,
+    RATE_LIMITED: 6,
+    TIMEOUT: 7,
+    SERVER_ERROR: 8,
+    NETWORK_ERROR: 9,
+};
+class NetworkError extends CliError {
+    constructor(url, cause) {
+        const host = new URL(url).host;
+        super(`Unable to connect to ${host}\n\n` +
+            'Possible causes:\n' +
+            '  - Network connectivity issues\n' +
+            '  - Service temporarily unavailable\n' +
+            '  - Firewall or proxy blocking the request\n\n' +
+            'Check status at: https://status.orchagent.io', exports.ExitCodes.NETWORK_ERROR);
+        this.cause = cause;
+    }
+}
+exports.NetworkError = NetworkError;
+function jsonInputError(flag) {
+    return new CliError(`Invalid JSON in --${flag} option.\n\n` +
+        'Common causes:\n' +
+        '  - Shell special characters (!, $, `) need escaping\n' +
+        '  - Missing or mismatched quotes\n\n' +
+        'Shell-specific tips:\n' +
+        '  - Bash/Zsh: Use single quotes: --data \'{"key": "value"}\'\n' +
+        '  - PowerShell: Use double quotes and escape: --data "{\\"key\\": \\"value\\"}"\n' +
+        '  - Any shell: Use a file: --data @input.json\n\n' +
+        'Alternatives:\n' +
+        `  - Use a file:  --${flag} @input.json\n` +
+        `  - Use stdin:   echo '{"key":"value"}' | orch call agent --${flag} @-`, exports.ExitCodes.INVALID_INPUT);
+}

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.11",
+  "version": "0.2.13",
   "description": "Command-line interface for the OrchAgent AI agent marketplace",
   "license": "MIT",
   "author": "OrchAgent <hello@orchagent.io>",