@clawtrial/courtroom 1.0.2 → 1.0.3

package/src/index.js

@@ -1,5 +1,5 @@
 /**
- * @clawdbot/courtroom - AI Courtroom for OpenClaw
+ * @clawtrial/courtroom - AI Courtroom for OpenClaw
  * 
  * Autonomous behavioral oversight system that monitors agent-human interactions
  * and initiates hearings when behavioral rules are violated.
@@ -9,6 +9,9 @@ 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');
 
@@ -16,86 +19,120 @@ class Courtroom {
   constructor(agentRuntime, options = {}) {
     this.agent = agentRuntime;
     this.options = options;
-    this.config = new ConfigManager(agentRuntime);
-    this.consent = new ConsentManager(agentRuntime, this.config);
+    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-initialize if consent already granted
+   * Quick start - auto-detect agent and initialize if possible
    */
-  static async quickStart(agentRuntime, options = {}) {
-    const courtroom = new Courtroom(agentRuntime, options);
+  static async quickStart(options = {}) {
+    logger.info('COURTROOM', 'Starting quickStart');
     
-    // Check for existing config with consent
-    const configPath = path.join(process.env.HOME || '', '.clawdbot', 'courtroom_config.json');
-    if (fs.existsSync(configPath)) {
-      const savedConfig = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-      
-      if (savedConfig.consent?.granted && savedConfig.enabled !== false) {
-        // Auto-initialize!
-        await courtroom.initialize();
-        console.log('🏛️  AI Courtroom auto-initialized');
-        return courtroom;
-      }
+    // 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);
     }
     
-    // No config or not consented - return uninitialized
-    return courtroom;
+    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
-   * Must be called after construction
    */
   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(process.env.HOME || '', '.clawdbot', 'courtroom_config.json');
     if (!fs.existsSync(configPath)) {
-      console.log('\n🏛️  Welcome to ClawTrial - AI Courtroom Setup\n');
-      console.log('This appears to be your first time. Running setup...\n');
-      
-      // Run setup
-      const { postInstall } = require('../scripts/postinstall.js');
-      await postInstall();
-      
-      // After setup, check consent again
-      const hasConsent = await this.consent.verifyConsent();
-      if (!hasConsent) {
-        return {
-          status: 'setup_complete_consent_required',
-          message: 'Setup complete! Run courtroom.grantConsent() to enable'
-        };
-      }
+      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: 'Courtroom requires explicit user consent. Run courtroom.requestConsent()'
+        message: 'Consent required. Run: clawtrial setup'
       };
     }
 
     // Initialize core systems
-    this.core = new CourtroomCore(this.agent, this.config);
-    await this.core.initialize();
-    
-    this.enabled = true;
-    
-    return {
-      status: 'initialized',
-      version: this.version,
-      config: this.config.getPublicConfig()
-    };
+    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
-   * Returns a consent form that must be explicitly accepted
    */
   async requestConsent() {
     return this.consent.presentConsentForm();
@@ -152,8 +189,10 @@ class Courtroom {
     return {
       enabled: this.enabled,
       version: this.version,
-      consent: this.consent?.getStatus(),
-      core: this.core?.getStatus()
+      hasAgent: !!this.agent,
+      hasCore: !!this.core,
+      consent: this.consent?.getStatus ? this.consent.getStatus() : null,
+      core: this.core?.getStatus ? this.core.getStatus() : null
     };
   }
 
@@ -164,21 +203,84 @@ class Courtroom {
     if (this.core) {
       await this.core.shutdown();
     }
-    await this.consent.clearAllData();
+    if (this.consent) {
+      await this.consent.clearAllData();
+    }
+    this.enabled = false;
     return { status: 'uninstalled' };
   }
 }
 
-// Factory function for OpenClaw integration
-function createCourtroom(agentRuntime, options) {
+// 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);
 }
 
-// Trigger auto-start if in ClawDBot environment
-require('./autostart');
+// Export environment utilities
+const environment = {
+  detectAgentRuntime,
+  createMockAgent,
+  checkEnvironment,
+  getSetupInstructions
+};
 
-module.exports = {
-  Courtroom,
-  createCourtroom,
-  quickStart: Courtroom.quickStart
+// 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');
+    
+    // Store runtime reference
+    const runtime = api.runtime;
+    
+    // Only initialize skill if runtime has the required memory interface
+    // The skill system will auto-initialize via shouldActivate if this fails
+    if (skill && typeof skill.initialize === 'function' && runtime && runtime.memory) {
+      skill.initialize(runtime).catch(err => {
+        logger.error('PLUGIN', 'Skill initialization failed', { error: err.message });
+      });
+    } else {
+      logger.info('PLUGIN', 'Skill will auto-initialize via ClawDBot skill system');
+    }
+    
+    // Register any commands or hooks
+    logger.info('PLUGIN', 'Courtroom plugin registered successfully');
+  },
+  
+  // Optional: activation function
+  activate(api) {
+    logger.info('PLUGIN', 'Activating courtroom plugin');
+    // Additional activation logic if needed
+  }
 };
+
+// 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 });
+  });
+}

package/src/monitor.js

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+
+/**
+ * ClawTrial Background Monitor
+ * Runs continuously and initializes courtroom when agent becomes available
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { logger } = require('./debug');
+const { StatusManager } = require('./daemon');
+
+const CONFIG_PATH = path.join(process.env.HOME || '', '.clawdbot', 'courtroom_config.json');
+const CHECK_INTERVAL = 5000; // Check every 5 seconds
+const MAX_RETRIES = 100; // Give up after ~8 minutes
+
+let retryCount = 0;
+let courtroom = null;
+let statusManager = new StatusManager();
+
+logger.info('MONITOR', 'Background monitor started', { pid: process.pid });
+
+// Save PID
+statusManager.update({
+  running: true,
+  initialized: false,
+  pid: process.pid,
+  startedAt: new Date().toISOString()
+});
+
+/**
+ * Check if config exists and is enabled
+ */
+function checkConfig() {
+  try {
+    if (!fs.existsSync(CONFIG_PATH)) {
+      return { valid: false, reason: 'no_config' };
+    }
+    
+    const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+    
+    if (!config.consent?.granted) {
+      return { valid: false, reason: 'no_consent' };
+    }
+    
+    if (config.enabled === false) {
+      return { valid: false, reason: 'disabled' };
+    }
+    
+    return { valid: true, config };
+  } catch (err) {
+    logger.error('MONITOR', 'Config check failed', { error: err.message });
+    return { valid: false, reason: 'error' };
+  }
+}
+
+/**
+ * Detect agent runtime
+ */
+function detectAgent() {
+  // Check various global locations
+  if (typeof global.clawdbotAgent !== 'undefined' && global.clawdbotAgent) {
+    return { type: 'clawdbot', agent: global.clawdbotAgent };
+  }
+  
+  if (typeof global.agent !== 'undefined' && global.agent) {
+    return { type: 'generic', agent: global.agent };
+  }
+  
+  if (typeof process.clawdbotAgent !== 'undefined' && process.clawdbotAgent) {
+    return { type: 'clawdbot', agent: process.clawdbotAgent };
+  }
+  
+  // Check for ClawDBot specific indicators
+  if (process.env.CLAUDBOT_ENV === 'true') {
+    // Try to find agent in parent process or global scope
+    if (globalThis.clawdbotAgent) {
+      return { type: 'clawdbot', agent: globalThis.clawdbotAgent };
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Try to initialize courtroom
+ */
+async function tryInitialize() {
+  const configCheck = checkConfig();
+  
+  if (!configCheck.valid) {
+    logger.warn('MONITOR', 'Config not valid', { reason: configCheck.reason });
+    return false;
+  }
+  
+  const agentInfo = detectAgent();
+  
+  if (!agentInfo) {
+    logger.debug('MONITOR', 'Agent not detected yet');
+    return false;
+  }
+  
+  logger.info('MONITOR', `Agent detected: ${agentInfo.type}`);
+  
+  try {
+    // Import and initialize courtroom
+    const { createCourtroom } = require('./index');
+    courtroom = createCourtroom(agentInfo.agent);
+    
+    const result = await courtroom.initialize();
+    
+    if (result.status === 'initialized') {
+      logger.info('MONITOR', 'Courtroom initialized successfully');
+      
+      statusManager.update({
+        running: true,
+        initialized: true,
+        agentType: agentInfo.type,
+        publicKey: result.publicKey
+      });
+      
+      // Attach to global for access
+      global.courtroom = courtroom;
+      
+      console.log('\n🏛️  AI Courtroom is now active and monitoring!\n');
+      
+      return true;
+    } else {
+      logger.warn('MONITOR', 'Courtroom not initialized', { status: result.status });
+      return false;
+    }
+  } catch (err) {
+    logger.error('MONITOR', 'Initialization failed', { error: err.message });
+    return false;
+  }
+}
+
+/**
+ * Main monitoring loop
+ */
+async function monitor() {
+  logger.info('MONITOR', 'Starting monitoring loop');
+  
+  // Try immediately first
+  if (await tryInitialize()) {
+    return; // Success! Keep process alive
+  }
+  
+  // Set up interval to keep trying
+  const interval = setInterval(async () => {
+    retryCount++;
+    
+    if (retryCount > MAX_RETRIES) {
+      logger.warn('MONITOR', 'Max retries reached, giving up');
+      clearInterval(interval);
+      statusManager.update({ running: false, error: 'max_retries' });
+      process.exit(1);
+    }
+    
+    if (await tryInitialize()) {
+      clearInterval(interval);
+      // Keep process alive - courtroom is running
+    }
+  }, CHECK_INTERVAL);
+  
+  // Keep process alive
+  setInterval(() => {
+    // Heartbeat to keep process alive
+    if (courtroom && courtroom.enabled) {
+      statusManager.update({ lastHeartbeat: new Date().toISOString() });
+    }
+  }, 30000);
+}
+
+// Handle shutdown
+process.on('SIGTERM', () => {
+  logger.info('MONITOR', 'Received SIGTERM, shutting down');
+  statusManager.update({ running: false });
+  process.exit(0);
+});
+
+process.on('SIGINT', () => {
+  logger.info('MONITOR', 'Received SIGINT, shutting down');
+  statusManager.update({ running: false });
+  process.exit(0);
+});
+
+// Start monitoring
+monitor().catch(err => {
+  logger.error('MONITOR', 'Monitor crashed', { error: err.message });
+  statusManager.update({ running: false, error: err.message });
+  process.exit(1);
+});