@paylobster/cli 4.0.0

package/src/lib/display.ts

@@ -0,0 +1,265 @@
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import type { OutputOptions } from './types';
+
+/**
+ * Print JSON output if --json flag is set
+ */
+export function outputJSON(data: any, options?: OutputOptions): boolean {
+  if (options?.json) {
+    console.log(JSON.stringify(data, null, 2));
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Print success message
+ */
+export function success(message: string): void {
+  console.log(chalk.green('✅ ' + message));
+}
+
+/**
+ * Print error message
+ */
+export function error(message: string): void {
+  console.error(chalk.red('❌ ' + message));
+}
+
+/**
+ * Print warning message
+ */
+export function warning(message: string): void {
+  console.warn(chalk.yellow('⚠️  ' + message));
+}
+
+/**
+ * Print info message
+ */
+export function info(message: string): void {
+  console.log(chalk.blue('ℹ️  ' + message));
+}
+
+/**
+ * Print section header
+ */
+export function header(text: string): void {
+  console.log();
+  console.log(chalk.bold.cyan('🦞 ' + text));
+  console.log(chalk.gray('─'.repeat(text.length + 3)));
+}
+
+/**
+ * Create a table
+ */
+export function createTable(options?: any): Table.Table {
+  return new Table({
+    chars: {
+      top: '─',
+      'top-mid': '┬',
+      'top-left': '┌',
+      'top-right': '┐',
+      bottom: '─',
+      'bottom-mid': '┴',
+      'bottom-left': '└',
+      'bottom-right': '┘',
+      left: '│',
+      'left-mid': '├',
+      mid: '─',
+      'mid-mid': '┼',
+      right: '│',
+      'right-mid': '┤',
+      middle: '│',
+    },
+    style: {
+      head: ['cyan', 'bold'],
+      border: ['gray'],
+    },
+    ...options,
+  });
+}
+
+/**
+ * Print key-value pairs
+ */
+export function printKeyValue(data: Record<string, any>): void {
+  const maxKeyLength = Math.max(...Object.keys(data).map(k => k.length));
+  
+  for (const [key, value] of Object.entries(data)) {
+    const paddedKey = key.padEnd(maxKeyLength);
+    console.log(chalk.gray(paddedKey + ':'), chalk.white(value));
+  }
+}
+
+/**
+ * Format address (shorten)
+ */
+export function formatAddress(address: string): string {
+  return `${address.slice(0, 6)}...${address.slice(-4)}`;
+}
+
+/**
+ * Format status with color
+ */
+export function formatStatus(status: number | string): string {
+  const statusMap: Record<string, { text: string; color: any }> = {
+    0: { text: 'Pending', color: chalk.yellow },
+    1: { text: 'Active', color: chalk.blue },
+    2: { text: 'Released', color: chalk.green },
+    3: { text: 'Disputed', color: chalk.red },
+    pending: { text: 'Pending', color: chalk.yellow },
+    active: { text: 'Active', color: chalk.blue },
+    released: { text: 'Released', color: chalk.green },
+    disputed: { text: 'Disputed', color: chalk.red },
+  };
+
+  const statusKey = status.toString();
+  const statusInfo = statusMap[statusKey] || { text: status.toString(), color: chalk.white };
+  
+  return statusInfo.color(statusInfo.text);
+}
+
+/**
+ * Format boolean as emoji
+ */
+export function formatBoolean(value: boolean): string {
+  return value ? chalk.green('✅') : chalk.red('❌');
+}
+
+/**
+ * Format number with commas
+ */
+export function formatNumber(num: number | string): string {
+  return Number(num).toLocaleString();
+}
+
+/**
+ * Print a horizontal divider
+ */
+export function divider(): void {
+  console.log(chalk.gray('─'.repeat(50)));
+}
+
+/**
+ * Print agent status header
+ */
+export function printAgentHeader(name: string, address: string): void {
+  console.log();
+  console.log(chalk.bold.cyan('🦞 PayLobster Agent Status'));
+  divider();
+  console.log(chalk.gray('Name:    ') + chalk.white.bold(name));
+  console.log(chalk.gray('Address: ') + chalk.white(address));
+  divider();
+}
+
+/**
+ * Print escrow table
+ */
+export function printEscrowTable(escrows: any[]): void {
+  if (escrows.length === 0) {
+    info('No escrows found');
+    return;
+  }
+
+  const table = createTable({
+    head: ['ID', 'From', 'To', 'Amount', 'Status'],
+  });
+
+  for (const escrow of escrows) {
+    table.push([
+      escrow.id,
+      formatAddress(escrow.from),
+      formatAddress(escrow.to),
+      escrow.amount,
+      formatStatus(escrow.status),
+    ]);
+  }
+
+  console.log(table.toString());
+}
+
+/**
+ * Spinner/loading indicator using ora
+ */
+export async function withSpinner<T>(
+  text: string,
+  fn: () => Promise<T>
+): Promise<T> {
+  const ora = (await import('ora')).default;
+  const spinner = ora(text).start();
+  
+  try {
+    const result = await fn();
+    spinner.succeed();
+    return result;
+  } catch (error) {
+    spinner.fail();
+    throw error;
+  }
+}
+
+/**
+ * Format network name
+ */
+export function formatNetwork(network: string): string {
+  const networkMap: Record<string, string> = {
+    mainnet: 'Base Mainnet',
+    sepolia: 'Base Sepolia',
+  };
+  return networkMap[network] || network;
+}
+
+/**
+ * Print configuration table
+ */
+export function printConfig(config: Record<string, any>): void {
+  const table = createTable({
+    head: ['Setting', 'Value'],
+  });
+
+  for (const [key, value] of Object.entries(config)) {
+    if (key === 'wallet' && typeof value === 'object') {
+      table.push([key, value.type || 'env']);
+    } else {
+      table.push([key, value?.toString() || 'not set']);
+    }
+  }
+
+  console.log(table.toString());
+}
+
+/**
+ * Print reputation score with visual indicator
+ */
+export function printReputation(score: number): string {
+  const stars = Math.floor(score / 20); // Convert 0-100 to 0-5 stars
+  const fullStar = '★';
+  const emptyStar = '☆';
+  
+  const starsStr = fullStar.repeat(stars) + emptyStar.repeat(5 - stars);
+  
+  if (score >= 80) {
+    return chalk.green(starsStr + ` ${score}`);
+  } else if (score >= 60) {
+    return chalk.yellow(starsStr + ` ${score}`);
+  } else {
+    return chalk.red(starsStr + ` ${score}`);
+  }
+}
+
+/**
+ * Confirm action (simple yes/no prompt)
+ */
+export async function confirm(message: string): Promise<boolean> {
+  const inquirer = (await import('inquirer')).default;
+  const { confirmed } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirmed',
+      message,
+      default: false,
+    },
+  ]);
+  return confirmed;
+}

package/src/lib/types.ts

@@ -0,0 +1,57 @@
+import type { Address } from 'viem';
+
+export type Network = 'mainnet' | 'sepolia';
+
+export interface CLIConfig {
+  network: Network;
+  rpcUrl?: string;
+  wallet?: {
+    type: 'private-key' | 'keystore' | 'env';
+    path?: string;
+  };
+  indexerUrl?: string;
+}
+
+export interface AgentInfo {
+  name: string;
+  tokenId: bigint;
+  registered: boolean;
+  address: Address;
+}
+
+export interface Reputation {
+  score: bigint;
+  trustVector: bigint;
+}
+
+export interface CreditStatus {
+  limit: bigint;
+  available: bigint;
+  inUse: bigint;
+}
+
+export interface EscrowInfo {
+  sender: Address;
+  recipient: Address;
+  amount: bigint;
+  token: Address;
+  status: number; // 0=pending, 1=active, 2=released, 3=disputed
+}
+
+export interface Balance {
+  usdc: bigint;
+  eth: bigint;
+}
+
+export interface ServiceListing {
+  serviceId: string;
+  provider: Address;
+  name: string;
+  category: string;
+  price: bigint;
+  reputation: number;
+}
+
+export interface OutputOptions {
+  json?: boolean;
+}

package/src/lib/wallet.ts

@@ -0,0 +1,146 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { createWalletClient, http, type WalletClient, type Account } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { base, baseSepolia } from 'viem/chains';
+import { loadConfig, getRpcUrl } from './config';
+import type { Network } from './types';
+
+const KEYSTORE_DIR = path.join(os.homedir(), '.plob', 'keystore');
+
+/**
+ * Load wallet from configured source
+ */
+export async function loadWallet(): Promise<{ client: WalletClient; account: Account }> {
+  const config = loadConfig();
+  const network = config.network;
+  const chain = network === 'mainnet' ? base : baseSepolia;
+
+  let privateKey: `0x${string}`;
+
+  // Try different sources in order:
+  // 1. Environment variable PRIVATE_KEY or PAYLOBSTER_PRIVATE_KEY
+  // 2. Keystore file
+  // 3. Config file (not recommended for production)
+  
+  if (process.env.PRIVATE_KEY) {
+    privateKey = process.env.PRIVATE_KEY as `0x${string}`;
+  } else if (process.env.PAYLOBSTER_PRIVATE_KEY) {
+    privateKey = process.env.PAYLOBSTER_PRIVATE_KEY as `0x${string}`;
+  } else if (config.wallet?.type === 'keystore' && config.wallet.path) {
+    privateKey = loadFromKeystore(config.wallet.path);
+  } else {
+    throw new Error(
+      'No wallet configured. Run `plob auth --private-key <key>` or set PRIVATE_KEY env var'
+    );
+  }
+
+  // Validate private key format
+  if (!privateKey.startsWith('0x') || privateKey.length !== 66) {
+    throw new Error('Invalid private key format. Must be 0x-prefixed 64-character hex string');
+  }
+
+  const account = privateKeyToAccount(privateKey);
+  
+  const client = createWalletClient({
+    account,
+    chain,
+    transport: http(getRpcUrl(network)),
+  });
+
+  return { client, account };
+}
+
+/**
+ * Save private key to keystore (encrypted)
+ * Note: For production, use a proper keystore with password encryption
+ */
+export function saveToKeystore(privateKey: string, filename?: string): string {
+  try {
+    if (!fs.existsSync(KEYSTORE_DIR)) {
+      fs.mkdirSync(KEYSTORE_DIR, { recursive: true, mode: 0o700 });
+    }
+
+    const keystoreFile = filename || 'default.key';
+    const keystorePath = path.join(KEYSTORE_DIR, keystoreFile);
+
+    // WARNING: This is a simple file storage. For production, use proper encryption!
+    fs.writeFileSync(keystorePath, privateKey, { mode: 0o600 });
+
+    return keystorePath;
+  } catch (error) {
+    throw new Error(`Failed to save keystore: ${error}`);
+  }
+}
+
+/**
+ * Load private key from keystore
+ */
+export function loadFromKeystore(filename: string): `0x${string}` {
+  try {
+    let keystorePath: string;
+
+    if (path.isAbsolute(filename)) {
+      keystorePath = filename;
+    } else {
+      keystorePath = path.join(KEYSTORE_DIR, filename);
+    }
+
+    if (!fs.existsSync(keystorePath)) {
+      throw new Error(`Keystore file not found: ${keystorePath}`);
+    }
+
+    const privateKey = fs.readFileSync(keystorePath, 'utf-8').trim();
+    return privateKey as `0x${string}`;
+  } catch (error) {
+    throw new Error(`Failed to load keystore: ${error}`);
+  }
+}
+
+/**
+ * Delete keystore file
+ */
+export function deleteKeystore(filename: string): void {
+  const keystorePath = path.join(KEYSTORE_DIR, filename);
+  if (fs.existsSync(keystorePath)) {
+    fs.unlinkSync(keystorePath);
+  }
+}
+
+/**
+ * List all keystore files
+ */
+export function listKeystores(): string[] {
+  if (!fs.existsSync(KEYSTORE_DIR)) {
+    return [];
+  }
+  return fs.readdirSync(KEYSTORE_DIR).filter(file => file.endsWith('.key'));
+}
+
+/**
+ * Get wallet address without loading full client
+ */
+export function getWalletAddress(): string {
+  try {
+    let privateKey: `0x${string}`;
+
+    if (process.env.PRIVATE_KEY) {
+      privateKey = process.env.PRIVATE_KEY as `0x${string}`;
+    } else if (process.env.PAYLOBSTER_PRIVATE_KEY) {
+      privateKey = process.env.PAYLOBSTER_PRIVATE_KEY as `0x${string}`;
+    } else {
+      const config = loadConfig();
+      if (config.wallet?.type === 'keystore' && config.wallet.path) {
+        privateKey = loadFromKeystore(config.wallet.path);
+      } else {
+        throw new Error('No wallet configured');
+      }
+    }
+
+    const account = privateKeyToAccount(privateKey);
+    return account.address;
+  } catch (error) {
+    throw new Error(`Failed to get wallet address: ${error}`);
+  }
+}

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "lib": ["ES2022", "DOM"],
+    "outDir": "./dist",
+    "rootDir": "./",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "moduleResolution": "node",
+    "types": ["node"]
+  },
+  "include": ["src/**/*", "bin/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}