just-bash

# Standard (no deps):        bash scripts/bash/gate-check.sh <spec>
# Sandboxed (requires npm):  node sandbox/run-gate-check.mjs <spec>

cd your-project
npm install just-bash

#!/usr/bin/env node
// Sandboxed gate-check runner using just-bash
// Usage: node sandbox/run-gate-check.mjs <spec-path>

import { Bash } from "just-bash";
import { readFileSync, readdirSync, statSync, existsSync } from "fs";
import { join, resolve, relative } from "path";
import { createHash } from "crypto";
import { appendFileSync, mkdirSync } from "fs";

const specPath = process.argv[2];
if (!specPath) {
  console.error("usage: node sandbox/run-gate-check.mjs <spec-path>");
  process.exit(2);
}

// --- Load project files into the in-memory filesystem ---------------

const projectRoot = process.cwd();
const files = {};

function loadDir(dir, prefix) {
  for (const entry of readdirSync(dir, { withFileTypes: true })) {
    const full = join(dir, entry.name);
    const vpath = prefix + "/" + entry.name;
    if (entry.isDirectory()) {
      const skip = [
        "node_modules", ".git", ".next", "out",
        ".wrangler", "dist", ".source",
      ];
      if (skip.includes(entry.name)) continue;
      loadDir(full, vpath);
    } else if (entry.isFile()) {
      try {
        files[vpath] = readFileSync(full, "utf8");
      } catch {
        // skip binary files
      }
    }
  }
}

loadDir(projectRoot, "");
console.log(`Loaded ${Object.keys(files).length} files into sandbox`);

// --- Pre-parse config (replaces python3 config.sh) ------------------

const configPath = ".specify/extensions/tekimax-security/tekimax-security-config.yml";
let userSecretPatterns = [];
let userInlinePatterns = [];
let userGatewayAllowlist = [];

if (files["/" + configPath]) {
  // Minimal YAML list parser for the specific keys we need
  const content = files["/" + configPath];
  const parseList = (key) => {
    const re = new RegExp(
      `${key}:\\s*\\n((?:\\s+-\\s+.+\\n?)*)`,
    );
    const m = content.match(re);
    if (!m) return [];
    return m[1]
      .split("\n")
      .map((l) => l.replace(/^\s*-\s*/, "").replace(/["']/g, "").trim())
      .filter(Boolean);
  };
  userSecretPatterns = parseList("secret_patterns");
  userInlinePatterns = parseList("inline_prompt_patterns");
  userGatewayAllowlist = parseList("stack_direct_sdk");
}

// --- Inject parsed config as env vars for the bash script -----------

const bash = new Bash({
  files,
  cwd: "/",
  env: {
    HOME: "/",
    SANDBOX: "true",
    // Pass parsed config as env vars so the script doesn't need python3
    USER_SECRET_PATTERNS: userSecretPatterns.join("|"),
    USER_INLINE_PATTERNS: userInlinePatterns.join("|"),
    USER_GATEWAY_ALLOWLIST: userGatewayAllowlist.join(":"),
  },
  executionLimits: {
    maxCallDepth: 50,
    maxCommandCount: 10000,
    maxLoopIterations: 10000,
  },
});

// --- Run a simplified gate-check in the sandbox ---------------------

const specVpath = "/" + relative(projectRoot, resolve(specPath));

// Gate F: inline prompt scan (the most valuable sandbox check)
const inlinePromptRe =
  '([Yy]ou[[:space:]]+are[[:space:]]+(a|an)[[:space:]]+(helpful|AI|assistant|chatbot|expert)|<\\|system\\|>|<\\|im_start\\|>system)';

const gateF = await bash.exec(
  `if [ -d /src ]; then
    hits=$(grep -rIliE '${inlinePromptRe}' --include="*.ts" --include="*.tsx" --include="*.js" --include="*.py" /src 2>/dev/null || true)
    if [ -n "$hits" ]; then
      echo "FAIL: inline prompts found"
      echo "$hits"
      exit 1
    fi
  fi
  echo "PASS"`,
);

// Gate A: data contract section
const gateA = await bash.exec(
  `grep -qF "## 2. Data Contract" ${specVpath} 2>/dev/null || grep -qF "## Data Contract" ${specVpath} 2>/dev/null; echo $?`,
);

// Gate B: threat model with content
const gateB = await bash.exec(
  `if grep -qF "## Security / Threat Model" ${specVpath} 2>/dev/null || grep -qF "## Security" ${specVpath} 2>/dev/null; then
    if grep -qE '^\\|[[:space:]]*T[0-9]' ${specVpath} 2>/dev/null || grep -qE '^\\|[[:space:]]*(Spoofing|Tampering)' ${specVpath} 2>/dev/null; then
      echo "PASS"
    else
      echo "FAIL: STRIDE table has no threat rows"
    fi
  else
    echo "FAIL: missing threat model"
  fi`,
);

// --- Report ---------------------------------------------------------

console.log("\n--- Sandboxed Gate Check ---");
console.log(`Spec: ${specPath}`);
console.log(`Gate A (Data Contract): ${gateA.stdout.trim() === "0" ? "PASS" : "FAIL"}`);
console.log(`Gate B (Threat Model):  ${gateB.stdout.trim()}`);
console.log(`Gate F (Inline Scan):   ${gateF.stdout.trim().split("\n")[0]}`);

if (gateF.stdout.includes("FAIL")) {
  console.log("\nInline prompt findings:");
  console.log(
    gateF.stdout
      .split("\n")
      .slice(1)
      .map((l) => "  " + l)
      .join("\n"),
  );
}

// --- Write JSONL to real filesystem (outside sandbox) ---------------

const logDir = join(projectRoot, ".tekimax-security");
mkdirSync(logDir, { recursive: true });
const logPath = join(logDir, "gate-log.jsonl");

// Read previous hash for chain
let prevHash = "genesis";
if (existsSync(logPath)) {
  const lines = readFileSync(logPath, "utf8").trim().split("\n");
  if (lines.length > 0 && lines[lines.length - 1]) {
    prevHash =
      "sha256:" +
      createHash("sha256")
        .update(lines[lines.length - 1])
        .digest("hex");
  }
}

const verdict =
  gateA.stdout.trim() === "0" &&
  gateB.stdout.trim() === "PASS" &&
  gateF.stdout.trim() === "PASS"
    ? "PASS"
    : "BLOCK";

const entry = JSON.stringify({
  spec: specPath,
  phase: "before_implement",
  verdict,
  ts: new Date().toISOString(),
  user: "sandbox",
  sandbox: "just-bash",
  gates: {
    A: gateA.stdout.trim() === "0" ? "pass" : "fail",
    B: gateB.stdout.trim().startsWith("PASS") ? "pass" : "fail",
    F: gateF.stdout.trim() === "PASS" ? "pass" : "fail",
  },
  prev_hash: prevHash,
});

appendFileSync(logPath, entry + "\n");

console.log(`\nVERDICT: ${verdict}`);
console.log(`Gate log: ${logPath}`);

process.exit(verdict === "PASS" ? 0 : 1);

node sandbox/run-gate-check.mjs .specify/specs/F-001-my-feature.md

Loaded 132 files into sandbox

--- Sandboxed Gate Check ---
Spec: .specify/specs/F-001-my-feature.md
Gate A (Data Contract): PASS
Gate B (Threat Model):  PASS
Gate F (Inline Scan):   PASS

VERDICT: PASS
Gate log: .tekimax-security/gate-log.jsonl

// This returns exit 1 — /etc doesn't exist in the sandbox
const r = await bash.exec("cat /etc/passwd");
// r.exitCode === 1
// r.stderr === "cat: /etc/passwd: No such file or directory"

// Network is disabled — curl fails
const r2 = await bash.exec("curl https://example.com");
// r2.exitCode === 1