@orchagent/cli 0.3.31 → 0.3.34

package/dist/lib/api.js

@@ -48,6 +48,7 @@ exports.starAgent = starAgent;
 exports.unstarAgent = unstarAgent;
 exports.forkAgent = forkAgent;
 exports.searchAgents = searchAgents;
+exports.searchMyAgents = searchMyAgents;
 exports.fetchLlmKeys = fetchLlmKeys;
 exports.downloadCodeBundle = downloadCodeBundle;
 exports.uploadCodeBundle = uploadCodeBundle;
@@ -233,8 +234,16 @@ async function updateOrg(config, payload) {
         headers: { 'Content-Type': 'application/json' },
     });
 }
-async function listPublicAgents(config) {
-    return publicRequest(config, '/public/agents');
+async function listPublicAgents(config, options) {
+    const params = new URLSearchParams();
+    if (options?.sort)
+        params.append('sort', options.sort);
+    if (options?.tags?.length)
+        params.append('tags', options.tags.join(','));
+    if (options?.type)
+        params.append('type', options.type);
+    const queryStr = params.toString();
+    return publicRequest(config, `/public/agents${queryStr ? `?${queryStr}` : ''}`);
 }
 async function getPublicAgent(config, org, agent, version) {
     return publicRequest(config, `/public/agents/${org}/${agent}/${version}`);
@@ -250,7 +259,7 @@ async function createAgent(config, data) {
     });
 }
 async function starAgent(config, agentId) {
-    await request(config, 'POST', `/agents/${agentId}/star`);
+    return request(config, 'POST', `/agents/${agentId}/star`);
 }
 async function unstarAgent(config, agentId) {
     await request(config, 'DELETE', `/agents/${agentId}/star`);
@@ -266,9 +275,68 @@ async function searchAgents(config, query, options) {
         params.append('sort', options.sort);
     if (options?.tags?.length)
         params.append('tags', options.tags.join(','));
+    if (options?.type)
+        params.append('type', options.type);
     const queryStr = params.toString();
     return publicRequest(config, `/public/agents${queryStr ? `?${queryStr}` : ''}`);
 }
+/**
+ * Search within the authenticated user's own agents (public and private).
+ * Uses the authenticated /agents endpoint with client-side filtering.
+ */
+async function searchMyAgents(config, query, options) {
+    let agents = await listMyAgents(config);
+    // Deduplicate: keep only latest version per agent name
+    const latestByName = new Map();
+    for (const agent of agents) {
+        const existing = latestByName.get(agent.name);
+        if (!existing || new Date(agent.created_at) > new Date(existing.created_at)) {
+            latestByName.set(agent.name, agent);
+        }
+    }
+    agents = Array.from(latestByName.values());
+    // Apply type filter
+    if (options?.type) {
+        const typeFilter = options.type;
+        if (typeFilter === 'agents') {
+            agents = agents.filter(a => a.type === 'prompt' || a.type === 'code');
+        }
+        else if (typeFilter === 'skills' || typeFilter === 'skill') {
+            agents = agents.filter(a => a.type === 'skill');
+        }
+        else if (typeFilter === 'code' || typeFilter === 'prompt') {
+            agents = agents.filter(a => a.type === typeFilter);
+        }
+    }
+    // Apply search filter (match against name and description)
+    if (query) {
+        const words = query.toLowerCase().replace(/-/g, ' ').split(/\s+/);
+        agents = agents.filter(a => {
+            const name = (a.name || '').toLowerCase().replace(/-/g, ' ');
+            const desc = (a.description || '').toLowerCase();
+            return words.every(w => name.includes(w) || desc.includes(w));
+        });
+    }
+    // Map Agent to PublicAgent-compatible objects
+    const org = await getOrg(config);
+    return agents.map(a => ({
+        id: a.id,
+        org_name: org.name || org.slug || 'unknown',
+        org_slug: a.org_slug || org.slug || 'unknown',
+        name: a.name,
+        version: a.version,
+        type: a.type,
+        description: a.description,
+        stars_count: a.stars_count ?? 0,
+        tags: a.tags ?? [],
+        default_endpoint: a.default_endpoint || 'analyze',
+        created_at: a.created_at,
+        supported_providers: a.supported_providers ?? ['any'],
+        is_public: a.is_public,
+        pricing_mode: a.pricing_mode,
+        price_per_call_cents: a.price_per_call_cents,
+    }));
+}
 async function fetchLlmKeys(config) {
     const result = await request(config, 'GET', '/llm-keys/export');
     return result.keys;

package/dist/lib/config.js

@@ -43,6 +43,8 @@ exports.getResolvedConfig = getResolvedConfig;
 exports.getConfigPath = getConfigPath;
 exports.getDefaultFormats = getDefaultFormats;
 exports.setDefaultFormats = setDefaultFormats;
+exports.getDefaultScope = getDefaultScope;
+exports.setDefaultScope = setDefaultScope;
 const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
@@ -129,3 +131,12 @@ async function setDefaultFormats(formats) {
     config.default_formats = formats;
     await saveConfig(config);
 }
+async function getDefaultScope() {
+    const config = await loadConfig();
+    return config.default_scope;
+}
+async function setDefaultScope(scope) {
+    const config = await loadConfig();
+    config.default_scope = scope;
+    await saveConfig(config);
+}

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

@@ -1,128 +1,150 @@
 "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' },
+// All supported LLM providers (single source of truth)
+const PROVIDERS = [
+    { id: 'openai', displayName: 'OpenAI', envVars: ['OPENAI_API_KEY'], keyPrefix: 'sk-' },
+    { id: 'anthropic', displayName: 'Anthropic', envVars: ['ANTHROPIC_API_KEY'], keyPrefix: 'sk-ant-' },
+    { id: 'gemini', displayName: 'Gemini', envVars: ['GEMINI_API_KEY', 'GOOGLE_API_KEY'] },
+    { id: 'ollama', displayName: 'Ollama', envVars: ['OLLAMA_HOST'], isEndpoint: true },
 ];
 /**
- * Check if LLM keys are configured on the server.
+ * Get a format hint for a key value, or null if the format looks OK.
+ * Hints are informational only — never errors or warnings.
  */
-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' },
-        };
+function getFormatHint(provider, value) {
+    if ('isEndpoint' in provider && provider.isEndpoint)
+        return null;
+    if (!('keyPrefix' in provider) || !provider.keyPrefix)
+        return null;
+    const prefix = provider.keyPrefix;
+    if (!value.startsWith(prefix)) {
+        return `Key doesn't match expected format (${prefix}...)`;
     }
-    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);
-        // Warn if only one provider configured (no fallback for rate limits)
-        if (keys.length === 1) {
-            return {
-                category: 'llm',
-                name: 'server_llm_keys',
-                status: 'warning',
-                message: `Only 1 LLM provider configured (${providers[0]}). Consider adding a backup for rate limit fallback.`,
-                fix: 'Run: orchagent keys add <provider>',
-                details: { count: keys.length, providers },
-            };
-        }
-        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 null;
+}
+/**
+ * Gather per-provider status from server keys and local env vars.
+ */
+function gatherProviderStatuses(serverProviders) {
+    return PROVIDERS.map((provider) => {
+        // Server status
+        const server = serverProviders === null ? null : serverProviders.includes(provider.id);
+        // Local status — check each env var
+        let local = false;
+        let localEnvVar;
+        let formatHint;
+        for (const envVar of provider.envVars) {
+            const value = process.env[envVar];
+            if (value) {
+                local = true;
+                localEnvVar = envVar;
+                const hint = getFormatHint(provider, value);
+                if (hint)
+                    formatHint = hint;
+                break;
+            }
         }
         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' },
+            providerId: provider.id,
+            displayName: provider.displayName,
+            server,
+            local,
+            localEnvVar,
+            formatHint,
         };
+    });
+}
+/**
+ * Build a human-readable location string from server/local status.
+ */
+function locationString(status) {
+    if (status.server === null) {
+        // Server unknown (offline)
+        if (status.local)
+            return 'Server unknown, local configured';
+        return 'Server unknown, not local';
     }
+    if (status.server && status.local)
+        return 'Configured (server + local)';
+    if (status.server)
+        return 'Configured (server)';
+    if (status.local)
+        return 'Configured (local)';
+    return 'Not configured';
 }
 /**
- * Check if common LLM provider API keys are set in environment.
+ * Run all LLM configuration checks with per-provider breakdown.
+ *
+ * When skipServer is true, server status is null for all providers
+ * (shown as "unknown" in output). Use this when the gateway is unreachable.
  */
-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);
+async function runLlmChecks(options) {
+    let serverProviders = null;
+    if (!options?.skipServer) {
+        try {
+            const config = await (0, config_1.getResolvedConfig)();
+            if (config.apiKey) {
+                const keys = await (0, api_1.fetchLlmKeys)(config);
+                serverProviders = keys.map((k) => k.provider);
+            }
+        }
+        catch (err) {
+            // If we can't reach the server, treat as unknown
+            if (err instanceof api_1.ApiError && err.status === 401) {
+                // Auth failed — server providers unknown
+            }
+            // Network error or other — server providers unknown
         }
     }
-    if (configuredProviders.length === 0) {
-        return {
+    const statuses = gatherProviderStatuses(serverProviders);
+    const results = [];
+    // Per-provider results
+    for (const status of statuses) {
+        const configured = status.server === true || status.local;
+        results.push({
             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,
-        };
+            name: `llm_provider_${status.providerId}`,
+            status: configured ? 'success' : 'info',
+            message: `${status.providerId} — ${locationString(status)}`,
+            details: {
+                providerId: status.providerId,
+                displayName: status.displayName,
+                server: status.server,
+                local: status.local,
+                ...(status.localEnvVar && { localEnvVar: status.localEnvVar }),
+                ...(status.formatHint && { formatHint: status.formatHint }),
+            },
+        });
     }
-    // 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.
- * If server keys are configured, local keys warning becomes informational.
- */
-async function runLlmChecks() {
-    const serverResult = await checkServerLlmKeys();
-    const localResult = await checkLocalLlmEnvVars();
-    // If server keys are configured, downgrade local keys warning to info
-    // Users who only use server-side calls don't need local keys
-    if (serverResult.status === 'success' && localResult.status === 'warning') {
-        localResult.status = 'info';
-        localResult.message = 'No local LLM API keys (using server keys)';
-        localResult.fix = undefined;
+    // Summary result
+    const configuredCount = statuses.filter((s) => s.server === true || s.local).length;
+    const firstUnconfigured = statuses.find((s) => s.server !== true && !s.local);
+    let summaryStatus;
+    let summaryMessage;
+    let summaryFix;
+    if (configuredCount === 0) {
+        summaryStatus = 'warning';
+        summaryMessage = 'No LLM providers configured';
+        summaryFix = firstUnconfigured ? `Run: orch keys add ${firstUnconfigured.providerId}` : undefined;
+    }
+    else {
+        summaryStatus = 'success';
+        summaryMessage =
+            configuredCount < 2
+                ? 'Tip: Multiple providers enable automatic rate limit fallback.'
+                : `${configuredCount} providers configured`;
+        summaryFix = firstUnconfigured ? `Run: orch keys add ${firstUnconfigured.providerId}` : undefined;
     }
-    return [serverResult, localResult];
+    results.push({
+        category: 'llm',
+        name: 'llm_provider_summary',
+        status: summaryStatus,
+        message: summaryMessage,
+        fix: summaryFix,
+        details: { configuredCount, totalProviders: PROVIDERS.length },
+    });
+    return results;
 }

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

@@ -11,17 +11,17 @@ const pricing_1 = require("./pricing");
 function printJson(value) {
     process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
 }
-function printAgentsTable(agents) {
-    const table = new cli_table3_1.default({
-        head: [
-            chalk_1.default.bold('Agent'),
-            chalk_1.default.bold('Type'),
-            chalk_1.default.bold('Providers'),
-            chalk_1.default.bold('Stars'),
-            chalk_1.default.bold('Price'),
-            chalk_1.default.bold('Description'),
-        ],
-    });
+function printAgentsTable(agents, options) {
+    const head = [
+        chalk_1.default.bold('Agent'),
+        chalk_1.default.bold('Type'),
+        ...(options?.showVisibility ? [chalk_1.default.bold('Visibility')] : []),
+        chalk_1.default.bold('Providers'),
+        chalk_1.default.bold('Stars'),
+        chalk_1.default.bold('Price'),
+        chalk_1.default.bold('Description'),
+    ];
+    const table = new cli_table3_1.default({ head });
     agents.forEach((agent) => {
         const fullName = `${agent.org_slug}/${agent.name}`;
         const type = agent.type || 'code';
@@ -34,7 +34,14 @@ function printAgentsTable(agents) {
                 ? agent.description.slice(0, 27) + '...'
                 : agent.description
             : '-';
-        table.push([fullName, type, providers, stars.toString(), priceColored, desc]);
+        const visibility = agent.is_public === false
+            ? chalk_1.default.yellow('private')
+            : chalk_1.default.green('public');
+        const row = [fullName, type];
+        if (options?.showVisibility)
+            row.push(visibility);
+        row.push(providers, stars.toString(), priceColored, desc);
+        table.push(row);
     });
     process.stdout.write(`${table.toString()}\n`);
 }