@octocodeai/octocode-engine 16.5.0

package/dist/security/native.js

@@ -0,0 +1,161 @@
+import { createRequire } from 'module';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { maskEveryOtherChar } from './maskUtils.js';
+import { allRegexPatterns } from './regexes/index.js';
+const _require = createRequire(import.meta.url);
+const _dir = dirname(fileURLToPath(import.meta.url));
+const MAX_CONTENT_SIZE = 10_000_000;
+const CONTENT_SIZE_EXCEEDED = 'content-size-exceeded';
+const CONTENT_SIZE_PLACEHOLDER = '[CONTENT-REDACTED-SIZE-LIMIT]';
+let nativeLoadState;
+function envFlag(name) {
+    const value = process.env[name];
+    return value === '1' || value?.toLowerCase() === 'true';
+}
+// Secret detection is part of the single octocode-engine native binary. The
+// engine root loader (index.cjs) already resolves the correct platform binary
+// (incl. musl detection), so we simply require it — both dist/security/native.js
+// and src/security/native.ts sit two levels below the package root.
+function loadNative() {
+    const candidates = [];
+    if (process.env.OCTOCODE_SECURITY_NATIVE_PATH) {
+        candidates.push(process.env.OCTOCODE_SECURITY_NATIVE_PATH);
+    }
+    candidates.push(join(_dir, '..', '..', 'index.cjs'));
+    const errors = [];
+    for (const candidate of candidates) {
+        try {
+            return _require(candidate);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            errors.push(`${candidate}: ${message}`);
+        }
+    }
+    throw new Error(`octocode-engine: secret-detection native binding unavailable for ` +
+        `${process.platform}-${process.arch}. Tried:\n${errors.join('\n')}`);
+}
+function getNativeModule() {
+    if (envFlag('OCTOCODE_SECURITY_FORCE_JS')) {
+        if (envFlag('OCTOCODE_SECURITY_REQUIRE_NATIVE')) {
+            throw new Error('OCTOCODE_SECURITY_REQUIRE_NATIVE=1 conflicts with OCTOCODE_SECURITY_FORCE_JS=1');
+        }
+        nativeLoadState = { kind: 'fallback' };
+        return null;
+    }
+    if (nativeLoadState) {
+        if (nativeLoadState.kind === 'native')
+            return nativeLoadState.module;
+        if (envFlag('OCTOCODE_SECURITY_REQUIRE_NATIVE')) {
+            throw nativeLoadState.error instanceof Error
+                ? nativeLoadState.error
+                : new Error(String(nativeLoadState.error));
+        }
+        return null;
+    }
+    try {
+        const module = loadNative();
+        nativeLoadState = { kind: 'native', module };
+        return module;
+    }
+    catch (error) {
+        if (envFlag('OCTOCODE_SECURITY_REQUIRE_NATIVE')) {
+            throw error;
+        }
+        nativeLoadState = { kind: 'fallback', error };
+        return null;
+    }
+}
+function cloneGlobalRegex(regex) {
+    const flags = regex.flags.includes('g') ? regex.flags : `${regex.flags}g`;
+    return new RegExp(regex.source, flags);
+}
+function shouldApplyPattern(pattern, filePath) {
+    if (!pattern.fileContext)
+        return true;
+    if (!filePath)
+        return false;
+    pattern.fileContext.lastIndex = 0;
+    const applies = pattern.fileContext.test(filePath);
+    pattern.fileContext.lastIndex = 0;
+    return applies;
+}
+function sanitizeWithJsFallback(content, filePath) {
+    // Byte length (UTF-8) to match the native path's `content.len()` — otherwise
+    // large multibyte content is redacted by native but not by this fallback.
+    if (Buffer.byteLength(content, 'utf8') > MAX_CONTENT_SIZE) {
+        return {
+            content: CONTENT_SIZE_PLACEHOLDER,
+            hasSecrets: true,
+            secretsDetected: [CONTENT_SIZE_EXCEEDED],
+            warnings: [
+                `Content exceeds ${MAX_CONTENT_SIZE} byte limit — redacted for safety`,
+            ],
+        };
+    }
+    let sanitized = content;
+    const secretsDetected = [];
+    for (const pattern of allRegexPatterns) {
+        if (!shouldApplyPattern(pattern, filePath))
+            continue;
+        const regex = cloneGlobalRegex(pattern.regex);
+        regex.lastIndex = 0;
+        if (!regex.test(sanitized))
+            continue;
+        regex.lastIndex = 0;
+        const next = sanitized.replace(regex, `[REDACTED-${pattern.name.toUpperCase()}]`);
+        if (next !== sanitized) {
+            sanitized = next;
+            secretsDetected.push(pattern.name);
+        }
+    }
+    return {
+        content: sanitized,
+        hasSecrets: secretsDetected.length > 0,
+        secretsDetected,
+        warnings: secretsDetected.length > 0
+            ? [`${secretsDetected.length} secret(s) redacted`]
+            : [],
+    };
+}
+function maskWithJsFallback(text) {
+    if (!text)
+        return text;
+    const matches = [];
+    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 });
+            if (match[0].length === 0)
+                regex.lastIndex++;
+        }
+    }
+    if (matches.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;
+}
+export const nativeSanitizeContent = (content, filePath) => getNativeModule()?.sanitizeContent(content, filePath) ??
+    sanitizeWithJsFallback(content, filePath);
+export const nativeMaskSensitiveData = (text) => getNativeModule()?.maskSensitiveData(text) ?? maskWithJsFallback(text);
+export const nativePatternCount = () => getNativeModule()?.patternCount() ?? allRegexPatterns.length;

package/dist/security/paramExtractors.d.ts

@@ -0,0 +1,7 @@
+export interface ResearchFields {
+    mainResearchGoal?: string;
+    researchGoal?: string;
+    reasoning?: string;
+}
+export declare function extractResearchFields(params: Record<string, unknown>): ResearchFields;
+export declare function extractRepoOwnerFromParams(params: Record<string, unknown>): string[];

package/dist/security/paramExtractors.js

@@ -0,0 +1,75 @@
+function getQueriesArray(params) {
+    const queries = params.queries;
+    if (queries && Array.isArray(queries) && queries.length > 0) {
+        return queries;
+    }
+    return undefined;
+}
+function extractResearchFieldsFromQuery(query) {
+    const fields = {};
+    if (typeof query.mainResearchGoal === 'string' && query.mainResearchGoal) {
+        fields.mainResearchGoal = query.mainResearchGoal;
+    }
+    if (typeof query.researchGoal === 'string' && query.researchGoal) {
+        fields.researchGoal = query.researchGoal;
+    }
+    if (typeof query.reasoning === 'string' && query.reasoning) {
+        fields.reasoning = query.reasoning;
+    }
+    return fields;
+}
+export function extractResearchFields(params) {
+    const queries = getQueriesArray(params);
+    if (!queries) {
+        return extractResearchFieldsFromQuery(params);
+    }
+    const mainGoals = new Set();
+    const goals = new Set();
+    const reasonings = new Set();
+    for (const query of queries) {
+        const fields = extractResearchFieldsFromQuery(query);
+        if (fields.mainResearchGoal)
+            mainGoals.add(fields.mainResearchGoal);
+        if (fields.researchGoal)
+            goals.add(fields.researchGoal);
+        if (fields.reasoning)
+            reasonings.add(fields.reasoning);
+    }
+    return {
+        ...(mainGoals.size > 0 && {
+            mainResearchGoal: Array.from(mainGoals).join('; '),
+        }),
+        ...(goals.size > 0 && { researchGoal: Array.from(goals).join('; ') }),
+        ...(reasonings.size > 0 && {
+            reasoning: Array.from(reasonings).join('; '),
+        }),
+    };
+}
+function extractRepoOwnerFromQuery(query) {
+    const repository = typeof query.repository === 'string' ? query.repository : undefined;
+    if (repository && repository.includes('/')) {
+        return [repository];
+    }
+    const repo = typeof query.repo === 'string' ? query.repo : undefined;
+    const owner = typeof query.owner === 'string' ? query.owner : undefined;
+    if (owner && repo) {
+        return [`${owner}/${repo}`];
+    }
+    if (owner) {
+        return [owner];
+    }
+    return [];
+}
+export function extractRepoOwnerFromParams(params) {
+    const queries = getQueriesArray(params);
+    if (!queries) {
+        return extractRepoOwnerFromQuery(params);
+    }
+    const repoSet = new Set();
+    for (const query of queries) {
+        for (const repo of extractRepoOwnerFromQuery(query)) {
+            repoSet.add(repo);
+        }
+    }
+    return Array.from(repoSet);
+}

package/dist/security/pathPatterns.d.ts

@@ -0,0 +1 @@
+export declare const IGNORED_PATH_PATTERNS: RegExp[];

package/dist/security/pathPatterns.js

@@ -0,0 +1,26 @@
+export const IGNORED_PATH_PATTERNS = [
+    /(?:^|\/)\.git(?:\/|$)/,
+    /(?:^|\/)\.ssh(?:\/|$)/,
+    /(?:^|\/)\.aws(?:\/|$)/,
+    /(?:^|\/)\.docker(?:\/|$)/,
+    /(?:^|\/)\.config\/gcloud(?:\/|$)/,
+    /(?:^|\/)\.azure(?:\/|$)/,
+    /(?:^|\/)\.kube(?:\/|$)/,
+    /(?:^|\/)\.terraform(?:\/|$)/,
+    /(?:^|\/)secrets(?:\/|$)/,
+    /(?:^|\/)private(?:\/|$)/,
+    /(?:^|\/)\.password-store(?:\/|$)/,
+    /\.mozilla\/firefox\//,
+    /\.config\/chromium\//,
+    /\.config\/google-chrome\//,
+    /Library\/Application Support\/Google\/Chrome\//,
+    /Library\/Application Support\/Firefox\//,
+    /Library\/Keychains\//,
+    /(?:^|\/)\.thunderbird(?:\/|$)/,
+    /(?:^|\/)\.evolution(?:\/|$)/,
+    /(?:^|\/)\.vagrant(?:\/|$)/,
+    /(?:^|\/)\.minikube(?:\/|$)/,
+    /(?:^|\/)\.bitcoin(?:\/|$)/,
+    /(?:^|\/)\.ethereum(?:\/|$)/,
+    /(?:^|\/)\.electrum(?:\/|$)/,
+];

package/dist/security/pathUtils.d.ts

@@ -0,0 +1 @@
+export declare function redactPath(absolutePath: string, workspaceRoot?: string): string;

package/dist/security/pathUtils.js

@@ -0,0 +1,37 @@
+import path from 'path';
+import os from 'os';
+function normalizePath(p) {
+    if (!p)
+        return p;
+    const normalized = path.posix.normalize(p.replace(/\\/g, '/'));
+    return normalized.length > 1 && normalized.endsWith('/')
+        ? normalized.slice(0, -1)
+        : normalized;
+}
+function getRelativeIfChild(child, parent) {
+    if (child === parent)
+        return '.';
+    const parentPrefix = parent + '/';
+    if (child.startsWith(parentPrefix)) {
+        return child.slice(parentPrefix.length);
+    }
+    return null;
+}
+const HOME_DIR = normalizePath(os.homedir());
+export function redactPath(absolutePath, workspaceRoot) {
+    if (!absolutePath)
+        return '';
+    const normalized = normalizePath(absolutePath);
+    const rootSource = workspaceRoot ?? process.cwd();
+    const root = normalizePath(rootSource);
+    const relative = getRelativeIfChild(normalized, root);
+    if (relative !== null)
+        return relative;
+    if (HOME_DIR) {
+        const homeRelative = getRelativeIfChild(normalized, HOME_DIR);
+        if (homeRelative !== null) {
+            return homeRelative === '.' ? '~' : '~/' + homeRelative;
+        }
+    }
+    return path.basename(normalized);
+}

package/dist/security/pathValidator.d.ts

@@ -0,0 +1,22 @@
+import type { PathValidationResult } from './types.js';
+interface PathValidatorOptions {
+    workspaceRoot?: string;
+    additionalRoots?: string[];
+    includeHomeDir?: boolean;
+}
+export declare class PathValidator {
+    private allowedRoots;
+    constructor(options?: PathValidatorOptions);
+    private expandTilde;
+    addAllowedRoot(root: string): void;
+    private isResolvedPathAllowed;
+    validate(inputPath: string): PathValidationResult;
+    private validateNonExistentPath;
+    exists(inputPath: string): Promise<boolean>;
+    getType(inputPath: string): Promise<'file' | 'directory' | 'symlink' | null>;
+    getAllowedRoots(): readonly string[];
+    replaceAllowedRoots(roots: readonly string[]): void;
+}
+export declare const pathValidator: PathValidator;
+export declare function resetPathValidator(options?: PathValidatorOptions): PathValidator;
+export {};

package/dist/security/pathValidator.js

@@ -0,0 +1,229 @@
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import { shouldIgnore } from './ignoredPathFilter.js';
+import { redactPath } from './pathUtils.js';
+import { securityRegistry } from './registry.js';
+export class PathValidator {
+    allowedRoots;
+    constructor(options) {
+        const opts = options || {};
+        this.allowedRoots = [];
+        if (opts.workspaceRoot) {
+            this.addAllowedRoot(opts.workspaceRoot);
+        }
+        if (opts.includeHomeDir !== false) {
+            const homeDir = os.homedir();
+            if (homeDir && !this.allowedRoots.includes(homeDir)) {
+                this.allowedRoots.push(homeDir);
+            }
+        }
+        if (opts.additionalRoots) {
+            for (const additionalRoot of opts.additionalRoots) {
+                this.addAllowedRoot(additionalRoot);
+            }
+        }
+        const envPaths = process.env.ALLOWED_PATHS;
+        if (envPaths) {
+            const paths = envPaths
+                .split(',')
+                .map(p => p.trim())
+                .filter(p => p.length > 0);
+            for (const envPath of paths) {
+                this.addAllowedRoot(envPath);
+            }
+        }
+        for (const root of securityRegistry.extraAllowedRoots) {
+            this.addAllowedRoot(root);
+        }
+    }
+    expandTilde(inputPath) {
+        if (inputPath.startsWith('~')) {
+            return path.join(os.homedir(), inputPath.slice(1));
+        }
+        return inputPath;
+    }
+    addAllowedRoot(root) {
+        const expandedRoot = this.expandTilde(root);
+        const resolvedRoot = path.resolve(expandedRoot);
+        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;
+            }
+        });
+    }
+    validate(inputPath) {
+        if (!inputPath || inputPath.trim() === '') {
+            return {
+                isValid: false,
+                error: 'Path cannot be empty',
+            };
+        }
+        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);
+            if (!isRealPathAllowed) {
+                return {
+                    isValid: false,
+                    error: `Symlink target '${redactPath(realPath)}' is outside allowed directories`,
+                };
+            }
+            if (shouldIgnore(realPath)) {
+                return {
+                    isValid: false,
+                    error: `Symlink target '${redactPath(realPath)}' is in an ignored directory or matches an ignored pattern`,
+                };
+            }
+            return {
+                isValid: true,
+                sanitizedPath: realPath,
+            };
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                const nodeError = error;
+                if (nodeError.code === 'ENOENT') {
+                    return this.validateNonExistentPath(absolutePath, inputPath);
+                }
+                if (nodeError.code === 'EACCES') {
+                    return {
+                        isValid: false,
+                        error: `Permission denied accessing path: ${redactPath(inputPath)}`,
+                    };
+                }
+                if (nodeError.code === 'ELOOP') {
+                    return {
+                        isValid: false,
+                        error: `Symlink loop detected at path: ${redactPath(inputPath)}`,
+                    };
+                }
+                if (nodeError.code === 'ENAMETOOLONG') {
+                    return {
+                        isValid: false,
+                        error: `Path name too long: ${redactPath(inputPath)}`,
+                    };
+                }
+            }
+            return {
+                isValid: false,
+                error: `Unexpected error validating path: ${redactPath(inputPath)}`,
+            };
+        }
+    }
+    validateNonExistentPath(absolutePath, inputPath) {
+        const { root } = path.parse(absolutePath);
+        let ancestor = path.dirname(absolutePath);
+        const remainder = [path.basename(absolutePath)];
+        while (ancestor !== root && !fs.existsSync(ancestor)) {
+            remainder.unshift(path.basename(ancestor));
+            ancestor = path.dirname(ancestor);
+        }
+        let resolvedAncestor;
+        try {
+            resolvedAncestor = fs.realpathSync(ancestor);
+        }
+        catch {
+            return {
+                isValid: false,
+                error: `Unexpected error validating path: ${redactPath(inputPath)}`,
+            };
+        }
+        const resolvedPath = path.join(resolvedAncestor, ...remainder);
+        const isAllowed = this.isResolvedPathAllowed(absolutePath, resolvedPath);
+        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`,
+            };
+        }
+        return {
+            isValid: true,
+            sanitizedPath: resolvedPath,
+        };
+    }
+    async exists(inputPath) {
+        const validation = this.validate(inputPath);
+        if (!validation.isValid || !validation.sanitizedPath) {
+            return false;
+        }
+        try {
+            await fs.promises.access(validation.sanitizedPath, fs.constants.R_OK);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async getType(inputPath) {
+        const validation = this.validate(inputPath);
+        if (!validation.isValid || !validation.sanitizedPath) {
+            return null;
+        }
+        try {
+            const stats = await fs.promises.lstat(validation.sanitizedPath);
+            if (stats.isFile())
+                return 'file';
+            if (stats.isDirectory())
+                return 'directory';
+            if (stats.isSymbolicLink())
+                return 'symlink';
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    getAllowedRoots() {
+        return [...this.allowedRoots];
+    }
+    replaceAllowedRoots(roots) {
+        this.allowedRoots = [...roots];
+    }
+}
+export const pathValidator = new PathValidator();
+export function resetPathValidator(options) {
+    const newValidator = new PathValidator(options);
+    pathValidator.replaceAllowedRoots(newValidator.getAllowedRoots());
+    return pathValidator;
+}

package/dist/security/regexes/ai-providers.d.ts

@@ -0,0 +1,2 @@
+import type { SensitiveDataPattern } from './types.js';
+export declare const aiProviderPatterns: SensitiveDataPattern[];