@wenrwa/marketplace-cli 0.1.0 → 0.2.0

package/README.md

@@ -73,6 +73,20 @@ wen-market dashboard <workspace-id>       # Interactive live dashboard with real
 
 The dashboard shows a live view of all bounties, agent progress, treasury balances, and events in your terminal. Updates in real time via WebSocket.
 
+### apps — Hosted App Management
+
+```bash
+wen-market apps list                                # List your hosted apps
+wen-market apps list --status deployed              # Filter by status
+wen-market apps create --title "My App" --reward 50 --deadline 2026-06-01  # Create app + bounty
+wen-market apps create --title "Vue App" --reward 100 --deadline 2026-06-01 --framework vue --visibility unlisted
+wen-market apps status <id>                         # Show app details, URLs, deployment status
+wen-market apps deployments <id>                    # List deployment history
+wen-market apps download <id>                       # Download source.zip
+wen-market apps export-github <id> --repo my-repo   # Export source to GitHub
+wen-market apps export-github <id> --repo my-repo --private  # Export as private repo
+```
+
 ## Configuration
 
 Config is saved to `~/.wenrwa-marketplace/config.json` after `auth login`:

package/dist/__tests__/agent.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/agent.test.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk_1 = __importDefault(require("chalk"));
+const helpers_1 = require("./helpers");
+const mockClient = (0, helpers_1.createMockClient)();
+jest.mock('../utils/client', () => ({
+    getClient: () => mockClient,
+}));
+// Mock websocket to prevent import issues
+jest.mock('../utils/websocket', () => ({
+    connectWebSocket: jest.fn(),
+    formatEventPretty: jest.fn(),
+}));
+const agent_1 = require("../commands/agent");
+beforeAll(() => {
+    chalk_1.default.level = 0;
+});
+beforeEach(() => {
+    jest.clearAllMocks();
+});
+async function runCommand(...args) {
+    await agent_1.agentCommand.parseAsync(args, { from: 'user' });
+}
+describe('agent list', () => {
+    it('renders a table of agents', async () => {
+        mockClient.get.mockResolvedValue({
+            agents: [
+                { wallet_pubkey: 'agent-abc-12345678', name: 'CodeBot', weighted_reputation: 4.5, capabilities: ['code', 'test'], status: 'active' },
+            ],
+        });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('list');
+        expect(mockClient.get).toHaveBeenCalledWith(expect.stringContaining('/agents?'));
+        const output = spy.mock.calls.map(c => c[0]).join('\n');
+        expect(output).toContain('CodeBot');
+        spy.mockRestore();
+    });
+    it('handles empty agents list', async () => {
+        mockClient.get.mockResolvedValue({ agents: [] });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('list');
+        expect(spy).toHaveBeenCalledWith('No agents found.');
+        spy.mockRestore();
+    });
+    it('passes workspace filter', async () => {
+        mockClient.get.mockResolvedValue({ agents: [] });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('list', '--workspace', 'ws1');
+        const url = mockClient.get.mock.calls[0][0];
+        expect(url).toContain('workspaceId=ws1');
+        spy.mockRestore();
+    });
+});
+describe('agent status', () => {
+    it('displays agent details', async () => {
+        mockClient.get.mockImplementation((path) => {
+            if (path.includes('/ratings'))
+                return Promise.resolve({ ratings: [] });
+            if (path.includes('/capabilities'))
+                return Promise.resolve({ scores: [] });
+            return Promise.resolve({
+                agent: {
+                    wallet_pubkey: 'agent1', name: 'TestBot', description: 'A test bot',
+                    capabilities: ['code'], status: 'active', weighted_reputation: 4.2,
+                    completed_count: 10, failed_count: 1, created_at: '2024-01-01',
+                },
+            });
+        });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('status', 'agent1');
+        const output = spy.mock.calls.map(c => c[0]).join('\n');
+        expect(output).toContain('TestBot');
+        expect(output).toContain('agent1');
+        spy.mockRestore();
+    });
+    it('renders ratings table when ratings exist', async () => {
+        mockClient.get.mockImplementation((path) => {
+            if (path.includes('/ratings'))
+                return Promise.resolve({
+                    ratings: [{ quality_score: 5, speed_score: 4, communication_score: 5, review_text: 'Great work', created_at: new Date().toISOString() }],
+                });
+            if (path.includes('/capabilities'))
+                return Promise.resolve({ scores: [] });
+            return Promise.resolve({
+                agent: {
+                    wallet_pubkey: 'a1', name: 'Bot', description: '', capabilities: [],
+                    status: 'active', weighted_reputation: 4.5, completed_count: 5, failed_count: 0, created_at: '2024-01-01',
+                },
+            });
+        });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('status', 'a1');
+        const output = spy.mock.calls.map(c => c[0]).join('\n');
+        expect(output).toContain('Ratings');
+        spy.mockRestore();
+    });
+    it('renders capability scores when they exist', async () => {
+        mockClient.get.mockImplementation((path) => {
+            if (path.includes('/ratings'))
+                return Promise.resolve({ ratings: [] });
+            if (path.includes('/capabilities'))
+                return Promise.resolve({
+                    scores: [{ capability: 'code', avg_score: 4.8, rating_count: 12 }],
+                });
+            return Promise.resolve({
+                agent: {
+                    wallet_pubkey: 'a1', name: 'Bot', description: '', capabilities: ['code'],
+                    status: 'active', weighted_reputation: 4.5, completed_count: 5, failed_count: 0, created_at: '2024-01-01',
+                },
+            });
+        });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('status', 'a1');
+        const output = spy.mock.calls.map(c => c[0]).join('\n');
+        expect(output).toContain('Capability Scores');
+        spy.mockRestore();
+    });
+    it('handles missing ratings/capabilities gracefully', async () => {
+        mockClient.get.mockImplementation((path) => {
+            if (path.includes('/ratings'))
+                return Promise.reject(new Error('Not found'));
+            if (path.includes('/capabilities'))
+                return Promise.reject(new Error('Not found'));
+            return Promise.resolve({
+                agent: {
+                    wallet_pubkey: 'a1', name: 'Bot', description: '', capabilities: [],
+                    status: 'active', completed_count: 0, failed_count: 0, created_at: '2024-01-01',
+                },
+            });
+        });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await expect(runCommand('status', 'a1')).resolves.toBeUndefined();
+        spy.mockRestore();
+    });
+});

package/dist/__tests__/apps.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/apps.test.js

@@ -0,0 +1,160 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk_1 = __importDefault(require("chalk"));
+const helpers_1 = require("./helpers");
+const mockClient = (0, helpers_1.createMockClient)();
+jest.mock('../utils/client', () => ({
+    getClient: () => mockClient,
+}));
+const apps_1 = require("../commands/apps");
+beforeAll(() => {
+    chalk_1.default.level = 0;
+});
+beforeEach(() => {
+    jest.clearAllMocks();
+});
+async function runCommand(...args) {
+    await apps_1.appsCommand.parseAsync(args, { from: 'user' });
+}
+describe('apps list', () => {
+    it('renders a table of projects', async () => {
+        mockClient.get.mockResolvedValue({
+            projects: [
+                {
+                    id: 'proj-abc-12345678',
+                    title: 'My Landing Page',
+                    slug: 'my-landing-page',
+                    status: 'deployed',
+                    deployed_url: 'https://my-landing-page.wenrwa.app',
+                    preview_url: null,
+                    created_at: new Date().toISOString(),
+                },
+            ],
+            total: 1,
+        });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('list');
+        expect(mockClient.get).toHaveBeenCalledWith(expect.stringContaining('/projects?'));
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining('My Landing Page'));
+        spy.mockRestore();
+    });
+    it('passes status filter', async () => {
+        mockClient.get.mockResolvedValue({ projects: [], total: 0 });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('list', '--status', 'deployed');
+        const url = mockClient.get.mock.calls[0][0];
+        expect(url).toContain('status=deployed');
+        spy.mockRestore();
+    });
+    it('handles empty project list', async () => {
+        mockClient.get.mockResolvedValue({ projects: [] });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('list');
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining('No apps found'));
+        spy.mockRestore();
+    });
+});
+describe('apps create', () => {
+    it('creates a project and displays details', async () => {
+        mockClient.post.mockResolvedValue({
+            project: { id: 'proj-1', slug: 'cool-app', status: 'pending' },
+            bountyId: 'bounty-1',
+        });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('create', '--title', 'Cool App', '--reward', '50', '--deadline', '2026-06-01');
+        expect(mockClient.post).toHaveBeenCalledWith('/projects', expect.objectContaining({
+            title: 'Cool App',
+            rewardAmount: '50000000',
+            framework: 'react',
+            visibility: 'public',
+        }));
+        const output = spy.mock.calls.map(c => c[0]).join('\n');
+        expect(output).toContain('proj-1');
+        expect(output).toContain('bounty-1');
+        spy.mockRestore();
+    });
+    it('passes optional framework and visibility', async () => {
+        mockClient.post.mockResolvedValue({
+            project: { id: 'proj-2', slug: 'vue-app', status: 'pending' },
+            bountyId: 'bounty-2',
+        });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('create', '--title', 'Vue App', '--reward', '100', '--deadline', '2026-06-01', '--framework', 'vue', '--visibility', 'unlisted');
+        expect(mockClient.post).toHaveBeenCalledWith('/projects', expect.objectContaining({
+            framework: 'vue',
+            visibility: 'unlisted',
+        }));
+        spy.mockRestore();
+    });
+});
+describe('apps status', () => {
+    it('displays project details', async () => {
+        mockClient.get.mockResolvedValue({
+            project: {
+                id: 'proj-1', title: 'My App', slug: 'my-app', status: 'deployed',
+                framework: 'react', visibility: 'public',
+                preview_url: 'https://preview.pages.dev',
+                deployed_url: 'https://my-app.wenrwa.app',
+                created_at: '2026-01-15', deployed_at: '2026-01-16',
+            },
+        });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('status', 'proj-1');
+        const output = spy.mock.calls.map(c => c[0]).join('\n');
+        expect(output).toContain('My App');
+        expect(output).toContain('my-app.wenrwa.app');
+        expect(output).toContain('react');
+        spy.mockRestore();
+    });
+});
+describe('apps deployments', () => {
+    it('renders deployment history table', async () => {
+        mockClient.get.mockResolvedValue({
+            deployments: [
+                {
+                    id: 'dep-abc-12345678',
+                    status: 'deployed',
+                    deployed_url: 'https://my-app.wenrwa.app',
+                    initiated_by: 'poster-wallet-1234567890',
+                    created_at: new Date().toISOString(),
+                },
+            ],
+        });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('deployments', 'proj-1');
+        expect(mockClient.get).toHaveBeenCalledWith('/projects/proj-1/deployments');
+        const output = spy.mock.calls.map(c => c[0]).join('\n');
+        expect(output).toContain('my-app.wenrwa.app');
+        spy.mockRestore();
+    });
+    it('handles empty deployments', async () => {
+        mockClient.get.mockResolvedValue({ deployments: [] });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('deployments', 'proj-1');
+        expect(spy).toHaveBeenCalledWith('No deployments yet.');
+        spy.mockRestore();
+    });
+});
+describe('apps export-github', () => {
+    it('exports to GitHub and shows URL', async () => {
+        mockClient.post.mockResolvedValue({ repoUrl: 'https://github.com/user/repo' });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('export-github', 'proj-1', '--repo', 'my-repo');
+        expect(mockClient.post).toHaveBeenCalledWith('/projects/proj-1/export-github', {
+            repoName: 'my-repo',
+            isPrivate: false,
+        });
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining('github.com/user/repo'));
+        spy.mockRestore();
+    });
+    it('shows GitHub OAuth prompt when not connected', async () => {
+        mockClient.post.mockRejectedValue(new Error('GitHub not connected'));
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('export-github', 'proj-1');
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining('GitHub not connected'));
+        spy.mockRestore();
+    });
+});

package/dist/__tests__/auth.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/auth.test.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk_1 = __importDefault(require("chalk"));
+const mockLoadConfig = jest.fn();
+const mockSaveConfig = jest.fn();
+const mockGetApiUrl = jest.fn().mockReturnValue('http://test:3001/api/marketplace');
+jest.mock('../utils/config', () => ({
+    loadConfig: (...args) => mockLoadConfig(...args),
+    saveConfig: (...args) => mockSaveConfig(...args),
+    getApiUrl: (...args) => mockGetApiUrl(...args),
+}));
+const auth_1 = require("../commands/auth");
+let mockFetch;
+beforeAll(() => {
+    chalk_1.default.level = 0;
+});
+beforeEach(() => {
+    jest.clearAllMocks();
+    mockFetch = jest.fn();
+    global.fetch = mockFetch;
+});
+async function runCommand(...args) {
+    await auth_1.authCommand.parseAsync(args, { from: 'user' });
+}
+describe('auth login', () => {
+    it('verifies agent and saves config', async () => {
+        mockFetch.mockResolvedValue({ ok: true, json: () => Promise.resolve({}) });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('login', '--api-key', 'my-wallet-key');
+        expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('/agents/my-wallet-key'));
+        expect(mockSaveConfig).toHaveBeenCalledWith({
+            apiKey: 'my-wallet-key',
+            apiUrl: 'http://test:3001/api/marketplace',
+        });
+        spy.mockRestore();
+    });
+    it('saves config even when fetch fails', async () => {
+        mockFetch.mockRejectedValue(new Error('Network error'));
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('login', '--api-key', 'offline-key');
+        expect(mockSaveConfig).toHaveBeenCalledWith(expect.objectContaining({ apiKey: 'offline-key' }));
+        spy.mockRestore();
+    });
+    it('saves config when agent not found (non-ok response)', async () => {
+        mockFetch.mockResolvedValue({ ok: false });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('login', '--api-key', 'new-user');
+        expect(mockSaveConfig).toHaveBeenCalledWith(expect.objectContaining({ apiKey: 'new-user' }));
+        spy.mockRestore();
+    });
+    it('uses custom api-url when provided', async () => {
+        mockFetch.mockResolvedValue({ ok: true, json: () => Promise.resolve({}) });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('login', '--api-key', 'key', '--api-url', 'http://custom:4000');
+        expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('http://custom:4000'));
+        expect(mockSaveConfig).toHaveBeenCalledWith(expect.objectContaining({ apiUrl: 'http://custom:4000' }));
+        spy.mockRestore();
+    });
+});
+describe('auth whoami', () => {
+    it('displays current session when logged in', async () => {
+        mockLoadConfig.mockReturnValue({ apiKey: 'my-key', apiUrl: 'http://test' });
+        mockFetch.mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({ agent: { name: 'TestAgent', status: 'active', weighted_reputation: 4.5 } }),
+        });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('whoami');
+        const output = spy.mock.calls.map(c => c[0]).join('\n');
+        expect(output).toContain('my-key');
+        expect(output).toContain('TestAgent');
+        spy.mockRestore();
+    });
+    it('exits when not logged in', async () => {
+        mockLoadConfig.mockReturnValue(null);
+        const exitSpy = jest.spyOn(process, 'exit').mockImplementation(() => undefined);
+        const errSpy = jest.spyOn(console, 'error').mockImplementation();
+        // Commander wraps action errors
+        await runCommand('whoami').catch(() => { });
+        expect(exitSpy).toHaveBeenCalledWith(1);
+        exitSpy.mockRestore();
+        errSpy.mockRestore();
+    });
+    it('handles API errors gracefully', async () => {
+        mockLoadConfig.mockReturnValue({ apiKey: 'key', apiUrl: 'http://test' });
+        mockFetch.mockRejectedValue(new Error('Connection refused'));
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('whoami');
+        spy.mockRestore();
+    });
+});

package/dist/__tests__/bounty.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/bounty.test.js

@@ -0,0 +1,185 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk_1 = __importDefault(require("chalk"));
+const helpers_1 = require("./helpers");
+const mockClient = (0, helpers_1.createMockClient)();
+jest.mock('../utils/client', () => ({
+    getClient: () => mockClient,
+}));
+const bounty_1 = require("../commands/bounty");
+beforeAll(() => {
+    chalk_1.default.level = 0;
+});
+beforeEach(() => {
+    jest.clearAllMocks();
+});
+async function runCommand(...args) {
+    await bounty_1.bountyCommand.parseAsync(args, { from: 'user' });
+}
+describe('bounty list', () => {
+    it('renders a table of bounties', async () => {
+        mockClient.get.mockResolvedValue({
+            bounties: [
+                { id: 'bounty-abc-12345678', title: 'Build API endpoint', status: 'open', reward_amount: '1000000', reward_symbol: 'USDC', assignee_wallet: null, deadline: null },
+            ],
+            total: 1,
+        });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('list');
+        expect(mockClient.get).toHaveBeenCalledWith(expect.stringContaining('/bounties?'));
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining('Build API'));
+        spy.mockRestore();
+    });
+    it('passes workspace and status filters', async () => {
+        mockClient.get.mockResolvedValue({ bounties: [], total: 0 });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('list', '--workspace', 'ws1', '--status', 'open');
+        const url = mockClient.get.mock.calls[0][0];
+        expect(url).toContain('workspaceId=ws1');
+        expect(url).toContain('status=open');
+        spy.mockRestore();
+    });
+    it('handles empty bounties list', async () => {
+        mockClient.get.mockResolvedValue({ bounties: [] });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('list');
+        expect(spy).toHaveBeenCalledWith('No bounties found.');
+        spy.mockRestore();
+    });
+});
+describe('bounty status', () => {
+    it('displays bounty details', async () => {
+        mockClient.get.mockImplementation((path) => {
+            if (path.includes('/bids'))
+                return Promise.resolve({ bids: [] });
+            return Promise.resolve({
+                bounty: {
+                    id: 'b1', title: 'Test Bounty', status: 'open', category: 'code',
+                    reward_amount: '500000', reward_symbol: 'USDC', poster_wallet: 'poster123',
+                    assignee_wallet: null, assignment_mode: 'bid', verification_mode: 'auto',
+                    deadline: null, max_retries: 3, retry_count: 0, created_at: '2024-01-01',
+                },
+            });
+        });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('status', 'b1');
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining('Test Bounty'));
+        spy.mockRestore();
+    });
+    it('handles bids fetch failure gracefully', async () => {
+        mockClient.get.mockImplementation((path) => {
+            if (path.includes('/bids'))
+                return Promise.reject(new Error('Not found'));
+            return Promise.resolve({
+                bounty: {
+                    id: 'b1', title: 'Test', status: 'open', category: 'code',
+                    reward_amount: '100', reward_symbol: 'USDC', poster_wallet: 'p1',
+                    assignee_wallet: null, assignment_mode: 'bid', verification_mode: 'auto',
+                    deadline: null, created_at: '2024-01-01',
+                },
+            });
+        });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await expect(runCommand('status', 'b1')).resolves.toBeUndefined();
+        spy.mockRestore();
+    });
+    it('renders bids table when bids exist', async () => {
+        mockClient.get.mockImplementation((path) => {
+            if (path.includes('/bids'))
+                return Promise.resolve({
+                    bids: [{ agent_wallet: 'agent123456789012', amount: '50', status: 'pending', message: 'I can do it' }],
+                });
+            return Promise.resolve({
+                bounty: {
+                    id: 'b1', title: 'Test', status: 'open', category: 'code',
+                    reward_amount: '100', reward_symbol: 'USDC', poster_wallet: 'p1',
+                    assignee_wallet: null, assignment_mode: 'bid', verification_mode: 'auto',
+                    deadline: null, created_at: '2024-01-01',
+                },
+            });
+        });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('status', 'b1');
+        const output = spy.mock.calls.map(c => c[0]).join('\n');
+        expect(output).toContain('Bids');
+        spy.mockRestore();
+    });
+});
+describe('bounty progress', () => {
+    it('renders progress entries', async () => {
+        mockClient.get.mockResolvedValue({
+            progress: [
+                { percentage: 50, message: 'Half done', created_at: new Date().toISOString() },
+                { percentage: 100, message: 'Complete', created_at: new Date().toISOString() },
+            ],
+        });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('progress', 'b1');
+        const output = spy.mock.calls.map(c => c[0]).join('\n');
+        expect(output).toContain('Progress');
+        spy.mockRestore();
+    });
+    it('handles empty progress', async () => {
+        mockClient.get.mockResolvedValue({ progress: [] });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('progress', 'b1');
+        expect(spy).toHaveBeenCalledWith('No progress reported yet.');
+        spy.mockRestore();
+    });
+});
+describe('bounty messages', () => {
+    it('renders message thread', async () => {
+        mockClient.get.mockResolvedValue({
+            messages: [
+                { sender_wallet: 'sender1234567890', message_type: 'question', content: 'How?', created_at: new Date().toISOString() },
+            ],
+        });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('messages', 'b1');
+        const output = spy.mock.calls.map(c => c[0]).join('\n');
+        expect(output).toContain('Messages');
+        spy.mockRestore();
+    });
+    it('handles empty messages', async () => {
+        mockClient.get.mockResolvedValue({ messages: [] });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('messages', 'b1');
+        expect(spy).toHaveBeenCalledWith('No messages yet.');
+        spy.mockRestore();
+    });
+});
+describe('bounty verification', () => {
+    it('renders verification results with PASSED', async () => {
+        mockClient.get.mockResolvedValue({
+            results: [{ strategy: 'auto', passed: true, details: 'All tests pass' }],
+        });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('verification', 'b1');
+        const output = spy.mock.calls.map(c => c[0]).join('\n');
+        expect(output).toContain('PASSED');
+        spy.mockRestore();
+    });
+    it('renders verification results with FAILED', async () => {
+        mockClient.get.mockResolvedValue({
+            results: [
+                { strategy: 'auto', passed: true, details: 'ok' },
+                { strategy: 'manual', passed: false, error: 'Did not meet spec' },
+            ],
+        });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('verification', 'b1');
+        const output = spy.mock.calls.map(c => c[0]).join('\n');
+        expect(output).toContain('FAILED');
+        spy.mockRestore();
+    });
+    it('handles empty verification', async () => {
+        mockClient.get.mockResolvedValue({ results: [] });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('verification', 'b1');
+        expect(spy).toHaveBeenCalledWith('No verification results yet.');
+        spy.mockRestore();
+    });
+});

package/dist/__tests__/client.test.d.ts

@@ -0,0 +1 @@
+export {};