@qvac/harness 0.4.0 → 0.6.0

package/dist-lib/lib/tools/exec/adapters/python/create-effect.js

@@ -1,4 +1,4 @@
-import { IMAGE_INPUT, OFFICE_READ, PDF_READ, isEscaped, parseInputs, parseOutputs, parsePackages, stripCommentsAndDocstrings, unwrapPythonSource } from './python-adapter.js';
+import { IMAGE_INPUT, OFFICE_READ, PDF_READ, isEscaped, parseInputs, parseOutputs, parsePackages, stripCommentsAndDocstrings, tripleQuoteAt, unwrapPythonSource } from './python-adapter.js';
 const ARTIFACT_OUTPUT = /\.(docx|xlsx|pptx|pdf)$/i;
 const CREATE_PACKAGES = new Map([
     ['python-docx', '1.2.0'],
@@ -126,13 +126,14 @@ export function splitPythonSource(source) {
             }
             continue;
         }
-        const triple = source.startsWith('"""', i) ? '"""' : source.startsWith("'''", i) ? "'''" : null;
+        const triple = tripleQuoteAt(source, i);
         const quote = triple ?? (ch === '"' || ch === "'" ? ch : null);
         if (quote) {
             const fstring = isFStringPrefix(code);
-            const end = scanLiteral(source, i + quote.length, quote, fstring);
-            if (!end)
+            const end = scanLiteral(source, i + quote.length, { quote, fstring });
+            if (!end) {
                 return null;
+            }
             code += '""';
             text += end.text;
             code += end.code;
@@ -144,7 +145,7 @@ export function splitPythonSource(source) {
     }
     return { code, text };
 }
-function scanLiteral(source, start, quote, fstring) {
+function scanLiteral(source, start, { quote, fstring }) {
     let text = '';
     let code = '';
     let i = start;
@@ -159,11 +160,13 @@ function scanLiteral(source, start, quote, fstring) {
                 i += 2;
                 continue;
             }
-            if (ch === '}')
+            if (ch === '}') {
                 return null;
+            }
             const interior = scanInterpolation(source, i + 1);
-            if (!interior)
+            if (!interior) {
                 return null;
+            }
             code += ` ${interior.code} `;
             text += interior.text;
             i = interior.index;
@@ -183,10 +186,12 @@ function scanInterpolation(source, start) {
     while (i < source.length) {
         const ch = source[i];
         if (nested) {
-            if (ch === nested && !isEscaped(source, i))
+            if (ch === nested && !isEscaped(source, i)) {
                 nested = null;
-            else
+            }
+            else {
                 text += ch;
+            }
             i++;
             continue;
         }
@@ -195,12 +200,14 @@ function scanInterpolation(source, start) {
             i++;
             continue;
         }
-        if (ch === '{')
+        if (ch === '{') {
             depth++;
+        }
         if (ch === '}') {
             depth--;
-            if (depth === 0)
+            if (depth === 0) {
                 return { index: i + 1, text, code };
+            }
         }
         code += ch;
         i++;
@@ -210,81 +217,102 @@ function scanInterpolation(source, start) {
 function isKeywordArgument(code, start, length) {
     const before = code.slice(0, start).trimEnd();
     const last = before[before.length - 1];
-    if (last !== '(' && last !== ',')
+    if (last !== '(' && last !== ',') {
         return false;
+    }
     const after = code.slice(start + length).trimStart();
     return after.startsWith('=') && after[1] !== '=';
 }
 function lintCreateSource(source) {
     const halves = splitPythonSource(source);
-    if (!halves)
+    if (!halves) {
         return 'write';
-    if (halves.text.includes('__'))
+    }
+    if (halves.text.includes('__')) {
         return 'write';
-    if (/\\(?:x[0-9A-Fa-f]|u[0-9A-Fa-f]|U[0-9A-Fa-f]|N\{|[0-7])/.test(halves.text))
+    }
+    if (/\\(?:x[0-9A-Fa-f]|u[0-9A-Fa-f]|U[0-9A-Fa-f]|N\{|[0-7])/.test(halves.text)) {
         return 'write';
-    if (/[^\x20-\x7e\t\r\n\f]/.test(halves.code))
+    }
+    if (/[^\x20-\x7e\t\r\n\f]/.test(halves.code)) {
         return 'write';
+    }
     let builder = false;
     for (const line of halves.code.split('\n')) {
         for (const statement of line.split(';')) {
             if (!/\b(?:from|import)\b/.test(statement))
                 continue;
             const match = IMPORT_FROM.exec(statement);
-            if (!match)
+            if (!match) {
                 return 'write';
+            }
             const root = match[1].split('.')[0];
-            if (!IMPORT_ROOTS.has(root))
+            if (!IMPORT_ROOTS.has(root)) {
                 return 'write';
-            if (BUILDER_ROOTS.has(root))
+            }
+            if (BUILDER_ROOTS.has(root)) {
                 builder = true;
+            }
         }
     }
-    if (!builder)
+    if (!builder) {
         return 'write';
+    }
     for (const match of halves.code.matchAll(/[A-Za-z_]\w*/g)) {
         const token = match[0];
         if (token.includes('__') || DENIED_TOKENS.has(token) || INTROSPECTION_TOKEN.test(token)) {
             return 'write';
         }
-        if (isKeywordArgument(halves.code, match.index, token.length))
+        if (isKeywordArgument(halves.code, match.index, token.length)) {
             continue;
-        if (PYTHON_BUILTINS.has(token) && !ALLOWED_BUILTINS.has(token))
+        }
+        if (PYTHON_BUILTINS.has(token) && !ALLOWED_BUILTINS.has(token)) {
             return 'write';
+        }
     }
     const openers = stripCommentsAndDocstrings(source);
     const reads = [new RegExp(OFFICE_READ.source), new RegExp(PDF_READ.source)];
-    if (reads.some((pattern) => pattern.test(openers)))
+    if (reads.some((pattern) => pattern.test(openers))) {
         return 'write';
+    }
     return 'read';
 }
 export function pythonCreateEffect(args) {
     const outputs = parseOutputs(args.outputs);
-    if (!Array.isArray(outputs) || outputs.length === 0)
+    if (!Array.isArray(outputs) || outputs.length === 0) {
         return 'write';
-    if (!outputs.every((name) => ARTIFACT_OUTPUT.test(name)))
+    }
+    if (!outputs.every((name) => ARTIFACT_OUTPUT.test(name))) {
         return 'write';
+    }
     const packages = parsePackages(args.packages);
-    if (packages && 'error' in packages)
+    if (packages && 'error' in packages) {
         return 'write';
+    }
     for (const spec of packages ?? []) {
         const match = PACKAGE_SPEC.exec(spec);
-        if (!match)
+        if (!match) {
             return 'write';
+        }
         const name = match[1].toLowerCase().replace(/[_.]+/g, '-');
-        if (!CREATE_PACKAGES.has(name))
+        if (!CREATE_PACKAGES.has(name)) {
             return 'write';
-        if (CREATE_PACKAGES.get(name) !== (match[2] ?? null))
+        }
+        if (CREATE_PACKAGES.get(name) !== (match[2] ?? null)) {
             return 'write';
+        }
     }
     const inputs = parseInputs(args.inputs);
-    if (inputs && 'error' in inputs)
+    if (inputs && 'error' in inputs) {
         return 'write';
-    if ((inputs ?? []).some((input) => !IMAGE_INPUT.test(input.path)))
+    }
+    if ((inputs ?? []).some((input) => !IMAGE_INPUT.test(input.path))) {
         return 'write';
+    }
     const command = String(args.command ?? '');
     const source = unwrapPythonSource(command) ?? command;
-    if (!source.trim())
+    if (!source.trim()) {
         return 'write';
+    }
     return lintCreateSource(source);
 }

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

@@ -3,29 +3,32 @@ import type { NoRedirectFetchInit, NoRedirectFetchResponse } from '../../../../n
 export declare const MAX_RESPONSE_BYTES: number;
 type NoRedirectFetch = (url: URL, init?: NoRedirectFetchInit) => Promise<NoRedirectFetchResponse>;
 declare const GUARDED: unique symbol;
-export type ConnectPolicy = {
+export interface ConnectPolicy {
     readonly named: readonly string[];
     readonly ask: (host: string) => Promise<boolean>;
-};
+}
 export declare function setConnectPolicy(next: ConnectPolicy | null): void;
 export declare function isGuardedFetch(fetch: unknown): boolean;
-type SignalLike = {
+interface SignalLike {
     readonly aborted: boolean;
     addEventListener(type: 'abort', listener: () => void): void;
-};
-type FetchInit = {
+}
+interface RequestLike {
+    url: string;
+}
+interface FetchInit {
     method?: string;
     headers?: unknown;
     body?: unknown;
     signal?: SignalLike | null;
     redirect?: string;
-};
-export type GuardedFetchOptions = {
+}
+export interface GuardedFetchOptions {
     readonly fetch?: NoRedirectFetch;
     readonly resolveHost?: HostResolver;
     readonly maxBytes?: number;
     readonly timeoutMs?: number;
-};
+}
 declare class GuardedHeaders {
     #private;
     constructor(entries: [string, string][]);
@@ -37,6 +40,24 @@ declare class GuardedHeaders {
     forEach(fn: (value: string, key: string) => void): void;
     [Symbol.iterator](): IterableIterator<[string, string]>;
 }
+export interface GuardedResponseInit {
+    readonly status: number;
+    readonly headers: [string, string][];
+    readonly url: string;
+    readonly redirected: boolean;
+}
+interface BodyChunk {
+    done: boolean;
+    value?: Uint8Array;
+}
+interface BodyReader {
+    read(): Promise<BodyChunk>;
+    cancel(): Promise<void>;
+    releaseLock(): void;
+}
+interface ResponseBody {
+    getReader(): BodyReader;
+}
 export declare class GuardedResponse {
     #private;
     readonly type = "basic";
@@ -45,28 +66,18 @@ export declare class GuardedResponse {
     readonly headers: GuardedHeaders;
     readonly url: string;
     readonly redirected: boolean;
-    constructor(status: number, headers: [string, string][], bytes: Uint8Array, url: string, redirected: boolean);
+    constructor(bytes: Uint8Array, { status, headers, url, redirected }: GuardedResponseInit);
     get ok(): boolean;
     get bodyUsed(): boolean;
-    get body(): {
-        getReader(): {
-            read(): Promise<{
-                done: boolean;
-                value?: Uint8Array;
-            }>;
-            cancel(): Promise<void>;
-            releaseLock(): void;
-        };
-    };
+    get body(): ResponseBody;
     arrayBuffer(): Promise<ArrayBuffer>;
     bytes(): Promise<Uint8Array>;
     text(): Promise<string>;
     json(): Promise<unknown>;
     clone(): GuardedResponse;
 }
-export declare function createGuardedFetch(options?: GuardedFetchOptions): ((input: string | URL | {
-    url: string;
-}, init?: FetchInit) => Promise<GuardedResponse>) & {
+type GuardedFetch = ((input: string | URL | RequestLike, init?: FetchInit) => Promise<GuardedResponse>) & {
     [GUARDED]: true;
 };
+export declare function createGuardedFetch(options?: GuardedFetchOptions): GuardedFetch;
 export {};

package/dist-lib/lib/tools/exec/adapters/python/guarded-fetch.js

@@ -1,6 +1,6 @@
 import { AbortController } from 'bare-abort-controller';
 import b4a from 'b4a';
-import defaultFetch from '#no-redirect-fetch';
+import { noRedirectFetch } from '#no-redirect-fetch';
 import { lookupHost } from '../../../../dns-lookup.js';
 import { hostIsNamed } from './named-hosts.js';
 import { checkOutboundHost, resolveOutboundUrl } from '../../../url-guard.js';
@@ -16,28 +16,35 @@ export function setConnectPolicy(next) {
     granted.clear();
 }
 async function mayConnect(host) {
-    if (!policy || granted.has(host) || hostIsNamed(host, policy.named))
+    if (!policy || granted.has(host) || hostIsNamed(host, policy.named)) {
         return true;
+    }
     const allowed = await policy.ask(host);
-    if (allowed)
+    if (allowed) {
         granted.add(host);
+    }
     return allowed;
 }
 export function isGuardedFetch(fetch) {
-    return typeof fetch === 'function' && fetch[GUARDED] === true;
+    return typeof fetch === 'function' && GUARDED in fetch && fetch[GUARDED] === true;
 }
 function isRedirect(status) {
     return status === 301 || status === 302 || status === 303 || status === 307 || status === 308;
 }
+function headerPairs(headers) {
+    if (Array.isArray(headers))
+        return headers;
+    if ('entries' in headers && typeof headers.entries === 'function') {
+        return headers.entries();
+    }
+    return Object.entries(headers);
+}
 function headerRecord(headers) {
     const out = {};
-    if (!headers || typeof headers !== 'object')
+    if (!headers || typeof headers !== 'object') {
         return out;
-    const pairs = Array.isArray(headers)
-        ? headers
-        : typeof headers.entries === 'function'
-            ? headers.entries()
-            : Object.entries(headers);
+    }
+    const pairs = headerPairs(headers);
     for (const pair of pairs) {
         if (!Array.isArray(pair) || pair.length < 2)
             continue;
@@ -50,10 +57,12 @@ function bodyBytes(body) {
         return undefined;
     if (typeof body === 'string')
         return body;
-    if (body instanceof ArrayBuffer)
+    if (body instanceof ArrayBuffer) {
         return new Uint8Array(body);
-    if (ArrayBuffer.isView(body))
+    }
+    if (ArrayBuffer.isView(body)) {
         return new Uint8Array(body.buffer, body.byteOffset, body.byteLength);
+    }
     return String(body);
 }
 function plain(bytes) {
@@ -95,7 +104,7 @@ export class GuardedResponse {
     redirected;
     #bytes;
     #used = false;
-    constructor(status, headers, bytes, url, redirected) {
+    constructor(bytes, { status, headers, url, redirected }) {
         this.status = status;
         this.headers = new GuardedHeaders(headers);
         this.#bytes = bytes;
@@ -116,8 +125,9 @@ export class GuardedResponse {
                 this.#used = true;
                 return {
                     read: async () => {
-                        if (offset >= bytes.byteLength)
+                        if (offset >= bytes.byteLength) {
                             return { done: true };
+                        }
                         const value = plain(bytes.subarray(offset, offset + CHUNK_BYTES));
                         offset += value.byteLength;
                         return { done: false, value };
@@ -132,8 +142,7 @@ export class GuardedResponse {
     }
     async arrayBuffer() {
         this.#used = true;
-        const { buffer, byteOffset, byteLength } = this.#bytes;
-        return buffer.slice(byteOffset, byteOffset + byteLength);
+        return new Uint8Array(this.#bytes).buffer;
     }
     async bytes() {
         return new Uint8Array(await this.arrayBuffer());
@@ -146,11 +155,16 @@ export class GuardedResponse {
         return JSON.parse(await this.text());
     }
     clone() {
-        return new GuardedResponse(this.status, [...this.headers.entries()], this.#bytes, this.url, this.redirected);
+        return new GuardedResponse(this.#bytes, {
+            status: this.status,
+            headers: [...this.headers.entries()],
+            url: this.url,
+            redirected: this.redirected
+        });
     }
 }
 export function createGuardedFetch(options = {}) {
-    const send = options.fetch ?? defaultFetch;
+    const send = options.fetch ?? noRedirectFetch;
     const resolveHost = options.resolveHost ?? lookupHost;
     const maxBytes = options.maxBytes ?? MAX_RESPONSE_BYTES;
     const timeoutMs = options.timeoutMs ?? TIMEOUT_MS;
@@ -161,8 +175,9 @@ export function createGuardedFetch(options = {}) {
         const headers = headerRecord(init.headers);
         const controller = new AbortController();
         const timer = setTimeout(() => controller.abort(undefined), timeoutMs);
-        if (init.signal?.aborted)
+        if (init.signal?.aborted) {
             controller.abort(undefined);
+        }
         init.signal?.addEventListener('abort', () => controller.abort(undefined));
         try {
             for (let hops = 0;; hops++) {
@@ -170,14 +185,16 @@ export function createGuardedFetch(options = {}) {
                     throw new TypeError(`fetch refused: unsupported protocol ${url.protocol}`);
                 }
                 const literal = checkOutboundHost(url);
-                if (literal)
+                if (literal) {
                     throw new TypeError(`fetch refused: ${literal}`);
+                }
                 if (!(await mayConnect(url.hostname))) {
                     throw new TypeError(`fetch refused: ${url.hostname} was not approved for this run`);
                 }
                 const check = await resolveOutboundUrl(url, resolveHost, controller.signal);
-                if (check.blocked)
+                if (check.blocked) {
                     throw new TypeError(`fetch refused: ${check.blocked}`);
+                }
                 const response = await send(url, {
                     method,
                     headers,
@@ -188,18 +205,22 @@ export function createGuardedFetch(options = {}) {
                 });
                 const location = response.headers.get('location');
                 if (!isRedirect(response.status) || !location || init.redirect === 'manual') {
-                    return new GuardedResponse(response.status, response.headers.entries(), plain(response.bytes()), url.href, hops > 0);
+                    return new GuardedResponse(plain(response.bytes()), {
+                        status: response.status,
+                        headers: response.headers.entries(),
+                        url: url.href,
+                        redirected: hops > 0
+                    });
                 }
-                if (init.redirect === 'error')
+                if (init.redirect === 'error') {
                     throw new TypeError('fetch refused: redirect not allowed');
-                if (hops >= MAX_REDIRECTS)
+                }
+                if (hops >= MAX_REDIRECTS) {
                     throw new TypeError('fetch refused: too many redirects');
+                }
                 const next = new URL(location, url);
                 if (next.protocol !== url.protocol || next.host !== url.host) {
-                    for (const name of Object.keys(headers)) {
-                        if (/^(authorization|cookie)$/i.test(name))
-                            delete headers[name];
-                    }
+                    stripCredentials(headers);
                 }
                 if (response.status === 303 ||
                     ((response.status === 301 || response.status === 302) && method === 'POST')) {
@@ -215,8 +236,16 @@ export function createGuardedFetch(options = {}) {
     };
     const fetch = (input, init) => {
         const response = guardedFetch(input, init);
-        response.catch(() => { });
+        response.catch(noop);
         return response;
     };
     return Object.assign(fetch, { [GUARDED]: true });
 }
+function stripCredentials(headers) {
+    for (const name of Object.keys(headers)) {
+        if (/^(authorization|cookie)$/i.test(name)) {
+            delete headers[name];
+        }
+    }
+}
+function noop() { }

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

@@ -1,5 +1,5 @@
-export type InterruptTimer = {
+export interface InterruptTimer {
     readonly interrupt: Uint8Array;
     disarm(): boolean;
-};
+}
 export declare function startInterruptTimer(ms: number): InterruptTimer;

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

@@ -15,12 +15,15 @@ class B4aTextDecoder {
     encoding;
     constructor(label = 'utf-8') {
         const normalized = String(label).toLowerCase();
-        if (normalized.includes('16'))
+        if (normalized.includes('16')) {
             this.encoding = 'utf16le';
-        else if (/latin1|iso-8859|ascii/.test(normalized))
+        }
+        else if (/latin1|iso-8859|ascii/.test(normalized)) {
             this.encoding = 'latin1';
-        else
+        }
+        else {
             this.encoding = 'utf8';
+        }
     }
     decode(input) {
         if (input === undefined)
@@ -39,13 +42,15 @@ class B4aTextEncoder {
 export function nodeShapedProcess(base) {
     return new Proxy(base, {
         get(target, prop) {
-            if (prop === 'versions')
+            if (prop === 'versions') {
                 return { ...target.versions, node: '22.0.0' };
+            }
             if (prop === 'binding') {
                 return (name) => (name === 'constants' ? { fs: fsConstants } : {});
             }
-            if (prop === 'getuid')
+            if (prop === 'getuid') {
                 return () => 0;
+            }
             return Reflect.get(target, prop);
         }
     });
@@ -64,12 +69,15 @@ async function shapeBareGlobals() {
         g.AbortController = AbortController;
         g.AbortSignal = AbortSignal;
     }
-    if (!g.TextDecoder)
+    if (!g.TextDecoder) {
         g.TextDecoder = B4aTextDecoder;
-    if (!g.TextEncoder)
+    }
+    if (!g.TextEncoder) {
         g.TextEncoder = B4aTextEncoder;
-    if (!g.process)
+    }
+    if (!g.process) {
         g.process = nodeShapedProcess(process);
+    }
     if (!g.performance) {
         const origin = Date.now();
         g.performance = { now: () => Date.now() - origin, timeOrigin: origin };
@@ -82,17 +90,20 @@ const silentStdio = {
 };
 export function pyodideLoadOptions() {
     const cacheDir = process.env.QVAC_PYODIDE_CACHE_DIR;
-    if (!cacheDir)
+    if (!cacheDir) {
         return { ...silentStdio };
+    }
     return { ...silentStdio, packageCacheDir: cacheDir };
 }
 export const defaultLoad = async () => {
-    if (typeof globalThis.Bare !== 'undefined')
+    if (typeof globalThis.Bare !== 'undefined') {
         await shapeBareGlobals();
+    }
     const moduleName = 'pyodide';
-    const { loadPyodide } = (await import(__rewriteRelativeImportExtension(moduleName)));
+    const { loadPyodide } = await import(__rewriteRelativeImportExtension(moduleName));
     const options = pyodideLoadOptions();
-    if (options.packageCacheDir)
+    if (options.packageCacheDir) {
         seedPackageCache(options.packageCacheDir);
+    }
     return (await loadPyodide(options));
 };

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

@@ -1,4 +1,4 @@
-type Fs = {
+interface Fs {
     mkdirTree(path: string): void;
     chdir(path: string): void;
     writeFile(path: string, data: Uint8Array): void;
@@ -20,28 +20,30 @@ type Fs = {
     isLink(mode: number): boolean;
     unlink(path: string): void;
     rmdir(path: string): void;
-};
-export type Scratch = {
+}
+interface CwdFs extends Fs {
+    cwd(): string;
+}
+export interface Scratch {
     readonly dir: string;
     readonly cwd: string;
     [Symbol.dispose](): void;
-};
-type InputFile = {
+}
+interface InputFile {
     readonly path: string;
     readonly bytes: Uint8Array;
-};
+}
 export declare function nextScratchDir(fs: Pick<Fs, 'analyzePath'>): string;
 export declare function stageInputFiles(fs: Fs, dir: string, inputs: readonly InputFile[]): void;
-export declare function collectOutputs(fs: Fs, dir: string, names: readonly string[]): {
+export interface CollectedOutputs {
     files: Map<string, Uint8Array>;
     missing: string[];
     rejected: {
         name: string;
         reason: string;
     }[];
-};
+}
+export declare function collectOutputs(fs: Fs, dir: string, names: readonly string[]): CollectedOutputs;
 export declare function removeScratch(fs: Fs, dir: string, previousCwd: string): void;
-export declare function openScratch(fs: Fs & {
-    cwd(): string;
-}, workdir?: string): Scratch;
+export declare function openScratch(fs: CwdFs, workdir?: string): Scratch;
 export {};

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

@@ -1,3 +1,4 @@
+import { errorMessage } from '../../../../guards.js';
 import { hlog } from '../../../../log.js';
 import { MAX_OUTPUT_FILE_BYTES, MAX_OUTPUT_TOTAL_BYTES } from './output-policy.js';
 let runCounter = 0;
@@ -6,14 +7,16 @@ function filePath(dir, name) {
 }
 export function nextScratchDir(fs) {
     let candidate = `/tmp/qvac-exec-${++runCounter}`;
-    while (fs.analyzePath(candidate).exists)
+    while (fs.analyzePath(candidate).exists) {
         candidate = `/tmp/qvac-exec-${++runCounter}`;
+    }
     return candidate;
 }
 export function stageInputFiles(fs, dir, inputs) {
     fs.mkdirTree(dir);
-    for (const input of inputs)
+    for (const input of inputs) {
         fs.writeFile(filePath(dir, input.path), input.bytes);
+    }
 }
 function isRegularFile(fs, path) {
     const mode = fs.lstat(path).mode;
@@ -51,10 +54,12 @@ function removeTree(fs, dir) {
             continue;
         const path = filePath(dir, name);
         const mode = fs.lstat(path).mode;
-        if (fs.isDir(mode) && !fs.isLink(mode))
+        if (fs.isDir(mode) && !fs.isLink(mode)) {
             removeTree(fs, path);
-        else
+        }
+        else {
             fs.unlink(path);
+        }
     }
     fs.rmdir(dir);
 }
@@ -66,7 +71,7 @@ export function removeScratch(fs, dir, previousCwd) {
     catch (error) {
         hlog('python: scratch cleanup failed', {
             dir,
-            err: error instanceof Error ? error.message : String(error)
+            err: errorMessage(error)
         });
     }
 }