@ouro.bot/cli 0.1.0-alpha.888 → 0.1.0-alpha.889

package/dist/senses/voice/local-audio-control.js

@@ -0,0 +1,344 @@
+"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.LocalAudioControlServer = void 0;
+exports.localAudioPaths = localAudioPaths;
+exports.sendLocalAudioControl = sendLocalAudioControl;
+exports.inspectActiveJoin = inspectActiveJoin;
+exports.lockOwnerAlive = lockOwnerAlive;
+exports.stopLockHolder = stopLockHolder;
+exports.acquireJoinLock = acquireJoinLock;
+exports.writeJoinStatus = writeJoinStatus;
+exports.readJoinStatus = readJoinStatus;
+exports.parseNotifySession = parseNotifySession;
+const crypto = __importStar(require("node:crypto"));
+const fs = __importStar(require("fs"));
+const net = __importStar(require("net"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+const local_audio_devices_1 = require("./local-audio-devices");
+/** macOS unix socket paths are limited to about 104 bytes. */
+const MAX_SOCKET_PATH = 100;
+const MAX_REQUEST_BYTES = 1024;
+const DEFAULT_CLIENT_TIMEOUT_MS = 10_000;
+function localAudioPaths(agentRoot) {
+    const dir = path.join(agentRoot, "state", "voice", "local-audio");
+    let socketPath = path.join(dir, "control.sock");
+    if (socketPath.length > MAX_SOCKET_PATH) {
+        const digest = crypto.createHash("sha256").update(dir).digest("hex").slice(0, 12);
+        socketPath = path.join(os.tmpdir(), `ouro-la-${digest}.sock`);
+    }
+    return {
+        dir,
+        socketPath,
+        pidFile: path.join(dir, "join.pid"),
+        statusFile: path.join(dir, "status.json"),
+        soxPidFile: path.join(dir, "sox.pids"),
+        callsDir: path.join(dir, "calls"),
+        logFile: path.join(dir, "join.log"),
+        lockFile: path.join(dir, "join.lock"),
+    };
+}
+class LocalAudioControlServer {
+    paths;
+    handler;
+    server;
+    constructor(paths, handler) {
+        this.paths = paths;
+        this.handler = handler;
+    }
+    async start() {
+        fs.mkdirSync(this.paths.dir, { recursive: true, mode: 0o700 });
+        fs.chmodSync(this.paths.dir, 0o700);
+        fs.rmSync(this.paths.socketPath, { force: true });
+        this.server = net.createServer((socket) => this.serve(socket));
+        await new Promise((resolve, reject) => {
+            this.server.once("error", reject);
+            this.server.listen(this.paths.socketPath, resolve);
+        });
+        fs.chmodSync(this.paths.socketPath, 0o600);
+        fs.writeFileSync(this.paths.pidFile, JSON.stringify({ pid: process.pid, startedAt: new Date().toISOString() }), { mode: 0o600 });
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.voice_local_control_started",
+            message: "local audio control socket listening",
+            meta: { socketPath: this.paths.socketPath },
+        });
+    }
+    async close() {
+        const server = this.server;
+        this.server = undefined;
+        if (server)
+            await new Promise((resolve) => server.close(() => resolve()));
+        fs.rmSync(this.paths.socketPath, { force: true });
+        fs.rmSync(this.paths.pidFile, { force: true });
+    }
+    serve(socket) {
+        let buffer = "";
+        let answered = false;
+        const reply = (body) => {
+            socket.end(`${JSON.stringify(body)}\n`);
+        };
+        socket.on("error", () => undefined);
+        socket.on("data", (chunk) => {
+            // One request per connection: later bytes can never trigger a second leave or reply.
+            if (answered)
+                return;
+            buffer += chunk.toString();
+            if (buffer.length > MAX_REQUEST_BYTES) {
+                answered = true;
+                reply({ ok: false, error: "request too large" });
+                return;
+            }
+            const newline = buffer.indexOf("\n");
+            if (newline === -1)
+                return;
+            answered = true;
+            void this.handle(buffer.slice(0, newline), reply);
+        });
+    }
+    async handle(line, reply) {
+        let command;
+        try {
+            command = JSON.parse(line).cmd;
+        }
+        catch {
+            reply({ ok: false, error: "invalid request" });
+            return;
+        }
+        try {
+            if (command === "status") {
+                reply({ ok: true, status: this.handler.status() });
+            }
+            else if (command === "leave") {
+                await this.handler.leave();
+                reply({ ok: true, status: this.handler.status() });
+            }
+            else {
+                reply({ ok: false, error: "unknown command" });
+            }
+        }
+        catch (error) {
+            reply({ ok: false, error: error instanceof Error ? error.message : String(error) });
+        }
+    }
+}
+exports.LocalAudioControlServer = LocalAudioControlServer;
+function sendLocalAudioControl(paths, cmd, timeoutMs = DEFAULT_CLIENT_TIMEOUT_MS) {
+    return new Promise((resolve) => {
+        let buffer = "";
+        // A promise settles once, so a late second `done` (end after error) only repeats harmless cleanup.
+        const done = (reply) => {
+            clearTimeout(timer);
+            socket.destroy();
+            resolve(reply);
+        };
+        const socket = net.createConnection(paths.socketPath);
+        const timer = setTimeout(() => done({ ok: false, code: "timeout", error: "local audio session did not answer in time" }), timeoutMs);
+        socket.on("connect", () => socket.write(`${JSON.stringify({ cmd })}\n`));
+        socket.on("data", (chunk) => { buffer += chunk.toString(); });
+        socket.on("end", () => {
+            try {
+                done(JSON.parse(buffer.trim()));
+            }
+            catch {
+                done({ ok: false, code: "protocol", error: "local audio session sent an unreadable reply" });
+            }
+        });
+        socket.on("error", (error) => {
+            // Only a refused or missing socket proves nobody is listening; anything else may be a live, busy session.
+            const unreachable = error.code === "ECONNREFUSED" || error.code === "ENOENT" || error.code === "ENOTSOCK";
+            done(unreachable
+                ? { ok: false, code: "unreachable", error: "no local audio session is running" }
+                : { ok: false, code: "protocol", error: `could not reach the local audio session (${error.code})` });
+        });
+    });
+}
+/**
+ * The live status when a join is running; otherwise null. A join that holds the lock but has not
+ * opened its socket yet reports "starting". Leftover socket and pid files are deleted only when the
+ * socket is provably dead (connection refused, missing, or not a socket) and no live process holds the lock; a
+ * timeout never deletes anything, because a slow session is still a session.
+ */
+async function inspectActiveJoin(paths, timeoutMs = 2_000) {
+    const reply = await sendLocalAudioControl(paths, "status", timeoutMs);
+    if (reply.ok)
+        return reply.status;
+    const holder = readJoinLock(paths);
+    if (holder.live)
+        return { state: "starting", callSid: "starting" };
+    if (reply.code === "unreachable") {
+        fs.rmSync(paths.socketPath, { force: true });
+        fs.rmSync(paths.pidFile, { force: true });
+    }
+    return null;
+}
+/**
+ * True when `pid` is a live process of ours that is still the one that wrote the lock. A process we
+ * may not signal (EPERM) belongs to someone else, so it is never ours; a recorded start time must
+ * match, so a pid reused after a crash or reboot does not count.
+ */
+function lockOwnerAlive(pid, startTime, inspect = local_audio_devices_1.defaultInspectProcess) {
+    try {
+        process.kill(pid, 0);
+    }
+    catch {
+        return false;
+    }
+    return startTime === undefined || inspect(pid)?.startTime === startTime;
+}
+/** A lock file with no readable owner is treated as held for this long (its owner may be mid-write). */
+const UNREADABLE_LOCK_GRACE_MS = 5_000;
+/** A missing or unreadable lock reads as an old, ownerless record: stale, never held. */
+function readLockFile(file) {
+    let text = "";
+    let mtimeMs = 0;
+    try {
+        text = fs.readFileSync(file, "utf8");
+        mtimeMs = fs.statSync(file).mtimeMs;
+    }
+    catch { /* leave the record empty and old */ }
+    try {
+        const { pid, startTime } = JSON.parse(text);
+        return { text, pid: typeof pid === "number" ? pid : undefined, ...(typeof startTime === "string" ? { startTime } : {}), mtimeMs };
+    }
+    catch {
+        return { text, pid: undefined, mtimeMs };
+    }
+}
+/** Held means a live owner, or an ownerless file young enough that its owner may be mid-write. */
+function lockIsHeld(lock, isAlive) {
+    return lock.pid === undefined ? Date.now() - lock.mtimeMs < UNREADABLE_LOCK_GRACE_MS : isAlive(lock.pid, lock.startTime);
+}
+function readJoinLock(paths, isAlive = lockOwnerAlive) {
+    const lock = readLockFile(paths.lockFile);
+    return { live: lockIsHeld(lock, isAlive), ...(lock.pid !== undefined ? { pid: lock.pid } : {}) };
+}
+/** Tells the process holding the join lock to stop (SIGTERM). Returns its pid, or null when nobody live holds it. */
+function stopLockHolder(paths, kill = process.kill.bind(process), isAlive = lockOwnerAlive) {
+    const holder = readJoinLock(paths, isAlive);
+    if (!holder.live || holder.pid === undefined || holder.pid === process.pid)
+        return null;
+    try {
+        kill(holder.pid, "SIGTERM");
+    }
+    catch {
+        return null;
+    }
+    return holder.pid;
+}
+/**
+ * The single-join lock: an exclusive (O_EXCL) file holding the owner's pid. Another live process
+ * holding it means a join is running or starting, so the caller must not touch its sox, socket or
+ * files. A lock whose owner is dead is reclaimed; the reclaim renames the file away first and puts
+ * it back if it turns out to belong to someone else, so two reclaimers cannot both win.
+ */
+function acquireJoinLock(paths, pid = process.pid, isAlive = lockOwnerAlive, startTimeOf = (owner) => (0, local_audio_devices_1.defaultInspectProcess)(owner)?.startTime) {
+    fs.mkdirSync(paths.dir, { recursive: true, mode: 0o700 });
+    fs.chmodSync(paths.dir, 0o700);
+    for (;;) {
+        try {
+            const fd = fs.openSync(paths.lockFile, "wx", 0o600);
+            try {
+                const startTime = startTimeOf(pid);
+                fs.writeSync(fd, JSON.stringify({ pid, ...(startTime ? { startTime } : {}), startedAt: new Date().toISOString() }));
+            }
+            finally {
+                fs.closeSync(fd);
+            }
+            return {
+                ok: true,
+                release: () => {
+                    if (readLockFile(paths.lockFile)?.pid === pid)
+                        fs.rmSync(paths.lockFile, { force: true });
+                },
+            };
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+        }
+        const seen = readLockFile(paths.lockFile);
+        if (lockIsHeld(seen, isAlive))
+            return { ok: false, holderPid: seen.pid };
+        const claimed = `${paths.lockFile}.claim.${pid}.${crypto.randomBytes(4).toString("hex")}`;
+        try {
+            fs.renameSync(paths.lockFile, claimed);
+        }
+        catch {
+            continue;
+        }
+        const taken = readLockFile(claimed);
+        fs.rmSync(claimed, { force: true });
+        if (taken.text !== seen.text) {
+            // We moved aside a lock another process had just created: give it back and report it held.
+            try {
+                fs.writeFileSync(paths.lockFile, taken.text, { flag: "wx", mode: 0o600 });
+            }
+            catch { /* its owner already wrote a new one */ }
+            return { ok: false, holderPid: taken.pid };
+        }
+    }
+}
+function writeJoinStatus(paths, status) {
+    fs.mkdirSync(paths.dir, { recursive: true, mode: 0o700 });
+    fs.writeFileSync(paths.statusFile, JSON.stringify({ ...status, updatedAt: new Date().toISOString() }), { mode: 0o600 });
+}
+function readJoinStatus(paths) {
+    try {
+        return JSON.parse(fs.readFileSync(paths.statusFile, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+const UNSAFE_SEGMENT = /[/\\\0]|^\.{1,2}$/;
+/** `friend:channel:key` (the key may contain colons). Refuses anything that could leave the pending directory. */
+function parseNotifySession(value) {
+    const first = value.indexOf(":");
+    const second = value.indexOf(":", first + 1);
+    if (first <= 0 || second <= first + 1)
+        return null;
+    const friendId = value.slice(0, first);
+    const channel = value.slice(first + 1, second);
+    const key = value.slice(second + 1);
+    if (!key)
+        return null;
+    for (const segment of [friendId, channel, key])
+        if (UNSAFE_SEGMENT.test(segment))
+            return null;
+    return { friendId, channel, key };
+}