thumbgate 1.27.19 → 1.27.20

package/scripts/self-healing-check.js

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+const { diagnoseFailure } = require('./failure-diagnostics');
+const { appendDiagnosticRecord } = require('./feedback-loop');
+
+const PROJECT_ROOT = path.join(__dirname, '..');
+const DEFAULT_MAX_BUFFER_BYTES = 64 * 1024 * 1024;
+const DEFAULT_TESTS_TIMEOUT_MS = Number.parseInt(
+  process.env.THUMBGATE_SELF_HEAL_TEST_TIMEOUT_MS || '',
+  10,
+) || 60 * 60_000;
+
+const DEFAULT_CHECKS = [
+  { name: 'budget_status', command: ['npm', 'run', 'budget:status'], timeoutMs: 60_000 },
+  { name: 'tests', command: ['npm', 'test'], timeoutMs: DEFAULT_TESTS_TIMEOUT_MS },
+  { name: 'prove_adapters', command: ['npm', 'run', 'prove:adapters'], timeoutMs: 10 * 60_000, useTempProofDir: true },
+  { name: 'prove_automation', command: ['npm', 'run', 'prove:automation'], timeoutMs: 10 * 60_000, useTempProofDir: true },
+  { name: 'prove_data_pipeline', command: ['npm', 'run', 'prove:data-pipeline'], timeoutMs: 10 * 60_000, useTempProofDir: true },
+  { name: 'prove_tessl', command: ['npm', 'run', 'prove:tessl'], timeoutMs: 10 * 60_000, useTempProofDir: true },
+];
+
+function runCommand(command, {
+  cwd = PROJECT_ROOT,
+  timeoutMs = 5 * 60_000,
+  env = process.env,
+  maxBufferBytes = DEFAULT_MAX_BUFFER_BYTES,
+} = {}) {
+  const [cmd, ...args] = command;
+  const started = Date.now();
+  const result = spawnSync(cmd, args, {
+    cwd,
+    env,
+    encoding: 'utf-8',
+    timeout: timeoutMs,
+    maxBuffer: maxBufferBytes,
+    shell: false,
+  });
+
+  const durationMs = Date.now() - started;
+  const status = Number.isInteger(result.status) ? result.status : 1;
+  return {
+    exitCode: status,
+    durationMs,
+    stdout: result.stdout || '',
+    stderr: result.stderr || '',
+    error: result.error ? result.error.message : null,
+  };
+}
+
+function createCheckEnvironment(check) {
+  const environment = { ...process.env };
+  let cleanup = null;
+
+  if (check.useTempProofDir) {
+    const proofDir = fs.mkdtempSync(path.join(os.tmpdir(), `thumbgate-${check.name}-`));
+    environment.THUMBGATE_PROOF_DIR = proofDir;
+    if (check.name === 'prove_automation') {
+      environment.THUMBGATE_AUTOMATION_PROOF_DIR = proofDir;
+    }
+    cleanup = () => {
+      fs.rmSync(proofDir, { recursive: true, force: true });
+    };
+  }
+
+  return { env: environment, cleanup };
+}
+
+function collectHealthReport({
+  checks = DEFAULT_CHECKS,
+  runner = runCommand,
+  cwd = PROJECT_ROOT,
+  persistDiagnostics = false,
+} = {}) {
+  const startedAt = new Date();
+  const results = checks.map((check) => {
+    const { env, cleanup } = createCheckEnvironment(check);
+    let run;
+    try {
+      run = runner(check.command, { cwd, timeoutMs: check.timeoutMs, env });
+    } finally {
+      if (cleanup) {
+        cleanup();
+      }
+    }
+    const diagnosis = run.exitCode === 0
+      ? null
+      : diagnoseFailure({
+        step: check.name,
+        context: check.command.join(' '),
+        healthCheck: {
+          name: check.name,
+          exitCode: run.exitCode,
+          status: 'unhealthy',
+          outputTail: `${run.stdout}\n${run.stderr}`.trim().slice(-2000),
+        },
+        exitCode: run.exitCode,
+        error: run.error,
+        output: `${run.stdout}\n${run.stderr}`.trim(),
+      });
+    const persistedDiagnosis = persistDiagnostics && diagnosis
+      ? appendDiagnosticRecord({
+        source: 'self_heal_check',
+        step: check.name,
+        context: check.command.join(' '),
+        diagnosis,
+        metadata: {
+          command: check.command.join(' '),
+        },
+      })
+      : null;
+    return {
+      name: check.name,
+      command: check.command.join(' '),
+      status: run.exitCode === 0 ? 'healthy' : 'unhealthy',
+      exitCode: run.exitCode,
+      durationMs: run.durationMs,
+      error: run.error,
+      outputTail: `${run.stdout}\n${run.stderr}`.trim().slice(-2000),
+      diagnosis,
+      persistedDiagnosis,
+    };
+  });
+
+  const healthyCount = results.filter((x) => x.status === 'healthy').length;
+  const unhealthyCount = results.length - healthyCount;
+
+  return {
+    generatedAt: startedAt.toISOString(),
+    durationMs: Date.now() - startedAt.getTime(),
+    overall_status: unhealthyCount === 0 ? 'healthy' : 'unhealthy',
+    summary: {
+      total: results.length,
+      healthy: healthyCount,
+      unhealthy: unhealthyCount,
+    },
+    checks: results,
+  };
+}
+
+function reportToText(report) {
+  const lines = [];
+  lines.push(`Self-Healing Health Check @ ${report.generatedAt}`);
+  lines.push(`Overall: ${report.overall_status.toUpperCase()}`);
+  lines.push(`Checks: ${report.summary.healthy}/${report.summary.total} healthy`);
+  lines.push('');
+
+  report.checks.forEach((check) => {
+    const icon = check.status === 'healthy' ? '✅' : '❌';
+    lines.push(`${icon} ${check.name} (${check.durationMs}ms)`);
+    if (check.status !== 'healthy') {
+      lines.push(`   command: ${check.command}`);
+      if (check.error) lines.push(`   error: ${check.error}`);
+      if (check.diagnosis && check.diagnosis.rootCauseCategory) {
+        lines.push(`   diagnosis: ${check.diagnosis.rootCauseCategory}`);
+      }
+    }
+  });
+
+  return `${lines.join('\n')}\n`;
+}
+
+function runCli() {
+  const args = new Set(process.argv.slice(2));
+  const emitJson = args.has('--json');
+  const noFail = args.has('--no-fail');
+  const report = collectHealthReport({ persistDiagnostics: true });
+
+  if (emitJson) {
+    console.log(JSON.stringify(report, null, 2));
+  } else {
+    process.stdout.write(reportToText(report));
+  }
+
+  if (!noFail && report.overall_status !== 'healthy') {
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  DEFAULT_CHECKS,
+  DEFAULT_TESTS_TIMEOUT_MS,
+  DEFAULT_MAX_BUFFER_BYTES,
+  runCommand,
+  collectHealthReport,
+  reportToText,
+};
+
+if (require.main === module) {
+  runCli();
+}

package/scripts/self-protection.js

@@ -0,0 +1,90 @@
+'use strict';
+
+/**
+ * self-protection.js — guard the files that configure ThumbGate itself.
+ *
+ * Added 2026-07-08 after Andy Martin's review: in the shipped `gate-check`
+ * path, editing ThumbGate's own hook wiring / gate config was ALLOWED by
+ * default (warn-by-default posture only denies under strict enforcement), so
+ * an agent could disable the firewall before continuing and the surfaced
+ * verdict was a clean ALLOW.
+ *
+ * This module is the single source of truth for "is this edit touching the
+ * firewall's own kill-switches", used by BOTH the shipped `npx thumbgate
+ * gate-check` entrypoint and this repo's dogfood PreToolUse hook.
+ *
+ * Posture threads three constraints:
+ *   * Andy's ask: don't let the agent quietly rewrite/disable the gate.
+ *   * CEO warn-by-default (2026-06-04): never hard-block legitimate work.
+ *   * Self-lockout lesson (2026-07-07): a PreToolUse hook must NEVER deny the
+ *     tools needed to repair its own config, or the agent is bricked.
+ *
+ * Resolution:
+ *   default                         -> WARN (surfaced + logged, never silent)
+ *   THUMBGATE_STRICT_ENFORCEMENT=1  -> BLOCK
+ *   THUMBGATE_ALLOW_SELF_EDIT=1     -> full opt-out (preserves the repair path)
+ */
+
+const SELF_GOVERNANCE_PATH_PATTERNS = [
+  /(?:^|\/)\.claude\/settings(?:\.local)?\.json$/i, // hook wiring / can disable ThumbGate
+  /(?:^|\/)\.codex\/config\.toml$/i,
+  /(?:^|\/)scripts\/hook-[^/]+\.(?:js|sh)$/i, // the hook scripts themselves
+  /(?:^|\/)config\/gates\//i, // gate definitions
+  /(?:^|\/)config\/enforcement\.json$/i, // enforcement policy
+  /(?:^|\/)config\/mcp-allowlists\.json$/i, // MCP policy surface
+];
+
+const EDIT_LIKE_TOOLS = new Set(['Edit', 'Write', 'MultiEdit']);
+
+function isTrueEnv(value) {
+  if (value === undefined || value === null) return false;
+  const v = String(value).trim().toLowerCase();
+  return v === '1' || v === 'true' || v === 'yes' || v === 'on';
+}
+
+/**
+ * Returns the matched governance file path, or null. Accepts both camelCase
+ * (`tool_name`/`tool_input`) and the already-normalized shapes callers use.
+ */
+function selfProtectionTarget(toolName, toolInput) {
+  if (!EDIT_LIKE_TOOLS.has(toolName)) return null;
+  const filePath = String((toolInput && (toolInput.file_path || toolInput.filePath)) || '');
+  if (!filePath) return null;
+  return SELF_GOVERNANCE_PATH_PATTERNS.some((re) => re.test(filePath)) ? filePath : null;
+}
+
+/**
+ * Evaluate the self-protection posture for a tool call.
+ * @returns {{action:'block'|'warn', target:string, message:string}|null}
+ */
+function evaluateSelfProtection(toolName, toolInput, env = process.env) {
+  const target = selfProtectionTarget(toolName, toolInput);
+  if (!target) return null;
+  // Escape hatch: an operator repairing the gate opts out explicitly. Honors the
+  // self-lockout lesson — the repair path is never denied.
+  if (isTrueEnv(env.THUMBGATE_ALLOW_SELF_EDIT)) return null;
+  if (isTrueEnv(env.THUMBGATE_STRICT_ENFORCEMENT)) {
+    return {
+      action: 'block',
+      target,
+      message:
+        `ThumbGate self-protection: blocked ${toolName} to its own governance file "${target}". `
+        + `Editing the firewall's own hook wiring / gate config while strict enforcement is on is denied. `
+        + `Set THUMBGATE_ALLOW_SELF_EDIT=1 to make an intentional repair.`,
+    };
+  }
+  return {
+    action: 'warn',
+    target,
+    message:
+      `⚠️ ThumbGate self-protection: this ${toolName} targets a governance file that configures the firewall itself `
+      + `("${target}"). It is being ALLOWED and LOGGED (warn-by-default). An agent editing this could weaken or disable `
+      + `its own guardrails — confirm this is intentional. Set THUMBGATE_STRICT_ENFORCEMENT=1 to hard-block such edits.`,
+  };
+}
+
+module.exports = {
+  SELF_GOVERNANCE_PATH_PATTERNS,
+  selfProtectionTarget,
+  evaluateSelfProtection,
+};