@ouro.bot/cli 0.1.0-alpha.560 → 0.1.0-alpha.562

package/dist/senses/voice/twilio-phone.js

@@ -0,0 +1,462 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TWILIO_PHONE_WEBHOOK_BASE_PATH = exports.DEFAULT_TWILIO_RECORD_MAX_LENGTH_SECONDS = exports.DEFAULT_TWILIO_RECORD_TIMEOUT_SECONDS = exports.DEFAULT_TWILIO_PHONE_PORT = void 0;
+exports.computeTwilioSignature = computeTwilioSignature;
+exports.validateTwilioSignature = validateTwilioSignature;
+exports.twilioRecordingMediaUrl = twilioRecordingMediaUrl;
+exports.defaultTwilioRecordingDownloader = defaultTwilioRecordingDownloader;
+exports.createTwilioPhoneBridge = createTwilioPhoneBridge;
+exports.startTwilioPhoneBridgeServer = startTwilioPhoneBridgeServer;
+const crypto = __importStar(require("node:crypto"));
+const fs = __importStar(require("fs/promises"));
+const http = __importStar(require("http"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+const playback_1 = require("./playback");
+const turn_1 = require("./turn");
+exports.DEFAULT_TWILIO_PHONE_PORT = 18910;
+exports.DEFAULT_TWILIO_RECORD_TIMEOUT_SECONDS = 2;
+exports.DEFAULT_TWILIO_RECORD_MAX_LENGTH_SECONDS = 30;
+exports.TWILIO_PHONE_WEBHOOK_BASE_PATH = "/voice/twilio";
+function bodyText(body) {
+    if (body === undefined)
+        return "";
+    if (typeof body === "string")
+        return body;
+    return Buffer.from(body).toString("utf8");
+}
+function formParams(rawBody) {
+    const parsed = new URLSearchParams(rawBody);
+    const params = {};
+    for (const [key, value] of parsed) {
+        params[key] = value;
+    }
+    return params;
+}
+function headerValue(headers, name) {
+    const wanted = name.toLowerCase();
+    for (const [key, value] of Object.entries(headers)) {
+        if (key.toLowerCase() !== wanted)
+            continue;
+        if (Array.isArray(value))
+            return value[0] ?? "";
+        return value ?? "";
+    }
+    return "";
+}
+function xmlResponse(body) {
+    return {
+        statusCode: 200,
+        headers: { "content-type": "text/xml; charset=utf-8" },
+        body: `<?xml version="1.0" encoding="UTF-8"?><Response>${body}</Response>`,
+    };
+}
+function textResponse(statusCode, body) {
+    return {
+        statusCode,
+        headers: { "content-type": "text/plain; charset=utf-8" },
+        body,
+    };
+}
+function binaryResponse(body, contentType) {
+    return {
+        statusCode: 200,
+        headers: {
+            "content-type": contentType,
+            "cache-control": "private, max-age=300",
+        },
+        body,
+    };
+}
+function escapeXml(input) {
+    return input
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&apos;");
+}
+function routeUrl(publicBaseUrl, route) {
+    return new URL(route, publicBaseUrl).toString();
+}
+function requestPublicUrl(publicBaseUrl, requestPath) {
+    return routeUrl(publicBaseUrl, requestPath);
+}
+function recordTwiml(options) {
+    return `<Record action="${escapeXml(routeUrl(options.publicBaseUrl, `${exports.TWILIO_PHONE_WEBHOOK_BASE_PATH}/recording`))}" method="POST" playBeep="false" timeout="${options.timeoutSeconds}" maxLength="${options.maxLengthSeconds}" trim="trim-silence" />`;
+}
+function redirectTwiml(publicBaseUrl) {
+    return `<Redirect method="POST">${escapeXml(routeUrl(publicBaseUrl, `${exports.TWILIO_PHONE_WEBHOOK_BASE_PATH}/listen`))}</Redirect>`;
+}
+function sayTwiml(message) {
+    return `<Say>${escapeXml(message)}</Say>`;
+}
+function playTwiml(url) {
+    return `<Play>${escapeXml(url)}</Play>`;
+}
+function safeSegment(input) {
+    const cleaned = input.trim().replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+    return cleaned || "unknown";
+}
+function decodeSafeSegment(input) {
+    try {
+        const decoded = decodeURIComponent(input);
+        if (!/^[A-Za-z0-9._-]+$/.test(decoded))
+            return null;
+        if (decoded === "." || decoded === "..")
+            return null;
+        return decoded;
+    }
+    catch {
+        return null;
+    }
+}
+function contentTypeForAudio(fileName) {
+    const ext = path.extname(fileName).toLowerCase();
+    if (ext === ".mp3")
+        return "audio/mpeg";
+    if (ext === ".wav")
+        return "audio/wav";
+    if (ext === ".pcm")
+        return "audio/pcm";
+    return "application/octet-stream";
+}
+function friendIdFromCaller(from, callSid) {
+    const phoneish = from.replace(/[^0-9A-Za-z]+/g, "");
+    return phoneish ? `twilio-${phoneish}` : `twilio-${safeSegment(callSid)}`;
+}
+function parseRecordingParams(params) {
+    const callSid = params.CallSid?.trim();
+    const recordingSid = params.RecordingSid?.trim();
+    const recordingUrl = params.RecordingUrl?.trim();
+    if (!callSid || !recordingSid || !recordingUrl)
+        return null;
+    return {
+        callSid,
+        recordingSid,
+        recordingUrl,
+        from: params.From?.trim() ?? "",
+    };
+}
+function recordAgainResponse(publicBaseUrl, message) {
+    return xmlResponse(`${sayTwiml(message)}${recordTwiml({
+        publicBaseUrl,
+        timeoutSeconds: exports.DEFAULT_TWILIO_RECORD_TIMEOUT_SECONDS,
+        maxLengthSeconds: exports.DEFAULT_TWILIO_RECORD_MAX_LENGTH_SECONDS,
+    })}`);
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function computeTwilioSignature(input) {
+    const payload = input.url + Object.keys(input.params)
+        .sort()
+        .map((key) => `${key}${input.params[key]}`)
+        .join("");
+    return crypto.createHmac("sha1", input.authToken).update(payload).digest("base64");
+}
+function validateTwilioSignature(input) {
+    if (!input.authToken.trim())
+        return true;
+    if (!input.signature.trim())
+        return false;
+    const expected = Buffer.from(computeTwilioSignature(input));
+    const actual = Buffer.from(input.signature);
+    return actual.length === expected.length && crypto.timingSafeEqual(actual, expected);
+}
+function twilioRecordingMediaUrl(recordingUrl) {
+    const url = new URL(recordingUrl);
+    if (!/\.[A-Za-z0-9]+$/.test(url.pathname)) {
+        url.pathname = `${url.pathname}.wav`;
+    }
+    return url.toString();
+}
+async function defaultTwilioRecordingDownloader(request) {
+    const headers = {};
+    if (request.accountSid && request.authToken) {
+        headers.Authorization = `Basic ${Buffer.from(`${request.accountSid}:${request.authToken}`).toString("base64")}`;
+    }
+    const response = await fetch(request.recordingUrl, { headers });
+    if (!response.ok) {
+        throw new Error(`Twilio recording download failed: ${response.status} ${response.statusText}`.trim());
+    }
+    return Buffer.from(await response.arrayBuffer());
+}
+function verifyRequest(options, request, params) {
+    const authToken = options.twilioAuthToken?.trim();
+    if (!authToken)
+        return true;
+    return validateTwilioSignature({
+        authToken,
+        url: requestPublicUrl(options.publicBaseUrl, request.path),
+        params,
+        signature: headerValue(request.headers, "x-twilio-signature"),
+    });
+}
+async function handleIncoming(options) {
+    const greeting = options.greetingText ?? "Connected to Ouro voice. Speak after the prompt.";
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.voice_twilio_incoming",
+        message: "Twilio voice call connected",
+        meta: { agentName: options.agentName },
+    });
+    return xmlResponse(`${sayTwiml(greeting)}${recordTwiml({
+        publicBaseUrl: options.publicBaseUrl,
+        timeoutSeconds: options.recordTimeoutSeconds ?? exports.DEFAULT_TWILIO_RECORD_TIMEOUT_SECONDS,
+        maxLengthSeconds: options.recordMaxLengthSeconds ?? exports.DEFAULT_TWILIO_RECORD_MAX_LENGTH_SECONDS,
+    })}`);
+}
+async function handleListen(options) {
+    return xmlResponse(recordTwiml({
+        publicBaseUrl: options.publicBaseUrl,
+        timeoutSeconds: options.recordTimeoutSeconds ?? exports.DEFAULT_TWILIO_RECORD_TIMEOUT_SECONDS,
+        maxLengthSeconds: options.recordMaxLengthSeconds ?? exports.DEFAULT_TWILIO_RECORD_MAX_LENGTH_SECONDS,
+    }));
+}
+async function handleRecording(options, params) {
+    const recording = parseRecordingParams(params);
+    if (!recording) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.voice_twilio_recording_rejected",
+            message: "Twilio recording callback was missing required fields",
+            meta: { agentName: options.agentName },
+        });
+        return recordAgainResponse(options.publicBaseUrl, "I did not receive audio. Please try again.");
+    }
+    const safeCallSid = safeSegment(recording.callSid);
+    const safeRecordingSid = safeSegment(recording.recordingSid);
+    const callDir = path.join(options.outputDir, safeCallSid);
+    const inputPath = path.join(callDir, `${safeRecordingSid}.wav`);
+    const utteranceId = `twilio-${safeCallSid}-${safeRecordingSid}`;
+    const downloadRecording = options.downloadRecording ?? defaultTwilioRecordingDownloader;
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.voice_twilio_turn_start",
+        message: "starting Twilio voice turn",
+        meta: { agentName: options.agentName, callSid: safeCallSid, recordingSid: safeRecordingSid },
+    });
+    try {
+        await fs.mkdir(callDir, { recursive: true });
+        const mediaUrl = twilioRecordingMediaUrl(recording.recordingUrl);
+        const audio = await downloadRecording({
+            recordingUrl: mediaUrl,
+            accountSid: options.twilioAccountSid?.trim() || undefined,
+            authToken: options.twilioAuthToken?.trim() || undefined,
+        });
+        await fs.writeFile(inputPath, audio);
+        const transcript = await options.transcriber.transcribe({
+            utteranceId,
+            audioPath: inputPath,
+        });
+        const turn = await (0, turn_1.runVoiceLoopbackTurn)({
+            agentName: options.agentName,
+            friendId: options.defaultFriendId?.trim() || friendIdFromCaller(recording.from, recording.callSid),
+            sessionKey: `twilio-${safeCallSid}`,
+            transcript,
+            tts: options.tts,
+            runSenseTurn: options.runSenseTurn,
+        });
+        if (turn.tts.status !== "delivered") {
+            return xmlResponse(`${sayTwiml("voice output failed after the text response was captured.")}${redirectTwiml(options.publicBaseUrl)}`);
+        }
+        const playback = await (0, playback_1.writeVoicePlaybackArtifact)({
+            utteranceId,
+            delivery: turn.tts,
+            outputDir: callDir,
+        });
+        const audioUrl = routeUrl(options.publicBaseUrl, `${exports.TWILIO_PHONE_WEBHOOK_BASE_PATH}/audio/${encodeURIComponent(safeCallSid)}/${encodeURIComponent(path.basename(playback.audioPath))}`);
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.voice_twilio_turn_end",
+            message: "finished Twilio voice turn",
+            meta: { agentName: options.agentName, callSid: safeCallSid, recordingSid: safeRecordingSid, audioPath: playback.audioPath },
+        });
+        return xmlResponse(`${playTwiml(audioUrl)}${redirectTwiml(options.publicBaseUrl)}`);
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.voice_twilio_turn_error",
+            message: "Twilio voice turn failed",
+            meta: {
+                agentName: options.agentName,
+                callSid: safeCallSid,
+                recordingSid: safeRecordingSid,
+                error: errorMessage(error),
+            },
+        });
+        return xmlResponse(`${sayTwiml("I could not process that audio. Please try again.")}${redirectTwiml(options.publicBaseUrl)}`);
+    }
+}
+async function handleAudio(options, requestPath) {
+    const prefix = `${exports.TWILIO_PHONE_WEBHOOK_BASE_PATH}/audio/`;
+    const pathOnly = requestPath.split("?")[0];
+    const rest = pathOnly.slice(prefix.length);
+    const parts = rest.split("/");
+    if (parts.length !== 2)
+        return textResponse(404, "not found");
+    const [callSidPart, fileNamePart] = parts;
+    const callSid = decodeSafeSegment(callSidPart);
+    const fileName = decodeSafeSegment(fileNamePart);
+    if (!callSid || !fileName)
+        return textResponse(404, "not found");
+    const baseDir = path.resolve(options.outputDir, callSid);
+    const audioPath = path.resolve(baseDir, fileName);
+    try {
+        const audio = await fs.readFile(audioPath);
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.voice_twilio_audio_served",
+            message: "served Twilio voice audio artifact",
+            meta: { agentName: options.agentName, callSid, fileName },
+        });
+        return binaryResponse(audio, contentTypeForAudio(fileName));
+    }
+    catch {
+        return textResponse(404, "not found");
+    }
+}
+function createTwilioPhoneBridge(options) {
+    new URL(options.publicBaseUrl);
+    return {
+        async handle(request) {
+            const method = request.method.toUpperCase();
+            const requestPath = request.path.startsWith("/") ? request.path : `/${request.path}`;
+            const routePath = requestPath.split("?")[0];
+            if (method === "GET" && requestPath.startsWith(`${exports.TWILIO_PHONE_WEBHOOK_BASE_PATH}/audio/`)) {
+                return handleAudio(options, requestPath);
+            }
+            if (method === "GET" && routePath === `${exports.TWILIO_PHONE_WEBHOOK_BASE_PATH}/health`) {
+                return textResponse(200, "ok");
+            }
+            if (method !== "POST")
+                return textResponse(405, "method not allowed");
+            const params = formParams(bodyText(request.body));
+            if (!verifyRequest(options, { ...request, path: requestPath }, params)) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "senses",
+                    event: "senses.voice_twilio_signature_rejected",
+                    message: "rejected Twilio webhook with invalid signature",
+                    meta: { agentName: options.agentName, path: requestPath },
+                });
+                return textResponse(403, "invalid Twilio signature");
+            }
+            if (routePath === `${exports.TWILIO_PHONE_WEBHOOK_BASE_PATH}/incoming`)
+                return handleIncoming(options);
+            if (routePath === `${exports.TWILIO_PHONE_WEBHOOK_BASE_PATH}/listen`)
+                return handleListen(options);
+            if (routePath === `${exports.TWILIO_PHONE_WEBHOOK_BASE_PATH}/recording`)
+                return handleRecording(options, params);
+            return textResponse(404, "not found");
+        },
+    };
+}
+function readRequestBody(req, limitBytes = 1_000_000) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let byteLength = 0;
+        req.on("data", (chunk) => {
+            byteLength += chunk.byteLength;
+            if (byteLength > limitBytes) {
+                reject(new Error("request body too large"));
+                req.destroy();
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on("end", () => resolve(Buffer.concat(chunks)));
+        req.on("error", reject);
+    });
+}
+async function startTwilioPhoneBridgeServer(options) {
+    const port = options.port ?? exports.DEFAULT_TWILIO_PHONE_PORT;
+    const host = options.host ?? "127.0.0.1";
+    const bridge = createTwilioPhoneBridge(options);
+    const server = http.createServer(async (req, res) => {
+        try {
+            const body = await readRequestBody(req);
+            const response = await bridge.handle({
+                method: req.method,
+                path: req.url,
+                headers: req.headers,
+                body,
+            });
+            res.writeHead(response.statusCode, response.headers);
+            res.end(response.body);
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "senses",
+                event: "senses.voice_twilio_server_error",
+                message: "Twilio voice bridge server failed a request",
+                meta: { agentName: options.agentName, error: errorMessage(error) },
+            });
+            res.writeHead(500, { "content-type": "text/plain; charset=utf-8" });
+            res.end("internal server error");
+        }
+    });
+    await new Promise((resolve, reject) => {
+        const onError = (error) => {
+            server.off("listening", onListening);
+            reject(error);
+        };
+        const onListening = () => {
+            server.off("error", onError);
+            resolve();
+        };
+        server.once("error", onError);
+        server.once("listening", onListening);
+        server.listen(port, host);
+    });
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.voice_twilio_server_start",
+        message: "Twilio voice bridge server started",
+        meta: { agentName: options.agentName, host, port, publicBaseUrl: options.publicBaseUrl },
+    });
+    const actualPort = server.address().port;
+    return {
+        bridge,
+        server,
+        localUrl: `http://${host}:${actualPort}`,
+    };
+}

package/dist/senses/voice/whisper.js

@@ -34,10 +34,12 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseWhisperCppTranscriptJson = parseWhisperCppTranscriptJson;
+exports.createNodeWhisperCppProcessRunner = createNodeWhisperCppProcessRunner;
 exports.createWhisperCppTranscriber = createWhisperCppTranscriber;
 const fs = __importStar(require("fs/promises"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
 const runtime_1 = require("../../nerves/runtime");
 const transcript_1 = require("./transcript");
 function parseWhisperCppTranscriptJson(raw) {
@@ -68,11 +70,37 @@ async function defaultMakeTempDir() {
 async function defaultRemoveDir(dir) {
     await fs.rm(dir, { recursive: true, force: true });
 }
+function createNodeWhisperCppProcessRunner() {
+    return (command, args, options) => new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(command, args, { stdio: ["ignore", "pipe", "pipe"] });
+        const stdout = [];
+        const stderr = [];
+        const timer = setTimeout(() => {
+            child.kill("SIGTERM");
+            reject(new Error(`command timed out after ${options.timeoutMs}ms`));
+        }, options.timeoutMs);
+        child.stdout.on("data", (chunk) => stdout.push(chunk));
+        child.stderr.on("data", (chunk) => stderr.push(chunk));
+        child.on("error", (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+        child.on("close", (exitCode) => {
+            clearTimeout(timer);
+            resolve({
+                stdout: Buffer.concat(stdout).toString("utf8"),
+                stderr: Buffer.concat(stderr).toString("utf8"),
+                exitCode: exitCode ?? 0,
+            });
+        });
+    });
+}
 function createWhisperCppTranscriber(options) {
     const timeoutMs = options.timeoutMs ?? 120_000;
     const readFile = options.readFile ?? fs.readFile;
     const makeTempDir = options.makeTempDir ?? defaultMakeTempDir;
     const removeDir = options.removeDir ?? defaultRemoveDir;
+    const processRunner = options.processRunner ?? createNodeWhisperCppProcessRunner();
     return {
         async transcribe(request) {
             const workDir = await makeTempDir();
@@ -94,7 +122,7 @@ function createWhisperCppTranscriber(options) {
                 meta: { utteranceId: request.utteranceId, audioPath: request.audioPath },
             });
             try {
-                const result = await options.processRunner(options.whisperCliPath, args, { timeoutMs });
+                const result = await processRunner(options.whisperCliPath, args, { timeoutMs });
                 if (typeof result.exitCode === "number" && result.exitCode !== 0) {
                     throw new Error(`exit ${result.exitCode}${result.stderr ? `: ${result.stderr}` : ""}`);
                 }