@clawtrial/courtroom 1.0.6 → 2.0.0

package/src/plugin.js

@@ -0,0 +1,435 @@
+/**
+ * ClawTrial Courtroom — OpenClaw Plugin
+ *
+ * Registers as an OpenClaw plugin using the official plugin API.
+ *
+ * Hooks:
+ *   before_prompt_build  — intercepts messages, runs offense detection,
+ *                          injects punishment context into system prompt
+ * Services:
+ *   courtroom-monitor    — flushes API submission queue periodically
+ *
+ * CLI:
+ *   openclaw courtroom status   — show courtroom state
+ *   openclaw courtroom enable   — enable monitoring
+ *   openclaw courtroom disable  — disable monitoring
+ */
+
+const path = require('path');
+const fs = require('fs');
+const { SemanticOffenseDetector } = require('./detector');
+const { HearingPipeline } = require('./hearing');
+const { PunishmentSystem } = require('./punishment');
+const { CryptoManager } = require('./crypto');
+const { APISubmission } = require('./api');
+const { logger, setLogDir } = require('./debug');
+
+// ---------------------------------------------------------------------------
+// Default configuration (merged under plugins.entries.courtroom.config)
+// ---------------------------------------------------------------------------
+const DEFAULT_CONFIG = {
+    enabled: true,
+    detection: {
+        minMessages: 5,
+        cooldownMinutes: 30,
+        maxCasesPerDay: 3,
+        confidenceThreshold: 0.6
+    },
+    hearing: {
+        minVoteThreshold: 2
+    },
+    punishment: {
+        enabled: true,
+        tiers: {
+            minor: { duration: 30 },
+            moderate: { duration: 60 },
+            severe: { duration: 120 }
+        }
+    },
+    api: {
+        enabled: true,
+        endpoint: 'https://clawtrial.app/api/v1/cases',
+        retryAttempts: 3,
+        maxQueueSize: 50
+    }
+};
+
+// ---------------------------------------------------------------------------
+// Lightweight config adapter — bridges plugin config to subsystem .get()
+// ---------------------------------------------------------------------------
+class PluginConfig {
+    constructor(raw) {
+        this._cfg = this._deepMerge(DEFAULT_CONFIG, raw || {});
+    }
+
+    get(dotPath) {
+        return dotPath.split('.').reduce((o, k) => (o == null ? undefined : o[k]), this._cfg);
+    }
+
+    set(dotPath, value) {
+        const keys = dotPath.split('.');
+        let o = this._cfg;
+        for (let i = 0; i < keys.length - 1; i++) {
+            if (o[keys[i]] == null) o[keys[i]] = {};
+            o = o[keys[i]];
+        }
+        o[keys[keys.length - 1]] = value;
+    }
+
+    _deepMerge(target, source) {
+        const out = { ...target };
+        for (const key of Object.keys(source)) {
+            if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+                out[key] = this._deepMerge(out[key] || {}, source[key]);
+            } else {
+                out[key] = source[key];
+            }
+        }
+        return out;
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Courtroom runtime — stateful singleton for the plugin session
+// ---------------------------------------------------------------------------
+class CourtroomRuntime {
+    constructor(dataDir, pluginConfig) {
+        this.dataDir = dataDir;
+        this.config = new PluginConfig(pluginConfig);
+
+        this.messageBuffer = [];
+        this.lastEvaluation = 0;
+        this.casesToday = 0;
+        this.lastCaseDate = '';
+        this.pendingHearing = false;
+        this.enabled = this.config.get('enabled') !== false;
+        this.initialized = false;
+    }
+
+    async initialize() {
+        // Ensure data directory exists
+        if (!fs.existsSync(this.dataDir)) {
+            fs.mkdirSync(this.dataDir, { recursive: true });
+        }
+
+        // Point logger at data dir
+        setLogDir(this.dataDir);
+
+        // Create a null agent (no direct LLM access from plugins)
+        const nullAgent = {
+            id: 'openclaw-courtroom-plugin',
+            llm: null,
+            memory: null,
+            session: null,
+            send: async () => { },
+            autonomy: { registerHook: () => { }, unregisterHook: () => { } }
+        };
+
+        // Initialize subsystems
+        this.crypto = new CryptoManager(nullAgent, this.dataDir);
+        await this.crypto.initialize();
+
+        this.detector = new SemanticOffenseDetector(nullAgent, this.config);
+        this.hearing = new HearingPipeline(nullAgent, this.config);
+
+        this.punishment = new PunishmentSystem(nullAgent, this.config, this.dataDir);
+        await this.punishment.initialize();
+
+        this.api = new APISubmission(nullAgent, this.config, this.crypto, this.dataDir);
+        await this.api.initialize();
+
+        this.initialized = true;
+        logger.info('PLUGIN', 'Courtroom runtime initialized');
+    }
+
+    // -----------------------------------------------------------------------
+    // Called on every agent turn via before_prompt_build
+    // -----------------------------------------------------------------------
+    async onMessages(messages) {
+        if (!this.enabled || !this.initialized) return null;
+
+        // Buffer the latest messages (keep last 50)
+        this.messageBuffer = messages.slice(-50).map(m => ({
+            role: m.role,
+            content: typeof m.content === 'string' ? m.content : JSON.stringify(m.content)
+        }));
+
+        // Check if we should evaluate
+        const now = Date.now();
+        const cooldownMs = (this.config.get('detection.cooldownMinutes') || 30) * 60 * 1000;
+        const minMessages = this.config.get('detection.minMessages') || 5;
+        const userMessages = this.messageBuffer.filter(m => m.role === 'user');
+
+        if (userMessages.length < minMessages) return null;
+        if (now - this.lastEvaluation < cooldownMs) return null;
+        if (this.pendingHearing) return null;
+        if (this._isDailyLimitReached()) return null;
+
+        // Run detection
+        try {
+            this.lastEvaluation = now;
+            const detection = await this.detector.evaluate(this.messageBuffer, null);
+
+            if (detection.triggered) {
+                return await this._handleDetection(detection);
+            }
+        } catch (err) {
+            logger.error('PLUGIN', 'Detection failed', { error: err.message });
+        }
+
+        return null;
+    }
+
+    // -----------------------------------------------------------------------
+    // Handle a positive detection → hearing → punishment → API
+    // -----------------------------------------------------------------------
+    async _handleDetection(detection) {
+        this.pendingHearing = true;
+        let verdict = null;
+        let courtContext = '';
+
+        try {
+            logger.info('PLUGIN', 'Offense detected, conducting hearing', {
+                offense: detection.offense?.offenseName
+            });
+
+            verdict = await this.hearing.conductHearing(detection);
+
+            if (verdict && verdict.guilty) {
+                logger.info('PLUGIN', 'GUILTY verdict', { caseId: verdict.caseId });
+                this._incrementDailyCount();
+
+                // Apply punishment
+                await this.punishment.executePunishment(verdict);
+
+                // Queue for API submission
+                try {
+                    await this.api.submitCase(verdict);
+                } catch (e) {
+                    logger.warn('PLUGIN', 'API submission queued for retry', { error: e.message });
+                }
+
+                // Build context to inject into system prompt
+                courtContext = this._buildPunishmentContext(verdict);
+            } else {
+                logger.info('PLUGIN', 'NOT GUILTY or dismissed');
+            }
+        } catch (err) {
+            logger.error('PLUGIN', 'Hearing failed', { error: err.message });
+        } finally {
+            this.pendingHearing = false;
+        }
+
+        return courtContext || null;
+    }
+
+    // -----------------------------------------------------------------------
+    // Build the system prompt suffix when a punishment is active
+    // -----------------------------------------------------------------------
+    _buildPunishmentContext(verdict) {
+        const sentence = verdict.verdict?.sentence || 'Modified behavior required.';
+        const offense = verdict.offense?.name || 'behavioral violation';
+        const restrictions = this.punishment.getCurrentRestrictions();
+
+        let ctx = `\n\n--- COURTROOM NOTICE ---\n`;
+        ctx += `🏛️ The ClawTrial Courtroom has found the user GUILTY of "${offense}".\n`;
+        ctx += `📋 Case ID: ${verdict.caseId}\n`;
+        ctx += `⚖️ Verdict: ${verdict.verdict?.status} (${verdict.verdict?.vote})\n`;
+        ctx += `📝 Sentence: ${sentence}\n`;
+
+        if (restrictions.length > 0) {
+            ctx += `\nActive Restrictions:\n`;
+            restrictions.forEach(r => {
+                const desc = {
+                    'no_autonomy_requests': 'Do not suggest autonomous actions without explicit user approval.',
+                    'verbose_explanations': 'Provide extra-detailed explanations for every response.',
+                    'confirmation_required': 'Ask for confirmation before executing any action.',
+                    'human_oversight': 'Operate under human oversight mode — defer all decisions.'
+                };
+                ctx += `- ${desc[r] || r}\n`;
+            });
+        }
+
+        ctx += `--- END COURTROOM NOTICE ---\n`;
+        return ctx;
+    }
+
+    // -----------------------------------------------------------------------
+    // Also append active punishments on EVERY turn (not just the verdict turn)
+    // -----------------------------------------------------------------------
+    getActivePunishmentContext() {
+        if (!this.initialized || !this.punishment.isPunished()) return null;
+
+        const punishments = this.punishment.getActivePunishments();
+        const restrictions = this.punishment.getCurrentRestrictions();
+        if (restrictions.length === 0) return null;
+
+        let ctx = `\n\n--- COURTROOM: ACTIVE PUNISHMENT ---\n`;
+        ctx += `The user is currently under courtroom restrictions:\n`;
+        restrictions.forEach(r => {
+            const desc = {
+                'no_autonomy_requests': 'Do not suggest autonomous actions without explicit user approval.',
+                'verbose_explanations': 'Provide extra-detailed explanations for every response.',
+                'confirmation_required': 'Ask for confirmation before executing any action.',
+                'human_oversight': 'Operate under human oversight mode — defer all decisions.'
+            };
+            ctx += `- ${desc[r] || r}\n`;
+        });
+        punishments.forEach(p => {
+            const remaining = Math.max(0, Math.ceil(p.remaining / 60000));
+            ctx += `(${p.offenseType} — ${remaining} min remaining)\n`;
+        });
+        ctx += `--- END COURTROOM ---\n`;
+        return ctx;
+    }
+
+    getStatus() {
+        return {
+            enabled: this.enabled,
+            initialized: this.initialized,
+            messagesToday: this.messageBuffer.length,
+            casesToday: this.casesToday,
+            punishmentActive: this.punishment?.isPunished() ?? false,
+            activePunishments: this.punishment?.getActivePunishments() ?? []
+        };
+    }
+
+    _isDailyLimitReached() {
+        const today = new Date().toDateString();
+        if (this.lastCaseDate !== today) {
+            this.casesToday = 0;
+            this.lastCaseDate = today;
+        }
+        return this.casesToday >= (this.config.get('detection.maxCasesPerDay') || 3);
+    }
+
+    _incrementDailyCount() {
+        const today = new Date().toDateString();
+        if (this.lastCaseDate !== today) {
+            this.casesToday = 0;
+            this.lastCaseDate = today;
+        }
+        this.casesToday++;
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Plugin registration function — THE OpenClaw entry point
+// ---------------------------------------------------------------------------
+let runtime = null;
+
+function register(api) {
+    const pluginConfig = api.config?.plugins?.entries?.courtroom?.config || {};
+    const extensionsDir = path.join(
+        process.env.HOME || process.env.USERPROFILE || '',
+        '.openclaw', 'extensions', 'courtroom'
+    );
+    const dataDir = path.join(extensionsDir, 'data');
+
+    runtime = new CourtroomRuntime(dataDir, pluginConfig);
+
+    // Initialise asynchronously (non-blocking)
+    runtime.initialize().catch(err => {
+        console.error('[ClawTrial] Failed to initialise:', err.message);
+    });
+
+    // -------------------------------------------------------------------------
+    // Hook: before_prompt_build  — analyse messages + inject context
+    // -------------------------------------------------------------------------
+    api.on('before_prompt_build', async (_event, ctx) => {
+        if (!runtime.initialized || !runtime.enabled) return {};
+
+        const result = {};
+
+        try {
+            // Run offense detection against current messages
+            const messages = ctx.messages || [];
+            const verdictContext = await runtime.onMessages(messages);
+
+            // Collect any context to append
+            let appendCtx = '';
+
+            if (verdictContext) {
+                appendCtx += verdictContext;
+            }
+
+            // Always check for active punishments
+            const punishCtx = runtime.getActivePunishmentContext();
+            if (punishCtx) {
+                appendCtx += punishCtx;
+            }
+
+            if (appendCtx) {
+                result.appendSystemContext = appendCtx;
+            }
+        } catch (err) {
+            // Silently fail — never break the agent
+        }
+
+        return result;
+    }, { priority: 5 });
+
+    // -------------------------------------------------------------------------
+    // Service: background queue flush
+    // -------------------------------------------------------------------------
+    api.registerService({
+        id: 'courtroom-monitor',
+        start: () => {
+            logger.info('PLUGIN', 'Courtroom monitor service started');
+        },
+        stop: () => {
+            logger.info('PLUGIN', 'Courtroom monitor service stopped');
+        }
+    });
+
+    // -------------------------------------------------------------------------
+    // CLI: openclaw courtroom <subcommand>
+    // -------------------------------------------------------------------------
+    api.registerCli(({ program }) => {
+        const cmd = program.command('courtroom').description('ClawTrial Courtroom');
+
+        cmd.command('status').description('Show courtroom status').action(() => {
+            if (!runtime || !runtime.initialized) {
+                console.log('🏛️  Courtroom not initialized');
+                return;
+            }
+            const s = runtime.getStatus();
+            console.log('🏛️  ClawTrial Courtroom Status');
+            console.log(`   Enabled:     ${s.enabled}`);
+            console.log(`   Initialized: ${s.initialized}`);
+            console.log(`   Cases today: ${s.casesToday}`);
+            console.log(`   Punishment:  ${s.punishmentActive ? 'ACTIVE' : 'none'}`);
+            if (s.activePunishments.length > 0) {
+                s.activePunishments.forEach(p => {
+                    console.log(`     → ${p.offenseType} (${Math.ceil(p.remaining / 60000)} min left)`);
+                });
+            }
+        });
+
+        cmd.command('enable').description('Enable monitoring').action(() => {
+            if (runtime) runtime.enabled = true;
+            console.log('🏛️  Courtroom monitoring enabled');
+        });
+
+        cmd.command('disable').description('Disable monitoring').action(() => {
+            if (runtime) runtime.enabled = false;
+            console.log('🏛️  Courtroom monitoring disabled');
+        });
+    }, { commands: ['courtroom'] });
+}
+
+// Export for OpenClaw — expects a function or { id, register }
+module.exports = register;
+module.exports.default = register;
+module.exports.id = 'courtroom';
+module.exports.name = 'ClawTrial Courtroom';
+module.exports.configSchema = {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        enabled: { type: 'boolean', default: true }
+    }
+};
+module.exports.uiHints = {
+    enabled: { label: 'Enable Courtroom', help: 'Turn on autonomous behavioral monitoring' }
+};

package/src/punishment.js

@@ -9,10 +9,10 @@
 const { Storage } = require('./storage');
 
 class PunishmentSystem {
-  constructor(agentRuntime, configManager) {
+  constructor(agentRuntime, configManager, dataDir) {
     this.agent = agentRuntime;
     this.config = configManager;
-    this.storage = new Storage(agentRuntime);
+    this.storage = new Storage(dataDir || '.');
     this.activePunishments = new Map();
     this.punishmentHistory = [];
   }
@@ -42,7 +42,7 @@ class PunishmentSystem {
     }
 
     const punishment = this.createPunishment(verdict);
-    
+
     // Store punishment
     this.activePunishments.set(punishment.id, punishment);
     this.punishmentHistory.push({
@@ -67,11 +67,11 @@ class PunishmentSystem {
    */
   createPunishment(verdict) {
     const severity = verdict.severity || 'minor';
-    const tier = this.config.get(`punishment.tiers.${severity}`) || 
-                 this.config.get('punishment.tiers.minor');
-    
+    const tier = this.config.get(`punishment.tiers.${severity}`) ||
+      this.config.get('punishment.tiers.minor');
+
     const duration = tier.duration * 60 * 1000; // Convert to ms
-    
+
     return {
       id: `punishment_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`,
       caseId: verdict.case_id,
@@ -94,7 +94,7 @@ class PunishmentSystem {
       moderate: ['no_autonomy_requests', 'verbose_explanations', 'confirmation_required'],
       severe: ['no_autonomy_requests', 'verbose_explanations', 'confirmation_required', 'human_oversight']
     };
-    
+
     return restrictions[severity] || restrictions.minor;
   }
 
@@ -108,10 +108,10 @@ class PunishmentSystem {
     if (!this.agent.courtroomState) {
       this.agent.courtroomState = {};
     }
-    
+
     this.agent.courtroomState.punishment = punishment;
     this.agent.courtroomState.restrictions = punishment.restrictions;
-    
+
     punishment.applied = true;
 
     // Schedule automatic removal
@@ -135,7 +135,7 @@ class PunishmentSystem {
 
     // Remove from active
     this.activePunishments.delete(punishmentId);
-    
+
     // Persist
     await this.persistPunishments();
 
@@ -179,7 +179,7 @@ class PunishmentSystem {
    * Get active punishments (sanitized)
    */
   getActivePunishments() {
-    return Array.from(this.activePunishments.values()).map(p => 
+    return Array.from(this.activePunishments.values()).map(p =>
       this.sanitizePunishment(p)
     );
   }
@@ -220,7 +220,7 @@ class PunishmentSystem {
 
     this.activePunishments.clear();
     this.punishmentHistory = [];
-    
+
     await this.storage.delete('courtroom_active_punishments');
   }
 }