@octocodeai/octocode-engine 16.6.0 → 16.7.0

package/dist/security/filePatterns.js

@@ -1,3 +1,9 @@
+// File-access block list: prevents reading sensitive files by name/extension.
+// SYNC NOTE: discoveryFilter.ts:DISCOVERY_IGNORED_FILE_NAMES and
+// DISCOVERY_IGNORED_FILE_EXTENSIONS partially overlap this list (e.g. id_rsa,
+// id_dsa, .pem, .key, .crt). Both sets must be kept in sync — a new sensitive
+// file added here should also be added to discoveryFilter.ts to prevent it
+// from appearing in discovery results, and vice versa.
 export const IGNORED_FILE_PATTERNS = [
     /\.env$/,
     /\.env\..+$/,

package/dist/security/ignoredPathFilter.js

@@ -22,7 +22,10 @@ function getCompiledPathRegex() {
         const all = extra.length > 0
             ? [...IGNORED_PATH_PATTERNS, ...extra]
             : IGNORED_PATH_PATTERNS;
-        _compiledPathRegex = new RegExp(all.map(r => stripNamedGroups(r.source)).join('|'));
+        // Wrap each source in a non-capturing group so alternation precedence is
+        // correct: `a|b` joined with `c|d` must be `(?:a|b)|(?:c|d)`, not
+        // `a|b|c|d` which re-associates differently once combined.
+        _compiledPathRegex = new RegExp(all.map(r => `(?:${stripNamedGroups(r.source)})`).join('|'));
     }
     return _compiledPathRegex;
 }
@@ -33,7 +36,7 @@ function getCompiledFileRegex() {
         const all = extra.length > 0
             ? [...IGNORED_FILE_PATTERNS, ...extra]
             : IGNORED_FILE_PATTERNS;
-        _compiledFileRegex = new RegExp(all.map(r => stripNamedGroups(r.source)).join('|'));
+        _compiledFileRegex = new RegExp(all.map(r => `(?:${stripNamedGroups(r.source)})`).join('|'));
     }
     return _compiledFileRegex;
 }
@@ -51,6 +54,11 @@ export function shouldIgnorePath(pathToCheck) {
     return regex.test(normalizedPath);
 }
 function normalizePathForIgnoreMatching(normalizedPath) {
+    if (normalizedPath === '/private/tmp')
+        return '/tmp';
+    if (normalizedPath.startsWith('/private/tmp/')) {
+        return normalizedPath.slice('/private'.length);
+    }
     if (normalizedPath === '/private/var')
         return '/var';
     if (normalizedPath.startsWith('/private/var/')) {

package/dist/security/mask.js

@@ -1,41 +1,24 @@
 import { nativeMaskSensitiveData } from './native.js';
 import { securityRegistry } from './registry.js';
-import { maskEveryOtherChar } from './maskUtils.js';
+import { deduplicateSpans, applyMaskToSpans } from './maskUtils.js';
 function applyJsMask(text, patterns) {
     const applicable = patterns.filter(p => !p.fileContext);
     if (applicable.length === 0)
         return text;
-    const matches = [];
+    const spans = [];
     for (const p of applicable) {
         p.regex.lastIndex = 0;
         let m;
         const re = new RegExp(p.regex.source, p.regex.flags.replace('g', '') + 'g');
         while ((m = re.exec(text)) !== null) {
-            matches.push({ start: m.index, end: m.index + m[0].length });
+            spans.push({ start: m.index, end: m.index + m[0].length });
             if (m[0].length === 0)
                 re.lastIndex++;
         }
     }
-    if (matches.length === 0)
+    if (spans.length === 0)
         return text;
-    matches.sort((a, b) => a.start - b.start);
-    const deduped = [];
-    let lastEnd = 0;
-    for (const m of matches) {
-        if (m.start >= lastEnd) {
-            deduped.push(m);
-            lastEnd = m.end;
-        }
-    }
-    let result = text;
-    for (let i = deduped.length - 1; i >= 0; i--) {
-        const { start, end } = deduped[i];
-        result =
-            result.slice(0, start) +
-                maskEveryOtherChar(text.slice(start, end)) +
-                result.slice(end);
-    }
-    return result;
+    return applyMaskToSpans(text, deduplicateSpans(spans));
 }
 export function maskSensitiveData(text) {
     if (!text)

package/dist/security/maskUtils.d.ts

@@ -1 +1,7 @@
+export type Span = {
+    start: number;
+    end: number;
+};
 export declare function maskEveryOtherChar(text: string): string;
+export declare function deduplicateSpans(spans: Span[]): Span[];
+export declare function applyMaskToSpans(text: string, spans: Span[]): string;

package/dist/security/maskUtils.js

@@ -5,3 +5,25 @@ export function maskEveryOtherChar(text) {
     }
     return result;
 }
+export function deduplicateSpans(spans) {
+    spans.sort((a, b) => a.start - b.start);
+    const result = [];
+    let lastEnd = 0;
+    for (const span of spans) {
+        if (span.start >= lastEnd) {
+            result.push(span);
+            lastEnd = span.end;
+        }
+    }
+    return result;
+}
+export function applyMaskToSpans(text, spans) {
+    let result = '';
+    let position = 0;
+    for (const span of spans) {
+        result += text.slice(position, span.start);
+        result += maskEveryOtherChar(text.slice(span.start, span.end));
+        position = span.end;
+    }
+    return result + text.slice(position);
+}

package/dist/security/native.js

@@ -1,7 +1,7 @@
 import { createRequire } from 'module';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
-import { maskEveryOtherChar } from './maskUtils.js';
+import { deduplicateSpans, applyMaskToSpans } from './maskUtils.js';
 import { allRegexPatterns } from './regexes/index.js';
 const _require = createRequire(import.meta.url);
 const _dir = dirname(fileURLToPath(import.meta.url));
@@ -122,38 +122,21 @@ function sanitizeWithJsFallback(content, filePath) {
 function maskWithJsFallback(text) {
     if (!text)
         return text;
-    const matches = [];
+    const spans = [];
     for (const pattern of allRegexPatterns) {
         if (pattern.fileContext)
             continue;
         const regex = cloneGlobalRegex(pattern.regex);
         let match;
         while ((match = regex.exec(text)) !== null) {
-            matches.push({ start: match.index, end: match.index + match[0].length });
+            spans.push({ start: match.index, end: match.index + match[0].length });
             if (match[0].length === 0)
                 regex.lastIndex++;
         }
     }
-    if (matches.length === 0)
+    if (spans.length === 0)
         return text;
-    matches.sort((left, right) => left.start - right.start);
-    const nonOverlapping = [];
-    let lastEnd = 0;
-    for (const match of matches) {
-        if (match.start >= lastEnd) {
-            nonOverlapping.push(match);
-            lastEnd = match.end;
-        }
-    }
-    let result = '';
-    let position = 0;
-    for (const match of nonOverlapping) {
-        result += text.slice(position, match.start);
-        result += maskEveryOtherChar(text.slice(match.start, match.end));
-        position = match.end;
-    }
-    result += text.slice(position);
-    return result;
+    return applyMaskToSpans(text, deduplicateSpans(spans));
 }
 export const nativeSanitizeContent = (content, filePath) => getNativeModule()?.sanitizeContent(content, filePath) ??
     sanitizeWithJsFallback(content, filePath);

package/dist/security/pathPatterns.js

@@ -1,3 +1,8 @@
+// Path-access block list: prevents reading from sensitive directories.
+// SYNC NOTE: discoveryFilter.ts:DISCOVERY_IGNORED_FOLDER_NAMES overlaps this
+// list (e.g. .git, .aws, .ssh, .docker, .kube). Both lists must be kept in
+// sync — changes here that protect against directory traversal attacks should
+// be reflected there, and vice versa.
 export const IGNORED_PATH_PATTERNS = [
     /(?:^|\/)\.git(?:\/|$)/,
     /(?:^|\/)\.ssh(?:\/|$)/,

package/dist/security/pathValidator.js

@@ -12,7 +12,10 @@ export class PathValidator {
         if (opts.workspaceRoot) {
             this.addAllowedRoot(opts.workspaceRoot);
         }
-        if (opts.includeHomeDir !== false) {
+        // Home dir is opt-in. Local tools intentionally include it (users search
+        // ~/projects, ~/Documents, etc.) and rely on ignoredPathFilter as the
+        // second layer to block .ssh, .aws, .kube, etc. within it.
+        if (opts.includeHomeDir === true) {
             const homeDir = os.homedir();
             if (homeDir && !this.allowedRoots.includes(homeDir)) {
                 this.allowedRoots.push(homeDir);
@@ -49,23 +52,21 @@ export class PathValidator {
         if (!this.allowedRoots.includes(resolvedRoot)) {
             this.allowedRoots.push(resolvedRoot);
         }
-    }
-    isResolvedPathAllowed(absolutePath, resolvedPath) {
-        return this.allowedRoots.some(root => {
-            if (resolvedPath === root || resolvedPath.startsWith(root + path.sep)) {
-                return true;
-            }
-            try {
-                const realRoot = fs.realpathSync(root);
-                if (absolutePath === root) {
-                    return resolvedPath === realRoot;
-                }
-                return resolvedPath.startsWith(realRoot + path.sep);
-            }
-            catch {
-                return false;
+        try {
+            const realRoot = fs.realpathSync(resolvedRoot);
+            if (!this.allowedRoots.includes(realRoot)) {
+                this.allowedRoots.push(realRoot);
             }
-        });
+        }
+        catch {
+            // Non-existent roots are still useful for validating future output paths.
+        }
+    }
+    isResolvedPathAllowed(_absolutePath, resolvedPath) {
+        // addAllowedRoot already resolves both path.resolve() and realpathSync()
+        // and pushes both into allowedRoots, so a plain string comparison is
+        // sufficient here — no need for another realpathSync per validate() call.
+        return this.allowedRoots.some(root => resolvedPath === root || resolvedPath.startsWith(root + path.sep));
     }
     validate(inputPath) {
         if (!inputPath || inputPath.trim() === '') {
@@ -76,24 +77,6 @@ export class PathValidator {
         }
         const expandedPath = this.expandTilde(inputPath);
         const absolutePath = path.resolve(expandedPath);
-        const isAllowed = this.allowedRoots.some(root => {
-            if (absolutePath === root) {
-                return true;
-            }
-            return absolutePath.startsWith(root + path.sep);
-        });
-        if (!isAllowed) {
-            return {
-                isValid: false,
-                error: `Path '${redactPath(inputPath)}' is outside allowed directories`,
-            };
-        }
-        if (shouldIgnore(absolutePath)) {
-            return {
-                isValid: false,
-                error: `Path '${redactPath(inputPath)}' is in an ignored directory or matches an ignored pattern`,
-            };
-        }
         try {
             const realPath = fs.realpathSync(absolutePath);
             const isRealPathAllowed = this.isResolvedPathAllowed(absolutePath, realPath);
@@ -103,6 +86,12 @@ export class PathValidator {
                     error: `Symlink target '${redactPath(realPath)}' is outside allowed directories`,
                 };
             }
+            if (shouldIgnore(absolutePath)) {
+                return {
+                    isValid: false,
+                    error: `Path '${redactPath(inputPath)}' is in an ignored directory or matches an ignored pattern`,
+                };
+            }
             if (shouldIgnore(realPath)) {
                 return {
                     isValid: false,
@@ -177,6 +166,12 @@ export class PathValidator {
                 error: `Path '${redactPath(inputPath)}' is in an ignored directory or matches an ignored pattern`,
             };
         }
+        if (shouldIgnore(resolvedPath)) {
+            return {
+                isValid: false,
+                error: `Path '${redactPath(inputPath)}' resolves into an ignored directory or matches an ignored pattern`,
+            };
+        }
         return {
             isValid: true,
             sanitizedPath: resolvedPath,
@@ -221,9 +216,15 @@ export class PathValidator {
         this.allowedRoots = [...roots];
     }
 }
-export const pathValidator = new PathValidator();
+// The production singleton explicitly opts in to the home dir because local
+// tools are expected to search ~/projects, ~/Documents, etc. Security within
+// the home directory is provided by ignoredPathFilter (.ssh, .aws, .kube, etc.).
+export const pathValidator = new PathValidator({ includeHomeDir: true });
 export function resetPathValidator(options) {
-    const newValidator = new PathValidator(options);
+    // When called with no arguments (e.g. in afterEach tear-down), restore the
+    // same includeHomeDir state the singleton starts with.
+    const effective = options ?? { includeHomeDir: true };
+    const newValidator = new PathValidator(effective);
     pathValidator.replaceAllowedRoots(newValidator.getAllowedRoots());
     return pathValidator;
 }

package/dist/security/registry.js

@@ -1,15 +1,33 @@
 import { normalizeCommandName } from './commandUtils.js';
-const REDOS_TIMEOUT_MS = 50;
-const REDOS_TEST_INPUT = 'a'.repeat(100);
+const REDOS_TIMEOUT_MS = 200;
+// Use multiple input lengths to catch ReDoS patterns that only blow up at larger sizes.
+const REDOS_TEST_INPUTS = [
+    'a'.repeat(50),
+    'a'.repeat(500),
+    'a'.repeat(2000),
+];
 function isReDoSSafe(regex) {
-    const start = performance.now();
-    try {
-        regex.test(REDOS_TEST_INPUT);
-    }
-    catch {
-        return false;
+    // Timing heuristic — catches obvious exponential backtracking but cannot provide
+    // structural guarantees. Tests multiple input sizes to catch patterns that only
+    // blow up at larger scales. A proper linear-time checker (e.g., re2) would be
+    // the gold standard but adds a native dependency.
+    for (const input of REDOS_TEST_INPUTS) {
+        regex.lastIndex = 0;
+        const start = performance.now();
+        try {
+            regex.test(input);
+        }
+        catch {
+            return false;
+        }
+        finally {
+            regex.lastIndex = 0;
+        }
+        if (performance.now() - start >= REDOS_TIMEOUT_MS) {
+            return false;
+        }
     }
-    return performance.now() - start < REDOS_TIMEOUT_MS;
+    return true;
 }
 export class SecurityRegistry {
     _extraSecretPatterns = [];

package/dist/security/securityConstants.d.ts

@@ -1,3 +1,3 @@
-export declare const ALLOWED_COMMANDS: readonly ["rg", "ls", "find", "grep", "git"];
+export declare const ALLOWED_COMMANDS: readonly ["rg", "ls", "find", "grep", "git", "file", "zcat", "gunzip", "bzcat", "xzcat", "zstdcat", "zstd", "lz4cat", "brotli", "lzfse", "tar", "unzip", "bsdtar", "7z", "7zz"];
 export declare const DANGEROUS_PATTERNS: readonly [RegExp, RegExp, RegExp];
 export declare const PATTERN_DANGEROUS_PATTERNS: readonly [RegExp, RegExp, RegExp, RegExp];

package/dist/security/securityConstants.js

@@ -1,4 +1,25 @@
-export const ALLOWED_COMMANDS = ['rg', 'ls', 'find', 'grep', 'git'];
+export const ALLOWED_COMMANDS = [
+    'rg',
+    'ls',
+    'find',
+    'grep',
+    'git',
+    'file',
+    'zcat',
+    'gunzip',
+    'bzcat',
+    'xzcat',
+    'zstdcat',
+    'zstd',
+    'lz4cat',
+    'brotli',
+    'lzfse',
+    'tar',
+    'unzip',
+    'bsdtar',
+    '7z',
+    '7zz',
+];
 export const DANGEROUS_PATTERNS = [
     /[;&|`$(){}[\]<>]/, // Shell metacharacters
     /\${/,

package/dist/security/withSecurityValidation.js

@@ -13,13 +13,24 @@ export function configureSecurity(deps) {
 function createErrorResult(text) {
     return { content: [{ type: 'text', text }], isError: true };
 }
-function withToolTimeout(toolName, promise, signal, timeoutMs) {
+// Combine an external caller-provided AbortSignal with an internal one so that
+// aborting either cancels the tool. Returns the single source unchanged when
+// only one (or none) is present, preserving existing behavior.
+function mergeAbortSignals(external, internal) {
+    if (!external)
+        return internal;
+    if (!internal)
+        return external;
+    return AbortSignal.any([external, internal]);
+}
+function withToolTimeout(toolName, promise, signal, timeoutMs, onTimeout) {
     const timeout = getTimeoutMs(timeoutMs);
     if (signal?.aborted) {
         return Promise.resolve(createErrorResult(`Tool '${toolName}' was cancelled before execution.`));
     }
     return new Promise(resolve => {
         const timer = setTimeout(() => {
+            onTimeout?.();
             resolve(createErrorResult(`Tool '${toolName}' timed out after ${timeout / 1000}s. Try reducing query complexity or scope.`));
         }, timeout);
         const onAbort = () => {
@@ -27,6 +38,9 @@ function withToolTimeout(toolName, promise, signal, timeoutMs) {
             resolve(createErrorResult(`Tool '${toolName}' was cancelled by the client.`));
         };
         signal?.addEventListener('abort', onAbort, { once: true });
+        // Re-check after registering the listener: the signal may have been aborted
+        // in the window between addEventListener and this line, which the listener
+        // alone cannot catch.
         if (signal?.aborted) {
             clearTimeout(timer);
             signal.removeEventListener('abort', onAbort);
@@ -47,7 +61,7 @@ function withToolTimeout(toolName, promise, signal, timeoutMs) {
     });
 }
 async function runSecure(opts) {
-    const { toolName, handler, args, authInfo, sessionId, signal, timeoutMs } = opts;
+    const { toolName, handler, args, authInfo, sessionId, signal, timeoutMs, onTimeout, abortSignal, } = opts;
     try {
         const sanitizer = getSanitizer();
         const validation = sanitizer.validateInputParameters(args);
@@ -55,7 +69,8 @@ async function runSecure(opts) {
             return createErrorResult(`Security validation failed: ${validation.warnings.join('; ')}`);
         }
         const sanitizedParams = validation.sanitizedParams;
-        const rawResult = await withToolTimeout(toolName, handler(sanitizedParams, authInfo, sessionId), signal, timeoutMs);
+        const mergedSignal = mergeAbortSignals(signal, abortSignal);
+        const rawResult = await withToolTimeout(toolName, handler(sanitizedParams, authInfo, sessionId), mergedSignal, timeoutMs, onTimeout);
         return rawResult;
     }
     catch (error) {