@orchagent/cli 0.2.11 → 0.2.13

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

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkApiKeyPresent = checkApiKeyPresent;
+exports.checkApiKeyValid = checkApiKeyValid;
+exports.runAuthChecks = runAuthChecks;
+const config_1 = require("../../config");
+const api_1 = require("../../api");
+/**
+ * Check if API key is configured (in config file or env var).
+ */
+async function checkApiKeyPresent() {
+    const config = await (0, config_1.getResolvedConfig)();
+    const fileConfig = await (0, config_1.loadConfig)();
+    if (config.apiKey) {
+        // Determine source of the API key
+        let source = 'unknown';
+        if (process.env.ORCHAGENT_API_KEY) {
+            source = 'ORCHAGENT_API_KEY environment variable';
+        }
+        else if (fileConfig.api_key) {
+            source = '~/.orchagent/config.json';
+        }
+        // Get key prefix for verbose output (mask most of the key)
+        const keyPrefix = config.apiKey.slice(0, 12) + '...';
+        return {
+            category: 'authentication',
+            name: 'api_key_present',
+            status: 'success',
+            message: 'API key configured',
+            details: { source, keyPrefix },
+        };
+    }
+    return {
+        category: 'authentication',
+        name: 'api_key_present',
+        status: 'error',
+        message: 'No API key configured',
+        fix: 'Run `orch login` or set ORCHAGENT_API_KEY environment variable',
+        details: { configured: false },
+    };
+}
+/**
+ * Check if API key is valid by calling the /org endpoint.
+ */
+async function checkApiKeyValid() {
+    const config = await (0, config_1.getResolvedConfig)();
+    if (!config.apiKey) {
+        return {
+            category: 'authentication',
+            name: 'api_key_valid',
+            status: 'error',
+            message: 'Cannot validate API key (not configured)',
+            details: { reason: 'no api key' },
+        };
+    }
+    try {
+        const org = await (0, api_1.getOrg)(config);
+        return {
+            category: 'authentication',
+            name: 'api_key_valid',
+            status: 'success',
+            message: `API key valid (logged in as: ${org.name})`,
+            details: {
+                orgName: org.name,
+                orgSlug: org.slug,
+                apiUrl: config.apiUrl,
+            },
+        };
+    }
+    catch (err) {
+        if (err instanceof api_1.ApiError) {
+            if (err.status === 401) {
+                return {
+                    category: 'authentication',
+                    name: 'api_key_valid',
+                    status: 'error',
+                    message: 'API key is invalid or expired',
+                    fix: 'Run `orch login` to get a new key',
+                    details: { error: err.message, status: err.status },
+                };
+            }
+            return {
+                category: 'authentication',
+                name: 'api_key_valid',
+                status: 'error',
+                message: `API key validation failed (${err.status})`,
+                fix: 'Check your network connection and try again',
+                details: { error: err.message, status: err.status },
+            };
+        }
+        return {
+            category: 'authentication',
+            name: 'api_key_valid',
+            status: 'error',
+            message: 'Could not validate API key',
+            fix: 'Check your network connection and try again',
+            details: { error: err instanceof Error ? err.message : 'unknown error' },
+        };
+    }
+}
+/**
+ * Run all auth checks.
+ */
+async function runAuthChecks() {
+    const results = [];
+    // First check if key is present
+    const keyPresent = await checkApiKeyPresent();
+    results.push(keyPresent);
+    // Only validate key if it's present
+    if (keyPresent.status === 'success') {
+        const keyValid = await checkApiKeyValid();
+        results.push(keyValid);
+    }
+    return results;
+}

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

@@ -0,0 +1,119 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkConfigExists = checkConfigExists;
+exports.checkConfigPermissions = checkConfigPermissions;
+exports.runConfigChecks = runConfigChecks;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const CONFIG_DIR = path_1.default.join(os_1.default.homedir(), '.orchagent');
+const CONFIG_PATH = path_1.default.join(CONFIG_DIR, 'config.json');
+/**
+ * Check if config file exists.
+ */
+async function checkConfigExists() {
+    try {
+        await promises_1.default.access(CONFIG_PATH);
+        return {
+            category: 'configuration',
+            name: 'config_exists',
+            status: 'success',
+            message: `Config file exists (~/.orchagent/config.json)`,
+            details: { path: CONFIG_PATH },
+        };
+    }
+    catch {
+        return {
+            category: 'configuration',
+            name: 'config_exists',
+            status: 'warning',
+            message: 'Config file not found',
+            fix: 'Run `orch login` to create config',
+            details: { path: CONFIG_PATH, exists: false },
+        };
+    }
+}
+/**
+ * Check config file permissions (should be 600 for security).
+ */
+async function checkConfigPermissions() {
+    try {
+        const stats = await promises_1.default.stat(CONFIG_PATH);
+        // On Windows, file permissions work differently
+        if (process.platform === 'win32') {
+            return {
+                category: 'configuration',
+                name: 'config_permissions',
+                status: 'success',
+                message: 'Config file permissions (Windows)',
+                details: { platform: 'win32', note: 'permissions check skipped on Windows' },
+            };
+        }
+        // Check if permissions are 600 (owner read/write only)
+        // mode & 0o777 gives us the permission bits
+        const mode = stats.mode & 0o777;
+        if (mode === 0o600) {
+            return {
+                category: 'configuration',
+                name: 'config_permissions',
+                status: 'success',
+                message: 'Config file permissions (600)',
+                details: { mode: mode.toString(8), expected: '600' },
+            };
+        }
+        // Check if it's too permissive (world or group readable)
+        const worldReadable = (mode & 0o004) !== 0;
+        const groupReadable = (mode & 0o040) !== 0;
+        if (worldReadable || groupReadable) {
+            return {
+                category: 'configuration',
+                name: 'config_permissions',
+                status: 'warning',
+                message: `Config file permissions too open (${mode.toString(8)})`,
+                fix: 'Run `chmod 600 ~/.orchagent/config.json`',
+                details: {
+                    mode: mode.toString(8),
+                    expected: '600',
+                    worldReadable,
+                    groupReadable,
+                },
+            };
+        }
+        return {
+            category: 'configuration',
+            name: 'config_permissions',
+            status: 'success',
+            message: `Config file permissions (${mode.toString(8)})`,
+            details: { mode: mode.toString(8), expected: '600' },
+        };
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            // Config doesn't exist, skip permissions check
+            return {
+                category: 'configuration',
+                name: 'config_permissions',
+                status: 'warning',
+                message: 'Config file permissions (file not found)',
+                details: { error: 'file not found' },
+            };
+        }
+        return {
+            category: 'configuration',
+            name: 'config_permissions',
+            status: 'warning',
+            message: 'Could not check config permissions',
+            details: { error: err instanceof Error ? err.message : 'unknown error' },
+        };
+    }
+}
+/**
+ * Run all config checks.
+ */
+async function runConfigChecks() {
+    const results = await Promise.all([checkConfigExists(), checkConfigPermissions()]);
+    return results;
+}

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

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkGatewayHealth = checkGatewayHealth;
+exports.runConnectivityChecks = runConnectivityChecks;
+const config_1 = require("../../config");
+const LATENCY_WARNING_MS = 2000;
+/**
+ * Check if gateway is reachable by pinging /health endpoint.
+ * Also measures response time.
+ */
+async function checkGatewayHealth() {
+    const config = await (0, config_1.getResolvedConfig)();
+    const healthUrl = `${config.apiUrl.replace(/\/$/, '')}/health`;
+    const startTime = Date.now();
+    try {
+        const response = await fetch(healthUrl, {
+            signal: AbortSignal.timeout(10000),
+        });
+        const latency = Date.now() - startTime;
+        if (!response.ok) {
+            return [
+                {
+                    category: 'connectivity',
+                    name: 'gateway_reachable',
+                    status: 'error',
+                    message: `Gateway returned ${response.status}`,
+                    fix: 'Check if OrchAgent API is operational at https://status.orchagent.io',
+                    details: {
+                        url: healthUrl,
+                        status: response.status,
+                        latency,
+                    },
+                },
+            ];
+        }
+        // Parse hostname for display
+        const apiHost = new URL(config.apiUrl).host;
+        const results = [
+            {
+                category: 'connectivity',
+                name: 'gateway_reachable',
+                status: 'success',
+                message: `Gateway reachable (${apiHost})`,
+                details: {
+                    url: healthUrl,
+                    status: response.status,
+                    host: apiHost,
+                },
+            },
+        ];
+        // Add latency check
+        if (latency > LATENCY_WARNING_MS) {
+            results.push({
+                category: 'connectivity',
+                name: 'response_time',
+                status: 'warning',
+                message: `Response time: ${latency}ms (high latency)`,
+                fix: 'High latency detected. Check network or try a different region.',
+                details: { latency, threshold: LATENCY_WARNING_MS },
+            });
+        }
+        else {
+            results.push({
+                category: 'connectivity',
+                name: 'response_time',
+                status: 'success',
+                message: `Response time: ${latency}ms`,
+                details: { latency, threshold: LATENCY_WARNING_MS },
+            });
+        }
+        return results;
+    }
+    catch (err) {
+        const latency = Date.now() - startTime;
+        const isTimeout = err instanceof Error && (err.name === 'AbortError' || err.name === 'TimeoutError');
+        if (isTimeout) {
+            return [
+                {
+                    category: 'connectivity',
+                    name: 'gateway_reachable',
+                    status: 'error',
+                    message: 'Gateway connection timed out',
+                    fix: 'Check network, firewall, or proxy settings',
+                    details: { url: healthUrl, error: 'timeout', latency },
+                },
+            ];
+        }
+        return [
+            {
+                category: 'connectivity',
+                name: 'gateway_reachable',
+                status: 'error',
+                message: 'Cannot reach gateway',
+                fix: 'Check network, firewall, or proxy settings',
+                details: {
+                    url: healthUrl,
+                    error: err instanceof Error ? err.message : 'unknown error',
+                    latency,
+                },
+            },
+        ];
+    }
+}
+/**
+ * Run all connectivity checks.
+ */
+async function runConnectivityChecks() {
+    return checkGatewayHealth();
+}

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 keys add <provider>` 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);