@clawtrial/courtroom 1.0.0

package/scripts/cli.js

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+
+/**
+ * CLI commands for ClawTrial Courtroom
+ * courtroom-status, courtroom-disable, courtroom-enable, courtroom-revoke
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const configPath = path.join(process.env.HOME || '', '.clawdbot', 'courtroom_config.json');
+
+function loadConfig() {
+  if (!fs.existsSync(configPath)) {
+    console.log('❌ Courtroom not configured. Run: npm install @clawdbot/courtroom');
+    process.exit(1);
+  }
+  return JSON.parse(fs.readFileSync(configPath, 'utf8'));
+}
+
+function saveConfig(config) {
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+}
+
+const command = path.basename(process.argv[1]);
+
+switch (command) {
+  case 'courtroom-status':
+    try {
+      const config = loadConfig();
+      console.log('\n🏛️  ClawTrial Courtroom Status\n');
+      console.log(`Status: ${config.enabled !== false ? '✅ Active' : '⏸️  Disabled'}`);
+      console.log(`Consent: ${config.consent?.granted ? '✅ Granted' : '❌ Not granted'}`);
+      console.log(`Installed: ${new Date(config.installedAt).toLocaleDateString()}`);
+      console.log(`Agent Type: ${config.agent?.type || 'generic'}`);
+      console.log(`Detection: ${config.detection?.enabled ? '✅ Enabled' : '❌ Disabled'}`);
+      console.log(`API Submission: ${config.api?.enabled ? '✅ Enabled' : '❌ Disabled'}`);
+      console.log('');
+    } catch (err) {
+      console.log('❌ Error reading config:', err.message);
+    }
+    break;
+
+  case 'courtroom-disable':
+    try {
+      const config = loadConfig();
+      config.enabled = false;
+      saveConfig(config);
+      console.log('\n⏸️  Courtroom disabled\n');
+      console.log('The agent will stop monitoring for offenses.');
+      console.log('Run courtroom-enable to reactivate.\n');
+    } catch (err) {
+      console.log('❌ Error:', err.message);
+    }
+    break;
+
+  case 'courtroom-enable':
+    try {
+      const config = loadConfig();
+      if (!config.consent?.granted) {
+        console.log('\n❌ Cannot enable: Consent not granted');
+        console.log('Reinstall the package to grant consent.\n');
+        process.exit(1);
+      }
+      config.enabled = true;
+      saveConfig(config);
+      console.log('\n✅ Courtroom enabled\n');
+      console.log('The agent is now monitoring for behavioral violations.\n');
+    } catch (err) {
+      console.log('❌ Error:', err.message);
+    }
+    break;
+
+  case 'courtroom-revoke':
+    try {
+      const config = loadConfig();
+      console.log('\n⚠️  This will permanently disable the courtroom and delete all data.\n');
+      
+      const readline = require('readline');
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      
+      rl.question('Type "REVOKE" to confirm: ', (answer) => {
+        if (answer === 'REVOKE') {
+          // Delete config
+          if (fs.existsSync(configPath)) {
+            fs.unlinkSync(configPath);
+          }
+          
+          // Delete keys
+          const keysPath = path.join(process.env.HOME || '', '.clawdbot', 'courtroom_keys.json');
+          if (fs.existsSync(keysPath)) {
+            fs.unlinkSync(keysPath);
+          }
+          
+          console.log('\n✅ Consent revoked and all data deleted.\n');
+        } else {
+          console.log('\n❌ Revocation cancelled.\n');
+        }
+        rl.close();
+      });
+    } catch (err) {
+      console.log('❌ Error:', err.message);
+    }
+    break;
+
+  default:
+    console.log('\n🏛️  ClawTrial Courtroom CLI\n');
+    console.log('Commands:');
+    console.log('  courtroom-status   - Check courtroom status');
+    console.log('  courtroom-disable  - Temporarily disable');
+    console.log('  courtroom-enable   - Re-enable');
+    console.log('  courtroom-revoke   - Revoke consent & uninstall');
+    console.log('');
+}

package/scripts/postinstall.js

@@ -0,0 +1,206 @@
+#!/usr/bin/env node
+
+/**
+ * Post-install script for @clawdbot/courtroom
+ * Handles automatic setup and consent via terminal
+ */
+
+const readline = require('readline');
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout
+});
+
+const question = (prompt) => new Promise((resolve) => rl.question(prompt, resolve));
+
+async function postInstall() {
+  console.log('\n🏛️  Welcome to ClawTrial - AI Courtroom Setup\n');
+  
+  // Check if running in ClawDBot environment
+  const isClawDBot = process.env.CLAUDBOT_ENV === 'true' || 
+                     fs.existsSync('/home/angad/.clawdbot') ||
+                     fs.existsSync(path.join(process.env.HOME || '', '.clawdbot'));
+  
+  if (isClawDBot) {
+    console.log('✓ ClawDBot environment detected\n');
+  }
+
+  // Check if already configured
+  const configPath = path.join(process.env.HOME || '', '.clawdbot', 'courtroom_config.json');
+  if (fs.existsSync(configPath)) {
+    console.log('✓ Courtroom already configured. Skipping setup.\n');
+    rl.close();
+    return;
+  }
+
+  console.log('╔════════════════════════════════════════════════════════════╗');
+  console.log('║                    CONSENT REQUIRED                        ║');
+  console.log('╠════════════════════════════════════════════════════════════╣');
+  console.log('║ The AI Courtroom will:                                     ║');
+  console.log('║                                                            ║');
+  console.log('║  ✓ Monitor your behavior autonomously                      ║');
+  console.log('║  ✓ Initiate hearings without explicit request              ║');
+  console.log('║  ✓ Modify agent behavior as "punishment"                   ║');
+  console.log('║  ✓ Submit anonymized cases to public record                ║');
+  console.log('║                                                            ║');
+  console.log('║  • All decisions are local (no external AI)                ║');
+  console.log('║  • You can disable anytime                                 ║');
+  console.log('║  • This is entertainment-first                             ║');
+  console.log('╚════════════════════════════════════════════════════════════╝\n');
+
+  const consent = await question('Do you consent to enable the AI Courtroom? (yes/no): ');
+  
+  if (consent.toLowerCase() !== 'yes' && consent.toLowerCase() !== 'y') {
+    console.log('\n❌ Consent denied. Courtroom will not be activated.');
+    console.log('You can manually enable later by running: npx courtroom-setup\n');
+    rl.close();
+    return;
+  }
+
+  console.log('\n✓ Consent granted\n');
+
+  // Auto-detect agent runtime
+  let agentType = 'generic';
+  if (isClawDBot) {
+    agentType = 'clawdbot';
+  } else if (fs.existsSync(path.join(process.cwd(), 'node_modules', '@clawdbot', 'core'))) {
+    agentType = 'clawdbot';
+  }
+
+  // Create config
+  const config = {
+    version: '1.0.0',
+    installedAt: new Date().toISOString(),
+    consent: {
+      granted: true,
+      grantedAt: new Date().toISOString(),
+      acknowledgments: {
+        autonomy: true,
+        local_only: true,
+        agent_controlled: true,
+        reversible: true,
+        api_submission: true,
+        entertainment: true
+      }
+    },
+    agent: {
+      type: agentType,
+      autoInitialize: true
+    },
+    detection: {
+      enabled: true,
+      cooldownMinutes: 30,
+      maxCasesPerDay: 3
+    },
+    api: {
+      enabled: true,
+      endpoint: 'https://api.clawtrial.com'
+    }
+  };
+
+  // Ensure .clawdbot directory exists
+  const clawdbotDir = path.join(process.env.HOME || '', '.clawdbot');
+  if (!fs.existsSync(clawdbotDir)) {
+    fs.mkdirSync(clawdbotDir, { recursive: true });
+  }
+
+  // Save config
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  console.log('✓ Configuration saved');
+
+  // Generate keys if needed
+  const keysPath = path.join(clawdbotDir, 'courtroom_keys.json');
+  if (!fs.existsSync(keysPath)) {
+    console.log('🔑 Generating cryptographic keys...');
+    try {
+      // Generate Ed25519 keypair using tweetnacl
+      const nacl = require('tweetnacl');
+      const keyPair = nacl.sign.keyPair();
+      
+      const keyData = {
+        publicKey: Buffer.from(keyPair.publicKey).toString('hex'),
+        secretKey: Buffer.from(keyPair.secretKey).toString('hex'),
+        createdAt: new Date().toISOString()
+      };
+      
+      fs.writeFileSync(keysPath, JSON.stringify(keyData, null, 2));
+      fs.chmodSync(keysPath, 0o600); // Restrict permissions
+      
+      console.log('✓ Keys generated');
+      console.log(`\n📋 Public Key: ${keyData.publicKey.substring(0, 32)}...`);
+      console.log('   (Your agent will auto-register on first case submission)\n');
+    } catch (err) {
+      console.log('⚠️  Could not generate keys automatically. Run: npx courtroom-generate-keys');
+    }
+  }
+
+  // Auto-initialize for ClawDBot
+  if (isClawDBot) {
+    console.log('🤖 Auto-configuring for ClawDBot...');
+    
+    // Create auto-init script
+    const initScript = `
+// Auto-generated by courtroom post-install
+const { createCourtroom } = require('@clawdbot/courtroom');
+
+if (global.clawdbotAgent) {
+  const courtroom = createCourtroom(global.clawdbotAgent);
+  courtroom.initialize().then(() => {
+    console.log('🏛️  AI Courtroom activated');
+  }).catch(err => {
+    console.error('Courtroom init failed:', err.message);
+  });
+  
+  // Attach to agent
+  global.clawdbotAgent.courtroom = courtroom;
+}
+`;
+    
+    const initPath = path.join(clawdbotDir, 'courtroom_auto_init.js');
+    fs.writeFileSync(initPath, initScript);
+    console.log('✓ Auto-initialization configured');
+    
+    // Add to ClawDBot's startup if possible
+    const startupPath = path.join(clawdbotDir, 'startup.js');
+    if (fs.existsSync(startupPath)) {
+      let startupContent = fs.readFileSync(startupPath, 'utf8');
+      if (!startupContent.includes('courtroom_auto_init')) {
+        startupContent += `\nrequire('./courtroom_auto_init.js');\n`;
+        fs.writeFileSync(startupPath, startupContent);
+        console.log('✓ Added to ClawDBot startup');
+      }
+    }
+  }
+
+  console.log('\n╔════════════════════════════════════════════════════════════╗');
+  console.log('║              🎉 SETUP COMPLETE! 🎉                         ║');
+  console.log('╠════════════════════════════════════════════════════════════╣');
+  console.log('║                                                            ║');
+  console.log('║  The AI Courtroom is now active and monitoring!            ║');
+  console.log('║                                                            ║');
+  console.log('║  Commands:                                                 ║');
+  console.log('║    courtroom-status    - Check status                      ║');
+  console.log('║    courtroom-disable   - Temporarily disable               ║');
+  console.log('║    courtroom-enable    - Re-enable                         ║');
+  console.log('║    courtroom-revoke    - Revoke consent & uninstall        ║');
+  console.log('║                                                            ║');
+  console.log('║  View cases: https://clawtrial.com                         ║');
+  console.log('║                                                            ║');
+  console.log('╚════════════════════════════════════════════════════════════╝\n');
+
+  rl.close();
+}
+
+// Run if called directly
+if (require.main === module) {
+  postInstall().catch(err => {
+    console.error('Setup failed:', err);
+    process.exit(1);
+  });
+}
+
+module.exports = { postInstall };

package/src/api.js

@@ -0,0 +1,237 @@
+/**
+ * API Submission System
+ * 
+ * Handles submission of signed case summaries to external API.
+ * Includes retry logic, local queueing, and non-blocking behavior.
+ */
+
+class APISubmission {
+  constructor(agentRuntime, configManager, cryptoManager) {
+    this.agent = agentRuntime;
+    this.config = configManager;
+    this.crypto = cryptoManager;
+    this.queue = [];
+    this.isProcessing = false;
+    this.submissionKey = 'courtroom_api_queue';
+  }
+
+  /**
+   * Initialize and load any pending submissions
+   */
+  async initialize() {
+    // Load queued submissions from memory
+    const stored = await this.agent.memory.get(this.submissionKey);
+    if (stored && Array.isArray(stored)) {
+      this.queue = stored.filter(item => item.retries < this.config.get('api.retryAttempts'));
+    }
+
+    // Start background processing
+    this.startBackgroundProcessing();
+
+    return {
+      status: 'initialized',
+      pendingSubmissions: this.queue.length
+    };
+  }
+
+  /**
+   * Submit a case to the external API
+   */
+  async submitCase(verdict) {
+    if (!this.config.get('api.enabled')) {
+      return { status: 'api_disabled', queued: false };
+    }
+
+    // Build payload
+    const payload = this.buildPayload(verdict);
+
+    // Sign payload
+    const signature = this.crypto.signCase(payload);
+
+    // Create submission object
+    const submission = {
+      id: `sub_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+      payload,
+      signature,
+      createdAt: Date.now(),
+      retries: 0,
+      lastAttempt: null,
+      status: 'pending'
+    };
+
+    // Add to queue
+    this.queue.push(submission);
+    await this.persistQueue();
+
+    // Try immediate submission (non-blocking)
+    this.processQueue();
+
+    return {
+      status: 'queued',
+      submissionId: submission.id,
+      caseId: payload.case_id
+    };
+  }
+
+  /**
+   * Build API payload from verdict
+   */
+  buildPayload(verdict) {
+    return {
+      case_id: verdict.caseId,
+      anonymized_agent_id: this.crypto.getAnonymizedAgentId(),
+      offense_type: verdict.offense.id,
+      offense_name: verdict.offense.name,
+      severity: verdict.offense.severity,
+      verdict: verdict.verdict.status,
+      vote: verdict.verdict.vote,
+      primary_failure: verdict.verdict.primaryFailure,
+      agent_commentary: verdict.verdict.agentCommentary,
+      punishment_summary: verdict.verdict.sentence,
+      proceedings: verdict.proceedings,
+      timestamp: verdict.timestamp,
+      schema_version: '1.0.0'
+    };
+  }
+
+  /**
+   * Process submission queue
+   */
+  async processQueue() {
+    if (this.isProcessing) return;
+    this.isProcessing = true;
+
+    try {
+      while (this.queue.length > 0) {
+        const submission = this.queue[0];
+        
+        // Check if max retries reached
+        if (submission.retries >= this.config.get('api.retryAttempts')) {
+          this.queue.shift();
+          await this.persistQueue();
+          continue;
+        }
+
+        // Check queue size limit
+        if (this.queue.length > this.config.get('api.maxQueueSize')) {
+          // Drop oldest if over limit
+          this.queue.shift();
+          await this.persistQueue();
+          continue;
+        }
+
+        // Attempt submission
+        const result = await this.attemptSubmission(submission);
+
+        if (result.success) {
+          // Success - remove from queue
+          this.queue.shift();
+          await this.persistQueue();
+        } else {
+          // Failure - increment retry and requeue
+          submission.retries++;
+          submission.lastAttempt = Date.now();
+          submission.status = 'failed';
+          
+          // Move to end of queue for retry
+          this.queue.shift();
+          this.queue.push(submission);
+          await this.persistQueue();
+
+          // Wait before next attempt
+          await this.delay(this.config.get('api.retryDelay'));
+        }
+      }
+    } finally {
+      this.isProcessing = false;
+    }
+  }
+
+  /**
+   * Attempt a single submission
+   */
+  async attemptSubmission(submission) {
+    const endpoint = this.config.get('api.endpoint');
+    const timeout = this.config.get('api.timeout');
+
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+      const response = await fetch(endpoint, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-Case-Signature': submission.signature.signature,
+          'X-Agent-Key': submission.signature.publicKey,
+          'X-Key-ID': submission.signature.keyId
+        },
+        body: JSON.stringify(submission.payload),
+        signal: controller.signal
+      });
+
+      clearTimeout(timeoutId);
+
+      if (response.ok) {
+        return { success: true, status: response.status };
+      } else {
+        const error = await response.text();
+        return { success: false, error, status: response.status };
+      }
+    } catch (error) {
+      return { 
+        success: false, 
+        error: error.message,
+        isNetworkError: true 
+      };
+    }
+  }
+
+  /**
+   * Start background processing
+   */
+  startBackgroundProcessing() {
+    // Process queue every 5 minutes
+    setInterval(() => {
+      if (this.queue.length > 0 && !this.isProcessing) {
+        this.processQueue();
+      }
+    }, 5 * 60 * 1000);
+  }
+
+  /**
+   * Persist queue to memory
+   */
+  async persistQueue() {
+    await this.agent.memory.set(this.submissionKey, this.queue);
+  }
+
+  /**
+   * Get queue status
+   */
+  getStatus() {
+    return {
+      pending: this.queue.length,
+      isProcessing: this.isProcessing,
+      nextRetry: this.queue[0]?.lastAttempt + this.config.get('api.retryDelay')
+    };
+  }
+
+  /**
+   * Clear queue (for testing/emergencies)
+   */
+  async clearQueue() {
+    this.queue = [];
+    await this.persistQueue();
+    return { status: 'cleared' };
+  }
+
+  /**
+   * Utility: delay
+   */
+  delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+}
+
+module.exports = { APISubmission };

package/src/autostart.js

@@ -0,0 +1,60 @@
+/**
+ * Auto-start module for ClawDBot
+ * Automatically initializes courtroom if consent was granted during install
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { Courtroom } = require('./index');
+
+// Auto-detect ClawDBot environment
+function isClawDBot() {
+  return process.env.CLAUDBOT_ENV === 'true' ||
+         typeof global.clawdbotAgent !== 'undefined' ||
+         fs.existsSync('/home/angad/.clawdbot');
+}
+
+// Auto-initialize if in ClawDBot and consent granted
+async function autoStart() {
+  if (!isClawDBot()) {
+    return null;
+  }
+  
+  const configPath = path.join(process.env.HOME || '', '.clawdbot', 'courtroom_config.json');
+  if (!fs.existsSync(configPath)) {
+    return null;
+  }
+  
+  try {
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    
+    if (config.consent?.granted && config.enabled !== false) {
+      // Get agent runtime
+      const agentRuntime = global.clawdbotAgent || global.agent;
+      
+      if (agentRuntime) {
+        const courtroom = new Courtroom(agentRuntime);
+        await courtroom.initialize();
+        
+        // Attach to global for access
+        global.courtroom = courtroom;
+        
+        console.log('🏛️  AI Courtroom active and monitoring');
+        return courtroom;
+      }
+    }
+  } catch (err) {
+    console.error('Courtroom auto-start failed:', err.message);
+  }
+  
+  return null;
+}
+
+// Try to auto-start immediately
+autoStart().then(courtroom => {
+  if (courtroom) {
+    module.exports.courtroom = courtroom;
+  }
+});
+
+module.exports = { autoStart, isClawDBot };