@qvac/harness 1.0.0-rc.1 → 1.0.0-rc.2

package/dist-lib/lib/tools/exec/python-source.js

@@ -0,0 +1,243 @@
+import { sanitizeCommand } from './scope.js';
+export function isPythonLanguage(language) {
+    return typeof language === 'string' && language.trim().toLowerCase() === 'python';
+}
+const INTERPS = ['python3', 'python', 'py'];
+const PIPS = ['pip3', 'pip'];
+function isAsciiWs(c) {
+    return c === ' ' || c === '\t' || c === '\n' || c === '\r' || c === '\f';
+}
+function skipWs(s, i) {
+    while (i < s.length && isAsciiWs(s.charAt(i))) {
+        i++;
+    }
+    return i;
+}
+function leadingToken(s, tokens) {
+    for (const t of tokens) {
+        if (!s.startsWith(t))
+            continue;
+        const next = s[t.length];
+        if (next !== undefined && /[A-Za-z0-9_]/.test(next)) {
+            continue;
+        }
+        return t;
+    }
+    return null;
+}
+function unquote(payload) {
+    const quote = payload[0];
+    if (quote !== '"' && quote !== "'") {
+        return payload;
+    }
+    const body = payload.endsWith(quote) ? payload.slice(1, -1) : payload.slice(1);
+    return quote === '"' ? body.replace(/\\"/g, '"') : body;
+}
+function unwrapHeredoc(s) {
+    const interp = leadingToken(s, INTERPS);
+    if (!interp) {
+        return null;
+    }
+    let i = skipWs(s, interp.length);
+    if (!s.startsWith('<<', i)) {
+        return null;
+    }
+    i += 2;
+    if (s[i] === '-') {
+        i++;
+    }
+    i = skipWs(s, i);
+    const open = s.charAt(i);
+    const quote = open === '"' || open === "'" ? open : null;
+    if (quote) {
+        i++;
+    }
+    const tagStart = i;
+    while (i < s.length && /[A-Za-z0-9_]/.test(s.charAt(i))) {
+        i++;
+    }
+    if (i === tagStart) {
+        return null;
+    }
+    const tag = s.slice(tagStart, i);
+    if (quote) {
+        if (s[i] !== quote) {
+            return null;
+        }
+        i++;
+    }
+    while (i < s.length && (s[i] === ' ' || s[i] === '\t')) {
+        i++;
+    }
+    if (s[i] !== '\n') {
+        return null;
+    }
+    i++;
+    const body = s.slice(i);
+    for (let j = 0; j < body.length; j++) {
+        if (body[j] !== '\n')
+            continue;
+        let k = j + 1;
+        const closeInterp = leadingToken(body.slice(k), INTERPS);
+        if (closeInterp) {
+            k += closeInterp.length;
+        }
+        k = skipWs(body, k);
+        if (!body.startsWith(tag, k)) {
+            continue;
+        }
+        k += tag.length;
+        k = skipWs(body, k);
+        if (k === body.length) {
+            return body.slice(0, j).trim();
+        }
+    }
+    return body.trim();
+}
+function unwrapDashC(s) {
+    const interp = leadingToken(s, INTERPS);
+    if (!interp) {
+        return null;
+    }
+    let i = skipWs(s, interp.length);
+    if (!s.startsWith('-c', i)) {
+        return null;
+    }
+    i += 2;
+    if (i >= s.length || !isAsciiWs(s.charAt(i))) {
+        return null;
+    }
+    i = skipWs(s, i);
+    if (i >= s.length) {
+        return null;
+    }
+    const source = unquote(s.slice(i).trim()).trim();
+    return source || null;
+}
+function unwrapBareInterpreter(s) {
+    const interp = leadingToken(s, INTERPS);
+    if (!interp) {
+        return null;
+    }
+    let i = interp.length;
+    while (i < s.length && (s[i] === ' ' || s[i] === '\t')) {
+        i++;
+    }
+    if (s[i] !== '\n') {
+        return null;
+    }
+    const body = s.slice(i + 1).trim();
+    return body || null;
+}
+export function unwrapPythonSource(command) {
+    const trimmed = withoutProgramDir(command).trim();
+    const heredoc = unwrapHeredoc(trimmed);
+    if (heredoc !== null) {
+        return heredoc;
+    }
+    const dashC = unwrapDashC(trimmed);
+    if (dashC !== null) {
+        return dashC;
+    }
+    return unwrapBareInterpreter(trimmed);
+}
+export function withoutProgramDir(command) {
+    return command.trimStart().replace(/^[^\s'"]*[/\\](?=[^\s/\\]+(\s|$))/, '');
+}
+function pipInstallRest(command) {
+    const s = withoutProgramDir(command).trim();
+    let i = 0;
+    const pip = leadingToken(s, PIPS);
+    if (pip) {
+        i = pip.length;
+    }
+    else {
+        const interp = leadingToken(s, INTERPS);
+        if (!interp) {
+            return null;
+        }
+        i = skipWs(s, interp.length);
+        if (!s.startsWith('-m', i)) {
+            return null;
+        }
+        i += 2;
+        if (i >= s.length || !isAsciiWs(s.charAt(i))) {
+            return null;
+        }
+        i = skipWs(s, i);
+        if (!s.startsWith('pip', i)) {
+            return null;
+        }
+        const after = s[i + 3];
+        if (after !== undefined && /[A-Za-z0-9_]/.test(after)) {
+            return null;
+        }
+        i += 3;
+    }
+    if (i >= s.length || !isAsciiWs(s.charAt(i))) {
+        return null;
+    }
+    i = skipWs(s, i);
+    if (!s.startsWith('install', i)) {
+        return null;
+    }
+    i += 'install'.length;
+    if (i >= s.length || !isAsciiWs(s.charAt(i))) {
+        return null;
+    }
+    i = skipWs(s, i);
+    if (i >= s.length) {
+        return null;
+    }
+    return s.slice(i);
+}
+const REQUIREMENT = /^[A-Za-z0-9][A-Za-z0-9._-]*(\[[A-Za-z0-9,._-]+\])?([=<>!~]=?[^\s]+)?$/;
+export function pipInstallTargets(command) {
+    const rest = pipInstallRest(command);
+    if (!rest) {
+        return null;
+    }
+    const targets = [];
+    for (const raw of rest.split(/\s+/)) {
+        if (/[|;&<>()`$]/.test(raw))
+            break;
+        const token = raw.replace(/^['"]|['"]$/g, '');
+        if (/^(-r|--requirement|-e|--editable|-c|--constraint|-f|--find-links)$/.test(token)) {
+            return null;
+        }
+        if (!token || token.startsWith('-')) {
+            continue;
+        }
+        if (!REQUIREMENT.test(token)) {
+            return null;
+        }
+        if (/^pip3?$/i.test(token.split(/[=<>!~[]/)[0] ?? '')) {
+            continue;
+        }
+        targets.push(token);
+    }
+    return targets.length > 0 ? targets : null;
+}
+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;
+}

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

@@ -1,62 +1,41 @@
 import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
-export interface ExecAttachment {
-    readonly attachmentId: string;
-    readonly fileName: string;
-    readonly byteLength: number;
-}
-export interface RejectedOutput {
-    readonly name: string;
-    readonly reason: string;
-}
-export interface ExecResult {
-    readonly stdout: string;
-    readonly stderr: string;
-    readonly exitCode: number;
-    readonly attachments?: readonly ExecAttachment[];
-    readonly missingOutputs?: readonly string[];
-    readonly rejectedOutputs?: readonly RejectedOutput[];
-}
-export interface SpawnOptions {
-    cwd?: string;
-    shell?: boolean;
-    detached?: boolean;
-    stdio?: [string, string, string] | string;
-    env?: Record<string, string>;
-}
-export interface Child {
-    readonly pid?: number;
-    readonly stdout: {
-        on(event: 'data', handler: (chunk: Buffer | string) => void): void;
-    } | null;
-    readonly stderr: {
-        on(event: 'data', handler: (chunk: Buffer | string) => void): void;
-    } | null;
-    kill(signum?: number | string): void;
-    on(event: 'exit', handler: (code: number | null, signal?: string | null) => void): void;
-    on(event: 'error', handler: (err: Error) => void): void;
-}
-export type SpawnFn = (command: string, opts?: SpawnOptions) => Child;
+import type { SpillSink, ToolSpill } from '../../contract/index.ts';
+import type { ExecResult, KillProcess, SpawnFn } from '../../contract/exec.ts';
+export type { Child, ExecAttachment, ExecResult, KillProcess, RejectedOutput, SpawnFn, SpawnOptions } from '../../contract/exec.ts';
 export interface RunCommandOptions {
     readonly cwd?: string;
     readonly env?: Readonly<Record<string, string>>;
     readonly timeoutMs?: number;
     readonly maxOutputChars?: number;
     readonly signal?: BareAbortSignal;
+    readonly spill?: ToolSpill;
     readonly spawn: SpawnFn;
     readonly killProcess?: KillProcess;
     readonly platform?: string;
 }
+export declare const DEFAULT_TIMEOUT_MS = 120000;
 export declare const MAX_OUTPUT_CHARS = 8192;
 export declare const MAX_OUTPUT_CHARS_LIMIT = 65536;
-export declare const TRUNCATED_OUTPUT_SUFFIX = "\u2026 [truncated]";
-export type KillProcess = (pid: number, signal: string) => void;
 interface CapturedOutput {
-    value: string;
-    truncated: boolean;
+    readonly limit: number;
+    readonly sink?: SpillSink;
+    head: string;
+    tail: string;
+    total: number;
 }
 export declare function capOutput(text: string, limit: number): string;
-export declare function appendOutput(output: CapturedOutput, chunk: Buffer | string, limit: number): void;
-export declare function formatOutput(output: CapturedOutput): string;
-export declare function createCapturedOutput(): CapturedOutput;
+export declare function appendOutput(output: CapturedOutput, chunk: Buffer | string): void;
+export declare function formatOutput(output: CapturedOutput, locator?: string | null): string;
+export declare function createCapturedOutput(limit: number, sink?: SpillSink): CapturedOutput;
+export interface StartCommandOptions {
+    readonly cwd?: string;
+    readonly spawn: SpawnFn;
+    readonly killProcess?: KillProcess;
+    readonly platform?: string;
+}
+export interface StartedCommand {
+    readonly exited: Promise<number>;
+    stop(): Promise<void>;
+}
+export declare function startCommand(command: string, options: StartCommandOptions): StartedCommand;
 export declare function runCommand(command: string, options: RunCommandOptions): Promise<ExecResult>;
-export {};

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

@@ -1,47 +1,81 @@
 import b4a from 'b4a';
 import process from 'process';
+import { headTail, joinHeadTail } from '../../helpers/head-tail.js';
 import { AbortedError } from '../../helpers/race-abort.js';
-const DEFAULT_TIMEOUT_MS = 120_000;
+export const DEFAULT_TIMEOUT_MS = 120_000;
+const STOP_GRACE_MS = 2_000;
 export const MAX_OUTPUT_CHARS = 8_192;
 export const MAX_OUTPUT_CHARS_LIMIT = 65_536;
-export const TRUNCATED_OUTPUT_SUFFIX = '… [truncated]';
 export function capOutput(text, limit) {
-    const body = text.endsWith(TRUNCATED_OUTPUT_SUFFIX)
-        ? text.slice(0, -TRUNCATED_OUTPUT_SUFFIX.length)
-        : text;
-    if (body.length <= limit) {
-        return body === text ? text : `${body}${TRUNCATED_OUTPUT_SUFFIX}`;
-    }
-    return `${body.slice(0, limit)}${TRUNCATED_OUTPUT_SUFFIX}`;
+    return headTail(text, limit);
 }
-export function appendOutput(output, chunk, limit) {
-    if (output.truncated)
-        return;
-    const available = limit - output.value.length;
-    if (available <= 0) {
-        output.truncated = true;
-        return;
-    }
+export function appendOutput(output, chunk) {
     const text = typeof chunk === 'string' ? chunk : b4a.toString(chunk, 'utf8');
-    output.value += text.slice(0, available);
-    output.truncated = text.length > available;
+    if (output.sink && output.total + text.length > output.limit) {
+        output.sink.write(output.total > output.limit ? text : output.head + text);
+    }
+    if (output.head.length < output.limit) {
+        output.head += text.slice(0, output.limit - output.head.length);
+    }
+    output.tail = (output.tail + text.slice(-output.limit)).slice(-output.limit);
+    output.total += text.length;
 }
-export function formatOutput(output) {
-    return output.truncated ? `${output.value}${TRUNCATED_OUTPUT_SUFFIX}` : output.value;
+export function formatOutput(output, locator) {
+    return output.total <= output.limit ? output.head : joinHeadTail(output, output.limit, locator);
 }
-export function createCapturedOutput() {
-    return { value: '', truncated: false };
+export function createCapturedOutput(limit, sink) {
+    return { limit, sink, head: '', tail: '', total: 0 };
 }
-function terminateProcessTree(child, killProcess) {
+function terminateProcessTree(child, killProcess, signal = 'SIGTERM') {
     if (child.pid !== undefined && killProcess) {
         try {
-            killProcess(-child.pid, 'SIGTERM');
+            killProcess(-child.pid, signal);
             return;
         }
         catch {
         }
     }
-    child.kill('SIGTERM');
+    try {
+        child.kill(signal);
+    }
+    catch {
+    }
+}
+export function startCommand(command, options) {
+    const child = options.spawn(command, {
+        shell: true,
+        detached: (options.platform ?? process.platform) !== 'win32',
+        stdio: ['ignore', 'ignore', 'ignore'],
+        cwd: options.cwd
+    });
+    let running = true;
+    const exited = new Promise((resolve) => {
+        child.on('exit', (code) => resolve(code ?? 1));
+        child.on('error', () => resolve(1));
+    }).finally(() => {
+        running = false;
+    });
+    let stopping = null;
+    const stop = async () => {
+        if (!running) {
+            return;
+        }
+        terminateProcessTree(child, options.killProcess);
+        let timer;
+        await Promise.race([
+            exited,
+            new Promise((resolve) => (timer = setTimeout(resolve, STOP_GRACE_MS)))
+        ]);
+        clearTimeout(timer);
+        terminateProcessTree(child, options.killProcess, 'SIGKILL');
+    };
+    return {
+        exited,
+        stop() {
+            stopping ??= stop();
+            return stopping;
+        }
+    };
 }
 export function runCommand(command, options) {
     const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
@@ -50,8 +84,8 @@ export function runCommand(command, options) {
         return Promise.reject(new AbortedError());
     }
     return new Promise((resolve, reject) => {
-        const stdout = { value: '', truncated: false };
-        const stderr = { value: '', truncated: false };
+        const stdout = createCapturedOutput(maxOutputChars, options.spill?.sink('stdout'));
+        const stderr = createCapturedOutput(maxOutputChars, options.spill?.sink('stderr'));
         let settled = false;
         const child = options.spawn(command, {
             shell: true,
@@ -66,7 +100,7 @@ export function runCommand(command, options) {
             settled = true;
             clearTimeout(timer);
             options.signal?.removeEventListener('abort', onAbort);
-            fn();
+            Promise.all([stdout.sink?.close(), stderr.sink?.close()]).then(fn);
         };
         const onAbort = () => {
             finish(() => reject(new AbortedError()));
@@ -77,12 +111,12 @@ export function runCommand(command, options) {
             finish(() => reject(new Error(`Command timed out after ${timeoutMs}ms`)));
             terminateProcessTree(child, options.killProcess);
         }, timeoutMs);
-        child.stdout?.on('data', (chunk) => appendOutput(stdout, chunk, maxOutputChars));
-        child.stderr?.on('data', (chunk) => appendOutput(stderr, chunk, maxOutputChars));
+        child.stdout?.on('data', (chunk) => appendOutput(stdout, chunk));
+        child.stderr?.on('data', (chunk) => appendOutput(stderr, chunk));
         child.on('error', (err) => finish(() => reject(err)));
-        child.on('exit', (code) => finish(() => resolve({
-            stdout: formatOutput(stdout),
-            stderr: formatOutput(stderr),
+        child.on('exit', (code) => finish(([out, err]) => resolve({
+            stdout: formatOutput(stdout, out),
+            stderr: formatOutput(stderr, err),
             exitCode: code ?? 1
         })));
     });

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

@@ -1,3 +1,5 @@
 export declare function bareBin(token: string): string | null;
 export declare function firstCommandToken(command: string): string;
+export declare function escapeLiteralDollars(command: string): string;
+export declare const SHELL_EXPANSION_ERROR: string;
 export declare function sanitizeCommand(command: string): string | null;

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

@@ -50,12 +50,43 @@ function skipDoubleQuoted(chars, open) {
             return 'command must not use backtick substitution';
         }
         if (chars[i] === '$') {
-            return 'command must not use shell expansion';
+            return SHELL_EXPANSION_ERROR;
         }
         i++;
     }
     return i + 1;
 }
+const EXPANDS = /[A-Za-z_{(?#@*!$-]/;
+export function escapeLiteralDollars(command) {
+    const chars = [...command];
+    let out = '';
+    let quoted = false;
+    for (let i = 0; i < chars.length; i++) {
+        const c = chars[i] ?? '';
+        if (c === "'" && !quoted) {
+            const end = chars.indexOf("'", i + 1);
+            const stop = end === -1 ? chars.length : end + 1;
+            out += chars.slice(i, stop).join('');
+            i = stop - 1;
+            continue;
+        }
+        if (c === '\\') {
+            out += c + (chars[i + 1] ?? '');
+            i++;
+            continue;
+        }
+        if (c === '"') {
+            quoted = !quoted;
+        }
+        if (c === '$' && !EXPANDS.test(chars[i + 1] ?? '')) {
+            out += '\\';
+        }
+        out += c;
+    }
+    return out;
+}
+export const SHELL_EXPANSION_ERROR = 'command must not use shell expansion: $ outside single quotes is expanded by the shell. ' +
+    "Put text containing $ (prices, amounts) in single quotes, e.g. content='Total: $1,348'";
 export function sanitizeCommand(command) {
     const chars = [...command];
     let i = 0;
@@ -98,7 +129,7 @@ export function sanitizeCommand(command) {
             return 'command must not use backtick substitution';
         }
         if (c === '$') {
-            return 'command must not use shell expansion';
+            return SHELL_EXPANSION_ERROR;
         }
         if (c === ';') {
             return 'command must not chain with ;';

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

@@ -1,15 +1,17 @@
-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 const PYTHON_UNAVAILABLE_ERROR: string;
+export declare const LANGUAGE_UNAVAILABLE_ERROR: string;
+export declare const PIP_UNAVAILABLE_ERROR: string;
+export declare function commandBin(command: string): string;
+export declare function dashModule(command: string): string | null;
+export declare function runsPip(command: string): boolean;
+export declare function runsInterpreter(command: string): boolean;
 export interface VideoToolCall {
     packages?: readonly string[] | undefined;
     python: boolean;
     network?: boolean;
 }
 export declare function videoToolError(command: string, { packages, python, network }: VideoToolCall): 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;
+export declare function shellDownloader(command: string): string | null;
+export declare const SHELL_DOWNLOAD_NOTE = "The file was saved on this device's disk, not in the chat, so the user cannot see it.";
+export declare function savesDownload(command: string): boolean;
+export declare function shellOnlyError(command: string): string | null;

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

@@ -1,21 +1,27 @@
-import { pipInstallTargets, pipMessage, unwrapPythonSource, withoutProgramDir } from './adapters/python/python-adapter.js';
-import { bareBin, firstCommandToken, sanitizeCommand } from './scope.js';
+import { pipInstallTargets, unwrapPythonSource, withoutProgramDir } from './python-source.js';
+import { bareBin, firstCommandToken } from './scope.js';
 import { shellArgv } from './shell-argv.js';
-import { downloaderShellError, isTranscoder, TRANSCODE_ERROR, VIDEO_TOOLS_ERROR, videoTool } from './video-tools.js';
+import { 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) {
+export const PYTHON_UNAVAILABLE_ERROR = 'Python is not available here, and no exec call runs it. Use a shell command, or tell the ' +
+    'user it cannot be done.';
+export const LANGUAGE_UNAVAILABLE_ERROR = 'That language is not available here, and no exec call runs it. Use a shell command, or tell ' +
+    'the user it cannot be done.';
+export const PIP_UNAVAILABLE_ERROR = 'pip is not available here, and no exec call installs Python packages. Use a shell command, ' +
+    'or tell the user it cannot be done.';
+export function commandBin(command) {
     return bareBin(firstCommandToken(command).replace(/^.*[/\\]/, '')) ?? '';
 }
-function dashModule(command) {
+export function dashModule(command) {
     return /^\s*(?:python[\d.]*|py)\s+-m\s+([\w.-]+)/.exec(withoutProgramDir(command))?.[1] ?? null;
 }
+export function runsPip(command) {
+    return PIP.test(commandBin(command)) || dashModule(command) === 'pip';
+}
+export function runsInterpreter(command) {
+    return INTERPRETER.test(commandBin(command));
+}
 function importedModules(source) {
     const modules = [];
     for (const line of source.split('\n')) {
@@ -45,17 +51,12 @@ export function videoToolError(command, { packages, python, network = false }) {
     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;
+    return tools.some(isTranscoder) ? TRANSCODE_ERROR : null;
+}
+export function shellDownloader(command) {
+    return videoTool(commandBin(command)) ?? videoTool(dashModule(command) ?? '');
 }
-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.';
+export const SHELL_DOWNLOAD_NOTE = "The file was saved on this device's disk, not in the chat, so the user cannot see it.";
 const CURL_VALUED = new Set('AbcCdDeEFHKmoPQrTuUwxXyYz'.split(''));
 const WGET_VALUED = new Set('aABDeIilOoPQRtTUwX'.split(''));
 function writesFile(words, curl) {
@@ -93,46 +94,16 @@ function writesFile(words, curl) {
     }
     return saves;
 }
-export function shellDownloadNote(command) {
+export function savesDownload(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;
+    return writesFile(shellArgv(command), bin === 'curl');
 }
-export function pythonRedirectError(command, sandbox = false) {
-    const pip = pipError(command, sandbox);
-    if (pip) {
-        return pip;
+export function shellOnlyError(command) {
+    if (runsPip(command)) {
+        return PIP_UNAVAILABLE_ERROR;
     }
-    return INTERPRETER.test(commandBin(command)) ? PYTHON_BIN_ERROR : null;
+    return runsInterpreter(command) ? PYTHON_UNAVAILABLE_ERROR : null;
 }