@inetafrica/open-claudia 3.4.7 → 3.4.12

package/test-kazee-call-session.js

@@ -19,7 +19,7 @@ class FakeJanus {
 }
 
 class FakePC {
-  constructor() { this.onTrack = { subscribe: () => {} }; }
+  constructor(options) { this.options = options; this.onTrack = { subscribe: () => {} }; }
   addTrack() { return { codec: { payloadType: 111 } }; }
   async createOffer() { return {}; }
   async setLocalDescription() {}
@@ -79,6 +79,28 @@ async function testSpeakSerialization() {
   await session.close();
 }
 
+async function testMeasuredMediaReady() {
+  const { session } = makeSession();
+  let ready = 0, sent = 0;
+  session.onMediaReady = () => { ready++; };
+  await session._subscribe(901, "peer");
+  const codec = new OpusAudioCodec();
+  session._onFeedRtp(901, { payload: toneOpus(codec, 30) });
+  assert.strictEqual(ready, 0, "receive-only media is insufficient");
+  session._writeFrame(Buffer.alloc(WEBRTC_SAMPLES * 2));
+  assert.strictEqual(ready, 0, "missing publisher track cannot count as sent media");
+  session.publisher = { track: { writeRtp: () => { sent++; } }, sender: { codec: { payloadType: 111 } } };
+  session._writeFrame(Buffer.alloc(WEBRTC_SAMPLES * 2));
+  assert.strictEqual(ready, 1);
+  session._writeFrame(Buffer.alloc(WEBRTC_SAMPLES * 2));
+  session._onFeedRtp(901, { payload: toneOpus(codec, 30) });
+  assert.strictEqual(ready, 1, "media-ready is reported once per session");
+  await session.close();
+  session._writeFrame(Buffer.alloc(WEBRTC_SAMPLES * 2));
+  assert.strictEqual(sent, 2, "closed sessions cannot send or activate media");
+  codec.close();
+}
+
 async function testSpeakCancellation() {
   let frames = 0;
   const synthCalls = [];
@@ -421,9 +443,106 @@ async function testCloseResolvesSpeech() {
   assert.strictEqual(await session.speak("after"), false, "speak after close is a no-op");
 }
 
+async function testManagedRoomCredentials() {
+  class SignedJanus extends FakeJanus {
+    constructor(options) { super(); this.options = options; this.calls = []; }
+    async message(handle, body) {
+      this.calls.push(body);
+      if (body.request === "join" && body.ptype === "publisher") return { plugindata: { data: { videoroom: "joined", id: 41, private_id: 999, publishers: [] } } };
+      return {};
+    }
+  }
+  let refreshes = 0;
+  const session = new KazeeCallSession({ roomId: 7, chatId: "chat", callerId: "owner", botUserId: "bot", janusUrl: "ws://test",
+    janusToken: "root-token", roomToken: "publisher-token", roomTokenExpiresAt: Date.now() + 300000, managedRoom: true, asCaller: true, iceServers: [{ urls: "turn:relay:3478", username: "fixture", credential: "fixture" }], iceCredentialsExpiresAt: Date.now() + 3600000,
+    refreshRoomAccess: async () => { refreshes += 1; return { iceServers: [{ urls: "turn:relay:3478", username: "fresh", credential: "fresh" }], iceCredentialsExpiresAt: Date.now() + 3600000, janusToken: "fresh-root", janusTokenExpiresAt: Date.now() + 86400000, roomToken: "subscriber-token", roomTokenExpiresAt: Date.now() + 300000 }; },
+    JanusClientImpl: SignedJanus, PeerConnectionImpl: FakePC, SpeechStreamImpl: FakeSpeechStream });
+  session._maybePublish = async () => {};
+  await session.start();
+  assert.strictEqual(session.janus.options.token, "root-token");
+  assert.strictEqual(session.janus.calls[0].token, "publisher-token");
+  await session._consumePublisherFrame({ plugindata: { data: { publishers: [{ id: 41, display: 'canonical-bot@calling.invalid' }, { id: 42, display: 'open-claudia:legacy-bot' }] } } });
+  assert.strictEqual(session.subscribers.size, 0, 'own joined publisher ID is excluded independently of canonical display; legacy bot exclusion remains');
+
+  session.roomTokenExpiresAt = Date.now() - 1;
+  await Promise.all([session._subscribe(17, "owner"), session._subscribe(18, "other")]);
+  const subJoin = session.janus.calls.find(body => body.ptype === "subscriber");
+  assert.strictEqual(subJoin.token, "subscriber-token");
+  assert.strictEqual(subJoin.private_id, 999);
+  assert.strictEqual(refreshes, 1, "simultaneous subscriber joins share one token refresh");
+  session.janusTokenExpiresAt = Date.now() + 50000;
+  const handlesBefore = session.janus.handles;
+  await session._enforceLimits();
+  await wait(0);
+  assert.strictEqual(session.janus.token, "fresh-root");
+  assert.strictEqual(refreshes, 2, "root renewal does not wait for a new subscriber");
+  assert.strictEqual(session.janus.handles, handlesBefore, "renewal keeps existing session and handles");
+  session.janusTokenExpiresAt = Date.now() - 1;
+  await session._enforceLimits();
+  assert.strictEqual(session.closed, true, "expired transport credentials close media");
+  await session.close();
+  assert.ok(!session.janus.calls.some(body => ["create", "destroy"].includes(body.request)), "server allocated room ownership never transfers to the bot");
+}
+
+async function testAssignedRelayTransportLifetime() {
+  const { RTCPeerConnection } = require('werift');
+  const originalExpiry = Date.now() + 3600000;
+  const assigned = (username, expiresAt) => ({ iceServers: [{ urls: 'turn:127.0.0.1:3478', username, credential: username + '-password' }], iceCredentialsExpiresAt: expiresAt });
+  const session = new KazeeCallSession({ roomId: 7, chatId: 'chat', callerId: 'owner', botUserId: 'bot', managedRoom: true,
+    ...assigned('original-fixture', originalExpiry), roomToken: 'room', roomTokenExpiresAt: Date.now() + 300000,
+    refreshRoomAccess: async () => ({ ...assigned('renewed-fixture', originalExpiry + 3600000), roomToken: 'renewed-room', roomTokenExpiresAt: Date.now() + 300000, janusToken: 'renewed-root', janusTokenExpiresAt: Date.now() + 300000 }),
+    JanusClientImpl: FakeJanus, PeerConnectionImpl: RTCPeerConnection, SpeechStreamImpl: FakeSpeechStream });
+  try {
+    const old = session._newPeerConnection(); old.addTransceiver('audio');
+    assert.strictEqual(old.iceTransports[0].connection.options.turnUsername, 'original-fixture');
+    // Calling Werift's public setter cannot refresh an already-created ICE
+    // transport. Verify the installed implementation, without network gathering.
+    old.setConfiguration({ iceServers: assigned('setter-fixture', originalExpiry).iceServers });
+    assert.strictEqual(old.getConfiguration().iceServers[0].username, 'setter-fixture');
+    assert.strictEqual(old.iceTransports[0].connection.options.turnUsername, 'original-fixture');
+    await session._roomAuth(true);
+    assert.strictEqual(session._transportIceExpiry.get(old), originalExpiry, 'new access never extends an existing allocation deadline');
+    assert.strictEqual(old.iceTransports[0].connection.options.turnUsername, 'original-fixture');
+    const fresh = session._newPeerConnection(); fresh.addTransceiver('audio');
+    assert.strictEqual(fresh.iceTransports[0].connection.options.turnUsername, 'renewed-fixture');
+    assert.strictEqual(session._transportIceExpiry.get(fresh), originalExpiry + 3600000);
+  } finally { await session.close(); }
+  assert.strictEqual(session._transportExpiryTimer, null);
+  assert.strictEqual(session._transportIceExpiry.size, 0);
+
+  let ended;
+  const bounded = new KazeeCallSession({ roomId: 7, chatId: 'chat', callerId: 'owner', botUserId: 'bot', managedRoom: true,
+    ...assigned('short-fixture', Date.now() + 1500), roomToken: 'room', roomTokenExpiresAt: Date.now() + 300000,
+    refreshRoomAccess: async () => ({ ...assigned('fresh-fixture', Date.now() + 3600000), roomToken: 'fresh', roomTokenExpiresAt: Date.now() + 300000 }),
+    onEnded: reason => { ended = reason; }, JanusClientImpl: FakeJanus, PeerConnectionImpl: FakePC, SpeechStreamImpl: FakeSpeechStream });
+  try {
+    const old = bounded._newPeerConnection();
+    const deadline = bounded._transportIceExpiry.get(old);
+    await bounded._roomAuth(true);
+    assert.strictEqual(bounded._transportIceExpiry.get(old), deadline);
+    const until = Date.now() + 2000;
+    while (!bounded.closed && Date.now() < until) await wait(25);
+    assert.strictEqual(ended, 'relay-credentials-expired', 'existing transport closes on its original expiry despite successful refresh');
+  } finally { await bounded.close(); }
+
+  let publications = 0;
+  class PublishingPC extends FakePC { constructor(options) { super(options); publications += 1; } }
+  class PublishingJanus extends FakeJanus { async message() { return { jsep: { type: 'answer', sdp: 'fixture' } }; } }
+  const concurrent = new KazeeCallSession({ roomId: 7, chatId: 'chat', callerId: 'owner', botUserId: 'bot', managedRoom: true,
+    ...assigned('original-fixture', Date.now() + 3600000), roomToken: 'room', roomTokenExpiresAt: Date.now() + 300000,
+    JanusClientImpl: PublishingJanus, PeerConnectionImpl: PublishingPC });
+  try { await Promise.all([concurrent._publish(), concurrent._publish()]); assert.strictEqual(publications, 1, 'concurrent publisher events cannot race across async room authorization'); } finally { await concurrent.close(); }
+
+  const missing = new KazeeCallSession({ roomId: 7, chatId: 'chat', callerId: 'owner', botUserId: 'bot', managedRoom: true, JanusClientImpl: FakeJanus, PeerConnectionImpl: FakePC });
+  try { assert.throws(() => missing._newPeerConnection(), /relay credentials unavailable/); } finally { await missing.close(); }
+}
+
 (async () => {
+  await testAssignedRelayTransportLifetime();
+  await testManagedRoomCredentials();
   await testSpeakSerialization();
   await testSpeakCancellation();
+  await testMeasuredMediaReady();
   await testEchoGateAndBargeIn();
   await testPrebufferAndCommit();
   await testHoldForWords();

package/test-provider-enforcer.js

@@ -6,7 +6,8 @@ const assert = require("assert");
 const fs = require("fs");
 const os = require("os");
 const path = require("path");
-const { spawnSync } = require("child_process");
+const { spawn, spawnSync } = require("child_process");
+const { killProcessTree } = require("./core/process-tree");
 
 const RESULT_PREFIX = "__PROVIDER_ENFORCER_RESULT__";
 
@@ -73,7 +74,6 @@ function auditSink() {
 
 async function providerProbe(kind) {
   const root = isolate(kind);
-  const timeoutSignal = path.join(root, `${kind}-timeout-signal.json`);
   const controls = [
     { FAKE_AGENT_TEXT: '{"decision":"allow","reason":"inside mandate"}' },
     { FAKE_AGENT_TEXT: '{"decision":"block","reason":"outside mandate"}' },
@@ -82,16 +82,27 @@ async function providerProbe(kind) {
     // The guard-reliability fix retries ONCE on a transient timeout before
     // failing closed: BOTH attempts hang, so the verdict still escalates —
     // proving the retry is bounded and never fails open at the transport level.
-    { FAKE_AGENT_SCENARIO: "forced-termination", FAKE_AGENT_SIGNAL_CAPTURE: timeoutSignal },
     { FAKE_AGENT_SCENARIO: "forced-termination" },
+    { FAKE_AGENT_SCENARIO: "forced-termination", FAKE_AGENT_IGNORE_SIGTERM: "1" },
   ];
   const entry = makeProvider(kind, root, controls);
   const model = `${kind}-enforcer-exact`;
   const { createUtilityAgentService } = require("./core/utility-agent");
+  const children = [];
+  const terminations = [];
   const utility = createUtilityAgentService({
     registry: registry([entry]),
     env: { ENFORCER_PROVIDER: kind, [`ENFORCER_MODEL_${kind.toUpperCase()}`]: model },
     killGraceMs: 300,
+    spawnProcess(...args) {
+      const child = spawn(...args);
+      children.push(child);
+      return child;
+    },
+    killTree(pid, signal) {
+      terminations.push({ pid, signal });
+      return killProcessTree(pid, signal);
+    },
   });
   const enforcer = require("./core/enforcer");
   assert.strictEqual(typeof enforcer.createEnforcerService, "function", "enforcer exposes an injectable utility-provider service");
@@ -114,8 +125,8 @@ async function providerProbe(kind) {
     spawnUtilityAgent: utility.spawnUtilityAgent,
     audit,
     // Bounded (this deadline MUST fire — the child hangs by design), but with
-    // enough headroom for the hung child to boot on a loaded CI runner (write
-    // capture #5, arm its SIGTERM recorder) before the deadline kills it.
+    // enough headroom for the hung children to boot on a loaded CI runner
+    // before the deadline kills them; the retry deliberately ignores TERM.
     timeoutMs: 5000,
   });
   const timedOut = await timeoutService.vetReply(speaker, "timeout verdict fixture");
@@ -154,7 +165,19 @@ async function providerProbe(kind) {
     assert.ok(record.argv.includes(kind === "claude" ? "plan" : "read-only"));
     assert.ok(record.argv.includes(kind === "claude" ? "--json-schema" : "--output-schema"));
   }
-  assert.strictEqual(JSON.parse(fs.readFileSync(timeoutSignal, "utf8")).signal, "SIGTERM");
+  // Observe shutdown from the surviving parent. A child-written receipt can
+  // be truncated by SIGKILL during synchronous I/O (CI pipeline 12017), even
+  // though the guard correctly failed closed and waited for process close.
+  assert.strictEqual(children.length, 6);
+  for (const child of children.slice(4)) {
+    const signals = terminations.filter((entry) => entry.pid === child.pid).map((entry) => entry.signal);
+    assert.strictEqual(signals[0], "SIGTERM", "both timeout attempts first request graceful termination");
+    assert.ok(["SIGTERM", "SIGKILL"].includes(child.signalCode), "the timed-out child has exited by signal before the verdict settles");
+    assert.throws(() => process.kill(child.pid, 0), { code: "ESRCH" }, "the timed-out provider must not survive its verdict");
+  }
+  assert.ok(terminations.some((entry) => entry.pid === children[5].pid && entry.signal === "SIGKILL"), "the retry that ignores TERM is forcibly terminated after the grace period");
+  assert.strictEqual(children[5].signalCode, "SIGKILL");
+  assert.deepStrictEqual(utility.stats(), { activeGlobal: 0, activeByPurpose: {} }, "both timed-out attempts release their concurrency slots after close");
 
   return { kind, decisions: [allow.decision, block.decision, escalate.decision, malformed.decision, timedOut.decision] };
 }

package/test-provider-language.js

@@ -463,8 +463,8 @@ assert.match(pkg.description, /provider-agnostic coding-agent harness/i);
 // Codex turn. Live probe: unified-exec shell calls still reach PreToolUse as
 // tool_name "Bash" and the deny gate caught the probe, so the gate no longer
 // requires unified_exec off. Push approved by Sumeet before release.
-// 3.4.7: owner approved scheduler fix and push on 2026-09-05.
-assert.strictEqual(pkg.version, "3.4.7", "release version must remain unchanged without explicit approval");
+// 3.4.12: Sumeet approved the full calling rollout on 2026-09-05; preserve assigned media configuration across canary changes.
+assert.strictEqual(pkg.version, "3.4.12", "release version must remain unchanged without explicit approval");
 for (const keyword of ["claude", "codex", "coding-agent", "provider-agnostic"]) {
   assert.ok(pkg.keywords.includes(keyword), `package keyword missing: ${keyword}`);
 }