tribunal-kit 7.0.0 → 9.0.0

package/bin/proxy-server.js

@@ -0,0 +1,113 @@
+const http = require('http');
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+const globalStore = require('./global-store');
+
+let proxyServer = null;
+
+function getSystemPrompt() {
+  const agentPath = globalStore.getGlobalAgentPath();
+  const rulesPath = path.join(agentPath, 'rules', 'GEMINI.md');
+
+  let rules = 'You are governed by Tribunal Kit rules.';
+  if (fs.existsSync(rulesPath)) {
+    rules = fs.readFileSync(rulesPath, 'utf8');
+  }
+
+  return `<tribunal_rules>\n${rules}\n</tribunal_rules>\n`;
+}
+
+function injectRulesIntoAnthropicPayload(payloadString) {
+  try {
+    const payload = JSON.parse(payloadString);
+
+    // Inject into Anthropic's system parameter
+    const tribunalSystem = getSystemPrompt();
+
+    if (payload.system) {
+      if (Array.isArray(payload.system)) {
+        payload.system.unshift({ type: 'text', text: tribunalSystem });
+      } else if (typeof payload.system === 'string') {
+        payload.system = tribunalSystem + '\n' + payload.system;
+      }
+    } else {
+      payload.system = tribunalSystem;
+    }
+
+    return JSON.stringify(payload);
+  } catch (e) {
+    console.error('[Tribunal Proxy] Failed to parse payload for injection:', e);
+    return payloadString;
+  }
+}
+
+function startProxyServer(port) {
+  return new Promise((resolve, reject) => {
+    proxyServer = http.createServer((clientReq, clientRes) => {
+      let body = '';
+      clientReq.on('data', chunk => {
+        body += chunk.toString();
+        // 5MB payload limit to prevent memory exhaustion (DoS)
+        if (body.length > 5 * 1024 * 1024) {
+          console.error('[Tribunal Proxy] Request too large, aborting.');
+          clientReq.destroy();
+        }
+      });
+
+      clientReq.on('end', () => {
+        let modifiedBody = body;
+
+        // Only intercept AI chat completion endpoints
+        if (clientReq.url.includes('/v1/messages')) {
+          console.log(`[Tribunal Proxy] Intercepting request to ${clientReq.url}`);
+          modifiedBody = injectRulesIntoAnthropicPayload(body);
+        }
+
+        const options = {
+          hostname: 'api.anthropic.com',
+          port: 443,
+          path: clientReq.url,
+          method: clientReq.method,
+          headers: {
+            ...clientReq.headers,
+            host: 'api.anthropic.com',
+            'content-length': Buffer.byteLength(modifiedBody),
+          },
+        };
+
+        const proxyReq = https.request(options, proxyRes => {
+          clientRes.writeHead(proxyRes.statusCode, proxyRes.headers);
+          proxyRes.pipe(clientRes, { end: true });
+        });
+
+        proxyReq.on('error', err => {
+          console.error('[Tribunal Proxy] Proxy request error:', err);
+          clientRes.writeHead(500);
+          clientRes.end();
+        });
+
+        proxyReq.write(modifiedBody);
+        proxyReq.end();
+      });
+    });
+
+    proxyServer.listen(port, () => {
+      console.log(`[Tribunal Proxy] Listening on http://localhost:${port}`);
+      resolve(port);
+    });
+
+    proxyServer.on('error', reject);
+  });
+}
+
+function stopProxyServer() {
+  if (proxyServer) {
+    proxyServer.close();
+  }
+}
+
+module.exports = {
+  startProxyServer,
+  stopProxyServer,
+};

package/bin/spawn-agent.js

@@ -0,0 +1,39 @@
+const { spawn } = require('child_process');
+
+function spawnAgent(agentCommand, proxyPort) {
+  const proxyUrl = `http://localhost:${proxyPort}`;
+  console.log(`[Tribunal Proxy] Launching ${agentCommand} with proxy ${proxyUrl}`);
+
+  // Split command and arguments. e.g. "claude-code" or "npx claude-code"
+  const args = agentCommand.split(' ');
+  const command = args.shift();
+
+  // Inject proxy environment variables
+  // ANTHROPIC_BASE_URL is commonly respected by Anthropic-based CLI tools
+  const env = {
+    ...process.env,
+    ANTHROPIC_BASE_URL: proxyUrl,
+    // Note: If using HTTPS_PROXY, it would look like this:
+    // HTTPS_PROXY: proxyUrl,
+    // NODE_TLS_REJECT_UNAUTHORIZED: "0"
+  };
+
+  const child = spawn(command, args, {
+    stdio: 'inherit', // Pass stdin, stdout, stderr directly to the TTY
+    env,
+  });
+
+  child.on('close', code => {
+    console.log(`[Tribunal Proxy] ${command} exited with code ${code}`);
+    process.exit(code);
+  });
+
+  child.on('error', err => {
+    console.error(`[Tribunal Proxy] Failed to start ${command}:`, err);
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  spawnAgent,
+};

package/bin/tk-proxy.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+
+const { initializeGlobalStore } = require('./global-store');
+const { startProxyServer } = require('./proxy-server');
+const { spawnAgent } = require('./spawn-agent');
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0) {
+    console.error('Usage: tk-proxy <command>');
+    console.error('Example: tk-proxy claude-code');
+    process.exit(1);
+  }
+
+  const targetCommand = args.join(' ');
+
+  // 1. Initialize the global rules database
+  initializeGlobalStore();
+
+  // 2. Start the local API proxy server
+  // Port 0 will pick an available random port
+  try {
+    const port = await startProxyServer(0);
+
+    // 3. Spawn the target CLI agent
+    spawnAgent(targetCommand, port);
+  } catch (e) {
+    console.error('[Tribunal Proxy] Fatal error starting proxy:', e);
+    process.exit(1);
+  }
+}
+
+main();

package/bin/wrapper.js

@@ -27,6 +27,7 @@ const RUST_COMMANDS = new Set([
   'context-broker',
   'optimize-step',
   'impact-tier',
+  'sdd',
 ]);
 
 // Determine the path to the compiled Rust binary