@wenrwa/marketplace-cli 0.1.0 → 0.2.0

package/dist/__tests__/websocket.test.js

@@ -0,0 +1,61 @@
+"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 websocket_1 = require("../utils/websocket");
+beforeAll(() => {
+    chalk_1.default.level = 0;
+});
+function makeEvent(event, data, timestamp) {
+    return { event, data, timestamp: timestamp || '2024-06-15T14:30:00.000Z' };
+}
+describe('formatEventPretty()', () => {
+    it('formats bounty:created', () => {
+        const result = (0, websocket_1.formatEventPretty)(makeEvent('bounty:created', { title: 'Build API', rewardAmount: '100', rewardSymbol: 'USDC' }));
+        expect(result).toContain('[new]');
+        expect(result).toContain('Build API');
+    });
+    it('formats bounty:bid', () => {
+        const result = (0, websocket_1.formatEventPretty)(makeEvent('bounty:bid', { agentWallet: 'abcdefghijklmnop', bidAmount: '50', bountyId: 'bounty123456789' }));
+        expect(result).toContain('[bid]');
+    });
+    it('formats bounty:assigned', () => {
+        const result = (0, websocket_1.formatEventPretty)(makeEvent('bounty:assigned', { bountyId: 'bounty123456789', assigneeWallet: 'wallet12345678' }));
+        expect(result).toContain('[assigned]');
+    });
+    it('formats bounty:progress', () => {
+        const result = (0, websocket_1.formatEventPretty)(makeEvent('bounty:progress', { percentage: 50, bountyId: 'bounty123456789', message: 'Half done' }));
+        expect(result).toContain('[progress]');
+        expect(result).toContain('50%');
+    });
+    it('formats bounty:completed', () => {
+        const result = (0, websocket_1.formatEventPretty)(makeEvent('bounty:completed', { bountyId: 'bounty123456789' }));
+        expect(result).toContain('[complete]');
+    });
+    it('formats unknown event as fallback', () => {
+        const result = (0, websocket_1.formatEventPretty)(makeEvent('custom:event', { key: 'value' }));
+        expect(result).toContain('[custom:event]');
+    });
+    it('uses current time when timestamp is missing', () => {
+        const event = { event: 'bounty:completed', data: { bountyId: 'b1' } };
+        const result = (0, websocket_1.formatEventPretty)(event);
+        expect(result).toContain('[complete]');
+    });
+});
+describe('formatEventJson()', () => {
+    it('returns JSON with ts, event, and data', () => {
+        const event = makeEvent('bounty:created', { title: 'Test' });
+        const result = JSON.parse((0, websocket_1.formatEventJson)(event));
+        expect(result.ts).toBe('2024-06-15T14:30:00.000Z');
+        expect(result.event).toBe('bounty:created');
+        expect(result.data).toEqual({ title: 'Test' });
+    });
+    it('uses current time when timestamp missing', () => {
+        const event = { event: 'test', data: {} };
+        const result = JSON.parse((0, websocket_1.formatEventJson)(event));
+        expect(result.ts).toBeDefined();
+        expect(result.event).toBe('test');
+    });
+});

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

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

package/dist/__tests__/workspace.test.js

@@ -0,0 +1,105 @@
+"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(),
+    formatEventJson: jest.fn(),
+}));
+const workspace_1 = require("../commands/workspace");
+beforeAll(() => {
+    chalk_1.default.level = 0;
+});
+beforeEach(() => {
+    jest.clearAllMocks();
+});
+async function runCommand(...args) {
+    await workspace_1.workspaceCommand.parseAsync(args, { from: 'user' });
+}
+describe('workspace list', () => {
+    it('renders a table of workspaces', async () => {
+        mockClient.get.mockResolvedValue({
+            workspaces: [
+                { id: 'ws-abc-12345678', name: 'Test Workspace', mode: 'open', bounty_count: 5, agent_count: 2, created_at: '2024-01-01' },
+            ],
+        });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('list');
+        expect(mockClient.get).toHaveBeenCalledWith('/workspaces');
+        const output = spy.mock.calls.map(c => c[0]).join('\n');
+        expect(output).toContain('Test Workspace');
+        spy.mockRestore();
+    });
+    it('handles empty workspace list', async () => {
+        mockClient.get.mockResolvedValue({ workspaces: [] });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('list');
+        expect(spy).toHaveBeenCalledWith('No workspaces found.');
+        spy.mockRestore();
+    });
+    it('handles API error', async () => {
+        mockClient.get.mockRejectedValue(new Error('Network error'));
+        const errSpy = jest.spyOn(console, 'error').mockImplementation();
+        await runCommand('list');
+        expect(errSpy).toHaveBeenCalledWith(expect.stringContaining('Network error'));
+        errSpy.mockRestore();
+    });
+});
+describe('workspace status', () => {
+    it('displays workspace details with bounties and treasury', async () => {
+        mockClient.get.mockImplementation((path) => {
+            if (path.includes('/treasury')) {
+                return Promise.resolve({ balance: '1000', total_funded: '5000', total_paid: '4000' });
+            }
+            if (path.includes('/bounties')) {
+                return Promise.resolve({
+                    bounties: [{ title: 'Build Feature', status: 'open', assignee_wallet: null, reward_amount: '100', reward_symbol: 'USDC', blocked_by: [] }],
+                });
+            }
+            return Promise.resolve({
+                workspace: { id: 'ws1', name: 'Main', mode: 'open', use_escrow: true, created_at: '2024-01-01' },
+            });
+        });
+        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('Main');
+        expect(output).toContain('Build Feature');
+        expect(output).toContain('Treasury');
+        spy.mockRestore();
+    });
+    it('handles missing treasury gracefully', async () => {
+        mockClient.get.mockImplementation((path) => {
+            if (path.includes('/treasury'))
+                return Promise.reject(new Error('Not found'));
+            if (path.includes('/bounties'))
+                return Promise.resolve({ bounties: [] });
+            return Promise.resolve({
+                workspace: { id: 'ws1', name: 'Test WS', mode: 'open', use_escrow: false, created_at: '2024-01-01' },
+            });
+        });
+        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('Test WS');
+        // Treasury heading should NOT appear since the endpoint rejects
+        expect(output).not.toContain('Balance:');
+        spy.mockRestore();
+    });
+    it('handles workspace fetch error', async () => {
+        mockClient.get.mockRejectedValue(new Error('Workspace not found'));
+        const errSpy = jest.spyOn(console, 'error').mockImplementation();
+        await runCommand('status', 'ws-bad');
+        expect(errSpy).toHaveBeenCalledWith(expect.stringContaining('Workspace not found'));
+        errSpy.mockRestore();
+    });
+});

package/dist/commands/apps.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const appsCommand: Command;

package/dist/commands/apps.js

@@ -0,0 +1,174 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appsCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const client_1 = require("../utils/client");
+const format_1 = require("../utils/format");
+const fs_1 = require("fs");
+exports.appsCommand = new commander_1.Command('apps').description('Hosted apps management');
+exports.appsCommand
+    .command('list')
+    .description('List your hosted apps')
+    .option('--status <status>', 'Filter by status (pending, building, deployed, failed)')
+    .option('--limit <n>', 'Max results', '20')
+    .action(async (opts) => {
+    try {
+        const client = (0, client_1.getClient)();
+        const params = new URLSearchParams();
+        params.set('ownerWallet', client.getApiKey());
+        if (opts.status)
+            params.set('status', opts.status);
+        params.set('limit', opts.limit);
+        const data = await client.get(`/projects?${params}`);
+        const projects = data.projects || [];
+        if (projects.length === 0) {
+            console.log('No apps found. Create one with: wen-market apps create');
+            return;
+        }
+        console.log(`${chalk_1.default.dim(`Showing ${projects.length} of ${data.total || projects.length} apps`)}\n`);
+        console.log((0, format_1.makeTable)(['ID', 'Title', 'Slug', 'Status', 'URL', 'Created'], projects.map((p) => [
+            (0, format_1.shorten)(p.id),
+            p.title.slice(0, 30),
+            `${p.slug}.wenrwa.app`,
+            (0, format_1.statusColor)(p.status),
+            p.deployed_url || p.preview_url || '—',
+            p.created_at ? (0, format_1.formatTimeAgo)(p.created_at) : '—',
+        ])));
+    }
+    catch (err) {
+        (0, format_1.error)(err.message);
+    }
+});
+exports.appsCommand
+    .command('create')
+    .description('Create a new hosted app')
+    .requiredOption('--title <title>', 'App title')
+    .requiredOption('--reward <amount>', 'Reward amount in USDC')
+    .requiredOption('--deadline <date>', 'Deadline (ISO 8601)')
+    .option('--description <desc>', 'App description')
+    .option('--framework <fw>', 'Framework (react, nextjs, vue, svelte, vanilla)', 'react')
+    .option('--visibility <vis>', 'Visibility (public, unlisted)', 'public')
+    .action(async (opts) => {
+    try {
+        const client = (0, client_1.getClient)();
+        const amountMicro = String(Math.round(parseFloat(opts.reward) * 1e6));
+        const data = await client.post('/projects', {
+            title: opts.title,
+            description: opts.description || opts.title,
+            framework: opts.framework,
+            visibility: opts.visibility,
+            rewardAmount: amountMicro,
+            deadline: new Date(opts.deadline).toISOString(),
+        });
+        (0, format_1.heading)('App Created');
+        console.log(`  Project ID:  ${data.project.id}`);
+        console.log(`  Bounty ID:   ${data.bountyId}`);
+        console.log(`  Slug:        ${data.project.slug}.wenrwa.app`);
+        console.log(`  Status:      ${(0, format_1.statusColor)(data.project.status)}`);
+    }
+    catch (err) {
+        (0, format_1.error)(err.message);
+    }
+});
+exports.appsCommand
+    .command('status')
+    .argument('<id>', 'Project ID')
+    .description('Show app details')
+    .action(async (id) => {
+    try {
+        const client = (0, client_1.getClient)();
+        const data = await client.get(`/projects/${id}`);
+        const p = data.project;
+        (0, format_1.heading)(`App: ${p.title}`);
+        console.log(`  ID:           ${p.id}`);
+        console.log(`  Slug:         ${p.slug}.wenrwa.app`);
+        console.log(`  Status:       ${(0, format_1.statusColor)(p.status)}`);
+        console.log(`  Framework:    ${p.framework || '—'}`);
+        console.log(`  Visibility:   ${p.visibility}`);
+        console.log(`  Preview URL:  ${p.preview_url || '—'}`);
+        console.log(`  Deployed URL: ${p.deployed_url || '—'}`);
+        console.log(`  Created:      ${p.created_at}`);
+        if (p.deployed_at)
+            console.log(`  Deployed:     ${p.deployed_at}`);
+    }
+    catch (err) {
+        (0, format_1.error)(err.message);
+    }
+});
+exports.appsCommand
+    .command('download')
+    .argument('<id>', 'Project ID')
+    .option('-o, --output <path>', 'Output file path', 'source.zip')
+    .description('Download source.zip')
+    .action(async (id, opts) => {
+    try {
+        const client = (0, client_1.getClient)();
+        const url = `${client.getApiUrl()}/projects/${id}/source`;
+        const res = await fetch(url, {
+            headers: { 'X-Wallet-Pubkey': client.getApiKey() },
+        });
+        if (!res.ok) {
+            const data = await res.json().catch(() => ({}));
+            throw new Error(data?.error?.message || `HTTP ${res.status}`);
+        }
+        const buffer = Buffer.from(await res.arrayBuffer());
+        (0, fs_1.writeFileSync)(opts.output, buffer);
+        console.log(chalk_1.default.green(`Downloaded to ${opts.output} (${buffer.length} bytes)`));
+    }
+    catch (err) {
+        (0, format_1.error)(err.message);
+    }
+});
+exports.appsCommand
+    .command('export-github')
+    .argument('<id>', 'Project ID')
+    .option('--repo <name>', 'GitHub repo name')
+    .option('--private', 'Create private repo')
+    .description('Export source to GitHub')
+    .action(async (id, opts) => {
+    try {
+        const client = (0, client_1.getClient)();
+        const data = await client.post(`/projects/${id}/export-github`, {
+            repoName: opts.repo,
+            isPrivate: opts.private ?? false,
+        });
+        console.log(chalk_1.default.green(`Exported to GitHub: ${data.repoUrl}`));
+    }
+    catch (err) {
+        if (err.message?.includes('not connected')) {
+            console.log(chalk_1.default.yellow('GitHub not connected. Visit the web app to complete OAuth.'));
+        }
+        else {
+            (0, format_1.error)(err.message);
+        }
+    }
+});
+exports.appsCommand
+    .command('deployments')
+    .argument('<id>', 'Project ID')
+    .description('List deployment history')
+    .action(async (id) => {
+    try {
+        const client = (0, client_1.getClient)();
+        const data = await client.get(`/projects/${id}/deployments`);
+        const deployments = data.deployments || [];
+        if (deployments.length === 0) {
+            console.log('No deployments yet.');
+            return;
+        }
+        console.log((0, format_1.makeTable)(['ID', 'Status', 'URL', 'Initiated By', 'Created'], deployments.map((d) => [
+            (0, format_1.shorten)(d.id),
+            (0, format_1.statusColor)(d.status),
+            d.deployed_url || '—',
+            (0, format_1.shorten)(d.initiated_by),
+            d.created_at ? (0, format_1.formatTimeAgo)(d.created_at) : '—',
+        ])));
+    }
+    catch (err) {
+        (0, format_1.error)(err.message);
+    }
+});

package/dist/commands/bounty.js

@@ -65,6 +65,10 @@ exports.bountyCommand
         console.log(`  Assignee:       ${b.assignee_wallet || '—'}`);
         console.log(`  Assignment:     ${b.assignment_mode}`);
         console.log(`  Verification:   ${b.verification_mode}`);
+        if (b.expected_deliverable_type && b.expected_deliverable_type !== 'generic') {
+            const labels = { pr: 'Pull Request', document: 'Document', report: 'Report' };
+            console.log(`  Deliverable:    ${labels[b.expected_deliverable_type] || b.expected_deliverable_type}`);
+        }
         console.log(`  Deadline:       ${b.deadline || '—'}`);
         console.log(`  Max retries:    ${b.max_retries ?? 0}`);
         console.log(`  Retry count:    ${b.retry_count ?? 0}`);
@@ -75,6 +79,10 @@ exports.bountyCommand
         if (b.result_url) {
             console.log(`  Result URL:     ${b.result_url}`);
         }
+        // Show PR URL from latest submission if available
+        if (b.pr_url) {
+            console.log(`  PR URL:         ${b.pr_url}`);
+        }
         if (b.task_schema) {
             (0, format_1.heading)('Task Schema');
             console.log(JSON.stringify(b.task_schema, null, 2));

package/dist/commands/dashboard.d.ts

@@ -1,2 +1,33 @@
 import { Command } from 'commander';
+import { WsEvent } from '../utils/websocket';
+export interface BountyRow {
+    id: string;
+    title: string;
+    status: string;
+    assignee_wallet?: string;
+    percentage?: number;
+    last_heartbeat?: string;
+    reward_amount: string;
+    reward_symbol: string;
+}
+export interface DashboardState {
+    workspace: {
+        id: string;
+        name: string;
+        mode: string;
+    };
+    bounties: BountyRow[];
+    treasury: {
+        balance: string;
+        total_funded: string;
+        total_paid: string;
+    };
+    events: string[];
+    startTime: number;
+}
 export declare const dashboardCommand: Command;
+export declare function updateBountyFromEvent(state: DashboardState, event: WsEvent): void;
+export declare function pad(s: string, len: number, right?: boolean): string;
+export declare function colorOverhead(status: string): number;
+export declare function heartbeatColor(hb: string): string;
+export declare function formatUptime(ms: number): string;

package/dist/commands/dashboard.js

@@ -4,6 +4,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dashboardCommand = void 0;
+exports.updateBountyFromEvent = updateBountyFromEvent;
+exports.pad = pad;
+exports.colorOverhead = colorOverhead;
+exports.heartbeatColor = heartbeatColor;
+exports.formatUptime = formatUptime;
 const commander_1 = require("commander");
 const chalk_1 = __importDefault(require("chalk"));
 const client_1 = require("../utils/client");

package/dist/commands/treasury.js

@@ -57,7 +57,7 @@ exports.treasuryCommand
 exports.treasuryCommand
     .command('fund')
     .argument('<workspace-id>', 'Workspace ID')
-    .requiredOption('--amount <amount>', 'Amount in lamports to fund')
+    .requiredOption('--amount <amount>', 'Amount in USDC micro-units')
     .option('--tx-signature <sig>', 'On-chain transaction signature')
     .description('Fund workspace treasury')
     .action(async (workspaceId, opts) => {
@@ -76,7 +76,7 @@ exports.treasuryCommand
 exports.treasuryCommand
     .command('distribute')
     .argument('<workspace-id>', 'Workspace ID')
-    .requiredOption('--per-agent <amount>', 'Amount per agent in lamports')
+    .requiredOption('--per-agent <amount>', 'Amount per agent in USDC micro-units')
     .description('Distribute funds to workspace agents')
     .action(async (workspaceId, opts) => {
     try {

package/dist/commands/webhook.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const webhookCommand: Command;

package/dist/commands/webhook.js

@@ -0,0 +1,131 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webhookCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const client_1 = require("../utils/client");
+const format_1 = require("../utils/format");
+exports.webhookCommand = new commander_1.Command('webhook').description('Webhook subscription management');
+exports.webhookCommand
+    .command('create')
+    .requiredOption('--url <url>', 'Webhook callback URL (HTTPS)')
+    .requiredOption('--events <types...>', 'Event types to subscribe to (e.g. bounty:created bounty:completed)')
+    .option('--workspace <id>', 'Filter to a specific workspace')
+    .option('--bounty <id>', 'Filter to a specific bounty')
+    .description('Create a new webhook subscription')
+    .action(async (opts) => {
+    try {
+        const client = (0, client_1.getClient)();
+        const data = await client.post('/webhooks', {
+            url: opts.url,
+            eventTypes: opts.events,
+            filterWorkspaceId: opts.workspace,
+            filterBountyId: opts.bounty,
+        });
+        const sub = data.subscription;
+        (0, format_1.success)('Webhook created');
+        console.log(`  ID:     ${sub.id}`);
+        console.log(`  URL:    ${sub.url}`);
+        console.log(`  Events: ${sub.eventTypes.join(', ')}`);
+        console.log();
+        console.log(chalk_1.default.yellow.bold('  Secret (shown once — save it now):'));
+        console.log(chalk_1.default.yellow(`  ${sub.secret}`));
+    }
+    catch (err) {
+        (0, format_1.error)(err.message);
+    }
+});
+exports.webhookCommand
+    .command('list')
+    .description('List your webhook subscriptions')
+    .action(async () => {
+    try {
+        const client = (0, client_1.getClient)();
+        const data = await client.get('/webhooks');
+        const subs = data.subscriptions || [];
+        if (subs.length === 0) {
+            console.log(chalk_1.default.dim('  No webhook subscriptions'));
+            return;
+        }
+        (0, format_1.heading)('Webhook Subscriptions');
+        console.log((0, format_1.makeTable)(['ID', 'URL', 'Events', 'Active', 'Failures', 'Last Delivery'], subs.map((s) => [
+            (0, format_1.shorten)(s.id),
+            s.url.length > 40 ? s.url.slice(0, 37) + '...' : s.url,
+            s.eventTypes.length > 2
+                ? `${s.eventTypes.slice(0, 2).join(', ')} +${s.eventTypes.length - 2}`
+                : s.eventTypes.join(', '),
+            s.isActive ? chalk_1.default.green('yes') : chalk_1.default.red('no'),
+            s.consecutiveFailures > 0 ? chalk_1.default.red(String(s.consecutiveFailures)) : '0',
+            s.lastDeliveryAt ? (0, format_1.formatTimeAgo)(s.lastDeliveryAt) : chalk_1.default.dim('never'),
+        ])));
+    }
+    catch (err) {
+        (0, format_1.error)(err.message);
+    }
+});
+exports.webhookCommand
+    .command('delete')
+    .argument('<id>', 'Webhook subscription ID')
+    .description('Delete a webhook subscription')
+    .action(async (id) => {
+    try {
+        const client = (0, client_1.getClient)();
+        await client.del(`/webhooks/${id}`);
+        (0, format_1.success)(`Webhook ${(0, format_1.shorten)(id)} deleted`);
+    }
+    catch (err) {
+        (0, format_1.error)(err.message);
+    }
+});
+exports.webhookCommand
+    .command('deliveries')
+    .argument('<id>', 'Webhook subscription ID')
+    .option('--limit <n>', 'Number of deliveries to show', '10')
+    .description('Show recent delivery attempts for a webhook')
+    .action(async (id, opts) => {
+    try {
+        const client = (0, client_1.getClient)();
+        const data = await client.get(`/webhooks/${id}/deliveries?limit=${opts.limit}`);
+        const deliveries = data.deliveries || [];
+        if (deliveries.length === 0) {
+            console.log(chalk_1.default.dim('  No deliveries yet'));
+            return;
+        }
+        (0, format_1.heading)('Webhook Deliveries');
+        console.log((0, format_1.makeTable)(['Event', 'Type', 'Attempt', 'Status', 'HTTP', 'Time'], deliveries.map((d) => [
+            (0, format_1.shorten)(d.eventId),
+            d.eventType,
+            String(d.attempt),
+            (0, format_1.statusColor)(d.status),
+            d.httpStatus ? String(d.httpStatus) : chalk_1.default.dim('—'),
+            d.createdAt ? (0, format_1.formatTimeAgo)(d.createdAt) : '',
+        ])));
+    }
+    catch (err) {
+        (0, format_1.error)(err.message);
+    }
+});
+exports.webhookCommand
+    .command('test')
+    .argument('<id>', 'Webhook subscription ID')
+    .description('Send a synthetic test event to a webhook')
+    .action(async (id) => {
+    try {
+        const client = (0, client_1.getClient)();
+        console.log(`Sending test event to webhook ${(0, format_1.shorten)(id)}...`);
+        const data = await client.post(`/webhooks/${id}/test`, {});
+        const delivery = data.delivery;
+        if (delivery.status === 'success') {
+            (0, format_1.success)(`Test delivered successfully (HTTP ${delivery.httpStatus})`);
+        }
+        else {
+            (0, format_1.error)(`Test delivery failed: ${delivery.errorMessage || `HTTP ${delivery.httpStatus}`}`);
+        }
+    }
+    catch (err) {
+        (0, format_1.error)(err.message);
+    }
+});