claude-phone-local 2.0.0

package/voice-app/lib/whisper-client.js

@@ -0,0 +1,140 @@
+/**
+ * Speech-to-Text Client
+ *
+ * Default mode ("local"): sends audio to the local faster-whisper sidecar
+ * container (stt-local) — no API key, fully offline.
+ *
+ * Optional mode ("cloud", set STT_MODE=cloud): original OpenAI Whisper API
+ * behavior, preserved for anyone who still wants it.
+ */
+
+const WaveFile = require("wavefile").WaveFile;
+const axios = require("axios");
+const FormData = require("form-data");
+
+const STT_MODE = (process.env.STT_MODE || "local").toLowerCase();
+// Docker Desktop bridge networking: reach the sidecar by service name.
+const STT_LOCAL_URL = process.env.STT_LOCAL_URL || "http://stt-local:9001";
+
+// Lazy-initialized OpenAI client (cloud mode only)
+let openai = null;
+
+function getOpenAIClient() {
+  if (!openai) {
+    if (!process.env.OPENAI_API_KEY) {
+      console.warn("[WHISPER] OPENAI_API_KEY not set - cloud STT will not work");
+      return null;
+    }
+    const OpenAI = require("openai");
+    openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+  }
+  return openai;
+}
+
+/**
+ * Convert L16 PCM buffer to WAV format
+ * @param {Buffer} pcmBuffer - Raw L16 PCM audio data
+ * @param {number} sampleRate - Sample rate (default: 8000 Hz for telephony)
+ * @returns {Buffer} WAV file buffer
+ */
+function pcmToWav(pcmBuffer, sampleRate = 8000) {
+  const wav = new WaveFile();
+  const samples = new Int16Array(pcmBuffer.buffer, pcmBuffer.byteOffset, pcmBuffer.length / 2);
+  wav.fromScratch(1, sampleRate, "16", samples);
+  return Buffer.from(wav.toBuffer());
+}
+
+async function transcribeLocal(wavBuffer, language) {
+  const form = new FormData();
+  form.append("file", wavBuffer, { filename: "audio.wav", contentType: "audio/wav" });
+  form.append("language", language);
+
+  const timestamp = new Date().toISOString();
+  const response = await axios.post(`${STT_LOCAL_URL}/transcribe`, form, {
+    headers: form.getHeaders(),
+    timeout: 30000
+  });
+
+  const text = (response.data && response.data.text) ? response.data.text.trim() : "";
+  const detected = (response.data && response.data.language) ? response.data.language : null;
+  console.log(`[${timestamp}] WHISPER-LOCAL Transcribed [${detected || "?"}]: ${text.substring(0, 100)}${text.length > 100 ? "..." : ""}`);
+  return { text, language: detected };
+}
+
+async function transcribeCloud(wavBuffer, language) {
+  const fs = require("fs");
+  const path = require("path");
+  const client = getOpenAIClient();
+  if (!client) {
+    throw new Error("OpenAI API key not configured");
+  }
+
+  const tempFile = path.join("/tmp", "whisper-" + Date.now() + ".wav");
+  fs.writeFileSync(tempFile, wavBuffer);
+
+  try {
+    const transcription = await client.audio.transcriptions.create({
+      file: fs.createReadStream(tempFile),
+      model: "whisper-1",
+      language,
+      response_format: "text"
+    });
+
+    const timestamp = new Date().toISOString();
+    console.log(`[${timestamp}] WHISPER-CLOUD Transcribed: ${transcription.substring(0, 100)}${transcription.length > 100 ? "..." : ""}`);
+    return transcription;
+  } finally {
+    try { fs.unlinkSync(tempFile); } catch (e) { /* ignore */ }
+  }
+}
+
+/**
+ * Transcribe audio (local by default, cloud if STT_MODE=cloud)
+ * @param {Buffer} audioBuffer - Audio data (either WAV or raw PCM)
+ * @param {Object} options - { format: "wav"|"pcm", sampleRate, language }
+ * @returns {Promise<string>} Transcribed text
+ */
+async function transcribe(audioBuffer, options = {}) {
+  const result = await transcribeDetailed(audioBuffer, options);
+  return result.text;
+}
+
+/**
+ * Same as transcribe() but also reports the language Whisper detected.
+ * @returns {Promise<{text: string, language: string|null}>}
+ */
+async function transcribeDetailed(audioBuffer, options = {}) {
+  const {
+    format = "pcm",
+    sampleRate = 8000,
+    language = process.env.STT_LANGUAGE || "auto"
+  } = options;
+
+  const wavBuffer = format === "pcm" ? pcmToWav(audioBuffer, sampleRate) : audioBuffer;
+
+  if (STT_MODE === "cloud") {
+    // Cloud path has no detection contract; report the requested language.
+    const text = await transcribeCloud(wavBuffer, language === "auto" ? undefined : language);
+    return { text, language: language === "auto" ? null : language };
+  }
+  return transcribeLocal(wavBuffer, language);
+}
+
+/**
+ * Check if STT is configured and available
+ * @returns {boolean}
+ */
+function isAvailable() {
+  if (STT_MODE === "cloud") {
+    return !!process.env.OPENAI_API_KEY;
+  }
+  return true; // local mode has no key requirement
+}
+
+module.exports = {
+  transcribe,
+  transcribeDetailed,
+  pcmToWav,
+  isAvailable,
+  mode: STT_MODE
+};

package/voice-app/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "claude-phone-voice-app",
+  "version": "1.0.0",
+  "description": "Voice interface for Claude Code via SIP/3CX",
+  "main": "index.js",
+  "scripts": {
+    "start": "node index.js",
+    "dev": "node --watch index.js",
+    "lint": "cd .. && npm run lint:voice-app",
+    "lint:fix": "cd .. && eslint voice-app/ --fix"
+  },
+  "dependencies": {
+    "axios": "^1.6.0",
+    "debug": "^4.3.4",
+    "dotenv": "^16.3.1",
+    "drachtio-fsmrf": "^3.0.0",
+    "drachtio-srf": "^4.5.0",
+    "express": "^4.18.2",
+    "form-data": "^4.0.0",
+    "openai": "^4.20.0",
+    "uuid": "^9.0.0",
+    "wavefile": "^11.0.0",
+    "ws": "^8.14.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "voice",
+    "sip",
+    "claude",
+    "ai",
+    "3cx",
+    "drachtio"
+  ],
+  "author": "Deepak Chougale",
+  "license": "MIT"
+}

package/voice-app/test/freeswitch-retry.test.js

@@ -0,0 +1,100 @@
+/**
+ * FreeSWITCH Retry Logic Test
+ *
+ * Tests the exponential backoff retry mechanism for FreeSWITCH connections.
+ * Run with: node test/freeswitch-retry.test.js
+ */
+
+var assert = require('assert');
+
+// Import the ACTUAL production code - not a copy!
+var connectionRetry = require('../lib/connection-retry');
+var connectWithRetry = connectionRetry.connectWithRetry;
+
+// Mock FreeSWITCH connection function for testing
+function createMockFreeswitchConnect(failCount) {
+  var attempts = 0;
+  return function() {
+    attempts++;
+    if (attempts <= failCount) {
+      return Promise.reject(new Error('Connection refused (attempt ' + attempts + ')'));
+    }
+    return Promise.resolve({ connection: 'mock-ms' });
+  };
+}
+
+// Test suite
+function runTests() {
+  console.log('='.repeat(64));
+  console.log('FreeSWITCH Retry Logic Tests');
+  console.log('='.repeat(64));
+
+  // Use short delays for testing (10ms instead of 1000ms)
+  var testDelays = [10, 20, 30, 50, 50, 50, 100, 100, 100, 100];
+  var maxRetries = 10;
+
+  // Test 1: Succeed on first attempt
+  console.log('\n[TEST 1] Should succeed on first attempt');
+  var mockConnect1 = createMockFreeswitchConnect(0);
+  connectWithRetry(mockConnect1, {
+    maxRetries: maxRetries,
+    retryDelays: testDelays,
+    name: 'TEST'
+  })
+    .then(function(ms) {
+      assert.strictEqual(ms.connection, 'mock-ms', 'Should return mock connection');
+      console.log('[TEST 1] PASSED\n');
+
+      // Test 2: Succeed on 3rd attempt
+      console.log('[TEST 2] Should succeed on 3rd attempt after 2 failures');
+      var mockConnect2 = createMockFreeswitchConnect(2);
+      return connectWithRetry(mockConnect2, {
+        maxRetries: maxRetries,
+        retryDelays: testDelays,
+        name: 'TEST'
+      });
+    })
+    .then(function(ms) {
+      assert.strictEqual(ms.connection, 'mock-ms', 'Should return mock connection');
+      console.log('[TEST 2] PASSED\n');
+
+      // Test 3: Fail after max retries
+      console.log('[TEST 3] Should fail after max retries');
+      var mockConnect3 = createMockFreeswitchConnect(999); // Always fail
+      return connectWithRetry(mockConnect3, {
+        maxRetries: maxRetries,
+        retryDelays: testDelays,
+        name: 'TEST'
+      });
+    })
+    .catch(function(err) {
+      assert.ok(err.message.includes('failed after 10 attempts'), 'Should report max retries');
+      console.log('[TEST 3] PASSED - Correctly failed after max retries\n');
+
+      // Test 4: Verify default delay values from production code
+      console.log('[TEST 4] Verify default delay values match production');
+      // The production defaults are: [1000, 2000, 3000, 5000, 5000, 5000, 10000, 10000, 10000, 10000]
+      // We verify by testing that the module accepts empty options and uses defaults
+      var mockConnect4 = createMockFreeswitchConnect(0);
+      return connectWithRetry(mockConnect4, { name: 'DEFAULT-TEST' });
+    })
+    .then(function(ms) {
+      assert.strictEqual(ms.connection, 'mock-ms', 'Should work with default options');
+      console.log('[TEST 4] PASSED\n');
+
+      console.log('='.repeat(64));
+      console.log('All tests PASSED!');
+      console.log('='.repeat(64));
+    })
+    .catch(function(err) {
+      console.error('[TEST] FAILED: ' + err.message);
+      process.exit(1);
+    });
+}
+
+// Run tests if executed directly
+if (require.main === module) {
+  runTests();
+}
+
+module.exports = { runTests: runTests };