@qvac/harness 0.4.0 → 0.6.0

package/dist-lib/lib/tools/generate-music.js

@@ -28,12 +28,14 @@ export function musicPercentTick(onPercent) {
     let last = -1;
     return ({ stage, step, total }) => {
         const weight = STAGE_WEIGHT[stage];
-        if (!weight)
+        if (!weight) {
             return;
+        }
         const frac = total > 0 ? Math.min(1, Math.max(0, step / total)) : 0;
         const percentage = Math.min(100, Math.round(weight.base + frac * weight.span));
-        if (percentage <= last)
+        if (percentage <= last) {
             return;
+        }
         last = percentage;
         onPercent(percentage);
     };
@@ -83,16 +85,18 @@ export function createMusicRuntime({ loadSdk, onProgress, onBeforeLoad, loads =
         loadSdk,
         gpuRequested: useGpu,
         defaultSteps,
-        ensureLoaded: async (sdk, signal, modelChoice, steps) => {
+        ensureLoaded: async (sdk, { signal, modelChoice, inferenceSteps: steps } = {}) => {
             const stages = stagesFor(modelChoice, base);
             const effectiveSteps = steps ?? baseSteps;
             const fingerprint = fingerprintOf(stages, effectiveSteps);
             await lock.lock();
             try {
-                if (loading && residentFingerprint !== fingerprint)
+                if (loading && residentFingerprint !== fingerprint) {
                     await doUnload();
-                if (!loading && onBeforeLoad)
+                }
+                if (!loading && onBeforeLoad) {
                     await onBeforeLoad(signal);
+                }
                 residentFingerprint = fingerprint;
                 loading ??= (async () => {
                     onProgress?.(musicProgressName(stages.dit), {});
@@ -108,7 +112,7 @@ export function createMusicRuntime({ loadSdk, onProgress, onBeforeLoad, loads =
                         ditModelSrc,
                         vaeModelSrc,
                         useGPU: useGpu,
-                        ...(effectiveSteps ? { inferenceSteps: effectiveSteps } : {})
+                        inferenceSteps: effectiveSteps || undefined
                     };
                     const modelId = await loads.track(sdk.loadModel({
                         modelType: 'audiogen',
@@ -136,41 +140,48 @@ export function createMusicRuntime({ loadSdk, onProgress, onBeforeLoad, loads =
     };
 }
 export const BUSY_ERROR = 'a music generation is already running; try again when it finishes';
-export async function runAudioGen(sdk, modelId, params, signal, onTick) {
-    if (signal?.aborted)
+export async function runAudioGen(sdk, { modelId, params, signal, onTick }) {
+    if (signal?.aborted) {
         return { error: 'music generation canceled' };
+    }
     let run;
     try {
         run = sdk.audioGen({ modelId, ...params });
     }
     catch (err) {
-        if (signal?.aborted)
+        if (signal?.aborted) {
             return { error: 'music generation canceled' };
+        }
         throw err;
     }
     const onAbort = () => {
-        void sdk.cancel?.({ requestId: run.requestId }).catch(() => { });
+        void sdk.cancel?.({ requestId: run.requestId }).catch(noop);
     };
     signal?.addEventListener('abort', onAbort, { once: true });
     let settled = false;
     try {
         const drained = (async () => {
-            for await (const tick of run.progressStream)
-                if (!settled)
+            for await (const tick of run.progressStream) {
+                if (!settled) {
                     onTick?.(tick);
-        })().catch(() => { });
+                }
+            }
+        })().catch(noop);
         const audio = await run.audio;
         await drained;
-        if (signal?.aborted)
+        if (signal?.aborted) {
             return { error: 'music generation canceled' };
-        if (!audio?.pcm?.length)
+        }
+        if (!audio?.pcm?.length) {
             return { error: 'the audiogen model produced no audio' };
-        const stats = await run.stats.catch(() => undefined);
+        }
+        const stats = await run.stats.catch(noop);
         return stats ? { ...audio, stats } : audio;
     }
     catch (err) {
-        if (signal?.aborted)
+        if (signal?.aborted) {
             return { error: 'music generation canceled' };
+        }
         throw err;
     }
     finally {
@@ -180,8 +191,9 @@ export async function runAudioGen(sdk, modelId, params, signal, onTick) {
 }
 export function audioDurationSeconds(audio) {
     const bytesPerSample = audio.bitsPerSample / 8;
-    if (bytesPerSample <= 0 || audio.channels <= 0 || audio.sampleRate <= 0)
+    if (bytesPerSample <= 0 || audio.channels <= 0 || audio.sampleRate <= 0) {
         return 0;
+    }
     const samplesPerChannel = audio.pcm.byteLength / bytesPerSample / audio.channels;
     return Math.round(samplesPerChannel / audio.sampleRate);
 }
@@ -197,8 +209,9 @@ export function presentStats(stats) {
         'backendId'
     ]) {
         const value = stats[key];
-        if (typeof value === 'number' && Number.isFinite(value))
+        if (typeof value === 'number' && Number.isFinite(value)) {
             kept[key] = value;
+        }
     }
     return Object.keys(kept).length > 0 ? kept : undefined;
 }
@@ -240,8 +253,9 @@ export function pcmToWav(audio) {
     const header = new ArrayBuffer(44);
     const view = new DataView(header);
     const ascii = (offset, value) => {
-        for (let i = 0; i < value.length; i++)
+        for (let i = 0; i < value.length; i++) {
             view.setUint8(offset + i, value.charCodeAt(i));
+        }
     };
     ascii(0, 'RIFF');
     view.setUint32(4, 36 + pcm.byteLength, true);
@@ -263,8 +277,9 @@ export function pcmToWav(audio) {
 }
 function parseArgs(args, defaults, maxDuration) {
     const caption = typeof args.prompt === 'string' ? args.prompt.trim() : '';
-    if (!caption)
+    if (!caption) {
         return { error: 'prompt must be a non-empty string' };
+    }
     if (caption.length > MAX_CAPTION_CHARS) {
         return { error: `prompt exceeds ${MAX_CAPTION_CHARS} characters` };
     }
@@ -285,16 +300,18 @@ function parseArgs(args, defaults, maxDuration) {
         }
         duration = Math.round(n);
     }
-    if (duration !== undefined)
+    if (duration !== undefined) {
         duration = Math.min(duration, maxDuration);
+    }
     let seed;
     if (args.seed !== undefined && args.seed !== null) {
         seed = Number(args.seed);
         if (!Number.isInteger(seed) || seed < -1 || seed > MAX_SEED) {
             return { error: `seed must be an integer between -1 (random) and ${MAX_SEED}` };
         }
-        if (seed === -1)
+        if (seed === -1) {
             seed = undefined;
+        }
     }
     let vocalLanguage;
     if (typeof args.vocalLanguage === 'string' && args.vocalLanguage.trim()) {
@@ -362,8 +379,9 @@ export function normalizeClamps(clamps) {
 }
 export function resolveMusicSettings(ctx) {
     const settings = ctx?.settings;
-    if (!settings)
+    if (!settings) {
         return {};
+    }
     const out = {};
     if (typeof settings.modelChoice === 'string' && settings.modelChoice) {
         out.modelChoice = settings.modelChoice;
@@ -438,12 +456,15 @@ export function createGenerateMusicTool(runtime, clamps) {
         execute: async (args, ctx) => {
             const music = resolveMusicSettings(ctx);
             const parsed = parseArgs(args, { duration: settingsDuration(music.duration, cap.maxDuration) }, cap.maxDuration);
-            if ('error' in parsed)
+            if ('error' in parsed) {
                 return parsed;
-            if (!ctx?.attach)
+            }
+            if (!ctx?.attach) {
                 return { error: 'this device cannot persist generated audio' };
-            if (!runtime.acquire())
+            }
+            if (!runtime.acquire()) {
                 return { error: BUSY_ERROR, code: 'busy' };
+            }
             const report = ctx.progress;
             const onTick = report && musicPercentTick((percentage) => report({ percentage }));
             const capMax = stepsCap ?? MAX_STEPS;
@@ -453,25 +474,35 @@ export function createGenerateMusicTool(runtime, clamps) {
                 stepsCap;
             try {
                 const sdk = await runtime.loadSdk();
-                const { modelId } = await runtime.ensureLoaded(sdk, ctx.signal, music.modelChoice, steps);
+                const { modelId } = await runtime.ensureLoaded(sdk, {
+                    signal: ctx.signal,
+                    modelChoice: music.modelChoice,
+                    inferenceSteps: steps
+                });
                 const hasVocals = parsed.lyrics !== undefined &&
                     parsed.lyrics.trim().toLowerCase() !== INSTRUMENTAL.toLowerCase();
                 const instrumental = !hasVocals;
                 const vocalLanguage = hasVocals
                     ? (parsed.vocalLanguage ?? DEFAULT_VOCAL_LANGUAGE)
                     : undefined;
-                const result = await runAudioGen(sdk, modelId, {
-                    caption: parsed.caption,
-                    lyrics: hasVocals ? parsed.lyrics : INSTRUMENTAL,
-                    ...(parsed.duration !== undefined ? { duration: parsed.duration } : {}),
-                    ...(parsed.seed !== undefined ? { seed: parsed.seed } : {}),
-                    ...(vocalLanguage ? { vocalLanguage } : {}),
-                    ...(parsed.bpm !== undefined ? { bpm: parsed.bpm } : {}),
-                    ...(parsed.keyscale ? { keyscale: parsed.keyscale } : {}),
-                    ...(parsed.timesignature ? { timesignature: parsed.timesignature } : {})
-                }, ctx.signal, onTick);
-                if ('error' in result)
+                const result = await runAudioGen(sdk, {
+                    modelId,
+                    params: {
+                        caption: parsed.caption,
+                        lyrics: hasVocals ? parsed.lyrics : INSTRUMENTAL,
+                        duration: parsed.duration,
+                        seed: parsed.seed,
+                        vocalLanguage: vocalLanguage || undefined,
+                        bpm: parsed.bpm,
+                        keyscale: parsed.keyscale || undefined,
+                        timesignature: parsed.timesignature || undefined
+                    },
+                    signal: ctx.signal,
+                    onTick
+                });
+                if ('error' in result) {
                     return result;
+                }
                 const wav = pcmToWav(result);
                 const record = await ctx.attach({
                     fileName: musicFileName(parsed.title, parsed.caption),
@@ -497,20 +528,19 @@ export function createGenerateMusicTool(runtime, clamps) {
                     sampleRate: result.sampleRate,
                     channels: result.channels,
                     instrumental,
-                    ...(instrumental && captionImpliesVocals(parsed.caption)
-                        ? {
-                            note: 'This track is instrumental: no lyrics were provided, so the model did not sing. ' +
-                                'The prompt described vocals; to produce a sung version, call generate_music again ' +
-                                'with lyrics ([verse]/[chorus] tags). Otherwise describe this track as instrumental, not vocal.'
-                        }
-                        : {}),
+                    note: instrumental && captionImpliesVocals(parsed.caption)
+                        ? 'This track is instrumental: no lyrics were provided, so the model did not sing. ' +
+                            'The prompt described vocals; to produce a sung version, call generate_music again ' +
+                            'with lyrics ([verse]/[chorus] tags). Otherwise describe this track as instrumental, not vocal.'
+                        : undefined,
                     hostNotice: notice,
-                    ...(stats ? { data: { stats } } : {})
+                    data: stats ? { stats } : undefined
                 };
             }
             catch (err) {
-                if (err instanceof AbortedError)
+                if (err instanceof AbortedError) {
                     return { error: 'music generation canceled' };
+                }
                 throw err;
             }
             finally {
@@ -520,3 +550,4 @@ export function createGenerateMusicTool(runtime, clamps) {
         }
     };
 }
+function noop() { }

package/dist-lib/lib/tools/grep.js

@@ -1,3 +1,4 @@
+import { errorMessage } from '../guards.js';
 import { hlog } from '../log.js';
 import { searchTargets } from './file-glob.js';
 import { readLines } from './fs/read.js';
@@ -8,6 +9,38 @@ export const DEFAULT_GREP_MATCHES = 200;
 export const MAX_GREP_MATCHES = 1000;
 const MAX_LINE_CHARS = 500;
 const BINARY_PROBE_CHARS = 1024;
+async function scanFile(drive, key, { path, tests, room }) {
+    const hits = [];
+    let probed = 0;
+    let binary = false;
+    let index = 0;
+    try {
+        for await (const line of readLines(drive, key)) {
+            index++;
+            if (probed < BINARY_PROBE_CHARS && line.includes('\0')) {
+                binary = true;
+                break;
+            }
+            if (probed < BINARY_PROBE_CHARS) {
+                probed += line.length + 1;
+            }
+            if (!tests.some((test) => test(line))) {
+                continue;
+            }
+            hits.push({ file: path, line: index, text: line.slice(0, MAX_LINE_CHARS) });
+            if (hits.length >= room) {
+                return { hits, binary, end: 'capped' };
+            }
+        }
+    }
+    catch (error) {
+        if (isDriveReadTruncated(error)) {
+            return { hits, binary, end: 'cut' };
+        }
+        return { hits, binary, end: 'unreadable', error };
+    }
+    return { hits, binary, end: 'complete' };
+}
 function stringArray(raw) {
     if (!Array.isArray(raw) || raw.length === 0)
         return null;
@@ -23,7 +56,7 @@ function compileQueries(queries, regex, caseSensitive) {
             });
         }
         catch (err) {
-            return { error: `invalid regex: ${err.message}` };
+            return { error: `invalid regex: ${errorMessage(err)}` };
         }
     }
     return queries.map((q) => {
@@ -70,11 +103,13 @@ export function createGrepTool({ realpath = defaultRealpath, deniedRoots } = {})
         rootsRequired: true,
         validate(rawArgs) {
             const queries = stringArray(rawArgs.queries);
-            if (!queries)
+            if (!queries) {
                 return 'queries must be a non-empty array of strings';
+            }
             const compiled = compileQueries(queries, rawArgs.regex === true, rawArgs.caseSensitive === true);
-            if ('error' in compiled)
+            if ('error' in compiled) {
                 return compiled.error;
+            }
             const maxMatches = rawArgs.maxMatches;
             if (maxMatches !== undefined && maxMatches !== null) {
                 const n = Number(maxMatches);
@@ -91,16 +126,19 @@ export function createGrepTool({ realpath = defaultRealpath, deniedRoots } = {})
         async execute(rawArgs, ctx) {
             const roots = ctx?.fsRoots ?? [];
             const queries = stringArray(rawArgs.queries);
-            if (!queries)
+            if (!queries) {
                 return { error: 'queries must be a non-empty array of strings' };
+            }
             const compiled = compileQueries(queries, rawArgs.regex === true, rawArgs.caseSensitive === true);
-            if ('error' in compiled)
+            if ('error' in compiled) {
                 return compiled;
+            }
             const maxMatches = rawArgs.maxMatches ? Number(rawArgs.maxMatches) : DEFAULT_GREP_MATCHES;
             const deny = await canonicalDenyRoots(deniedRoots, realpath);
-            const scoped = await searchTargets(rawArgs.dir, roots, realpath, deny);
-            if ('error' in scoped)
+            const scoped = await searchTargets(rawArgs.dir, roots, { realpath, deny });
+            if ('error' in scoped) {
                 return scoped;
+            }
             const matches = [];
             let truncated = false;
             let skippedLinks = 0;
@@ -111,47 +149,34 @@ export function createGrepTool({ realpath = defaultRealpath, deniedRoots } = {})
                 for (const file of walk.files) {
                     if (isDeniedPath(file.path, deny))
                         continue;
-                    const hits = [];
-                    let probed = 0;
-                    let binary = false;
-                    let index = 0;
-                    try {
-                        for await (const line of readLines(target.root.drive, file.key)) {
-                            index++;
-                            if (probed < BINARY_PROBE_CHARS) {
-                                if (line.includes('\0')) {
-                                    binary = true;
-                                    break;
-                                }
-                                probed += line.length + 1;
-                            }
-                            if (!compiled.some((test) => test(line)))
-                                continue;
-                            hits.push({ file: file.path, line: index, text: line.slice(0, MAX_LINE_CHARS) });
-                            if (matches.length + hits.length >= maxMatches) {
-                                matches.push(...hits);
-                                return { matches, truncated: true, ...(skippedLinks ? { skippedLinks } : {}) };
-                            }
-                        }
+                    const scan = await scanFile(target.root.drive, file.key, {
+                        path: file.path,
+                        tests: compiled,
+                        room: maxMatches - matches.length
+                    });
+                    if (scan.end === 'capped') {
+                        matches.push(...scan.hits);
+                        return { matches, truncated: true, skippedLinks: skippedLinks || undefined };
                     }
-                    catch (err) {
-                        if (isDriveReadTruncated(err)) {
-                            if (!binary)
-                                matches.push(...hits);
-                            truncated = true;
-                            continue;
-                        }
-                        hlog('warn: grep skipped a file', { file: file.path, err: err.message });
+                    if (scan.end === 'unreadable') {
+                        hlog('warn: grep skipped a file', {
+                            file: file.path,
+                            err: errorMessage(scan.error)
+                        });
                         continue;
                     }
-                    if (!binary)
-                        matches.push(...hits);
+                    if (scan.end === 'cut') {
+                        truncated = true;
+                    }
+                    if (!scan.binary) {
+                        matches.push(...scan.hits);
+                    }
                 }
             }
             return {
                 matches,
-                ...(truncated ? { truncated } : {}),
-                ...(skippedLinks ? { skippedLinks } : {})
+                truncated: truncated || undefined,
+                skippedLinks: skippedLinks || undefined
             };
         }
     };

package/dist-lib/lib/tools/http-request/encode-fields.js

@@ -1,11 +1,14 @@
+import b4a from 'b4a';
+import { isRecord } from '../../guards.js';
 const BASE64URL = /^[A-Za-z0-9_-]+={0,2}$/;
 const PRINTABLE_RATIO = 0.9;
 export function encodeDeclaredFields(body, encode) {
     if (!encode)
         return body;
     const parsed = asObject(body);
-    if (!parsed)
+    if (!parsed) {
         return body;
+    }
     let next = parsed;
     for (const [path, encoding] of Object.entries(encode)) {
         if (encoding !== 'base64' && encoding !== 'base64url')
@@ -23,34 +26,39 @@ function asObject(body) {
             return null;
         }
     }
-    if (typeof body !== 'object' || body === null || Array.isArray(body))
+    if (!isRecord(body) || Array.isArray(body)) {
         return null;
+    }
     return body;
 }
 function setAt(body, path, encoding) {
     const [head, ...rest] = path;
-    if (head === undefined)
+    if (head === undefined) {
         return body;
+    }
     const current = body[head];
     if (rest.length) {
-        if (typeof current !== 'object' || current === null)
+        if (!isRecord(current)) {
             return body;
+        }
         return { ...body, [head]: setAt(current, rest, encoding) };
     }
-    if (typeof current !== 'string')
+    if (typeof current !== 'string') {
         return body;
+    }
     return { ...body, [head]: encodeValue(current, encoding) };
 }
 function encodeValue(value, encoding) {
     if (isAlreadyEncoded(value))
         return value;
-    return Buffer.from(value, 'utf8').toString(encoding);
+    return b4a.toString(b4a.from(value, 'utf8'), encoding);
 }
 function isAlreadyEncoded(value) {
-    if (!BASE64URL.test(value) && !/^[A-Za-z0-9+/]+={0,2}$/.test(value))
+    if (!BASE64URL.test(value) && !/^[A-Za-z0-9+/]+={0,2}$/.test(value)) {
         return false;
+    }
     try {
-        const decoded = Buffer.from(value, 'base64').toString('utf8');
+        const decoded = b4a.toString(b4a.from(value, 'base64'), 'utf8');
         return decoded.length > 0 && isMostlyPrintable(decoded);
     }
     catch {
@@ -61,8 +69,9 @@ function isMostlyPrintable(text) {
     const chars = [...text];
     const printable = chars.filter((char) => {
         const code = char.codePointAt(0) ?? 0;
-        if (code === 0xfffd)
+        if (code === 0xfffd) {
             return false;
+        }
         return code === 9 || code === 10 || code === 13 || (code >= 32 && code !== 127);
     }).length;
     return printable / chars.length >= PRINTABLE_RATIO;

package/dist-lib/lib/tools/http-request/{utils.js → request.js}

@@ -1,3 +1,4 @@
+import { isRecord } from '../../guards.js';
 const BLOCKED_HEADERS = new Set(['authorization', 'cookie', 'proxy-authorization']);
 export const MAX_RESPONSE_CHARS = 8192;
 export const TIMEOUT_MS = 10_000;
@@ -5,8 +6,9 @@ export function isRedirectStatus(status) {
     return status === 301 || status === 302 || status === 303 || status === 307 || status === 308;
 }
 export function parseObjectArg(v, name) {
-    if (v === null || v === undefined)
+    if (v === null || v === undefined) {
         return { ok: true, value: undefined };
+    }
     let value = v;
     if (typeof v === 'string') {
         try {
@@ -16,20 +18,23 @@ export function parseObjectArg(v, name) {
             return { ok: false, error: `${name} must be an object` };
         }
     }
-    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    if (!isPlainRecord(value)) {
         return { ok: false, error: `${name} must be an object` };
     }
-    return { ok: true, value: value };
+    return { ok: true, value };
 }
 const BODY_JSON_ERROR = 'body is not valid JSON — resend it as one complete JSON object';
 export function parseJsonBody(body, contentType) {
-    if (typeof body !== 'string')
+    if (typeof body !== 'string') {
         return { ok: true, value: body };
-    if (contentType !== undefined && !/json/i.test(contentType))
+    }
+    if (contentType !== undefined && !/json/i.test(contentType)) {
         return { ok: true, value: body };
+    }
     const text = body.trim();
-    if (text[0] !== '{' && text[0] !== '[')
+    if (text[0] !== '{' && text[0] !== '[') {
         return { ok: true, value: body };
+    }
     let parsed;
     try {
         parsed = JSON.parse(text);
@@ -40,15 +45,16 @@ export function parseJsonBody(body, contentType) {
     return { ok: true, value: isPlainRecord(parsed) ? parsed : body };
 }
 function isPlainRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
+    return isRecord(value) && !Array.isArray(value);
 }
 export function applyQuery(url, query) {
     for (const [key, value] of Object.entries(query)) {
         if (value === null || value === undefined)
             continue;
         if (Array.isArray(value)) {
-            for (const item of value)
+            for (const item of value) {
                 url.searchParams.append(key, String(item));
+            }
         }
         else {
             url.searchParams.append(key, String(value));
@@ -59,24 +65,27 @@ export function contentTypeOf(headers) {
     if (typeof headers !== 'object' || headers === null)
         return undefined;
     for (const [key, value] of Object.entries(headers)) {
-        if (key.toLowerCase() === 'content-type')
+        if (key.toLowerCase() === 'content-type') {
             return String(value);
+        }
     }
     return undefined;
 }
 export function buildHeaders(headerArgs) {
     const headers = {};
     for (const [key, value] of Object.entries(headerArgs)) {
-        if (!BLOCKED_HEADERS.has(key.toLowerCase()))
+        if (!BLOCKED_HEADERS.has(key.toLowerCase())) {
             headers[key] = String(value);
+        }
     }
     return headers;
 }
 export function encodeBody(body, headers) {
     if (body === null || body === undefined)
         return undefined;
-    if (typeof body !== 'object')
+    if (typeof body !== 'object') {
         return String(body);
+    }
     if (!Object.keys(headers).some((h) => h.toLowerCase() === 'content-type')) {
         headers['Content-Type'] = 'application/json';
     }