@rafter-security/cli 0.5.5 → 0.5.9

package/dist/commands/issues/index.js

@@ -0,0 +1,25 @@
+/**
+ * rafter issues — GitHub Issues integration.
+ *
+ * Subcommands:
+ *   rafter issues create --from-scan <id>     Create issues from backend scan results
+ *   rafter issues create --from-local <path>   Create issues from local scan JSON
+ *   rafter issues create --from-text           Create issue from natural text (stdin/file/inline)
+ */
+import { Command } from "commander";
+import { createFromScanCommand } from "./from-scan.js";
+import { createFromTextCommand } from "./from-text.js";
+export function createIssuesCommand() {
+    const issuesGroup = new Command("issues")
+        .description("GitHub Issues integration — create issues from scan results or text");
+    const createGroup = new Command("create")
+        .description("Create GitHub issues from scan findings or natural text");
+    createGroup.addCommand(createFromScanCommand());
+    createGroup.addCommand(createFromTextCommand());
+    // Default action for `rafter issues create` with no subcommand — show help
+    createGroup.action(() => {
+        createGroup.help();
+    });
+    issuesGroup.addCommand(createGroup);
+    return issuesGroup;
+}

package/dist/commands/issues/issue-builder.js

@@ -0,0 +1,101 @@
+/**
+ * Build structured GitHub issues from scan findings.
+ *
+ * Handles both:
+ * - Backend scan vulnerabilities (SAST/policy findings)
+ * - Local scan results (secret detection)
+ */
+import { fingerprint, embedFingerprint } from "./dedup.js";
+function severityLabel(level) {
+    const map = {
+        error: "critical",
+        critical: "critical",
+        warning: "high",
+        high: "high",
+        note: "medium",
+        medium: "medium",
+        low: "low",
+    };
+    return map[level.toLowerCase()] || "medium";
+}
+function severityEmoji(level) {
+    const sev = severityLabel(level);
+    const emojis = {
+        critical: "🔴",
+        high: "🟠",
+        medium: "🟡",
+        low: "🟢",
+    };
+    return emojis[sev] || "🟡";
+}
+export function buildFromBackendVulnerability(vuln) {
+    const sev = severityLabel(vuln.level);
+    const emoji = severityEmoji(vuln.level);
+    const fp = fingerprint(vuln.file, vuln.ruleId);
+    const title = `${emoji} [${sev.toUpperCase()}] ${vuln.ruleId}: ${truncate(vuln.message, 80)}`;
+    let body = `## Security Finding\n\n`;
+    body += `**Rule:** \`${vuln.ruleId}\`\n`;
+    body += `**Severity:** ${sev}\n`;
+    body += `**File:** \`${vuln.file}\``;
+    if (vuln.line)
+        body += ` (line ${vuln.line})`;
+    body += `\n\n`;
+    body += `### Description\n\n${vuln.message}\n\n`;
+    body += `### Remediation\n\nReview and fix the finding in \`${vuln.file}\`.\n`;
+    body += `\n---\n*Created by [Rafter CLI](https://rafter.so) — security for AI builders*\n`;
+    const labels = [
+        "security",
+        `severity:${sev}`,
+        `rule:${vuln.ruleId}`,
+    ];
+    return {
+        title,
+        body: embedFingerprint(body, fp),
+        labels,
+        fingerprint: fp,
+    };
+}
+export function buildFromLocalMatch(file, match) {
+    const sev = severityLabel(match.pattern.severity);
+    const emoji = severityEmoji(match.pattern.severity);
+    const fp = fingerprint(file, match.pattern.name);
+    const title = `${emoji} [${sev.toUpperCase()}] Secret detected: ${match.pattern.name} in ${basename(file)}`;
+    let body = `## Secret Detection\n\n`;
+    body += `**Pattern:** \`${match.pattern.name}\`\n`;
+    body += `**Severity:** ${sev}\n`;
+    body += `**File:** \`${file}\``;
+    if (match.line)
+        body += ` (line ${match.line})`;
+    body += `\n`;
+    if (match.redacted) {
+        body += `**Match:** \`${match.redacted}\`\n`;
+    }
+    body += `\n`;
+    if (match.pattern.description) {
+        body += `### Description\n\n${match.pattern.description}\n\n`;
+    }
+    body += `### Remediation\n\n`;
+    body += `1. Rotate the exposed credential immediately\n`;
+    body += `2. Remove the secret from source code\n`;
+    body += `3. Use environment variables or a secrets manager instead\n`;
+    body += `\n---\n*Created by [Rafter CLI](https://rafter.so) — security for AI builders*\n`;
+    const labels = [
+        "security",
+        "secret-detected",
+        `severity:${sev}`,
+    ];
+    return {
+        title,
+        body: embedFingerprint(body, fp),
+        labels,
+        fingerprint: fp,
+    };
+}
+function truncate(s, max) {
+    if (s.length <= max)
+        return s;
+    return s.slice(0, max - 3) + "...";
+}
+function basename(filepath) {
+    return filepath.split("/").pop() || filepath;
+}

package/dist/commands/policy/export.js

@@ -54,9 +54,14 @@ function generateCodexConfig() {
     const policy = cfg.agent?.commandPolicy;
     const blocked = policy?.blockedPatterns || [];
     const approval = policy?.requireApproval || [];
-    let toml = `# Rafter security policy for OpenAI Codex
+    let toml = `# Rafter security policy for OpenAI Codex CLI
 # Generated by: rafter policy export --format codex
-# Docs: https://docs.rafter.so/cli/pretool-hooks
+#
+# Usage: Save this file to your project root as codex-policy.toml
+# then reference it in your Codex sandbox configuration.
+#
+# For full Codex integration, run: rafter agent init
+# This auto-detects Codex CLI and installs skills to ~/.agents/skills/
 
 `;
     if (blocked.length > 0) {

package/dist/commands/scan/index.js

@@ -0,0 +1,44 @@
+/**
+ * rafter scan — top-level scan command group.
+ *
+ * Default (no subcommand): remote backend scan (same as `rafter run`)
+ * rafter scan remote:       explicit alias for remote backend scan
+ * rafter scan local [path]: local secret scanner (was `rafter agent scan`)
+ */
+import { Command } from "commander";
+import { runRemoteScan } from "../backend/run.js";
+import { createScanCommand as createLocalScanCommand } from "../agent/scan.js";
+export function createScanGroupCommand() {
+    // "local" subcommand — reuses agent/scan.ts logic, renamed
+    const localCmd = createLocalScanCommand();
+    localCmd.name("local");
+    localCmd.description("Scan files or directories for secrets (local)");
+    // "remote" subcommand — same handler as `rafter run`
+    const remoteCmd = new Command("remote")
+        .description("Trigger a remote backend security scan (explicit alias for 'rafter run')")
+        .option("-r, --repo <repo>", "org/repo (default: current)")
+        .option("-b, --branch <branch>", "branch (default: current else main)")
+        .option("-k, --api-key <key>", "API key or RAFTER_API_KEY env var")
+        .option("-f, --format <format>", "json | md", "md")
+        .option("--skip-interactive", "do not wait for scan to complete")
+        .option("--quiet", "suppress status messages")
+        .action(async (opts) => {
+        await runRemoteScan(opts);
+    });
+    // Root scan group — default action is remote backend scan
+    const scanGroup = new Command("scan")
+        .description("Scan for security issues. Default: remote backend scan. Use 'scan local' for local secret scanning.")
+        .option("-r, --repo <repo>", "org/repo (default: current)")
+        .option("-b, --branch <branch>", "branch (default: current else main)")
+        .option("-k, --api-key <key>", "API key or RAFTER_API_KEY env var")
+        .option("-f, --format <format>", "json | md", "md")
+        .option("--skip-interactive", "do not wait for scan to complete")
+        .option("--quiet", "suppress status messages");
+    scanGroup.addCommand(localCmd);
+    scanGroup.addCommand(remoteCmd);
+    // When invoked with no subcommand, run remote backend scan
+    scanGroup.action(async (opts) => {
+        await runRemoteScan(opts);
+    });
+    return scanGroup;
+}

package/dist/core/config-defaults.js

@@ -19,6 +19,30 @@ export function getDefaultConfig() {
                 claudeCode: {
                     enabled: false,
                     mcpPath: path.join(os.homedir(), ".claude", "mcp", "rafter-security.json")
+                },
+                codex: {
+                    enabled: false,
+                    skillsDir: path.join(os.homedir(), ".agents", "skills")
+                },
+                gemini: {
+                    enabled: false,
+                    configPath: path.join(os.homedir(), ".gemini", "settings.json")
+                },
+                aider: {
+                    enabled: false,
+                    configPath: path.join(os.homedir(), ".aider.conf.yml")
+                },
+                cursor: {
+                    enabled: false,
+                    mcpPath: path.join(os.homedir(), ".cursor", "mcp.json")
+                },
+                windsurf: {
+                    enabled: false,
+                    mcpPath: path.join(os.homedir(), ".codeium", "windsurf", "mcp_config.json")
+                },
+                continueDev: {
+                    enabled: false,
+                    configPath: path.join(os.homedir(), ".continue", "config.json")
                 }
             },
             skills: {

package/dist/core/config-manager.js

@@ -179,10 +179,27 @@ export class ConfigManager {
      * Migrate config to latest version
      */
     migrate(config) {
-        // For now, just ensure version is current
-        // In future, handle version-specific migrations
+        let dirty = false;
         if (config.version !== CONFIG_VERSION) {
             config.version = CONFIG_VERSION;
+            dirty = true;
+        }
+        // Fix overly broad curl/wget pipe-to-shell patterns.
+        // Old pattern: "curl.*\|.*sh" — matches any command containing "sh" after a pipe
+        // (e.g. `grep "curl\|sh"` or `git push`). Replace with word-bounded shell names.
+        const badToGood = {
+            "curl.*\\|.*sh": "curl.*\\|\\s*(bash|sh|zsh|dash)\\b",
+            "wget.*\\|.*sh": "wget.*\\|\\s*(bash|sh|zsh|dash)\\b",
+        };
+        const approval = config.agent?.commandPolicy?.requireApproval;
+        if (Array.isArray(approval)) {
+            const fixed = approval.map(p => badToGood[p] ?? p);
+            if (fixed.some((p, i) => p !== approval[i])) {
+                config.agent.commandPolicy.requireApproval = fixed;
+                dirty = true;
+            }
+        }
+        if (dirty) {
             this.save(config);
         }
         return config;

package/dist/core/pattern-engine.js

@@ -1,3 +1,7 @@
+const GENERIC_PATTERN_NAMES = new Set(["Generic API Key", "Generic Secret"]);
+const VARIABLE_NAME_RE = /^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)+$/;
+const LOWERCASE_IDENT_RE = /^[a-z][a-z0-9]*(?:_[a-z0-9]+)+$/;
+const QUOTED_VALUE_RE = /['"]([^'"]+)['"]/;
 export class PatternEngine {
     constructor(patterns) {
         this.patterns = patterns;
@@ -11,6 +15,8 @@ export class PatternEngine {
             const regex = this.createRegex(pattern.regex);
             let match;
             while ((match = regex.exec(text)) !== null) {
+                if (this.isFalsePositive(pattern, match[0]))
+                    continue;
                 matches.push({
                     pattern,
                     match: match[0],
@@ -32,6 +38,8 @@ export class PatternEngine {
                 const regex = this.createRegex(pattern.regex);
                 let match;
                 while ((match = regex.exec(line)) !== null) {
+                    if (this.isFalsePositive(pattern, match[0]))
+                        continue;
                     matches.push({
                         pattern,
                         match: match[0],
@@ -51,7 +59,7 @@ export class PatternEngine {
         let redacted = text;
         for (const pattern of this.patterns) {
             const regex = this.createRegex(pattern.regex);
-            redacted = redacted.replace(regex, (match) => this.redact(match));
+            redacted = redacted.replace(regex, (match) => this.isFalsePositive(pattern, match) ? match : this.redact(match));
         }
         return redacted;
     }
@@ -67,6 +75,23 @@ export class PatternEngine {
     getPatternsBySeverity(severity) {
         return this.patterns.filter(p => p.severity === severity);
     }
+    /**
+     * Check if a match from a generic pattern looks like a variable name
+     * rather than an actual secret value.
+     */
+    isFalsePositive(pattern, matchText) {
+        if (!GENERIC_PATTERN_NAMES.has(pattern.name))
+            return false;
+        const m = QUOTED_VALUE_RE.exec(matchText);
+        if (!m)
+            return false;
+        const value = m[1];
+        if (VARIABLE_NAME_RE.test(value))
+            return true;
+        if (LOWERCASE_IDENT_RE.test(value))
+            return true;
+        return false;
+    }
     /**
      * Create RegExp from pattern string, extracting inline flags
      */

package/dist/index.js

@@ -4,16 +4,18 @@ import * as dotenv from "dotenv";
 import { createRunCommand } from "./commands/backend/run.js";
 import { createGetCommand } from "./commands/backend/get.js";
 import { createUsageCommand } from "./commands/backend/usage.js";
+import { createScanGroupCommand } from "./commands/scan/index.js";
 import { createAgentCommand } from "./commands/agent/index.js";
 import { createCiCommand } from "./commands/ci/index.js";
 import { createHookCommand } from "./commands/hook/index.js";
 import { createMcpCommand } from "./commands/mcp/index.js";
 import { createPolicyCommand } from "./commands/policy/index.js";
 import { createCompletionCommand } from "./commands/completion.js";
+import { createIssuesCommand } from "./commands/issues/index.js";
 import { checkForUpdate } from "./utils/update-checker.js";
 import { setAgentMode } from "./utils/formatter.js";
 dotenv.config();
-const VERSION = "0.5.5";
+const VERSION = "0.5.7";
 const program = new Command()
     .name("rafter")
     .description("Rafter CLI")
@@ -26,10 +28,12 @@ program.hook("preAction", (thisCommand) => {
         setAgentMode(true);
     }
 });
-// Backend commands (existing)
+// Backend commands
 program.addCommand(createRunCommand());
 program.addCommand(createGetCommand());
 program.addCommand(createUsageCommand());
+// Scan command group (default: remote backend scan; subcommands: local, remote)
+program.addCommand(createScanGroupCommand());
 // Agent commands
 program.addCommand(createAgentCommand());
 // CI commands
@@ -40,6 +44,8 @@ program.addCommand(createHookCommand());
 program.addCommand(createMcpCommand());
 // Policy commands
 program.addCommand(createPolicyCommand());
+// GitHub Issues integration
+program.addCommand(createIssuesCommand());
 // Shell completions
 program.addCommand(createCompletionCommand());
 // Non-blocking update check — runs after command, prints to stderr

package/dist/scanners/gitleaks.js

@@ -44,11 +44,7 @@ export class GitleaksScanner {
             };
         }
         catch (e) {
-            // Clean up report
-            if (fs.existsSync(tmpReport)) {
-                fs.unlinkSync(tmpReport);
-            }
-            // Gitleaks exits with code 1 when leaks found
+            // Gitleaks exits with code 1 when leaks found — read report before cleanup
             if (e.code === 1 && fs.existsSync(tmpReport)) {
                 const results = this.parseResults(tmpReport);
                 fs.unlinkSync(tmpReport);
@@ -57,6 +53,10 @@ export class GitleaksScanner {
                     matches: results.map(r => this.convertToPatternMatch(r))
                 };
             }
+            // Clean up report for non-leak errors
+            if (fs.existsSync(tmpReport)) {
+                fs.unlinkSync(tmpReport);
+            }
             throw new Error(`Gitleaks scan failed: ${e.message}`);
         }
     }

package/dist/scanners/regex-scanner.js

@@ -57,7 +57,18 @@ export class RegexScanner {
             ".next",
             "coverage",
             ".vscode",
-            ".idea"
+            ".idea",
+            // Vendored / virtual-env / generated dirs that cause false positives
+            "vendor",
+            ".venv",
+            "venv",
+            "__pycache__",
+            ".tox",
+            ".mypy_cache",
+            ".pytest_cache",
+            "results",
+            ".terraform",
+            "bower_components"
         ];
         // Merge policy excludePaths into the exclude list
         if (options?.excludePaths) {

package/dist/scanners/secret-patterns.js

@@ -90,13 +90,13 @@ export const DEFAULT_SECRET_PATTERNS = [
     // Generic patterns
     {
         name: "Generic API Key",
-        regex: "(?i)(api[_-]?key|apikey)[\\s]*[:=][\\s]*['\"]?[0-9a-zA-Z\\-_]{16,}['\"]?",
+        regex: "(?i)(?<![a-zA-Z0-9_])(api[_-]?key|apikey)[\\s]*[:=][\\s]*['\"](?=[0-9a-zA-Z\\-_]*[0-9])[0-9a-zA-Z\\-_]{16,}['\"]",
         severity: "high",
         description: "Generic API key pattern detected"
     },
     {
         name: "Generic Secret",
-        regex: "(?i)(secret|password|passwd|pwd)[\\s]*[:=][\\s]*['\"]?[0-9a-zA-Z\\-_!@#$%^&*()]{8,}['\"]?",
+        regex: "(?i)(?<![a-zA-Z0-9_])(secret|password|passwd|pwd)[\\s]*[:=][\\s]*['\"](?=[^\\s'\"]*[0-9])(?=[^\\s'\"]*[a-zA-Z])[0-9a-zA-Z\\-_!@#$%^&*()]{12,}['\"]",
         severity: "high",
         description: "Generic secret pattern detected"
     },
@@ -108,7 +108,7 @@ export const DEFAULT_SECRET_PATTERNS = [
     },
     {
         name: "Bearer Token",
-        regex: "(?i)bearer[\\s]+[a-zA-Z0-9\\-_\\.=]+",
+        regex: "(?i)bearer[\\s]+(?=[a-zA-Z0-9\\-_\\.=]*[0-9])(?=[a-zA-Z0-9\\-_\\.=]*[a-zA-Z])[a-zA-Z0-9\\-_\\.=]{20,}",
         severity: "high",
         description: "Bearer token detected"
     },

package/dist/utils/binary-manager.js

@@ -75,10 +75,10 @@ export class BinaryManager {
             return false;
         }
         try {
-            const { stdout } = await execAsync(`"${this.getGitleaksPath()}" version`, {
-                timeout: 5000
-            });
-            return stdout.includes("gitleaks version");
+            // execAsync rejects on non-zero exit, so reaching here means exit code 0.
+            // Accept any successful exit — don't require specific stdout content.
+            await execAsync(`"${this.getGitleaksPath()}" version`, { timeout: 5000 });
+            return true;
         }
         catch {
             return false;
@@ -91,8 +91,9 @@ export class BinaryManager {
         const gitleaksPath = binaryPath ?? this.getGitleaksPath();
         try {
             const { stdout, stderr } = await execAsync(`"${gitleaksPath}" version`, { timeout: 5000 });
-            const ok = stdout.includes("gitleaks version");
-            return { ok, stdout: stdout.trim(), stderr: stderr.trim() };
+            // execAsync rejects on non-zero exit, so reaching here means exit code 0.
+            // Accept any successful exit — don't require specific stdout content.
+            return { ok: true, stdout: stdout.trim(), stderr: stderr.trim() };
         }
         catch (e) {
             const err = e;

package/dist/utils/skill-manager.js

@@ -156,15 +156,17 @@ export class SkillManager {
     async installRafterSkillVerbose(force = false) {
         const skillPath = this.getRafterSkillPath();
         const sourcePath = this.getRafterSkillSourcePath();
-        if (!this.isOpenClawInstalled()) {
-            return { ok: false, sourcePath, destPath: skillPath, error: `OpenClaw skills directory not found: ${this.getOpenClawSkillsDir()}` };
+        // Check if ~/.openclaw exists (the parent dir), not just the skills subdir
+        const openclawDir = path.join(os.homedir(), ".openclaw");
+        if (!fs.existsSync(openclawDir)) {
+            return { ok: false, sourcePath, destPath: skillPath, error: `OpenClaw not found: ${openclawDir}` };
         }
         // Check if already installed and not forcing
         if (!force && this.isRafterSkillInstalled()) {
             return { ok: true, sourcePath, destPath: skillPath };
         }
         try {
-            // Ensure skills directory exists
+            // Ensure skills directory exists (may not exist on fresh OpenClaw installs)
             const skillsDir = this.getOpenClawSkillsDir();
             if (!fs.existsSync(skillsDir)) {
                 fs.mkdirSync(skillsDir, { recursive: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rafter-security/cli",
-  "version": "0.5.5",
+  "version": "0.5.9",
   "type": "module",
   "bin": {
     "rafter": "./dist/index.js"
@@ -22,6 +22,7 @@
     "@modelcontextprotocol/sdk": "^1.12.0",
     "axios": "^1.6.8",
     "chalk": "^5.3.0",
+    "chokidar": "^5.0.0",
     "commander": "^11.1.0",
     "dotenv": "^16.4.5",
     "js-yaml": "^4.1.0",

package/resources/pre-commit-hook.sh

@@ -27,14 +27,14 @@ fi
 echo "🔍 Rafter: Scanning staged files for secrets..."
 
 # Scan staged files
-rafter agent scan --staged --quiet
+rafter scan local --staged --quiet
 
 EXIT_CODE=$?
 
 if [ $EXIT_CODE -ne 0 ]; then
     echo -e "${RED}❌ Commit blocked: Secrets detected in staged files${NC}"
     echo ""
-    echo "   Run: rafter agent scan --staged"
+    echo "   Run: rafter scan local --staged"
     echo "   To see details and remediate."
     echo ""
     echo "   To bypass (NOT recommended): git commit --no-verify"

package/resources/pre-push-hook.sh

@@ -38,7 +38,7 @@ while read local_ref local_sha remote_ref remote_sha; do
 
     echo "🔍 Rafter: Scanning commits being pushed ($local_ref)..."
 
-    rafter agent scan --diff "$ref_arg" --quiet
+    rafter scan local --diff "$ref_arg" --quiet
     EXIT_CODE=$?
 
     if [ $EXIT_CODE -ne 0 ]; then
@@ -49,7 +49,7 @@ done
 if [ $FOUND_SECRETS -ne 0 ]; then
     echo -e "${RED}❌ Push blocked: Secrets detected in commits being pushed${NC}"
     echo ""
-    echo "   Run: rafter agent scan --diff <remote-sha>"
+    echo "   Run: rafter scan local --diff <remote-sha>"
     echo "   To see details and remediate."
     echo ""
     echo "   To bypass (NOT recommended): git push --no-verify"

package/resources/rafter-security-skill.md

@@ -6,8 +6,8 @@ openclaw:
   always: false
   requires:
     bins: [rafter]
-version: 0.4.0
-last_updated: 2026-02-03
+version: 0.5.8
+last_updated: 2026-03-04
 ---
 
 # Rafter Security
@@ -32,7 +32,7 @@ Rafter provides real-time security checks for agent operations:
 Scan files for secrets before committing.
 
 ```bash
-rafter agent scan <path>
+rafter scan local <path>
 ```
 
 **When to use:**
@@ -57,21 +57,17 @@ rafter agent scan <path>
 
 ### /rafter-bash
 
-Execute shell command with security validation.
+Explicitly run a command through Rafter's security validator.
 
 ```bash
 rafter agent exec <command>
 ```
 
-**Features:**
-- Blocks destructive commands (rm -rf /, fork bombs)
-- Requires approval for dangerous operations
-- Logs all command attempts
-- Scans staged files before git commits
+**When to use:** Only needed in environments where the `PreToolUse` hook is not installed. When `rafter agent init` has been run, all shell commands are validated automatically — you do not need to route commands through this.
 
 **Risk levels:**
 - **Critical** (blocked): rm -rf /, fork bombs, dd to /dev
-- **High** (approval required): sudo rm, chmod 777, curl|bash
+- **High** (approval required): sudo rm, chmod 777, curl | bash
 - **Medium** (approval on moderate+): sudo, chmod, kill -9
 - **Low** (allowed): npm install, git commit, ls
 
@@ -269,7 +265,7 @@ Configure with: `rafter agent config set agent.riskLevel moderate`
 
 ## Best Practices
 
-1. **Always scan before commits**: Run `rafter agent scan` before `git commit`
+1. **Always scan before commits**: Run `rafter scan local` before `git commit`
 2. **Audit untrusted skills**: Run `/rafter-audit-skill` on skills from unknown sources before installation
 3. **Review audit logs**: Check `rafter agent audit` after suspicious activity
 4. **Keep patterns updated**: Patterns updated automatically with CLI updates