@ouro.bot/cli 0.1.0-alpha.59 → 0.1.0-alpha.591

package/dist/senses/voice/meeting.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redactVoiceMeetingUrl = redactVoiceMeetingUrl;
+exports.parseVoiceMeetingUrl = parseVoiceMeetingUrl;
+const crypto_1 = require("crypto");
+const runtime_1 = require("../../nerves/runtime");
+function isRiversideHost(host) {
+    return host === "riverside.fm" || host === "riverside.com";
+}
+function stableMeetingHash(provider, url) {
+    return (0, crypto_1.createHash)("sha256")
+        .update(`${provider}:${url.protocol}//${url.host}${url.pathname}`)
+        .digest("hex")
+        .slice(0, 12);
+}
+function redactPath(pathname) {
+    const parts = pathname.split("/").filter(Boolean);
+    if (parts.length === 0)
+        return "/";
+    if (parts.length === 1)
+        return "/:redacted";
+    return `/${parts[0]}/:redacted`;
+}
+function redactVoiceMeetingUrl(input) {
+    try {
+        const url = new URL(input);
+        return `${url.protocol}//${url.host}${redactPath(url.pathname)}`;
+    }
+    catch {
+        return ":invalid";
+    }
+}
+function parseVoiceMeetingUrl(input) {
+    const trimmed = input.trim();
+    if (!trimmed) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.voice_meeting_rejected",
+            message: "voice meeting URL is empty",
+            meta: { reason: "empty" },
+        });
+        throw new Error("voice meeting URL is empty");
+    }
+    let url;
+    try {
+        url = new URL(trimmed);
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.voice_meeting_rejected",
+            message: "voice meeting URL is invalid",
+            meta: { reason: "invalid_url" },
+        });
+        throw new Error("voice meeting URL is invalid");
+    }
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.voice_meeting_rejected",
+            message: "voice meeting URL must be http or https",
+            meta: { protocol: url.protocol },
+        });
+        throw new Error("voice meeting URL must be http or https");
+    }
+    const host = url.hostname.toLowerCase();
+    const provider = isRiversideHost(host) ? "riverside" : "generic";
+    if (provider === "riverside" && !url.pathname.startsWith("/studio/")) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.voice_meeting_rejected",
+            message: "Riverside voice meeting URLs must use /studio/",
+            meta: { host, redactedUrl: redactVoiceMeetingUrl(trimmed) },
+        });
+        throw new Error("Riverside voice meeting URLs must use /studio/");
+    }
+    if (provider === "generic" && url.protocol !== "https:") {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.voice_meeting_rejected",
+            message: "generic voice meeting URLs must use https",
+            meta: { host, redactedUrl: redactVoiceMeetingUrl(trimmed) },
+        });
+        throw new Error("generic voice meeting URLs must use https");
+    }
+    const hash = stableMeetingHash(provider, url);
+    const meeting = {
+        originalUrl: trimmed,
+        provider,
+        host,
+        pathname: url.pathname,
+        redactedUrl: redactVoiceMeetingUrl(trimmed),
+        sessionKey: `voice-${provider}-${hash}`,
+        requiresBrowserJoin: true,
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.voice_meeting_parsed",
+        message: "voice meeting URL parsed",
+        meta: {
+            provider: meeting.provider,
+            host: meeting.host,
+            sessionKey: meeting.sessionKey,
+            redactedUrl: meeting.redactedUrl,
+        },
+    });
+    return meeting;
+}

package/dist/senses/voice/outbound.js

@@ -0,0 +1,190 @@
+"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.readVoiceOutboundFriendRecordById = readVoiceOutboundFriendRecordById;
+exports.findVoiceOutboundFriendRecord = findVoiceOutboundFriendRecord;
+exports.voiceOutboundPhoneNumberForFriend = voiceOutboundPhoneNumberForFriend;
+exports.placeTrustedFriendVoiceOutboundCall = placeTrustedFriendVoiceOutboundCall;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const types_1 = require("../../mind/friends/types");
+const runtime_1 = require("../../nerves/runtime");
+const phone_1 = require("./phone");
+function readVoiceOutboundFriendRecordById(friendsDir, friendId) {
+    const recordPath = path.join(friendsDir, `${friendId}.json`);
+    if (!fs.existsSync(recordPath))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(recordPath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function externalIdMatches(externalId, wanted, wantedPhone) {
+    const normalized = externalId.trim().toLowerCase();
+    /* v8 ignore next -- exact external-id aliases are supported for non-phone providers; phone aliases are the production voice path @preserve */
+    if (normalized === wanted)
+        return true;
+    const phone = (0, phone_1.normalizeTwilioE164PhoneNumber)(externalId);
+    return Boolean(wantedPhone && phone === wantedPhone);
+}
+function findVoiceOutboundFriendRecord(friendsDir, friendId) {
+    const byId = readVoiceOutboundFriendRecordById(friendsDir, friendId);
+    if (byId)
+        return byId;
+    const normalized = friendId.trim().toLowerCase();
+    if (!normalized)
+        return null;
+    const normalizedPhone = (0, phone_1.normalizeTwilioE164PhoneNumber)(friendId);
+    try {
+        const records = fs.readdirSync(friendsDir)
+            .filter((file) => file.endsWith(".json"))
+            .map((file) => {
+            try {
+                return JSON.parse(fs.readFileSync(path.join(friendsDir, file), "utf-8"));
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((record) => Boolean(record));
+        return records.find((record) => record.id === friendId
+            || record.name?.toLowerCase() === normalized
+            || record.externalIds?.some((externalId) => externalIdMatches(externalId.externalId, normalized, normalizedPhone))) ?? records.find((record) => record.name?.toLowerCase().startsWith(normalized)) ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function voiceOutboundPhoneNumberForFriend(friend, explicitPhoneNumber) {
+    const explicit = (0, phone_1.normalizeTwilioE164PhoneNumber)(explicitPhoneNumber);
+    if (explicit)
+        return explicit;
+    for (const externalId of friend?.externalIds ?? []) {
+        /* v8 ignore next -- voice outbound only consumes iMessage phone handles today @preserve */
+        if (externalId.provider !== "imessage-handle")
+            continue;
+        const phoneNumber = (0, phone_1.normalizeTwilioE164PhoneNumber)(externalId.externalId);
+        /* v8 ignore next -- malformed iMessage handles are covered by missing-number blocking at the caller boundary @preserve */
+        if (phoneNumber)
+            return phoneNumber;
+    }
+    return undefined;
+}
+async function placeTrustedFriendVoiceOutboundCall(request) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.voice_outbound_call_start",
+        message: "checking trusted friend outbound voice call request",
+        meta: { agentName: request.agentName, friendId: request.friendId },
+    });
+    const friendsDir = path.join(request.agentRoot, "friends");
+    const friend = findVoiceOutboundFriendRecord(friendsDir, request.friendId);
+    if (!friend) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.voice_outbound_call_blocked",
+            message: "blocked outbound voice call request",
+            meta: { agentName: request.agentName, friendId: request.friendId, reason: "unknown_friend" },
+        });
+        return { status: "blocked", detail: "voice call requires a known friend record" };
+    }
+    if (!(0, types_1.isTrustedLevel)(friend.trustLevel)) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.voice_outbound_call_blocked",
+            message: "blocked outbound voice call request",
+            meta: { agentName: request.agentName, friendId: friend.id, reason: "untrusted_friend" },
+        });
+        return { status: "blocked", detail: "voice calls are limited to trusted friends" };
+    }
+    const phoneNumber = voiceOutboundPhoneNumberForFriend(friend, request.phoneNumber);
+    if (!phoneNumber) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.voice_outbound_call_blocked",
+            message: "blocked outbound voice call request",
+            meta: { agentName: request.agentName, friendId: friend.id, reason: "missing_phone_number" },
+        });
+        return { status: "blocked", detail: "no phone number is available for voice call" };
+    }
+    try {
+        const { placeConfiguredTwilioPhoneCall } = await Promise.resolve().then(() => __importStar(require("./twilio-phone-runtime")));
+        const call = await placeConfiguredTwilioPhoneCall({
+            agentName: request.agentName,
+            friendId: friend.id,
+            to: phoneNumber,
+            reason: request.reason,
+            ...(request.initialAudio ? { initialAudio: request.initialAudio } : {}),
+        });
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.voice_outbound_call_placed",
+            message: "placed outbound voice call request",
+            meta: {
+                agentName: request.agentName,
+                friendId: friend.id,
+                outboundId: call.outboundId.replace(/[^A-Za-z0-9._-]+/g, "-"),
+                callSid: call.callSid?.replace(/[^A-Za-z0-9._-]+/g, "-") ?? "unknown",
+                status: call.status ?? "unknown",
+            },
+        });
+        return {
+            status: "placed",
+            detail: `voice call initiated${call.status ? ` (${call.status})` : ""}`,
+            friendId: friend.id,
+            phoneNumber,
+            outboundId: call.outboundId,
+            ...(call.callSid ? { callSid: call.callSid } : {}),
+            ...(call.status ? { callStatus: call.status } : {}),
+        };
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.voice_outbound_call_failed",
+            message: "failed outbound voice call request",
+            /* v8 ignore next -- dynamic import/runtime failures arrive as Error objects in supported Node runtimes @preserve */
+            meta: { agentName: request.agentName, friendId: friend.id, error: error instanceof Error ? error.message : String(error) },
+        });
+        return {
+            status: "failed",
+            /* v8 ignore next -- dynamic import/runtime failures arrive as Error objects in supported Node runtimes @preserve */
+            detail: error instanceof Error ? error.message : String(error),
+        };
+    }
+}

package/dist/senses/voice/phone.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeTwilioE164PhoneNumber = normalizeTwilioE164PhoneNumber;
+const runtime_1 = require("../../nerves/runtime");
+function normalizeTwilioE164PhoneNumber(value) {
+    const raw = value?.trim();
+    if (!raw)
+        return undefined;
+    if (raw.toLowerCase().startsWith("group:")) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.voice_phone_number_rejected",
+            message: "voice phone number candidate rejected",
+            meta: { reason: "group_handle" },
+        });
+        return undefined;
+    }
+    const cleaned = raw.replace(/[^\d+]+/g, "");
+    if (/^\+[1-9]\d{6,14}$/.test(cleaned))
+        return cleaned;
+    const digits = cleaned.replace(/\D+/g, "");
+    if (/^1\d{10}$/.test(digits))
+        return `+${digits}`;
+    if (/^\d{10}$/.test(digits))
+        return `+1${digits}`;
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.voice_phone_number_rejected",
+        message: "voice phone number candidate rejected",
+        meta: { reason: "invalid_e164" },
+    });
+    return undefined;
+}

package/dist/senses/voice/playback.js

@@ -0,0 +1,139 @@
+"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.writeVoicePlaybackArtifact = writeVoicePlaybackArtifact;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+const audio_routing_1 = require("./audio-routing");
+function audioExtension(mimeType) {
+    if (mimeType === "audio/mpeg")
+        return "mp3";
+    if (mimeType === "audio/wav" || mimeType === "audio/x-wav")
+        return "wav";
+    if (mimeType.startsWith("audio/pcm"))
+        return "pcm";
+    return "audio";
+}
+function safeFileStem(input) {
+    const stem = input
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return stem || "utterance";
+}
+function commandFailureMessage(exitCode, result) {
+    const stderr = result.stderr?.trim();
+    if (stderr)
+        return `exit ${exitCode}: ${stderr}`;
+    const stdout = result.stdout?.trim();
+    if (stdout)
+        return `exit ${exitCode}: ${stdout}`;
+    return `exit ${exitCode}`;
+}
+async function writeVoicePlaybackArtifact(request) {
+    const mkdir = request.mkdir ?? fs.mkdir;
+    const writeFile = request.writeFile ?? fs.writeFile;
+    const commandRunner = request.commandRunner ?? (0, audio_routing_1.createNodeVoiceCommandRunner)();
+    const timeoutMs = request.timeoutMs ?? 30_000;
+    const playbackCommandPath = request.playbackCommandPath ?? "afplay";
+    const audioPath = path.join(request.outputDir, `${safeFileStem(request.utteranceId)}.${audioExtension(request.delivery.mimeType)}`);
+    await mkdir(request.outputDir, { recursive: true });
+    await writeFile(audioPath, request.delivery.audio);
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.voice_playback_artifact_written",
+        message: "voice playback artifact written",
+        meta: {
+            utteranceId: request.utteranceId,
+            audioPath,
+            byteLength: request.delivery.byteLength,
+            mimeType: request.delivery.mimeType,
+        },
+    });
+    if (request.playAudio !== true) {
+        return {
+            status: "written",
+            audioPath,
+            byteLength: request.delivery.byteLength,
+            mimeType: request.delivery.mimeType,
+            playbackAttempted: false,
+        };
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.voice_playback_start",
+        message: "starting voice playback",
+        meta: { utteranceId: request.utteranceId, audioPath, playbackCommandPath },
+    });
+    try {
+        const result = await commandRunner(playbackCommandPath, [audioPath], { timeoutMs });
+        if (typeof result.exitCode === "number" && result.exitCode !== 0) {
+            throw new Error(commandFailureMessage(result.exitCode, result));
+        }
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.voice_playback_end",
+            message: "finished voice playback",
+            meta: { utteranceId: request.utteranceId, audioPath },
+        });
+        return {
+            status: "played",
+            audioPath,
+            byteLength: request.delivery.byteLength,
+            mimeType: request.delivery.mimeType,
+            playbackAttempted: true,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "senses",
+            event: "senses.voice_playback_error",
+            message: "voice playback failed",
+            meta: { utteranceId: request.utteranceId, audioPath, error: message },
+        });
+        return {
+            status: "failed",
+            audioPath,
+            byteLength: request.delivery.byteLength,
+            mimeType: request.delivery.mimeType,
+            playbackAttempted: true,
+            error: message,
+        };
+    }
+}