@octocodeai/octocode-engine 16.5.1 → 16.6.2

package/dist/lsp/serverProvisioner.js

@@ -0,0 +1,253 @@
+import { createHash } from 'node:crypto';
+import { chmodSync, existsSync, mkdirSync, openSync, closeSync, renameSync, rmSync, statSync, writeFileSync, } from 'node:fs';
+import path from 'node:path';
+import { gunzipSync, inflateRawSync } from 'node:zlib';
+import { detectPlatformId } from './platform.js';
+import { cachedServerBinPath, managedCacheRoot, manifestServer, provisionMode, resolveCachedServer, } from './serverManifest.js';
+/**
+ * The write half of LSP provisioning — downloads a pinned, verified portable
+ * server binary into the managed cache. This is invoked ONLY by the explicit
+ * `octocode lsp-server install` path, never lazily during a semantic query
+ * (the resolution ladder's L4 stays read-only). Provisioning a server is
+ * orthogonal to the runtime contract: when no server is available at query
+ * time the tool layer throws and the agent pivots to text search.
+ *
+ * Security invariants (all enforced here):
+ *   - opt-in: refuses unless OCTOCODE_LSP_AUTO_INSTALL is prompt|auto
+ *   - pinned SHA-256 gate: refuses if the manifest sha256 is null
+ *   - host allowlist on the request URL AND every redirect hop; https only
+ *   - atomic: download to a temp file in the dest dir, verify, chmod, rename
+ *   - `.ok` completion marker written last, so a partial install never resolves
+ *   - per-target lock so editor + CLI don't race the same download
+ * v1 handles `gz` and `none` (raw) assets with zero new deps; archive formats
+ * needing zip/tar/xz extraction return a clear "install manually" error.
+ */
+const ALLOWED_HOSTS = new Set([
+    'github.com',
+    // GitHub release assets redirect to a CDN host; both the legacy
+    // (objects.) and current (release-assets.) hosts are GitHub-owned.
+    'objects.githubusercontent.com',
+    'release-assets.githubusercontent.com',
+    'releases.hashicorp.com',
+]);
+const MAX_REDIRECTS = 5;
+const LOCK_STALE_MS = 10 * 60 * 1000;
+function fail(error) {
+    return { ok: false, error };
+}
+function hostAllowed(url) {
+    try {
+        const parsed = new URL(url);
+        return parsed.protocol === 'https:' && ALLOWED_HOSTS.has(parsed.hostname);
+    }
+    catch {
+        return false;
+    }
+}
+/** Fetch following redirects manually, re-checking the host allowlist each hop. */
+async function fetchAllowlisted(url, signal) {
+    let current = url;
+    for (let hop = 0; hop <= MAX_REDIRECTS; hop++) {
+        if (!hostAllowed(current)) {
+            // Report only the host — release-asset URLs carry signed query tokens we
+            // must not echo into logs/CLI output.
+            let host;
+            try {
+                host = new URL(current).host;
+            }
+            catch {
+                host = '(unparseable url)';
+            }
+            return { ok: false, error: `Blocked non-allowlisted/insecure host: ${host}` };
+        }
+        let response;
+        try {
+            response = await fetch(current, { redirect: 'manual', signal });
+        }
+        catch (err) {
+            return { ok: false, error: `Download failed: ${err instanceof Error ? err.message : String(err)}` };
+        }
+        if (response.status >= 300 && response.status < 400) {
+            const location = response.headers.get('location');
+            if (!location)
+                return { ok: false, error: 'Redirect without Location header' };
+            current = new URL(location, current).toString();
+            continue;
+        }
+        if (!response.ok) {
+            return { ok: false, error: `Download failed: HTTP ${response.status}` };
+        }
+        return { ok: true, body: await response.arrayBuffer() };
+    }
+    return { ok: false, error: 'Too many redirects' };
+}
+function sha256(buffer) {
+    return createHash('sha256').update(buffer).digest('hex');
+}
+/** Decode the downloaded asset into the final executable bytes. */
+function extractBinary(asset, raw) {
+    switch (asset.archive) {
+        case 'none':
+            return { ok: true, bytes: raw };
+        case 'gz':
+            return { ok: true, bytes: gunzipSync(raw) };
+        case 'zip': {
+            if (!asset.binPath) {
+                return { ok: false, error: 'zip asset is missing binPath in manifest' };
+            }
+            const extracted = extractFromZip(raw, asset.binPath);
+            if (!extracted) {
+                return {
+                    ok: false,
+                    error: `Could not find '${asset.binPath}' in zip archive — try installing via your package manager.`,
+                };
+            }
+            return { ok: true, bytes: extracted };
+        }
+        case 'tar.gz':
+        case 'tar.xz':
+            return {
+                ok: false,
+                error: `Archive format '${asset.archive}' is not supported; install the server via your package manager.`,
+            };
+        default:
+            return { ok: false, error: `Unknown archive format '${asset.archive}'` };
+    }
+}
+/**
+ * Minimal ZIP local-file-header parser. Handles stored (method 0) and deflate
+ * (method 8) entries — the two methods used by all known LSP server releases.
+ * Searches for `targetPath` by exact match or trailing-segment match so both
+ * `clangd_22.1.0/bin/clangd` and `./clangd_22.1.0/bin/clangd` resolve.
+ */
+function extractFromZip(zipBuffer, targetPath) {
+    const LOCAL_HEADER_SIG = 0x04034b50;
+    const normalizedTarget = targetPath.replace(/^\.?\//u, '');
+    let offset = 0;
+    while (offset + 30 < zipBuffer.length) {
+        if (zipBuffer.readUInt32LE(offset) !== LOCAL_HEADER_SIG)
+            break;
+        const compressionMethod = zipBuffer.readUInt16LE(offset + 8);
+        const compressedSize = zipBuffer.readUInt32LE(offset + 18);
+        const filenameLen = zipBuffer.readUInt16LE(offset + 26);
+        const extraLen = zipBuffer.readUInt16LE(offset + 28);
+        const filename = zipBuffer
+            .subarray(offset + 30, offset + 30 + filenameLen)
+            .toString('utf8')
+            .replace(/^\.?\//u, '');
+        const dataOffset = offset + 30 + filenameLen + extraLen;
+        if (filename === normalizedTarget) {
+            const compressed = zipBuffer.subarray(dataOffset, dataOffset + compressedSize);
+            if (compressionMethod === 0)
+                return compressed; // stored
+            if (compressionMethod === 8)
+                return inflateRawSync(compressed); // deflate
+            return null; // unsupported method within zip
+        }
+        offset = dataOffset + compressedSize;
+    }
+    return null;
+}
+function acquireLock(lockPath) {
+    try {
+        closeSync(openSync(lockPath, 'wx'));
+        return true;
+    }
+    catch {
+        // Reclaim a stale lock from a crashed/killed installer.
+        try {
+            if (Date.now() - statSync(lockPath).mtimeMs > LOCK_STALE_MS) {
+                rmSync(lockPath, { force: true });
+                closeSync(openSync(lockPath, 'wx'));
+                return true;
+            }
+        }
+        catch {
+            /* fall through */
+        }
+        return false;
+    }
+}
+/**
+ * Provision `serverName` into the managed cache. Idempotent: returns the
+ * already-present path when a verified copy exists. Pure-data inputs come from
+ * `serverManifest.json`; nothing is executed during install.
+ */
+export async function provisionServer(serverName, options = {}) {
+    const platformId = detectPlatformId();
+    const mode = options.mode ?? provisionMode();
+    const server = manifestServer(serverName);
+    if (!server)
+        return fail(`${serverName} is not an auto-downloadable server.`);
+    const unsupported = server.unsupportedPlatforms?.[platformId];
+    if (unsupported)
+        return fail(unsupported);
+    const asset = server.platforms[platformId];
+    if (!asset) {
+        return fail(`No ${serverName} asset for platform ${platformId}.`);
+    }
+    // Idempotent: a verified copy is already present.
+    const existing = resolveCachedServer(serverName, platformId);
+    if (existing)
+        return { ok: true, path: existing, source: 'already-present' };
+    if (mode === 'off') {
+        return fail('Auto-install is off. Set OCTOCODE_LSP_AUTO_INSTALL=prompt|auto (or pass --yes) to allow downloading.');
+    }
+    if (!asset.sha256) {
+        return fail(`${serverName} has no pinned sha256 in the manifest yet; refusing to download unverified bytes.`);
+    }
+    const binPath = cachedServerBinPath(serverName, platformId);
+    if (!binPath)
+        return fail(`Cannot compute cache path for ${serverName}.`);
+    const dir = path.dirname(binPath);
+    mkdirSync(dir, { recursive: true });
+    const lockPath = path.join(dir, '.lock');
+    if (!acquireLock(lockPath)) {
+        return fail(`Another install of ${serverName} is in progress (${lockPath}).`);
+    }
+    try {
+        // Re-check after acquiring the lock (another process may have finished).
+        const racedWinner = resolveCachedServer(serverName, platformId);
+        if (racedWinner)
+            return { ok: true, path: racedWinner, source: 'already-present' };
+        const fetched = await fetchAllowlisted(asset.url, options.signal);
+        if (!fetched.ok)
+            return fail(fetched.error);
+        const downloaded = Buffer.from(fetched.body);
+        const actualSha = sha256(downloaded);
+        if (actualSha !== asset.sha256) {
+            return fail(`Checksum mismatch for ${serverName}: expected ${asset.sha256}, got ${actualSha}.`);
+        }
+        const extracted = extractBinary(asset, downloaded);
+        if (!extracted.ok)
+            return fail(extracted.error);
+        // Atomic: write a temp file in the same dir, chmod, then rename into place.
+        const tmpPath = `${binPath}.tmp-${process.pid}`;
+        writeFileSync(tmpPath, extracted.bytes);
+        if (process.platform !== 'win32')
+            chmodSync(tmpPath, 0o755);
+        renameSync(tmpPath, binPath);
+        // Completion marker LAST — resolveCachedServer trusts the binary only now.
+        writeFileSync(`${binPath}.ok`, JSON.stringify({ sha256: asset.sha256, size: extracted.bytes.length }));
+        return { ok: true, path: binPath, source: 'downloaded' };
+    }
+    finally {
+        rmSync(lockPath, { force: true });
+    }
+}
+/** Remove a server from the managed cache only (never touches external installs). */
+export function uninstallServer(serverName, platformId = detectPlatformId()) {
+    const binPath = cachedServerBinPath(serverName, platformId);
+    if (!binPath)
+        return false;
+    const serverDir = path.dirname(path.dirname(binPath)); // <root>/<server>
+    if (!existsSync(serverDir))
+        return false;
+    // Guard: only ever delete inside the managed cache root.
+    const root = managedCacheRoot();
+    if (!path.resolve(serverDir).startsWith(path.resolve(root) + path.sep)) {
+        return false;
+    }
+    rmSync(serverDir, { recursive: true, force: true });
+    return true;
+}

package/dist/lsp/types.d.ts

@@ -1,4 +1,11 @@
 export type InitializationOptions = Record<string, unknown>;
+/**
+ * Where a language-server executable was resolved from, for honest status
+ * reporting. Ordered by the resolution ladder (see docs/context/LSP_GUIDE.md):
+ * explicit override / PATH → bundled JS dep → project-local → ecosystem dir →
+ * managed download cache → IDE bridge; `unavailable` when nothing provides it.
+ */
+export type LspServerSource = 'path' | 'bundled' | 'project-local' | 'ecosystem' | 'managed-cache' | 'ide-bridge' | 'unavailable';
 export interface LanguageServerConfig {
     command: string;
     args?: string[];

package/dist/lsp/workspaceRoot.d.ts

@@ -1,2 +1,2 @@
-export declare function resolveWorkspaceRootForFile(filePath: string, _workspaceRoot?: string): Promise<string>;
+export declare function resolveWorkspaceRootForFile(filePath: string, workspaceRoot?: string): Promise<string>;
 export declare function findWorkspaceRoot(filePath: string): Promise<string>;

package/dist/lsp/workspaceRoot.js

@@ -1,5 +1,7 @@
 import { nativeBinding } from './native.js';
-export async function resolveWorkspaceRootForFile(filePath, _workspaceRoot) {
+export async function resolveWorkspaceRootForFile(filePath, workspaceRoot) {
+    if (workspaceRoot)
+        return workspaceRoot;
     return nativeBinding.resolveWorkspaceRootForFile(filePath);
 }
 export async function findWorkspaceRoot(filePath) {

package/dist/security/commandValidator.js

@@ -201,6 +201,9 @@ function validateCommandArgs(command, args) {
             };
         }
     }
+    // grep: no per-flag allowlist — only the shared dangerous-pattern scan below
+    // applies. grep flags are wide (e.g. -r, -Z, --include) and intentionally
+    // left to the pattern scan rather than a strict allowlist.
     const patternPositions = getPatternArgPositions(command, args);
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
@@ -295,16 +298,13 @@ function getFindPatternPositions(args) {
     return positions;
 }
 function getPatternArgPositions(command, args) {
-    switch (true) {
-        case isRgCommand(command):
-            return getRgPatternPositions(args);
-        case command === 'grep':
-            return getGrepPatternPositions(args);
-        case command === 'find':
-            return getFindPatternPositions(args);
-        default:
-            return new Set();
-    }
+    if (isRgCommand(command))
+        return getRgPatternPositions(args);
+    if (command === 'grep')
+        return getGrepPatternPositions(args);
+    if (command === 'find')
+        return getFindPatternPositions(args);
+    return new Set();
 }
 function findDisallowedRgFlag(args) {
     for (let i = 0; i < args.length; i++) {

package/dist/security/discoveryFilter.js

@@ -1,3 +1,10 @@
+// Discovery pruning lists: skip these dirs/files/extensions during tree walks.
+// SYNC NOTE: pathPatterns.ts:IGNORED_PATH_PATTERNS and
+// filePatterns.ts:IGNORED_FILE_PATTERNS overlap these lists (e.g. .git, .aws,
+// .ssh, .docker, .kube, id_rsa, .pem, .key). The two systems have different
+// roles — pathPatterns/filePatterns block *access* (read-time check);
+// discoveryFilter blocks *visibility* (tree-walk pruning). Both must be kept
+// in sync so that adding a sensitive path/file to one is reflected in the other.
 export const DISCOVERY_IGNORED_FOLDER_NAMES = [
     '.github',
     '.git',
@@ -76,8 +83,6 @@ export const DISCOVERY_IGNORED_FOLDER_NAMES = [
     '.history',
     'coverage',
     '.nyc_output',
-    'logs',
-    'log',
     '.DS_Store',
 ];
 export const DISCOVERY_IGNORED_FILE_NAMES = [
@@ -126,7 +131,6 @@ export const DISCOVERY_IGNORED_FILE_NAMES = [
 ];
 export const DISCOVERY_IGNORED_FILE_EXTENSIONS = [
     '.lock',
-    '.log',
     '.tmp',
     '.temp',
     '.cache',

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

@@ -51,6 +51,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

@@ -49,6 +49,15 @@ export class PathValidator {
         if (!this.allowedRoots.includes(resolvedRoot)) {
             this.allowedRoots.push(resolvedRoot);
         }
+        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) {
         return this.allowedRoots.some(root => {
@@ -76,24 +85,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 +94,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 +174,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,

package/dist/security/withSecurityValidation.d.ts

@@ -2,9 +2,6 @@ import type { ISanitizer, ToolResult } from './types.js';
 export interface SecurityDepsConfig {
     sanitizer?: ISanitizer;
     defaultTimeoutMs?: number;
-    logToolCall?: (toolName: string, repos: string[], goal?: string, rGoal?: string, reasoning?: string) => Promise<void>;
-    logSessionError?: (toolName: string, errorCode: string) => Promise<void>;
-    isLoggingEnabled?: () => boolean;
 }
 export declare function configureSecurity(deps: SecurityDepsConfig): void;
 export declare function withSecurityValidation<T extends Record<string, unknown>, TAuth = unknown>(toolName: string, toolHandler: (sanitizedArgs: T, authInfo?: TAuth, sessionId?: string) => Promise<ToolResult>, options?: {

package/dist/security/withSecurityValidation.js

@@ -1,6 +1,4 @@
 import { ContentSanitizer } from './contentSanitizer.js';
-import { extractResearchFields, extractRepoOwnerFromParams, } from './paramExtractors.js';
-const SECURITY_VALIDATION_FAILED_CODE = 'TOOL_SECURITY_VALIDATION_FAILED';
 const DEFAULT_TOOL_TIMEOUT_MS = 60_000;
 let _deps = {};
 function getSanitizer() {
@@ -29,6 +27,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);
@@ -58,15 +59,9 @@ async function runSecure(opts) {
         }
         const sanitizedParams = validation.sanitizedParams;
         const rawResult = await withToolTimeout(toolName, handler(sanitizedParams, authInfo, sessionId), signal, timeoutMs);
-        if (!rawResult.isError && _deps.isLoggingEnabled?.()) {
-            handleBulk(toolName, sanitizedParams);
-        }
         return rawResult;
     }
     catch (error) {
-        _deps
-            .logSessionError?.(toolName, SECURITY_VALIDATION_FAILED_CODE)
-            .catch(() => { });
         return createErrorResult(`Security validation error: ${error instanceof Error ? error.message : 'Unknown error'}`);
     }
 }
@@ -92,16 +87,3 @@ export function withBasicSecurityValidation(toolHandler, toolName, options) {
         timeoutMs: options?.timeoutMs,
     });
 }
-function handleBulk(toolName, params) {
-    const queries = params.queries;
-    const items = queries && Array.isArray(queries) && queries.length > 0
-        ? queries
-        : [params];
-    for (const item of items) {
-        const repos = extractRepoOwnerFromParams(item);
-        const fields = extractResearchFields(item);
-        _deps
-            .logToolCall?.(toolName, repos, fields.mainResearchGoal, fields.researchGoal, fields.reasoning)
-            .catch(() => { });
-    }
-}