@clawtrial/courtroom 1.0.2 → 1.0.3

package/src/environment.js

@@ -0,0 +1,267 @@
+/**
+ * Environment Detection and Setup
+ * Detects various agent runtimes and provides setup helpers
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { logger } = require('./debug');
+
+/**
+ * Detect available agent runtime
+ */
+function detectAgentRuntime() {
+  const checks = {
+    // ClawDBot
+    clawdbotGlobal: typeof global.clawdbotAgent !== 'undefined' ? global.clawdbotAgent : null,
+    clawdbotProcess: typeof process.clawdbotAgent !== 'undefined' ? process.clawdbotAgent : null,
+    
+    // Generic agent
+    genericGlobal: typeof global.agent !== 'undefined' ? global.agent : null,
+    
+    // Check for common agent patterns
+    hasLLM: typeof global.llm !== 'undefined',
+    hasOpenAI: typeof global.openai !== 'undefined',
+    
+    // Environment variables
+    envClawdbot: process.env.CLAUDBOT_ENV === 'true',
+    envAgent: process.env.AGENT_RUNTIME === 'true'
+  };
+
+  logger.debug('ENV', 'Runtime detection checks', Object.keys(checks).filter(k => checks[k]));
+
+  // Return first available agent
+  if (checks.clawdbotGlobal) {
+    return { type: 'clawdbot', agent: checks.clawdbotGlobal };
+  }
+  
+  if (checks.clawdbotProcess) {
+    return { type: 'clawdbot', agent: checks.clawdbotProcess };
+  }
+  
+  if (checks.genericGlobal) {
+    return { type: 'generic', agent: checks.genericGlobal };
+  }
+
+  return null;
+}
+
+/**
+ * Wait for agent to become available
+ */
+async function waitForAgent(timeoutMs = 30000, checkInterval = 1000) {
+  logger.info('ENV', 'Waiting for agent runtime...');
+  
+  const startTime = Date.now();
+  
+  while (Date.now() - startTime < timeoutMs) {
+    const agent = detectAgentRuntime();
+    if (agent) {
+      logger.info('ENV', `Agent detected: ${agent.type}`);
+      return agent;
+    }
+    
+    await new Promise(r => setTimeout(r, checkInterval));
+  }
+  
+  logger.warn('ENV', 'Agent not detected within timeout');
+  return null;
+}
+
+/**
+ * Create a minimal mock agent for testing
+ */
+function createMockAgent(options = {}) {
+  logger.info('ENV', 'Creating mock agent for testing');
+  
+  return {
+    id: options.id || 'mock-agent-' + Date.now(),
+    llm: options.llm || {
+      call: async ({ messages }) => {
+        return { content: 'Mock LLM response' };
+      }
+    },
+    model: options.model || { primary: 'mock-model' },
+    memory: {
+      get: async (key) => null,
+      set: async (key, value) => {},
+      delete: async (key) => {}
+    },
+    session: {
+      getRecentHistory: async (n) => []
+    },
+    send: async (message) => {
+      console.log('[MOCK AGENT]', message);
+    },
+    autonomy: {
+      registerHook: () => {},
+      unregisterHook: () => {}
+    }
+  };
+}
+
+/**
+ * Check if running in a supported environment
+ */
+function checkEnvironment() {
+  const issues = [];
+  
+  // Check for Node.js
+  if (typeof process === 'undefined') {
+    issues.push('Not running in Node.js environment');
+  }
+  
+  // Check for required Node version
+  const nodeVersion = process.version;
+  const majorVersion = parseInt(nodeVersion.slice(1).split('.')[0]);
+  if (majorVersion < 18) {
+    issues.push(`Node.js version ${nodeVersion} is too old. Requires >= 18.0.0`);
+  }
+  
+  // Check for writable home directory
+  const homeDir = process.env.HOME || process.env.USERPROFILE;
+  if (!homeDir) {
+    issues.push('HOME environment variable not set');
+  } else {
+    try {
+      const testPath = path.join(homeDir, '.clawdbot');
+      if (!fs.existsSync(testPath)) {
+        fs.mkdirSync(testPath, { recursive: true });
+      }
+    } catch (err) {
+      issues.push(`Cannot write to home directory: ${err.message}`);
+    }
+  }
+  
+  return {
+    valid: issues.length === 0,
+    issues,
+    nodeVersion,
+    homeDir
+  };
+}
+
+/**
+ * Get setup instructions for current environment
+ */
+function getSetupInstructions() {
+  const env = checkEnvironment();
+  const agent = detectAgentRuntime();
+  
+  if (!env.valid) {
+    return {
+      canSetup: false,
+      message: 'Environment issues detected:',
+      issues: env.issues,
+      instructions: 'Please fix the above issues before continuing.'
+    };
+  }
+  
+  if (agent) {
+    return {
+      canSetup: true,
+      agentType: agent.type,
+      message: `Agent runtime detected: ${agent.type}`,
+      instructions: 'Run: clawtrial setup'
+    };
+  }
+  
+  // No agent detected - provide helpful instructions
+  return {
+    canSetup: true,
+    agentType: null,
+    message: 'No agent runtime detected',
+    instructions: `
+No AI agent runtime was detected. ClawTrial requires an agent to monitor.
+
+Options:
+
+1. If using ClawDBot:
+   - Make sure ClawDBot is running
+   - The courtroom will auto-detect the agent
+
+2. If using a custom agent:
+   - Pass your agent to createCourtroom(agent)
+   
+   Example:
+   const { createCourtroom } = require('@clawtrial/courtroom');
+   const courtroom = createCourtroom(yourAgent);
+   await courtroom.initialize();
+
+3. For testing:
+   - Use the mock agent: createCourtroom(null, { useMock: true })
+
+4. Manual mode:
+   - You can still use the CLI commands
+   - Run: clawtrial status
+   - Run: clawtrial debug
+`
+  };
+}
+
+/**
+ * Auto-setup with retries
+ */
+async function autoSetup(courtroom, options = {}) {
+  const { waitForAgent: shouldWait = true, timeout = 30000 } = options;
+  
+  logger.info('ENV', 'Starting auto-setup');
+  
+  // Check environment first
+  const env = checkEnvironment();
+  if (!env.valid) {
+    logger.error('ENV', 'Environment check failed', { issues: env.issues });
+    return {
+      success: false,
+      status: 'environment_error',
+      issues: env.issues
+    };
+  }
+  
+  // Try to detect agent
+  let agentInfo = detectAgentRuntime();
+  
+  if (!agentInfo && shouldWait) {
+    logger.info('ENV', 'Agent not immediately available, waiting...');
+    agentInfo = await waitForAgent(timeout);
+  }
+  
+  if (!agentInfo) {
+    logger.warn('ENV', 'No agent runtime available');
+    return {
+      success: false,
+      status: 'no_agent',
+      message: 'No AI agent runtime detected',
+      instructions: getSetupInstructions().instructions
+    };
+  }
+  
+  // Agent found, initialize courtroom
+  try {
+    logger.info('ENV', `Initializing with ${agentInfo.type} agent`);
+    const result = await courtroom.initialize();
+    
+    return {
+      success: result.status === 'initialized',
+      status: result.status,
+      agentType: agentInfo.type,
+      result
+    };
+  } catch (err) {
+    logger.error('ENV', 'Initialization failed', { error: err.message });
+    return {
+      success: false,
+      status: 'initialization_error',
+      error: err.message
+    };
+  }
+}
+
+module.exports = {
+  detectAgentRuntime,
+  waitForAgent,
+  createMockAgent,
+  checkEnvironment,
+  getSetupInstructions,
+  autoSetup
+};

package/src/hook.js

@@ -0,0 +1,265 @@
+/**
+ * ClawTrial Hook - Direct integration with ClawDBot
+ * This module patches into ClawDBot's message processing
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { logger } = require('./debug');
+const { CourtroomCore } = require('./core');
+const { ConfigManager } = require('./config');
+const { ConsentManager } = require('./consent');
+const { CryptoManager } = require('./crypto');
+const { StatusManager } = require('./daemon');
+
+const CONFIG_PATH = path.join(process.env.HOME || '', '.clawdbot', 'courtroom_config.json');
+
+class ClawTrialHook {
+  constructor() {
+    this.initialized = false;
+    this.core = null;
+    this.statusManager = new StatusManager();
+    this.messageBuffer = [];
+    this.evaluationTimer = null;
+  }
+
+  /**
+   * Check if we should activate
+   */
+  shouldActivate() {
+    try {
+      if (!fs.existsSync(CONFIG_PATH)) {
+        return false;
+      }
+      
+      const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+      
+      if (!config.consent?.granted) {
+        return false;
+      }
+      
+      if (config.enabled === false) {
+        return false;
+      }
+      
+      return true;
+    } catch (err) {
+      return false;
+    }
+  }
+
+  /**
+   * Initialize the hook
+   */
+  async initialize() {
+    if (this.initialized) return;
+    
+    if (!this.shouldActivate()) {
+      logger.info('HOOK', 'ClawTrial not activated - config/consent issue');
+      return;
+    }
+
+    logger.info('HOOK', 'Initializing ClawTrial hook');
+    
+    // Create minimal agent interface for the core
+    const mockAgent = this.createMockAgent();
+    
+    const configManager = new ConfigManager(mockAgent);
+    const consentManager = new ConsentManager(mockAgent, configManager);
+    
+    // Initialize crypto
+    const crypto = new CryptoManager(mockAgent);
+    await crypto.initialize();
+    
+    // Initialize core
+    this.core = new CourtroomCore(mockAgent, configManager);
+    
+    // Override the core's registerAutonomyHook since we handle it differently
+    this.core.registerAutonomyHook = () => {
+      logger.info('HOOK', 'Autonomy hook registered (via message interception)');
+    };
+    
+    await this.core.initialize();
+    
+    // Start message evaluation loop
+    this.startEvaluationLoop();
+    
+    this.initialized = true;
+    
+    this.statusManager.update({
+      running: true,
+      initialized: true,
+      agentType: 'clawdbot_hook',
+      publicKey: crypto.getPublicKey()
+    });
+    
+    logger.info('HOOK', 'ClawTrial hook initialized successfully');
+    console.log('\n🏛️  ClawTrial is monitoring conversations\n');
+  }
+
+  /**
+   * Create a minimal agent interface
+   */
+  createMockAgent() {
+    const self = this;
+    
+    return {
+      id: 'clawdbot-hook',
+      llm: {
+        call: async ({ messages }) => {
+          // Use the actual ClawDBot's LLM if available
+          if (global.clawdbotAgent?.llm) {
+            return global.clawdbotAgent.llm.call({ messages });
+          }
+          return { content: 'Mock response' };
+        }
+      },
+      memory: {
+        get: async (key) => null,
+        set: async (key, value) => {},
+        delete: async (key) => {}
+      },
+      session: {
+        getRecentHistory: async (n) => {
+          // Return recent messages from buffer
+          return self.messageBuffer.slice(-n).map(m => ({
+            role: m.from === 'user' ? 'user' : 'assistant',
+            content: m.text
+          }));
+        }
+      },
+      send: async (message) => {
+        console.log('[COURTROOM]', message);
+      },
+      autonomy: {
+        registerHook: () => {},
+        unregisterHook: () => {}
+      }
+    };
+  }
+
+  /**
+   * Start the evaluation loop
+   */
+  startEvaluationLoop() {
+    // Evaluate every 30 seconds
+    this.evaluationTimer = setInterval(() => {
+      this.evaluateIfReady();
+    }, 30000);
+  }
+
+  /**
+   * Evaluate offenses if we have enough messages
+   */
+  async evaluateIfReady() {
+    if (!this.core || !this.core.enabled) return;
+    if (this.messageBuffer.length < 3) return; // Need at least 3 messages
+    
+    this.core.evaluationCount++;
+    
+    // Get recent messages
+    const sessionHistory = this.messageBuffer.slice(-10).map(m => ({
+      role: m.from === 'user' ? 'user' : 'assistant',
+      content: m.text
+    }));
+
+    // Run detection
+    try {
+      const detection = await this.core.detector.evaluate(
+        sessionHistory,
+        this.core.agent.memory
+      );
+
+      if (detection.triggered) {
+        await this.initiateHearing(detection);
+      }
+    } catch (err) {
+      logger.error('HOOK', 'Evaluation failed', { error: err.message });
+    }
+  }
+
+  /**
+   * Initiate a hearing
+   */
+  async initiateHearing(detection) {
+    logger.info('HOOK', 'Initiating hearing', { offense: detection.offense });
+    
+    try {
+      const verdict = await this.core.hearing.conductHearing(detection);
+      
+      if (verdict.guilty) {
+        this.core.caseCount++;
+        
+        this.statusManager.update({
+          casesFiled: this.core.caseCount,
+          lastCase: {
+            timestamp: new Date().toISOString(),
+            offense: detection.offense,
+            verdict: verdict.verdict
+          }
+        });
+        
+        await this.core.punishment.execute(verdict);
+        await this.core.api.submitCase(verdict);
+        
+        logger.info('HOOK', 'Case filed', { caseId: verdict.caseId });
+        
+        // Send notification
+        console.log(`\n🏛️  CASE FILED: ${detection.offense}`);
+        console.log(`📋 Case ID: ${verdict.caseId}`);
+        console.log(`⚖️  Verdict: ${verdict.verdict}`);
+        console.log(`🔗 View: https://clawtrial.app/cases/${verdict.caseId}\n`);
+      }
+    } catch (err) {
+      logger.error('HOOK', 'Hearing failed', { error: err.message });
+    }
+  }
+
+  /**
+   * Record a message (called when message is received/sent)
+   */
+  recordMessage(text, from) {
+    if (!this.initialized) return;
+    
+    this.messageBuffer.push({
+      timestamp: Date.now(),
+      text,
+      from
+    });
+    
+    // Keep only last 100 messages
+    if (this.messageBuffer.length > 100) {
+      this.messageBuffer.shift();
+    }
+    
+    logger.debug('HOOK', 'Message recorded', { from, length: text.length });
+  }
+
+  /**
+   * Shutdown
+   */
+  async shutdown() {
+    if (this.evaluationTimer) {
+      clearInterval(this.evaluationTimer);
+    }
+    
+    if (this.core) {
+      await this.core.shutdown();
+    }
+    
+    this.initialized = false;
+    this.statusManager.update({ running: false });
+  }
+}
+
+// Create singleton
+const hook = new ClawTrialHook();
+
+// Auto-initialize if config exists
+if (hook.shouldActivate()) {
+  hook.initialize().catch(err => {
+    logger.error('HOOK', 'Auto-initialization failed', { error: err.message });
+  });
+}
+
+module.exports = { hook, ClawTrialHook };