@orchagent/cli 0.1.0

package/dist/commands/publish.test.js

@@ -0,0 +1,475 @@
+"use strict";
+/**
+ * Tests for the publish command.
+ *
+ * These tests cover publishing agents and skills from local files:
+ * - Reading orchagent.json manifest
+ * - Reading prompt.md for prompt agents
+ * - Reading SKILL.md for skills
+ * - Calling createAgent API with correct payload
+ * - Error handling for missing files
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const commander_1 = require("commander");
+// Mock modules before importing the command
+vitest_1.vi.mock('fs/promises');
+vitest_1.vi.mock('../lib/config');
+vitest_1.vi.mock('../lib/api');
+const promises_1 = __importDefault(require("fs/promises"));
+const publish_1 = require("./publish");
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const mockFs = vitest_1.vi.mocked(promises_1.default);
+const mockGetResolvedConfig = vitest_1.vi.mocked(config_1.getResolvedConfig);
+const mockCreateAgent = vitest_1.vi.mocked(api_1.createAgent);
+const mockGetOrg = vitest_1.vi.mocked(api_1.getOrg);
+(0, vitest_1.describe)('publish command', () => {
+    let program;
+    let stdoutSpy;
+    let stderrSpy;
+    let originalCwd;
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.clearAllMocks();
+        program = new commander_1.Command();
+        program.exitOverride();
+        (0, publish_1.registerPublishCommand)(program);
+        // Mock stdout/stderr
+        stdoutSpy = vitest_1.vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        stderrSpy = vitest_1.vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+        // Mock config
+        mockGetResolvedConfig.mockResolvedValue({
+            apiKey: 'sk_test_123',
+            apiUrl: 'https://api.test.com',
+        });
+        // Mock getOrg
+        mockGetOrg.mockResolvedValue({
+            id: 'org-123',
+            slug: 'test-org',
+            name: 'Test Org',
+        });
+        // Mock createAgent
+        mockCreateAgent.mockResolvedValue({ id: 'agent-123' });
+        // Store original cwd
+        originalCwd = process.cwd;
+        process.cwd = () => '/test/project';
+    });
+    (0, vitest_1.afterEach)(() => {
+        stdoutSpy.mockRestore();
+        stderrSpy.mockRestore();
+        process.cwd = originalCwd;
+        vitest_1.vi.restoreAllMocks();
+    });
+    (0, vitest_1.describe)('publishing from orchagent.json', () => {
+        (0, vitest_1.it)('reads manifest and publishes prompt agent', async () => {
+            const manifest = {
+                name: 'my-agent',
+                version: 'v1',
+                type: 'prompt',
+                description: 'Test agent',
+                tags: ['test'],
+            };
+            mockFs.readFile.mockImplementation(async (filePath) => {
+                const path = String(filePath);
+                if (path.includes('SKILL.md')) {
+                    throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+                }
+                if (path.includes('orchagent.json')) {
+                    return JSON.stringify(manifest);
+                }
+                if (path.includes('prompt.md')) {
+                    return 'You are a helpful assistant.\n\nAnalyze: {{input}}';
+                }
+                if (path.includes('schema.json')) {
+                    throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+                }
+                throw new Error(`Unexpected file: ${path}`);
+            });
+            await program.parseAsync(['node', 'test', 'publish']);
+            (0, vitest_1.expect)(mockCreateAgent).toHaveBeenCalledWith(vitest_1.expect.any(Object), vitest_1.expect.objectContaining({
+                name: 'my-agent',
+                version: 'v1',
+                type: 'prompt',
+                description: 'Test agent',
+                prompt: 'You are a helpful assistant.\n\nAnalyze: {{input}}',
+                tags: ['test'],
+                is_public: true,
+                supported_providers: ['any'],
+            }));
+        });
+        (0, vitest_1.it)('reads schema.json when present', async () => {
+            const manifest = {
+                name: 'schema-agent',
+                version: 'v1',
+                type: 'prompt',
+                description: 'Agent with schemas',
+            };
+            const schemas = {
+                input: { type: 'object', properties: { text: { type: 'string' } } },
+                output: { type: 'object', properties: { result: { type: 'string' } } },
+            };
+            mockFs.readFile.mockImplementation(async (filePath) => {
+                const path = String(filePath);
+                if (path.includes('SKILL.md')) {
+                    throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+                }
+                if (path.includes('orchagent.json')) {
+                    return JSON.stringify(manifest);
+                }
+                if (path.includes('prompt.md')) {
+                    return 'Process: {{text}}';
+                }
+                if (path.includes('schema.json')) {
+                    return JSON.stringify(schemas);
+                }
+                throw new Error(`Unexpected file: ${path}`);
+            });
+            await program.parseAsync(['node', 'test', 'publish']);
+            (0, vitest_1.expect)(mockCreateAgent).toHaveBeenCalledWith(vitest_1.expect.any(Object), vitest_1.expect.objectContaining({
+                input_schema: schemas.input,
+                output_schema: schemas.output,
+            }));
+        });
+        (0, vitest_1.it)('throws error when orchagent.json is missing', async () => {
+            mockFs.readFile.mockImplementation(async (filePath) => {
+                const path = String(filePath);
+                if (path.includes('SKILL.md')) {
+                    throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+                }
+                if (path.includes('orchagent.json')) {
+                    throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+                }
+                throw new Error(`Unexpected file: ${path}`);
+            });
+            await (0, vitest_1.expect)(program.parseAsync(['node', 'test', 'publish'])).rejects.toThrow('No orchagent.json found');
+        });
+        (0, vitest_1.it)('throws error when prompt.md is missing for prompt agent', async () => {
+            const manifest = {
+                name: 'prompt-agent',
+                version: 'v1',
+                type: 'prompt',
+            };
+            mockFs.readFile.mockImplementation(async (filePath) => {
+                const path = String(filePath);
+                if (path.includes('SKILL.md')) {
+                    throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+                }
+                if (path.includes('orchagent.json')) {
+                    return JSON.stringify(manifest);
+                }
+                if (path.includes('prompt.md')) {
+                    throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+                }
+                throw new Error(`Unexpected file: ${path}`);
+            });
+            await (0, vitest_1.expect)(program.parseAsync(['node', 'test', 'publish'])).rejects.toThrow('No prompt.md found');
+        });
+        (0, vitest_1.it)('throws error when manifest missing required fields', async () => {
+            const manifest = {
+                name: 'incomplete-agent',
+                // missing version
+            };
+            mockFs.readFile.mockImplementation(async (filePath) => {
+                const path = String(filePath);
+                if (path.includes('SKILL.md')) {
+                    throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+                }
+                if (path.includes('orchagent.json')) {
+                    return JSON.stringify(manifest);
+                }
+                throw new Error(`Unexpected file: ${path}`);
+            });
+            await (0, vitest_1.expect)(program.parseAsync(['node', 'test', 'publish'])).rejects.toThrow('must have name and version');
+        });
+        (0, vitest_1.it)('requires URL for code-based agents', async () => {
+            const manifest = {
+                name: 'code-agent',
+                version: 'v1',
+                type: 'code',
+            };
+            mockFs.readFile.mockImplementation(async (filePath) => {
+                const path = String(filePath);
+                if (path.includes('SKILL.md')) {
+                    throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+                }
+                if (path.includes('orchagent.json')) {
+                    return JSON.stringify(manifest);
+                }
+                if (path.includes('schema.json')) {
+                    throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+                }
+                throw new Error(`Unexpected file: ${path}`);
+            });
+            await (0, vitest_1.expect)(program.parseAsync(['node', 'test', 'publish'])).rejects.toThrow('URL is required for code-based agents');
+        });
+        (0, vitest_1.it)('publishes code agent with --url option', async () => {
+            const manifest = {
+                name: 'code-agent',
+                version: 'v1',
+                type: 'code',
+                description: 'Code agent',
+            };
+            mockFs.readFile.mockImplementation(async (filePath) => {
+                const path = String(filePath);
+                if (path.includes('SKILL.md')) {
+                    throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+                }
+                if (path.includes('orchagent.json')) {
+                    return JSON.stringify(manifest);
+                }
+                if (path.includes('schema.json')) {
+                    throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+                }
+                throw new Error(`Unexpected file: ${path}`);
+            });
+            await program.parseAsync([
+                'node',
+                'test',
+                'publish',
+                '--url',
+                'https://my-agent.run.app',
+            ]);
+            (0, vitest_1.expect)(mockCreateAgent).toHaveBeenCalledWith(vitest_1.expect.any(Object), vitest_1.expect.objectContaining({
+                name: 'code-agent',
+                type: 'code',
+                url: 'https://my-agent.run.app',
+            }));
+        });
+        (0, vitest_1.it)('respects --private flag', async () => {
+            const manifest = {
+                name: 'private-agent',
+                version: 'v1',
+                type: 'prompt',
+            };
+            mockFs.readFile.mockImplementation(async (filePath) => {
+                const path = String(filePath);
+                if (path.includes('SKILL.md')) {
+                    throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+                }
+                if (path.includes('orchagent.json')) {
+                    return JSON.stringify(manifest);
+                }
+                if (path.includes('prompt.md')) {
+                    return 'Private prompt';
+                }
+                if (path.includes('schema.json')) {
+                    throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+                }
+                throw new Error(`Unexpected file: ${path}`);
+            });
+            await program.parseAsync(['node', 'test', 'publish', '--private']);
+            (0, vitest_1.expect)(mockCreateAgent).toHaveBeenCalledWith(vitest_1.expect.any(Object), vitest_1.expect.objectContaining({
+                is_public: false,
+            }));
+        });
+        (0, vitest_1.it)('uses manifest supported_providers', async () => {
+            const manifest = {
+                name: 'openai-agent',
+                version: 'v1',
+                type: 'prompt',
+                supported_providers: ['openai', 'anthropic'],
+            };
+            mockFs.readFile.mockImplementation(async (filePath) => {
+                const path = String(filePath);
+                if (path.includes('SKILL.md')) {
+                    throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+                }
+                if (path.includes('orchagent.json')) {
+                    return JSON.stringify(manifest);
+                }
+                if (path.includes('prompt.md')) {
+                    return 'Provider-specific prompt';
+                }
+                if (path.includes('schema.json')) {
+                    throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+                }
+                throw new Error(`Unexpected file: ${path}`);
+            });
+            await program.parseAsync(['node', 'test', 'publish']);
+            (0, vitest_1.expect)(mockCreateAgent).toHaveBeenCalledWith(vitest_1.expect.any(Object), vitest_1.expect.objectContaining({
+                supported_providers: ['openai', 'anthropic'],
+            }));
+        });
+        (0, vitest_1.it)('outputs service key when returned', async () => {
+            const manifest = {
+                name: 'service-agent',
+                version: 'v1',
+                type: 'prompt',
+            };
+            mockCreateAgent.mockResolvedValue({
+                id: 'agent-123',
+                service_key: 'sk_service_abc123',
+            });
+            mockFs.readFile.mockImplementation(async (filePath) => {
+                const path = String(filePath);
+                if (path.includes('SKILL.md')) {
+                    throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+                }
+                if (path.includes('orchagent.json')) {
+                    return JSON.stringify(manifest);
+                }
+                if (path.includes('prompt.md')) {
+                    return 'Service prompt';
+                }
+                if (path.includes('schema.json')) {
+                    throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+                }
+                throw new Error(`Unexpected file: ${path}`);
+            });
+            await program.parseAsync(['node', 'test', 'publish']);
+            (0, vitest_1.expect)(stdoutSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining('sk_service_abc123'));
+        });
+    });
+    (0, vitest_1.describe)('publishing from SKILL.md', () => {
+        (0, vitest_1.it)('publishes skill from SKILL.md with frontmatter', async () => {
+            const skillMd = `---
+name: my-skill
+description: A helpful skill
+metadata:
+  version: v2
+---
+You are a helpful skill that does specific things.
+
+Use this prompt to guide the agent.`;
+            mockFs.readFile.mockImplementation(async (filePath) => {
+                const path = String(filePath);
+                if (path.includes('SKILL.md')) {
+                    return skillMd;
+                }
+                throw new Error(`Unexpected file: ${path}`);
+            });
+            await program.parseAsync(['node', 'test', 'publish']);
+            (0, vitest_1.expect)(mockCreateAgent).toHaveBeenCalledWith(vitest_1.expect.any(Object), vitest_1.expect.objectContaining({
+                name: 'my-skill',
+                type: 'skill',
+                description: 'A helpful skill',
+                version: 'v2',
+                prompt: vitest_1.expect.stringContaining('You are a helpful skill'),
+                is_public: true,
+                supported_providers: ['any'],
+            }));
+        });
+        (0, vitest_1.it)('uses default version v1 when not specified', async () => {
+            const skillMd = `---
+name: simple-skill
+description: Simple skill
+---
+Skill content here.`;
+            mockFs.readFile.mockImplementation(async (filePath) => {
+                const path = String(filePath);
+                if (path.includes('SKILL.md')) {
+                    return skillMd;
+                }
+                throw new Error(`Unexpected file: ${path}`);
+            });
+            await program.parseAsync(['node', 'test', 'publish']);
+            (0, vitest_1.expect)(mockCreateAgent).toHaveBeenCalledWith(vitest_1.expect.any(Object), vitest_1.expect.objectContaining({
+                version: 'v1',
+            }));
+        });
+        (0, vitest_1.it)('respects --private flag for skills', async () => {
+            const skillMd = `---
+name: private-skill
+description: Private skill
+---
+Private skill content.`;
+            mockFs.readFile.mockImplementation(async (filePath) => {
+                const path = String(filePath);
+                if (path.includes('SKILL.md')) {
+                    return skillMd;
+                }
+                throw new Error(`Unexpected file: ${path}`);
+            });
+            await program.parseAsync(['node', 'test', 'publish', '--private']);
+            (0, vitest_1.expect)(mockCreateAgent).toHaveBeenCalledWith(vitest_1.expect.any(Object), vitest_1.expect.objectContaining({
+                is_public: false,
+            }));
+        });
+        (0, vitest_1.it)('falls back to manifest if SKILL.md has no frontmatter', async () => {
+            const manifest = {
+                name: 'fallback-agent',
+                version: 'v1',
+                type: 'prompt',
+            };
+            mockFs.readFile.mockImplementation(async (filePath) => {
+                const path = String(filePath);
+                if (path.includes('SKILL.md')) {
+                    // No frontmatter - just content
+                    return 'Just some content without frontmatter';
+                }
+                if (path.includes('orchagent.json')) {
+                    return JSON.stringify(manifest);
+                }
+                if (path.includes('prompt.md')) {
+                    return 'Fallback prompt';
+                }
+                if (path.includes('schema.json')) {
+                    throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+                }
+                throw new Error(`Unexpected file: ${path}`);
+            });
+            await program.parseAsync(['node', 'test', 'publish']);
+            // Should fall back to manifest
+            (0, vitest_1.expect)(mockCreateAgent).toHaveBeenCalledWith(vitest_1.expect.any(Object), vitest_1.expect.objectContaining({
+                name: 'fallback-agent',
+                type: 'prompt',
+            }));
+        });
+        (0, vitest_1.it)('falls back to manifest if SKILL.md missing required fields', async () => {
+            const skillMd = `---
+name: incomplete-skill
+---
+Missing description field.`;
+            const manifest = {
+                name: 'manifest-agent',
+                version: 'v1',
+                type: 'prompt',
+            };
+            mockFs.readFile.mockImplementation(async (filePath) => {
+                const path = String(filePath);
+                if (path.includes('SKILL.md')) {
+                    return skillMd;
+                }
+                if (path.includes('orchagent.json')) {
+                    return JSON.stringify(manifest);
+                }
+                if (path.includes('prompt.md')) {
+                    return 'Manifest prompt';
+                }
+                if (path.includes('schema.json')) {
+                    throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+                }
+                throw new Error(`Unexpected file: ${path}`);
+            });
+            await program.parseAsync(['node', 'test', 'publish']);
+            // Should fall back to manifest since SKILL.md is incomplete
+            (0, vitest_1.expect)(mockCreateAgent).toHaveBeenCalledWith(vitest_1.expect.any(Object), vitest_1.expect.objectContaining({
+                name: 'manifest-agent',
+                type: 'prompt',
+            }));
+        });
+        (0, vitest_1.it)('outputs correct skill publish message', async () => {
+            const skillMd = `---
+name: output-skill
+description: Test output
+metadata:
+  version: v3
+---
+Skill prompt.`;
+            mockFs.readFile.mockImplementation(async (filePath) => {
+                const path = String(filePath);
+                if (path.includes('SKILL.md')) {
+                    return skillMd;
+                }
+                throw new Error(`Unexpected file: ${path}`);
+            });
+            await program.parseAsync(['node', 'test', 'publish']);
+            (0, vitest_1.expect)(stdoutSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining('Published skill'));
+            (0, vitest_1.expect)(stdoutSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining('test-org/output-skill'));
+            (0, vitest_1.expect)(stdoutSpy).toHaveBeenCalledWith(vitest_1.expect.stringContaining('Version: v3'));
+        });
+    });
+});