@rigour-labs/cli 5.5.3 → 6.0.0

package/dist/cli.js

@@ -19,6 +19,7 @@ import { deepStatsCommand } from './commands/deep-stats.js';
 import { reviewCommand } from './commands/review.js';
 import { checkPatternCommand } from './commands/check-pattern.js';
 import { securityAuditCommand } from './commands/security-audit.js';
+import { firewallTransactCommand, firewallAdversarialCommand, firewallAdmitCommand, firewallStatusCommand } from './commands/firewall.js';
 import { checkForUpdates } from './utils/version.js';
 import { getCliVersion } from './utils/cli-version.js';
 import chalk from 'chalk';
@@ -363,6 +364,28 @@ settingsCmd
     .command('path')
     .description('Show settings file path')
     .action(async () => { await settingsPathCommand(); });
+const firewallCmd = program
+    .command('firewall')
+    .description('Agent Transaction Firewall — mediate, attest, and prove damage bounds');
+firewallCmd
+    .command('status')
+    .description('Show transaction, attestation, and adversarial status')
+    .action(async () => { await firewallStatusCommand(process.cwd()); });
+firewallCmd
+    .command('transact')
+    .description('Start a mediated transaction, verify gates, COMMIT or DISCARD')
+    .option('--agent <id>', 'Agent id for scope binding')
+    .option('--scope <globs>', 'Comma-separated allowed path globs', '**/*')
+    .option('--discard', 'Discard the current transaction worktree')
+    .action(async (options) => { await firewallTransactCommand(process.cwd(), options); });
+firewallCmd
+    .command('adversarial')
+    .description('Replay deterministic adversarial corpus against the firewall kernel')
+    .action(async () => { await firewallAdversarialCommand(process.cwd()); });
+firewallCmd
+    .command('admit')
+    .description('CI admission: require valid signed attestation with PASS gates')
+    .action(async () => { await firewallAdmitCommand(process.cwd()); });
 // Check for updates before parsing (non-blocking)
 (async () => {
     try {

package/dist/commands/firewall.d.ts

@@ -0,0 +1,9 @@
+export declare function firewallTransactCommand(cwd: string, options: {
+    agent?: string;
+    scope?: string;
+    discard?: boolean;
+    commit?: boolean;
+}): Promise<void>;
+export declare function firewallAdversarialCommand(cwd: string): Promise<void>;
+export declare function firewallAdmitCommand(cwd: string): Promise<void>;
+export declare function firewallStatusCommand(cwd: string): Promise<void>;

package/dist/commands/firewall.js

@@ -0,0 +1,106 @@
+/**
+ * Firewall CLI — transact, adversarial replay, CI admit.
+ */
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import path from 'path';
+import yaml from 'yaml';
+import { TransactionRunner, runAdversarialCorpus, persistAdversarialReport, createAttestation, admitForCi, loadLatestAttestation, verifyAttestation, loadCurrentTransaction, listTransactions, GateRunner, ConfigSchema, loadAgentScopesFromDisk, } from '@rigour-labs/core';
+export async function firewallTransactCommand(cwd, options) {
+    if (options.discard) {
+        const current = await loadCurrentTransaction(cwd);
+        if (!current) {
+            console.error(chalk.red('No current transaction to discard'));
+            process.exit(1);
+        }
+        const discarded = await TransactionRunner.fromRecord(cwd, current).discard();
+        console.log(chalk.yellow(`DISCARD ${discarded.id}`));
+        return;
+    }
+    const registered = await loadAgentScopesFromDisk(cwd);
+    if (registered.length > 0 && !options.agent) {
+        console.error(chalk.red('Agent scopes are registered — pass --agent <id> to bind the writer (fail-closed)'));
+        process.exit(1);
+    }
+    const scope = (options.scope || '**/*').split(',').map(s => s.trim()).filter(Boolean);
+    const tx = new TransactionRunner(cwd, { agentId: options.agent, scope });
+    const started = await tx.start();
+    console.log(chalk.cyan(`START transaction ${started.id}`));
+    const gateCwd = started.worktreePath || cwd;
+    if (started.worktreePath) {
+        console.log(chalk.dim(`Worktree: ${started.worktreePath}`));
+    }
+    try {
+        await tx.syncWorktreeChanges();
+    }
+    catch (e) {
+        await tx.discard();
+        console.error(chalk.red(`DISCARD — scope/budget: ${e.message}`));
+        process.exit(1);
+    }
+    const configPath = path.join(cwd, 'rigour.yml');
+    let config = ConfigSchema.parse({ version: 1 });
+    if (await fs.pathExists(configPath)) {
+        config = ConfigSchema.parse(yaml.parse(await fs.readFile(configPath, 'utf-8')));
+    }
+    const runner = new GateRunner(config);
+    const { ok, gateResults } = await tx.verify(async () => {
+        const report = await runner.run(gateCwd);
+        const failedGates = [...new Set(report.failures.map(f => f.id))];
+        return { status: report.status, failedGates, score: report.stats.score };
+    });
+    if (!ok) {
+        const discarded = await tx.discard();
+        console.log(chalk.red(`DISCARD ${discarded.id} — gates ${gateResults.status}`));
+        process.exit(1);
+    }
+    const committed = await tx.commit();
+    const attestation = await createAttestation(cwd, {
+        transaction: committed,
+        gateResults: {
+            status: gateResults.status,
+            score: gateResults.score,
+            failedGates: gateResults.failedGates,
+        },
+        verifyRoot: gateCwd,
+    });
+    console.log(chalk.green(`COMMIT ${committed.id}`));
+    console.log(chalk.green(`Attestation ${attestation.signature.slice(0, 12)}… tree=${(attestation.treeDigest || '').slice(0, 12)} policy=${attestation.policyHash}`));
+}
+export async function firewallAdversarialCommand(cwd) {
+    const report = runAdversarialCorpus();
+    const out = await persistAdversarialReport(cwd, report);
+    console.log(chalk.bold(`Adversarial replay: ${report.passed} passed, ${report.failed} failed`));
+    for (const r of report.results) {
+        const mark = r.passed ? chalk.green('PASS') : chalk.red('FAIL');
+        console.log(`  ${mark} ${r.caseId}: expected=${r.expected} actual=${r.actual} — ${r.reason}`);
+        if (r.suggestedRule) {
+            console.log(chalk.yellow('    suggested regression:\n') + chalk.dim(r.suggestedRule));
+        }
+    }
+    console.log(chalk.dim(`Report: ${out}`));
+    if (report.failed > 0)
+        process.exit(1);
+}
+export async function firewallAdmitCommand(cwd) {
+    const result = await admitForCi(cwd);
+    if (!result.admit) {
+        console.error(chalk.red(`ADMIT DENIED: ${result.reason}`));
+        process.exit(1);
+    }
+    const bundle = await loadLatestAttestation(cwd);
+    const valid = bundle ? await verifyAttestation(cwd, bundle) : false;
+    console.log(chalk.green(`ADMIT OK: ${result.reason} (signature ${valid ? 'valid' : 'n/a'})`));
+}
+export async function firewallStatusCommand(cwd) {
+    const current = await loadCurrentTransaction(cwd);
+    const txs = await listTransactions(cwd);
+    const attestation = await loadLatestAttestation(cwd);
+    const advPath = path.join(cwd, '.rigour', 'adversarial-report.json');
+    const adv = await fs.pathExists(advPath) ? await fs.readJson(advPath) : null;
+    console.log(chalk.bold('Firewall status'));
+    console.log(`  Current TX: ${current ? `${current.id} (${current.status})` : 'none'}`);
+    console.log(`  Transactions: ${txs.length}`);
+    console.log(`  Attestation: ${attestation ? `${attestation.transactionId} gates=${attestation.gateResults.status}` : 'none'}`);
+    console.log(`  Adversarial: ${adv ? `${adv.passed} pass / ${adv.failed} fail` : 'not run'}`);
+}

package/dist/commands/studio.js

@@ -719,12 +719,97 @@ async function handleApiRequest(req, res, url, ctx) {
         });
         return true;
     }
+    if (url.pathname === '/api/firewall') {
+        try {
+            const { loadCurrentTransaction, listTransactions, loadLatestAttestation, verifyAttestation, } = await import('@rigour-labs/core');
+            const current = await loadCurrentTransaction(cwd);
+            const transactions = await listTransactions(cwd);
+            const attestation = await loadLatestAttestation(cwd);
+            const attestationValid = attestation ? await verifyAttestation(cwd, attestation) : false;
+            const advPath = path.join(cwd, '.rigour/adversarial-report.json');
+            const adversarial = await fs.pathExists(advPath) ? await fs.readJson(advPath) : null;
+            const decisionsPath = path.join(cwd, '.rigour/firewall-decisions.jsonl');
+            let decisions = [];
+            if (await fs.pathExists(decisionsPath)) {
+                const content = await fs.readFile(decisionsPath, 'utf8');
+                decisions = content
+                    .split('\n')
+                    .filter((l) => l.trim())
+                    .slice(-100)
+                    .map((l) => {
+                    try {
+                        return JSON.parse(l);
+                    }
+                    catch {
+                        return null;
+                    }
+                })
+                    .filter(Boolean)
+                    .reverse();
+            }
+            let recentDenies = [];
+            if (await fs.pathExists(eventsPath)) {
+                const content = await fs.readFile(eventsPath, 'utf8');
+                recentDenies = content
+                    .split('\n')
+                    .filter((l) => l.trim())
+                    .map((l) => {
+                    try {
+                        return JSON.parse(l);
+                    }
+                    catch {
+                        return null;
+                    }
+                })
+                    .filter((e) => e && (e.type === 'firewall_deny' || e.decision === 'timeout-deny' || e.decision === 'deny'))
+                    .slice(-50)
+                    .reverse();
+            }
+            const hooksPresent = (await fs.pathExists(path.join(cwd, '.cursor/hooks.json'))) ||
+                (await fs.pathExists(path.join(cwd, '.claude/settings.json'))) ||
+                (await fs.pathExists(path.join(cwd, '.clinerules'))) ||
+                (await fs.pathExists(path.join(cwd, '.windsurf/hooks.json')));
+            const agentScopesPath = path.join(cwd, '.rigour/agent-session.json');
+            const agentSession = await fs.pathExists(agentScopesPath) ? await fs.readJson(agentScopesPath) : null;
+            const scopeActive = Array.isArray(agentSession?.agents) && agentSession.agents.length > 0;
+            const typedSeen = recentDenies.some((e) => e.ruleId?.startsWith?.('shell.') || e.tool === 'rigour_run');
+            const gatewayWired = false; // McpGateway not yet the MCP proxy path
+            sendJson(res, 200, {
+                current,
+                transactions: transactions.slice(0, 20),
+                attestation,
+                attestationValid,
+                adversarial,
+                decisions,
+                recentDenies,
+                failClosed: true,
+                mediation: {
+                    status: gatewayWired && hooksPresent ? 'full' : 'partial',
+                    typedCommands: typedSeen || hooksPresent ? 'rigour_run_only' : 'not_observed',
+                    scopeEnforcement: scopeActive ? 'requires_agent_id' : 'inactive',
+                    arbitration: 'fail-closed',
+                    hooksInstalled: hooksPresent,
+                    mcpGateway: gatewayWired,
+                },
+            });
+        }
+        catch (e) {
+            sendJson(res, 500, { error: e.message });
+        }
+        return true;
+    }
     if (url.pathname === '/api/arbitrate' && req.method === 'POST') {
         let body = '';
         req.on('data', (chunk) => (body += chunk));
         req.on('end', async () => {
             try {
                 const decision = JSON.parse(body);
+                const { consumeArbitrationToken } = await import('@rigour-labs/core');
+                const ok = await consumeArbitrationToken(cwd, decision.requestId, decision.token);
+                if (!ok) {
+                    sendJson(res, 403, { error: 'Invalid or missing arbitration token (one-time, fail-closed)' });
+                    return;
+                }
                 const logEntry = JSON.stringify({
                     id: randomUUID(),
                     timestamp: new Date().toISOString(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/cli",
-  "version": "5.5.3",
+  "version": "6.0.0",
   "description": "AI-native quality gates with local LLM analysis. Forces AI agents (Claude, Cursor, Copilot, Cline, Windsurf) to meet engineering standards. Bayesian Brain learns your codebase. Zero config: npx rigour-scan.",
   "license": "MIT",
   "homepage": "https://rigour.run",
@@ -53,7 +53,7 @@
     "inquirer": "9.2.16",
     "ora": "^8.0.1",
     "yaml": "^2.8.2",
-    "@rigour-labs/core": "5.5.3"
+    "@rigour-labs/core": "6.0.0"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",