@thaut/claude-ide 0.0.0-stage → 1.0.0

package/server/http-channel-pull.test.ts

@@ -0,0 +1,314 @@
+import { test, after, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { channelFixture, until } from "./http-channel-test-fixture.ts";
+
+const fixture = await channelFixture();
+afterEach(() => fixture.reset());
+after(() => fixture.close());
+
+test("empty responses repoll after 20ms without starting an SDK; text IDs deduplicate, not content", async () => {
+  const times: number[] = [];
+  const responses = [{ kind: "empty" }, { kind: "text", id: "one", text: "/cd literal input" }, { kind: "text", id: "one", text: "duplicate" }, { kind: "text", id: "two", text: "/cd literal input" }];
+  let headers = "";
+  const endpoint = await fixture.http((request, response) => {
+    times.push(Date.now());
+    headers = String(request.headers.authorization);
+    if (times.length === 1) assert.equal(fixture.queries.length, 0);
+    response.end(JSON.stringify(responses.shift() ?? { kind: "empty" }));
+  });
+  const manager = fixture.httpChannels;
+  manager.start();
+  const session = fixture.newSession();
+  const source = fixture.store.saveSource({ name: "pull", url: endpoint.url, headers: { Authorization: "Bearer test" } });
+  const binding = fixture.store.createBinding(session, source.id, "subscribe");
+  manager.activate(binding.id);
+  await until(() => fixture.queryFor(session)?.received.length === 2);
+  const messages = fixture.queryFor(session)!.received;
+  assert.ok(times[1]! - times[0]! >= 18);
+  assert.equal(headers, "Bearer test");
+  assert.equal(messages[0]!.client_composed, true);
+  assert.equal(messages[0]!.priority, "next");
+  assert.deepEqual(messages.map((message) => message.message.content[0].text), ["/cd literal input", "/cd literal input"]);
+  assert.notEqual(messages[0]!.uuid, messages[1]!.uuid);
+  assert.equal(manager.info(session).bindings[0]!.stats!.duplicates, 1);
+});
+
+test("same URL subscriptions consume independently and deduplicate IDs in their own scope", async () => {
+  let requests = 0;
+  const endpoint = await fixture.http((_request, response) => { requests++; response.end('{"kind":"text","id":"same-id","text":"same text"}'); });
+  const manager = fixture.httpChannels;
+  manager.start();
+  const source = fixture.store.saveSource({ name: "shared", url: endpoint.url });
+  const sessions = [fixture.newSession(), fixture.newSession()];
+  for (const session of sessions) manager.activate(fixture.store.createBinding(session, source.id, "subscribe").id);
+  await until(() => sessions.every((session) => fixture.queryFor(session)?.received.length === 1) && requests >= 4);
+  manager.stop();
+  assert.equal(fixture.queries.length, 2);
+  for (const session of sessions) assert.equal(fixture.queryFor(session)!.received.length, 1);
+});
+
+test("POST subscriptions send exact extra JSON and preserve ASR text with optional response IDs", async () => {
+  const text = "<asr-recognized-text>帮我把客厅的灯关一下。</asr-recognized-text>";
+  const responses = [{ kind: "empty" }, { kind: "text", text }, { kind: "text", text }, { kind: "text", id: "asr-1", text }, { kind: "text", id: "asr-1", text }];
+  const requests: { method: string | undefined; body: unknown; contentType: string | undefined }[] = [];
+  const endpoint = await fixture.http(async (request, response) => {
+    let raw = "";
+    for await (const chunk of request) raw += chunk;
+    requests.push({ method: request.method, body: JSON.parse(raw), contentType: request.headers["content-type"] });
+    response.end(JSON.stringify(responses.shift() ?? { kind: "empty" }));
+  });
+  const manager = fixture.httpChannels;
+  manager.start();
+  const session = fixture.newSession();
+  const source = fixture.store.saveSource({ name: "ASR", url: endpoint.url, subscribeMethod: "POST", extraBody: { brain_id: "genkigirl" } });
+  manager.activate(fixture.store.createBinding(session, source.id, "subscribe").id);
+  await until(() => fixture.queryFor(session)?.received.length === 3 && manager.info(session).bindings[0]!.stats!.duplicates === 1);
+  manager.stop();
+  assert.ok(requests.length >= 5);
+  assert.ok(requests.every((request) => request.method === "POST" && request.contentType === "application/json"));
+  assert.ok(requests.every((request) => JSON.stringify(request.body) === '{"brain_id":"genkigirl"}'));
+  const received = fixture.queryFor(session)!.received;
+  assert.deepEqual(received.map((message) => message.message.content[0].text), [text, text, text]);
+  assert.equal(new Set(received.map((message) => message.uuid)).size, 3);
+  assert.ok(received.every((message) => message.client_composed === true && message.priority === "next"));
+});
+
+test("brain-api exchanges exact JSON in both directions with one activation while a poll is blocked", async () => {
+  const text = "<asr-recognized-text>帮我把客厅的灯关一下。</asr-recognized-text>";
+  const posts: unknown[] = [];
+  let polls = 0;
+  let held = false;
+  let cancelled = false;
+  const endpoint = await fixture.http(async (request, response) => {
+    assert.equal(request.method, "POST");
+    assert.equal(request.headers["content-type"], "application/json");
+    assert.equal(request.headers.authorization, "Bearer test");
+    let raw = "";
+    for await (const chunk of request) raw += chunk;
+    const body = JSON.parse(raw);
+    if (request.url === "/api/brain-to-agent?scope=test") {
+      assert.equal(request.headers["x-brain-voice"], undefined);
+      assert.deepEqual(body, { brain_id: "genkigirl" });
+      if (++polls === 1) response.end(JSON.stringify({ kind: "text", text }));
+      else { held = true; response.on("close", () => { cancelled = true; }); }
+    } else {
+      assert.equal(request.url, "/api/agent-to-brain?scope=test");
+      assert.equal(request.headers["x-brain-voice"], "test-voice");
+      posts.push(body);
+      response.end('{"kind":"empty"}');
+    }
+  });
+  const manager = fixture.httpChannels;
+  manager.start();
+  const session = fixture.newSession();
+  const source = fixture.store.saveSource({ kind: "brain-api", brainId: "genkigirl", brainVoice: "test-voice", url: `${endpoint.url}/api/?scope=test`, headers: { Authorization: "Bearer test" } });
+  const binding = fixture.store.createBinding(session, source.id, "subscribe");
+  manager.activate(binding.id);
+  await until(() => held && fixture.queryFor(session)?.received.length === 1);
+  assert.equal(fixture.queryFor(session)!.received[0]!.message.content[0].text, text);
+  assert.equal(manager.info().activeCount, 1);
+  fixture.queryFor(session)!.push(fixture.text(fixture.id(), "灯已关闭。"));
+  fixture.queryFor(session)!.push(fixture.text(fixture.id(), "another block"));
+  await until(() => manager.info(session).bindings[0]!.stats!.pushed === 2);
+  assert.deepEqual(posts, [{ brain_id: "genkigirl", text: "灯已关闭。" }, { brain_id: "genkigirl", text: "another block" }]);
+  assert.equal(manager.info(session).bindings[0]!.stats!.received, 1);
+  assert.equal(fixture.queryFor(session)!.received.length, 1); // push's empty response isn't an input
+  manager.deactivate(binding.id);
+  await until(() => cancelled);
+  fixture.queryFor(session)!.push(fixture.text(fixture.id(), "inactive"));
+  await until(() => fixture.sessions.get(session)!.events.some((event) => event.ev.k === "sdk" && JSON.stringify(event.ev.m).includes("inactive")));
+  assert.equal(posts.length, 2);
+  assert.equal(manager.info().activeCount, 0);
+});
+
+test("brain-api restores both directions and keeps push failures visible across successful polls", async () => {
+  let polls = 0;
+  let posts = 0;
+  const endpoint = await fixture.http(async (request, response) => {
+    assert.equal(request.headers["x-brain-voice"], undefined);
+    for await (const _chunk of request) { /* drain body */ }
+    if (request.url === "/brain-to-agent") { polls++; response.end('{"kind":"empty"}'); }
+    else { posts++; response.statusCode = 500; response.end(); }
+  });
+  const manager = fixture.httpChannels;
+  manager.start();
+  const session = fixture.newSession();
+  const source = fixture.store.saveSource({ kind: "brain-api", brainId: "test", url: endpoint.url });
+  manager.activate(fixture.store.createBinding(session, source.id, "subscribe").id);
+  await until(() => polls > 0);
+  manager.stop();
+  const previous = polls;
+  manager.start();
+  await until(() => polls > previous);
+  assert.equal(manager.info().activeCount, 1);
+  await (await fixture.sessions.getOrCreate(session, fixture.tmp)).wake();
+  fixture.queryFor(session)!.push(fixture.text(fixture.id(), "one attempt"));
+  await until(() => manager.info(session).bindings[0]!.stats!.dropped === 1);
+  const afterFailure = polls;
+  await until(() => polls > afterFailure);
+  const stats = manager.info(session).bindings[0]!.stats!;
+  assert.equal(stats.lastPushError, "HTTP 500");
+  assert.equal(stats.lastError, "HTTP 500");
+  assert.equal(posts, 1);
+});
+
+test("changing subscription method and POST body restarts long polls without losing delivery state", async () => {
+  let getHeld = false;
+  let getCancelled = false;
+  let postHeld = false;
+  let postCancelled = false;
+  let firstPosts = 0;
+  const endpoint = await fixture.http(async (request, response) => {
+    if (request.method === "GET") {
+      getHeld = true;
+      response.on("close", () => { getCancelled = true; });
+      return;
+    }
+    let raw = "";
+    for await (const chunk of request) raw += chunk;
+    const body = JSON.parse(raw);
+    if (body.brain_id === "first") {
+      if (++firstPosts === 1) response.end('{"kind":"text","id":"one","text":"first"}');
+      else { postHeld = true; response.on("close", () => { postCancelled = true; }); }
+    } else response.end('{"kind":"text","id":"two","text":"second"}');
+  });
+  const manager = fixture.httpChannels;
+  manager.start();
+  const session = fixture.newSession();
+  const source = fixture.store.saveSource({ name: "changing", url: endpoint.url });
+  assert.equal(source.subscribe_method, "GET");
+  manager.activate(fixture.store.createBinding(session, source.id, "subscribe").id);
+  await until(() => getHeld);
+  fixture.store.saveSource({ name: source.name, url: source.url, subscribeMethod: "POST", extraBody: { brain_id: "first" } }, source.id);
+  manager.sourceChanged(source.id);
+  await until(() => getCancelled && postHeld && fixture.queryFor(session)?.received.length === 1);
+  fixture.store.saveSource({ name: source.name, url: source.url, extraBody: { brain_id: "second" } }, source.id);
+  manager.sourceChanged(source.id);
+  await until(() => postCancelled && fixture.queryFor(session)?.received.length === 2);
+  manager.stop();
+  assert.deepEqual(fixture.queryFor(session)!.received.map((message) => message.message.content[0].text), ["first", "second"]);
+});
+
+test("only 404 backs off, capped at two seconds; other HTTP errors return to 20ms", async () => {
+  let requests = 0;
+  const delays: number[] = [];
+  const endpoint = await fixture.http((_request, response) => { response.statusCode = ++requests <= 8 ? 404 : 500; response.end(); });
+  const manager = new (fixture.httpChannels.constructor as new (pause: (ms: number, signal: AbortSignal) => Promise<void>) => typeof fixture.httpChannels)(async (ms) => {
+    delays.push(ms);
+    if (delays.length >= 10) { manager.stop(); return; }
+    await new Promise<void>((resolve) => setImmediate(resolve));
+  });
+  manager.start();
+  const source = fixture.store.saveSource({ name: "missing", url: endpoint.url });
+  manager.activate(fixture.store.createBinding(fixture.newSession(), source.id, "subscribe").id);
+  await until(() => delays.length >= 10);
+  assert.deepEqual(delays, [100, 200, 400, 800, 1600, 2000, 2000, 2000, 20, 20]);
+});
+
+test("inbox capacity is 1024, then polling stops until there is delivery capacity", async () => {
+  let requests = 0;
+  const endpoint = await fixture.http((_request, response) => { response.end(JSON.stringify({ kind: "text", id: String(++requests), text: "queued" })); });
+  const manager = fixture.fastManager();
+  manager.start();
+  const session = fixture.newSession();
+  const source = fixture.store.saveSource({ name: "backlog", url: endpoint.url });
+  manager.activate(fixture.store.createBinding(session, source.id, "subscribe").id);
+  await until(() => fixture.queryFor(session)?.received.length === 32 && manager.info().inboxSize === 1024, 8000);
+  const count = requests;
+  await new Promise((resolve) => setTimeout(resolve, 40));
+  assert.equal(manager.info().inboxSize, 1024);
+  assert.equal(requests, count);
+  assert.equal(fixture.queryFor(session)!.received.length, 32);
+  manager.stop();
+});
+
+test("deactivation aborts long polling; a late response cannot wake or steer the session", async () => {
+  let respond: (() => void) | undefined;
+  const endpoint = await fixture.http((_request, response) => { respond = () => response.end('{"kind":"text","id":"late","text":"do not deliver"}'); });
+  const manager = fixture.httpChannels;
+  manager.start();
+  const source = fixture.store.saveSource({ name: "late", url: endpoint.url });
+  const binding = fixture.store.createBinding(fixture.newSession(), source.id, "subscribe");
+  manager.activate(binding.id);
+  await until(() => !!respond);
+  manager.deactivate(binding.id);
+  respond!();
+  await new Promise((resolve) => setTimeout(resolve, 40));
+  assert.equal(fixture.queries.length, 0);
+  assert.equal(manager.info().inboxSize, 0);
+  assert.equal(manager.info().activeCount, 0);
+});
+
+test("renaming a source keeps its consumed inbox and dedup cache", async () => {
+  let requests = 0;
+  const endpoint = await fixture.http((_request, response) => {
+    const id = String(++requests <= 35 ? requests : 1);
+    response.end(JSON.stringify({ kind: "text", id, text: `message ${id}` }));
+  });
+  const manager = fixture.fastManager();
+  manager.start();
+  const session = fixture.newSession();
+  const source = fixture.store.saveSource({ name: "before", url: endpoint.url });
+  manager.activate(fixture.store.createBinding(session, source.id, "subscribe").id);
+  await until(() => fixture.queryFor(session)?.received.length === 32 && manager.info().inboxSize === 3 && requests > 35);
+  const duplicates = manager.info(session).bindings[0]!.stats!.duplicates;
+  fixture.store.saveSource({ name: "after", url: endpoint.url }, source.id);
+  manager.sourceChanged(source.id);
+  assert.equal(manager.info().inboxSize, 3);
+  await until(() => manager.info(session).bindings[0]!.stats!.duplicates > duplicates);
+  assert.equal(manager.info().inboxSize, 3);
+  assert.equal(fixture.queryFor(session)!.received.length, 32);
+});
+
+test("editing a request restarts a long poll without dropping its inbox or dedup state", async () => {
+  let requests = 0;
+  let held = false;
+  let cancelled = false;
+  const oldEndpoint = await fixture.http((_request, response) => {
+    if (++requests <= 35) response.end(JSON.stringify({ kind: "text", id: String(requests), text: `message ${requests}` }));
+    else { held = true; response.on("close", () => { cancelled = true; }); }
+  });
+  let newRequests = 0;
+  const newEndpoint = await fixture.http((request, response) => {
+    assert.equal(request.headers.authorization, "Bearer updated");
+    assert.equal(request.headers["content-type"], "application/json");
+    response.end(JSON.stringify({ kind: "text", id: ++newRequests === 1 ? "1" : "36", text: "next" }));
+  });
+  const manager = fixture.fastManager();
+  manager.start();
+  const session = fixture.newSession();
+  const source = fixture.store.saveSource({ name: "source", url: oldEndpoint.url });
+  manager.activate(fixture.store.createBinding(session, source.id, "subscribe").id);
+  await until(() => held && fixture.queryFor(session)?.received.length === 32 && manager.info().inboxSize === 3);
+  fixture.store.saveSource({ name: "source", url: newEndpoint.url, headers: { Authorization: "Bearer updated" } }, source.id);
+  manager.sourceChanged(source.id);
+  assert.equal(manager.info().inboxSize, 3);
+  await until(() => cancelled && newRequests >= 2 && manager.info().inboxSize === 4);
+  assert.equal(fixture.queryFor(session)!.received.length, 32);
+});
+
+test("a failed SDK handoff retries before a later message from the same session", async () => {
+  const messages = [{ kind: "text", id: "a", text: "A" }, { kind: "text", id: "b", text: "B" }];
+  const endpoint = await fixture.http((_request, response) => { response.end(JSON.stringify(messages.shift() ?? { kind: "empty" })); });
+  const manager = fixture.fastManager();
+  manager.start();
+  const session = fixture.newSession();
+  const live = await fixture.sessions.getOrCreate(session, fixture.tmp);
+  const send = live.sendExternalText.bind(live);
+  let release: (() => void) | undefined;
+  let fail = true;
+  live.sendExternalText = async (...args) => {
+    if (fail) {
+      fail = false;
+      await new Promise<void>((resolve) => { release = resolve; });
+      throw new Error("transient SDK startup failure");
+    }
+    return send(...args);
+  };
+  const source = fixture.store.saveSource({ name: "ordered", url: endpoint.url });
+  manager.activate(fixture.store.createBinding(session, source.id, "subscribe").id);
+  await until(() => !!release && manager.info().inboxSize === 2);
+  release!();
+  await until(() => fixture.queryFor(session)?.received.length === 2);
+  assert.deepEqual(fixture.queryFor(session)!.received.map((message) => message.message.content[0].text), ["A", "B"]);
+});