@clawtrial/courtroom 1.0.3 → 2.0.0

package/src/index.js

@@ -1,286 +0,0 @@
-/**
- * @clawtrial/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(process.env.HOME || '', '.clawdbot', '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');
-    
-    // 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

@@ -1,193 +0,0 @@
-#!/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);
-});