@wenrwa/marketplace-cli 0.1.0 → 0.2.0

package/dist/__tests__/client.test.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+jest.mock('../utils/config', () => ({
+    requireConfig: jest.fn().mockReturnValue({
+        apiUrl: 'http://test:3001/api/marketplace',
+        apiKey: 'test-wallet-key',
+    }),
+}));
+const client_1 = require("../utils/client");
+let mockFetch;
+beforeEach(() => {
+    mockFetch = jest.fn();
+    global.fetch = mockFetch;
+    // Reset singleton
+    client_1.getClient.__reset?.();
+});
+afterEach(() => {
+    jest.restoreAllMocks();
+});
+function okResponse(data) {
+    return Promise.resolve({
+        ok: true,
+        status: 200,
+        json: () => Promise.resolve(data),
+    });
+}
+function errorResponse(status, data) {
+    return Promise.resolve({
+        ok: false,
+        status,
+        json: () => Promise.resolve(data),
+    });
+}
+describe('ApiClient', () => {
+    it('reads apiUrl and apiKey from config', () => {
+        const client = new client_1.ApiClient();
+        expect(client.getApiUrl()).toBe('http://test:3001/api/marketplace');
+        expect(client.getApiKey()).toBe('test-wallet-key');
+    });
+    describe('get()', () => {
+        it('sends GET request with correct URL and headers', async () => {
+            mockFetch.mockReturnValue(okResponse({ success: true, items: [] }));
+            const client = new client_1.ApiClient();
+            await client.get('/bounties');
+            expect(mockFetch).toHaveBeenCalledWith('http://test:3001/api/marketplace/bounties', expect.objectContaining({
+                method: 'GET',
+                headers: expect.objectContaining({
+                    'X-Wallet-Pubkey': 'test-wallet-key',
+                }),
+            }));
+        });
+        it('returns parsed response data', async () => {
+            mockFetch.mockReturnValue(okResponse({ success: true, bounties: [{ id: '1' }] }));
+            const client = new client_1.ApiClient();
+            const result = await client.get('/bounties');
+            expect(result.bounties).toEqual([{ id: '1' }]);
+        });
+        it('throws on HTTP error', async () => {
+            mockFetch.mockReturnValue(errorResponse(404, { success: false, error: { code: 'NOT_FOUND', message: 'Not found' } }));
+            const client = new client_1.ApiClient();
+            await expect(client.get('/missing')).rejects.toThrow('Not found');
+        });
+        it('throws generic message when error has no message', async () => {
+            mockFetch.mockReturnValue(errorResponse(500, {}));
+            const client = new client_1.ApiClient();
+            await expect(client.get('/fail')).rejects.toThrow('HTTP 500');
+        });
+    });
+    describe('post()', () => {
+        it('sends POST with JSON body and Content-Type', async () => {
+            mockFetch.mockReturnValue(okResponse({ success: true }));
+            const client = new client_1.ApiClient();
+            await client.post('/bounties', { title: 'New bounty' });
+            expect(mockFetch).toHaveBeenCalledWith('http://test:3001/api/marketplace/bounties', expect.objectContaining({
+                method: 'POST',
+                headers: expect.objectContaining({ 'Content-Type': 'application/json' }),
+                body: JSON.stringify({ title: 'New bounty' }),
+            }));
+        });
+        it('sends POST without body when none provided', async () => {
+            mockFetch.mockReturnValue(okResponse({ success: true }));
+            const client = new client_1.ApiClient();
+            await client.post('/action');
+            expect(mockFetch).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({ method: 'POST', body: undefined }));
+        });
+    });
+    describe('del()', () => {
+        it('sends DELETE request', async () => {
+            mockFetch.mockReturnValue(okResponse({ success: true }));
+            const client = new client_1.ApiClient();
+            await client.del('/bounties/123');
+            expect(mockFetch).toHaveBeenCalledWith('http://test:3001/api/marketplace/bounties/123', expect.objectContaining({ method: 'DELETE' }));
+        });
+    });
+});
+describe('getClient()', () => {
+    it('returns an ApiClient instance', () => {
+        const client = (0, client_1.getClient)();
+        expect(client).toBeInstanceOf(client_1.ApiClient);
+    });
+    it('returns the same instance on subsequent calls', () => {
+        const a = (0, client_1.getClient)();
+        const b = (0, client_1.getClient)();
+        expect(a).toBe(b);
+    });
+});

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

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

package/dist/__tests__/config.test.js

@@ -0,0 +1,99 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const config_1 = require("../utils/config");
+jest.mock('fs');
+const mockedFs = fs;
+afterEach(() => {
+    jest.restoreAllMocks();
+    delete process.env.MARKETPLACE_API_URL;
+});
+describe('loadConfig()', () => {
+    it('returns parsed config when file exists', () => {
+        const config = { apiKey: 'test-key', apiUrl: 'http://localhost:3001/api/marketplace' };
+        mockedFs.readFileSync.mockReturnValue(JSON.stringify(config));
+        expect((0, config_1.loadConfig)()).toEqual(config);
+    });
+    it('returns null when file does not exist', () => {
+        mockedFs.readFileSync.mockImplementation(() => { throw new Error('ENOENT'); });
+        expect((0, config_1.loadConfig)()).toBeNull();
+    });
+    it('returns null on invalid JSON', () => {
+        mockedFs.readFileSync.mockReturnValue('not json{');
+        expect((0, config_1.loadConfig)()).toBeNull();
+    });
+});
+describe('saveConfig()', () => {
+    it('creates directory and writes file', () => {
+        mockedFs.mkdirSync.mockReturnValue(undefined);
+        mockedFs.writeFileSync.mockReturnValue(undefined);
+        const config = { apiKey: 'key', apiUrl: 'http://test' };
+        (0, config_1.saveConfig)(config);
+        expect(mockedFs.mkdirSync).toHaveBeenCalledWith(expect.any(String), { recursive: true });
+        expect(mockedFs.writeFileSync).toHaveBeenCalledWith(expect.any(String), expect.stringContaining('"apiKey": "key"'));
+    });
+});
+describe('requireConfig()', () => {
+    it('returns config when it exists', () => {
+        const config = { apiKey: 'key', apiUrl: 'http://test' };
+        mockedFs.readFileSync.mockReturnValue(JSON.stringify(config));
+        expect((0, config_1.requireConfig)()).toEqual(config);
+    });
+    it('exits process when config is missing', () => {
+        mockedFs.readFileSync.mockImplementation(() => { throw new Error('ENOENT'); });
+        const exitSpy = jest.spyOn(process, 'exit').mockImplementation(() => undefined);
+        const errSpy = jest.spyOn(console, 'error').mockImplementation();
+        (0, config_1.requireConfig)();
+        expect(exitSpy).toHaveBeenCalledWith(1);
+        exitSpy.mockRestore();
+        errSpy.mockRestore();
+    });
+});
+describe('getApiUrl()', () => {
+    it('prefers env var over config', () => {
+        process.env.MARKETPLACE_API_URL = 'http://env-url';
+        expect((0, config_1.getApiUrl)()).toBe('http://env-url');
+    });
+    it('falls back to config value', () => {
+        const config = { apiKey: 'key', apiUrl: 'http://config-url' };
+        mockedFs.readFileSync.mockReturnValue(JSON.stringify(config));
+        expect((0, config_1.getApiUrl)()).toBe('http://config-url');
+    });
+    it('falls back to default when no config or env', () => {
+        mockedFs.readFileSync.mockImplementation(() => { throw new Error('ENOENT'); });
+        expect((0, config_1.getApiUrl)()).toBe('http://localhost:3001/api/marketplace');
+    });
+});

package/dist/__tests__/dashboard-helpers.test.d.ts

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

package/dist/__tests__/dashboard-helpers.test.js

@@ -0,0 +1,123 @@
+"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 dashboard_1 = require("../commands/dashboard");
+beforeAll(() => {
+    chalk_1.default.level = 0;
+});
+function makeBounty(overrides = {}) {
+    return {
+        id: 'b1', title: 'Test', status: 'open', reward_amount: '100', reward_symbol: 'USDC',
+        ...overrides,
+    };
+}
+function makeState(bounties) {
+    return {
+        workspace: { id: 'ws1', name: 'Test', mode: 'open' },
+        bounties,
+        treasury: { balance: '0', total_funded: '0', total_paid: '0' },
+        events: [],
+        startTime: Date.now(),
+    };
+}
+describe('updateBountyFromEvent()', () => {
+    it('handles bounty:assigned', () => {
+        const state = makeState([makeBounty({ id: 'b1' })]);
+        const event = { event: 'bounty:assigned', data: { bountyId: 'b1', assigneeWallet: 'agent1' } };
+        (0, dashboard_1.updateBountyFromEvent)(state, event);
+        expect(state.bounties[0].status).toBe('assigned');
+        expect(state.bounties[0].assignee_wallet).toBe('agent1');
+    });
+    it('handles bounty:progress', () => {
+        const state = makeState([makeBounty({ id: 'b1' })]);
+        const event = { event: 'bounty:progress', data: { bountyId: 'b1', percentage: 75 } };
+        (0, dashboard_1.updateBountyFromEvent)(state, event);
+        expect(state.bounties[0].percentage).toBe(75);
+    });
+    it('handles bounty:submitted', () => {
+        const state = makeState([makeBounty({ id: 'b1', status: 'assigned' })]);
+        const event = { event: 'bounty:submitted', data: { bountyId: 'b1' } };
+        (0, dashboard_1.updateBountyFromEvent)(state, event);
+        expect(state.bounties[0].status).toBe('submitted');
+    });
+    it('handles bounty:completed', () => {
+        const state = makeState([makeBounty({ id: 'b1' })]);
+        const event = { event: 'bounty:completed', data: { bountyId: 'b1' } };
+        (0, dashboard_1.updateBountyFromEvent)(state, event);
+        expect(state.bounties[0].status).toBe('completed');
+        expect(state.bounties[0].percentage).toBe(100);
+    });
+    it('handles bounty:heartbeat', () => {
+        const state = makeState([makeBounty({ id: 'b1' })]);
+        const event = { event: 'bounty:heartbeat', data: { bountyId: 'b1' } };
+        (0, dashboard_1.updateBountyFromEvent)(state, event);
+        expect(state.bounties[0].last_heartbeat).toBeDefined();
+    });
+    it('no-ops for unknown event', () => {
+        const state = makeState([makeBounty({ id: 'b1', status: 'open' })]);
+        const event = { event: 'unknown:event', data: { bountyId: 'b1' } };
+        (0, dashboard_1.updateBountyFromEvent)(state, event);
+        expect(state.bounties[0].status).toBe('open');
+    });
+    it('no-ops when bountyId is missing', () => {
+        const state = makeState([makeBounty({ id: 'b1', status: 'open' })]);
+        const event = { event: 'bounty:completed', data: {} };
+        (0, dashboard_1.updateBountyFromEvent)(state, event);
+        expect(state.bounties[0].status).toBe('open');
+    });
+    it('no-ops when bounty not found in state', () => {
+        const state = makeState([makeBounty({ id: 'b1', status: 'open' })]);
+        const event = { event: 'bounty:completed', data: { bountyId: 'b999' } };
+        (0, dashboard_1.updateBountyFromEvent)(state, event);
+        expect(state.bounties[0].status).toBe('open');
+    });
+});
+describe('pad()', () => {
+    it('left-aligns by default', () => {
+        const result = (0, dashboard_1.pad)('hi', 6);
+        expect(result).toBe('hi    ');
+    });
+    it('right-aligns when right=true', () => {
+        const result = (0, dashboard_1.pad)('hi', 6, true);
+        expect(result).toBe('    hi');
+    });
+    it('handles strings already at target length', () => {
+        expect((0, dashboard_1.pad)('abc', 3)).toBe('abc');
+    });
+});
+describe('colorOverhead()', () => {
+    it('returns 0 for unknown status (no color applied)', () => {
+        // chalk.level=0 means no ANSI codes, overhead = 0
+        expect((0, dashboard_1.colorOverhead)('unknown')).toBe(0);
+    });
+});
+describe('heartbeatColor()', () => {
+    it('returns dash unchanged', () => {
+        expect((0, dashboard_1.heartbeatColor)('—')).toBe('—');
+    });
+    it('returns green for fresh heartbeat (seconds)', () => {
+        const result = (0, dashboard_1.heartbeatColor)('30s ago');
+        expect(result).toBe('30s ago'); // chalk.level=0
+    });
+    it('returns red for stale heartbeat (hours)', () => {
+        const result = (0, dashboard_1.heartbeatColor)('2h ago');
+        expect(result).toBe('2h ago'); // chalk.level=0
+    });
+    it('returns value for no-match pattern', () => {
+        expect((0, dashboard_1.heartbeatColor)('just now')).toBe('just now');
+    });
+});
+describe('formatUptime()', () => {
+    it('formats 0ms as "0h 0m"', () => {
+        expect((0, dashboard_1.formatUptime)(0)).toBe('0h 0m');
+    });
+    it('formats 90 minutes as "1h 30m"', () => {
+        expect((0, dashboard_1.formatUptime)(90 * 60 * 1000)).toBe('1h 30m');
+    });
+    it('formats 2 hours as "2h 0m"', () => {
+        expect((0, dashboard_1.formatUptime)(2 * 60 * 60 * 1000)).toBe('2h 0m');
+    });
+});

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

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

package/dist/__tests__/format.test.js

@@ -0,0 +1,144 @@
+"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 format_1 = require("../utils/format");
+beforeAll(() => {
+    chalk_1.default.level = 0;
+});
+describe('statusColor()', () => {
+    it('returns green for completed/approved/done', () => {
+        expect((0, format_1.statusColor)('completed')).toBe('completed');
+        expect((0, format_1.statusColor)('approved')).toBe('approved');
+        expect((0, format_1.statusColor)('done')).toBe('done');
+    });
+    it('returns yellow for assigned/working/in_progress', () => {
+        expect((0, format_1.statusColor)('assigned')).toBe('assigned');
+        expect((0, format_1.statusColor)('working')).toBe('working');
+        expect((0, format_1.statusColor)('in_progress')).toBe('in_progress');
+    });
+    it('returns red for disputed/stale/failed', () => {
+        expect((0, format_1.statusColor)('disputed')).toBe('disputed');
+        expect((0, format_1.statusColor)('stale')).toBe('stale');
+        expect((0, format_1.statusColor)('failed')).toBe('failed');
+    });
+    it('returns gray for blocked', () => {
+        expect((0, format_1.statusColor)('blocked')).toBe('blocked');
+    });
+    it('returns cyan for open/pending', () => {
+        expect((0, format_1.statusColor)('open')).toBe('open');
+        expect((0, format_1.statusColor)('pending')).toBe('pending');
+    });
+    it('returns dim for expired/cancelled', () => {
+        expect((0, format_1.statusColor)('expired')).toBe('expired');
+        expect((0, format_1.statusColor)('cancelled')).toBe('cancelled');
+    });
+    it('returns raw string for unknown status', () => {
+        expect((0, format_1.statusColor)('mystery')).toBe('mystery');
+    });
+});
+describe('shorten()', () => {
+    it('shortens long strings', () => {
+        expect((0, format_1.shorten)('abcdefghijklmnop')).toBe('abcd...mnop');
+    });
+    it('returns short strings unchanged', () => {
+        expect((0, format_1.shorten)('short')).toBe('short');
+    });
+    it('returns null/undefined as-is', () => {
+        expect((0, format_1.shorten)(null)).toBe(null);
+        expect((0, format_1.shorten)(undefined)).toBe(undefined);
+    });
+    it('respects custom length', () => {
+        expect((0, format_1.shorten)('abcdefghij', 8)).toBe('abcd...ghij');
+    });
+});
+describe('formatUsdc()', () => {
+    it('converts micro-USDC to USDC', () => {
+        expect((0, format_1.formatUsdc)(1_000_000)).toBe('1.00');
+        expect((0, format_1.formatUsdc)('2500000')).toBe('2.50');
+    });
+});
+describe('formatReward()', () => {
+    it('formats USDC amounts by default', () => {
+        expect((0, format_1.formatReward)(1_000_000)).toBe('1.00 USDC');
+    });
+    it('formats with explicit USDC symbol', () => {
+        expect((0, format_1.formatReward)(1_000_000, 'USDC')).toBe('1.00 USDC');
+    });
+    it('formats with custom symbol using USDC decimals', () => {
+        expect((0, format_1.formatReward)(500_000, 'USDT')).toBe('0.50 USDT');
+    });
+});
+describe('formatTimestamp()', () => {
+    it('extracts HH:MM:SS from ISO timestamp', () => {
+        const result = (0, format_1.formatTimestamp)('2024-06-15T14:30:45.000Z');
+        expect(result).toBe('14:30:45');
+    });
+});
+describe('formatTimeAgo()', () => {
+    it('returns seconds for < 60s', () => {
+        const ts = new Date(Date.now() - 30_000).toISOString();
+        expect((0, format_1.formatTimeAgo)(ts)).toMatch(/^\d+s ago$/);
+    });
+    it('returns minutes for < 60m', () => {
+        const ts = new Date(Date.now() - 5 * 60_000).toISOString();
+        expect((0, format_1.formatTimeAgo)(ts)).toMatch(/^\d+m ago$/);
+    });
+    it('returns hours for < 24h', () => {
+        const ts = new Date(Date.now() - 3 * 3600_000).toISOString();
+        expect((0, format_1.formatTimeAgo)(ts)).toMatch(/^\d+h ago$/);
+    });
+    it('returns days for >= 24h', () => {
+        const ts = new Date(Date.now() - 2 * 86400_000).toISOString();
+        expect((0, format_1.formatTimeAgo)(ts)).toMatch(/^\d+d ago$/);
+    });
+});
+describe('makeTable()', () => {
+    it('returns a string containing headers and rows', () => {
+        const result = (0, format_1.makeTable)(['Name', 'Age'], [['Alice', '30'], ['Bob', '25']]);
+        expect(result).toContain('Name');
+        expect(result).toContain('Age');
+        expect(result).toContain('Alice');
+        expect(result).toContain('Bob');
+    });
+});
+describe('heading()', () => {
+    it('logs formatted heading', () => {
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        (0, format_1.heading)('My Section');
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining('My Section'));
+        spy.mockRestore();
+    });
+});
+describe('success()', () => {
+    it('logs success message with + prefix', () => {
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        (0, format_1.success)('Done!');
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining('+ Done!'));
+        spy.mockRestore();
+    });
+});
+describe('error()', () => {
+    it('logs error message with x prefix', () => {
+        const spy = jest.spyOn(console, 'error').mockImplementation();
+        (0, format_1.error)('Oops');
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining('x Oops'));
+        spy.mockRestore();
+    });
+});
+describe('info()', () => {
+    it('logs info message with i prefix', () => {
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        (0, format_1.info)('Note');
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining('i Note'));
+        spy.mockRestore();
+    });
+});
+describe('formatJson()', () => {
+    it('returns pretty-printed JSON', () => {
+        const result = (0, format_1.formatJson)({ a: 1, b: 'hello' });
+        expect(result).toBe('{\n  "a": 1,\n  "b": "hello"\n}');
+    });
+});

package/dist/__tests__/helpers.d.ts

@@ -0,0 +1,7 @@
+export declare function createMockClient(): {
+    get: jest.Mock<any, any, any>;
+    post: jest.Mock<any, any, any>;
+    del: jest.Mock<any, any, any>;
+    getApiUrl: jest.Mock<any, any, any>;
+    getApiKey: jest.Mock<any, any, any>;
+};

package/dist/__tests__/helpers.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMockClient = createMockClient;
+function createMockClient() {
+    return {
+        get: jest.fn(),
+        post: jest.fn(),
+        del: jest.fn(),
+        getApiUrl: jest.fn().mockReturnValue('http://test:3001/api/marketplace'),
+        getApiKey: jest.fn().mockReturnValue('test-key'),
+    };
+}

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

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

package/dist/__tests__/treasury.test.js

@@ -0,0 +1,122 @@
+"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 treasury_1 = require("../commands/treasury");
+beforeAll(() => {
+    chalk_1.default.level = 0;
+});
+beforeEach(() => {
+    jest.clearAllMocks();
+});
+async function runCommand(...args) {
+    await treasury_1.treasuryCommand.parseAsync(args, { from: 'user' });
+}
+describe('treasury status', () => {
+    it('displays treasury balances', async () => {
+        mockClient.get.mockImplementation((path) => {
+            if (path.includes('/ledger'))
+                return Promise.resolve({ ledger: [] });
+            return Promise.resolve({ balance: '5000', total_funded: '10000', total_paid: '5000', agents: [] });
+        });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('status', 'ws1');
+        const output = spy.mock.calls.map(c => c[0]).join('\n');
+        expect(output).toContain('5000');
+        expect(output).toContain('10000');
+        spy.mockRestore();
+    });
+    it('renders agent allocations when available', async () => {
+        mockClient.get.mockImplementation((path) => {
+            if (path.includes('/ledger'))
+                return Promise.resolve({ ledger: [] });
+            return Promise.resolve({
+                balance: '1000', total_funded: '2000', total_paid: '1000',
+                agents: [{ agent_wallet: 'agent-12345678901', allocated: '500', spent: '200', remaining: '300' }],
+            });
+        });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('status', 'ws1');
+        const output = spy.mock.calls.map(c => c[0]).join('\n');
+        expect(output).toContain('Agent Allocations');
+        spy.mockRestore();
+    });
+    it('renders ledger when available', async () => {
+        mockClient.get.mockImplementation((path) => {
+            if (path.includes('/ledger'))
+                return Promise.resolve({
+                    ledger: [{ type: 'fund', amount: '1000', agent_wallet: null, created_at: new Date().toISOString() }],
+                });
+            return Promise.resolve({ balance: '1000', total_funded: '1000', total_paid: '0', agents: [] });
+        });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('status', 'ws1');
+        const output = spy.mock.calls.map(c => c[0]).join('\n');
+        expect(output).toContain('Ledger');
+        spy.mockRestore();
+    });
+    it('handles ledger fetch failure gracefully', async () => {
+        mockClient.get.mockImplementation((path) => {
+            if (path.includes('/ledger'))
+                return Promise.reject(new Error('Not found'));
+            return Promise.resolve({ balance: '100', agents: [] });
+        });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await expect(runCommand('status', 'ws1')).resolves.toBeUndefined();
+        spy.mockRestore();
+    });
+});
+describe('treasury fund', () => {
+    it('posts funding amount', async () => {
+        mockClient.post.mockResolvedValue({ success: true });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('fund', 'ws1', '--amount', '5000');
+        expect(mockClient.post).toHaveBeenCalledWith('/workspaces/ws1/treasury/fund', { amount: '5000', txSignature: 'cli-funding' });
+        spy.mockRestore();
+    });
+    it('uses provided tx signature', async () => {
+        mockClient.post.mockResolvedValue({ success: true });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('fund', 'ws1', '--amount', '1000', '--tx-signature', 'abc123');
+        expect(mockClient.post).toHaveBeenCalledWith('/workspaces/ws1/treasury/fund', { amount: '1000', txSignature: 'abc123' });
+        spy.mockRestore();
+    });
+    it('handles fund error', async () => {
+        mockClient.post.mockRejectedValue(new Error('Insufficient balance'));
+        const errSpy = jest.spyOn(console, 'error').mockImplementation();
+        await runCommand('fund', 'ws1', '--amount', '9999999');
+        expect(errSpy).toHaveBeenCalledWith(expect.stringContaining('Insufficient balance'));
+        errSpy.mockRestore();
+    });
+});
+describe('treasury distribute', () => {
+    it('distributes to all workspace agents', async () => {
+        mockClient.get.mockResolvedValue({
+            workspace: { agent_wallets: ['agent1', 'agent2'] },
+        });
+        mockClient.post.mockResolvedValue({ success: true });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('distribute', 'ws1', '--per-agent', '500');
+        expect(mockClient.post).toHaveBeenCalledWith('/workspaces/ws1/treasury/fund-agents', {
+            distributions: [
+                { agentWallet: 'agent1', amount: '500' },
+                { agentWallet: 'agent2', amount: '500' },
+            ],
+        });
+        spy.mockRestore();
+    });
+    it('handles empty agent list', async () => {
+        mockClient.get.mockResolvedValue({ workspace: { agent_wallets: [] } });
+        const errSpy = jest.spyOn(console, 'error').mockImplementation();
+        await runCommand('distribute', 'ws1', '--per-agent', '500');
+        expect(errSpy).toHaveBeenCalledWith(expect.stringContaining('No agents'));
+        errSpy.mockRestore();
+    });
+});

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

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