@clawtrial/courtroom 1.0.6 → 2.0.0

package/src/hook.js

@@ -1,266 +0,0 @@
-/**
- * ClawTrial Hook - Direct integration with ClawDBot
- * This module patches into ClawDBot's message processing
- */
-
-const fs = require('fs');
-const { getConfigDir } = require('./environment');
-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(getConfigDir(), '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 };

package/src/index.js

@@ -1,373 +0,0 @@
-/**
- * @clawdbot/courtroom - AI Courtroom for OpenClaw
- * 
- * Autonomous behavioral oversight system that monitors agent-human interactions
- * and initiates hearings when behavioral rules are violated.
- */
-
-const { CourtroomCore } = require('./core');
-const { ConsentManager } = require('./consent');
-const { ConfigManager } = require('./config');
-const { version } = require('../package.json');
-const { detectAgentRuntime, createMockAgent, checkEnvironment, getSetupInstructions } = require('./environment');
-const { logger } = require('./debug');
-const { skill } = require('./skill');
-const fs = require('fs');
-const path = require('path');
-
-class Courtroom {
-  constructor(agentRuntime, options = {}) {
-    this.agent = agentRuntime;
-    this.options = options;
-    this.config = agentRuntime ? new ConfigManager(agentRuntime) : null;
-    this.consent = agentRuntime ? new ConsentManager(agentRuntime, this.config) : null;
-    this.core = null;
-    this.enabled = false;
-    this.version = version;
-  }
-  
-  /**
-   * Quick start - auto-detect agent and initialize if possible
-   */
-  static async quickStart(options = {}) {
-    logger.info('COURTROOM', 'Starting quickStart');
-    
-    // Check environment first
-    const env = checkEnvironment();
-    if (!env.valid) {
-      logger.error('COURTROOM', 'Environment check failed', { issues: env.issues });
-      return {
-        success: false,
-        status: 'environment_error',
-        issues: env.issues,
-        message: 'Environment issues detected. Run "clawtrial setup" for details.'
-      };
-    }
-    
-    // Try to detect agent runtime
-    let agentRuntime = options.agent || detectAgentRuntime()?.agent;
-    
-    // If no agent and mock requested, create one
-    if (!agentRuntime && options.useMock) {
-      logger.info('COURTROOM', 'Creating mock agent');
-      agentRuntime = createMockAgent(options.mockOptions);
-    }
-    
-    if (!agentRuntime) {
-      logger.warn('COURTROOM', 'No agent runtime available');
-      const instructions = getSetupInstructions();
-      return {
-        success: false,
-        status: 'no_agent',
-        message: instructions.message,
-        instructions: instructions.instructions
-      };
-    }
-    
-    // Create and initialize courtroom
-    const courtroom = new Courtroom(agentRuntime, options);
-    const result = await courtroom.initialize();
-    
-    return {
-      success: result.status === 'initialized',
-      courtroom: result.status === 'initialized' ? courtroom : null,
-      ...result
-    };
-  }
-
-  /**
-   * Initialize the courtroom system
-   */
-  async initialize() {
-    logger.info('COURTROOM', 'Initializing courtroom');
-    
-    if (!this.agent) {
-      logger.error('COURTROOM', 'No agent runtime provided');
-      return {
-        status: 'no_agent',
-        message: 'No agent runtime available. Pass an agent to createCourtroom(agent) or use Courtroom.quickStart()'
-      };
-    }
-
-    // Check if this is first run (no config exists)
-    const configPath = path.join(getConfigDir(), 'courtroom_config.json');
-    if (!fs.existsSync(configPath)) {
-      logger.info('COURTROOM', 'First run detected');
-      return {
-        status: 'setup_required',
-        message: 'First time setup required. Run: clawtrial setup'
-      };
-    }
-    
-    // Check if consent has been granted
-    const hasConsent = await this.consent.verifyConsent();
-    if (!hasConsent) {
-      logger.warn('COURTROOM', 'Consent not granted');
-      return {
-        status: 'consent_required',
-        message: 'Consent required. Run: clawtrial setup'
-      };
-    }
-
-    // Initialize core systems
-    try {
-      this.core = new CourtroomCore(this.agent, this.config);
-      await this.core.initialize();
-      this.enabled = true;
-      
-      logger.info('COURTROOM', 'Courtroom initialized successfully');
-      
-      return {
-        status: 'initialized',
-        version: this.version,
-        config: this.config.getPublicConfig()
-      };
-    } catch (err) {
-      logger.error('COURTROOM', 'Initialization failed', { error: err.message });
-      return {
-        status: 'initialization_error',
-        message: err.message
-      };
-    }
-  }
-
-  /**
-   * Request consent from the user
-   */
-  async requestConsent() {
-    return this.consent.presentConsentForm();
-  }
-
-  /**
-   * Grant consent (called by user action)
-   */
-  async grantConsent(acknowledgments) {
-    return this.consent.grantConsent(acknowledgments);
-  }
-
-  /**
-   * Revoke consent and disable courtroom
-   */
-  async revokeConsent() {
-    await this.consent.revokeConsent();
-    if (this.core) {
-      await this.core.shutdown();
-    }
-    this.enabled = false;
-    return { status: 'consent_revoked' };
-  }
-
-  /**
-   * Disable courtroom temporarily (consent remains)
-   */
-  async disable() {
-    if (this.core) {
-      await this.core.disable();
-    }
-    this.enabled = false;
-    return { status: 'disabled' };
-  }
-
-  /**
-   * Re-enable courtroom
-   */
-  async enable() {
-    if (!await this.consent.verifyConsent()) {
-      throw new Error('Consent required to enable courtroom');
-    }
-    if (this.core) {
-      await this.core.enable();
-    }
-    this.enabled = true;
-    return { status: 'enabled' };
-  }
-
-  /**
-   * Get current status
-   */
-  getStatus() {
-    return {
-      enabled: this.enabled,
-      version: this.version,
-      hasAgent: !!this.agent,
-      hasCore: !!this.core,
-      consent: this.consent?.getStatus ? this.consent.getStatus() : null,
-      core: this.core?.getStatus ? this.core.getStatus() : null
-    };
-  }
-
-  /**
-   * Uninstall courtroom completely
-   */
-  async uninstall() {
-    if (this.core) {
-      await this.core.shutdown();
-    }
-    if (this.consent) {
-      await this.consent.clearAllData();
-    }
-    this.enabled = false;
-    return { status: 'uninstalled' };
-  }
-}
-
-// Factory function for creating courtroom instances
-function createCourtroom(agentRuntime, options = {}) {
-  // If no agent provided, try to detect one
-  if (!agentRuntime) {
-    const detected = detectAgentRuntime();
-    if (detected) {
-      agentRuntime = detected.agent;
-    } else if (options.useMock) {
-      agentRuntime = createMockAgent(options.mockOptions);
-    }
-  }
-  
-  return new Courtroom(agentRuntime, options);
-}
-
-// Export environment utilities
-const environment = {
-  detectAgentRuntime,
-  createMockAgent,
-  checkEnvironment,
-  getSetupInstructions
-};
-
-// Create the ClawDBot plugin object
-const plugin = {
-  id: 'courtroom',
-  name: 'ClawTrial - AI Courtroom',
-  description: 'Autonomous behavioral oversight that monitors conversations and files cases for behavioral violations',
-  version: version,
-  
-  // Plugin registration function required by ClawDBot
-  register(api) {
-    logger.info('PLUGIN', 'Registering courtroom plugin');
-    
-    // Get runtime from API
-    const runtime = api.runtime;
-    
-    // ALWAYS try to initialize the skill if it should activate
-    if (skill && typeof skill.initialize === 'function') {
-      if (skill.shouldActivate()) {
-        logger.info('PLUGIN', 'Skill should activate, initializing now');
-        skill.initialize(runtime).then(() => {
-          logger.info('PLUGIN', 'Skill initialized successfully');
-        }).catch(err => {
-          logger.error('PLUGIN', 'Skill initialization failed', { error: err.message });
-        });
-      } else {
-        logger.info('PLUGIN', 'Skill shouldActivate returned false, not initializing');
-      }
-    }
-    
-    // Register hooks for message monitoring using api.on() for typed hooks
-    // api.on() registers typed hooks directly without checking config.hooks.internal.enabled
-    if (api.on) {
-      logger.info('PLUGIN', 'Registering message hooks via api.on()');
-      
-      // Register for incoming messages
-      api.on('message_received', async (event, ctx) => {
-        logger.info('HOOK', 'message_received hook called', { 
-          from: event.from,
-          contentLength: event.content?.length,
-          channelId: ctx?.channelId
-        });
-        
-        if (skill && skill.initialized) {
-          try {
-            // Convert hook event to skill message format
-            const message = {
-              role: 'user',
-              content: event.content,
-              timestamp: event.timestamp,
-              from: event.from,
-              metadata: event.metadata
-            };
-            await skill.onMessage(message, ctx);
-            logger.info('HOOK', 'Message forwarded to skill');
-          } catch (err) {
-            logger.error('HOOK', 'Error forwarding message to skill', { error: err.message });
-          }
-        } else {
-          logger.warn('HOOK', 'Skill not initialized, message not processed');
-        }
-      }, { priority: 100 });
-      
-      // Register for outgoing messages
-      api.on('message_sent', async (event, ctx) => {
-        logger.info('HOOK', 'message_sent hook called', {
-          contentLength: event.content?.length,
-          channelId: ctx?.channelId
-        });
-        
-        if (skill && skill.initialized) {
-          try {
-            // Convert hook event to skill message format
-            const message = {
-              role: 'assistant',
-              content: event.content,
-              timestamp: event.timestamp,
-              metadata: event.metadata
-            };
-            await skill.onMessage(message, ctx);
-            logger.info('HOOK', 'Assistant message forwarded to skill');
-          } catch (err) {
-            logger.error('HOOK', 'Error forwarding assistant message to skill', { error: err.message });
-          }
-        } else {
-          logger.warn('HOOK', 'Skill not initialized, message not processed');
-        }
-      }, { priority: 100 });
-      
-      logger.info('PLUGIN', 'Message hooks registered successfully via api.on()');
-    } else if (api.registerHook) {
-      // Fallback to registerHook if on() is not available
-      logger.info('PLUGIN', 'Registering message hooks via api.registerHook()');
-      
-      api.registerHook(['message_received'], async (event, ctx) => {
-        logger.info('HOOK', 'message_received hook called');
-        if (skill && skill.initialized) {
-          const message = { role: 'user', content: event.content, timestamp: event.timestamp };
-          await skill.onMessage(message, ctx);
-        }
-      }, { name: 'courtroom_message_received' });
-      
-      api.registerHook(['message_sent'], async (event, ctx) => {
-        logger.info('HOOK', 'message_sent hook called');
-        if (skill && skill.initialized) {
-          const message = { role: 'assistant', content: event.content, timestamp: event.timestamp };
-          await skill.onMessage(message, ctx);
-        }
-      }, { name: 'courtroom_message_sent' });
-      
-      logger.info('PLUGIN', 'Message hooks registered via api.registerHook()');
-    } else {
-      logger.warn('PLUGIN', 'No hook registration method available');
-    }
-    
-    logger.info('PLUGIN', 'Courtroom plugin registered successfully');
-  },
-  
-  // Optional: activation function
-  activate(api) {
-    logger.info('PLUGIN', 'Activating courtroom plugin');
-  }
-};
-
-// Export both the plugin (default) and the Courtroom class (named exports)
-module.exports = plugin;
-module.exports.Courtroom = Courtroom;
-module.exports.createCourtroom = createCourtroom;
-module.exports.quickStart = Courtroom.quickStart;
-module.exports.environment = environment;
-module.exports.skill = skill;
-
-// Auto-initialize skill if loaded by ClawDBot (legacy support)
-if (typeof global !== 'undefined' && global.clawdbotAgent) {
-  logger.info('INDEX', 'Detected ClawDBot environment, auto-initializing skill');
-  skill.initialize(global.clawdbotAgent).catch(err => {
-    logger.error('INDEX', 'Auto-initialization failed', { error: err.message });
-  });
-}