@iaforged/context-code 1.1.4 → 1.1.5

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.`,
                     },
                 };
             }

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

@@ -99,7 +99,7 @@ export const SUPPORTED_SETTINGS = {
     language: {
         source: 'settings',
         type: 'string',
-        description: 'Preferred language for Claude responses and voice dictation (e.g., "japanese", "spanish")',
+        description: 'Idioma preferido para las respuestas de Context y el dictado local (por ejemplo, "japanese", "spanish")',
     },
     teammateMode: {
         source: 'global',
@@ -121,7 +121,7 @@ export const SUPPORTED_SETTINGS = {
             voiceEnabled: {
                 source: 'settings',
                 type: 'boolean',
-                description: 'Enable voice dictation (hold-to-talk)',
+                description: 'Activar dictado local (mantener pulsado para hablar)',
             },
         }
         : {}),

package/dist/src/utils/imagePaste.js

@@ -25,6 +25,7 @@ function getClipboardCommands() {
         win32: join(baseTmpDir, screenshotFilename),
     };
     const screenshotPath = tempPaths[platform] || tempPaths.linux;
+    const escapedScreenshotPath = screenshotPath.replace(/'/g, "''");
     // Platform-specific clipboard commands
     const commands = {
         darwin: {
@@ -40,10 +41,10 @@ function getClipboardCommands() {
             deleteFile: `rm -f "${screenshotPath}"`,
         },
         win32: {
-            checkImage: 'powershell -NoProfile -Command "(Get-Clipboard -Format Image) -ne $null"',
-            saveImage: `powershell -NoProfile -Command "$img = Get-Clipboard -Format Image; if ($img) { $img.Save('${screenshotPath.replace(/\\/g, '\\\\')}', [System.Drawing.Imaging.ImageFormat]::Png) }"`,
-            getPath: 'powershell -NoProfile -Command "Get-Clipboard"',
-            deleteFile: `del /f "${screenshotPath}"`,
+            checkImage: 'powershell -NoProfile -STA -Command "Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.Clipboard]::ContainsImage()"',
+            saveImage: `powershell -NoProfile -STA -Command "Add-Type -AssemblyName System.Windows.Forms; Add-Type -AssemblyName System.Drawing; $img = [System.Windows.Forms.Clipboard]::GetImage(); if ($img -ne $null) { $img.Save('${escapedScreenshotPath}', [System.Drawing.Imaging.ImageFormat]::Png) } else { exit 1 }"`,
+            getPath: 'powershell -NoProfile -Command "Get-Clipboard -Raw"',
+            deleteFile: `powershell -NoProfile -Command "Remove-Item -LiteralPath '${escapedScreenshotPath}' -Force -ErrorAction SilentlyContinue"`,
         },
     };
     return {
@@ -56,7 +57,12 @@ function getClipboardCommands() {
  */
 export async function hasImageInClipboard() {
     if (process.platform !== 'darwin') {
-        return false;
+        const { commands } = getClipboardCommands();
+        const result = await execa(commands.checkImage, {
+            shell: true,
+            reject: false,
+        });
+        return result.exitCode === 0 && result.stdout.trim().toLowerCase() !== 'false';
     }
     if (feature('NATIVE_CLIPBOARD_IMAGE') &&
         getFeatureValue_CACHED_MAY_BE_STALE('tengu_collage_kaleidoscope', true)) {

package/dist/src/utils/settings/types.js

@@ -501,7 +501,7 @@ export const SettingsSchema = lazySchema(() => z
     language: z
         .string()
         .optional()
-        .describe('Preferred language for Context responses and voice dictation (e.g., "japanese", "spanish")'),
+        .describe('Idioma preferido para las respuestas de Context y el dictado local (por ejemplo, "japanese", "spanish")'),
     skipWebFetchPreflight: z
         .boolean()
         .optional()
@@ -666,7 +666,7 @@ export const SettingsSchema = lazySchema(() => z
             voiceEnabled: z
                 .boolean()
                 .optional()
-                .describe('Enable voice mode (hold-to-talk dictation)'),
+                .describe('Activar dictado local (mantener pulsado para hablar)'),
         }
         : {}),
     ...(feature('KAIROS')

package/dist/src/voice/voiceModeEnabled.js

@@ -1,6 +1,4 @@
-import { feature } from '../recovery/bunBundleShim.js';
 import { getFeatureValue_CACHED_MAY_BE_STALE } from '../services/analytics/growthbook.js';
-import { getClaudeAIOAuthTokens, isAnthropicAuthEnabled, } from '../utils/auth.js';
 /**
  * Kill-switch check for voice mode. Returns true unless the
  * `tengu_amber_quartz_disabled` GrowthBook flag is flipped on (emergency
@@ -10,32 +8,14 @@ import { getClaudeAIOAuthTokens, isAnthropicAuthEnabled, } from '../utils/auth.j
  * should be *visible* (e.g., command registration, config UI).
  */
 export function isVoiceGrowthBookEnabled() {
-    // Positive ternary pattern — see docs/feature-gating.md.
-    // Negative pattern (if (!feature(...)) return) does not eliminate
-    // inline string literals from external builds.
-    return feature('VOICE_MODE')
-        ? !getFeatureValue_CACHED_MAY_BE_STALE('tengu_amber_quartz_disabled', false)
-        : false;
+    return !getFeatureValue_CACHED_MAY_BE_STALE('tengu_amber_quartz_disabled', false);
 }
 /**
- * Auth-only check for voice mode. Returns true when the user has a valid
- * Anthropic OAuth token. Backed by the memoized getClaudeAIOAuthTokens —
- * first call spawns `security` on macOS (~20-50ms), subsequent calls are
- * cache hits. The memoize clears on token refresh (~once/hour), so one
- * cold spawn per refresh is expected. Cheap enough for usage-time checks.
+ * Keep this helper for compatibility with the existing voice hooks. Local
+ * dictation no longer depends on Claude.ai auth.
  */
 export function hasVoiceAuth() {
-    // Voice mode requires Anthropic OAuth — it uses the voice_stream
-    // endpoint on claude.ai which is not available with API keys,
-    // Bedrock, Vertex, or Foundry.
-    if (!isAnthropicAuthEnabled()) {
-        return false;
-    }
-    // isAnthropicAuthEnabled only checks the auth *provider*, not whether
-    // a token exists. Without this check, the voice UI renders but
-    // connectVoiceStream fails silently when the user isn't logged in.
-    const tokens = getClaudeAIOAuthTokens();
-    return Boolean(tokens?.accessToken);
+    return true;
 }
 /**
  * Full runtime check: auth + GrowthBook kill-switch. Callers: `/voice`
@@ -44,5 +24,5 @@ export function hasVoiceAuth() {
  * paths use useVoiceEnabled() instead (memoizes the auth half).
  */
 export function isVoiceModeEnabled() {
-    return hasVoiceAuth() && isVoiceGrowthBookEnabled();
+    return isVoiceGrowthBookEnabled();
 }

package/dist/vendor/audio-capture-src/index.js

@@ -0,0 +1,114 @@
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+let cachedModule = null;
+let loadAttempted = false;
+function loadModule() {
+    if (loadAttempted) {
+        return cachedModule;
+    }
+    loadAttempted = true;
+    // Supported platforms: macOS (darwin), Linux, Windows (win32)
+    const platform = process.platform;
+    if (platform !== 'darwin' && platform !== 'linux' && platform !== 'win32') {
+        return null;
+    }
+    // Candidate 1: native-embed path (bun compile). AUDIO_CAPTURE_NODE_PATH is
+    // defined at build time in build-with-plugins.ts for native builds only — the
+    // define resolves it to the static literal "../../audio-capture.node" so bun
+    // compile can rewrite it to /$bunfs/root/audio-capture.node. MUST stay a
+    // direct require(env var) — bun cannot analyze require(variable) from a loop.
+    if (process.env.AUDIO_CAPTURE_NODE_PATH) {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            cachedModule = require(process.env.AUDIO_CAPTURE_NODE_PATH);
+            return cachedModule;
+        }
+        catch {
+            // fall through to runtime fallbacks below
+        }
+    }
+    // Candidates 2/3: npm-install and dev/source layouts. Dynamic require is
+    // fine here — in bundled output (node --target build) require() resolves at
+    // runtime relative to cli.js at the package root; in dev it resolves
+    // relative to this file (vendor/audio-capture-src/index.ts).
+    const platformDir = `${process.arch}-${platform}`;
+    const fallbacks = [
+        `./vendor/audio-capture/${platformDir}/audio-capture.node`,
+        `../audio-capture/${platformDir}/audio-capture.node`,
+    ];
+    for (const p of fallbacks) {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            cachedModule = require(p);
+            return cachedModule;
+        }
+        catch {
+            // try next
+        }
+    }
+    return null;
+}
+export function isNativeAudioAvailable() {
+    return loadModule() !== null;
+}
+export function startNativeRecording(onData, onEnd) {
+    const mod = loadModule();
+    if (!mod) {
+        return false;
+    }
+    return mod.startRecording(onData, onEnd);
+}
+export function stopNativeRecording() {
+    const mod = loadModule();
+    if (!mod) {
+        return;
+    }
+    mod.stopRecording();
+}
+export function isNativeRecordingActive() {
+    const mod = loadModule();
+    if (!mod) {
+        return false;
+    }
+    return mod.isRecording();
+}
+export function startNativePlayback(sampleRate, channels) {
+    const mod = loadModule();
+    if (!mod) {
+        return false;
+    }
+    return mod.startPlayback(sampleRate, channels);
+}
+export function writeNativePlaybackData(data) {
+    const mod = loadModule();
+    if (!mod) {
+        return;
+    }
+    mod.writePlaybackData(data);
+}
+export function stopNativePlayback() {
+    const mod = loadModule();
+    if (!mod) {
+        return;
+    }
+    mod.stopPlayback();
+}
+export function isNativePlaying() {
+    const mod = loadModule();
+    if (!mod) {
+        return false;
+    }
+    return mod.isPlaying();
+}
+// Returns the microphone authorization status.
+// On macOS, returns the TCC status: 0=notDetermined, 1=restricted, 2=denied, 3=authorized.
+// On Linux, always returns 3 (authorized) — no system-level mic permission API.
+// On Windows, returns 3 (authorized) if registry key absent or allowed, 2 (denied) if explicitly denied.
+// Returns 0 (notDetermined) if the native module is unavailable.
+export function microphoneAuthorizationStatus() {
+    const mod = loadModule();
+    if (!mod || !mod.microphoneAuthorizationStatus) {
+        return 0;
+    }
+    return mod.microphoneAuthorizationStatus();
+}

package/dist/vendor/audio-capture-src/index.ts

@@ -0,0 +1,155 @@
+
+import { createRequire } from 'module'
+
+const require = createRequire(import.meta.url)
+
+type AudioCaptureNapi = {
+  startRecording(
+    onData: (data: Buffer) => void,
+    onEnd: () => void,
+  ): boolean
+  stopRecording(): void
+  isRecording(): boolean
+  startPlayback(sampleRate: number, channels: number): boolean
+  writePlaybackData(data: Buffer): void
+  stopPlayback(): void
+  isPlaying(): boolean
+  // TCC microphone authorization status (macOS only):
+  // 0 = notDetermined, 1 = restricted, 2 = denied, 3 = authorized.
+  // Linux: always returns 3 (authorized) — no system-level microphone permission API.
+  // Windows: returns 3 (authorized) if registry key absent or allowed,
+  //          2 (denied) if microphone access is explicitly denied.
+  microphoneAuthorizationStatus?(): number
+}
+
+let cachedModule: AudioCaptureNapi | null = null
+let loadAttempted = false
+
+function loadModule(): AudioCaptureNapi | null {
+  if (loadAttempted) {
+    return cachedModule
+  }
+  loadAttempted = true
+
+  // Supported platforms: macOS (darwin), Linux, Windows (win32)
+  const platform = process.platform
+  if (platform !== 'darwin' && platform !== 'linux' && platform !== 'win32') {
+    return null
+  }
+
+  // Candidate 1: native-embed path (bun compile). AUDIO_CAPTURE_NODE_PATH is
+  // defined at build time in build-with-plugins.ts for native builds only — the
+  // define resolves it to the static literal "../../audio-capture.node" so bun
+  // compile can rewrite it to /$bunfs/root/audio-capture.node. MUST stay a
+  // direct require(env var) — bun cannot analyze require(variable) from a loop.
+  if (process.env.AUDIO_CAPTURE_NODE_PATH) {
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      cachedModule = require(
+        process.env.AUDIO_CAPTURE_NODE_PATH,
+      ) as AudioCaptureNapi
+      return cachedModule
+    } catch {
+      // fall through to runtime fallbacks below
+    }
+  }
+
+  // Candidates 2/3: npm-install and dev/source layouts. Dynamic require is
+  // fine here — in bundled output (node --target build) require() resolves at
+  // runtime relative to cli.js at the package root; in dev it resolves
+  // relative to this file (vendor/audio-capture-src/index.ts).
+  const platformDir = `${process.arch}-${platform}`
+  const fallbacks = [
+    `./vendor/audio-capture/${platformDir}/audio-capture.node`,
+    `../audio-capture/${platformDir}/audio-capture.node`,
+  ]
+  for (const p of fallbacks) {
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      cachedModule = require(p) as AudioCaptureNapi
+      return cachedModule
+    } catch {
+      // try next
+    }
+  }
+  return null
+}
+
+export function isNativeAudioAvailable(): boolean {
+  return loadModule() !== null
+}
+
+export function startNativeRecording(
+  onData: (data: Buffer) => void,
+  onEnd: () => void,
+): boolean {
+  const mod = loadModule()
+  if (!mod) {
+    return false
+  }
+  return mod.startRecording(onData, onEnd)
+}
+
+export function stopNativeRecording(): void {
+  const mod = loadModule()
+  if (!mod) {
+    return
+  }
+  mod.stopRecording()
+}
+
+export function isNativeRecordingActive(): boolean {
+  const mod = loadModule()
+  if (!mod) {
+    return false
+  }
+  return mod.isRecording()
+}
+
+export function startNativePlayback(
+  sampleRate: number,
+  channels: number,
+): boolean {
+  const mod = loadModule()
+  if (!mod) {
+    return false
+  }
+  return mod.startPlayback(sampleRate, channels)
+}
+
+export function writeNativePlaybackData(data: Buffer): void {
+  const mod = loadModule()
+  if (!mod) {
+    return
+  }
+  mod.writePlaybackData(data)
+}
+
+export function stopNativePlayback(): void {
+  const mod = loadModule()
+  if (!mod) {
+    return
+  }
+  mod.stopPlayback()
+}
+
+export function isNativePlaying(): boolean {
+  const mod = loadModule()
+  if (!mod) {
+    return false
+  }
+  return mod.isPlaying()
+}
+
+// Returns the microphone authorization status.
+// On macOS, returns the TCC status: 0=notDetermined, 1=restricted, 2=denied, 3=authorized.
+// On Linux, always returns 3 (authorized) — no system-level mic permission API.
+// On Windows, returns 3 (authorized) if registry key absent or allowed, 2 (denied) if explicitly denied.
+// Returns 0 (notDetermined) if the native module is unavailable.
+export function microphoneAuthorizationStatus(): number {
+  const mod = loadModule()
+  if (!mod || !mod.microphoneAuthorizationStatus) {
+    return 0
+  }
+  return mod.microphoneAuthorizationStatus()
+}