@inetafrica/open-claudia 3.5.47 → 3.5.59

package/core/switchboard/call-host.js

@@ -0,0 +1,298 @@
+// The live call room, held by the switchboard so a brain restart doesn't drop
+// it. Each Kazee channel gets the same KazeeCallManager the bot always ran,
+// on the switchboard's own chat-central socket. What the manager used to hand
+// straight to the bot's router (a full-agent job) goes to the brain over the
+// link instead. While the brain is away, new jobs wait, the call stays up and
+// the caller hears why; when it is back, the waiting jobs go out.
+
+const { KazeeAdapter } = require("../../channels/kazee/adapter");
+const { KazeeCallManager, greetingContext } = require("../../channels/kazee/call/manager");
+
+// Plain values of the per-job call adapter the brain needs as they are.
+const JOB_FIELDS = ["callHistory", "quickVoice", "quickRelay", "liveCall", "suppressStreamPreview", "suppressChatVisibility", "liveCallThreadNote"];
+// What the brain may call back on a job.
+const JOB_FUNCTIONS = new Set(["speakSentence", "send", "earlyCallAnswer", "cancelCallSpeech", "onCallStage", "onCallActivity"]);
+
+const LINES = {
+  restarting: "I'm restarting. Back in a few seconds.",
+  crashed: "Sorry, something went wrong on my side. Give me a few seconds.",
+  back: "I'm back.",
+};
+
+const DEFAULT_TIMING = {
+  // How often a job's live view (call so far, camera, still on the board)
+  // is re-checked and sent to the brain when it changed.
+  mirrorMs: 250,
+  // A finished job is kept this long: a carried-on answer can come late.
+  jobKeepMs: 30 * 60 * 1000,
+  greetingAskMs: 1500,
+  // A thread call reads the thread first (its title from the server).
+  threadGreetingAskMs: 3000,
+};
+
+function defaultLog(message) {
+  console.log(`${new Date().toISOString()} Switchboard: ${message}`);
+}
+
+function abortReason(signal) {
+  const reason = signal?.reason;
+  if (typeof reason === "string") return reason;
+  return String(reason?.message || reason?.name || "aborted");
+}
+
+// What the brain's prompt builder reads from a job while its run starts.
+function mirrorOf(callAdapter, now = Date.now()) {
+  let history = [];
+  let camera = null;
+  let active = false;
+  try { history = callAdapter.liveCallHistory?.() || []; } catch (_) {}
+  try {
+    const still = callAdapter.liveCallCamera?.();
+    if (still?.path) camera = { path: still.path, at: now - (Number(still.ageMs) || 0), receiving: still.receiving !== false };
+  } catch (_) {}
+  try { active = !!callAdapter.isCallTurnActive?.(); } catch (_) {}
+  return { history, camera, active };
+}
+
+class CallHost {
+  constructor({ specs = [], AdapterImpl = KazeeAdapter, ManagerImpl = KazeeCallManager, managerOptions = {},
+    timing = {}, log = defaultLog } = {}) {
+    this.specs = specs;
+    this.AdapterImpl = AdapterImpl;
+    this.ManagerImpl = ManagerImpl;
+    this.managerOptions = managerOptions;
+    this.timing = { ...DEFAULT_TIMING, ...timing };
+    this.log = log;
+    this.adapters = [];
+    this.jobs = new Map();
+    this.link = null;
+    this.brainReady = false;
+    this.stopping = false;
+    this._seq = 0;
+    this._carryOns = [];
+    this._away = new Set();
+    this._told = new WeakSet();
+    this._idleListeners = [];
+    this._wasLive = false;
+  }
+
+  async start() {
+    for (const spec of this.specs) {
+      const adapter = new this.AdapterImpl({
+        id: spec.id, ...spec.opts,
+        callManager: (owner) => new this.ManagerImpl({
+          adapter: owner,
+          resolveGreetingContext: (target) => this._greetingContext(target),
+          ...this.managerOptions,
+          dispatchJob: (envelope, job) => this._dispatch(owner, envelope, job),
+          carryOn: (args) => this._carryOn(owner, args),
+        }),
+      });
+      this.adapters.push(adapter);
+      await adapter.startCalls();
+    }
+    this._pump = setInterval(() => this._tick(), this.timing.mirrorMs);
+    this._pump.unref?.();
+  }
+
+  onIdle(fn) { this._idleListeners.push(fn); }
+
+  liveCall() {
+    return this.adapters.some((adapter) => {
+      const manager = adapter._callManager;
+      return !!(manager?._pending || (manager?.session && !manager.session.closed));
+    });
+  }
+
+  _liveSessions() {
+    return this.adapters.map((adapter) => ({ manager: adapter._callManager, session: adapter._callManager?.session }))
+      .filter(({ session }) => session && !session.closed);
+  }
+
+  _say(manager, session, line) {
+    try { manager._rememberSpeech?.(session, "assistant", line); } catch (_) {}
+    Promise.resolve(session.speak(line)).catch(() => {});
+  }
+
+  // ── The brain ────────────────────────────────────────────────────
+
+  attachBrain(link) {
+    this.link = link;
+    this.brainReady = false;
+    link.handle("call.job.fn", (payload) => this._jobFn(payload));
+    link.handle("call.outgoing", (payload) => this._outgoing(payload));
+    link.on("brain.hello", (info) => this._brainHello(info));
+    link.on("brain.exiting", (payload) => this._brainLeaving(payload?.reason));
+    link.on("config.changed", (payload) => {
+      if (payload?.what === "voice") { try { require("../tts-voice")._resetCache(); } catch (_) {} }
+    });
+  }
+
+  // The brain said it is about to exit on purpose (restart, upgrade).
+  _brainLeaving(reason) {
+    this._leaving = String(reason || "restart");
+    if (this.stopping) return;
+    for (const { manager, session } of this._liveSessions()) {
+      if (this._told.has(session)) continue;
+      this._told.add(session);
+      this._away.add(session);
+      this._say(manager, session, LINES.restarting);
+    }
+  }
+
+  brainGone({ planned = false, reason = "" } = {}) {
+    this.link = null;
+    this.brainReady = false;
+    const leaving = this._leaving;
+    this._leaving = null;
+    if (this.stopping) return;
+    const live = this._liveSessions();
+    for (const { manager, session } of live) {
+      this._away.add(session);
+      if (this._told.has(session)) continue;
+      this._told.add(session);
+      this._say(manager, session, planned || leaving ? LINES.restarting : LINES.crashed);
+    }
+    // Jobs the brain had and never answered. After a planned exit they end
+    // (the exit was likely what they asked for); after a crash each is asked
+    // again once, when the brain is back.
+    for (const job of this.jobs.values()) {
+      if (!job.sent || job.answered || job.signal?.aborted) continue;
+      job.sent = false;
+      if (!planned && !leaving && !job.resent) { job.resent = true; continue; }
+      this._drop(job, "restart");
+    }
+    if (live.length) this.log(`brain gone (${planned || leaving ? "planned" : "unplanned"}: ${reason || leaving}); call kept`);
+  }
+
+  _brainHello(info = {}) {
+    this.brainReady = true;
+    const away = this._liveSessions().filter(({ session }) => this._away.has(session));
+    for (const { manager, session } of away) this._say(manager, session, LINES.back);
+    if (away.length) this.log(`brain back pid=${info.pid || "?"} v${info.version || "?"}; call went on`);
+    this._away.clear();
+    this._told = new WeakSet();
+    for (const job of this.jobs.values()) {
+      if (!job.sent && !job.answered && !job.signal?.aborted) this._send(job);
+    }
+    for (const carry of this._carryOns.splice(0)) this._sendCarryOn(carry);
+  }
+
+  // ── Jobs ─────────────────────────────────────────────────────────
+
+  _dispatch(adapter, envelope, { turn = null, session = null } = {}) {
+    const { adapter: callAdapter, ...rest } = envelope;
+    const signal = callAdapter?.callTurn?.signal || null;
+    const job = {
+      id: `${adapter.id}:${++this._seq}`, adapterId: adapter.id, manager: adapter._callManager,
+      callAdapter, envelope: rest, signal, turn, session,
+      sent: false, resent: false, answered: false, lastMirror: "", inactiveAt: 0,
+    };
+    this.jobs.set(job.id, job);
+    signal?.addEventListener("abort", () => {
+      if (job.sent) this.link?.notify("call.job.abort", { id: job.id, reason: abortReason(signal) });
+    }, { once: true });
+    if (!this._send(job)) this.log(`job ${job.id} waits for the brain`);
+    return job;
+  }
+
+  _send(job) {
+    if (!this.link || !this.brainReady) return false;
+    const fields = {};
+    for (const key of JOB_FIELDS) if (job.callAdapter[key] !== undefined) fields[key] = job.callAdapter[key];
+    const mirror = mirrorOf(job.callAdapter);
+    job.lastMirror = JSON.stringify(mirror);
+    job.sent = this.link.notify("call.job", {
+      id: job.id, adapterId: job.adapterId, envelope: job.envelope, fields, mirror, resent: job.resent,
+    });
+    return job.sent;
+  }
+
+  _drop(job, reason) {
+    if (job.turn && job.session && typeof job.manager?._dropJob === "function") {
+      try { job.manager._dropJob(job.session, job.turn, reason); return; } catch (_) {}
+    }
+    try { job.turn?.controller?.abort(reason); } catch (_) {}
+  }
+
+  async _jobFn({ id, name, args } = {}) {
+    const job = this.jobs.get(id);
+    if (!job) throw new Error("call job gone");
+    if (!JOB_FUNCTIONS.has(name) || typeof job.callAdapter[name] !== "function") throw new Error(`not a call job function: ${name}`);
+    if (name === "send") job.answered = true;
+    const value = await job.callAdapter[name](...(Array.isArray(args) ? args : []));
+    return value === undefined ? null : value;
+  }
+
+  _tick() {
+    const now = Date.now();
+    for (const job of this.jobs.values()) {
+      if (job.inactiveAt && now - job.inactiveAt > this.timing.jobKeepMs) {
+        this.jobs.delete(job.id);
+        this.link?.notify("call.job.forget", { id: job.id });
+        continue;
+      }
+      if (job.inactiveAt) continue;
+      const mirror = mirrorOf(job.callAdapter, now);
+      if (!mirror.active) job.inactiveAt = now;
+      if (!job.sent || !this.link) continue;
+      const text = JSON.stringify(mirror);
+      if (text === job.lastMirror) continue;
+      job.lastMirror = text;
+      this.link.notify("call.job.mirror", { id: job.id, mirror });
+    }
+    const live = this.liveCall();
+    if (this._wasLive && !live) for (const fn of this._idleListeners) { try { fn(); } catch (_) {} }
+    this._wasLive = live;
+  }
+
+  // ── Other things the call asks of the brain ──────────────────────
+
+  async _outgoing({ adapterId, args } = {}) {
+    const adapter = this.adapters.find((candidate) => candidate.id === adapterId) || this.adapters[0];
+    if (!adapter) throw new Error("No Kazee channel holds calls here");
+    return adapter._callManager.outgoing(args || {});
+  }
+
+  // The opening line reads the end of the chat. The brain knows which
+  // project the chat is on now; ask it, else read the files here.
+  async _greetingContext(target) {
+    if (this.link && this.brainReady) {
+      try {
+        return await this.link.request("call.greetingContext", {
+          adapterId: target.adapter?.id, chatId: String(target.chatId), userId: String(target.userId),
+          ...(target.threadId ? { threadId: String(target.threadId) } : {}),
+        }, { timeoutMs: target.threadId ? this.timing.threadGreetingAskMs : this.timing.greetingAskMs });
+      } catch (_) {}
+    }
+    return greetingContext(target);
+  }
+
+  _carryOn(adapter, { chatId, userId, prompt, threadId = null } = {}) {
+    const carry = { adapterId: adapter.id, chatId: String(chatId), userId: String(userId), prompt: String(prompt || ""), ...(threadId ? { threadId: String(threadId) } : {}) };
+    if (this.link && this.brainReady) this._sendCarryOn(carry);
+    else this._carryOns.push(carry);
+  }
+
+  _sendCarryOn(carry) {
+    const link = this.link;
+    if (!link || !this.brainReady) { this._carryOns.push(carry); return; }
+    link.request("call.carryOn", carry).catch((error) => {
+      this.log(`carry-on not handed over (${error.message}); kept for the brain`);
+      this._carryOns.push(carry);
+    });
+  }
+
+  // A full stop (pod going away, launchd stop): end calls properly so the
+  // caller's app hangs up now, not after chat-central's 20 s grace.
+  async stop(reason = "stop") {
+    this.stopping = true;
+    clearInterval(this._pump);
+    for (const adapter of this.adapters) {
+      try { await adapter._callManager.shutdown?.(`switchboard-${String(reason).toLowerCase().replace(/[^a-z0-9]+/g, "-")}`); } catch (_) {}
+      try { adapter.stopCalls?.(); } catch (_) {}
+    }
+  }
+}
+
+module.exports = { CallHost, LINES, JOB_FIELDS, JOB_FUNCTIONS, mirrorOf };

package/core/switchboard/handoff.js

@@ -0,0 +1,80 @@
+// OC_SWITCHBOARD=on splits the bot in two: a small switchboard process that
+// holds what must not drop (stage 1: the live call room) and the brain (the
+// rest of the bot), which runs as its child and can restart freely. The
+// launchd plist and the pod CMD stay as they are: whichever entry point they
+// run hands itself over here, and the child re-runs that same entry point.
+
+const fs = require("fs");
+const path = require("path");
+const { execFileSync } = require("child_process");
+
+const CHILD_ENV = "OC_SWITCHBOARD_CHILD";
+
+function flagOn(value) {
+  return ["on", "1", "true", "yes"].includes(String(value || "").trim().toLowerCase());
+}
+
+function switchboardWanted(config = null) {
+  if (process.env.OC_SWITCHBOARD !== undefined) return flagOn(process.env.OC_SWITCHBOARD);
+  return flagOn(config?.OC_SWITCHBOARD);
+}
+
+// The brain, started by a switchboard: it has the IPC channel to talk back on.
+function isSwitchboardChild() {
+  return process.env[CHILD_ENV] === "1" && typeof process.send === "function";
+}
+
+// Which install this is: a reinstall of the same version is a new stamp too.
+function packageStamp(botDir) {
+  try {
+    const file = path.join(botDir, "package.json");
+    const version = JSON.parse(fs.readFileSync(file, "utf8")).version || "0";
+    return `${version}-${Math.floor(fs.statSync(file).mtimeMs)}`;
+  } catch (_) {
+    return null;
+  }
+}
+
+// The switchboard runs from its own copy of the package. An upgrade swaps the
+// files on disk while a call may be live, and Node loads some modules only on
+// first use, so a switchboard running in place could mix old and new code
+// mid-call. On macOS the copy is an APFS clone: instant and costing no space.
+// Elsewhere it runs in place (bot pods are replaced whole to upgrade).
+function runtimeCopy({ botDir, configDir, platform = process.platform }) {
+  const stamp = packageStamp(botDir);
+  if (platform !== "darwin" || !stamp) return botDir;
+  const root = path.join(configDir, "switchboard-runtime");
+  const target = path.join(root, stamp);
+  try {
+    if (!fs.existsSync(path.join(target, "package.json"))) {
+      fs.mkdirSync(root, { recursive: true });
+      const tmp = `${target}.tmp-${process.pid}`;
+      fs.rmSync(tmp, { recursive: true, force: true });
+      execFileSync("/bin/cp", ["-cR", botDir, tmp], { stdio: "ignore", timeout: 120000 });
+      // Settings live in the config dir; never keep a second copy of a stray one.
+      fs.rmSync(path.join(tmp, ".env"), { force: true });
+      fs.renameSync(tmp, target);
+    }
+    for (const old of fs.readdirSync(root)) {
+      if (old !== stamp) fs.rmSync(path.join(root, old), { recursive: true, force: true });
+    }
+    return target;
+  } catch (error) {
+    console.error(`Switchboard: running in place (copy failed: ${error.message})`);
+    return botDir;
+  }
+}
+
+// True when this process became the switchboard; the caller must then do
+// nothing else (the brain runs in the child, from the live install).
+function maybeRunSwitchboard() {
+  if (isSwitchboardChild()) return false;
+  const { config, CONFIG_DIR, BOT_DIR } = require("../config");
+  if (!switchboardWanted(config)) return false;
+  const runtime = runtimeCopy({ botDir: BOT_DIR, configDir: CONFIG_DIR });
+  require(path.join(runtime, "core", "switchboard", "supervisor"))
+    .runSwitchboard({ argv: process.argv.slice(1), configDir: CONFIG_DIR, botDir: BOT_DIR, runtimeDir: runtime });
+  return true;
+}
+
+module.exports = { CHILD_ENV, flagOn, switchboardWanted, isSwitchboardChild, maybeRunSwitchboard, packageStamp, runtimeCopy };

package/core/switchboard/ipc.js

@@ -0,0 +1,130 @@
+// The switchboard and the brain talk over Node's child IPC channel (the brain
+// is the switchboard's child, so the channel needs no socket file or token).
+// A Link wraps one end: requests with replies, one-way notes, and a close
+// that fails whatever is still waiting, so neither side hangs on a peer that
+// went away mid-call.
+
+const { EventEmitter } = require("events");
+
+class Link extends EventEmitter {
+  constructor(channel, { label = "switchboard" } = {}) {
+    super();
+    this.channel = channel;
+    this.label = label;
+    this.closed = false;
+    this._seq = 0;
+    this._pending = new Map();
+    this._handlers = new Map();
+    this._onMessage = (message) => this._receive(message);
+    this._onClose = () => this.close();
+    channel.on("message", this._onMessage);
+    channel.on("disconnect", this._onClose);
+    // A ChildProcess end also sees the child exit; harmless twice.
+    channel.on("exit", this._onClose);
+  }
+
+  handle(type, fn) {
+    this._handlers.set(type, fn);
+    return this;
+  }
+
+  notify(type, payload) {
+    return this._send({ sb: 1, kind: "note", type, payload });
+  }
+
+  request(type, payload, { timeoutMs = 30000 } = {}) {
+    if (this.closed) return Promise.reject(new Error(`${this.label} link closed`));
+    const id = ++this._seq;
+    return new Promise((resolve, reject) => {
+      const timer = timeoutMs > 0 ? setTimeout(() => {
+        this._pending.delete(id);
+        reject(new Error(`${this.label} ${type} timed out`));
+      }, timeoutMs) : null;
+      timer?.unref?.();
+      this._pending.set(id, { resolve, reject, timer });
+      if (!this._send({ sb: 1, kind: "req", id, type, payload })) {
+        clearTimeout(timer);
+        this._pending.delete(id);
+        reject(new Error(`${this.label} link closed`));
+      }
+    });
+  }
+
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.channel.off?.("message", this._onMessage);
+    this.channel.off?.("disconnect", this._onClose);
+    this.channel.off?.("exit", this._onClose);
+    for (const { reject, timer } of this._pending.values()) {
+      clearTimeout(timer);
+      reject(new Error(`${this.label} link closed`));
+    }
+    this._pending.clear();
+    this.emit("close");
+  }
+
+  _send(message) {
+    if (this.closed || this.channel.connected === false) return false;
+    try {
+      // The callback swallows a channel that closed between the check and
+      // the write; close() above is what reports it.
+      this.channel.send(message, () => {});
+      return true;
+    } catch (_) {
+      return false;
+    }
+  }
+
+  async _receive(message) {
+    if (!message || message.sb !== 1) return;
+    if (message.kind === "res") {
+      const waiting = this._pending.get(message.id);
+      if (!waiting) return;
+      this._pending.delete(message.id);
+      clearTimeout(waiting.timer);
+      if (message.ok) waiting.resolve(message.value);
+      else waiting.reject(new Error(message.error || `${this.label} request failed`));
+      return;
+    }
+    if (message.kind === "note") {
+      this.emit(message.type, message.payload);
+      return;
+    }
+    if (message.kind !== "req") return;
+    const handler = this._handlers.get(message.type);
+    try {
+      if (!handler) throw new Error(`no handler for ${message.type}`);
+      const value = await handler(message.payload);
+      this._send({ sb: 1, kind: "res", id: message.id, ok: true, value: value === undefined ? null : value });
+    } catch (error) {
+      this._send({ sb: 1, kind: "res", id: message.id, ok: false, error: String(error?.message || error) });
+    }
+  }
+}
+
+// Two connected in-memory channel ends, for tests: messages are copied
+// through JSON and delivered on a later tick, as the real channel does.
+function channelPair() {
+  const a = new EventEmitter();
+  const b = new EventEmitter();
+  for (const [self, peer] of [[a, b], [b, a]]) {
+    self.connected = true;
+    self.send = (message, callback) => {
+      if (!self.connected) throw new Error("channel closed");
+      const copy = JSON.parse(JSON.stringify(message));
+      setImmediate(() => { if (peer.connected) peer.emit("message", copy); });
+      if (callback) setImmediate(callback);
+      return true;
+    };
+    self.disconnect = () => {
+      if (!self.connected) return;
+      self.connected = false;
+      peer.connected = false;
+      setImmediate(() => { self.emit("disconnect"); peer.emit("disconnect"); });
+    };
+  }
+  return [a, b];
+}
+
+module.exports = { Link, channelPair };