@iaforged/context-code 1.0.63 → 1.0.65

package/dist/src/services/vcr.js

@@ -1,291 +0,0 @@
-import { createHash, randomUUID } from 'crypto';
-import { mkdir, readFile, writeFile } from 'fs/promises';
-import isPlainObject from 'lodash-es/isPlainObject.js';
-import mapValues from 'lodash-es/mapValues.js';
-import { dirname, join } from 'path';
-import { addToTotalSessionCost } from '../cost-tracker.js';
-import { calculateUSDCost } from '../utils/modelCost.js';
-import { getCwd } from '../utils/cwd.js';
-import { env } from '../utils/env.js';
-import { getClaudeConfigHomeDir, isEnvTruthy } from '../utils/envUtils.js';
-import { getErrnoCode } from '../utils/errors.js';
-import { normalizeMessagesForAPI } from '../utils/messages.js';
-import { jsonParse, jsonStringify } from '../utils/slowOperations.js';
-function shouldUseVCR() {
-    if (process.env.NODE_ENV === 'test') {
-        return true;
-    }
-    if (process.env.USER_TYPE === 'ant' && isEnvTruthy(process.env.FORCE_VCR)) {
-        return true;
-    }
-    return false;
-}
-/**
- * Generic fixture management helper
- * Handles caching, reading, writing fixtures for any data type
- */
-async function withFixture(input, fixtureName, f) {
-    if (!shouldUseVCR()) {
-        return await f();
-    }
-    // Create hash of input for fixture filename
-    const hash = createHash('sha1')
-        .update(jsonStringify(input))
-        .digest('hex')
-        .slice(0, 12);
-    const filename = join(process.env.CLAUDE_CODE_TEST_FIXTURES_ROOT ?? getCwd(), `fixtures/${fixtureName}-${hash}.json`);
-    // Fetch cached fixture
-    try {
-        const cached = jsonParse(await readFile(filename, { encoding: 'utf8' }));
-        return cached;
-    }
-    catch (e) {
-        const code = getErrnoCode(e);
-        if (code !== 'ENOENT') {
-            throw e;
-        }
-    }
-    if ((env.isCI || process.env.CI) && !isEnvTruthy(process.env.VCR_RECORD)) {
-        throw new Error(`Fixture missing: ${filename}. Re-run tests with VCR_RECORD=1, then commit the result.`);
-    }
-    // Create & write new fixture
-    const result = await f();
-    await mkdir(dirname(filename), { recursive: true });
-    await writeFile(filename, jsonStringify(result, null, 2), {
-        encoding: 'utf8',
-    });
-    return result;
-}
-export async function withVCR(messages, f) {
-    if (!shouldUseVCR()) {
-        return await f();
-    }
-    const messagesForAPI = normalizeMessagesForAPI(messages.filter(_ => {
-        if (_.type !== 'user') {
-            return true;
-        }
-        if (_.isMeta) {
-            return false;
-        }
-        return true;
-    }));
-    const dehydratedInput = mapMessages(messagesForAPI.map(_ => _.message.content), dehydrateValue);
-    const filename = join(process.env.CLAUDE_CODE_TEST_FIXTURES_ROOT ?? getCwd(), `fixtures/${dehydratedInput.map(_ => createHash('sha1').update(jsonStringify(_)).digest('hex').slice(0, 6)).join('-')}.json`);
-    // Fetch cached fixture
-    try {
-        const cached = jsonParse(await readFile(filename, { encoding: 'utf8' }));
-        cached.output.forEach(addCachedCostToTotalSessionCost);
-        return cached.output.map((message, index) => mapMessage(message, hydrateValue, index, randomUUID()));
-    }
-    catch (e) {
-        const code = getErrnoCode(e);
-        if (code !== 'ENOENT') {
-            throw e;
-        }
-    }
-    if (env.isCI && !isEnvTruthy(process.env.VCR_RECORD)) {
-        throw new Error(`Anthropic API fixture missing: ${filename}. Re-run tests with VCR_RECORD=1, then commit the result. Input messages:\n${jsonStringify(dehydratedInput, null, 2)}`);
-    }
-    // Create & write new fixture
-    const results = await f();
-    if (env.isCI && !isEnvTruthy(process.env.VCR_RECORD)) {
-        return results;
-    }
-    await mkdir(dirname(filename), { recursive: true });
-    await writeFile(filename, jsonStringify({
-        input: dehydratedInput,
-        output: results.map((message, index) => mapMessage(message, dehydrateValue, index)),
-    }, null, 2), { encoding: 'utf8' });
-    return results;
-}
-function addCachedCostToTotalSessionCost(message) {
-    if (message.type === 'stream_event') {
-        return;
-    }
-    const model = message.message.model;
-    const usage = message.message.usage;
-    const costUSD = calculateUSDCost(model, usage);
-    addToTotalSessionCost(costUSD, usage, model);
-}
-function mapMessages(messages, f) {
-    return messages.map(_ => {
-        if (typeof _ === 'string') {
-            return f(_);
-        }
-        return _.map(_ => {
-            switch (_.type) {
-                case 'tool_result':
-                    if (typeof _.content === 'string') {
-                        return { ..._, content: f(_.content) };
-                    }
-                    if (Array.isArray(_.content)) {
-                        return {
-                            ..._,
-                            content: _.content.map(_ => {
-                                switch (_.type) {
-                                    case 'text':
-                                        return { ..._, text: f(_.text) };
-                                    case 'image':
-                                        return _;
-                                    default:
-                                        return undefined;
-                                }
-                            }),
-                        };
-                    }
-                    return _;
-                case 'text':
-                    return { ..._, text: f(_.text) };
-                case 'tool_use':
-                    return {
-                        ..._,
-                        input: mapValuesDeep(_.input, f),
-                    };
-                case 'image':
-                    return _;
-                default:
-                    return undefined;
-            }
-        });
-    });
-}
-function mapValuesDeep(obj, f) {
-    return mapValues(obj, (val, key) => {
-        if (Array.isArray(val)) {
-            return val.map(_ => mapValuesDeep(_, f));
-        }
-        if (isPlainObject(val)) {
-            return mapValuesDeep(val, f);
-        }
-        return f(val, key, obj);
-    });
-}
-function mapAssistantMessage(message, f, index, uuid) {
-    return {
-        // Use provided UUID if given (hydrate path uses randomUUID for globally unique IDs),
-        // otherwise fall back to deterministic index-based UUID (dehydrate/fixture path).
-        // sessionStorage.ts deduplicates messages by UUID, so without unique UUIDs across
-        // VCR calls, resumed sessions would treat different responses as duplicates.
-        uuid: uuid ?? `UUID-${index}`,
-        requestId: 'REQUEST_ID',
-        timestamp: message.timestamp,
-        message: {
-            ...message.message,
-            content: message.message.content
-                .map(_ => {
-                switch (_.type) {
-                    case 'text':
-                        return {
-                            ..._,
-                            text: f(_.text),
-                            citations: _.citations || [],
-                        }; // Ensure citations
-                    case 'tool_use':
-                        return {
-                            ..._,
-                            input: mapValuesDeep(_.input, f),
-                        };
-                    default:
-                        return _; // Handle other block types unchanged
-                }
-            })
-                .filter(Boolean),
-        },
-        type: 'assistant',
-    };
-}
-function mapMessage(message, f, index, uuid) {
-    if (message.type === 'assistant') {
-        return mapAssistantMessage(message, f, index, uuid);
-    }
-    else {
-        return message;
-    }
-}
-function dehydrateValue(s) {
-    if (typeof s !== 'string') {
-        return s;
-    }
-    const cwd = getCwd();
-    const configHome = getClaudeConfigHomeDir();
-    let s1 = s
-        .replace(/num_files="\d+"/g, 'num_files="[NUM]"')
-        .replace(/duration_ms="\d+"/g, 'duration_ms="[DURATION]"')
-        .replace(/cost_usd="\d+"/g, 'cost_usd="[COST]"')
-        // Note: We intentionally don't replace all forward slashes with path.sep here.
-        // That would corrupt XML-like tags (e.g., </system-reminder> -> <\system-reminder>).
-        // The [CONFIG_HOME] and [CWD] replacements below handle path normalization.
-        .replaceAll(configHome, '[CONFIG_HOME]')
-        .replaceAll(cwd, '[CWD]')
-        .replace(/Available commands:.+/, 'Available commands: [COMMANDS]');
-    // On Windows, paths may appear in multiple forms:
-    // 1. Forward-slash variants (Git, some Node APIs)
-    // 2. JSON-escaped variants (backslashes doubled in serialized JSON within messages)
-    if (process.platform === 'win32') {
-        const cwdFwd = cwd.replaceAll('\\', '/');
-        const configHomeFwd = configHome.replaceAll('\\', '/');
-        // jsonStringify escapes \ to \\ - match paths embedded in JSON strings
-        const cwdJsonEscaped = jsonStringify(cwd).slice(1, -1);
-        const configHomeJsonEscaped = jsonStringify(configHome).slice(1, -1);
-        s1 = s1
-            .replaceAll(cwdJsonEscaped, '[CWD]')
-            .replaceAll(configHomeJsonEscaped, '[CONFIG_HOME]')
-            .replaceAll(cwdFwd, '[CWD]')
-            .replaceAll(configHomeFwd, '[CONFIG_HOME]');
-    }
-    // Normalize backslash path separators after placeholders so VCR fixture
-    // hashes match across platforms (e.g., [CWD]\foo\bar -> [CWD]/foo/bar)
-    // Handle both single backslashes and JSON-escaped double backslashes (\\)
-    s1 = s1
-        .replace(/\[CWD\][^\s"'<>]*/g, match => match.replaceAll('\\\\', '/').replaceAll('\\', '/'))
-        .replace(/\[CONFIG_HOME\][^\s"'<>]*/g, match => match.replaceAll('\\\\', '/').replaceAll('\\', '/'));
-    if (s1.includes('Files modified by user:')) {
-        return 'Files modified by user: [FILES]';
-    }
-    return s1;
-}
-function hydrateValue(s) {
-    if (typeof s !== 'string') {
-        return s;
-    }
-    return s
-        .replaceAll('[NUM]', '1')
-        .replaceAll('[DURATION]', '100')
-        .replaceAll('[CONFIG_HOME]', getClaudeConfigHomeDir())
-        .replaceAll('[CWD]', getCwd());
-}
-export async function* withStreamingVCR(messages, f) {
-    if (!shouldUseVCR()) {
-        return yield* f();
-    }
-    // Compute and yield messages
-    const buffer = [];
-    // Record messages (or fetch from cache)
-    const cachedBuffer = await withVCR(messages, async () => {
-        for await (const message of f()) {
-            buffer.push(message);
-        }
-        return buffer;
-    });
-    if (cachedBuffer.length > 0) {
-        yield* cachedBuffer;
-        return;
-    }
-    yield* buffer;
-}
-export async function withTokenCountVCR(messages, tools, f) {
-    // Dehydrate before hashing so fixture keys survive cwd/config-home/tempdir
-    // variation and message UUID/timestamp churn. System prompts embed the
-    // working directory (both raw and as a slash→dash project slug in the
-    // auto-memory path) and messages carry fresh UUIDs per run; without this,
-    // every test run produces a new hash and fixtures never hit in CI.
-    const cwdSlug = getCwd().replace(/[^a-zA-Z0-9]/g, '-');
-    const dehydrated = dehydrateValue(jsonStringify({ messages, tools }))
-        .replaceAll(cwdSlug, '[CWD_SLUG]')
-        .replace(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, '[UUID]')
-        .replace(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z?/g, '[TIMESTAMP]');
-    const result = await withFixture(dehydrated, 'token-count', async () => ({
-        tokenCount: await f(),
-    }));
-    return result.tokenCount;
-}

package/dist/src/services/voice.js

@@ -1,394 +0,0 @@
-import { createRequire } from 'module';
-const require = createRequire(import.meta.url);
-// Voice service: audio recording for push-to-talk voice input.
-//
-// Recording uses native audio capture (cpal) on macOS, Linux, and Windows
-// for in-process mic access. Falls back to SoX `rec` or arecord (ALSA)
-// on Linux if the native module is unavailable.
-import { spawn, spawnSync } from 'child_process';
-import { readFile } from 'fs/promises';
-import { logForDebugging } from '../utils/debug.js';
-import { isEnvTruthy, isRunningOnHomespace } from '../utils/envUtils.js';
-import { logError } from '../utils/log.js';
-import { getPlatform } from '../utils/platform.js';
-let audioNapi = null;
-let audioNapiPromise = null;
-function loadAudioNapi() {
-    audioNapiPromise ??= (async () => {
-        const t0 = Date.now();
-        const mod = await import('audio-capture-napi');
-        // vendor/audio-capture-src/index.ts defers require(...node) until the
-        // first function call — trigger it here so timing reflects real cost.
-        mod.isNativeAudioAvailable();
-        audioNapi = mod;
-        logForDebugging(`[voice] audio-capture-napi loaded in ${Date.now() - t0}ms`);
-        return mod;
-    })();
-    return audioNapiPromise;
-}
-// ─── Constants ───────────────────────────────────────────────────────
-const RECORDING_SAMPLE_RATE = 16000;
-const RECORDING_CHANNELS = 1;
-// SoX silence detection: stop after this duration of silence
-const SILENCE_DURATION_SECS = '2.0';
-const SILENCE_THRESHOLD = '3%';
-// ─── Dependency check ────────────────────────────────────────────────
-function hasCommand(cmd) {
-    // Spawn the target directly instead of `which cmd`. On Termux/Android
-    // `which` is a shell builtin — the external binary is absent or
-    // kernel-blocked (EPERM) when spawned from Node. Only reached on
-    // non-Windows (win32 returns early from all callers), no PATHEXT issue.
-    // result.error is set iff the spawn itself fails (ENOENT/EACCES); exit
-    // code is irrelevant — an unrecognized --version still means cmd exists.
-    const result = spawnSync(cmd, ['--version'], {
-        stdio: 'ignore',
-        timeout: 3000,
-    });
-    return result.error === undefined;
-}
-let arecordProbe = null;
-function probeArecord() {
-    arecordProbe ??= new Promise(resolve => {
-        const child = spawn('arecord', [
-            '-f',
-            'S16_LE',
-            '-r',
-            String(RECORDING_SAMPLE_RATE),
-            '-c',
-            String(RECORDING_CHANNELS),
-            '-t',
-            'raw',
-            '/dev/null',
-        ], { stdio: ['ignore', 'ignore', 'pipe'] });
-        let stderr = '';
-        child.stderr?.on('data', (chunk) => {
-            stderr += chunk.toString();
-        });
-        const timer = setTimeout((c, r) => {
-            c.kill('SIGTERM');
-            r({ ok: true, stderr: '' });
-        }, 150, child, resolve);
-        child.once('close', code => {
-            clearTimeout(timer);
-            // SIGTERM close (code=null) after timer fired is already resolved.
-            // Early close with code=0 is unusual (arecord shouldn't exit on its
-            // own) but treat as ok.
-            void resolve({ ok: code === 0, stderr: stderr.trim() });
-        });
-        child.once('error', () => {
-            clearTimeout(timer);
-            void resolve({ ok: false, stderr: 'arecord: command not found' });
-        });
-    });
-    return arecordProbe;
-}
-export function _resetArecordProbeForTesting() {
-    arecordProbe = null;
-}
-// cpal's ALSA backend writes to our process stderr when it can't find any
-// sound cards (it runs in-process — no subprocess pipe to capture it). The
-// spawn fallbacks below pipe stderr correctly, so skip native when ALSA has
-// nothing to open. Memoized: card presence doesn't change mid-session.
-let linuxAlsaCardsMemo = null;
-function linuxHasAlsaCards() {
-    linuxAlsaCardsMemo ??= readFile('/proc/asound/cards', 'utf8').then(cards => {
-        const c = cards.trim();
-        return c !== '' && !c.includes('no soundcards');
-    }, () => false);
-    return linuxAlsaCardsMemo;
-}
-export function _resetAlsaCardsForTesting() {
-    linuxAlsaCardsMemo = null;
-}
-function detectPackageManager() {
-    if (process.platform === 'darwin') {
-        if (hasCommand('brew')) {
-            return {
-                cmd: 'brew',
-                args: ['install', 'sox'],
-                displayCommand: 'brew install sox',
-            };
-        }
-        return null;
-    }
-    if (process.platform === 'linux') {
-        if (hasCommand('apt-get')) {
-            return {
-                cmd: 'sudo',
-                args: ['apt-get', 'install', '-y', 'sox'],
-                displayCommand: 'sudo apt-get install sox',
-            };
-        }
-        if (hasCommand('dnf')) {
-            return {
-                cmd: 'sudo',
-                args: ['dnf', 'install', '-y', 'sox'],
-                displayCommand: 'sudo dnf install sox',
-            };
-        }
-        if (hasCommand('pacman')) {
-            return {
-                cmd: 'sudo',
-                args: ['pacman', '-S', '--noconfirm', 'sox'],
-                displayCommand: 'sudo pacman -S sox',
-            };
-        }
-    }
-    return null;
-}
-export async function checkVoiceDependencies() {
-    // Native audio module (cpal) handles everything on macOS, Linux, and Windows
-    const napi = await loadAudioNapi();
-    if (napi.isNativeAudioAvailable()) {
-        return { available: true, missing: [], installCommand: null };
-    }
-    // Windows has no supported fallback — native module is required
-    if (process.platform === 'win32') {
-        return {
-            available: false,
-            missing: ['Voice mode requires the native audio module (not loaded)'],
-            installCommand: null,
-        };
-    }
-    // On Linux, arecord (ALSA utils) is a valid fallback recording backend
-    if (process.platform === 'linux' && hasCommand('arecord')) {
-        return { available: true, missing: [], installCommand: null };
-    }
-    const missing = [];
-    if (!hasCommand('rec')) {
-        missing.push('sox (rec command)');
-    }
-    const pm = missing.length > 0 ? detectPackageManager() : null;
-    return {
-        available: missing.length === 0,
-        missing,
-        installCommand: pm?.displayCommand ?? null,
-    };
-}
-// Probe-record through the full fallback chain (native → arecord → SoX)
-// to verify that at least one backend can record. On macOS this also
-// triggers the TCC permission dialog on first use. We trust the probe
-// result over the TCC status API, which can be unreliable for ad-hoc
-// signed or cross-architecture binaries (e.g., x64-on-arm64).
-export async function requestMicrophonePermission() {
-    const napi = await loadAudioNapi();
-    if (!napi.isNativeAudioAvailable()) {
-        return true; // non-native platforms skip this check
-    }
-    const started = await startRecording(_chunk => { }, // discard audio data — this is a permission probe only
-    () => { }, // ignore silence-detection end signal
-    { silenceDetection: false });
-    if (started) {
-        stopRecording();
-        return true;
-    }
-    return false;
-}
-export async function checkRecordingAvailability() {
-    // Remote environments have no local microphone
-    if (isRunningOnHomespace() || isEnvTruthy(process.env.CLAUDE_CODE_REMOTE)) {
-        return {
-            available: false,
-            reason: 'Voice mode requires microphone access, but no audio device is available in this environment.\n\nTo use voice mode, run Context Code locally instead.',
-        };
-    }
-    // Native audio module (cpal) handles everything on macOS, Linux, and Windows
-    const napi = await loadAudioNapi();
-    if (napi.isNativeAudioAvailable()) {
-        return { available: true, reason: null };
-    }
-    // Windows has no supported fallback
-    if (process.platform === 'win32') {
-        return {
-            available: false,
-            reason: 'Voice recording requires the native audio module, which could not be loaded.',
-        };
-    }
-    const wslNoAudioReason = 'Voice mode could not access an audio device in WSL.\n\nWSL2 with WSLg (Windows 11) provides audio via PulseAudio — if you are on Windows 10 or WSL1, run Context Code in native Windows instead.';
-    // On Linux (including WSL), probe arecord. hasCommand() is insufficient:
-    // the binary can exist while the device open() fails (WSL1, Win10-WSL2,
-    // headless Linux). WSL2+WSLg (Win11 default) works via PulseAudio RDP
-    // pipes — cpal fails (no /proc/asound/cards) but arecord succeeds.
-    if (process.platform === 'linux' && hasCommand('arecord')) {
-        const probe = await probeArecord();
-        if (probe.ok) {
-            return { available: true, reason: null };
-        }
-        if (getPlatform() === 'wsl') {
-            return { available: false, reason: wslNoAudioReason };
-        }
-        logForDebugging(`[voice] arecord probe failed: ${probe.stderr}`);
-        // fall through to SoX
-    }
-    // Fallback: check for SoX
-    if (!hasCommand('rec')) {
-        // WSL without arecord AND without SoX: the generic "install SoX"
-        // hint below is misleading on WSL1/Win10 (no audio devices at all),
-        // but correct on WSL2+WSLg (SoX works via PulseAudio). Since we can't
-        // distinguish WSLg-vs-not without a backend to probe, show the WSLg
-        // guidance — it points WSL1 users at native Windows AND tells WSLg
-        // users their setup should work (they can install sox or alsa-utils).
-        // Known gap: WSL with SoX but NO arecord skips both this branch and
-        // the probe above — hasCommand('rec') lies the same way. We optimistically
-        // trust it (WSLg+SoX would work) rather than probeSox() for a near-zero
-        // population (WSL1 × minimal distro × SoX-but-not-alsa-utils).
-        if (getPlatform() === 'wsl') {
-            return { available: false, reason: wslNoAudioReason };
-        }
-        const pm = detectPackageManager();
-        return {
-            available: false,
-            reason: pm
-                ? `Voice mode requires SoX for audio recording. Install it with: ${pm.displayCommand}`
-                : 'Voice mode requires SoX for audio recording. Install SoX manually:\n  macOS: brew install sox\n  Ubuntu/Debian: sudo apt-get install sox\n  Fedora: sudo dnf install sox',
-        };
-    }
-    return { available: true, reason: null };
-}
-// ─── Recording (native audio on macOS/Linux/Windows, SoX/arecord fallback on Linux) ─────────────
-let activeRecorder = null;
-let nativeRecordingActive = false;
-export async function startRecording(onData, onEnd, options) {
-    logForDebugging(`[voice] startRecording called, platform=${process.platform}`);
-    // Try native audio module first (macOS, Linux, Windows via cpal)
-    const napi = await loadAudioNapi();
-    const nativeAvailable = napi.isNativeAudioAvailable() &&
-        (process.platform !== 'linux' || (await linuxHasAlsaCards()));
-    const useSilenceDetection = options?.silenceDetection !== false;
-    if (nativeAvailable) {
-        // Ensure any previous recording is fully stopped
-        if (nativeRecordingActive || napi.isNativeRecordingActive()) {
-            napi.stopNativeRecording();
-            nativeRecordingActive = false;
-        }
-        const started = napi.startNativeRecording((data) => {
-            onData(data);
-        }, () => {
-            if (useSilenceDetection) {
-                nativeRecordingActive = false;
-                onEnd();
-            }
-            // In push-to-talk mode, ignore the native module's silence-triggered
-            // onEnd.  Recording continues until the caller explicitly calls
-            // stopRecording() (e.g. when the user presses Ctrl+X).
-        });
-        if (started) {
-            nativeRecordingActive = true;
-            return true;
-        }
-        // Native recording failed — fall through to platform fallbacks
-    }
-    // Windows has no supported fallback
-    if (process.platform === 'win32') {
-        logForDebugging('[voice] Windows native recording unavailable, no fallback');
-        return false;
-    }
-    // On Linux, try arecord (ALSA utils) before SoX. Consult the probe so
-    // backend selection matches checkRecordingAvailability() — otherwise
-    // on headless Linux with both alsa-utils and SoX, the availability
-    // check falls through to SoX (probe.ok=false, not WSL) but this path
-    // would still pick broken arecord. Probe is memoized; zero latency.
-    if (process.platform === 'linux' &&
-        hasCommand('arecord') &&
-        (await probeArecord()).ok) {
-        return startArecordRecording(onData, onEnd);
-    }
-    // Fallback: SoX rec (Linux, or macOS if native module unavailable)
-    return startSoxRecording(onData, onEnd, options);
-}
-function startSoxRecording(onData, onEnd, options) {
-    const useSilenceDetection = options?.silenceDetection !== false;
-    // Record raw PCM: 16 kHz, 16-bit signed, mono, to stdout.
-    // --buffer 1024 forces SoX to flush audio in small chunks instead of
-    // accumulating data in its internal buffer. Without this, SoX may buffer
-    // several seconds of audio before writing anything to stdout when piped,
-    // causing zero data flow until the process exits.
-    const args = [
-        '-q', // quiet
-        '--buffer',
-        '1024',
-        '-t',
-        'raw',
-        '-r',
-        String(RECORDING_SAMPLE_RATE),
-        '-e',
-        'signed',
-        '-b',
-        '16',
-        '-c',
-        String(RECORDING_CHANNELS),
-        '-', // stdout
-    ];
-    // Add silence detection filter (auto-stop on silence).
-    // Omit for push-to-talk where the user manually controls start/stop.
-    if (useSilenceDetection) {
-        args.push('silence', // start/stop on silence
-        '1', '0.1', SILENCE_THRESHOLD, '1', SILENCE_DURATION_SECS, SILENCE_THRESHOLD);
-    }
-    const child = spawn('rec', args, {
-        stdio: ['pipe', 'pipe', 'pipe'],
-    });
-    activeRecorder = child;
-    child.stdout?.on('data', (chunk) => {
-        onData(chunk);
-    });
-    // Consume stderr to prevent backpressure
-    child.stderr?.on('data', () => { });
-    child.on('close', () => {
-        activeRecorder = null;
-        onEnd();
-    });
-    child.on('error', err => {
-        logError(err);
-        activeRecorder = null;
-        onEnd();
-    });
-    return true;
-}
-function startArecordRecording(onData, onEnd) {
-    // Record raw PCM: 16 kHz, 16-bit signed little-endian, mono, to stdout.
-    // arecord does not support built-in silence detection, so this backend
-    // is best suited for push-to-talk (silenceDetection: false).
-    const args = [
-        '-f',
-        'S16_LE', // signed 16-bit little-endian
-        '-r',
-        String(RECORDING_SAMPLE_RATE),
-        '-c',
-        String(RECORDING_CHANNELS),
-        '-t',
-        'raw', // raw PCM, no WAV header
-        '-q', // quiet — no progress output
-        '-', // write to stdout
-    ];
-    const child = spawn('arecord', args, {
-        stdio: ['pipe', 'pipe', 'pipe'],
-    });
-    activeRecorder = child;
-    child.stdout?.on('data', (chunk) => {
-        onData(chunk);
-    });
-    // Consume stderr to prevent backpressure
-    child.stderr?.on('data', () => { });
-    child.on('close', () => {
-        activeRecorder = null;
-        onEnd();
-    });
-    child.on('error', err => {
-        logError(err);
-        activeRecorder = null;
-        onEnd();
-    });
-    return true;
-}
-export function stopRecording() {
-    if (nativeRecordingActive && audioNapi) {
-        audioNapi.stopNativeRecording();
-        nativeRecordingActive = false;
-        return;
-    }
-    if (activeRecorder) {
-        activeRecorder.kill('SIGTERM');
-        activeRecorder = null;
-    }
-}