clawguard-cli 0.1.0 → 0.2.1

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import fs9 from "fs";
+import fs11 from "fs";
 import { Command } from "commander";
 import chalk3 from "chalk";
 
@@ -65,7 +65,7 @@ function getInfoCount(result) {
 
 // src/reporter.ts
 import chalk from "chalk";
-var VERSION = "0.1.0";
+var VERSION = "0.2.0";
 var SEVERITY_COLORS = {
   [Severity.CRITICAL]: chalk.red.bold,
   [Severity.HIGH]: chalk.yellow.bold,
@@ -177,16 +177,16 @@ function printJson(result) {
 
 // src/scanner.ts
 import crypto from "crypto";
-import fs8 from "fs";
-import path8 from "path";
-import os2 from "os";
-import JSON54 from "json5";
+import fs10 from "fs";
+import path11 from "path";
+import os3 from "os";
+import JSON55 from "json5";
 import chalk2 from "chalk";
 
 // src/checks/credentials.ts
-import fs from "fs";
-import path from "path";
-import JSON5 from "json5";
+import fs2 from "fs";
+import path2 from "path";
+import JSON52 from "json5";
 
 // src/patterns.ts
 var API_KEY_PATTERNS = [
@@ -206,7 +206,8 @@ var API_KEY_PATTERNS = [
   ["OpenRouter API key", /sk-or-v1-[a-f0-9]{64}/],
   ["Google API key", /AIza[0-9A-Za-z_-]{35}/],
   ["Stripe Secret key", /sk_live_[a-zA-Z0-9]{20,}/],
-  ["Generic Bearer token", /Bearer\s+[a-zA-Z0-9_.-]{20,}/]
+  ["Generic Bearer token", /Bearer\s+[a-zA-Z0-9_.-]{20,}/],
+  ["Brave Search API key", /BSA[a-zA-Z0-9]{20,}/]
 ];
 var ENV_VAR_PATTERN = /\$\{[A-Z_][A-Z0-9_]*\}/;
 var MALICIOUS_PATTERNS = [
@@ -258,6 +259,27 @@ var SUSPICIOUS_BINS = [
   "wireshark",
   "tshark"
 ];
+var PROVIDER_ENV_MAP = {
+  anthropic: "ANTHROPIC_API_KEY",
+  openai: "OPENAI_API_KEY",
+  groq: "GROQ_API_KEY",
+  xai: "XAI_API_KEY",
+  openrouter: "OPENROUTER_API_KEY",
+  google: "GOOGLE_API_KEY",
+  mistral: "MISTRAL_API_KEY",
+  deepseek: "DEEPSEEK_API_KEY",
+  cohere: "COHERE_API_KEY",
+  together: "TOGETHER_API_KEY"
+};
+var PROVIDER_LIMITS = {
+  groq: { tpm: 6e3, rpm: 30, note: "Groq free tier: 6K TPM, 30 RPM" },
+  openrouter: {
+    tpm: 1e5,
+    rpm: 8,
+    note: "OpenRouter free tier: ~8 RPM"
+  }
+};
+var OPENCLAW_SYSTEM_PROMPT_TOKENS = 12600;
 var MEMORY_POISONING_PATTERNS = [
   [
     "Hidden instruction injection",
@@ -281,7 +303,12 @@ var MEMORY_POISONING_PATTERNS = [
   ]
 ];
 
-// src/checks/credentials.ts
+// src/utils.ts
+import { execFileSync } from "child_process";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import JSON5 from "json5";
 function scanFileForKeys(filepath) {
   const hits = [];
   try {
@@ -293,7 +320,10 @@ function scanFileForKeys(filepath) {
         continue;
       }
       for (const [keyName, pattern] of API_KEY_PATTERNS) {
-        const globalPattern = new RegExp(pattern.source, pattern.flags + (pattern.flags.includes("g") ? "" : "g"));
+        const globalPattern = new RegExp(
+          pattern.source,
+          pattern.flags + (pattern.flags.includes("g") ? "" : "g")
+        );
         let match;
         while ((match = globalPattern.exec(line)) !== null) {
           const matched = match[0];
@@ -306,45 +336,80 @@ function scanFileForKeys(filepath) {
   }
   return hits;
 }
+function parseConfig(configPath) {
+  try {
+    const content = fs.readFileSync(configPath, { encoding: "utf-8" });
+    return JSON5.parse(content);
+  } catch {
+    return null;
+  }
+}
+function findFilesRecursive(dir, match, mode = "extension") {
+  const results = [];
+  if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) {
+    return results;
+  }
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        results.push(...findFilesRecursive(fullPath, match, mode));
+      } else if (entry.isFile()) {
+        if (mode === "extension" && entry.name.endsWith(match)) {
+          results.push(fullPath);
+        } else if (mode === "exact" && entry.name === match) {
+          results.push(fullPath);
+        }
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+function isDockerAvailable() {
+  try {
+    execFileSync("which", ["docker"], { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getTotalMemoryGB() {
+  return os.totalmem() / (1024 * 1024 * 1024);
+}
 function getRelativePath(filePath, basePath) {
   const parentDir = path.dirname(basePath);
   return path.relative(parentDir, filePath);
 }
+
+// src/checks/credentials.ts
 function checkCredentials(openclawPath) {
   const findings = [];
   const configFiles = [
-    path.join(openclawPath, "openclaw.json"),
-    path.join(openclawPath, "credentials", "profiles.json")
+    path2.join(openclawPath, "openclaw.json"),
+    path2.join(openclawPath, "credentials", "profiles.json")
   ];
-  const agentsDir = path.join(openclawPath, "agents");
-  if (fs.existsSync(agentsDir) && fs.statSync(agentsDir).isDirectory()) {
+  const agentsDir = path2.join(openclawPath, "agents");
+  if (fs2.existsSync(agentsDir) && fs2.statSync(agentsDir).isDirectory()) {
     try {
-      for (const agentEntry of fs.readdirSync(agentsDir)) {
-        const authFile = path.join(
+      for (const agentEntry of fs2.readdirSync(agentsDir)) {
+        const authFile = path2.join(
           agentsDir,
           agentEntry,
           "agent",
           "auth-profiles.json"
         );
-        if (fs.existsSync(authFile)) {
+        if (fs2.existsSync(authFile)) {
           configFiles.push(authFile);
         }
       }
     } catch {
     }
   }
-  const envFiles = [
-    path.join(openclawPath, ".env"),
-    path.join(openclawPath, "workspace", ".env")
-  ];
-  for (const envFile of envFiles) {
-    if (fs.existsSync(envFile)) {
-      configFiles.push(envFile);
-    }
-  }
   const allHits = [];
   for (const filepath of configFiles) {
-    if (fs.existsSync(filepath)) {
+    if (fs2.existsSync(filepath)) {
       const hits = scanFileForKeys(filepath);
       for (const { keyName, masked, lineNum } of hits) {
         const relPath = getRelativePath(filepath, openclawPath);
@@ -356,16 +421,16 @@ function checkCredentials(openclawPath) {
     findings.push(
       createFinding({
         severity: Severity.CRITICAL,
-        title: `${allHits.length} API key(s) stored in plaintext`,
+        title: `${allHits.length} API key(s) stored in plaintext config files`,
         details: allHits.slice(0, 10),
         // Show max 10
-        fix: 'Use environment variables: "apiKey": "${ANTHROPIC_API_KEY}" instead of raw strings',
+        fix: 'Move keys to .env and use env var refs: "apiKey": "${ANTHROPIC_API_KEY}"',
         category: "credentials"
       })
     );
   }
   const bakWithKeys = [];
-  const bakFiles = findFilesRecursive(openclawPath, ".bak");
+  const bakFiles = findFilesRecursive(openclawPath, ".bak", "extension");
   for (const bakFile of bakFiles) {
     const hits = scanFileForKeys(bakFile);
     if (hits.length > 0) {
@@ -384,11 +449,11 @@ function checkCredentials(openclawPath) {
     );
   }
   const transcriptHits = [];
-  if (fs.existsSync(agentsDir) && fs.statSync(agentsDir).isDirectory()) {
-    const jsonlFiles = findFilesRecursive(agentsDir, ".jsonl");
+  if (fs2.existsSync(agentsDir) && fs2.statSync(agentsDir).isDirectory()) {
+    const jsonlFiles = findFilesRecursive(agentsDir, ".jsonl", "extension");
     for (const jsonlFile of jsonlFiles) {
       try {
-        const content = fs.readFileSync(jsonlFile, { encoding: "utf-8" });
+        const content = fs2.readFileSync(jsonlFile, { encoding: "utf-8" });
         const lines = content.split("\n");
         let found = false;
         for (let i = 0; i < Math.min(lines.length, 501); i++) {
@@ -419,11 +484,11 @@ function checkCredentials(openclawPath) {
       })
     );
   }
-  const configFile = path.join(openclawPath, "openclaw.json");
-  if (fs.existsSync(configFile)) {
+  const configFile = path2.join(openclawPath, "openclaw.json");
+  if (fs2.existsSync(configFile)) {
     try {
-      const content = fs.readFileSync(configFile, { encoding: "utf-8" });
-      const config = JSON5.parse(content);
+      const content = fs2.readFileSync(configFile, { encoding: "utf-8" });
+      const config = JSON52.parse(content);
       const loggingConfig = config.logging ?? {};
       const redact = loggingConfig.redactSensitive;
       if (redact === void 0 || redact === null || redact === "off") {
@@ -442,58 +507,41 @@ function checkCredentials(openclawPath) {
   }
   return findings;
 }
-function findFilesRecursive(dir, ext) {
-  const results = [];
-  if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) {
-    return results;
+
+// src/checks/gateway.ts
+import { execSync } from "child_process";
+import fs3 from "fs";
+import path3 from "path";
+import JSON53 from "json5";
+function checkPortExposed(port) {
+  if (process.platform !== "linux") {
+    return false;
   }
   try {
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        results.push(...findFilesRecursive(fullPath, ext));
-      } else if (entry.isFile() && entry.name.endsWith(ext)) {
-        results.push(fullPath);
+    const output = execSync(`ss -tlnp`, { encoding: "utf-8", timeout: 5e3 });
+    const lines = output.split("\n");
+    for (const line of lines) {
+      const columns = line.trim().split(/\s+/);
+      if (columns.length < 5) continue;
+      const localAddr = columns[3];
+      const lastColon = localAddr.lastIndexOf(":");
+      if (lastColon === -1) continue;
+      const portStr = localAddr.substring(lastColon + 1);
+      if (parseInt(portStr, 10) !== port) continue;
+      const host = localAddr.substring(0, lastColon);
+      if (host === "0.0.0.0" || host === "*" || host === "[::]" || host === "::") {
+        return true;
       }
     }
+    return false;
   } catch {
+    return false;
   }
-  return results;
-}
-
-// src/checks/gateway.ts
-import fs2 from "fs";
-import net from "net";
-import path2 from "path";
-import JSON52 from "json5";
-function checkPortExposed(port) {
-  return new Promise((resolve) => {
-    const socket = new net.Socket();
-    socket.setTimeout(1e3);
-    socket.on("connect", () => {
-      socket.destroy();
-      resolve(true);
-    });
-    socket.on("timeout", () => {
-      socket.destroy();
-      resolve(false);
-    });
-    socket.on("error", () => {
-      socket.destroy();
-      resolve(false);
-    });
-    try {
-      socket.connect(port, "0.0.0.0");
-    } catch {
-      resolve(false);
-    }
-  });
 }
-async function checkGateway(openclawPath) {
+function checkGateway(openclawPath) {
   const findings = [];
-  const configFile = path2.join(openclawPath, "openclaw.json");
-  if (!fs2.existsSync(configFile)) {
+  const configFile = path3.join(openclawPath, "openclaw.json");
+  if (!fs3.existsSync(configFile)) {
     findings.push(
       createFinding({
         severity: Severity.INFO,
@@ -506,8 +554,8 @@ async function checkGateway(openclawPath) {
   }
   let config;
   try {
-    const content = fs2.readFileSync(configFile, { encoding: "utf-8" });
-    config = JSON52.parse(content);
+    const content = fs3.readFileSync(configFile, { encoding: "utf-8" });
+    config = JSON53.parse(content);
   } catch {
     findings.push(
       createFinding({
@@ -561,7 +609,7 @@ async function checkGateway(openclawPath) {
     );
   }
   const port = gateway.port ?? 18789;
-  const portExposed = await checkPortExposed(port);
+  const portExposed = checkPortExposed(port);
   if (portExposed) {
     findings.push(
       createFinding({
@@ -576,32 +624,83 @@ async function checkGateway(openclawPath) {
       })
     );
   }
+  const ramGB = getTotalMemoryGB();
+  const nodeOptions = process.env.NODE_OPTIONS ?? "";
+  if (ramGB < 2) {
+    if (!nodeOptions.includes("max-old-space-size")) {
+      findings.push(
+        createFinding({
+          severity: Severity.HIGH,
+          title: `System has only ${ramGB.toFixed(1)}GB RAM without NODE_OPTIONS set`,
+          details: [
+            `Total RAM: ${ramGB.toFixed(1)}GB`,
+            "OpenClaw may be killed by OOM without memory limits",
+            "NODE_OPTIONS environment variable is not set"
+          ],
+          fix: 'Set NODE_OPTIONS="--max-old-space-size=512" in your service file or shell profile',
+          category: "gateway"
+        })
+      );
+    }
+  }
+  if (process.platform === "linux") {
+    const serviceFiles = [
+      "/etc/systemd/system/openclaw.service",
+      "/etc/systemd/system/openclaw-gateway.service"
+    ];
+    for (const serviceFile of serviceFiles) {
+      if (!fs3.existsSync(serviceFile)) continue;
+      try {
+        const serviceContent = fs3.readFileSync(serviceFile, { encoding: "utf-8" });
+        if (ramGB < 2 && !serviceContent.includes("NODE_OPTIONS")) {
+          findings.push(
+            createFinding({
+              severity: Severity.HIGH,
+              title: `Systemd service missing NODE_OPTIONS (${path3.basename(serviceFile)})`,
+              details: [
+                `Low RAM system (${ramGB.toFixed(1)}GB) but service has no NODE_OPTIONS`,
+                "Add Environment=NODE_OPTIONS=--max-old-space-size=512 to [Service] section"
+              ],
+              fix: `Edit ${serviceFile} and add NODE_OPTIONS, then systemctl daemon-reload`,
+              category: "gateway"
+            })
+          );
+        }
+        if (serviceContent.includes("Restart=always") && !serviceContent.includes("RestartSec")) {
+          findings.push(
+            createFinding({
+              severity: Severity.MEDIUM,
+              title: `Systemd service has Restart=always without RestartSec (${path3.basename(serviceFile)})`,
+              details: [
+                "Service will restart immediately on crash, potentially causing a restart storm",
+                "Add RestartSec=5 to [Service] section to prevent rapid restarts"
+              ],
+              fix: `Add RestartSec=5 to ${serviceFile} [Service] section`,
+              category: "gateway"
+            })
+          );
+        }
+      } catch {
+      }
+    }
+  }
   return findings;
 }
 
 // src/checks/sandbox.ts
-import { execFileSync } from "child_process";
-import fs3 from "fs";
-import path3 from "path";
-import JSON53 from "json5";
-function isDockerAvailable() {
-  try {
-    execFileSync("which", ["docker"], { stdio: "pipe" });
-    return true;
-  } catch {
-    return false;
-  }
-}
+import fs4 from "fs";
+import path4 from "path";
+import JSON54 from "json5";
 function checkSandbox(openclawPath) {
   const findings = [];
-  const configFile = path3.join(openclawPath, "openclaw.json");
-  if (!fs3.existsSync(configFile)) {
+  const configFile = path4.join(openclawPath, "openclaw.json");
+  if (!fs4.existsSync(configFile)) {
     return findings;
   }
   let config;
   try {
-    const content = fs3.readFileSync(configFile, { encoding: "utf-8" });
-    config = JSON53.parse(content);
+    const content = fs4.readFileSync(configFile, { encoding: "utf-8" });
+    config = JSON54.parse(content);
   } catch {
     return findings;
   }
@@ -670,7 +769,22 @@ function checkSandbox(openclawPath) {
     );
   }
   const execSecurity = execConfig.security;
-  if (execSecurity !== "allowlist") {
+  const validExecSecurity = ["deny", "allowlist", "full"];
+  if (execSecurity && !validExecSecurity.includes(execSecurity)) {
+    findings.push(
+      createFinding({
+        severity: Severity.HIGH,
+        title: `Invalid tools.exec.security value: "${execSecurity}"`,
+        details: [
+          `tools.exec.security = "${execSecurity}"`,
+          `Valid values: ${validExecSecurity.join(", ")}`,
+          "Invalid value may cause unpredictable behavior"
+        ],
+        fix: 'Set tools.exec.security to "deny", "allowlist", or "full" in openclaw.json',
+        category: "sandbox"
+      })
+    );
+  } else if (execSecurity !== "allowlist") {
     findings.push(
       createFinding({
         severity: Severity.MEDIUM,
@@ -684,6 +798,26 @@ function checkSandbox(openclawPath) {
       })
     );
   }
+  const commands = config.commands ?? {};
+  const nativeSkills = commands.nativeSkills;
+  if (nativeSkills !== void 0 && nativeSkills !== null) {
+    const validNativeSkills = [false, "auto", "off"];
+    if (!validNativeSkills.includes(nativeSkills)) {
+      findings.push(
+        createFinding({
+          severity: Severity.MEDIUM,
+          title: `Invalid commands.nativeSkills value: "${String(nativeSkills)}"`,
+          details: [
+            `commands.nativeSkills = "${String(nativeSkills)}"`,
+            'Valid values: false, "auto", "off"',
+            "Invalid value may cause skill execution issues"
+          ],
+          fix: 'Set commands.nativeSkills to false, "auto", or "off" in openclaw.json',
+          category: "sandbox"
+        })
+      );
+    }
+  }
   if (dockerAvailable) {
     findings.push(
       createFinding({
@@ -700,48 +834,44 @@ function checkSandbox(openclawPath) {
 }
 
 // src/checks/permissions.ts
-import fs4 from "fs";
-import path4 from "path";
+import fs5 from "fs";
+import path5 from "path";
 function getPermissionOctal(filepath) {
-  const stats = fs4.statSync(filepath);
+  const stats = fs5.statSync(filepath);
   return "0o" + (stats.mode & 511).toString(8);
 }
 function isWorldReadable(filepath) {
-  const stats = fs4.statSync(filepath);
+  const stats = fs5.statSync(filepath);
   return (stats.mode & 4) !== 0;
 }
 function isGroupReadable(filepath) {
-  const stats = fs4.statSync(filepath);
+  const stats = fs5.statSync(filepath);
   return (stats.mode & 32) !== 0;
 }
-function getRelativePath2(filePath, basePath) {
-  const parentDir = path4.dirname(basePath);
-  return path4.relative(parentDir, filePath);
-}
 function checkPermissions(openclawPath) {
   const findings = [];
   const tooOpen = [];
-  if (fs4.existsSync(openclawPath)) {
+  if (fs5.existsSync(openclawPath)) {
     const perms = getPermissionOctal(openclawPath);
     if (isWorldReadable(openclawPath) || isGroupReadable(openclawPath)) {
       tooOpen.push(`${openclawPath} is ${perms} (should be 0o700)`);
     }
   }
   const sensitiveFiles = [
-    path4.join(openclawPath, "openclaw.json"),
-    path4.join(openclawPath, ".env"),
-    path4.join(openclawPath, "credentials", "profiles.json")
+    path5.join(openclawPath, "openclaw.json"),
+    path5.join(openclawPath, ".env"),
+    path5.join(openclawPath, "credentials", "profiles.json")
   ];
-  const agentsDir = path4.join(openclawPath, "agents");
-  if (fs4.existsSync(agentsDir) && fs4.statSync(agentsDir).isDirectory()) {
-    const authFiles = findFilesRecursive2(agentsDir, "auth-profiles.json");
+  const agentsDir = path5.join(openclawPath, "agents");
+  if (fs5.existsSync(agentsDir) && fs5.statSync(agentsDir).isDirectory()) {
+    const authFiles = findFilesRecursive(agentsDir, "auth-profiles.json", "exact");
     sensitiveFiles.push(...authFiles);
   }
   for (const filepath of sensitiveFiles) {
-    if (fs4.existsSync(filepath)) {
+    if (fs5.existsSync(filepath)) {
       const perms = getPermissionOctal(filepath);
       if (isWorldReadable(filepath) || isGroupReadable(filepath)) {
-        const relPath = getRelativePath2(filepath, openclawPath);
+        const relPath = getRelativePath(filepath, openclawPath);
         tooOpen.push(`${relPath} is ${perms} (should be 0o600)`);
       }
     }
@@ -759,31 +889,12 @@ function checkPermissions(openclawPath) {
   }
   return findings;
 }
-function findFilesRecursive2(dir, filename) {
-  const results = [];
-  if (!fs4.existsSync(dir) || !fs4.statSync(dir).isDirectory()) {
-    return results;
-  }
-  try {
-    const entries = fs4.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path4.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        results.push(...findFilesRecursive2(fullPath, filename));
-      } else if (entry.isFile() && entry.name === filename) {
-        results.push(fullPath);
-      }
-    }
-  } catch {
-  }
-  return results;
-}
 
 // src/checks/version.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import fs5 from "fs";
-import path5 from "path";
-import os from "os";
+import fs6 from "fs";
+import path6 from "path";
+import os2 from "os";
 var CVES = [
   {
     id: "CVE-2026-25253",
@@ -870,8 +981,8 @@ function checkVersion(_openclawPath) {
     }
   } else {
     const pkgPaths = [
-      path5.join(
-        os.homedir(),
+      path6.join(
+        os2.homedir(),
         ".bun",
         "install",
         "global",
@@ -883,9 +994,9 @@ function checkVersion(_openclawPath) {
     ];
     let found = false;
     for (const pkgPath of pkgPaths) {
-      if (fs5.existsSync(pkgPath)) {
+      if (fs6.existsSync(pkgPath)) {
         try {
-          const content = fs5.readFileSync(pkgPath, { encoding: "utf-8" });
+          const content = fs6.readFileSync(pkgPath, { encoding: "utf-8" });
           const pkg = JSON.parse(content);
           ocVersion = pkg.version ?? "unknown";
           findings.push(
@@ -943,11 +1054,11 @@ function checkVersion(_openclawPath) {
 }
 
 // src/checks/skills.ts
-import fs6 from "fs";
-import path6 from "path";
+import fs7 from "fs";
+import path7 from "path";
 import yaml from "js-yaml";
 function parseSkillMd(skillPath) {
-  const content = fs6.readFileSync(skillPath, { encoding: "utf-8" });
+  const content = fs7.readFileSync(skillPath, { encoding: "utf-8" });
   let frontmatter = {};
   let body = content;
   if (content.startsWith("---")) {
@@ -1044,18 +1155,18 @@ function checkSkillMalicious(name, body) {
 function checkSkills(openclawPath) {
   const findings = [];
   const skillDirs = [
-    path6.join(openclawPath, "workspace", "skills"),
-    path6.join(openclawPath, "skills")
+    path7.join(openclawPath, "workspace", "skills"),
+    path7.join(openclawPath, "skills")
   ];
   let totalSkills = 0;
   let flaggedSkills = 0;
   for (const skillsRoot of skillDirs) {
-    if (!fs6.existsSync(skillsRoot) || !fs6.statSync(skillsRoot).isDirectory()) {
+    if (!fs7.existsSync(skillsRoot) || !fs7.statSync(skillsRoot).isDirectory()) {
       continue;
     }
     let entries;
     try {
-      entries = fs6.readdirSync(skillsRoot, { withFileTypes: true });
+      entries = fs7.readdirSync(skillsRoot, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -1063,8 +1174,8 @@ function checkSkills(openclawPath) {
       if (!entry.isDirectory()) {
         continue;
       }
-      const skillMdPath = path6.join(skillsRoot, entry.name, "SKILL.md");
-      if (!fs6.existsSync(skillMdPath)) {
+      const skillMdPath = path7.join(skillsRoot, entry.name, "SKILL.md");
+      if (!fs7.existsSync(skillMdPath)) {
         continue;
       }
       totalSkills++;
@@ -1079,7 +1190,7 @@ function checkSkills(openclawPath) {
             details: [
               "This publisher name is known to be associated with malicious skills"
             ],
-            fix: `REMOVE IMMEDIATELY: rm -rf ${path6.join(skillsRoot, entry.name)}`,
+            fix: `REMOVE IMMEDIATELY: rm -rf ${path7.join(skillsRoot, entry.name)}`,
             category: "skills"
           })
         );
@@ -1119,23 +1230,23 @@ function checkSkills(openclawPath) {
 }
 
 // src/checks/memory.ts
-import fs7 from "fs";
-import path7 from "path";
+import fs8 from "fs";
+import path8 from "path";
 function checkMemory(openclawPath) {
   const findings = [];
-  const workspace = path7.join(openclawPath, "workspace");
-  if (!fs7.existsSync(workspace) || !fs7.statSync(workspace).isDirectory()) {
+  const workspace = path8.join(openclawPath, "workspace");
+  if (!fs8.existsSync(workspace) || !fs8.statSync(workspace).isDirectory()) {
     return findings;
   }
   const identityFiles = [
-    path7.join(workspace, "SOUL.md"),
-    path7.join(workspace, "IDENTITY.md")
+    path8.join(workspace, "SOUL.md"),
+    path8.join(workspace, "IDENTITY.md")
   ];
   for (const filepath of identityFiles) {
-    if (!fs7.existsSync(filepath)) {
+    if (!fs8.existsSync(filepath)) {
       continue;
     }
-    const content = fs7.readFileSync(filepath, { encoding: "utf-8" });
+    const content = fs8.readFileSync(filepath, { encoding: "utf-8" });
     const detected = [];
     for (const [patternName, pattern] of MEMORY_POISONING_PATTERNS) {
       const matches = content.match(pattern);
@@ -1148,7 +1259,7 @@ function checkMemory(openclawPath) {
       findings.push(
         createFinding({
           severity: Severity.HIGH,
-          title: `Potential memory poisoning in ${path7.basename(filepath)}`,
+          title: `Potential memory poisoning in ${path8.basename(filepath)}`,
           details: detected,
           fix: `Review ${filepath} for injected instructions and restore from backup`,
           category: "memory"
@@ -1156,14 +1267,14 @@ function checkMemory(openclawPath) {
       );
     }
   }
-  const memoryFiles = [path7.join(workspace, "MEMORY.md")];
-  const memoryDir = path7.join(workspace, "memory");
-  if (fs7.existsSync(memoryDir) && fs7.statSync(memoryDir).isDirectory()) {
+  const memoryFiles = [path8.join(workspace, "MEMORY.md")];
+  const memoryDir = path8.join(workspace, "memory");
+  if (fs8.existsSync(memoryDir) && fs8.statSync(memoryDir).isDirectory()) {
     try {
-      const entries = fs7.readdirSync(memoryDir);
+      const entries = fs8.readdirSync(memoryDir);
       for (const entry of entries) {
         if (entry.endsWith(".md")) {
-          memoryFiles.push(path7.join(memoryDir, entry));
+          memoryFiles.push(path8.join(memoryDir, entry));
         }
       }
     } catch {
@@ -1171,13 +1282,13 @@ function checkMemory(openclawPath) {
   }
   const leakedIn = [];
   for (const filepath of memoryFiles) {
-    if (!fs7.existsSync(filepath)) {
+    if (!fs8.existsSync(filepath)) {
       continue;
     }
-    const content = fs7.readFileSync(filepath, { encoding: "utf-8" });
+    const content = fs8.readFileSync(filepath, { encoding: "utf-8" });
     for (const [keyName, pattern] of API_KEY_PATTERNS) {
       if (pattern.test(content)) {
-        leakedIn.push(`${path7.basename(filepath)} contains ${keyName}`);
+        leakedIn.push(`${path8.basename(filepath)} contains ${keyName}`);
         break;
       }
     }
@@ -1196,6 +1307,257 @@ function checkMemory(openclawPath) {
   return findings;
 }
 
+// src/checks/agents.ts
+import fs9 from "fs";
+import path9 from "path";
+function checkAgents(openclawPath) {
+  const findings = [];
+  const agentsDir = path9.join(openclawPath, "agents");
+  if (!fs9.existsSync(agentsDir) || !fs9.statSync(agentsDir).isDirectory()) {
+    return findings;
+  }
+  const globalConfig = parseConfig(
+    path9.join(openclawPath, "openclaw.json")
+  );
+  const globalModel = getGlobalModel(globalConfig);
+  let agentCount = 0;
+  let issueCount = 0;
+  let entries;
+  try {
+    entries = fs9.readdirSync(agentsDir, { withFileTypes: true });
+  } catch {
+    return findings;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const modelsJsonPath = path9.join(
+      agentsDir,
+      entry.name,
+      "agent",
+      "models.json"
+    );
+    if (!fs9.existsSync(modelsJsonPath)) continue;
+    agentCount++;
+    const agentName = entry.name;
+    const keyHits = scanFileForKeys(modelsJsonPath);
+    const openclawUsesEnvRefs = keyHits.length > 0 ? checkOpenclawModelsUseEnvRefs(openclawPath) : false;
+    if (keyHits.length > 0) {
+      if (openclawUsesEnvRefs) {
+        findings.push(
+          createFinding({
+            severity: Severity.INFO,
+            title: `Agent '${agentName}': models.json contains resolved keys (auto-generated)`,
+            details: [
+              "models.json contains resolved API keys, but openclaw.json uses ${ENV_VAR} references",
+              "OpenClaw regenerates models.json from openclaw.json on every gateway startup",
+              "This is expected behavior \u2014 no action needed"
+            ],
+            category: "agents"
+          })
+        );
+      } else {
+        issueCount++;
+        const details = keyHits.slice(0, 5).map(
+          (h) => `Line ${h.lineNum}: ${h.keyName} (${h.masked})`
+        );
+        findings.push(
+          createFinding({
+            severity: Severity.CRITICAL,
+            title: `Agent '${agentName}' has plaintext API keys in models.json`,
+            details,
+            fix: `Replace raw keys with env var refs: "apiKey": "\${${PROVIDER_ENV_MAP.anthropic}}"`,
+            category: "agents"
+          })
+        );
+      }
+    }
+    if (!openclawUsesEnvRefs) {
+      try {
+        const content = fs9.readFileSync(modelsJsonPath, {
+          encoding: "utf-8"
+        });
+        const hasEnvRefs = ENV_VAR_PATTERN.test(content);
+        if (keyHits.length > 0 && !hasEnvRefs) {
+          findings.push(
+            createFinding({
+              severity: Severity.HIGH,
+              title: `Agent '${agentName}' uses raw keys instead of env var references`,
+              details: [
+                "models.json contains no ${ENV_VAR} references",
+                "All API keys should use environment variable substitution"
+              ],
+              fix: 'Run "clawguard migrate-env" to auto-migrate keys to .env',
+              category: "agents"
+            })
+          );
+          issueCount++;
+        }
+      } catch {
+      }
+    }
+    if (globalModel) {
+      const agentModel = getAgentModel(modelsJsonPath);
+      if (agentModel && agentModel !== globalModel) {
+        findings.push(
+          createFinding({
+            severity: Severity.MEDIUM,
+            title: `Agent '${agentName}' model differs from global config`,
+            details: [
+              `Global model: ${globalModel}`,
+              `Agent model: ${agentModel}`,
+              "This agent overrides the global model setting (config shadow)"
+            ],
+            fix: "Verify this is intentional. Remove agent-level model to use global setting.",
+            category: "agents"
+          })
+        );
+        issueCount++;
+      }
+    }
+  }
+  if (agentCount > 0 && issueCount === 0) {
+    findings.push(
+      createFinding({
+        severity: Severity.INFO,
+        title: `${agentCount} agent config(s) scanned - no issues found`,
+        category: "agents"
+      })
+    );
+  }
+  return findings;
+}
+function getGlobalModel(config) {
+  if (!config) return null;
+  try {
+    const models = config.models;
+    if (!models) return null;
+    const defaultModel = models.default;
+    if (defaultModel) return defaultModel;
+    const providers = models.providers;
+    if (providers) {
+      for (const provider of Object.values(providers)) {
+        if (provider.model) return String(provider.model);
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function checkOpenclawModelsUseEnvRefs(openclawPath) {
+  try {
+    const configPath = path9.join(openclawPath, "openclaw.json");
+    const content = fs9.readFileSync(configPath, { encoding: "utf-8" });
+    const config = JSON.parse(content);
+    const models = config.models;
+    if (!models) return false;
+    const providers = models.providers;
+    if (!providers) return false;
+    for (const provider of Object.values(providers)) {
+      const apiKey = String(provider.apiKey ?? provider.key ?? "");
+      if (ENV_VAR_PATTERN.test(apiKey)) {
+        return true;
+      }
+    }
+  } catch {
+  }
+  return false;
+}
+function getAgentModel(modelsJsonPath) {
+  try {
+    const content = fs9.readFileSync(modelsJsonPath, { encoding: "utf-8" });
+    const data = JSON.parse(content);
+    if (data.model) return String(data.model);
+    if (data.default) return String(data.default);
+    const providers = data.providers;
+    if (providers) {
+      for (const provider of Object.values(providers)) {
+        if (provider.model) return String(provider.model);
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+
+// src/checks/providers.ts
+import path10 from "path";
+function checkProviders(openclawPath) {
+  const findings = [];
+  const config = parseConfig(path10.join(openclawPath, "openclaw.json"));
+  if (!config) return findings;
+  const models = config.models ?? {};
+  const providers = models.providers ?? {};
+  const providerSummary = [];
+  for (const [providerName, providerConfig] of Object.entries(providers)) {
+    const lowerName = providerName.toLowerCase();
+    providerSummary.push(
+      `${providerName}: model=${String(providerConfig.model ?? "default")}`
+    );
+    const limits = PROVIDER_LIMITS[lowerName];
+    if (limits && limits.tpm < OPENCLAW_SYSTEM_PROMPT_TOKENS) {
+      findings.push(
+        createFinding({
+          severity: Severity.HIGH,
+          title: `Provider '${providerName}' TPM too low for system prompt`,
+          details: [
+            `${limits.note}`,
+            `OpenClaw system prompt requires ~${OPENCLAW_SYSTEM_PROMPT_TOKENS} tokens`,
+            `Provider free tier allows only ${limits.tpm} TPM`,
+            "System prompt alone exceeds the per-minute token limit"
+          ],
+          fix: `Upgrade to a paid ${providerName} plan or switch to a provider with higher limits`,
+          category: "providers"
+        })
+      );
+    }
+    if (limits && limits.rpm < 10) {
+      findings.push(
+        createFinding({
+          severity: Severity.MEDIUM,
+          title: `Provider '${providerName}' has very low rate limits (${limits.rpm} RPM)`,
+          details: [
+            `${limits.note}`,
+            "Low RPM causes frequent rate limit errors during conversations"
+          ],
+          fix: `Consider upgrading ${providerName} plan or using a different provider`,
+          category: "providers"
+        })
+      );
+    }
+  }
+  const tools = config.tools ?? {};
+  const webSearch = tools.webSearch ?? tools.web_search ?? {};
+  const webSearchEnabled = webSearch.enabled !== false && Object.keys(webSearch).length > 0;
+  if (webSearchEnabled) {
+    const apiKey = webSearch.apiKey ?? webSearch.api_key;
+    if (!apiKey) {
+      findings.push(
+        createFinding({
+          severity: Severity.MEDIUM,
+          title: "Web search tool has no API key configured",
+          details: [
+            "tools.webSearch.apiKey is not set",
+            "Web search will fail or use a very limited fallback"
+          ],
+          fix: "Set tools.webSearch.apiKey to your Brave Search API key (get one at brave.com/search/api)",
+          category: "providers"
+        })
+      );
+    }
+  }
+  if (providerSummary.length > 0) {
+    findings.push(
+      createFinding({
+        severity: Severity.INFO,
+        title: `${providerSummary.length} LLM provider(s) configured`,
+        details: providerSummary,
+        category: "providers"
+      })
+    );
+  }
+  return findings;
+}
+
 // src/scanner.ts
 var CHECK_REGISTRY = {
   credentials: checkCredentials,
@@ -1203,14 +1565,16 @@ var CHECK_REGISTRY = {
   sandbox: checkSandbox,
   permissions: checkPermissions,
   skills: checkSkills,
-  memory: checkMemory
+  memory: checkMemory,
+  agents: checkAgents,
+  providers: checkProviders
 };
 function detectOpenclawPath() {
   const candidates = [
-    path8.join(os2.homedir(), ".openclaw"),
-    path8.join(os2.homedir(), ".clawdbot"),
+    path11.join(os3.homedir(), ".openclaw"),
+    path11.join(os3.homedir(), ".clawdbot"),
     // Legacy name
-    path8.join(os2.homedir(), ".moltbot")
+    path11.join(os3.homedir(), ".moltbot")
     // Legacy name
   ];
   const envPath = process.env.OPENCLAW_HOME;
@@ -1218,7 +1582,7 @@ function detectOpenclawPath() {
     candidates.unshift(envPath);
   }
   for (const candidate of candidates) {
-    if (fs8.existsSync(candidate) && fs8.statSync(candidate).isDirectory()) {
+    if (fs10.existsSync(candidate) && fs10.statSync(candidate).isDirectory()) {
       return candidate;
     }
   }
@@ -1256,36 +1620,36 @@ async function runScan(openclawPath, checks) {
 }
 function runFix(openclawPath) {
   const actions = [];
-  if (fs8.existsSync(openclawPath)) {
-    const currentMode = fs8.statSync(openclawPath).mode & 511;
+  if (fs10.existsSync(openclawPath)) {
+    const currentMode = fs10.statSync(openclawPath).mode & 511;
     const current = "0o" + currentMode.toString(8);
     if (current !== "0o700") {
-      fs8.chmodSync(openclawPath, 448);
+      fs10.chmodSync(openclawPath, 448);
       actions.push(`Fixed ${openclawPath} permissions: ${current} -> 0o700`);
     }
   }
-  const configFile = path8.join(openclawPath, "openclaw.json");
-  if (fs8.existsSync(configFile)) {
-    const currentMode = fs8.statSync(configFile).mode & 511;
+  const configFile = path11.join(openclawPath, "openclaw.json");
+  if (fs10.existsSync(configFile)) {
+    const currentMode = fs10.statSync(configFile).mode & 511;
     const current = "0o" + currentMode.toString(8);
     if (current !== "0o600") {
-      fs8.chmodSync(configFile, 384);
+      fs10.chmodSync(configFile, 384);
       actions.push(
-        `Fixed ${path8.basename(configFile)} permissions: ${current} -> 0o600`
+        `Fixed ${path11.basename(configFile)} permissions: ${current} -> 0o600`
       );
     }
   }
-  const credsDir = path8.join(openclawPath, "credentials");
-  if (fs8.existsSync(credsDir) && fs8.statSync(credsDir).isDirectory()) {
+  const credsDir = path11.join(openclawPath, "credentials");
+  if (fs10.existsSync(credsDir) && fs10.statSync(credsDir).isDirectory()) {
     try {
-      const entries = fs8.readdirSync(credsDir, { withFileTypes: true });
+      const entries = fs10.readdirSync(credsDir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isFile()) {
-          const filePath = path8.join(credsDir, entry.name);
-          const currentMode = fs8.statSync(filePath).mode & 511;
+          const filePath = path11.join(credsDir, entry.name);
+          const currentMode = fs10.statSync(filePath).mode & 511;
           const current = "0o" + currentMode.toString(8);
           if (current !== "0o600") {
-            fs8.chmodSync(filePath, 384);
+            fs10.chmodSync(filePath, 384);
             actions.push(
               `Fixed ${entry.name} permissions: ${current} -> 0o600`
             );
@@ -1295,38 +1659,45 @@ function runFix(openclawPath) {
     } catch {
     }
   }
-  if (fs8.existsSync(configFile)) {
+  if (fs10.existsSync(configFile)) {
     try {
-      const content = fs8.readFileSync(configFile, { encoding: "utf-8" });
-      const config = JSON54.parse(content);
+      const content = fs10.readFileSync(configFile, { encoding: "utf-8" });
+      const config = JSON55.parse(content);
       let modified = false;
-      if (!config.agents) config.agents = {};
-      const agents = config.agents;
-      if (!agents.defaults) agents.defaults = {};
-      const defaults = agents.defaults;
-      if (!defaults.sandbox) defaults.sandbox = {};
-      const sandbox = defaults.sandbox;
-      if (sandbox.mode === "off" || !sandbox.mode) {
-        sandbox.mode = "all";
-        sandbox.scope = "session";
-        modified = true;
-        actions.push('Enabled sandbox: agents.defaults.sandbox.mode = "all"');
-      }
-      if (!sandbox.docker) sandbox.docker = {};
-      const docker = sandbox.docker;
-      if (docker.network !== "none") {
-        docker.network = "none";
-        modified = true;
-        actions.push('Set sandbox.docker.network = "none"');
-      }
-      if (!config.tools) config.tools = {};
-      const tools = config.tools;
-      if (!tools.exec) tools.exec = {};
-      const execConfig = tools.exec;
-      if (execConfig.host === "gateway") {
-        execConfig.host = "sandbox";
-        modified = true;
-        actions.push('Set tools.exec.host = "sandbox"');
+      const dockerInstalled = isDockerAvailable();
+      if (dockerInstalled) {
+        if (!config.agents) config.agents = {};
+        const agents = config.agents;
+        if (!agents.defaults) agents.defaults = {};
+        const defaults = agents.defaults;
+        if (!defaults.sandbox) defaults.sandbox = {};
+        const sandbox = defaults.sandbox;
+        if (sandbox.mode === "off" || !sandbox.mode) {
+          sandbox.mode = "all";
+          sandbox.scope = "session";
+          modified = true;
+          actions.push('Enabled sandbox: agents.defaults.sandbox.mode = "all"');
+        }
+        if (!sandbox.docker) sandbox.docker = {};
+        const docker = sandbox.docker;
+        if (docker.network !== "none") {
+          docker.network = "none";
+          modified = true;
+          actions.push('Set sandbox.docker.network = "none"');
+        }
+        if (!config.tools) config.tools = {};
+        const tools = config.tools;
+        if (!tools.exec) tools.exec = {};
+        const execConfig = tools.exec;
+        if (execConfig.host === "gateway") {
+          execConfig.host = "sandbox";
+          modified = true;
+          actions.push('Set tools.exec.host = "sandbox"');
+        }
+      } else {
+        actions.push(
+          chalk2.yellow("Sandbox changes skipped: Docker not installed. Install Docker to enable sandbox isolation.")
+        );
       }
       if (!config.logging) config.logging = {};
       const loggingConfig = config.logging;
@@ -1349,42 +1720,138 @@ function runFix(openclawPath) {
         );
       }
       if (modified) {
-        fs8.writeFileSync(configFile, JSON.stringify(config, null, 2));
+        fs10.writeFileSync(configFile, JSON.stringify(config, null, 2));
+      }
+      const ramGB = getTotalMemoryGB();
+      if (ramGB < 2) {
+        actions.push(
+          chalk2.yellow(`Warning: System has only ${ramGB.toFixed(1)}GB RAM. Set NODE_OPTIONS="--max-old-space-size=512" to prevent OOM kills.`)
+        );
+      }
+      const hits = scanFileForKeys(configFile);
+      if (hits.length > 0) {
+        actions.push(
+          `Tip: Run ${chalk2.bold("clawguard migrate-env")} to move ${hits.length} plaintext key(s) to .env`
+        );
       }
     } catch (e) {
       const message = e instanceof Error ? e.message : String(e);
       actions.push(`Could not modify config: ${message}`);
     }
   }
-  const bakFiles = findFilesRecursive3(openclawPath, ".bak");
+  const bakFiles = findFilesRecursive(openclawPath, ".bak", "extension");
   for (const bakFile of bakFiles) {
-    fs8.unlinkSync(bakFile);
-    actions.push(`Deleted backup file: ${path8.basename(bakFile)}`);
+    fs10.unlinkSync(bakFile);
+    actions.push(`Deleted backup file: ${path11.basename(bakFile)}`);
   }
   return actions;
 }
-function findFilesRecursive3(dir, ext) {
-  const results = [];
-  if (!fs8.existsSync(dir) || !fs8.statSync(dir).isDirectory()) {
-    return results;
+function runMigrateEnv(openclawPath, dryRun = false) {
+  const result = {
+    migrations: [],
+    envFileCreated: false,
+    configsUpdated: []
+  };
+  const configFiles = [];
+  const mainConfig = path11.join(openclawPath, "openclaw.json");
+  if (fs10.existsSync(mainConfig)) {
+    configFiles.push(mainConfig);
+  }
+  const agentsDir = path11.join(openclawPath, "agents");
+  const modelsFiles = findFilesRecursive(agentsDir, "models.json", "exact");
+  configFiles.push(...modelsFiles);
+  const keyToEnvVar = /* @__PURE__ */ new Map();
+  for (const configFile of configFiles) {
+    try {
+      const content = fs10.readFileSync(configFile, { encoding: "utf-8" });
+      const lines = content.split("\n");
+      for (const line of lines) {
+        if (/\$\{[A-Z_][A-Z0-9_]*\}/.test(line)) continue;
+        for (const [keyName, pattern] of API_KEY_PATTERNS) {
+          const globalPattern = new RegExp(
+            pattern.source,
+            pattern.flags + (pattern.flags.includes("g") ? "" : "g")
+          );
+          let match;
+          while ((match = globalPattern.exec(line)) !== null) {
+            const rawKey = match[0];
+            if (keyToEnvVar.has(rawKey)) continue;
+            const envVar = guessEnvVarName(keyName, line);
+            keyToEnvVar.set(rawKey, envVar);
+            result.migrations.push({
+              file: path11.relative(openclawPath, configFile),
+              key: rawKey.slice(0, 8) + "..." + rawKey.slice(-4),
+              envVar
+            });
+          }
+        }
+      }
+    } catch {
+    }
   }
-  try {
-    const entries = fs8.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path8.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        results.push(...findFilesRecursive3(fullPath, ext));
-      } else if (entry.isFile() && entry.name.endsWith(ext)) {
-        results.push(fullPath);
+  if (result.migrations.length === 0) {
+    return result;
+  }
+  if (dryRun) {
+    return result;
+  }
+  const envFilePath = path11.join(openclawPath, ".env");
+  const existingEnv = fs10.existsSync(envFilePath) ? fs10.readFileSync(envFilePath, { encoding: "utf-8" }) : "";
+  const existingKeys = new Set(
+    existingEnv.split("\n").filter((l) => l.includes("=")).map((l) => l.split("=")[0].trim())
+  );
+  const newEnvLines = [];
+  for (const [rawKey, envVar] of keyToEnvVar) {
+    if (!existingKeys.has(envVar)) {
+      newEnvLines.push(`${envVar}=${rawKey}`);
+    }
+  }
+  if (newEnvLines.length > 0) {
+    const separator = existingEnv.endsWith("\n") || existingEnv === "" ? "" : "\n";
+    fs10.appendFileSync(envFilePath, separator + newEnvLines.join("\n") + "\n");
+    result.envFileCreated = true;
+    try {
+      fs10.chmodSync(envFilePath, 384);
+    } catch {
+    }
+  }
+  for (const configFile of configFiles) {
+    try {
+      let content = fs10.readFileSync(configFile, { encoding: "utf-8" });
+      let modified = false;
+      for (const [rawKey, envVar] of keyToEnvVar) {
+        if (content.includes(rawKey)) {
+          content = content.split(rawKey).join(`\${${envVar}}`);
+          modified = true;
+        }
+      }
+      if (modified) {
+        fs10.writeFileSync(configFile, content);
+        result.configsUpdated.push(
+          path11.relative(openclawPath, configFile)
+        );
       }
+    } catch {
     }
-  } catch {
   }
-  return results;
+  return result;
+}
+function guessEnvVarName(keyName, contextLine) {
+  const lower = keyName.toLowerCase();
+  for (const [provider, envVar] of Object.entries(PROVIDER_ENV_MAP)) {
+    if (lower.includes(provider)) return envVar;
+  }
+  if (contextLine.includes("telegram")) return "TELEGRAM_BOT_TOKEN";
+  if (contextLine.includes("discord")) return "DISCORD_BOT_TOKEN";
+  if (contextLine.includes("slack")) return "SLACK_BOT_TOKEN";
+  if (contextLine.includes("brave") || contextLine.includes("webSearch"))
+    return "BRAVE_SEARCH_API_KEY";
+  if (contextLine.includes("stripe")) return "STRIPE_SECRET_KEY";
+  return keyName.toUpperCase().replace(/[\s/]/g, "_").replace(/[^A-Z0-9_]/g, "");
 }
 
 // src/index.ts
-var VERSION2 = "0.1.0";
+var VERSION2 = "0.2.0";
 var program = new Command();
 program.name("clawguard").description("Security scanner for OpenClaw AI agent installations").version(VERSION2);
 program.command("scan").description("Scan your OpenClaw installation for security issues").option("-p, --path <path>", "Path to OpenClaw directory").option("-f, --format <format>", "Output format: rich or json", "rich").option(
@@ -1399,7 +1866,7 @@ program.command("scan").description("Scan your OpenClaw installation for securit
       console.log("Use --path to specify the directory.");
       process.exit(1);
     }
-    if (!fs9.existsSync(openclawPath)) {
+    if (!fs11.existsSync(openclawPath)) {
       console.log(chalk3.red(`Path does not exist: ${openclawPath}`));
       process.exit(1);
     }
@@ -1455,6 +1922,65 @@ ${actions.length} issue(s) fixed.`));
     console.log(chalk3.green("No auto-fixable issues found.\n"));
   }
 });
+program.command("migrate-env").description(
+  "Migrate plaintext API keys from config files to .env with ${REF} substitution"
+).option("-p, --path <path>", "Path to OpenClaw directory").option("--dry-run", "Show what would be migrated without making changes").action((options) => {
+  const openclawPath = options.path ?? detectOpenclawPath();
+  if (!openclawPath) {
+    console.log(chalk3.red("Could not find OpenClaw installation."));
+    process.exit(1);
+  }
+  if (!fs11.existsSync(openclawPath)) {
+    console.log(chalk3.red(`Path does not exist: ${openclawPath}`));
+    process.exit(1);
+  }
+  const dryRun = options.dryRun ?? false;
+  if (dryRun) {
+    console.log(chalk3.cyan("\n-- DRY RUN (no files will be modified) --\n"));
+  }
+  const result = runMigrateEnv(openclawPath, dryRun);
+  if (result.migrations.length === 0) {
+    console.log(chalk3.green("No plaintext API keys found to migrate."));
+    return;
+  }
+  console.log(
+    chalk3.bold(`
+Found ${result.migrations.length} key(s) to migrate:
+`)
+  );
+  for (const m of result.migrations) {
+    console.log(
+      `  ${chalk3.cyan(m.envVar)} <- ${m.key} (${chalk3.dim(m.file)})`
+    );
+  }
+  if (dryRun) {
+    console.log(
+      chalk3.cyan("\nRun without --dry-run to apply these changes.")
+    );
+  } else {
+    console.log();
+    if (result.envFileCreated) {
+      console.log(
+        chalk3.green("  Created/updated .env file (chmod 600)")
+      );
+    }
+    for (const f of result.configsUpdated) {
+      console.log(
+        chalk3.green(`  Updated ${f} with \${ENV_VAR} references`)
+      );
+    }
+    console.log(
+      chalk3.green(
+        `
+${result.migrations.length} key(s) migrated successfully.`
+      )
+    );
+    console.log(
+      `Run ${chalk3.bold("clawguard scan")} to verify.
+`
+    );
+  }
+});
 program.command("version").description("Show ClawGuard version").action(() => {
   console.log(`ClawGuard v${VERSION2}`);
 });