@qvac/harness 0.3.0 → 0.3.2

package/dist-lib/lib/tools/exec/adapters/python/run-session.js

@@ -2,6 +2,8 @@ import { AbortedError } from '../../../../helpers/race-abort.js';
 import { hlog } from '../../../../log.js';
 import { TRUNCATED_OUTPUT_SUFFIX } from '../../runner.js';
 import { collectOutputs, openScratch, stageInputFiles } from './memfs.js';
+import { isGuardedFetch, setConnectPolicy } from './guarded-fetch.js';
+import { NET_SHIM, pythonReachesNetwork } from './net-shim.js';
 import { planVendoredInstall, stageVendoredWheels } from './wheels.js';
 export function cap(text, limit) {
     if (text.length <= limit)
@@ -37,9 +39,30 @@ export function repairDoubleEscapedSource(code, message) {
     const repaired = unescapeSource(code);
     return repaired === code ? null : repaired;
 }
-function attempt(py, code, output, maxOutputChars) {
-    try {
+const promisingEval = new WeakMap();
+async function enter(py, code, access) {
+    const guarded = pythonReachesNetwork() && isGuardedFetch(globalThis.fetch);
+    if (!access || !guarded || py.ffi === undefined || py.pyimport === undefined) {
         py.runPython(code);
+        return;
+    }
+    let evalCode = promisingEval.get(py);
+    if (!evalCode) {
+        py.runPython(NET_SHIM);
+        evalCode = py.pyimport('pyodide.code').eval_code;
+        promisingEval.set(py, evalCode);
+    }
+    setConnectPolicy(access.policy);
+    try {
+        await evalCode.callPromising(code, py.globals);
+    }
+    finally {
+        setConnectPolicy(null);
+    }
+}
+async function attempt(py, code, output, maxOutputChars, access) {
+    try {
+        await enter(py, code, access);
         return {
             result: {
                 stdout: cap(output.stdout, maxOutputChars),
@@ -63,14 +86,14 @@ function attempt(py, code, output, maxOutputChars) {
         };
     }
 }
-function runOnce(py, code, output, maxOutputChars) {
-    const first = attempt(py, code, output, maxOutputChars);
+async function runOnce(py, code, output, maxOutputChars, access) {
+    const first = await attempt(py, code, output, maxOutputChars, access);
     if (first.error === null)
         return first;
     const repaired = repairDoubleEscapedSource(code, first.error);
     if (repaired === null)
         return first;
-    const retry = attempt(py, repaired, output, maxOutputChars);
+    const retry = await attempt(py, repaired, output, maxOutputChars, access);
     if (retry.error !== null && retry.error.includes('SyntaxError'))
         return first;
     return retry;
@@ -168,7 +191,7 @@ async function installPackages(py, packages, timeoutMs, isCancelled) {
             clearTimeout(timer);
     }
 }
-const DELIVERABLE = /\.(pptx|docx|xlsx|pdf|png|jpe?g|gif|webp|csv|json|txt|md|zip)$/i;
+const DELIVERABLE = /\.(pptx|docx|xlsx|pdf|png|jpe?g|gif|webp|csv|json|txt|md|zip|mp4|webm|m4a|mp3)$/i;
 function listFiles(py, dir) {
     try {
         return new Set(py.FS.readdir(dir).filter((name) => name !== '.' && name !== '..'));
@@ -196,6 +219,8 @@ function fitDecks(py, outputs) {
 }
 export async function performRun(py, spec, opts = {}) {
     const isCancelled = opts.isCancelled ?? (() => false);
+    const ask = opts.askConnect ?? (async () => false);
+    const access = spec.network === true ? { policy: spec.hosts ? { named: spec.hosts, ask } : null } : null;
     const output = { stdout: '', stderr: '' };
     py.setStdout({ batched: (chunk) => (output.stdout += chunk + '\n') });
     py.setStderr({ batched: (chunk) => (output.stderr += chunk + '\n') });
@@ -234,7 +259,7 @@ export async function performRun(py, spec, opts = {}) {
     if (!spec.inputs?.length && !spec.outputs?.length && !spec.workdir) {
         const cwd = py.FS.cwd();
         const before = listFiles(py, cwd);
-        const { result, fatal } = runOnce(py, spec.code, output, spec.maxOutputChars);
+        const { result, fatal } = await runOnce(py, spec.code, output, spec.maxOutputChars, access);
         if (result.exitCode !== 0)
             return { result, evict: fatal };
         const undeclared = newDeliverables(before, listFiles(py, cwd));
@@ -245,7 +270,7 @@ export async function performRun(py, spec, opts = {}) {
         py.FS.chdir(scratch.cwd);
         stageInputFiles(py.FS, scratch.cwd, spec.inputs ?? []);
         const before = listFiles(py, scratch.cwd);
-        const { result, fatal } = runOnce(py, spec.code, output, spec.maxOutputChars);
+        const { result, fatal } = await runOnce(py, spec.code, output, spec.maxOutputChars, access);
         let evict = fatal;
         if (result.exitCode === 0)
             evict = fitDecks(py, spec.outputs ?? []);

package/dist-lib/lib/tools/exec/adapters/python/wheels.d.ts

@@ -3,6 +3,7 @@ declare const ManifestSchema: z.ZodObject<{
     pyodide: z.ZodString;
     packages: z.ZodRecord<z.ZodString, z.ZodObject<{
         version: z.ZodOptional<z.ZodString>;
+        imports: z.ZodOptional<z.ZodArray<z.ZodString>>;
         pypi: z.ZodArray<z.ZodString>;
         pyodide: z.ZodArray<z.ZodString>;
     }, z.core.$strip>>;
@@ -29,6 +30,11 @@ type WheelFs = {
 };
 export declare function wheelsDir(): string | undefined;
 export declare function vendoredManifest(dir?: string | undefined): WheelManifest | null;
+export declare function normalizeDistribution(name: string): string;
+export declare function vendoredSpec(distribution: string, opts?: {
+    readonly dir?: string | undefined;
+    readonly manifest?: WheelManifest | null;
+}): string | null;
 export declare function planVendoredInstall(specs: readonly string[], opts?: {
     readonly dir?: string | undefined;
     readonly manifest?: WheelManifest | null;

package/dist-lib/lib/tools/exec/adapters/python/wheels.js

@@ -7,6 +7,7 @@ const ManifestSchema = z.object({
     pyodide: z.string(),
     packages: z.record(z.string(), z.object({
         version: z.string().optional(),
+        imports: z.array(z.string()).optional(),
         pypi: z.array(z.string()),
         pyodide: z.array(z.string())
     })),
@@ -42,12 +43,25 @@ export function vendoredManifest(dir = wheelsDir()) {
         return null;
     }
 }
-function normalize(name) {
-    return name.toLowerCase().replace(/[_.]+/g, '-');
+export function normalizeDistribution(name) {
+    return name
+        .trim()
+        .toLowerCase()
+        .replace(/[-_.]+/g, '-');
 }
 function parseSpec(spec) {
     const [name, version] = spec.split('==');
-    return { name: normalize((name ?? '').trim()), version: version?.trim() };
+    return { name: normalizeDistribution(name ?? ''), version: version?.trim() };
+}
+export function vendoredSpec(distribution, opts = {}) {
+    const name = normalizeDistribution(distribution);
+    const dir = opts.dir ?? wheelsDir();
+    const manifest = opts.manifest === undefined ? vendoredManifest(dir) : opts.manifest;
+    const entry = manifest?.packages[name];
+    if (!entry)
+        return null;
+    const spec = entry.version ? `${name}==${entry.version}` : name;
+    return planVendoredInstall([spec], { dir, manifest }) ? spec : null;
 }
 export function planVendoredInstall(specs, opts = {}) {
     const dir = opts.dir ?? wheelsDir();

package/dist-lib/lib/tools/exec/adapters/python/worker/client.d.ts

@@ -1,7 +1,8 @@
-import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
+import { type AbortSignal as BareAbortSignal } from 'bare-abort-controller';
 import type { PythonRunResult, RunSpec } from '../run-session.ts';
 export declare function runPythonInWorker(spec: RunSpec, opts: {
     readonly timeoutMs: number;
     readonly signal?: BareAbortSignal | undefined;
+    readonly askConnect?: ((host: string) => Promise<boolean>) | undefined;
 }): Promise<PythonRunResult>;
 export declare function closePythonWorker(): Promise<void>;

package/dist-lib/lib/tools/exec/adapters/python/worker/client.js

@@ -1,10 +1,12 @@
 import { spawnPythonWorker } from '#pyodide-worker-spawn';
+import { AbortController } from 'bare-abort-controller';
 import process from 'process';
 import { fileURLToPath } from 'url';
 import { AbortedError, raceAbort } from '../../../../../helpers/race-abort.js';
 import { harnessLogEnabled, hlog } from '../../../../../log.js';
 import { asWorkerMessage, fromWireResult } from './protocol.js';
 const SIGINT = 2;
+const RESEND_MS = 100;
 function interruptGraceMs() {
     const ms = Number(process.env.QVAC_PYODIDE_INTERRUPT_GRACE_MS);
     return ms > 0 ? ms : 30_000;
@@ -69,8 +71,13 @@ async function drainAndReap(worker) {
         timer.clear();
     }
 }
-async function resultFor(worker, id) {
-    const message = await readMessage(worker.link);
+async function resultFor(worker, id, askConnect) {
+    let message = await readMessage(worker.link);
+    while (message?.type === 'connect-ask') {
+        const allowed = askConnect ? await askConnect(message.host).catch(() => false) : false;
+        await worker.link.write({ type: 'connect-answer', allowed });
+        message = await readMessage(worker.link);
+    }
     if (message?.type === 'result') {
         if (message.id !== id)
             throw new Error('python worker answered a different run');
@@ -89,6 +96,7 @@ function grace(ms) {
 }
 async function interrupt(worker, outcome) {
     Atomics.store(worker.view, 0, SIGINT);
+    const resend = setInterval(() => Atomics.store(worker.view, 0, SIGINT), RESEND_MS);
     const graceMs = interruptGraceMs();
     const timer = grace(graceMs);
     try {
@@ -105,6 +113,7 @@ async function interrupt(worker, outcome) {
         }
     }
     finally {
+        clearInterval(resend);
         timer.clear();
     }
 }
@@ -116,13 +125,15 @@ export async function runPythonInWorker(spec, opts) {
         Atomics.store(worker.view, 0, 0);
         let cancelled = false;
         let sent = false;
+        const stop = new AbortController();
+        const ask = opts.askConnect;
         const outcome = (async () => {
             await worker.ready;
             if (cancelled)
                 throw new AbortedError();
             sent = true;
             await worker.link.write({ type: 'run', id, spec });
-            return resultFor(worker, id);
+            return resultFor(worker, id, ask && ((host) => raceAbort(ask(host), stop.signal)));
         })();
         let timer;
         const timeout = new Promise((resolve) => {
@@ -135,6 +146,7 @@ export async function runPythonInWorker(spec, opts) {
         catch (error) {
             if (error instanceof AbortedError) {
                 cancelled = true;
+                stop.abort(undefined);
                 if (sent)
                     await interrupt(worker, outcome);
                 else
@@ -150,6 +162,7 @@ export async function runPythonInWorker(spec, opts) {
         }
         if (first === 'timeout') {
             cancelled = true;
+            stop.abort(undefined);
             if (sent)
                 await interrupt(worker, outcome);
             else

package/dist-lib/lib/tools/exec/adapters/python/worker/entry.js

@@ -90,9 +90,22 @@ try {
         const message = asHostMessage(await port.read());
         if (!message || message.type === 'close')
             break;
-        const { result, evict } = await performRun(py, message.spec);
+        if (message.type === 'connect-answer')
+            continue;
+        let closing = false;
+        const askConnect = async (host) => {
+            if (closing)
+                return false;
+            port.write({ type: 'connect-ask', host });
+            const answer = asHostMessage(await port.read());
+            if (answer?.type === 'connect-answer')
+                return answer.allowed;
+            closing = true;
+            return false;
+        };
+        const { result, evict } = await performRun(py, message.spec, { askConnect });
         port.write({ type: 'result', id: message.id, result: toWireResult(result), evict });
-        if (evict)
+        if (evict || closing)
             break;
     }
 }

package/dist-lib/lib/tools/exec/adapters/python/worker/protocol.d.ts

@@ -5,6 +5,9 @@ export type HostMessage = {
     readonly spec: RunSpec;
 } | {
     readonly type: 'close';
+} | {
+    readonly type: 'connect-answer';
+    readonly allowed: boolean;
 };
 export type WireResult = {
     readonly stdout: string;
@@ -31,6 +34,9 @@ export type WorkerMessage = {
     readonly id: number;
     readonly result: WireResult;
     readonly evict: boolean;
+} | {
+    readonly type: 'connect-ask';
+    readonly host: string;
 };
 export declare function toWireResult(result: PythonRunResult): WireResult;
 export declare function fromWireResult(wire: WireResult): PythonRunResult;

package/dist-lib/lib/tools/exec/adapters/python/worker/protocol.js

@@ -28,13 +28,17 @@ function messageType(value) {
 }
 export function asHostMessage(value) {
     const type = messageType(value);
-    if (type === 'run' || type === 'close')
+    if (type === 'run' || type === 'close' || type === 'connect-answer')
         return value;
     return null;
 }
 export function asWorkerMessage(value) {
     const type = messageType(value);
-    if (type === 'log' || type === 'ready' || type === 'boot-error' || type === 'result') {
+    if (type === 'log' ||
+        type === 'ready' ||
+        type === 'boot-error' ||
+        type === 'result' ||
+        type === 'connect-ask') {
         return value;
     }
     return null;

package/dist-lib/lib/tools/exec/adapters/python/worker/spawn-bare.d.ts

@@ -1,2 +1,3 @@
 import type { WorkerData, WorkerLink } from './spawn-node.ts';
+export declare function spawnInlineThread(source: string, data: object): () => void;
 export declare function spawnPythonWorker(entry: string, data: WorkerData): WorkerLink;

package/dist-lib/lib/tools/exec/adapters/python/worker/spawn-bare.js

@@ -1,5 +1,13 @@
 import Channel from 'bare-channel';
 import safetyCatch from 'safety-catch';
+export function spawnInlineThread(source, data) {
+    const Thread = Bare.Thread;
+    const thread = new Thread('inline-thread.js', {
+        data,
+        source: `const data = Bare.Thread.self.data\n${source}`
+    });
+    return () => thread.join();
+}
 export function spawnPythonWorker(entry, data) {
     const channel = new Channel();
     const thread = new Bare.Thread(entry, { data: { handle: channel.handle, ...data } });

package/dist-lib/lib/tools/exec/adapters/python/worker/spawn-node.d.ts

@@ -11,3 +11,4 @@ export type WorkerData = {
     readonly log: boolean;
 };
 export declare function spawnPythonWorker(entry: string, data: WorkerData): WorkerLink;
+export declare function spawnInlineThread(source: string, data: object): () => void;

package/dist-lib/lib/tools/exec/adapters/python/worker/spawn-node.js

@@ -43,3 +43,11 @@ export function spawnPythonWorker(entry, data) {
         unref: () => worker.unref()
     };
 }
+export function spawnInlineThread(source, data) {
+    const worker = new Worker(`const data = require('worker_threads').workerData\n${source}`, {
+        eval: true,
+        workerData: data
+    });
+    worker.unref();
+    return () => { };
+}

package/dist-lib/lib/tools/exec/adapters/shell/shell-adapter.js

@@ -1,4 +1,5 @@
 import { runCommand } from '../../runner.js';
+import { shellDownloadNote } from '../../shell-guidance.js';
 export function createShellAdapter(options) {
     return {
         resolve(args) {
@@ -8,11 +9,16 @@ export function createShellAdapter(options) {
                     const runtime = options.spawn
                         ? { spawn: options.spawn, killProcess: options.killProcess }
                         : await options.loadRuntime();
-                    return runCommand(command, {
+                    const result = await runCommand(command, {
                         ...execution,
                         spawn: runtime.spawn,
                         killProcess: runtime.killProcess
                     });
+                    const note = result.exitCode === 0 ? shellDownloadNote(command) : null;
+                    if (!note)
+                        return result;
+                    const stdout = `${result.stdout}${result.stdout && !result.stdout.endsWith('\n') ? '\n' : ''}${note}`;
+                    return { ...result, stdout };
                 }
             };
         }

package/dist-lib/lib/tools/exec/shell-guidance.d.ts

@@ -0,0 +1,10 @@
+export declare const PYTHON_BIN_ERROR: string;
+export declare const PACKAGES_NEED_PYTHON_ERROR: string;
+export declare const FILES_NEED_PYTHON_ERROR: string;
+export declare function videoToolError(command: string, packages: readonly string[] | undefined, python: boolean, network?: boolean): string | null;
+export declare const SHELL_DOWNLOAD_NOTE: string;
+export declare function shellDownloadNote(command: string): string | null;
+export declare function pipError(command: string, sandbox?: boolean): string | null;
+export declare function startsLikePython(command: string): boolean;
+export declare function isPythonSourceShaped(command: string): boolean;
+export declare function pythonRedirectError(command: string, sandbox?: boolean): string | null;

package/dist-lib/lib/tools/exec/shell-guidance.js

@@ -0,0 +1,123 @@
+import { pipInstallTargets, pipMessage, unwrapPythonSource, withoutProgramDir } from './adapters/python/python-adapter.js';
+import { bareBin, firstCommandToken, sanitizeCommand } from './scope.js';
+import { shellArgv } from './shell-argv.js';
+import { downloaderShellError, isTranscoder, TRANSCODE_ERROR, VIDEO_TOOLS_ERROR, videoTool } from './video-tools.js';
+const INTERPRETER = /^(python[\d.]*|py)$/;
+const PIP = /^pip[\d.]*$/;
+export const PYTHON_BIN_ERROR = 'python is not a shell command here. Call exec with language "python" and command set to the ' +
+    'Python source itself: drop "python -c" and the quotes around the code. PyPI names go in packages.';
+export const PACKAGES_NEED_PYTHON_ERROR = 'packages only work with language "python". Call exec with language "python", the same packages ' +
+    'and the Python source in command.';
+export const FILES_NEED_PYTHON_ERROR = 'inputs and outputs only work with language "python". Call exec with language "python" and the ' +
+    'Python source in command.';
+function commandBin(command) {
+    return bareBin(firstCommandToken(command).replace(/^.*[/\\]/, '')) ?? '';
+}
+function dashModule(command) {
+    return /^\s*(?:python[\d.]*|py)\s+-m\s+([\w.-]+)/.exec(withoutProgramDir(command))?.[1] ?? null;
+}
+function importedModules(source) {
+    const modules = [];
+    for (const line of source.split('\n')) {
+        const from = /^\s*from\s+([\w.]+)\s+import\b/.exec(line)?.[1];
+        if (from) {
+            modules.push(from);
+            continue;
+        }
+        const imported = /^\s*import\s+([\w.]+(?:\s*,\s*[\w.]+)*)/.exec(line)?.[1];
+        if (imported)
+            modules.push(...imported.split(',').map((m) => m.trim()));
+    }
+    return modules.map((m) => m.split('.')[0]);
+}
+export function videoToolError(command, packages, python, network = false) {
+    const names = [
+        dashModule(command) ?? '',
+        ...(pipInstallTargets(command) ?? []),
+        ...(packages ?? []),
+        ...(python ? importedModules(unwrapPythonSource(command) ?? command) : [commandBin(command)])
+    ];
+    const tools = names.map(videoTool).filter((tool) => tool !== null);
+    if (tools.length === 0)
+        return null;
+    if (!network)
+        return VIDEO_TOOLS_ERROR;
+    if (tools.some(isTranscoder))
+        return TRANSCODE_ERROR;
+    if (python)
+        return null;
+    const program = videoTool(commandBin(command)) ?? videoTool(dashModule(command) ?? '');
+    return program ? downloaderShellError(program) : null;
+}
+export const SHELL_DOWNLOAD_NOTE = "The file was saved on this device's disk, not in the chat, so the user cannot see it. To " +
+    'give the user a downloaded file, fetch it in exec with language "python" and declare it in outputs.';
+const CURL_VALUED = new Set('AbcCdDeEFHKmoPQrTuUwxXyYz'.split(''));
+const WGET_VALUED = new Set('aABDeIilOoPQRtTUwX'.split(''));
+function writesFile(words, curl) {
+    const valued = curl ? CURL_VALUED : WGET_VALUED;
+    const output = curl ? 'o' : 'O';
+    const long = curl ? '--output' : '--output-document';
+    let saves = !curl;
+    for (let i = 1; i < words.length; i++) {
+        const word = words[i];
+        if (curl && /^--remote-name(-all)?$/.test(word))
+            saves = true;
+        if (word === long || word.startsWith(`${long}=`)) {
+            const value = word === long ? words[++i] : word.slice(long.length + 1);
+            saves = value !== '-';
+            continue;
+        }
+        if (!/^-[A-Za-z]/.test(word))
+            continue;
+        for (let j = 1; j < word.length; j++) {
+            const flag = word[j];
+            if (curl && flag === 'O')
+                saves = true;
+            if (!valued.has(flag))
+                continue;
+            const value = j + 1 < word.length ? word.slice(j + 1) : words[++i];
+            if (flag === output)
+                saves = value !== '-';
+            break;
+        }
+    }
+    return saves;
+}
+export function shellDownloadNote(command) {
+    const bin = commandBin(command);
+    if (bin !== 'curl' && bin !== 'wget')
+        return null;
+    return writesFile(shellArgv(command), bin === 'curl') ? SHELL_DOWNLOAD_NOTE : null;
+}
+export function pipError(command, sandbox = false) {
+    if (!PIP.test(commandBin(command)) && dashModule(command) !== 'pip')
+        return null;
+    return pipMessage(pipInstallTargets(command), sandbox);
+}
+function firstCodeLine(command) {
+    return (command
+        .split('\n')
+        .find((line) => line.trim() && !line.trim().startsWith('#'))
+        ?.trim() ?? '');
+}
+const PYTHON_START = /^(from\s+[\w.]+\s+import\b|import\s+[\w.]+\s*(,|;|$|\sas\s)|def\s+\w+\s*\(|class\s+\w+|@[\w.]+|(for|while|if|with|try|async)\b[^\n]*:$|"""|\'\'\'|[A-Za-z_][\w.]*(\[[^\]]*\])?\s+=\s+)/;
+export function startsLikePython(command) {
+    return PYTHON_START.test(firstCodeLine(command));
+}
+export function isPythonSourceShaped(command) {
+    const first = firstCodeLine(command);
+    if (/^from\s+[\w.]+\s+import\b/.test(first))
+        return true;
+    if (/^[A-Za-z_][\w.]*\s*\(/.test(first) && !/^[A-Za-z_]\w*\s*\(\s*\)\s*\{/.test(first)) {
+        return true;
+    }
+    if (!PYTHON_START.test(first))
+        return false;
+    return command.trim().includes('\n') || sanitizeCommand(command) !== null;
+}
+export function pythonRedirectError(command, sandbox = false) {
+    const pip = pipError(command, sandbox);
+    if (pip)
+        return pip;
+    return INTERPRETER.test(commandBin(command)) ? PYTHON_BIN_ERROR : null;
+}

package/dist-lib/lib/tools/exec/video-tools.d.ts

@@ -0,0 +1,5 @@
+export declare const VIDEO_TOOLS_ERROR: string;
+export declare const TRANSCODE_ERROR: string;
+export declare function downloaderShellError(tool: string): string;
+export declare function videoTool(name: string): string | null;
+export declare function isTranscoder(tool: string): boolean;

package/dist-lib/lib/tools/exec/video-tools.js

@@ -0,0 +1,40 @@
+const TRANSCODERS = new Set([
+    'ffmpeg',
+    'ffprobe',
+    'ffmpeg-python',
+    'imageio-ffmpeg',
+    'moviepy',
+    'avconv',
+    'ytdl'
+]);
+const DOWNLOADERS = new Set([
+    'yt-dlp',
+    'youtube-dl',
+    'you-get',
+    'streamlink',
+    'pytube',
+    'pytubefix'
+]);
+export const VIDEO_TOOLS_ERROR = 'downloading or transcoding video is not possible on this device: yt-dlp, youtube-dl, ffmpeg ' +
+    'and similar tools cannot run here, on any path. Do not retry; tell the user it cannot be done.';
+export const TRANSCODE_ERROR = 'ffmpeg is not available on this device: ffmpeg, ffprobe and the packages that run them ' +
+    '(moviepy, ffmpeg-python) cannot run here, on any path, so nothing can merge or convert ' +
+    'video. Fetch a single file that needs neither, or tell the user it cannot be done.';
+export function downloaderShellError(tool) {
+    return (`${tool} is not a program here: it is a Python package. Call exec with language "python", ` +
+        `packages: ["${tool}"] and Python source that imports it, and declare the file it saves ` +
+        'in outputs so it reaches the user.');
+}
+export function videoTool(name) {
+    const bare = name
+        .trim()
+        .replace(/^['"]|['"]$/g, '')
+        .split(/[=<>!~[\s]/)[0]
+        .toLowerCase()
+        .replace(/\.exe$/, '')
+        .replace(/[-_.]+/g, '-');
+    return TRANSCODERS.has(bare) || DOWNLOADERS.has(bare) ? bare : null;
+}
+export function isTranscoder(tool) {
+    return TRANSCODERS.has(tool);
+}

package/dist-lib/lib/tools/exec.d.ts

@@ -10,6 +10,7 @@ export interface ExecToolOptions {
     readonly killProcess?: KillProcess;
     readonly loadPyodide?: LoadPyodideFn;
     readonly disablePyodide?: boolean;
+    readonly pythonNetwork?: boolean;
     readonly credentialStore?: CredentialStoreFn;
     readonly skillSettings?: SkillSettingsFn;
     readonly realpath?: Realpath;
@@ -26,4 +27,4 @@ export declare function resolveScriptRun(rawArgs: Record<string, unknown>, skill
 } | {
     error: string;
 } | null;
-export declare function createExecTool({ spawn, killProcess, loadPyodide, disablePyodide, credentialStore, skillSettings, realpath, deniedRoots, skillsDir }?: ExecToolOptions): ToolDefinition;
+export declare function createExecTool({ spawn, killProcess, loadPyodide, disablePyodide, pythonNetwork, credentialStore, skillSettings, realpath, deniedRoots, skillsDir }?: ExecToolOptions): ToolDefinition;