@orchagent/cli 0.3.33 → 0.3.34

package/dist/lib/doctor/output.js

@@ -19,8 +19,81 @@ const CATEGORY_NAMES = {
     configuration: 'Configuration',
     connectivity: 'Connectivity',
     authentication: 'Authentication',
-    llm: 'LLM Configuration',
+    llm: 'LLM Providers',
 };
+// Symbol for server-unknown state
+const UNKNOWN_SYMBOL = chalk_1.default.dim('?');
+/**
+ * Render the LLM section with per-provider table layout.
+ */
+function renderLlmSection(checks, verbose) {
+    const providerChecks = checks.filter((c) => c.name.startsWith('llm_provider_') && c.name !== 'llm_provider_summary');
+    const summaryCheck = checks.find((c) => c.name === 'llm_provider_summary');
+    // Calculate padding for aligned columns
+    const maxIdLen = Math.max(...providerChecks.map((c) => {
+        const id = c.details?.providerId || '';
+        return id.length;
+    }));
+    for (const check of providerChecks) {
+        const id = check.details?.providerId || '';
+        const padded = id.padEnd(maxIdLen);
+        const serverVal = check.details?.server;
+        const localVal = check.details?.local;
+        const configured = serverVal === true || localVal;
+        // Pick symbol: ✓ for configured, ✗ for not configured, ? for server-unknown
+        let symbol;
+        if (configured) {
+            symbol = SYMBOLS.success;
+        }
+        else if (serverVal === null) {
+            symbol = UNKNOWN_SYMBOL;
+        }
+        else {
+            symbol = SYMBOLS.error;
+        }
+        // Build location text
+        let location;
+        if (serverVal === null) {
+            location = localVal ? 'Server unknown, local configured' : 'Server unknown, not local';
+        }
+        else if (serverVal && localVal) {
+            location = 'Configured (server + local)';
+        }
+        else if (serverVal) {
+            location = 'Configured (server)';
+        }
+        else if (localVal) {
+            location = 'Configured (local)';
+        }
+        else {
+            location = 'Not configured';
+        }
+        process.stdout.write(`  ${symbol} ${padded}  ${location}\n`);
+        // Show format hint as dim indented text
+        const formatHint = check.details?.formatHint;
+        if (formatHint) {
+            process.stdout.write(chalk_1.default.dim(`    \u26a0 ${formatHint}\n`));
+        }
+        // Verbose: show details
+        if (verbose && check.details) {
+            for (const [key, value] of Object.entries(check.details)) {
+                if (key === 'providerId' || key === 'displayName' || key === 'formatHint')
+                    continue;
+                const displayValue = typeof value === 'object' ? JSON.stringify(value) : String(value);
+                process.stdout.write(chalk_1.default.dim(`    ${key}: ${displayValue}\n`));
+            }
+        }
+    }
+    // Summary tip/fix
+    if (summaryCheck) {
+        process.stdout.write('\n');
+        const symbol = SYMBOLS[summaryCheck.status] || SYMBOLS.info;
+        process.stdout.write(`  ${symbol} ${summaryCheck.message}\n`);
+        if (summaryCheck.fix) {
+            process.stdout.write(chalk_1.default.dim(`    \u2192 ${summaryCheck.fix}\n`));
+        }
+    }
+}
 /**
  * Group check results by category.
  */
@@ -65,18 +138,23 @@ function printHumanOutput(results, summary, verbose) {
     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] || SYMBOLS.info;
-            process.stdout.write(`  ${symbol} ${check.message}\n`);
-            // Show fix suggestion for warnings/errors (not for success/info)
-            if (check.fix && (check.status === 'warning' || check.status === 'error')) {
-                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`));
+        if (category === 'llm') {
+            renderLlmSection(checks, verbose);
+        }
+        else {
+            for (const check of checks) {
+                const symbol = SYMBOLS[check.status] || SYMBOLS.info;
+                process.stdout.write(`  ${symbol} ${check.message}\n`);
+                // Show fix suggestion for warnings/errors (not for success/info)
+                if (check.fix && (check.status === 'warning' || check.status === 'error')) {
+                    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`));
+                    }
                 }
             }
         }

package/dist/lib/doctor/runner.js

@@ -41,18 +41,9 @@ async function runAllChecks() {
             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);
-        }
+        // LLM checks with server status unknown — local env vars still checked
+        const llmResults = await (0, llm_1.runLlmChecks)({ skipServer: true });
+        results.push(...llmResults);
     }
     return results;
 }

package/dist/lib/update-notifier.js

@@ -0,0 +1,146 @@
+"use strict";
+/**
+ * Lightweight CLI update notifier.
+ *
+ * Design goals:
+ *   1. NEVER crash or block the CLI — every call is wrapped in try/catch
+ *   2. Zero npm dependencies — uses only Node built-ins (https, fs, path, os)
+ *   3. Works on Node 14+ — avoids fetch(), AbortController, and other modern APIs
+ *   4. Non-blocking — the HTTP check uses req.unref() so it won't prevent process exit
+ *   5. Cached — checks npm registry at most once per 24 hours
+ *
+ * Flow:
+ *   - On startup: read ~/.orchagent/update-check.json (sync, ~1ms)
+ *   - If cache is stale (>24h): fire off a background HTTPS GET to registry, write result
+ *   - After command completes: if cached version > current version, print one-line notice
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkForUpdates = checkForUpdates;
+exports.printUpdateNotification = printUpdateNotification;
+const https_1 = __importDefault(require("https"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const package_json_1 = __importDefault(require("../../package.json"));
+const PACKAGE_NAME = '@orchagent/cli';
+const CACHE_DIR = path_1.default.join(os_1.default.homedir(), '.orchagent');
+const CACHE_PATH = path_1.default.join(CACHE_DIR, 'update-check.json');
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours
+const REQUEST_TIMEOUT_MS = 5000;
+// ── Cache I/O ──────────────────────────────────────────────────────────
+function readCache() {
+    try {
+        const raw = fs_1.default.readFileSync(CACHE_PATH, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed.latest === 'string' && typeof parsed.checkedAt === 'number') {
+            return parsed;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+function writeCache(latest) {
+    try {
+        fs_1.default.mkdirSync(CACHE_DIR, { recursive: true });
+        fs_1.default.writeFileSync(CACHE_PATH, JSON.stringify({ latest, checkedAt: Date.now() }));
+    }
+    catch {
+        // Best-effort — silently ignore write failures
+    }
+}
+function isCacheStale(cache) {
+    if (!cache)
+        return true;
+    return Date.now() - cache.checkedAt > CHECK_INTERVAL_MS;
+}
+// ── Version comparison ─────────────────────────────────────────────────
+function isNewer(latest, current) {
+    const a = latest.split('.').map(Number);
+    const b = current.split('.').map(Number);
+    for (let i = 0; i < 3; i++) {
+        if ((a[i] || 0) > (b[i] || 0))
+            return true;
+        if ((a[i] || 0) < (b[i] || 0))
+            return false;
+    }
+    return false;
+}
+// ── Background check ───────────────────────────────────────────────────
+function triggerBackgroundCheck() {
+    try {
+        const url = `https://registry.npmjs.org/-/package/${PACKAGE_NAME}/dist-tags`;
+        const req = https_1.default.get(url, { timeout: REQUEST_TIMEOUT_MS }, (res) => {
+            if (res.statusCode !== 200) {
+                res.resume(); // drain
+                return;
+            }
+            let data = '';
+            res.on('data', (chunk) => { data += chunk; });
+            res.on('end', () => {
+                try {
+                    const parsed = JSON.parse(data);
+                    if (typeof parsed.latest === 'string') {
+                        writeCache(parsed.latest);
+                    }
+                }
+                catch {
+                    // Malformed JSON — ignore
+                }
+            });
+        });
+        req.on('error', () => { });
+        req.on('timeout', () => { req.destroy(); });
+        // Don't keep the process alive waiting for this response
+        req.on('socket', (socket) => { socket.unref(); });
+    }
+    catch {
+        // Spawn/setup failure — ignore
+    }
+}
+// ── Public API ──────────────────────────────────────────────────────────
+/** State captured at startup; used later by printUpdateNotification(). */
+let cachedLatest = null;
+/**
+ * Call once at CLI startup. Reads the cache (sync, fast) and fires off
+ * a background registry check if the cache is stale. Never throws.
+ */
+function checkForUpdates() {
+    try {
+        // Respect opt-out
+        if (process.env.NO_UPDATE_NOTIFIER)
+            return;
+        const cache = readCache();
+        if (cache) {
+            cachedLatest = cache.latest;
+        }
+        if (isCacheStale(cache)) {
+            triggerBackgroundCheck();
+        }
+    }
+    catch {
+        // Absolutely never crash
+    }
+}
+/**
+ * Call after the command finishes. Prints a one-line update notice to
+ * stderr if a newer version is available. Never throws.
+ */
+function printUpdateNotification() {
+    try {
+        if (!cachedLatest)
+            return;
+        const current = package_json_1.default.version;
+        if (isNewer(cachedLatest, current)) {
+            process.stderr.write(`\nUpdate available: v${current} → v${cachedLatest}\n` +
+                `Run \`npm update -g @orchagent/cli\` to update\n`);
+        }
+    }
+    catch {
+        // Absolutely never crash
+    }
+}

package/package.json

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

package/dist/commands/llm-config.js

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerLlmConfigCommand = registerLlmConfigCommand;
-const config_1 = require("../lib/config");
-const api_1 = require("../lib/api");
-const errors_1 = require("../lib/errors");
-function registerLlmConfigCommand(program) {
-    program
-        .command('llm-config')
-        .description('Set default LLM configuration for prompt-based agents')
-        .option('--endpoint <url>', 'LLM API base URL (e.g., https://api.openai.com/v1)')
-        .option('--model <model>', 'Default model name (e.g., gpt-4.1-mini)')
-        .option('--api-key <key>', 'LLM API key')
-        .option('--clear', 'Clear the stored default LLM config')
-        .action(async (options) => {
-        const config = await (0, config_1.getResolvedConfig)();
-        if (!config.apiKey) {
-            throw new errors_1.CliError('Missing API key. Run `orchagent login` first.');
-        }
-        if (options.clear) {
-            await (0, api_1.updateOrg)(config, { default_llm_config: null });
-            process.stdout.write('Cleared default LLM config.\n');
-            return;
-        }
-        const endpoint = options.endpoint?.trim();
-        const model = options.model?.trim();
-        const apiKey = options.apiKey?.trim();
-        if (!endpoint || !model || !apiKey) {
-            throw new errors_1.CliError('Missing required flags. Use --endpoint, --model, and --api-key (or --clear).');
-        }
-        await (0, api_1.updateOrg)(config, {
-            default_llm_config: {
-                endpoint,
-                model,
-                api_key: apiKey,
-            },
-        });
-        process.stdout.write('Saved default LLM config.\n');
-    });
-}