@paylobster/cli 4.5.0 → 4.6.1

package/src/commands/webhook.ts

@@ -0,0 +1,260 @@
+import { Command } from 'commander';
+import { success, error, info, withSpinner, outputJSON } from '../lib/display';
+import type { OutputOptions } from '../lib/types';
+
+const API_URL = process.env.PAYLOBSTER_API_URL || 'https://paylobster.com';
+
+interface Webhook {
+  id: string;
+  url: string;
+  events: string[];
+  secret?: string;
+  createdAt: string;
+  status: 'active' | 'paused';
+  lastDeliveryAttempt?: string;
+  lastDeliveryStatus?: 'success' | 'failed';
+}
+
+/**
+ * Webhooks command
+ */
+export function createWebhookCommand(): Command {
+  const cmd = new Command('webhooks')
+    .description('Register and manage webhooks');
+
+  // Register subcommand
+  cmd
+    .command('register')
+    .description('Register a new webhook')
+    .requiredOption('--url <url>', 'Webhook URL')
+    .requiredOption('--events <events>', 'Comma-separated event types')
+    .option('--secret <secret>', 'Webhook secret for signature verification')
+    .option('--json', 'Output as JSON')
+    .action(async (options: {
+      url: string;
+      events: string;
+      secret?: string;
+    } & OutputOptions) => {
+      try {
+        // Validate URL
+        try {
+          new URL(options.url);
+        } catch {
+          error('Invalid URL format');
+          process.exit(1);
+        }
+
+        // Parse events
+        const events = options.events.split(',').map(e => e.trim()).filter(Boolean);
+        if (events.length === 0) {
+          error('At least one event type is required');
+          process.exit(1);
+        }
+
+        const webhook = await withSpinner(
+          'Registering webhook...',
+          async () => {
+            const response = await fetch(`${API_URL}/api/v3/webhooks`, {
+              method: 'POST',
+              headers: {
+                'Content-Type': 'application/json',
+              },
+              body: JSON.stringify({
+                url: options.url,
+                events,
+                secret: options.secret,
+              }),
+            });
+
+            if (!response.ok) {
+              const err = await response.json() as { error?: string };
+              throw new Error(err.error || 'Failed to register webhook');
+            }
+
+            return response.json() as Promise<Webhook>;
+          }
+        );
+
+        if (outputJSON(webhook, options)) {
+          return;
+        }
+
+        success('Webhook registered!');
+        console.log();
+        console.log('  Webhook ID: ', webhook.id);
+        console.log('  URL:        ', webhook.url);
+        console.log('  Events:     ', webhook.events.join(', '));
+        console.log('  Status:     ', webhook.status);
+        if (webhook.secret) {
+          console.log('  Secret:     ', webhook.secret);
+        }
+        console.log();
+        info('Your webhook will receive notifications for the specified events');
+      } catch (err) {
+        error(`Failed to register webhook: ${(err as Error).message}`);
+        process.exit(1);
+      }
+    });
+
+  // List subcommand
+  cmd
+    .command('list')
+    .description('List all registered webhooks')
+    .option('--address <address>', 'Filter by address')
+    .option('--json', 'Output as JSON')
+    .action(async (options: {
+      address?: string;
+    } & OutputOptions) => {
+      try {
+        const result = await withSpinner(
+          'Fetching webhooks...',
+          async () => {
+            const url = new URL(`${API_URL}/api/v3/webhooks`);
+            if (options.address) {
+              url.searchParams.set('address', options.address);
+            }
+
+            const response = await fetch(url.toString(), {
+              method: 'GET',
+              headers: {
+                'Content-Type': 'application/json',
+              },
+            });
+
+            if (!response.ok) {
+              const err = await response.json() as { error?: string };
+              throw new Error(err.error || 'Failed to fetch webhooks');
+            }
+
+            return response.json() as Promise<{ webhooks: Webhook[] }>;
+          }
+        );
+
+        if (outputJSON(result, options)) {
+          return;
+        }
+
+        if (result.webhooks.length === 0) {
+          info('No webhooks registered');
+          return;
+        }
+
+        console.log();
+        console.log(`Found ${result.webhooks.length} webhook(s):`);
+        console.log();
+
+        for (const webhook of result.webhooks) {
+          console.log(`  ${webhook.id}`);
+          console.log(`    URL:     ${webhook.url}`);
+          console.log(`    Events:  ${webhook.events.join(', ')}`);
+          console.log(`    Status:  ${webhook.status === 'active' ? '✅ Active' : '⏸️  Paused'}`);
+          if (webhook.lastDeliveryAttempt) {
+            const status = webhook.lastDeliveryStatus === 'success' ? '✅' : '❌';
+            console.log(`    Last:    ${status} ${new Date(webhook.lastDeliveryAttempt).toLocaleString()}`);
+          }
+          console.log();
+        }
+      } catch (err) {
+        error(`Failed to fetch webhooks: ${(err as Error).message}`);
+        process.exit(1);
+      }
+    });
+
+  // Get subcommand
+  cmd
+    .command('get <id>')
+    .description('Get webhook details')
+    .option('--include-secret', 'Include webhook secret in output')
+    .option('--json', 'Output as JSON')
+    .action(async (id: string, options: {
+      includeSecret?: boolean;
+    } & OutputOptions) => {
+      try {
+        const webhook = await withSpinner(
+          'Fetching webhook...',
+          async () => {
+            const url = new URL(`${API_URL}/api/v3/webhooks/${id}`);
+            if (options.includeSecret) {
+              url.searchParams.set('includeSecret', 'true');
+            }
+
+            const response = await fetch(url.toString(), {
+              method: 'GET',
+              headers: {
+                'Content-Type': 'application/json',
+              },
+            });
+
+            if (!response.ok) {
+              const err = await response.json() as { error?: string };
+              throw new Error(err.error || 'Failed to fetch webhook');
+            }
+
+            return response.json() as Promise<Webhook>;
+          }
+        );
+
+        if (outputJSON(webhook, options)) {
+          return;
+        }
+
+        console.log();
+        console.log('Webhook Details:');
+        console.log('  ID:      ', webhook.id);
+        console.log('  URL:     ', webhook.url);
+        console.log('  Events:  ', webhook.events.join(', '));
+        console.log('  Status:  ', webhook.status === 'active' ? '✅ Active' : '⏸️  Paused');
+        if (webhook.secret) {
+          console.log('  Secret:  ', webhook.secret);
+        }
+        console.log('  Created: ', new Date(webhook.createdAt).toLocaleString());
+        if (webhook.lastDeliveryAttempt) {
+          const status = webhook.lastDeliveryStatus === 'success' ? '✅ Success' : '❌ Failed';
+          console.log('  Last:    ', `${status} at ${new Date(webhook.lastDeliveryAttempt).toLocaleString()}`);
+        }
+        console.log();
+      } catch (err) {
+        error(`Failed to fetch webhook: ${(err as Error).message}`);
+        process.exit(1);
+      }
+    });
+
+  // Delete subcommand
+  cmd
+    .command('delete <id>')
+    .description('Delete a webhook')
+    .option('--json', 'Output as JSON')
+    .action(async (id: string, options: OutputOptions) => {
+      try {
+        const result = await withSpinner(
+          'Deleting webhook...',
+          async () => {
+            const response = await fetch(`${API_URL}/api/v3/webhooks/${id}`, {
+              method: 'DELETE',
+              headers: {
+                'Content-Type': 'application/json',
+              },
+            });
+
+            if (!response.ok) {
+              const err = await response.json() as { error?: string };
+              throw new Error(err.error || 'Failed to delete webhook');
+            }
+
+            return response.json() as Promise<{ success: boolean; message: string }>;
+          }
+        );
+
+        if (outputJSON(result, options)) {
+          return;
+        }
+
+        success('Webhook deleted successfully');
+      } catch (err) {
+        error(`Failed to delete webhook: ${(err as Error).message}`);
+        process.exit(1);
+      }
+    });
+
+  return cmd;
+}

package/src/index.ts

@@ -29,6 +29,11 @@ import { createHealthCommand } from './commands/health';
 import { createSearchCommand } from './commands/search';
 import { createExportCommand } from './commands/export';
 import { createTrustGraphCommand } from './commands/trust-graph';
+import { createInitCommand } from './commands/init';
+import { createLinkCommand } from './commands/link';
+import { createWebhookCommand } from './commands/webhook';
+import { createRefundCommand } from './commands/refund';
+import { createAlertsCommand } from './commands/alerts';
 import chalk from 'chalk';
 
 // Load environment variables from .env file if present
@@ -83,6 +88,11 @@ program.addCommand(createHealthCommand());
 program.addCommand(createSearchCommand());
 program.addCommand(createExportCommand());
 program.addCommand(createTrustGraphCommand());
+program.addCommand(createInitCommand());
+program.addCommand(createLinkCommand());
+program.addCommand(createWebhookCommand());
+program.addCommand(createRefundCommand());
+program.addCommand(createAlertsCommand());
 registerInvestCommand(program);
 
 // Handle errors

package/src/lib/contracts.ts

@@ -8,21 +8,21 @@ import type { Network, AgentInfo, Reputation, CreditStatus, EscrowInfo, Balance
 const CONTRACTS_MAINNET = {
   IDENTITY: '0xA174ee274F870631B3c330a85EBCad74120BE662' as Address,
   REPUTATION: '0x02bb4132a86134684976E2a52E43D59D89E64b29' as Address,
-  CREDIT: '0xD9241Ce8a721Ef5fcCAc5A11983addC526eC80E1' as Address,
-  ESCROW: '0x49EdEe04c78B7FeD5248A20706c7a6c540748806' as Address,
+  CREDIT: '0x4c22B52eacAB9eD2Ce018d032739a93eC68eD27a' as Address,
+  ESCROW: '0x703B528C1b07cd27992af9Ae11DD67bE685E489e' as Address,
   USDC: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913' as Address,
-  TRUST_GRAPH: '0x0000000000000000000000000000000000000000' as Address, // TODO: Deploy TrustGraph
+  TRUST_GRAPH: '0xbccd1d0a37ce981a13b3392d7881f94e28fa693b' as Address,
 };
 
 const CONTRACTS_SEPOLIA = {
   IDENTITY: '0x3dfA02Ed4F0e4F10E8031d7a4cB8Ea0bBbFbCB8c' as Address,
   // NOTE: Reputation address provided has 41 hex chars (invalid). Using placeholder.
-  // Original (invalid): 0xb0033901e3b94f4F36dA0b3e396942C1e78205C7d
-  REPUTATION: '0x0000000000000000000000000000000000000000' as Address, // TODO: Fix this address
+  // Was broken (41 hex chars) — fixed to correct address
+  REPUTATION: '0xb0033901e3b94f4F36dA0b3e59A1F4AD9f4f1697' as Address,
   CREDIT: '0xBA64e2b2F2a80D03A4B13b3396942C1e78205C7d' as Address,
   ESCROW: '0x78D1f50a1965dE34f6b5a3D3546C94FE1809Cd82' as Address,
   USDC: '0x036CbD53842c5426634e7929541eC2318f3dCF7e' as Address,
-  TRUST_GRAPH: '0x0000000000000000000000000000000000000000' as Address, // TODO: Deploy TrustGraph
+  TRUST_GRAPH: '0xbccd1d0a37ce981a13b3392d7881f94e28fa693b' as Address,
 };
 
 // ABIs