@inetafrica/open-claudia 3.4.13 → 3.4.14

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 3.4.14
+
+- Subscribe to managed call audio only when gateway-authenticated publisher metadata identifies a User. Exclude bots, the current bot's other feeds, and missing or malformed classifications before creating subscriber connections or speech streams.
+- Preserve metadata through the initial room response and live publisher events. Managed calls use that authenticated classification; legacy calls retain their existing display-prefix exclusion because client-supplied metadata is untrusted.
+- Exercise the actual session subscription and offer/answer path for allowed users and rejected bot, self and unknown feeds.
+
 ## 3.4.13
 
 - **Codex is now measured the way Claude is.** After each Codex turn the bot reads Codex's own per-request token log (`$CODEX_HOME/sessions/…/rollout-*-<thread>.jsonl`) and uses the last request's size as the live context, instead of the turn's input summed over every tool call. That sum (33M on one turn) tripped auto-compact after almost every substantial Codex turn — 8 needless compactions on 2026-09-05, each a summary run plus a cold restart — while Codex's real window occupancy never exceeded 245k of its 258k window. Codex sessions now compact at 80% of the window Codex reports.

package/channels/kazee/call/session.js

@@ -256,8 +256,8 @@ class KazeeCallSession {
     }
     for (const publisher of data.publishers || []) {
       const feedId = Number(publisher.id);
-      if (Number.isSafeInteger(feedId) && feedId > 0 && feedId !== this.publisherId && !this.subscribers.has(feedId) && !String(publisher.display || "").startsWith("open-claudia:")) {
-        await this._subscribe(feedId, publisher.display);
+      if (Number.isSafeInteger(feedId) && feedId > 0 && feedId !== this.publisherId && !this.subscribers.has(feedId)) {
+        await this._subscribe(feedId, publisher.display, publisher.metadata);
       }
     }
     if (data.videoroom === "joined") {
@@ -357,8 +357,21 @@ class KazeeCallSession {
     this.speak(this.greeting).catch((error) => console.error("Kazee call greeting:", error.message));
   }
 
-  async _subscribe(feedId, display) {
-    if (this.subscribers.has(feedId)) return;
+  async _subscribe(feedId, display, metadata) {
+    if (this.closed || feedId === this.publisherId || this.subscribers.has(feedId)) return;
+    if (this.managedRoom) {
+      // Only the enforced gateway owns this metadata. Display remains an email
+      // for presentation, and cannot tell us whether a publisher is another bot.
+      // Missing or malformed classification must not start STT on an unknown feed.
+      const principal = metadata?.kazee;
+      if (!principal || Array.isArray(principal) || principal.version !== 1 ||
+        typeof principal.userId !== "string" || !/^[a-f\d]{24}$/i.test(principal.userId) ||
+        !["User", "Bot"].includes(principal.principalKind) || principal.principalKind === "Bot" ||
+        principal.userId.toLowerCase() === this.botUserId.toLowerCase()) return;
+    } else if (String(display || "").startsWith("open-claudia:")) {
+      // Legacy/direct rooms allow client metadata, so it is not a trusted source.
+      return;
+    }
     // Reserve the slot before the first await: the join response and the async
     // publishers event both list the same feed, and while attach() is in
     // flight the second frame passes the caller's has() check and subscribes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "3.4.13",
+  "version": "3.4.14",
   "description": "An always-on, provider-agnostic coding-agent harness for Claude Code and OpenAI Codex via chat",
   "main": "bot.js",
   "bin": {

package/test-kazee-call-session.js

@@ -462,10 +462,11 @@ async function testManagedRoomCredentials() {
   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');
+  assert.strictEqual(session.subscribers.size, 0, 'own joined publisher ID and unclassified managed feeds are excluded independently of display');
 
   session.roomTokenExpiresAt = Date.now() - 1;
-  await Promise.all([session._subscribe(17, "owner"), session._subscribe(18, "other")]);
+  const userMetadata = { kazee: { version: 1, userId: 'a'.repeat(24), principalKind: 'User' } };
+  await Promise.all([session._subscribe(17, "owner", userMetadata), session._subscribe(18, "other", userMetadata)]);
   const subJoin = session.janus.calls.find(body => body.ptype === "subscriber");
   assert.strictEqual(subJoin.token, "subscriber-token");
   assert.strictEqual(subJoin.private_id, 999);
@@ -484,6 +485,66 @@ async function testManagedRoomCredentials() {
   assert.ok(!session.janus.calls.some(body => ["create", "destroy"].includes(body.request)), "server allocated room ownership never transfers to the bot");
 }
 
+async function testTrustedPublisherMetadata() {
+  const botId = 'b'.repeat(24), userId = 'a'.repeat(24);
+  const metadata = (principalKind, id = userId) => ({ kazee: { version: 1, userId: id, principalKind } });
+  const publisher = (id, meta, display = 'speaker@calling.invalid') => ({ id, display, metadata: meta });
+  let initial = [];
+  class MetadataJanus extends FakeJanus {
+    constructor() { super(); this.calls = []; this.listeners = new Map(); }
+    onHandle(handle, listener) { this.listeners.set(handle, listener); }
+    async message(handle, body) {
+      this.calls.push({ handle, ...body });
+      if (body.request === 'join' && body.ptype === 'publisher') return { plugindata: { data: { videoroom: 'joined', id: 41, private_id: 999, publishers: initial } } };
+      if (body.request === 'configure') return { jsep: { type: 'answer', sdp: 'fixture' } };
+      if (body.request === 'join' && body.ptype === 'subscriber') return { plugindata: { data: { videoroom: 'attached' } }, jsep: { type: 'offer', sdp: 'fixture' } };
+      return {};
+    }
+  }
+  const make = managedRoom => new KazeeCallSession({ roomId: 7, chatId: 'chat', callerId: userId, botUserId: botId, managedRoom,
+    roomToken: 'fixture', roomTokenExpiresAt: Date.now() + 300000,
+    iceServers: [{ urls: 'turn:relay:3478', username: 'fixture', credential: 'fixture' }], iceCredentialsExpiresAt: Date.now() + 3600000,
+    JanusClientImpl: MetadataJanus, PeerConnectionImpl: FakePC, SpeechStreamImpl: FakeSpeechStream });
+  const invalid = [undefined, null, {}, { kazee: null }, { kazee: [] },
+    { kazee: { version: 2, userId, principalKind: 'User' } }, { kazee: { version: '1', userId, principalKind: 'User' } },
+    metadata('Human'), metadata('bot'), metadata(undefined), metadata('User', 'invalid'), { kazee: { version: 1, principalKind: 'User' } },
+    { kazee: { version: 1, userId: { $ne: null }, principalKind: 'User' } }];
+  initial = [publisher(41, metadata('User')), publisher(42, metadata('Bot', 'c'.repeat(24)), 'other-bot@calling.invalid'),
+    publisher(43, metadata('User')), publisher(44, metadata('User', botId.toUpperCase())),
+    ...invalid.map((meta, i) => publisher(100 + i, meta))];
+  const managed = make(true);
+  try {
+    await managed.start();
+    assert.deepStrictEqual([...managed.subscribers.keys()], [43], 'initial join reaches real subscription only for a classified human, never self/bot/unknown');
+    assert.strictEqual(managed.subscribers.get(43).started, true, 'authorized human reaches the actual subscriber offer/answer path');
+    const emit = publishers => managed.janus.listeners.get(managed.publisherHandle)({ janus: 'event', plugindata: { data: { publishers } } });
+    await emit([publisher(50, metadata('Bot', 'd'.repeat(24)), 'another-bot@calling.invalid'),
+      publisher(51, metadata('User'), 'open-claudia:display-is-not-managed-authority'),
+      ...invalid.map((meta, i) => publisher(200 + i, meta))]);
+    assert.deepStrictEqual([...managed.subscribers.keys()], [43, 51], 'live publisher metadata survives forwarding; managed classification never falls back to display prefix');
+    assert.strictEqual(managed.subscribers.get(51).display, 'open-claudia:display-is-not-managed-authority', 'presentation remains unchanged');
+    const handles = managed.janus.handles;
+    await managed._subscribe(60, 'unclassified@calling.invalid');
+    await managed._subscribe(61, 'bot@calling.invalid', metadata('Bot'));
+    await managed._subscribe(41, 'own@calling.invalid', metadata('User'));
+    assert.strictEqual(managed.janus.handles, handles, 'the subscription method itself fails closed before creating handles or speech streams');
+    assert.deepStrictEqual(managed.janus.calls.filter(body => body.ptype === 'subscriber').map(body => body.feed), [43, 51]);
+  } finally { await managed.close(); }
+
+  initial = [publisher(41, metadata('User')), publisher(42, metadata('User'), 'open-claudia:legacy-bot'),
+    publisher(43, metadata('Bot'), 'human@calling.invalid')];
+  const legacy = make(false);
+  try {
+    await legacy.start();
+    assert.deepStrictEqual([...legacy.subscribers.keys()], [43], 'legacy metadata cannot hide a human or impersonate one for a prefixed bot; own numeric feed remains excluded');
+    await legacy.janus.listeners.get(legacy.publisherHandle)({ janus: 'event', plugindata: { data: { publishers: [
+      publisher(50, metadata('Bot'), 'untrusted-kind@calling.invalid'), publisher(51, metadata('User'), 'open-claudia:other-bot'),
+      publisher(52, undefined, 'older-client@calling.invalid'),
+    ] } } });
+    assert.deepStrictEqual([...legacy.subscribers.keys()], [43, 50, 52], 'legacy live publishers keep display-prefix behavior regardless of spoofed or absent metadata');
+  } finally { await legacy.close(); }
+}
+
 async function testAssignedRelayTransportLifetime() {
   const { RTCPeerConnection } = require('werift');
   const originalExpiry = Date.now() + 3600000;
@@ -538,6 +599,7 @@ async function testAssignedRelayTransportLifetime() {
 }
 
 (async () => {
+  await testTrustedPublisherMetadata();
   await testAssignedRelayTransportLifetime();
   await testManagedRoomCredentials();
   await testSpeakSerialization();

package/test-provider-language.js

@@ -464,9 +464,10 @@ assert.match(pkg.description, /provider-agnostic coding-agent harness/i);
 // 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.12: Sumeet approved the full calling rollout on 2026-09-05; preserve assigned media configuration across canary changes.
+// 3.4.14: bot managed-call consumer (subscribe only to gateway-authenticated User publishers) — part of the Janus calling plan Sumeet approved on 2026-09-05.
 // 3.4.13: Codex usage accounting fix — Sumeet approved the three-bug fix on 2026-09-05 ("Yes");
 // prepared 2026-09-06 for his release go. Rollout-based Codex context, per-turn ledger, sub-agent + quota accounting.
-assert.strictEqual(pkg.version, "3.4.13", "release version must remain unchanged without explicit approval");
+assert.strictEqual(pkg.version, "3.4.14", "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}`);
 }