@dreb/coding-agent 2.7.0 → 2.9.0

package/dist/core/agent-session.js

@@ -24,8 +24,10 @@ import { DEFAULT_THINKING_LEVEL } from "./defaults.js";
 import { exportSessionToHtml } from "./export-html/index.js";
 import { createToolHtmlRenderer } from "./export-html/tool-renderer.js";
 import { ExtensionRunner, wrapRegisteredTools, } from "./extensions/index.js";
-import { isForbiddenCommand } from "./forbidden-commands.js";
+import { checkScriptContent, extractScriptPaths, isForbiddenCommand } from "./forbidden-commands.js";
 import { expandPromptTemplate } from "./prompt-templates.js";
+import { scrubSecrets } from "./secret-scrubber.js";
+import { isSensitivePath } from "./sensitive-paths.js";
 import { CURRENT_SESSION_VERSION, getLatestCompactionEntry } from "./session-manager.js";
 import { createSyntheticSourceInfo } from "./source-info.js";
 import { buildSystemPrompt } from "./system-prompt.js";
@@ -171,6 +173,45 @@ export class AgentSession {
                             reason: `Command blocked by forbidden-commands guard: "${pattern}" matched "${command}"`,
                         };
                     }
+                    // Check script files referenced by the command (e.g., bash script.sh)
+                    const scriptPaths = extractScriptPaths(command);
+                    if (scriptPaths.length > 0) {
+                        const { readFileSync, existsSync } = await import("node:fs");
+                        const { resolve } = await import("node:path");
+                        const cwd = this._cwd;
+                        for (const scriptPath of scriptPaths) {
+                            const resolved = resolve(cwd, scriptPath);
+                            if (existsSync(resolved)) {
+                                try {
+                                    const content = readFileSync(resolved, "utf-8");
+                                    const match = checkScriptContent(content, customPatterns);
+                                    if (match) {
+                                        return {
+                                            block: true,
+                                            reason: `Command blocked by forbidden-commands guard: script "${scriptPath}" contains forbidden command at line ${match.line}: "${match.text}" (matched pattern "${match.pattern}")`,
+                                        };
+                                    }
+                                }
+                                catch {
+                                    // File not readable — skip (could be binary, permission denied, etc.)
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            // Check sensitive file paths — blocks read tool access to credential files
+            if (toolCall.name === "read") {
+                const filePath = args?.path;
+                if (typeof filePath === "string") {
+                    const extraSensitivePaths = this.settingsManager?.getSensitiveFilePaths();
+                    const sensitiveResult = isSensitivePath(filePath, extraSensitivePaths);
+                    if (sensitiveResult.blocked) {
+                        return {
+                            block: true,
+                            reason: `File blocked by sensitive-path guard: "${sensitiveResult.pattern}". This file contains credentials that should not be sent to the model.`,
+                        };
+                    }
                 }
             }
             const runner = this._extensionRunner;
@@ -194,24 +235,56 @@ export class AgentSession {
             }
         });
         this.agent.setAfterToolCall(async ({ toolCall, args, result, isError }) => {
+            // Scrub secrets from tool output — runs before extensions, cannot be bypassed
+            let scrubbedContent = result.content;
+            const extraSecretPatterns = this.settingsManager?.getSecretOutputPatterns();
+            const compiledExtras = extraSecretPatterns?.flatMap((p) => {
+                if (!p.pattern || typeof p.pattern !== "string" || p.pattern.trim() === "") {
+                    console.warn(`[secret-scrubber] Skipping empty or invalid pattern in secretOutputPatterns: "${p.name}"`);
+                    return [];
+                }
+                try {
+                    return [{ name: p.name, pattern: new RegExp(p.pattern, "g") }];
+                }
+                catch (err) {
+                    console.warn(`[secret-scrubber] Skipping invalid regex in secretOutputPatterns "${p.name}": ${p.pattern} — ${err instanceof Error ? err.message : String(err)}`);
+                    return [];
+                }
+            });
+            let totalRedactions = 0;
+            scrubbedContent = scrubbedContent.map((item) => {
+                if (item.type === "text" && item.text) {
+                    const { scrubbed, redactionCount } = scrubSecrets(item.text, compiledExtras);
+                    totalRedactions += redactionCount;
+                    if (redactionCount > 0) {
+                        return { ...item, text: scrubbed };
+                    }
+                }
+                return item;
+            });
+            // Build override result if secrets were scrubbed
+            let scrubOverride;
+            if (totalRedactions > 0) {
+                scrubOverride = { content: scrubbedContent };
+            }
             const runner = this._extensionRunner;
             if (!runner?.hasHandlers("tool_result")) {
-                return undefined;
+                return scrubOverride;
             }
             const hookResult = await runner.emitToolResult({
                 type: "tool_result",
                 toolName: toolCall.name,
                 toolCallId: toolCall.id,
                 input: args,
-                content: result.content,
+                content: scrubbedContent,
                 details: isError ? undefined : result.details,
                 isError,
             });
             if (!hookResult || isError) {
-                return undefined;
+                return scrubOverride;
             }
             return {
-                content: hookResult.content,
+                content: hookResult.content ?? scrubOverride?.content,
                 details: hookResult.details,
             };
         });