@gguf/pigbot 0.0.1 → 0.0.3

package/dist/security/audit-extra.js

@@ -13,7 +13,7 @@ import { resolveSandboxConfigForAgent, resolveSandboxToolPolicyForAgent, } from
 import { resolveGatewayAuth } from "../gateway/auth.js";
 import { INCLUDE_KEY, MAX_INCLUDE_DEPTH } from "../config/includes.js";
 import { normalizeAgentId } from "../routing/session-key.js";
-import { formatOctal, isGroupReadable, isGroupWritable, isWorldReadable, isWorldWritable, modeBits, safeStat, } from "./audit-fs.js";
+import { formatPermissionDetail, formatPermissionRemediation, inspectPathPermissions, safeStat, } from "./audit-fs.js";
 const SMALL_MODEL_PARAM_B_MAX = 300;
 function expandTilde(p, env) {
     if (!p.startsWith("~"))
@@ -52,7 +52,7 @@ export function collectAttackSurfaceSummaryFindings(cfg) {
     const group = summarizeGroupPolicy(cfg);
     const elevated = cfg.tools?.elevated?.enabled !== false;
     const hooksEnabled = cfg.hooks?.enabled === true;
-    const browserEnabled = Boolean(cfg.browser?.enabled ?? cfg.browser?.controlUrl);
+    const browserEnabled = cfg.browser?.enabled ?? true;
     const detail = `groups: open=${group.open}, allowlist=${group.allowlist}` +
         `\n` +
         `tools.elevated: ${elevated ? "enabled" : "disabled"}` +
@@ -85,7 +85,7 @@ export function collectSyncedFolderFindings(params) {
             severity: "warn",
             title: "State/config path looks like a synced folder",
             detail: `stateDir=${params.stateDir}, configPath=${params.configPath}. Synced folders (iCloud/Dropbox/OneDrive/Google Drive) can leak tokens and transcripts onto other devices.`,
-            remediation: `Keep PIGBOT_STATE_DIR on a local-only volume and re-run "${formatCliCommand("pigbot security audit --fix")}".`,
+            remediation: `Keep CLAWDBOT_STATE_DIR on a local-only volume and re-run "${formatCliCommand("moltbot security audit --fix")}".`,
         });
     }
     return findings;
@@ -103,17 +103,7 @@ export function collectSecretsInConfigFindings(cfg) {
             severity: "warn",
             title: "Gateway password is stored in config",
             detail: "gateway.auth.password is set in the config file; prefer environment variables for secrets when possible.",
-            remediation: "Prefer PIGBOT_GATEWAY_PASSWORD (env) and remove gateway.auth.password from disk.",
-        });
-    }
-    const browserToken = typeof cfg.browser?.controlToken === "string" ? cfg.browser.controlToken.trim() : "";
-    if (browserToken && !looksLikeEnvRef(browserToken)) {
-        findings.push({
-            checkId: "config.secrets.browser_control_token_in_config",
-            severity: "warn",
-            title: "Browser control token is stored in config",
-            detail: "browser.controlToken is set in the config file; prefer environment variables for secrets when possible.",
-            remediation: "Prefer PIGBOT_BROWSER_CONTROL_TOKEN (env) and remove browser.controlToken from disk.",
+            remediation: "Prefer CLAWDBOT_GATEWAY_PASSWORD (env) and remove gateway.auth.password from disk.",
         });
     }
     const hooksToken = typeof cfg.hooks?.token === "string" ? cfg.hooks.token.trim() : "";
@@ -158,18 +148,6 @@ export function collectHooksHardeningFindings(cfg) {
             remediation: "Use a separate hooks.token dedicated to hook ingress.",
         });
     }
-    const browserToken = typeof cfg.browser?.controlToken === "string" && cfg.browser.controlToken.trim()
-        ? cfg.browser.controlToken.trim()
-        : process.env.PIGBOT_BROWSER_CONTROL_TOKEN?.trim() || null;
-    if (token && browserToken && token === browserToken) {
-        findings.push({
-            checkId: "hooks.token_reuse_browser_token",
-            severity: "warn",
-            title: "Hooks token reuses the browser control token",
-            detail: "hooks.token matches browser control token; compromise of hooks may enable browser control endpoints.",
-            remediation: "Use a separate hooks.token dedicated to hook ingress.",
-        });
-    }
     const rawPath = typeof cfg.hooks?.path === "string" ? cfg.hooks.path.trim() : "";
     if (rawPath === "/") {
         findings.push({
@@ -252,7 +230,10 @@ function isClaudeModel(id) {
     return /\bclaude-/i.test(id);
 }
 function isClaude45OrHigher(id) {
-    return /\bclaude-[^\s/]*?(?:-4-5\b|4\.5\b)/i.test(id);
+    // Match claude-*-4-5, claude-*-45, claude-*4.5, or opus-4-5/opus-45 variants
+    // Examples that should match:
+    //   claude-opus-4-5, claude-opus-45, claude-4.5, venice/claude-opus-45
+    return /\bclaude-[^\s/]*?(?:-4-?5\b|4\.5\b)/i.test(id);
 }
 export function collectModelHygieneFindings(cfg) {
     const findings = [];
@@ -382,7 +363,7 @@ function isWebFetchEnabled(cfg) {
 }
 function isBrowserEnabled(cfg) {
     try {
-        return resolveBrowserConfig(cfg.browser).enabled;
+        return resolveBrowserConfig(cfg.browser, cfg).enabled;
     }
     catch {
         return true;
@@ -603,35 +584,56 @@ export async function collectIncludeFilePermFindings(params) {
         return findings;
     for (const p of includePaths) {
         // eslint-disable-next-line no-await-in-loop
-        const st = await safeStat(p);
-        if (!st.ok)
+        const perms = await inspectPathPermissions(p, {
+            env: params.env,
+            platform: params.platform,
+            exec: params.execIcacls,
+        });
+        if (!perms.ok)
             continue;
-        const bits = modeBits(st.mode);
-        if (isWorldWritable(bits) || isGroupWritable(bits)) {
+        if (perms.worldWritable || perms.groupWritable) {
             findings.push({
                 checkId: "fs.config_include.perms_writable",
                 severity: "critical",
                 title: "Config include file is writable by others",
-                detail: `${p} mode=${formatOctal(bits)}; another user could influence your effective config.`,
-                remediation: `chmod 600 ${p}`,
+                detail: `${formatPermissionDetail(p, perms)}; another user could influence your effective config.`,
+                remediation: formatPermissionRemediation({
+                    targetPath: p,
+                    perms,
+                    isDir: false,
+                    posixMode: 0o600,
+                    env: params.env,
+                }),
             });
         }
-        else if (isWorldReadable(bits)) {
+        else if (perms.worldReadable) {
             findings.push({
                 checkId: "fs.config_include.perms_world_readable",
                 severity: "critical",
                 title: "Config include file is world-readable",
-                detail: `${p} mode=${formatOctal(bits)}; include files can contain tokens and private settings.`,
-                remediation: `chmod 600 ${p}`,
+                detail: `${formatPermissionDetail(p, perms)}; include files can contain tokens and private settings.`,
+                remediation: formatPermissionRemediation({
+                    targetPath: p,
+                    perms,
+                    isDir: false,
+                    posixMode: 0o600,
+                    env: params.env,
+                }),
             });
         }
-        else if (isGroupReadable(bits)) {
+        else if (perms.groupReadable) {
             findings.push({
                 checkId: "fs.config_include.perms_group_readable",
                 severity: "warn",
                 title: "Config include file is group-readable",
-                detail: `${p} mode=${formatOctal(bits)}; include files can contain tokens and private settings.`,
-                remediation: `chmod 600 ${p}`,
+                detail: `${formatPermissionDetail(p, perms)}; include files can contain tokens and private settings.`,
+                remediation: formatPermissionRemediation({
+                    targetPath: p,
+                    perms,
+                    isDir: false,
+                    posixMode: 0o600,
+                    env: params.env,
+                }),
             });
         }
     }
@@ -640,25 +642,40 @@ export async function collectIncludeFilePermFindings(params) {
 export async function collectStateDeepFilesystemFindings(params) {
     const findings = [];
     const oauthDir = resolveOAuthDir(params.env, params.stateDir);
-    const oauthStat = await safeStat(oauthDir);
-    if (oauthStat.ok && oauthStat.isDir) {
-        const bits = modeBits(oauthStat.mode);
-        if (isWorldWritable(bits) || isGroupWritable(bits)) {
+    const oauthPerms = await inspectPathPermissions(oauthDir, {
+        env: params.env,
+        platform: params.platform,
+        exec: params.execIcacls,
+    });
+    if (oauthPerms.ok && oauthPerms.isDir) {
+        if (oauthPerms.worldWritable || oauthPerms.groupWritable) {
             findings.push({
                 checkId: "fs.credentials_dir.perms_writable",
                 severity: "critical",
                 title: "Credentials dir is writable by others",
-                detail: `${oauthDir} mode=${formatOctal(bits)}; another user could drop/modify credential files.`,
-                remediation: `chmod 700 ${oauthDir}`,
+                detail: `${formatPermissionDetail(oauthDir, oauthPerms)}; another user could drop/modify credential files.`,
+                remediation: formatPermissionRemediation({
+                    targetPath: oauthDir,
+                    perms: oauthPerms,
+                    isDir: true,
+                    posixMode: 0o700,
+                    env: params.env,
+                }),
             });
         }
-        else if (isGroupReadable(bits) || isWorldReadable(bits)) {
+        else if (oauthPerms.groupReadable || oauthPerms.worldReadable) {
             findings.push({
                 checkId: "fs.credentials_dir.perms_readable",
                 severity: "warn",
                 title: "Credentials dir is readable by others",
-                detail: `${oauthDir} mode=${formatOctal(bits)}; credentials and allowlists can be sensitive.`,
-                remediation: `chmod 700 ${oauthDir}`,
+                detail: `${formatPermissionDetail(oauthDir, oauthPerms)}; credentials and allowlists can be sensitive.`,
+                remediation: formatPermissionRemediation({
+                    targetPath: oauthDir,
+                    perms: oauthPerms,
+                    isDir: true,
+                    posixMode: 0o700,
+                    env: params.env,
+                }),
             });
         }
     }
@@ -673,40 +690,64 @@ export async function collectStateDeepFilesystemFindings(params) {
         const agentDir = path.join(params.stateDir, "agents", agentId, "agent");
         const authPath = path.join(agentDir, "auth-profiles.json");
         // eslint-disable-next-line no-await-in-loop
-        const authStat = await safeStat(authPath);
-        if (authStat.ok) {
-            const bits = modeBits(authStat.mode);
-            if (isWorldWritable(bits) || isGroupWritable(bits)) {
+        const authPerms = await inspectPathPermissions(authPath, {
+            env: params.env,
+            platform: params.platform,
+            exec: params.execIcacls,
+        });
+        if (authPerms.ok) {
+            if (authPerms.worldWritable || authPerms.groupWritable) {
                 findings.push({
                     checkId: "fs.auth_profiles.perms_writable",
                     severity: "critical",
                     title: "auth-profiles.json is writable by others",
-                    detail: `${authPath} mode=${formatOctal(bits)}; another user could inject credentials.`,
-                    remediation: `chmod 600 ${authPath}`,
+                    detail: `${formatPermissionDetail(authPath, authPerms)}; another user could inject credentials.`,
+                    remediation: formatPermissionRemediation({
+                        targetPath: authPath,
+                        perms: authPerms,
+                        isDir: false,
+                        posixMode: 0o600,
+                        env: params.env,
+                    }),
                 });
             }
-            else if (isWorldReadable(bits) || isGroupReadable(bits)) {
+            else if (authPerms.worldReadable || authPerms.groupReadable) {
                 findings.push({
                     checkId: "fs.auth_profiles.perms_readable",
                     severity: "warn",
                     title: "auth-profiles.json is readable by others",
-                    detail: `${authPath} mode=${formatOctal(bits)}; auth-profiles.json contains API keys and OAuth tokens.`,
-                    remediation: `chmod 600 ${authPath}`,
+                    detail: `${formatPermissionDetail(authPath, authPerms)}; auth-profiles.json contains API keys and OAuth tokens.`,
+                    remediation: formatPermissionRemediation({
+                        targetPath: authPath,
+                        perms: authPerms,
+                        isDir: false,
+                        posixMode: 0o600,
+                        env: params.env,
+                    }),
                 });
             }
         }
         const storePath = path.join(params.stateDir, "agents", agentId, "sessions", "sessions.json");
         // eslint-disable-next-line no-await-in-loop
-        const storeStat = await safeStat(storePath);
-        if (storeStat.ok) {
-            const bits = modeBits(storeStat.mode);
-            if (isWorldReadable(bits) || isGroupReadable(bits)) {
+        const storePerms = await inspectPathPermissions(storePath, {
+            env: params.env,
+            platform: params.platform,
+            exec: params.execIcacls,
+        });
+        if (storePerms.ok) {
+            if (storePerms.worldReadable || storePerms.groupReadable) {
                 findings.push({
                     checkId: "fs.sessions_store.perms_readable",
                     severity: "warn",
                     title: "sessions.json is readable by others",
-                    detail: `${storePath} mode=${formatOctal(bits)}; routing and transcript metadata can be sensitive.`,
-                    remediation: `chmod 600 ${storePath}`,
+                    detail: `${formatPermissionDetail(storePath, storePerms)}; routing and transcript metadata can be sensitive.`,
+                    remediation: formatPermissionRemediation({
+                        targetPath: storePath,
+                        perms: storePerms,
+                        isDir: false,
+                        posixMode: 0o600,
+                        env: params.env,
+                    }),
                 });
             }
         }
@@ -716,16 +757,25 @@ export async function collectStateDeepFilesystemFindings(params) {
         const expanded = logFile.startsWith("~") ? expandTilde(logFile, params.env) : logFile;
         if (expanded) {
             const logPath = path.resolve(expanded);
-            const st = await safeStat(logPath);
-            if (st.ok) {
-                const bits = modeBits(st.mode);
-                if (isWorldReadable(bits) || isGroupReadable(bits)) {
+            const logPerms = await inspectPathPermissions(logPath, {
+                env: params.env,
+                platform: params.platform,
+                exec: params.execIcacls,
+            });
+            if (logPerms.ok) {
+                if (logPerms.worldReadable || logPerms.groupReadable) {
                     findings.push({
                         checkId: "fs.log_file.perms_readable",
                         severity: "warn",
                         title: "Log file is readable by others",
-                        detail: `${logPath} mode=${formatOctal(bits)}; logs can contain private messages and tool output.`,
-                        remediation: `chmod 600 ${logPath}`,
+                        detail: `${formatPermissionDetail(logPath, logPerms)}; logs can contain private messages and tool output.`,
+                        remediation: formatPermissionRemediation({
+                            targetPath: logPath,
+                            perms: logPerms,
+                            isDir: false,
+                            posixMode: 0o600,
+                            env: params.env,
+                        }),
                     });
                 }
             }

package/dist/security/audit-fs.js

@@ -1,4 +1,5 @@
 import fs from "node:fs/promises";
+import { formatIcaclsResetCommand, formatWindowsAclSummary, inspectWindowsAcl, } from "./windows-acl.js";
 export async function safeStat(targetPath) {
     try {
         const lst = await fs.lstat(targetPath);
@@ -23,6 +24,83 @@ export async function safeStat(targetPath) {
         };
     }
 }
+export async function inspectPathPermissions(targetPath, opts) {
+    const st = await safeStat(targetPath);
+    if (!st.ok) {
+        return {
+            ok: false,
+            isSymlink: false,
+            isDir: false,
+            mode: null,
+            bits: null,
+            source: "unknown",
+            worldWritable: false,
+            groupWritable: false,
+            worldReadable: false,
+            groupReadable: false,
+            error: st.error,
+        };
+    }
+    const bits = modeBits(st.mode);
+    const platform = opts?.platform ?? process.platform;
+    if (platform === "win32") {
+        const acl = await inspectWindowsAcl(targetPath, { env: opts?.env, exec: opts?.exec });
+        if (!acl.ok) {
+            return {
+                ok: true,
+                isSymlink: st.isSymlink,
+                isDir: st.isDir,
+                mode: st.mode,
+                bits,
+                source: "unknown",
+                worldWritable: false,
+                groupWritable: false,
+                worldReadable: false,
+                groupReadable: false,
+                error: acl.error,
+            };
+        }
+        return {
+            ok: true,
+            isSymlink: st.isSymlink,
+            isDir: st.isDir,
+            mode: st.mode,
+            bits,
+            source: "windows-acl",
+            worldWritable: acl.untrustedWorld.some((entry) => entry.canWrite),
+            groupWritable: acl.untrustedGroup.some((entry) => entry.canWrite),
+            worldReadable: acl.untrustedWorld.some((entry) => entry.canRead),
+            groupReadable: acl.untrustedGroup.some((entry) => entry.canRead),
+            aclSummary: formatWindowsAclSummary(acl),
+        };
+    }
+    return {
+        ok: true,
+        isSymlink: st.isSymlink,
+        isDir: st.isDir,
+        mode: st.mode,
+        bits,
+        source: "posix",
+        worldWritable: isWorldWritable(bits),
+        groupWritable: isGroupWritable(bits),
+        worldReadable: isWorldReadable(bits),
+        groupReadable: isGroupReadable(bits),
+    };
+}
+export function formatPermissionDetail(targetPath, perms) {
+    if (perms.source === "windows-acl") {
+        const summary = perms.aclSummary ?? "unknown";
+        return `${targetPath} acl=${summary}`;
+    }
+    return `${targetPath} mode=${formatOctal(perms.bits)}`;
+}
+export function formatPermissionRemediation(params) {
+    if (params.perms.source === "windows-acl") {
+        return formatIcaclsResetCommand(params.targetPath, { isDir: params.isDir, env: params.env });
+    }
+    const mode = params.posixMode.toString(8).padStart(3, "0");
+    return `chmod ${mode} ${params.targetPath}`;
+}
 export function modeBits(mode) {
     if (mode == null)
         return null;