auramaxx 1.0.0-alpha.4

package/server/cli/approval.ts

@@ -0,0 +1,447 @@
+/**
+ * Terminal Approval Interface
+ *
+ * Connects to the WebSocket server to receive ACTION_CREATED events
+ * and presents an interactive terminal UI for approve/reject decisions.
+ */
+
+import * as readline from 'readline';
+import { WebSocket } from 'ws';
+import { getErrorMessage } from '../lib/error';
+
+interface HumanAction {
+  id: string;
+  type: string;
+  agentId: string;
+  limit: number;
+  permissions: string[];
+  ttl: number;
+  createdAt: number;
+}
+
+interface ApprovalManagerOptions {
+  serverUrl: string;
+  getToken: () => string | null;
+  autoApprove?: boolean;
+  headless?: boolean; // Skip terminal interface (for --password-stdin mode)
+}
+
+export class ApprovalManager {
+  private ws: WebSocket | null = null;
+  private pendingRequests: Map<string, HumanAction> = new Map();
+  private rl: readline.Interface | null = null;
+  private options: ApprovalManagerOptions;
+  private reconnectTimeout: NodeJS.Timeout | null = null;
+  private isRunning = false;
+
+  constructor(options: ApprovalManagerOptions) {
+    this.options = options;
+  }
+
+  /**
+   * Start the approval manager
+   */
+  async start(): Promise<void> {
+    this.isRunning = true;
+
+    // Fetch any existing pending requests
+    await this.fetchPendingRequests();
+
+    // Connect to WebSocket
+    this.connectWebSocket();
+
+    // Set up terminal interface (skip in headless mode)
+    if (!this.options.headless) {
+      this.setupTerminalInterface();
+    }
+  }
+
+  /**
+   * Stop the approval manager
+   */
+  stop(): void {
+    this.isRunning = false;
+
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+
+    if (this.rl) {
+      this.rl.close();
+      this.rl = null;
+    }
+  }
+
+  /**
+   * Fetch existing pending requests from the server
+   */
+  private async fetchPendingRequests(): Promise<void> {
+    try {
+      const token = this.options.getToken();
+      if (!token) return;
+
+      const response = await fetch(`${this.options.serverUrl}/actions/pending`, {
+        headers: { Authorization: `Bearer ${token}` }
+      });
+
+      if (response.ok) {
+        const data = await response.json() as { success?: boolean; actions?: HumanAction[] };
+        const requests = data.actions || [];
+        for (const req of requests) {
+          this.addRequest(req);
+        }
+        if (requests.length > 0) {
+          console.log(`\nFound ${requests.length} pending request(s).`);
+          this.displayQueue();
+        }
+      }
+    } catch {
+      // Silently ignore - will get requests via WebSocket
+    }
+  }
+
+  /**
+   * Connect to the WebSocket server
+   */
+  private connectWebSocket(): void {
+    const wsUrl = process.env.WS_URL || 'ws://localhost:4748';
+
+    try {
+      this.ws = new WebSocket(wsUrl);
+
+      this.ws.on('open', () => {
+        console.log('WebSocket connected - listening for events');
+      });
+
+      this.ws.on('message', (data: Buffer) => {
+        try {
+          const event = JSON.parse(data.toString());
+          this.handleEvent(event);
+        } catch {
+          // Ignore malformed messages
+        }
+      });
+
+      this.ws.on('close', () => {
+        if (this.isRunning) {
+          console.log('WebSocket disconnected, reconnecting in 3s...');
+          this.reconnectTimeout = setTimeout(() => {
+            this.connectWebSocket();
+          }, 3000);
+        }
+      });
+
+      this.ws.on('error', (error) => {
+        console.error('WebSocket error:', error.message);
+      });
+    } catch (error) {
+      console.error('Failed to connect WebSocket:', error);
+      if (this.isRunning) {
+        this.reconnectTimeout = setTimeout(() => {
+          this.connectWebSocket();
+        }, 3000);
+      }
+    }
+  }
+
+  /**
+   * Handle incoming WebSocket event
+   */
+  private handleEvent(event: { type: string; data: unknown }): void {
+    switch (event.type) {
+      case 'action:created':
+        this.handleRequestCreated(event.data as HumanAction);
+        break;
+      case 'action:resolved':
+        this.handleRequestResolved((event.data as { id: string }).id);
+        break;
+    }
+  }
+
+  /**
+   * Handle new request created
+   */
+  private handleRequestCreated(request: HumanAction): void {
+    this.addRequest(request);
+
+    console.log('\n┌─────────────────────────────────────────────────────────────┐');
+    console.log('│  NEW AGENT REQUEST                                          │');
+    console.log('├─────────────────────────────────────────────────────────────┤');
+    console.log(`│  ID:          ${request.id.substring(0, 40).padEnd(45)}│`);
+    console.log(`│  Agent:       ${request.agentId.substring(0, 40).padEnd(45)}│`);
+    console.log(`│  Type:        ${request.type.padEnd(45)}│`);
+    console.log(`│  Limit:       ${(request.limit + ' ETH').padEnd(45)}│`);
+    console.log(`│  Permissions: ${request.permissions.slice(0, 3).join(', ').substring(0, 40).padEnd(45)}│`);
+    console.log(`│  TTL:         ${(request.ttl + 's').padEnd(45)}│`);
+    console.log('└─────────────────────────────────────────────────────────────┘');
+
+    if (this.options.autoApprove) {
+      console.log('Auto-approving (--auto-approve enabled)...');
+      this.resolveAction(request.id, true);
+    } else {
+      console.log('\nEnter request number to review, or:');
+      console.log('  a <id> - approve    r <id> - reject    l - list pending\n');
+    }
+  }
+
+  /**
+   * Handle request resolved (approved or rejected)
+   */
+  private handleRequestResolved(requestId: string): void {
+    this.pendingRequests.delete(requestId);
+  }
+
+  /**
+   * Add request to pending queue
+   */
+  private addRequest(request: HumanAction): void {
+    this.pendingRequests.set(request.id, {
+      ...request,
+      createdAt: Date.now()
+    });
+  }
+
+  /**
+   * Display the pending request queue
+   */
+  private displayQueue(): void {
+    const requests = Array.from(this.pendingRequests.values());
+
+    if (requests.length === 0) {
+      console.log('\nNo pending requests.\n');
+      return;
+    }
+
+    console.log('\n┌─────────────────────────────────────────────────────────────┐');
+    console.log('│  PENDING REQUESTS                                           │');
+    console.log('├─────────────────────────────────────────────────────────────┤');
+
+    requests.forEach((req, index) => {
+      const shortId = req.id.substring(0, 8);
+      const agent = req.agentId.substring(0, 20).padEnd(20);
+      const type = req.type.substring(0, 15).padEnd(15);
+      console.log(`│  ${(index + 1).toString().padStart(2)}. [${shortId}] ${agent} ${type} ${req.limit} ETH │`);
+    });
+
+    console.log('└─────────────────────────────────────────────────────────────┘');
+    console.log('\nCommands: a <id> approve, r <id> reject, <num> review, l list\n');
+  }
+
+  /**
+   * Set up terminal interface for user input
+   */
+  private setupTerminalInterface(): void {
+    this.rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      prompt: 'aura> '
+    });
+
+    this.rl.on('line', (line) => {
+      this.handleCommand(line.trim());
+      this.rl?.prompt();
+    });
+
+    this.rl.on('close', () => {
+      // Interface closed
+    });
+
+    // Initial prompt
+    this.rl.prompt();
+  }
+
+  /**
+   * Handle user command
+   */
+  private handleCommand(input: string): void {
+    if (!input) return;
+
+    const parts = input.split(/\s+/);
+    const cmd = parts[0].toLowerCase();
+    const arg = parts[1];
+
+    switch (cmd) {
+      case 'l':
+      case 'list':
+        this.displayQueue();
+        break;
+
+      case 'a':
+      case 'approve':
+        if (arg) {
+          this.approveByIdOrNumber(arg);
+        } else {
+          console.log('Usage: a <id or number>');
+        }
+        break;
+
+      case 'r':
+      case 'reject':
+        if (arg) {
+          this.rejectByIdOrNumber(arg);
+        } else {
+          console.log('Usage: r <id or number>');
+        }
+        break;
+
+      case 'h':
+      case 'help':
+        this.showHelp();
+        break;
+
+      case 'q':
+      case 'quit':
+        console.log('Use Ctrl+C to exit.');
+        break;
+
+      default:
+        // Check if it's a number (review by index)
+        const num = parseInt(cmd, 10);
+        if (!isNaN(num)) {
+          this.reviewByNumber(num);
+        } else {
+          console.log(`Unknown command: ${cmd}. Type 'h' for help.`);
+        }
+    }
+  }
+
+  /**
+   * Show help
+   */
+  private showHelp(): void {
+    console.log(`
+Commands:
+  l, list           List all pending requests
+  a, approve <id>   Approve request by ID or number
+  r, reject <id>    Reject request by ID or number
+  <number>          Review request details by queue number
+  h, help           Show this help
+  Ctrl+C            Exit CLI
+`);
+  }
+
+  /**
+   * Review request by queue number
+   */
+  private reviewByNumber(num: number): void {
+    const requests = Array.from(this.pendingRequests.values());
+    const index = num - 1;
+
+    if (index < 0 || index >= requests.length) {
+      console.log(`Invalid number. Use 1-${requests.length}`);
+      return;
+    }
+
+    const req = requests[index];
+    console.log(`
+┌─────────────────────────────────────────────────────────────┐
+│  REQUEST DETAILS                                            │
+├─────────────────────────────────────────────────────────────┤
+│  ID:          ${req.id}
+│  Agent:       ${req.agentId}
+│  Type:        ${req.type}
+│  Limit:       ${req.limit} ETH
+│  Permissions: ${req.permissions.join(', ')}
+│  TTL:         ${req.ttl}s (${Math.round(req.ttl / 60)} minutes)
+└─────────────────────────────────────────────────────────────┘
+
+  a ${num}  - approve    r ${num}  - reject
+`);
+  }
+
+  /**
+   * Approve by ID or queue number
+   */
+  private approveByIdOrNumber(arg: string): void {
+    const id = this.resolveRequestId(arg);
+    if (id) {
+      this.resolveAction(id, true);
+    }
+  }
+
+  /**
+   * Reject by ID or queue number
+   */
+  private rejectByIdOrNumber(arg: string): void {
+    const id = this.resolveRequestId(arg);
+    if (id) {
+      this.resolveAction(id, false);
+    }
+  }
+
+  /**
+   * Resolve argument to request ID
+   */
+  private resolveRequestId(arg: string): string | null {
+    // Try as number first
+    const num = parseInt(arg, 10);
+    if (!isNaN(num)) {
+      const requests = Array.from(this.pendingRequests.values());
+      const index = num - 1;
+      if (index >= 0 && index < requests.length) {
+        return requests[index].id;
+      }
+      console.log(`Invalid number. Use 1-${requests.length}`);
+      return null;
+    }
+
+    // Try as ID (partial match)
+    const matching = Array.from(this.pendingRequests.keys()).filter(
+      id => id.startsWith(arg) || id.includes(arg)
+    );
+
+    if (matching.length === 1) {
+      return matching[0];
+    } else if (matching.length > 1) {
+      console.log('Ambiguous ID, matches:', matching.map(id => id.substring(0, 12)).join(', '));
+      return null;
+    } else {
+      console.log('Request not found:', arg);
+      return null;
+    }
+  }
+
+  /**
+   * Resolve an action (approve or reject)
+   */
+  private async resolveAction(requestId: string, approved: boolean): Promise<void> {
+    const token = this.options.getToken();
+    if (!token) {
+      console.log('Error: No admin token available');
+      return;
+    }
+
+    try {
+      const response = await fetch(`${this.options.serverUrl}/actions/${requestId}/resolve`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${token}`
+        },
+        body: JSON.stringify({ approved })
+      });
+
+      const data = await response.json() as { success?: boolean; error?: string; agentId?: string; token?: string };
+
+      if (response.ok && data.success) {
+        if (approved) {
+          console.log(`✓ Request approved. Token created for ${data.agentId}`);
+        } else {
+          console.log(`✓ Request rejected`);
+        }
+        this.pendingRequests.delete(requestId);
+      } else {
+        console.log(`✗ Failed to ${approved ? 'approve' : 'reject'}: ${data.error || 'Unknown error'}`);
+      }
+    } catch (error) {
+      const message = getErrorMessage(error);
+      console.log(`✗ Error ${approved ? 'approving' : 'rejecting'} request: ${message}`);
+    }
+  }
+}

package/server/cli/commands/app.ts

@@ -0,0 +1,204 @@
+/**
+ * aurawallet app — Manage installed apps
+ *
+ * Usage:
+ *   npx aurawallet app install <source> [--name <id>] [--force]
+ *   npx aurawallet app remove <id> [--yes]
+ *   npx aurawallet app list
+ *   npx aurawallet app update <id>
+ */
+
+import {
+  installApp,
+  removeApp,
+  listApps,
+  updateApp,
+} from '../../lib/app-installer';
+import { promptConfirm } from '../lib/prompt';
+import { getErrorMessage } from '../../lib/error';
+
+const args = process.argv.slice(2);
+
+function getFlag(name: string): boolean {
+  return args.includes(`--${name}`);
+}
+
+function getFlagValue(name: string): string | undefined {
+  const idx = args.indexOf(`--${name}`);
+  if (idx === -1 || idx + 1 >= args.length) return undefined;
+  return args[idx + 1];
+}
+
+function showHelp() {
+  console.log(`
+  aurawallet app — Manage installed apps
+
+  Usage:
+    npx aurawallet app install <source> [--name <id>] [--force]
+    npx aurawallet app remove <id> [--yes]
+    npx aurawallet app list
+    npx aurawallet app update <id>
+
+  Sources:
+    Local path       ./path/to/app or /absolute/path
+    Git repo         github.com/user/repo
+    Tarball          https://example.com/app.tar.gz
+    Zip              https://example.com/app.zip
+    Subdirectory     github.com/user/repo#path=apps/my-app
+
+  Options:
+    --name <id>      Override the app folder name
+    --force          Overwrite existing app with same ID
+    --yes            Skip removal confirmation
+
+  Examples:
+    npx aurawallet app install github.com/user/my-app
+    npx aurawallet app install ./my-local-app --name custom-id
+    npx aurawallet app list
+    npx aurawallet app remove my-app
+    npx aurawallet app update my-app
+`);
+}
+
+async function main() {
+  const subcommand = args[0];
+
+  if (!subcommand || subcommand === '--help' || subcommand === '-h') {
+    showHelp();
+    process.exit(0);
+  }
+
+  switch (subcommand) {
+    case 'install': {
+      const source = args[1];
+      if (!source || source.startsWith('--')) {
+        console.error('  Error: Missing source argument\n');
+        console.error('  Usage: npx aurawallet app install <source> [--name <id>] [--force]');
+        process.exit(1);
+      }
+
+      const name = getFlagValue('name');
+      const force = getFlag('force');
+
+      console.log(`\n  Installing app from: ${source}`);
+      if (name) console.log(`  App ID: ${name}`);
+      if (force) console.log(`  Force: overwrite existing`);
+      console.log('');
+
+      try {
+        const result = installApp(source, { name, force });
+        console.log(`  ┌─────────────────────────────────────────┐`);
+        console.log(`  │ App installed successfully            │`);
+        console.log(`  ├─────────────────────────────────────────┤`);
+        console.log(`  │ ID:     ${result.id.padEnd(32)}│`);
+        console.log(`  │ Name:   ${result.name.padEnd(32)}│`);
+        console.log(`  │ Source: ${result.source.type.padEnd(32)}│`);
+        console.log(`  │ Path:   apps/${result.id.padEnd(23)}│`);
+        console.log(`  └─────────────────────────────────────────┘`);
+        console.log('');
+        console.log('  App will appear in the App Store under INSTALLED.');
+        console.log('  Restart the server or use the dashboard to load it.\n');
+      } catch (err) {
+        const msg = getErrorMessage(err);
+        console.error(`  Error: ${msg}\n`);
+        process.exit(1);
+      }
+      break;
+    }
+
+    case 'remove': {
+      const id = args[1];
+      if (!id || id.startsWith('--')) {
+        console.error('  Error: Missing app ID\n');
+        console.error('  Usage: npx aurawallet app remove <id> [--yes]');
+        process.exit(1);
+      }
+
+      const skipConfirm = getFlag('yes');
+
+      if (!skipConfirm) {
+        const confirmed = await promptConfirm(`  Remove app "${id}"?`);
+        if (!confirmed) {
+          console.log('  Cancelled.\n');
+          process.exit(0);
+        }
+      }
+
+      try {
+        removeApp(id);
+        console.log(`\n  App "${id}" removed.\n`);
+        console.log('  Note: App token will be revoked on next server restart.\n');
+      } catch (err) {
+        const msg = getErrorMessage(err);
+        console.error(`  Error: ${msg}\n`);
+        process.exit(1);
+      }
+      break;
+    }
+
+    case 'list': {
+      const apps = listApps();
+
+      if (apps.length === 0) {
+        console.log('\n  No apps installed.\n');
+        console.log('  Install a app:');
+        console.log('    npx aurawallet app install <source>\n');
+        process.exit(0);
+      }
+
+      console.log(`\n  Installed Apps (${apps.length})\n`);
+
+      for (const w of apps) {
+        const sourceLabel = w.source
+          ? `${w.source.type} — ${w.source.url}`
+          : 'local (no .source.json)';
+        const perms = w.permissions.length > 0
+          ? w.permissions.join(', ')
+          : 'none';
+
+        console.log(`  ┌ ${w.name} (${w.id})`);
+        console.log(`  │ ${w.description || '(no description)'}`);
+        console.log(`  │ Permissions: ${perms}`);
+        console.log(`  │ Source: ${sourceLabel}`);
+        if (w.source?.installedAt) {
+          console.log(`  │ Installed: ${w.source.installedAt}`);
+        }
+        console.log(`  └──`);
+        console.log('');
+      }
+      break;
+    }
+
+    case 'update': {
+      const id = args[1];
+      if (!id || id.startsWith('--')) {
+        console.error('  Error: Missing app ID\n');
+        console.error('  Usage: npx aurawallet app update <id>');
+        process.exit(1);
+      }
+
+      console.log(`\n  Updating app "${id}"...\n`);
+
+      try {
+        const result = updateApp(id);
+        console.log(`  App "${result.id}" updated from ${result.source.type} source.`);
+        console.log(`  Restart the server to load changes.\n`);
+      } catch (err) {
+        const msg = getErrorMessage(err);
+        console.error(`  Error: ${msg}\n`);
+        process.exit(1);
+      }
+      break;
+    }
+
+    default:
+      console.error(`  Unknown subcommand: ${subcommand}\n`);
+      showHelp();
+      process.exit(1);
+  }
+}
+
+main().catch((error) => {
+  console.error('Error:', getErrorMessage(error));
+  process.exit(1);
+});

package/server/cli/commands/cron.ts

@@ -0,0 +1,24 @@
+/**
+ * aurawallet cron — Run the cron server standalone
+ * Useful for development or running cron separately from the main server.
+ */
+
+import { findProjectRoot } from '../lib/process';
+import { execFileSync } from 'child_process';
+import path from 'path';
+
+const root = findProjectRoot();
+const cronEntry = path.join(root, 'server', 'cron', 'index.ts');
+
+console.log('Starting AuraWallet Cron Server...\n');
+
+try {
+  execFileSync('npx', ['tsx', cronEntry], {
+    cwd: root,
+    stdio: 'inherit',
+    env: process.env,
+  });
+} catch (error: unknown) {
+  const exitCode = (error as { status?: number }).status || 1;
+  process.exit(exitCode);
+}