@iaforged/context-code 1.1.4 → 1.1.7

package/dist/src/services/localDictation.js

@@ -0,0 +1,520 @@
+import { accessSync, constants } from 'fs';
+import { mkdir, mkdtemp, readdir, readFile, rm, writeFile } from 'fs/promises';
+import { tmpdir } from 'os';
+import { basename, join } from 'path';
+import { execa } from 'execa';
+import { saveGlobalConfig, getGlobalConfig } from '../utils/config.js';
+import { logForDebugging } from '../utils/debug.js';
+import { getClaudeConfigHomeDir } from '../utils/envUtils.js';
+const SAMPLE_RATE = 16_000;
+const CHANNELS = 1;
+const BITS_PER_SAMPLE = 16;
+const DEFAULT_MODEL_NAME = 'base';
+const WHISPER_RELEASE_API = 'https://api.github.com/repos/ggml-org/whisper.cpp/releases/latest';
+const WHISPER_MODEL_BASE_URL = 'https://huggingface.co/ggerganov/whisper.cpp/resolve/main';
+function fileExists(path) {
+    try {
+        accessSync(path, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function getStoredDictationConfig() {
+    return getGlobalConfig().dictationConfig;
+}
+function getConfiguredExecutable() {
+    const explicit = process.env.CONTEXT_CODE_DICTATION_EXECUTABLE ??
+        process.env.WHISPER_CPP_PATH;
+    if (explicit?.trim()) {
+        return explicit.trim();
+    }
+    const stored = getStoredDictationConfig()?.executablePath;
+    if (stored?.trim()) {
+        return stored.trim();
+    }
+    // Fallback al nombre por defecto en PATH segun plataforma. En macOS/Linux
+    // probamos primero `whisper-cli` (releases) y luego `whisper-cpp` (Homebrew).
+    if (process.platform === 'win32')
+        return 'whisper-cli.exe';
+    return 'whisper-cli';
+}
+function getConfiguredModel() {
+    const model = process.env.CONTEXT_CODE_DICTATION_MODEL ??
+        process.env.WHISPER_MODEL_PATH;
+    if (model?.trim()) {
+        return model.trim();
+    }
+    const stored = getStoredDictationConfig()?.modelPath;
+    return stored?.trim() ? stored.trim() : null;
+}
+function getConfiguredLanguage() {
+    const language = process.env.CONTEXT_CODE_DICTATION_LANGUAGE ?? process.env.WHISPER_LANGUAGE;
+    if (language?.trim()) {
+        return language.trim();
+    }
+    const stored = getStoredDictationConfig()?.language;
+    return stored?.trim() ? stored.trim() : 'es';
+}
+function getDictationConfig() {
+    const executable = getConfiguredExecutable();
+    const model = getConfiguredModel();
+    if (!executable || !model) {
+        return null;
+    }
+    return {
+        executable,
+        model,
+        language: getConfiguredLanguage(),
+    };
+}
+function getInstallRoot() {
+    return join(getClaudeConfigHomeDir(), 'dictation', 'whisper.cpp');
+}
+function normalizeModelName(modelName) {
+    const raw = (modelName ?? DEFAULT_MODEL_NAME).trim();
+    if (!raw) {
+        return DEFAULT_MODEL_NAME;
+    }
+    return raw.endsWith('.bin')
+        ? raw.replace(/^ggml-/, '').replace(/\.bin$/i, '')
+        : raw;
+}
+function buildModelFileName(modelName) {
+    return `ggml-${normalizeModelName(modelName)}.bin`;
+}
+function getPlatformArchiveExtension() {
+    return process.platform === 'win32' ? '.zip' : '.tar.gz';
+}
+function escapePowerShellLiteral(value) {
+    return value.replace(/'/g, "''");
+}
+async function fetchBuffer(url, label) {
+    const response = await fetch(url, {
+        headers: {
+            'User-Agent': 'ContextCode-DictationInstaller',
+            Accept: 'application/octet-stream, application/json',
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`No se pudo descargar ${label} (${response.status} ${response.statusText}).`);
+    }
+    return Buffer.from(await response.arrayBuffer());
+}
+async function fetchLatestRelease() {
+    const response = await fetch(WHISPER_RELEASE_API, {
+        headers: {
+            'User-Agent': 'ContextCode-DictationInstaller',
+            Accept: 'application/vnd.github+json',
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`No se pudo consultar la ultima version de whisper.cpp (${response.status} ${response.statusText}).`);
+    }
+    return (await response.json());
+}
+function scoreReleaseAsset(asset) {
+    const name = asset.name.toLowerCase();
+    if (name.includes('source code')) {
+        return -100;
+    }
+    let score = 0;
+    const expectedExt = getPlatformArchiveExtension();
+    if (name.endsWith(expectedExt))
+        score += 10;
+    if (name.includes('bin'))
+        score += 5;
+    if (name.includes('build'))
+        score += 2;
+    switch (process.platform) {
+        case 'win32':
+            if (name.includes('win') || name.includes('windows') || name.includes('msvc')) {
+                score += 5;
+            }
+            if (name.includes('x64') || name.includes('amd64'))
+                score += 4;
+            if (name.includes('arm64'))
+                score -= 4;
+            break;
+        case 'darwin':
+            if (name.includes('mac') || name.includes('darwin') || name.includes('apple')) {
+                score += 5;
+            }
+            if (process.arch === 'arm64') {
+                if (name.includes('arm64'))
+                    score += 4;
+                if (name.includes('x64') || name.includes('amd64'))
+                    score -= 4;
+            }
+            break;
+        default:
+            if (name.includes('linux'))
+                score += 5;
+            if (process.arch === 'x64' && (name.includes('x64') || name.includes('amd64'))) {
+                score += 4;
+            }
+            if (process.arch === 'arm64' && name.includes('arm64'))
+                score += 4;
+            break;
+    }
+    return score;
+}
+function pickReleaseAsset(assets) {
+    const ranked = [...assets]
+        .map(asset => ({ asset, score: scoreReleaseAsset(asset) }))
+        .filter(entry => entry.score > 0)
+        .sort((a, b) => b.score - a.score);
+    return ranked[0]?.asset ?? null;
+}
+async function extractArchive(archivePath, destination) {
+    if (archivePath.endsWith('.zip')) {
+        if (process.platform === 'win32') {
+            await execa('powershell', [
+                '-NoProfile',
+                '-NonInteractive',
+                '-Command',
+                `Expand-Archive -LiteralPath '${escapePowerShellLiteral(archivePath)}' -DestinationPath '${escapePowerShellLiteral(destination)}' -Force`,
+            ], { windowsHide: true });
+            return;
+        }
+        await execa('unzip', ['-o', archivePath, '-d', destination], {
+            windowsHide: true,
+        });
+        return;
+    }
+    if (archivePath.endsWith('.tar.gz') || archivePath.endsWith('.tgz')) {
+        await execa('tar', ['-xzf', archivePath, '-C', destination], {
+            windowsHide: true,
+        });
+        return;
+    }
+    throw new Error(`Formato de paquete no soportado: ${basename(archivePath)}`);
+}
+async function findFileRecursive(rootDir, predicate) {
+    const entries = await readdir(rootDir, { withFileTypes: true });
+    for (const entry of entries) {
+        const absolutePath = join(rootDir, entry.name);
+        if (entry.isDirectory()) {
+            const nested = await findFileRecursive(absolutePath, predicate);
+            if (nested) {
+                return nested;
+            }
+            continue;
+        }
+        if (predicate(absolutePath)) {
+            return absolutePath;
+        }
+    }
+    return null;
+}
+async function findInstalledExecutable(installDir) {
+    const candidateNames = process.platform === 'win32'
+        ? ['whisper-cli.exe', 'main.exe']
+        : ['whisper-cli', 'whisper-cpp', 'main'];
+    return findFileRecursive(installDir, path => candidateNames.some(name => path.toLowerCase().endsWith(name.toLowerCase())));
+}
+function persistInstalledDictationConfig(config) {
+    saveGlobalConfig(current => ({
+        ...current,
+        dictationConfig: {
+            ...(current.dictationConfig ?? {}),
+            ...config,
+        },
+    }));
+}
+export function getLocalDictationSetupHint() {
+    return [
+        'Configura Whisper local antes de usar /dictar.',
+        'Opcion recomendada:',
+        '- Ejecuta /dictar install para descargar e instalar el backend automaticamente.',
+        'Tambien puedes configurarlo manualmente con estas variables:',
+        '- CONTEXT_CODE_DICTATION_EXECUTABLE o WHISPER_CPP_PATH',
+        '- CONTEXT_CODE_DICTATION_MODEL o WHISPER_MODEL_PATH',
+        'Ejemplo PowerShell:',
+        'setx CONTEXT_CODE_DICTATION_EXECUTABLE "C:\\whisper\\whisper-cli.exe"',
+        'setx CONTEXT_CODE_DICTATION_MODEL "C:\\whisper\\models\\ggml-base.bin"',
+    ].join('\n');
+}
+export async function checkLocalDictationConfiguration() {
+    const config = getDictationConfig();
+    if (!config) {
+        return { available: false, error: getLocalDictationSetupHint() };
+    }
+    if (!fileExists(config.model)) {
+        return {
+            available: false,
+            error: `No se encontro el modelo de dictado: ${config.model}\n` +
+                getLocalDictationSetupHint(),
+        };
+    }
+    try {
+        await execa(config.executable, ['--help'], {
+            timeout: 10_000,
+            windowsHide: true,
+            reject: false,
+        });
+        return { available: true };
+    }
+    catch (error) {
+        return {
+            available: false,
+            error: `No se pudo ejecutar el backend de dictado (${config.executable}).\n` +
+                `${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+export async function getLocalDictationStatus() {
+    const config = getDictationConfig();
+    const check = await checkLocalDictationConfiguration();
+    const stored = getStoredDictationConfig();
+    if (!config || !check.available) {
+        return check.error ?? 'El dictado local no esta configurado.';
+    }
+    const lines = [
+        'Dictado local configurado.',
+        `Backend: ${config.executable}`,
+        `Modelo: ${config.model}`,
+    ];
+    if (stored?.releaseTag) {
+        lines.push(`Release instalada: ${stored.releaseTag}`);
+    }
+    if (stored?.installedAt) {
+        lines.push(`Instalado: ${stored.installedAt}`);
+    }
+    return lines.join('\n');
+}
+async function isCommandAvailable(command) {
+    const probe = process.platform === 'win32' ? 'where' : 'which';
+    try {
+        const result = await execa(probe, [command], {
+            reject: false,
+            windowsHide: true,
+            timeout: 5_000,
+        });
+        return result.exitCode === 0;
+    }
+    catch {
+        return false;
+    }
+}
+async function getBrewPrefix() {
+    try {
+        const result = await execa('brew', ['--prefix'], {
+            reject: false,
+            windowsHide: true,
+            timeout: 10_000,
+        });
+        if (result.exitCode === 0) {
+            const prefix = result.stdout.trim();
+            return prefix || null;
+        }
+    }
+    catch {
+        // ignore
+    }
+    return null;
+}
+async function installViaHomebrew(modelName) {
+    const normalizedModelName = normalizeModelName(modelName);
+    const modelFileName = buildModelFileName(normalizedModelName);
+    const installDir = getInstallRoot();
+    // Instala (o reinstala/actualiza si ya estaba) whisper-cpp con brew.
+    const brewResult = await execa('brew', ['install', 'whisper-cpp'], {
+        reject: false,
+        windowsHide: true,
+        timeout: 600_000,
+    });
+    if (brewResult.exitCode !== 0) {
+        throw new Error(`brew install whisper-cpp fallo:\n${brewResult.stderr || brewResult.stdout || 'error desconocido'}`);
+    }
+    // Homebrew instala el binario como `whisper-cli` (igual que los releases),
+    // pero algunas versiones antiguas usaban `whisper-cpp`. Probamos ambos.
+    const brewPrefix = await getBrewPrefix();
+    const binNames = ['whisper-cli', 'whisper-cpp'];
+    const candidatePaths = [];
+    for (const name of binNames) {
+        if (brewPrefix)
+            candidatePaths.push(join(brewPrefix, 'bin', name));
+        candidatePaths.push(`/opt/homebrew/bin/${name}`);
+        candidatePaths.push(`/usr/local/bin/${name}`);
+    }
+    let executablePath = candidatePaths.find(fileExists) ?? null;
+    if (!executablePath) {
+        // Fallback: resolver via `which` para cualquiera de los nombres.
+        for (const name of binNames) {
+            const which = await execa('which', [name], {
+                reject: false,
+                windowsHide: true,
+                timeout: 5_000,
+            });
+            if (which.exitCode === 0 && which.stdout.trim()) {
+                executablePath = which.stdout.trim();
+                break;
+            }
+        }
+    }
+    if (!executablePath) {
+        throw new Error('brew instalo whisper-cpp pero no encontre el binario en el PATH.');
+    }
+    // Descarga el modelo GGML (Homebrew no lo trae) en nuestra carpeta privada.
+    const modelDir = join(installDir, 'models');
+    const modelPath = join(modelDir, modelFileName);
+    await mkdir(modelDir, { recursive: true });
+    if (!fileExists(modelPath)) {
+        await writeFile(modelPath, await fetchBuffer(`${WHISPER_MODEL_BASE_URL}/${modelFileName}?download=1`, `modelo ${modelFileName}`));
+    }
+    // Intenta resolver la version instalada para guardarla como releaseTag.
+    let releaseTag = 'homebrew';
+    try {
+        const versionResult = await execa(executablePath, ['--version'], {
+            reject: false,
+            windowsHide: true,
+            timeout: 10_000,
+        });
+        const text = `${versionResult.stdout}\n${versionResult.stderr}`;
+        const match = text.match(/v?\d+\.\d+(?:\.\d+)?/);
+        if (match)
+            releaseTag = `homebrew-${match[0]}`;
+    }
+    catch {
+        // ignore
+    }
+    persistInstalledDictationConfig({
+        executablePath,
+        installDir,
+        installedAt: new Date().toISOString(),
+        modelName: normalizedModelName,
+        modelPath,
+        releaseTag,
+    });
+    logForDebugging(`[dictation] Instalacion via Homebrew: ${executablePath}, modelo en ${modelPath}`);
+    return { executablePath, installDir, modelPath, releaseTag };
+}
+function getManualInstallInstructions() {
+    if (process.platform === 'darwin') {
+        return [
+            'En macOS no hay binarios precompilados en los releases oficiales de whisper.cpp.',
+            'Opciones para instalarlo manualmente:',
+            '1) Instala Homebrew (https://brew.sh) y luego ejecuta `brew install whisper-cpp`.',
+            '2) Compila desde fuente: clona https://github.com/ggml-org/whisper.cpp y',
+            '   ejecuta `cmake -B build && cmake --build build -j --config Release`.',
+            'Despues apunta el backend con la variable CONTEXT_CODE_DICTATION_EXECUTABLE',
+            'y el modelo con CONTEXT_CODE_DICTATION_MODEL, o vuelve a ejecutar /dictar install.',
+        ].join('\n');
+    }
+    if (process.platform === 'linux') {
+        return [
+            'En Linux no hay binarios precompilados en los releases oficiales de whisper.cpp.',
+            'Compila desde fuente:',
+            '  git clone https://github.com/ggml-org/whisper.cpp && cd whisper.cpp',
+            '  cmake -B build && cmake --build build -j --config Release',
+            'Despues exporta CONTEXT_CODE_DICTATION_EXECUTABLE y CONTEXT_CODE_DICTATION_MODEL,',
+            'o vuelve a ejecutar /dictar install una vez tengas el binario en el PATH.',
+        ].join('\n');
+    }
+    return 'No encontre un binario compatible para tu plataforma.';
+}
+export async function installLocalDictation(modelName) {
+    // En macOS los releases oficiales solo publican binarios para Windows e iOS,
+    // asi que usamos Homebrew como camino preferido.
+    if (process.platform === 'darwin') {
+        if (await isCommandAvailable('brew')) {
+            return installViaHomebrew(modelName);
+        }
+        throw new Error(`No se encontro Homebrew en el sistema.\n${getManualInstallInstructions()}`);
+    }
+    const normalizedModelName = normalizeModelName(modelName);
+    const modelFileName = buildModelFileName(normalizedModelName);
+    const installDir = getInstallRoot();
+    const tempDir = await mkdtemp(join(tmpdir(), 'context-dictation-install-'));
+    try {
+        const release = await fetchLatestRelease();
+        const asset = pickReleaseAsset(release.assets);
+        if (!asset) {
+            throw new Error(`No encontre un binario compatible de whisper.cpp para ${process.platform}/${process.arch}.\n${getManualInstallInstructions()}`);
+        }
+        const archivePath = join(tempDir, asset.name);
+        const modelPath = join(installDir, 'models', modelFileName);
+        await mkdir(installDir, { recursive: true });
+        await writeFile(archivePath, await fetchBuffer(asset.browser_download_url, `whisper.cpp (${asset.name})`));
+        await rm(installDir, { recursive: true, force: true });
+        await mkdir(installDir, { recursive: true });
+        await extractArchive(archivePath, installDir);
+        const executablePath = await findInstalledExecutable(installDir);
+        if (!executablePath) {
+            throw new Error('La descarga termino, pero no encontre whisper-cli dentro del paquete instalado.');
+        }
+        await mkdir(join(installDir, 'models'), { recursive: true });
+        await writeFile(modelPath, await fetchBuffer(`${WHISPER_MODEL_BASE_URL}/${modelFileName}?download=1`, `modelo ${modelFileName}`));
+        persistInstalledDictationConfig({
+            executablePath,
+            installDir,
+            installedAt: new Date().toISOString(),
+            modelName: normalizedModelName,
+            modelPath,
+            releaseTag: release.tag_name,
+        });
+        logForDebugging(`[dictation] Instalacion completada en ${installDir} usando ${asset.name}`);
+        return {
+            executablePath,
+            installDir,
+            modelPath,
+            releaseTag: release.tag_name,
+        };
+    }
+    finally {
+        await rm(tempDir, { recursive: true, force: true });
+    }
+}
+function buildWavBuffer(chunks) {
+    const pcmData = Buffer.concat(chunks);
+    const byteRate = SAMPLE_RATE * CHANNELS * (BITS_PER_SAMPLE / 8);
+    const blockAlign = CHANNELS * (BITS_PER_SAMPLE / 8);
+    const header = Buffer.alloc(44);
+    header.write('RIFF', 0);
+    header.writeUInt32LE(36 + pcmData.length, 4);
+    header.write('WAVE', 8);
+    header.write('fmt ', 12);
+    header.writeUInt32LE(16, 16);
+    header.writeUInt16LE(1, 20);
+    header.writeUInt16LE(CHANNELS, 22);
+    header.writeUInt32LE(SAMPLE_RATE, 24);
+    header.writeUInt32LE(byteRate, 28);
+    header.writeUInt16LE(blockAlign, 32);
+    header.writeUInt16LE(BITS_PER_SAMPLE, 34);
+    header.write('data', 36);
+    header.writeUInt32LE(pcmData.length, 40);
+    return Buffer.concat([header, pcmData]);
+}
+export async function transcribePcmBuffers(chunks, opts) {
+    const config = getDictationConfig();
+    if (!config) {
+        throw new Error(getLocalDictationSetupHint());
+    }
+    const dir = await mkdtemp(join(tmpdir(), 'context-dictation-'));
+    const inputPath = join(dir, 'input.wav');
+    const outputPrefix = join(dir, 'result');
+    const outputTxtPath = `${outputPrefix}.txt`;
+    try {
+        await writeFile(inputPath, buildWavBuffer(chunks));
+        const args = ['-m', config.model, '-f', inputPath, '-otxt', '-of', outputPrefix];
+        const language = opts?.language || config.language;
+        if (language && language !== 'auto') {
+            args.push('-l', language);
+        }
+        logForDebugging(`[dictation] Running ${config.executable} ${args.map(part => JSON.stringify(part)).join(' ')}`);
+        const result = await execa(config.executable, args, {
+            timeout: 120_000,
+            windowsHide: true,
+            reject: false,
+        });
+        if (result.exitCode !== 0) {
+            throw new Error(result.stderr || result.stdout || 'Whisper finalizo con error.');
+        }
+        return (await readFile(outputTxtPath, 'utf8')).trim();
+    }
+    finally {
+        await rm(dir, { recursive: true, force: true });
+    }
+}

package/dist/src/services/voice.js

@@ -16,7 +16,7 @@ let audioNapiPromise = null;
 function loadAudioNapi() {
     audioNapiPromise ??= (async () => {
         const t0 = Date.now();
-        const mod = await import('audio-capture-napi');
+        const mod = await import('../../vendor/audio-capture-src/index.js');
         // vendor/audio-capture-src/index.ts defers require(...node) until the
         // first function call — trigger it here so timing reflects real cost.
         mod.isNativeAudioAvailable();
@@ -146,7 +146,9 @@ export async function checkVoiceDependencies() {
     if (process.platform === 'win32') {
         return {
             available: false,
-            missing: ['Voice mode requires the native audio module (not loaded)'],
+            missing: [
+                'El dictado local requiere el modulo nativo de audio y no se pudo cargar.',
+            ],
             installCommand: null,
         };
     }
@@ -189,7 +191,7 @@ export async function checkRecordingAvailability() {
     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.',
+            reason: 'El dictado local necesita acceso al microfono, pero este entorno no tiene un dispositivo de audio disponible.\n\nPara usar dictado, ejecuta Context Code de forma local.',
         };
     }
     // Native audio module (cpal) handles everything on macOS, Linux, and Windows
@@ -201,10 +203,10 @@ export async function checkRecordingAvailability() {
     if (process.platform === 'win32') {
         return {
             available: false,
-            reason: 'Voice recording requires the native audio module, which could not be loaded.',
+            reason: 'La grabacion para dictado requiere el modulo nativo de audio y no se pudo cargar.',
         };
     }
-    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.';
+    const wslNoAudioReason = 'El dictado local no pudo acceder a un dispositivo de audio en WSL.\n\nWSL2 con WSLg (Windows 11) expone audio mediante PulseAudio. Si estas en Windows 10 o WSL1, ejecuta Context Code directamente en Windows.';
     // 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
@@ -239,8 +241,8 @@ export async function checkRecordingAvailability() {
         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',
+                ? `El dictado local requiere SoX para grabar audio. Instalalo con: ${pm.displayCommand}`
+                : 'El dictado local requiere SoX para grabar audio. Instalalo manualmente:\n  macOS: brew install sox\n  Ubuntu/Debian: sudo apt-get install sox\n  Fedora: sudo dnf install sox',
         };
     }
     return { available: true, reason: null };

package/dist/src/state/AppState.js

@@ -1,4 +1,3 @@
-import { feature } from '../recovery/bunBundleShim.js';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
@@ -10,9 +9,8 @@ import { logForDebugging } from '../utils/debug.js';
 import { createDisabledBypassPermissionsContext, isBypassPermissionsModeDisabled } from '../utils/permissions/permissionSetup.js';
 import { applySettingsChange } from '../utils/settings/applySettingsChange.js';
 import { createStore } from './store.js';
-// DCE: voice context is ant-only. External builds get a passthrough.
 /* eslint-disable @typescript-eslint/no-require-imports */
-const VoiceProvider = feature('VOICE_MODE') ? require('../context/voice.js').VoiceProvider : ({ children }) => children;
+const VoiceProvider = require('../context/voice.js').VoiceProvider;
 /* eslint-enable @typescript-eslint/no-require-imports */
 import { getDefaultAppState } from './AppStateStore.js';
 // TODO: Remove these re-exports once all callers import directly from

package/dist/src/tools/ConfigTool/ConfigTool.js

@@ -190,33 +190,31 @@ export const ConfigTool = buildTool({
             finalValue === true) {
             const { isVoiceModeEnabled } = await import('../../voice/voiceModeEnabled.js');
             if (!isVoiceModeEnabled()) {
-                const { isAnthropicAuthEnabled } = await import('../../utils/auth.js');
                 return {
                     data: {
                         success: false,
-                        error: !isAnthropicAuthEnabled()
-                            ? 'Voice mode requires a Claude.ai account. Please run /login to sign in.'
-                            : 'Voice mode is not available.',
+                        error: 'El modo de dictado no esta disponible.',
                     },
                 };
             }
-            const { isVoiceStreamAvailable } = await import('../../services/voiceStreamSTT.js');
             const { checkRecordingAvailability, checkVoiceDependencies, requestMicrophonePermission, } = await import('../../services/voice.js');
+            const { checkLocalDictationConfiguration } = await import('../../services/localDictation.js');
             const recording = await checkRecordingAvailability();
             if (!recording.available) {
                 return {
                     data: {
                         success: false,
                         error: recording.reason ??
-                            'Voice mode is not available in this environment.',
+                            'El modo de dictado no esta disponible en este entorno.',
                     },
                 };
             }
-            if (!isVoiceStreamAvailable()) {
+            const dictation = await checkLocalDictationConfiguration();
+            if (!dictation.available) {
                 return {
                     data: {
                         success: false,
-                        error: 'Voice mode requires a Claude.ai account. Please run /login to sign in.',
+                        error: dictation.error ?? 'El dictado local no esta configurado.',
                     },
                 };
             }
@@ -225,27 +223,26 @@ export const ConfigTool = buildTool({
                 return {
                     data: {
                         success: false,
-                        error: 'No audio recording tool found.' +
-                            (deps.installCommand ? ` Run: ${deps.installCommand}` : ''),
+                        error: 'No se encontro una herramienta de grabacion de audio.' +
+                            (deps.installCommand ? ` Ejecuta: ${deps.installCommand}` : ''),
                     },
                 };
             }
             if (!(await requestMicrophonePermission())) {
                 let guidance;
                 if (process.platform === 'win32') {
-                    guidance = 'Settings \u2192 Privacy \u2192 Microphone';
+                    guidance = 'Configuracion > Privacidad > Microfono';
                 }
                 else if (process.platform === 'linux') {
-                    guidance = "your system's audio settings";
+                    guidance = 'la configuracion de audio del sistema';
                 }
                 else {
-                    guidance =
-                        'System Settings \u2192 Privacy & Security \u2192 Microphone';
+                    guidance = 'System Settings > Privacy & Security > Microphone';
                 }
                 return {
                     data: {
                         success: false,
-                        error: `Microphone access is denied. To enable it, go to ${guidance}, then try again.`,
+                        error: `El acceso al microfono esta denegado. Habilitalo en ${guidance} y vuelve a intentar.`,
                     },
                 };
             }