@orchagent/cli 0.3.31 → 0.3.33

package/dist/commands/update.js

@@ -53,100 +53,135 @@ function registerUpdateCommand(program) {
             process.stdout.write(`Agent "${agentRef}" is not installed.\n`);
             return;
         }
-        process.stdout.write(`Checking ${toCheck.length} installed agent(s) for updates...\n\n`);
+        // Group installed entries by agent name to avoid duplicates
+        // (same agent installed to multiple formats shows once)
+        const grouped = new Map();
+        for (const item of toCheck) {
+            const existing = grouped.get(item.agent);
+            if (existing) {
+                existing.push(item);
+            }
+            else {
+                grouped.set(item.agent, [item]);
+            }
+        }
+        process.stdout.write(`Checking ${grouped.size} installed agent(s) for updates...\n\n`);
         let updatesAvailable = 0;
         let updatesApplied = 0;
         let skippedModified = 0;
         let skippedMissing = 0;
-        for (const item of toCheck) {
-            // Check if file was modified locally or is missing
-            const fileStatus = await (0, installed_1.checkModified)(item);
-            // Fetch latest version
-            const latest = await fetchLatestAgent(resolved, item.agent);
+        for (const [agentName, entries] of grouped) {
+            // Check file status for all entries in this group
+            const fileStatuses = [];
+            for (const item of entries) {
+                fileStatuses.push({ item, status: await (0, installed_1.checkModified)(item) });
+            }
+            // Fetch latest version once per agent
+            const latest = await fetchLatestAgent(resolved, agentName);
             if (!latest) {
-                process.stdout.write(`  ${chalk_1.default.yellow('?')} ${item.agent} - could not fetch latest\n`);
+                process.stdout.write(`  ${chalk_1.default.yellow('?')} ${agentName} - could not fetch latest\n`);
                 continue;
             }
-            const hasUpdate = latest.latestVersion !== item.version;
-            if (!hasUpdate && !fileStatus.modified && !fileStatus.missing) {
-                process.stdout.write(`  ${chalk_1.default.green('✓')} ${item.agent}@${item.version} - up to date\n`);
+            // Use the version from the first entry (all entries for the same
+            // agent should share the same version after install/update)
+            const installedVersion = entries[0].version;
+            const hasUpdate = latest.latestVersion !== installedVersion;
+            const anyMissing = fileStatuses.some(f => f.status.missing);
+            const anyModified = fileStatuses.some(f => f.status.modified);
+            if (!hasUpdate && !anyModified && !anyMissing) {
+                const formatSuffix = entries.length > 1
+                    ? ` ${chalk_1.default.dim(`(${entries.map(e => e.format).join(', ')})`)}`
+                    : '';
+                process.stdout.write(`  ${chalk_1.default.green('✓')} ${agentName}@${installedVersion} - up to date${formatSuffix}\n`);
                 continue;
             }
-            // Handle missing file without --force
-            if (fileStatus.missing && !options.force) {
-                process.stdout.write(`  ${chalk_1.default.yellow('!')} ${item.agent} - file missing (use --force to reinstall)\n`);
+            // Handle missing files without --force
+            if (anyMissing && !hasUpdate && !options.force) {
+                const missingFormats = fileStatuses.filter(f => f.status.missing).map(f => f.item.format);
+                process.stdout.write(`  ${chalk_1.default.yellow('!')} ${agentName} - file missing [${missingFormats.join(', ')}] (use --force to reinstall)\n`);
                 skippedMissing++;
                 continue;
             }
-            // Handle modified file without --force
-            if (fileStatus.modified && !options.force) {
-                process.stdout.write(`  ${chalk_1.default.yellow('!')} ${item.agent} - local modifications (use --force to overwrite)\n`);
+            // Handle modified files without --force
+            if (anyModified && !hasUpdate && !options.force) {
+                const modifiedFormats = fileStatuses.filter(f => f.status.modified).map(f => f.item.format);
+                process.stdout.write(`  ${chalk_1.default.yellow('!')} ${agentName} - local modifications [${modifiedFormats.join(', ')}] (use --force to overwrite)\n`);
                 skippedModified++;
                 continue;
             }
-            if (hasUpdate || fileStatus.missing) {
+            if (hasUpdate || anyMissing) {
                 if (hasUpdate) {
                     updatesAvailable++;
                 }
-                process.stdout.write(`  ${chalk_1.default.blue('↑')} ${item.agent}@${item.version} → ${latest.latestVersion}`);
-                if (fileStatus.modified) {
+                process.stdout.write(`  ${chalk_1.default.blue('↑')} ${agentName}@${installedVersion} → ${latest.latestVersion}`);
+                if (anyModified) {
                     process.stdout.write(` ${chalk_1.default.yellow('(modified)')}`);
                 }
-                if (fileStatus.missing) {
+                if (anyMissing) {
                     process.stdout.write(` ${chalk_1.default.yellow('(reinstalling)')}`);
                 }
                 process.stdout.write('\n');
                 if (options.check) {
                     continue;
                 }
-                // Apply update
-                const adapter = adapters_1.adapterRegistry.get(item.format);
-                if (!adapter) {
-                    process.stderr.write(`    Skipped: Unknown format "${item.format}"\n`);
-                    continue;
-                }
-                const checkResult = adapter.canConvert(latest.agent);
-                if (!checkResult.canConvert) {
-                    process.stderr.write(`    Skipped: ${checkResult.errors.join(', ')}\n`);
-                    continue;
-                }
-                const files = adapter.convert(latest.agent);
-                if (files.length > 1) {
-                    process.stderr.write(`    Skipped: Multi-file adapters not supported for update. Reinstall instead.\n`);
-                    continue;
-                }
-                for (const file of files) {
-                    // Use the original path from tracking
-                    const fullPath = item.path;
-                    try {
-                        const dir = path_1.default.dirname(fullPath);
-                        await promises_1.default.mkdir(dir, { recursive: true });
-                        // Special handling for AGENTS.md - append/replace instead of overwrite
-                        if (file.filename === 'AGENTS.md') {
-                            let existingContent = '';
-                            try {
-                                existingContent = await promises_1.default.readFile(fullPath, 'utf-8');
-                            }
-                            catch {
-                                // File doesn't exist, will create new
+                // Apply update to each format entry
+                for (const { item, status: fileStatus } of fileStatuses) {
+                    // Skip unmodified and non-missing entries if no version update
+                    if (!hasUpdate && !fileStatus.missing)
+                        continue;
+                    // Skip modified entries without --force
+                    if (fileStatus.modified && !options.force) {
+                        process.stderr.write(`    Skipped ${item.format}: local modifications (use --force)\n`);
+                        continue;
+                    }
+                    const adapter = adapters_1.adapterRegistry.get(item.format);
+                    if (!adapter) {
+                        process.stderr.write(`    Skipped ${item.format}: unknown format\n`);
+                        continue;
+                    }
+                    const checkResult = adapter.canConvert(latest.agent);
+                    if (!checkResult.canConvert) {
+                        process.stderr.write(`    Skipped ${item.format}: ${checkResult.errors.join(', ')}\n`);
+                        continue;
+                    }
+                    const files = adapter.convert(latest.agent);
+                    if (files.length > 1) {
+                        process.stderr.write(`    Skipped ${item.format}: multi-file adapters not supported for update. Reinstall instead.\n`);
+                        continue;
+                    }
+                    for (const file of files) {
+                        // Use the original path from tracking
+                        const fullPath = item.path;
+                        try {
+                            const dir = path_1.default.dirname(fullPath);
+                            await promises_1.default.mkdir(dir, { recursive: true });
+                            // Special handling for AGENTS.md - append/replace instead of overwrite
+                            if (file.filename === 'AGENTS.md') {
+                                let existingContent = '';
+                                try {
+                                    existingContent = await promises_1.default.readFile(fullPath, 'utf-8');
+                                }
+                                catch {
+                                    // File doesn't exist, will create new
+                                }
+                                file.content = (0, agents_md_utils_1.mergeAgentsMdContent)(existingContent, file.content, item.agent);
                             }
-                            file.content = (0, agents_md_utils_1.mergeAgentsMdContent)(existingContent, file.content, item.agent);
+                            await promises_1.default.writeFile(fullPath, file.content);
+                            // Update tracking
+                            const updatedItem = {
+                                ...item,
+                                version: latest.latestVersion,
+                                installedAt: new Date().toISOString(),
+                                adapterVersion: adapter.version,
+                                contentHash: (0, installed_1.computeHash)(file.content),
+                            };
+                            await (0, installed_1.trackInstall)(updatedItem);
+                            process.stdout.write(`    Updated: ${fullPath}\n`);
+                            updatesApplied++;
+                        }
+                        catch (err) {
+                            process.stderr.write(`    Error (${item.format}): ${err.message}\n`);
                         }
-                        await promises_1.default.writeFile(fullPath, file.content);
-                        // Update tracking
-                        const updatedItem = {
-                            ...item,
-                            version: latest.latestVersion,
-                            installedAt: new Date().toISOString(),
-                            adapterVersion: adapter.version,
-                            contentHash: (0, installed_1.computeHash)(file.content),
-                        };
-                        await (0, installed_1.trackInstall)(updatedItem);
-                        process.stdout.write(`    Updated: ${fullPath}\n`);
-                        updatesApplied++;
-                    }
-                    catch (err) {
-                        process.stderr.write(`    Error: ${err.message}\n`);
                     }
                 }
             }

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,14 @@ 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?.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}`);
@@ -266,9 +273,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/api.test.js

@@ -0,0 +1,230 @@
+"use strict";
+/**
+ * Tests for API client functions.
+ *
+ * These tests cover the core API client that all CLI commands depend on:
+ * - Request building and authentication
+ * - Error parsing
+ * - Public vs authenticated requests
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const api_1 = require("./api");
+// Mock fetch globally
+const mockFetch = vitest_1.vi.fn();
+global.fetch = mockFetch;
+(0, vitest_1.describe)('ApiError', () => {
+    (0, vitest_1.it)('includes status code and message', () => {
+        const error = new api_1.ApiError('Not found', 404);
+        (0, vitest_1.expect)(error.message).toBe('Not found');
+        (0, vitest_1.expect)(error.status).toBe(404);
+    });
+    (0, vitest_1.it)('includes optional payload', () => {
+        const payload = { error: { code: 'NOT_FOUND' } };
+        const error = new api_1.ApiError('Not found', 404, payload);
+        (0, vitest_1.expect)(error.payload).toEqual(payload);
+    });
+});
+(0, vitest_1.describe)('request', () => {
+    const config = {
+        apiKey: 'sk_test_123',
+        apiUrl: 'https://api.test.com',
+    };
+    (0, vitest_1.beforeEach)(() => {
+        mockFetch.mockReset();
+    });
+    (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.restoreAllMocks();
+    });
+    (0, vitest_1.it)('adds Authorization header with Bearer token', async () => {
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({ data: 'test' }),
+        });
+        await (0, api_1.request)(config, 'GET', '/test');
+        (0, vitest_1.expect)(mockFetch).toHaveBeenCalledWith('https://api.test.com/test', vitest_1.expect.objectContaining({
+            method: 'GET',
+            headers: vitest_1.expect.objectContaining({
+                Authorization: 'Bearer sk_test_123',
+            }),
+        }));
+    });
+    (0, vitest_1.it)('returns parsed JSON response', async () => {
+        const responseData = { org: 'test', slug: 'test-org' };
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve(responseData),
+        });
+        const result = await (0, api_1.request)(config, 'GET', '/org');
+        (0, vitest_1.expect)(result).toEqual(responseData);
+    });
+    (0, vitest_1.it)('throws ApiError when response not ok', async () => {
+        mockFetch.mockResolvedValueOnce({
+            ok: false,
+            status: 404,
+            statusText: 'Not Found',
+            text: () => Promise.resolve(JSON.stringify({
+                error: { message: 'Agent not found' }
+            })),
+        });
+        await (0, vitest_1.expect)((0, api_1.request)(config, 'GET', '/agents/missing'))
+            .rejects.toThrow(api_1.ApiError);
+    });
+    (0, vitest_1.it)('throws ApiError with 401 when no API key', async () => {
+        const noKeyConfig = {
+            apiKey: undefined,
+            apiUrl: 'https://api.test.com',
+        };
+        await (0, vitest_1.expect)((0, api_1.request)(noKeyConfig, 'GET', '/test'))
+            .rejects.toThrow('Missing API key');
+    });
+    (0, vitest_1.it)('parses error message from JSON response', async () => {
+        mockFetch.mockResolvedValueOnce({
+            ok: false,
+            status: 403,
+            statusText: 'Forbidden',
+            text: () => Promise.resolve(JSON.stringify({
+                error: { message: 'Access denied to private agent' }
+            })),
+        });
+        try {
+            await (0, api_1.request)(config, 'GET', '/agents/private');
+            vitest_1.expect.fail('Should have thrown');
+        }
+        catch (error) {
+            (0, vitest_1.expect)(error).toBeInstanceOf(api_1.ApiError);
+            (0, vitest_1.expect)(error.message).toBe('Access denied to private agent');
+            (0, vitest_1.expect)(error.status).toBe(403);
+        }
+    });
+    (0, vitest_1.it)('uses statusText when no JSON message', async () => {
+        mockFetch.mockResolvedValueOnce({
+            ok: false,
+            status: 500,
+            statusText: 'Internal Server Error',
+            text: () => Promise.resolve('not json'),
+        });
+        try {
+            await (0, api_1.request)(config, 'GET', '/broken');
+            vitest_1.expect.fail('Should have thrown');
+        }
+        catch (error) {
+            (0, vitest_1.expect)(error).toBeInstanceOf(api_1.ApiError);
+            (0, vitest_1.expect)(error.message).toBe('Internal Server Error');
+        }
+    });
+    (0, vitest_1.it)('includes custom headers', async () => {
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({}),
+        });
+        await (0, api_1.request)(config, 'POST', '/agents', {
+            body: JSON.stringify({ name: 'test' }),
+            headers: { 'Content-Type': 'application/json' },
+        });
+        (0, vitest_1.expect)(mockFetch).toHaveBeenCalledWith(vitest_1.expect.any(String), vitest_1.expect.objectContaining({
+            headers: vitest_1.expect.objectContaining({
+                'Content-Type': 'application/json',
+                Authorization: 'Bearer sk_test_123',
+            }),
+        }));
+    });
+    (0, vitest_1.it)('strips trailing slash from API URL', async () => {
+        const configWithSlash = {
+            apiKey: 'sk_test_123',
+            apiUrl: 'https://api.test.com/',
+        };
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({}),
+        });
+        await (0, api_1.request)(configWithSlash, 'GET', '/test');
+        (0, vitest_1.expect)(mockFetch).toHaveBeenCalledWith('https://api.test.com/test', vitest_1.expect.any(Object));
+    });
+});
+(0, vitest_1.describe)('publicRequest', () => {
+    const config = {
+        apiUrl: 'https://api.test.com',
+    };
+    (0, vitest_1.beforeEach)(() => {
+        mockFetch.mockReset();
+    });
+    (0, vitest_1.it)('makes unauthenticated request', async () => {
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve([]),
+        });
+        await (0, api_1.publicRequest)(config, '/public/agents');
+        (0, vitest_1.expect)(mockFetch).toHaveBeenCalledWith('https://api.test.com/public/agents');
+    });
+    (0, vitest_1.it)('returns parsed JSON', async () => {
+        const agents = [{ name: 'agent1' }, { name: 'agent2' }];
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve(agents),
+        });
+        const result = await (0, api_1.publicRequest)(config, '/public/agents');
+        (0, vitest_1.expect)(result).toEqual(agents);
+    });
+    (0, vitest_1.it)('throws ApiError on failure', async () => {
+        mockFetch.mockResolvedValueOnce({
+            ok: false,
+            status: 404,
+            statusText: 'Not Found',
+            text: () => Promise.resolve('{}'),
+        });
+        await (0, vitest_1.expect)((0, api_1.publicRequest)(config, '/public/agents/missing'))
+            .rejects.toThrow(api_1.ApiError);
+    });
+});
+(0, vitest_1.describe)('getOrg', () => {
+    const config = {
+        apiKey: 'sk_test_123',
+        apiUrl: 'https://api.test.com',
+    };
+    (0, vitest_1.beforeEach)(() => {
+        mockFetch.mockReset();
+    });
+    (0, vitest_1.it)('calls GET /org endpoint', async () => {
+        const orgData = { id: '123', slug: 'test-org', name: 'Test Org' };
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve(orgData),
+        });
+        const result = await (0, api_1.getOrg)(config);
+        (0, vitest_1.expect)(mockFetch).toHaveBeenCalledWith('https://api.test.com/org', vitest_1.expect.objectContaining({ method: 'GET' }));
+        (0, vitest_1.expect)(result).toEqual(orgData);
+    });
+});
+(0, vitest_1.describe)('searchAgents', () => {
+    const config = {
+        apiUrl: 'https://api.test.com',
+    };
+    (0, vitest_1.beforeEach)(() => {
+        mockFetch.mockReset();
+    });
+    (0, vitest_1.it)('builds search query params', async () => {
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve([]),
+        });
+        await (0, api_1.searchAgents)(config, 'pdf analyzer', { sort: 'stars' });
+        (0, vitest_1.expect)(mockFetch).toHaveBeenCalledWith('https://api.test.com/public/agents?search=pdf+analyzer&sort=stars');
+    });
+    (0, vitest_1.it)('handles empty query', async () => {
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve([]),
+        });
+        await (0, api_1.searchAgents)(config, '');
+        (0, vitest_1.expect)(mockFetch).toHaveBeenCalledWith('https://api.test.com/public/agents');
+    });
+    (0, vitest_1.it)('includes tags in query', async () => {
+        mockFetch.mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve([]),
+        });
+        await (0, api_1.searchAgents)(config, 'test', { tags: ['ai', 'document'] });
+        (0, vitest_1.expect)(mockFetch).toHaveBeenCalledWith(vitest_1.expect.stringContaining('tags=ai%2Cdocument'));
+    });
+});

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);
+}