@inetafrica/open-claudia 3.4.6 → 3.4.11

package/test-kazee-call-session.js

@@ -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,49 @@ 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", 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,
+    refreshRoomAccess: async () => { refreshes += 1; return { 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");
+  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 () => {
+  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,7 +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.
-assert.strictEqual(pkg.version, "3.4.6", "release version must remain unchanged without explicit approval");
+// 3.4.11: owner approved end-to-end calling rollout on 2026-09-05.
+assert.strictEqual(pkg.version, "3.4.11", "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}`);
 }

package/test-provider-scheduler.js

@@ -633,6 +633,88 @@ async function busyRestartAndMissedProbe(createSchedulerService) {
   assert.strictEqual(missedTimers.length, 1, "a missed wakeup gets exactly one startup attempt");
 }
 
+async function durablePendingProbe(createSchedulerService, jobsApi) {
+  const configDir = fs.mkdtempSync(path.join(os.tmpdir(), "oc-pending-restart-"));
+  let clock = 1_720_000_000_500;
+  const openStore = () => jobsApi.createJobsStore({ configDir, jobsFile: path.join(configDir, "jobs.json"), now: () => clock });
+  const success = { ok: true, status: "succeeded", delivery: { ok: true } };
+  try {
+    for (const kind of ["wakeup", "watch", "expiry"]) {
+      const store = openStore();
+      store.add(baseJob({ id: kind, ...(kind === "wakeup" ? {} : {
+        kind: "cron", schedule: "* * * * *", check: "fixture-check", repeat: true,
+        expiresAt: kind === "expiry" ? clock - 1 : clock + 1000,
+      }) }));
+      let checks = 0;
+      const h = schedulerHarness(createSchedulerService, [], {
+        jobsStore: store, now: () => clock,
+        runWatchCheck: async () => { checks++; return { code: kind === "expiry" ? 1 : 0 }; },
+      });
+      h.state.runningProcess = { pid: 1 };
+      for (let tick = 0; tick < 12; tick++) {
+        clock += 60 * 60 * 1000;
+        const result = await h.service.fireJob(kind);
+        assert.strictEqual(result.deferred, true, "hours of busy time must remain queued");
+      }
+      assert.strictEqual(store.get(kind).attemptCount, 0);
+      assert.strictEqual(store.get(kind).disabled, false);
+      assert.strictEqual(checks, kind === "wakeup" ? 0 : 1);
+      assert.strictEqual(h.sends.length, 0);
+      h.service.stopAll();
+
+      // Reopen the real on-disk store and construct a new scheduler, as boot does.
+      const reloaded = openStore();
+      const terminal = deferred();
+      const restarted = schedulerHarness(createSchedulerService, [], {
+        jobsStore: reloaded, now: () => clock, outcomes: [terminal.promise, success],
+        runWatchCheck: async () => { throw new Error("pending watch must not poll after restart"); },
+      });
+      restarted.service.init();
+      const firing = restarted.scheduled[0].fn();
+      await nextTurn();
+      clock += 60 * 60 * 1000;
+      assert.strictEqual((await restarted.service.fireJob(kind)).inFlight, true, "long runs cannot re-enter after retry delay");
+      assert.strictEqual(restarted.runCalls.length, 1);
+      assert.strictEqual(restarted.sends.length, 1);
+      if (kind === "expiry") assert.match(restarted.runCalls[0].prompt, /Watch expired/);
+      terminal.resolve(success);
+      await firing;
+      if (kind === "watch") {
+        assert.strictEqual(reloaded.get(kind).status, "pending");
+        assert.strictEqual(reloaded.get(kind).watchTriggeredOccurrenceId, null);
+        restarted.service.removeJob(kind);
+      } else assert.strictEqual(reloaded.get(kind), null);
+      restarted.service.stopAll();
+      const finalBoot = schedulerHarness(createSchedulerService, [], { jobsStore: openStore(), now: () => clock });
+      finalBoot.service.init();
+      assert.strictEqual(finalBoot.scheduled.length, 0, "successful one-shot cannot replay on restart");
+    }
+
+    const store = openStore();
+    store.add(baseJob({ id: "failure", kind: "cron", schedule: "* * * * *", check: "fixture" }));
+    const failed = schedulerHarness(createSchedulerService, [], {
+      jobsStore: store, now: () => clock,
+      runWatchCheck: async () => ({ code: 0 }), outcomes: [{ ok: false, error: { code: "FIXTURE_FAILED" } }],
+    });
+    await failed.service.fireJob("failure");
+    failed.service.stopAll();
+    clock += 2000;
+    const retry = schedulerHarness(createSchedulerService, [], {
+      jobsStore: openStore(), now: () => clock,
+      runWatchCheck: async () => { throw new Error("do not recheck"); },
+      outcomes: [{ ok: false }, { ok: false }],
+    });
+    await retry.service.fireJob("failure");
+    await retry.service.fireJob("failure");
+    assert.strictEqual(retry.jobsStore.get("failure").status, "dead-letter", "real failures retain bounded retries");
+    assert.strictEqual(retry.jobsStore.get("failure").attemptCount, 3);
+    assert.strictEqual(retry.sends.length, 0, "advisory is not repeated across failure/restart");
+    retry.service.stopAll();
+  } finally {
+    fs.rmSync(configDir, { recursive: true, force: true });
+  }
+}
+
 async function unavailableAndFallbackProbe(createSchedulerService) {
   const noFallback = schedulerHarness(createSchedulerService, [baseJob({ id: "unavailable" })], {
     providerStatus: () => ({ availability: { state: "missing" }, auth: { state: "not_checked" } }),
@@ -960,6 +1042,7 @@ async function main() {
   await failureAndRetryProbe(schedulerApi.createSchedulerService);
   await detachedHistoricalBranchProbe(schedulerApi.createSchedulerService);
   await busyRestartAndMissedProbe(schedulerApi.createSchedulerService);
+  await durablePendingProbe(schedulerApi.createSchedulerService, jobsApi);
   await unavailableAndFallbackProbe(schedulerApi.createSchedulerService);
   await cronOccurrenceProbe(schedulerApi.createSchedulerService);
   await watchGateProbe(schedulerApi.createSchedulerService);