@juspay/neurolink 13.8.17 → 13.8.19

package/dist/processors/base/BaseFileProcessor.js

@@ -47,6 +47,7 @@ import { promisify } from "util";
 import { gunzip } from "zlib";
 import { SIZE_LIMITS } from "../config/index.js";
 import { isAbortError } from "../../utils/errorHandling.js";
+import { downloadAttachment } from "../../utils/attachmentPolicy.js";
 import { withSpan } from "../../telemetry/withSpan.js";
 import { tracers } from "../../telemetry/tracers.js";
 // Starts tracing at the first span, as this module always did: the shared
@@ -425,126 +426,54 @@ export class BaseFileProcessor {
     /**
      * Download file from URL with authentication.
      *
+     * Goes through `downloadAttachment`, which applies the attachment policy
+     * (HTTPS and public hosts unless the instance says otherwise), pins the
+     * connection to the vetted addresses, re-validates every redirect hop and
+     * bounds the body while it streams. `authHeaders` ride on the first request
+     * only — they are never replayed to a redirect target.
+     *
      * @param url - URL to download from
      * @param authHeaders - Optional authentication headers
      * @param timeout - Optional timeout override
+     * @param attachmentPolicy - Policy for the fetch; the environment default when omitted
      * @returns Downloaded file content as Buffer
      * @throws Error if download fails
      */
-    async downloadFile(url, authHeaders, timeout) {
-        // Note: We intentionally use AbortController + setTimeout here rather than the shared
-        // withTimeout utility. AbortController.signal cancels the actual HTTP request via
-        // fetch's signal option, while withTimeout only races promises and would leave
-        // the fetch running in the background, consuming network resources.
-        const controller = new AbortController();
-        const effectiveTimeout = timeout ?? this.config.timeoutMs;
-        const timeoutId = setTimeout(() => {
-            controller.abort();
-        }, effectiveTimeout);
-        try {
-            const headers = {
-                ...authHeaders,
-            };
-            const response = await fetch(url, {
-                headers,
-                signal: controller.signal,
-            });
-            if (!response.ok) {
-                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-            }
-            // Reject HTML responses - likely an error page or redirect
-            const contentType = response.headers.get("Content-Type");
-            if (contentType && contentType.includes("text/html")) {
-                throw new Error(`Received HTML response instead of file content (Content-Type: ${contentType}). This usually means the download URL returned an error page.`);
-            }
-            const maxBytes = this.config.maxSizeMB * 1024 * 1024;
-            let buffer = await this.readBodyWithinLimit(response, maxBytes);
-            // Check for gzip encoding and decompress if needed
-            // Only decompress if the data actually starts with gzip magic bytes (0x1f 0x8b)
-            const contentEncoding = response.headers.get("Content-Encoding");
-            const isActuallyGzipped = buffer.length >= 2 && buffer[0] === 0x1f && buffer[1] === 0x8b;
-            if (contentEncoding?.toLowerCase().includes("gzip") &&
-                isActuallyGzipped) {
-                try {
-                    // Bounded at the decoder. The size check that runs after the download
-                    // only ever sees what already fits in memory, so a few KB of gzip
-                    // declaring gigabytes was inflated in full before anything objected —
-                    // the response passed the "is it small" test on its way in.
-                    buffer = Buffer.from(await gunzipAsync(buffer, { maxOutputLength: maxBytes }));
-                }
-                catch (gzipError) {
-                    if (isBufferTooLargeError(gzipError)) {
-                        throw downloadTooLargeError(this.config.maxSizeMB, this.config.fileTypeName);
-                    }
-                    throw new Error(`Failed to decompress gzip response: ${gzipError instanceof Error ? gzipError.message : String(gzipError)}`, { cause: gzipError });
-                }
-            }
-            return buffer;
-        }
-        finally {
-            clearTimeout(timeoutId);
-            // Release the connection on every early exit. Rejecting a response for
-            // its status or its Content-Type leaves the body unread, which keeps the
-            // socket out of the pool until the response is garbage-collected. After
-            // a successful read there is nothing left in flight, so this is a no-op.
-            controller.abort();
-        }
-    }
-    /**
-     * Read a response body, refusing it the moment it passes `maxBytes`.
-     *
-     * `response.arrayBuffer()` buffers whatever the server sends before anyone
-     * can object, so the size check further up only ever ran against a body that
-     * had already been paid for in full. Metering the stream makes the ceiling
-     * the configured limit instead of the server's choice, and cancelling the
-     * reader stops the transfer rather than merely stopping our interest in it.
-     *
-     * Content-Length is deliberately not trusted as the bound — it is a hint that
-     * can be absent or a lie — but it is worth honouring when present, because it
-     * refuses the honest oversized case without reading a byte.
-     *
-     * @param response - Fetch response whose body should be read
-     * @param maxBytes - Ceiling for the body, in bytes
-     * @returns The body as a Buffer
-     * @throws When the body exceeds `maxBytes`
-     */
-    async readBodyWithinLimit(response, maxBytes) {
-        const declared = Number(response.headers.get("Content-Length"));
-        if (Number.isFinite(declared) && declared > maxBytes) {
-            // Release the socket. An unread body keeps the connection out of the
-            // pool until the response is collected, so a run of oversized downloads
-            // would hold one socket open each.
-            await response.body?.cancel();
-            throw downloadTooLargeError(this.config.maxSizeMB, this.config.fileTypeName);
-        }
-        // Some responses carry no readable stream (mocked fetch, polyfills). The
-        // buffered read is the fallback, still checked — just after the fact.
-        if (!response.body) {
-            const buffered = Buffer.from(await response.arrayBuffer());
-            if (buffered.length > maxBytes) {
-                throw downloadTooLargeError(this.config.maxSizeMB, this.config.fileTypeName);
-            }
-            return buffered;
+    async downloadFile(url, authHeaders, timeout, attachmentPolicy) {
+        const maxBytes = this.config.maxSizeMB * 1024 * 1024;
+        const downloaded = await downloadAttachment(url, {
+            policy: attachmentPolicy,
+            maxBytes,
+            label: `${this.config.fileTypeName} download`,
+            headers: authHeaders,
+            timeoutMs: timeout ?? this.config.timeoutMs,
+        });
+        // Reject HTML responses - likely an error page or redirect
+        const contentType = downloaded.contentType;
+        if (contentType && contentType.includes("text/html")) {
+            throw new Error(`Received HTML response instead of file content (Content-Type: ${contentType}). This usually means the download URL returned an error page.`);
         }
-        const reader = response.body.getReader();
-        const chunks = [];
-        let total = 0;
-        for (;;) {
-            const { done, value } = await reader.read();
-            if (done) {
-                break;
-            }
-            if (!value) {
-                continue;
+        let buffer = downloaded.buffer;
+        // Check for gzip encoding and decompress if needed
+        // Only decompress if the data actually starts with gzip magic bytes (0x1f 0x8b)
+        const contentEncoding = downloaded.contentEncoding;
+        const isActuallyGzipped = buffer.length >= 2 && buffer[0] === 0x1f && buffer[1] === 0x8b;
+        if (contentEncoding.toLowerCase().includes("gzip") && isActuallyGzipped) {
+            try {
+                // Bounded at the decoder. The size check that runs after the download
+                // only ever sees what already fits in memory, so a few KB of gzip
+                // declaring gigabytes was inflated in full before anything objected —
+                // the response passed the "is it small" test on its way in.
+                buffer = Buffer.from(await gunzipAsync(buffer, { maxOutputLength: maxBytes }));
             }
-            total += value.byteLength;
-            if (total > maxBytes) {
-                await reader.cancel();
-                throw downloadTooLargeError(this.config.maxSizeMB, this.config.fileTypeName);
+            catch (gzipError) {
+                if (isBufferTooLargeError(gzipError)) {
+                    throw downloadTooLargeError(this.config.maxSizeMB, this.config.fileTypeName);
+                }
+                throw new Error(`Failed to decompress gzip response: ${gzipError instanceof Error ? gzipError.message : String(gzipError)}`, { cause: gzipError });
             }
-            chunks.push(Buffer.from(value));
         }
-        return Buffer.concat(chunks, total);
+        return buffer;
     }
     /**
      * Download file with retry logic for transient failures.
@@ -567,7 +496,7 @@ export class BaseFileProcessor {
         let lastError;
         for (let attempt = 0; attempt <= retryConfig.maxRetries; attempt++) {
             try {
-                const buffer = await this.downloadFile(url, options?.authHeaders, options?.timeout);
+                const buffer = await this.downloadFile(url, options?.authHeaders, options?.timeout, options?.attachmentPolicy);
                 return { success: true, data: buffer };
             }
             catch (error) {

package/dist/processors/data/YamlProcessor.d.ts

@@ -15,7 +15,10 @@
  * 2. **Billion Laughs Attack (Entity Expansion)**: YAML supports anchors (&) and aliases (*)
  *    for referencing content. Malicious YAML can use nested aliases to create exponential
  *    expansion (e.g., 10 levels of 10x expansion = 10^10 entities from a small file).
- *    We limit `maxAliasCount` to 100 to prevent memory exhaustion.
+ *    js-yaml parses aliases as SHARED references, so the parsed tree stays small — the
+ *    expansion happens at serialization. `asJson` is therefore produced by a bounded
+ *    serializer that stops at the processor's byte limit and reports `null` instead of
+ *    materialising the expanded document.
  *
  * 3. **Denial of Service**: Large or deeply nested YAML files can exhaust memory/CPU.
  *    Size limits are enforced by the base processor's maxSizeMB configuration.
@@ -109,6 +112,15 @@ export declare class YamlProcessor extends BaseFileProcessor<ProcessedYaml> {
      */
     protected buildProcessedResult(buffer: Buffer, fileInfo: FileInfo): ProcessedYaml;
 }
+/**
+ * `JSON.stringify(value, null, 2)` that stops once the output would pass
+ * `maxChars`, returning `null` instead. Walks the value iteratively enough to
+ * visit shared references once per path (which is what expands an alias
+ * bomb) but counts output as it goes, so the work is bounded by the limit
+ * rather than by the document's expanded size. Cycles — which YAML anchors
+ * can also express — serialize as `"[Circular]"`.
+ */
+export declare function boundedJsonStringify(value: unknown, maxChars: number): string | null;
 /** Singleton YAML processor instance */
 export declare const yamlProcessor: YamlProcessor;
 /**

package/dist/processors/data/YamlProcessor.js

@@ -15,7 +15,10 @@
  * 2. **Billion Laughs Attack (Entity Expansion)**: YAML supports anchors (&) and aliases (*)
  *    for referencing content. Malicious YAML can use nested aliases to create exponential
  *    expansion (e.g., 10 levels of 10x expansion = 10^10 entities from a small file).
- *    We limit `maxAliasCount` to 100 to prevent memory exhaustion.
+ *    js-yaml parses aliases as SHARED references, so the parsed tree stays small — the
+ *    expansion happens at serialization. `asJson` is therefore produced by a bounded
+ *    serializer that stops at the processor's byte limit and reports `null` instead of
+ *    materialising the expanded document.
  *
  * 3. **Denial of Service**: Large or deeply nested YAML files can exhaust memory/CPU.
  *    Size limits are enforced by the base processor's maxSizeMB configuration.
@@ -45,6 +48,7 @@ import { createRequire } from "node:module";
 import { BaseFileProcessor } from "../base/BaseFileProcessor.js";
 import { SIZE_LIMITS_MB } from "../config/index.js";
 import { createFileError, FileErrorCode } from "../errors/index.js";
+import { logger } from "../../utils/logger.js";
 // Re-export for consumers who import from this module
 // Import for local use
 const require = createRequire(import.meta.url);
@@ -211,7 +215,14 @@ export class YamlProcessor extends BaseFileProcessor {
         try {
             // Use secure parsing - validation already passed, but maintain consistent security
             parsed = this.parseYamlSecurely(content);
-            asJson = JSON.stringify(parsed, null, 2);
+            // Bounded: a 30-level alias chain is a few hundred bytes of YAML and a
+            // small shared-reference graph in memory, but 2^30 nodes once
+            // stringified. The serializer gives up at the processor's own byte
+            // limit rather than letting `JSON.stringify` expand it.
+            asJson = boundedJsonStringify(parsed, this.config.maxSizeMB * 1024 * 1024);
+            if (asJson === null) {
+                logger.warn(`[YamlProcessor] "${this.getFilename(fileInfo)}" expands past the ${this.config.maxSizeMB}MB limit when serialized (alias expansion); asJson omitted`);
+            }
         }
         catch (error) {
             // This shouldn't happen since we validate, but handle gracefully
@@ -232,6 +243,86 @@ export class YamlProcessor extends BaseFileProcessor {
     }
 }
 // =============================================================================
+// BOUNDED SERIALIZATION
+// =============================================================================
+/**
+ * `JSON.stringify(value, null, 2)` that stops once the output would pass
+ * `maxChars`, returning `null` instead. Walks the value iteratively enough to
+ * visit shared references once per path (which is what expands an alias
+ * bomb) but counts output as it goes, so the work is bounded by the limit
+ * rather than by the document's expanded size. Cycles — which YAML anchors
+ * can also express — serialize as `"[Circular]"`.
+ */
+export function boundedJsonStringify(value, maxChars) {
+    const parts = [];
+    let length = 0;
+    const ancestors = [];
+    const push = (text) => {
+        length += text.length;
+        if (length > maxChars) {
+            return false;
+        }
+        parts.push(text);
+        return true;
+    };
+    const walk = (node, indent) => {
+        if (node === null || typeof node !== "object") {
+            if (node === undefined || typeof node === "function") {
+                return push("null");
+            }
+            if (typeof node === "number" && !Number.isFinite(node)) {
+                return push("null");
+            }
+            return push(JSON.stringify(node));
+        }
+        if (ancestors.includes(node)) {
+            return push('"[Circular]"');
+        }
+        ancestors.push(node);
+        try {
+            const inner = `${indent}  `;
+            if (Array.isArray(node)) {
+                if (node.length === 0) {
+                    return push("[]");
+                }
+                if (!push("[\n")) {
+                    return false;
+                }
+                for (let i = 0; i < node.length; i++) {
+                    if (!push(inner) || !walk(node[i], inner)) {
+                        return false;
+                    }
+                    if (!push(i < node.length - 1 ? ",\n" : "\n")) {
+                        return false;
+                    }
+                }
+                return push(`${indent}]`);
+            }
+            const entries = Object.entries(node).filter(([, v]) => v !== undefined && typeof v !== "function");
+            if (entries.length === 0) {
+                return push("{}");
+            }
+            if (!push("{\n")) {
+                return false;
+            }
+            for (let i = 0; i < entries.length; i++) {
+                const [key, child] = entries[i];
+                if (!push(`${inner}${JSON.stringify(key)}: `) || !walk(child, inner)) {
+                    return false;
+                }
+                if (!push(i < entries.length - 1 ? ",\n" : "\n")) {
+                    return false;
+                }
+            }
+            return push(`${indent}}`);
+        }
+        finally {
+            ancestors.pop();
+        }
+    };
+    return walk(value, "") ? parts.join("") : null;
+}
+// =============================================================================
 // SINGLETON INSTANCE
 // =============================================================================
 /** Singleton YAML processor instance */

package/dist/processors/document/OpenDocumentProcessor.js

@@ -10,6 +10,7 @@ import { createRequire } from "node:module";
 import * as zlib from "node:zlib";
 import { BaseFileProcessor, contentTooLargeError, isContentTooLarge, } from "../base/BaseFileProcessor.js";
 import { readZipEntryWithinLimit } from "../archive/zipEntryReader.js";
+import { indexZipEntriesByName } from "../archive/zipEntryIndex.js";
 import { SIZE_LIMITS } from "../config/index.js";
 const require = createRequire(import.meta.url);
 // Re-import for local use within this file
@@ -63,8 +64,12 @@ export class OpenDocumentProcessor extends BaseFileProcessor {
             // Dynamically import adm-zip to avoid issues if not available
             const AdmZip = require("adm-zip");
             const zip = new AdmZip(buffer);
-            // Try to get content.xml
-            const contentEntry = zip.getEntry("content.xml");
+            // Try to get content.xml — the FIRST member of that name, which is the
+            // one a listing shows; `getEntry` would resolve the last duplicate.
+            // `require("adm-zip")` is untyped; name the entry shape the bounded
+            // reader needs so the index is typed rather than `any`.
+            const zipEntries = zip.getEntries();
+            const contentEntry = indexZipEntriesByName(zipEntries).byName.get("content.xml");
             if (contentEntry) {
                 // Bounded rather than `getData()`: an ODF file is a ZIP, so its
                 // content.xml can declare any uncompressed size it likes, and

package/dist/processors/document/PptxProcessor.js

@@ -41,6 +41,7 @@
 import AdmZip from "adm-zip";
 import * as zlib from "node:zlib";
 import { readZipEntryWithinLimit } from "../archive/zipEntryReader.js";
+import { indexZipEntriesByName } from "../archive/zipEntryIndex.js";
 import { SIZE_LIMITS } from "../config/index.js";
 /**
  * Total budget for everything read out of one presentation.
@@ -182,9 +183,12 @@ export class PptxProcessor {
         const zip = new AdmZip(content);
         const entries = zip.getEntries();
         const readEntry = createBoundedEntryReader();
+        // First occurrence per name: a deck with two `slide1.xml` members shows
+        // the slide the listing found first, and only once.
+        const { byName } = indexZipEntriesByName(entries);
         // Collect slide entries with their slide numbers for sorting
         const slides = [];
-        for (const entry of entries) {
+        for (const entry of byName.values()) {
             const match = entry.entryName.match(SLIDE_ENTRY_REGEX);
             if (match) {
                 const slideNumber = parseInt(match[1], 10);
@@ -203,7 +207,7 @@ export class PptxProcessor {
         parts.push(`Presentation: ${slides.length} slide(s)\n`);
         for (const slide of slides) {
             const texts = PptxProcessor.extractTextFromXml(slide.xml);
-            const notes = PptxProcessor.extractNotesForSlide(zip, slide.slideNumber, readEntry);
+            const notes = PptxProcessor.extractNotesForSlide(byName, slide.slideNumber, readEntry);
             // Emit a slide section when it has either body text or speaker notes.
             if (texts.length > 0 || notes) {
                 parts.push(`### Slide ${slide.slideNumber}`);
@@ -232,8 +236,8 @@ export class PptxProcessor {
      * @param slideNumber - 1-indexed slide number
      * @returns The notes text (runs joined by a space), or null when absent
      */
-    static extractNotesForSlide(zip, slideNumber, readEntry) {
-        const relsXml = readEntry(zip.getEntry(SLIDE_RELS_NAME(slideNumber)));
+    static extractNotesForSlide(byName, slideNumber, readEntry) {
+        const relsXml = readEntry(byName.get(SLIDE_RELS_NAME(slideNumber)));
         if (relsXml === null) {
             return null;
         }
@@ -254,7 +258,7 @@ export class PptxProcessor {
         const normalized = notesTarget
             .replace(/^\.\.\//, "ppt/")
             .replace(/^\/+/, "");
-        const notesXml = readEntry(zip.getEntry(normalized));
+        const notesXml = readEntry(byName.get(normalized));
         if (notesXml === null) {
             return null;
         }
@@ -352,9 +356,10 @@ export class PptxProcessor {
         const zip = new AdmZip(content);
         const entries = zip.getEntries();
         const readEntry = createBoundedEntryReader();
+        const { byName } = indexZipEntriesByName(entries);
         // Collect all slides
         const slides = [];
-        for (const entry of entries) {
+        for (const entry of byName.values()) {
             const match = entry.entryName.match(SLIDE_ENTRY_REGEX);
             if (match) {
                 const slideNumber = parseInt(match[1], 10);
@@ -380,7 +385,7 @@ export class PptxProcessor {
         const parts = [];
         for (const slide of slides) {
             const texts = PptxProcessor.extractTextFromXml(slide.xml);
-            const notes = PptxProcessor.extractNotesForSlide(zip, slide.slideNumber, readEntry);
+            const notes = PptxProcessor.extractNotesForSlide(byName, slide.slideNumber, readEntry);
             parts.push(`### Slide ${slide.slideNumber}`);
             if (texts.length > 0) {
                 parts.push(texts.join("\n"));

package/dist/processors/media/VideoProcessor.js

@@ -43,7 +43,6 @@
  * }
  * ```
  */
-import { randomUUID } from "crypto";
 import { createWriteStream, existsSync, promises as fs } from "fs";
 import { tmpdir } from "os";
 import { join } from "path";
@@ -135,6 +134,44 @@ async function loadSharp() {
 // =============================================================================
 // FFMPEG PATH INITIALIZATION
 // =============================================================================
+/**
+ * Extensions a caller-supplied filename may contribute to a temp file name.
+ * Anything else is replaced by the MIME-derived or `.mp4` default, so the
+ * suffix ffmpeg sees as a format hint is always one of ours.
+ */
+const ALLOWED_TEMP_VIDEO_EXTENSIONS = new Set([
+    ".mp4",
+    ".m4v",
+    ".mkv",
+    ".mov",
+    ".webm",
+    ".avi",
+    ".wmv",
+    ".flv",
+    ".3gp",
+    ".3g2",
+    ".ts",
+    ".mts",
+    ".m2ts",
+    ".ogv",
+    ".ogg",
+    ".mpg",
+    ".mpeg",
+]);
+/**
+ * Input-side ffmpeg/ffprobe options applied to every invocation here.
+ *
+ * `-protocol_whitelist file,crypto,data` pins the demuxer to local files: a
+ * playlist or container that references `http://`, `concat:` or `subfile:`
+ * cannot make ffmpeg fetch or read anything else, whatever the installed
+ * build's defaults are. `-nostdin` keeps a child from ever waiting on a
+ * terminal.
+ */
+const FFMPEG_INPUT_HARDENING = [
+    "-nostdin",
+    "-protocol_whitelist",
+    "file,crypto,data",
+];
 /**
  * Whether ffmpeg/ffprobe paths have been initialized.
  * We only attempt path resolution once to avoid repeated dynamic import overhead.
@@ -361,8 +398,9 @@ export class VideoProcessor extends BaseFileProcessor {
             logger.info(`[NEUROLINK] Video processing started: ${filename} (${(sizeBytes / (1024 * 1024)).toFixed(2)} MB, ${fileInfo.mimetype || "video/mp4"})`);
             // Ensure ffmpeg paths are initialized before any processing
             await initFfmpegPaths();
-            // Temp directory for this processing run
-            const tempDir = join(tmpdir(), `neurolink-video-${randomUUID()}`);
+            // Temp directory for this processing run — minted with mkdtemp
+            // (0o700) once there are bytes to write, see Step 3.
+            let tempDir = "";
             let tempCreated = false;
             try {
                 // Step 1: Validate file type and size
@@ -430,7 +468,7 @@ export class VideoProcessor extends BaseFileProcessor {
                     };
                 }
                 // Step 3: Write buffer to temp file (ffmpeg needs a file path)
-                await fs.mkdir(tempDir, { recursive: true });
+                tempDir = await fs.mkdtemp(join(tmpdir(), "neurolink-video-"));
                 tempCreated = true;
                 const extension = this.getExtensionFromFileInfo(fileInfo);
                 const tempVideoPath = join(tempDir, `input${extension}`);
@@ -589,7 +627,7 @@ export class VideoProcessor extends BaseFileProcessor {
                     error: `ffprobe timed out after ${VIDEO_CONFIG.FFPROBE_TIMEOUT_MS}ms`,
                 });
             }, VIDEO_CONFIG.FFPROBE_TIMEOUT_MS);
-            ffmpeg.ffprobe(filePath, (err, data) => {
+            ffmpeg.ffprobe(filePath, ["-protocol_whitelist", "file,crypto,data"], (err, data) => {
                 clearTimeout(timeoutId);
                 if (err) {
                     resolve({
@@ -671,7 +709,17 @@ export class VideoProcessor extends BaseFileProcessor {
         let report;
         let exitFailure;
         try {
-            const { stderr } = await runFfmpeg(["-hide_banner", "-i", filePath, "-t", "0", "-f", "null", "-"], { timeoutMs: VIDEO_CONFIG.FFPROBE_TIMEOUT_MS });
+            const { stderr } = await runFfmpeg([
+                ...FFMPEG_INPUT_HARDENING,
+                "-hide_banner",
+                "-i",
+                filePath,
+                "-t",
+                "0",
+                "-f",
+                "null",
+                "-",
+            ], { timeoutMs: VIDEO_CONFIG.FFPROBE_TIMEOUT_MS });
             report = stderr;
         }
         catch (error) {
@@ -923,6 +971,7 @@ export class VideoProcessor extends BaseFileProcessor {
         const audioPath = join(tempDir, `audio.${audioFormat}`);
         try {
             await runFfmpeg([
+                ...FFMPEG_INPUT_HARDENING,
                 "-y",
                 "-v",
                 "error",
@@ -1045,7 +1094,7 @@ export class VideoProcessor extends BaseFileProcessor {
         }
         // Extract frames using ffmpeg
         const framesDir = join(tempDir, "frames");
-        await fs.mkdir(framesDir, { recursive: true });
+        await fs.mkdir(framesDir, { recursive: true, mode: 0o700 });
         // The requested `timestamps` are an idealized, evenly-spaced schedule.
         // ffmpeg's `-vf select` only guarantees a MINIMUM gap since the last
         // frame it actually selected — on a source whose real frame spacing
@@ -1131,10 +1180,20 @@ export class VideoProcessor extends BaseFileProcessor {
             const selectExpr = `isnan(prev_selected_t)+gte(t-prev_selected_t,${intervalSec}-0.001)`;
             const PTS_TIME_RE = /pts_time:\s*(-?\d+(?:\.\d+)?)/;
             const realTimestamps = [];
+            // Keep the command so the timeout can kill the child rather than only
+            // abandon it: a rejected promise used to leave ffmpeg running to
+            // completion on a file nobody would read.
+            const command = ff(videoPath).inputOptions([...FFMPEG_INPUT_HARDENING]);
             const timeoutId = setTimeout(() => {
+                try {
+                    command.kill("SIGKILL");
+                }
+                catch {
+                    // Already exited.
+                }
                 reject(new Error(`ffmpeg frame extraction timed out after ${VIDEO_CONFIG.FFMPEG_TIMEOUT_MS}ms`));
             }, VIDEO_CONFIG.FFMPEG_TIMEOUT_MS);
-            ff(videoPath)
+            command
                 .outputOptions([
                 "-vf",
                 `select='${selectExpr}',showinfo,scale='min(${VIDEO_CONFIG.FRAME_MAX_DIMENSION}\\,iw):-2'`,
@@ -1205,10 +1264,19 @@ export class VideoProcessor extends BaseFileProcessor {
         const subtitlePath = join(tempDir, "subtitles.srt");
         const ffSub = await loadFluentFfmpeg();
         await new Promise((resolve, reject) => {
+            const command = ffSub(videoPath).inputOptions([
+                ...FFMPEG_INPUT_HARDENING,
+            ]);
             const timeoutId = setTimeout(() => {
+                try {
+                    command.kill("SIGKILL");
+                }
+                catch {
+                    // Already exited.
+                }
                 reject(new Error(`ffmpeg subtitle extraction timed out after ${VIDEO_CONFIG.FFMPEG_TIMEOUT_MS}ms`));
             }, VIDEO_CONFIG.FFMPEG_TIMEOUT_MS);
-            ffSub(videoPath)
+            command
                 .outputOptions(["-map", "0:s:0", "-c:s", "srt"])
                 .output(subtitlePath)
                 .on("end", () => {
@@ -1383,7 +1451,13 @@ export class VideoProcessor extends BaseFileProcessor {
         const name = fileInfo.name || "";
         const dotIndex = name.lastIndexOf(".");
         if (dotIndex >= 0) {
-            return name.substring(dotIndex).toLowerCase();
+            const fromName = name.substring(dotIndex).toLowerCase();
+            // The tail of a caller-supplied name becomes a temp file suffix that
+            // ffmpeg reads as a format hint; only extensions this processor knows
+            // are allowed through, anything else falls back to the MIME type.
+            if (ALLOWED_TEMP_VIDEO_EXTENSIONS.has(fromName)) {
+                return fromName;
+            }
         }
         // Fallback: derive from MIME type
         const mimeExtMap = {
@@ -1409,7 +1483,9 @@ export class VideoProcessor extends BaseFileProcessor {
      */
     async writeBufferToFile(buffer, filePath) {
         const readable = Readable.from(buffer);
-        const writable = createWriteStream(filePath);
+        // Owner-only, and never over an existing file: the directory is fresh
+        // from mkdtemp, so a path that already exists is something planted.
+        const writable = createWriteStream(filePath, { mode: 0o600, flags: "wx" });
         await pipeline(readable, writable);
     }
     // ===========================================================================
@@ -1431,9 +1507,8 @@ export class VideoProcessor extends BaseFileProcessor {
      */
     async extractFrameRange(buffer, filename, startSec, endSec, frameCount = 5) {
         await initFfmpegPaths();
-        const tempDir = join(tmpdir(), `neurolink-video-extract-${randomUUID()}`);
+        const tempDir = await fs.mkdtemp(join(tmpdir(), "neurolink-video-extract-"));
         try {
-            await fs.mkdir(tempDir, { recursive: true });
             // Write buffer to temp file
             const ext = this.guessExtensionFromName(filename);
             const tempVideoPath = join(tempDir, `input${ext}`);
@@ -1457,7 +1532,7 @@ export class VideoProcessor extends BaseFileProcessor {
             }
             // Extract frames
             const framesDir = join(tempDir, "frames");
-            await fs.mkdir(framesDir, { recursive: true });
+            await fs.mkdir(framesDir, { recursive: true, mode: 0o700 });
             await this.runFfmpegFrameExtraction(tempVideoPath, framesDir, timestamps, interval);
             // Read and resize frames
             const keyframes = [];
@@ -1494,7 +1569,10 @@ export class VideoProcessor extends BaseFileProcessor {
     guessExtensionFromName(filename) {
         const dotIndex = filename.lastIndexOf(".");
         if (dotIndex >= 0) {
-            return filename.substring(dotIndex).toLowerCase();
+            const ext = filename.substring(dotIndex).toLowerCase();
+            if (ALLOWED_TEMP_VIDEO_EXTENSIONS.has(ext)) {
+                return ext;
+            }
         }
         return ".mp4";
     }