@dreb/coding-agent 2.8.0 → 2.9.0

package/dist/core/agent-session.js

@@ -26,6 +26,8 @@ import { createToolHtmlRenderer } from "./export-html/tool-renderer.js";
 import { ExtensionRunner, wrapRegisteredTools, } from "./extensions/index.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";
@@ -198,6 +200,20 @@ export class AgentSession {
                     }
                 }
             }
+            // 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;
             if (!runner?.hasHandlers("tool_call")) {
                 return undefined;
@@ -219,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,
             };
         });