Mohamed Boudra
d9e14186ce
Move terminal stream buffering, handler fanout, and ack offset state out of DaemonClient into a focused TerminalStreamManager.\n\nReasoning:\n- daemon-client.ts mixed RPC transport concerns with terminal stream state machine details.\n- terminal buffering/ack logic is cohesive and testable in isolation, so splitting it lowers logic density and makes future stream changes safer.\n\nWhat changed:\n- Added daemon-client-terminal-stream-manager.ts to own stream handlers, buffered chunks, and ack monotonicity.\n- Updated DaemonClient to delegate terminal stream state transitions (subscribe, receive chunk, clear stream/all, note ack).\n- Preserved public API by re-exporting TerminalStreamChunk from daemon-client.ts.\n- Hardened daemon-client tests to assert behavior (no delivery/ack after detach or stream_exit) rather than private internal maps.\n- Added dedicated manager unit tests for buffering, eviction, handler-failure behavior, and stale ack suppression.\n\nVerification:\n- npm run test --workspace=@getpaseo/server -- src/client/daemon-client.test.ts src/client/daemon-client-terminal-stream-manager.test.ts\n- npm run typecheck\n\nNext-agent notes:\n- Accomplishment: terminal stream state is now isolated; daemon-client.ts is slimmer and easier to extend.\n- Challenge: daemon-client.ts is still large (~3k lines) with other cohesive seams remaining (dictation flow and checkout RPC groups).
1111 lines
30 KiB
TypeScript
1111 lines
30 KiB
TypeScript
import { afterEach, describe, expect, expectTypeOf, test, vi } from "vitest";
|
|
import { DaemonClient, type DaemonTransport } from "./daemon-client";
|
|
import {
|
|
BinaryMuxChannel,
|
|
TerminalBinaryMessageType,
|
|
asUint8Array,
|
|
decodeBinaryMuxFrame,
|
|
encodeBinaryMuxFrame,
|
|
} from "../shared/binary-mux.js";
|
|
|
|
expectTypeOf<"getGitDiff" extends keyof DaemonClient ? true : false>().toEqualTypeOf<false>();
|
|
expectTypeOf<"getHighlightedDiff" extends keyof DaemonClient ? true : false>().toEqualTypeOf<false>();
|
|
|
|
function createMockLogger() {
|
|
return {
|
|
debug: vi.fn(),
|
|
info: vi.fn(),
|
|
warn: vi.fn(),
|
|
error: vi.fn(),
|
|
};
|
|
}
|
|
|
|
function createMockTransport() {
|
|
const sent: Array<string | Uint8Array | ArrayBuffer> = [];
|
|
|
|
let onMessage: (data: unknown) => void = () => {};
|
|
let onOpen: () => void = () => {};
|
|
let onClose: (_event?: unknown) => void = () => {};
|
|
let onError: (_event?: unknown) => void = () => {};
|
|
|
|
const transport: DaemonTransport = {
|
|
send: (data) => sent.push(data),
|
|
close: () => {},
|
|
onMessage: (handler) => {
|
|
onMessage = handler;
|
|
return () => {};
|
|
},
|
|
onOpen: (handler) => {
|
|
onOpen = handler;
|
|
return () => {};
|
|
},
|
|
onClose: (handler) => {
|
|
onClose = handler;
|
|
return () => {};
|
|
},
|
|
onError: (handler) => {
|
|
onError = handler;
|
|
return () => {};
|
|
},
|
|
};
|
|
|
|
return {
|
|
transport,
|
|
sent,
|
|
triggerOpen: () => onOpen(),
|
|
triggerClose: (event?: unknown) => onClose(event),
|
|
triggerError: (event?: unknown) => onError(event),
|
|
triggerMessage: (data: unknown) => onMessage(data),
|
|
};
|
|
}
|
|
|
|
function wrapSessionMessage(message: unknown): string {
|
|
return JSON.stringify({
|
|
type: "session",
|
|
message,
|
|
});
|
|
}
|
|
|
|
describe("DaemonClient", () => {
|
|
const clients: DaemonClient[] = [];
|
|
|
|
afterEach(async () => {
|
|
for (const client of clients) {
|
|
await client.close();
|
|
}
|
|
clients.length = 0;
|
|
});
|
|
|
|
test("dedupes in-flight checkout status requests per agentId", async () => {
|
|
const logger = createMockLogger();
|
|
const mock = createMockTransport();
|
|
|
|
const client = new DaemonClient({
|
|
url: "ws://test",
|
|
logger,
|
|
reconnect: { enabled: false },
|
|
transportFactory: () => mock.transport,
|
|
});
|
|
clients.push(client);
|
|
|
|
const connectPromise = client.connect();
|
|
mock.triggerOpen();
|
|
await connectPromise;
|
|
|
|
const p1 = client.getCheckoutStatus("/tmp/project");
|
|
const p2 = client.getCheckoutStatus("/tmp/project");
|
|
|
|
expect(mock.sent).toHaveLength(1);
|
|
|
|
const request = JSON.parse(mock.sent[0]) as {
|
|
type: "session";
|
|
message: { type: "checkout_status_request"; cwd: string; requestId: string };
|
|
};
|
|
|
|
const response = {
|
|
type: "session",
|
|
message: {
|
|
type: "checkout_status_response",
|
|
payload: {
|
|
cwd: "/tmp/project",
|
|
error: null,
|
|
requestId: request.message.requestId,
|
|
isGit: false,
|
|
isPaseoOwnedWorktree: false,
|
|
repoRoot: null,
|
|
currentBranch: null,
|
|
isDirty: null,
|
|
baseRef: null,
|
|
aheadBehind: null,
|
|
aheadOfOrigin: null,
|
|
hasRemote: false,
|
|
remoteUrl: null,
|
|
},
|
|
},
|
|
};
|
|
|
|
mock.triggerMessage(JSON.stringify(response));
|
|
const [r1, r2] = await Promise.all([p1, p2]);
|
|
expect(r1).toMatchObject({ cwd: "/tmp/project", requestId: request.message.requestId, isGit: false });
|
|
expect(r2).toMatchObject({ cwd: "/tmp/project", requestId: request.message.requestId, isGit: false });
|
|
|
|
// After completion, a new call should issue a new request.
|
|
const p3 = client.getCheckoutStatus("/tmp/project");
|
|
expect(mock.sent).toHaveLength(2);
|
|
|
|
const request2 = JSON.parse(mock.sent[1]) as {
|
|
type: "session";
|
|
message: { type: "checkout_status_request"; cwd: string; requestId: string };
|
|
};
|
|
|
|
mock.triggerMessage(
|
|
JSON.stringify({
|
|
...response,
|
|
message: {
|
|
...response.message,
|
|
payload: { ...response.message.payload, requestId: request2.message.requestId },
|
|
},
|
|
})
|
|
);
|
|
|
|
await expect(p3).resolves.toMatchObject({
|
|
cwd: "/tmp/project",
|
|
requestId: request2.message.requestId,
|
|
isGit: false,
|
|
});
|
|
});
|
|
|
|
test("subscribes to checkout diff updates via RPC handshake", async () => {
|
|
const logger = createMockLogger();
|
|
const mock = createMockTransport();
|
|
|
|
const client = new DaemonClient({
|
|
url: "ws://test",
|
|
logger,
|
|
reconnect: { enabled: false },
|
|
transportFactory: () => mock.transport,
|
|
});
|
|
clients.push(client);
|
|
|
|
const connectPromise = client.connect();
|
|
mock.triggerOpen();
|
|
await connectPromise;
|
|
|
|
const promise = client.subscribeCheckoutDiff(
|
|
"/tmp/project",
|
|
{ mode: "uncommitted" },
|
|
{ subscriptionId: "checkout-sub-1" }
|
|
);
|
|
|
|
expect(mock.sent).toHaveLength(1);
|
|
const request = JSON.parse(mock.sent[0]) as {
|
|
type: "session";
|
|
message: {
|
|
type: "subscribe_checkout_diff_request";
|
|
subscriptionId: string;
|
|
cwd: string;
|
|
compare: { mode: "uncommitted" | "base"; baseRef?: string };
|
|
requestId: string;
|
|
};
|
|
};
|
|
expect(request.message.type).toBe("subscribe_checkout_diff_request");
|
|
expect(request.message.subscriptionId).toBe("checkout-sub-1");
|
|
expect(request.message.cwd).toBe("/tmp/project");
|
|
expect(request.message.compare).toEqual({ mode: "uncommitted" });
|
|
|
|
mock.triggerMessage(
|
|
JSON.stringify({
|
|
type: "session",
|
|
message: {
|
|
type: "subscribe_checkout_diff_response",
|
|
payload: {
|
|
subscriptionId: "checkout-sub-1",
|
|
cwd: "/tmp/project",
|
|
files: [],
|
|
error: null,
|
|
requestId: request.message.requestId,
|
|
},
|
|
},
|
|
})
|
|
);
|
|
|
|
await expect(promise).resolves.toEqual({
|
|
subscriptionId: "checkout-sub-1",
|
|
cwd: "/tmp/project",
|
|
files: [],
|
|
error: null,
|
|
requestId: request.message.requestId,
|
|
});
|
|
});
|
|
|
|
test("getCheckoutDiff uses one-shot subscription protocol", async () => {
|
|
const logger = createMockLogger();
|
|
const mock = createMockTransport();
|
|
|
|
const client = new DaemonClient({
|
|
url: "ws://test",
|
|
logger,
|
|
reconnect: { enabled: false },
|
|
transportFactory: () => mock.transport,
|
|
});
|
|
clients.push(client);
|
|
|
|
const connectPromise = client.connect();
|
|
mock.triggerOpen();
|
|
await connectPromise;
|
|
|
|
const promise = client.getCheckoutDiff("/tmp/project", { mode: "base", baseRef: "main" });
|
|
|
|
expect(mock.sent).toHaveLength(1);
|
|
const subscribeRequest = JSON.parse(mock.sent[0]) as {
|
|
type: "session";
|
|
message: {
|
|
type: "subscribe_checkout_diff_request";
|
|
subscriptionId: string;
|
|
cwd: string;
|
|
compare: { mode: "uncommitted" | "base"; baseRef?: string };
|
|
requestId: string;
|
|
};
|
|
};
|
|
expect(subscribeRequest.message.type).toBe("subscribe_checkout_diff_request");
|
|
expect(subscribeRequest.message.cwd).toBe("/tmp/project");
|
|
expect(subscribeRequest.message.compare).toEqual({ mode: "base", baseRef: "main" });
|
|
|
|
mock.triggerMessage(
|
|
JSON.stringify({
|
|
type: "session",
|
|
message: {
|
|
type: "subscribe_checkout_diff_response",
|
|
payload: {
|
|
subscriptionId: subscribeRequest.message.subscriptionId,
|
|
cwd: "/tmp/project",
|
|
files: [],
|
|
error: null,
|
|
requestId: subscribeRequest.message.requestId,
|
|
},
|
|
},
|
|
})
|
|
);
|
|
|
|
await expect(promise).resolves.toEqual({
|
|
cwd: "/tmp/project",
|
|
files: [],
|
|
error: null,
|
|
requestId: subscribeRequest.message.requestId,
|
|
});
|
|
|
|
expect(mock.sent).toHaveLength(2);
|
|
const unsubscribeRequest = JSON.parse(mock.sent[1]) as {
|
|
type: "session";
|
|
message: {
|
|
type: "unsubscribe_checkout_diff_request";
|
|
subscriptionId: string;
|
|
};
|
|
};
|
|
expect(unsubscribeRequest.message.type).toBe("unsubscribe_checkout_diff_request");
|
|
expect(unsubscribeRequest.message.subscriptionId).toBe(
|
|
subscribeRequest.message.subscriptionId
|
|
);
|
|
});
|
|
|
|
test("requests branch suggestions via RPC", async () => {
|
|
const logger = createMockLogger();
|
|
const mock = createMockTransport();
|
|
|
|
const client = new DaemonClient({
|
|
url: "ws://test",
|
|
logger,
|
|
reconnect: { enabled: false },
|
|
transportFactory: () => mock.transport,
|
|
});
|
|
clients.push(client);
|
|
|
|
const connectPromise = client.connect();
|
|
mock.triggerOpen();
|
|
await connectPromise;
|
|
|
|
const promise = client.getBranchSuggestions(
|
|
{ cwd: "/tmp/project", query: "mai", limit: 5 },
|
|
"req-branches"
|
|
);
|
|
|
|
expect(mock.sent).toHaveLength(1);
|
|
const request = JSON.parse(mock.sent[0]) as {
|
|
type: "session";
|
|
message: {
|
|
type: "branch_suggestions_request";
|
|
cwd: string;
|
|
query?: string;
|
|
limit?: number;
|
|
requestId: string;
|
|
};
|
|
};
|
|
expect(request.message.type).toBe("branch_suggestions_request");
|
|
expect(request.message.cwd).toBe("/tmp/project");
|
|
expect(request.message.query).toBe("mai");
|
|
expect(request.message.limit).toBe(5);
|
|
expect(request.message.requestId).toBe("req-branches");
|
|
|
|
mock.triggerMessage(
|
|
JSON.stringify({
|
|
type: "session",
|
|
message: {
|
|
type: "branch_suggestions_response",
|
|
payload: {
|
|
branches: ["main"],
|
|
error: null,
|
|
requestId: "req-branches",
|
|
},
|
|
},
|
|
})
|
|
);
|
|
|
|
await expect(promise).resolves.toEqual({
|
|
branches: ["main"],
|
|
error: null,
|
|
requestId: "req-branches",
|
|
});
|
|
});
|
|
|
|
test("resubscribes checkout diff streams after reconnect", async () => {
|
|
const logger = createMockLogger();
|
|
const mock = createMockTransport();
|
|
|
|
const client = new DaemonClient({
|
|
url: "ws://test",
|
|
logger,
|
|
reconnect: { enabled: false },
|
|
transportFactory: () => mock.transport,
|
|
});
|
|
clients.push(client);
|
|
|
|
const internal = client as unknown as {
|
|
checkoutDiffSubscriptions: Map<
|
|
string,
|
|
{ cwd: string; compare: { mode: "uncommitted" | "base"; baseRef?: string } }
|
|
>;
|
|
};
|
|
internal.checkoutDiffSubscriptions.set("checkout-sub-1", {
|
|
cwd: "/tmp/project",
|
|
compare: { mode: "base", baseRef: "main" },
|
|
});
|
|
|
|
const connectPromise = client.connect();
|
|
mock.triggerOpen();
|
|
await connectPromise;
|
|
|
|
expect(mock.sent).toHaveLength(1);
|
|
const request = JSON.parse(mock.sent[0]) as {
|
|
type: "session";
|
|
message: {
|
|
type: "subscribe_checkout_diff_request";
|
|
subscriptionId: string;
|
|
cwd: string;
|
|
compare: { mode: "uncommitted" | "base"; baseRef?: string };
|
|
requestId: string;
|
|
};
|
|
};
|
|
expect(request.message.type).toBe("subscribe_checkout_diff_request");
|
|
expect(request.message.subscriptionId).toBe("checkout-sub-1");
|
|
expect(request.message.cwd).toBe("/tmp/project");
|
|
expect(request.message.compare).toEqual({ mode: "base", baseRef: "main" });
|
|
expect(typeof request.message.requestId).toBe("string");
|
|
expect(request.message.requestId.length).toBeGreaterThan(0);
|
|
});
|
|
|
|
test("fetches project-grouped agents via RPC", async () => {
|
|
const logger = createMockLogger();
|
|
const mock = createMockTransport();
|
|
|
|
const client = new DaemonClient({
|
|
url: "ws://test",
|
|
logger,
|
|
reconnect: { enabled: false },
|
|
transportFactory: () => mock.transport,
|
|
});
|
|
clients.push(client);
|
|
|
|
const connectPromise = client.connect();
|
|
mock.triggerOpen();
|
|
await connectPromise;
|
|
|
|
const promise = client.fetchAgentsGroupedByProject({
|
|
filter: { labels: { ui: "true" } },
|
|
});
|
|
|
|
expect(mock.sent).toHaveLength(1);
|
|
const request = JSON.parse(mock.sent[0]) as {
|
|
type: "session";
|
|
message: {
|
|
type: "fetch_agents_grouped_by_project_request";
|
|
requestId: string;
|
|
filter?: { labels?: Record<string, string> };
|
|
};
|
|
};
|
|
expect(request.message.type).toBe("fetch_agents_grouped_by_project_request");
|
|
|
|
mock.triggerMessage(
|
|
JSON.stringify({
|
|
type: "session",
|
|
message: {
|
|
type: "fetch_agents_grouped_by_project_response",
|
|
payload: {
|
|
requestId: request.message.requestId,
|
|
groups: [],
|
|
},
|
|
},
|
|
})
|
|
);
|
|
|
|
await expect(promise).resolves.toEqual({
|
|
requestId: request.message.requestId,
|
|
groups: [],
|
|
});
|
|
});
|
|
|
|
test("uses server-provided dictation finish timeout budget", async () => {
|
|
vi.useFakeTimers();
|
|
const logger = createMockLogger();
|
|
const mock = createMockTransport();
|
|
|
|
const client = new DaemonClient({
|
|
url: "ws://test",
|
|
logger,
|
|
reconnect: { enabled: false },
|
|
transportFactory: () => mock.transport,
|
|
});
|
|
clients.push(client);
|
|
|
|
const connectPromise = client.connect();
|
|
mock.triggerOpen();
|
|
await connectPromise;
|
|
|
|
const finishPromise = client.finishDictationStream("dict-1", 0);
|
|
const finishError = finishPromise.then(
|
|
() => null,
|
|
(error) => error
|
|
);
|
|
|
|
expect(mock.sent).toHaveLength(1);
|
|
mock.triggerMessage(
|
|
wrapSessionMessage({
|
|
type: "dictation_stream_finish_accepted",
|
|
payload: {
|
|
dictationId: "dict-1",
|
|
timeoutMs: 100,
|
|
},
|
|
})
|
|
);
|
|
|
|
await vi.advanceTimersByTimeAsync(5_101);
|
|
const error = await finishError;
|
|
expect(error).toBeInstanceOf(Error);
|
|
expect((error as Error).message).toContain(
|
|
"Timeout waiting for dictation finalization (5100ms)"
|
|
);
|
|
|
|
vi.useRealTimers();
|
|
});
|
|
|
|
test("resolves dictation finish when final arrives after finish accepted", async () => {
|
|
const logger = createMockLogger();
|
|
const mock = createMockTransport();
|
|
|
|
const client = new DaemonClient({
|
|
url: "ws://test",
|
|
logger,
|
|
reconnect: { enabled: false },
|
|
transportFactory: () => mock.transport,
|
|
});
|
|
clients.push(client);
|
|
|
|
const connectPromise = client.connect();
|
|
mock.triggerOpen();
|
|
await connectPromise;
|
|
|
|
const finishPromise = client.finishDictationStream("dict-2", 1);
|
|
expect(mock.sent).toHaveLength(1);
|
|
|
|
mock.triggerMessage(
|
|
wrapSessionMessage({
|
|
type: "dictation_stream_finish_accepted",
|
|
payload: {
|
|
dictationId: "dict-2",
|
|
timeoutMs: 1000,
|
|
},
|
|
})
|
|
);
|
|
mock.triggerMessage(
|
|
wrapSessionMessage({
|
|
type: "dictation_stream_final",
|
|
payload: {
|
|
dictationId: "dict-2",
|
|
text: "hello",
|
|
},
|
|
})
|
|
);
|
|
|
|
await expect(finishPromise).resolves.toEqual({
|
|
dictationId: "dict-2",
|
|
text: "hello",
|
|
});
|
|
});
|
|
|
|
test("cancels waiters when send fails (no leaked timeouts)", async () => {
|
|
vi.useFakeTimers();
|
|
const logger = createMockLogger();
|
|
const mock = createMockTransport();
|
|
|
|
const transportFactory = () => ({
|
|
...mock.transport,
|
|
send: () => {
|
|
throw new Error("boom");
|
|
},
|
|
});
|
|
|
|
const client = new DaemonClient({
|
|
url: "ws://test",
|
|
logger,
|
|
reconnect: { enabled: false },
|
|
transportFactory,
|
|
});
|
|
clients.push(client);
|
|
|
|
const connectPromise = client.connect();
|
|
mock.triggerOpen();
|
|
await connectPromise;
|
|
|
|
const promise = client.getCheckoutStatus("/tmp/project");
|
|
await expect(promise).rejects.toThrow("boom");
|
|
|
|
// Ensure we didn't leave a waiter behind that will reject later.
|
|
const internal = client as unknown as { waiters: Set<unknown> };
|
|
expect(internal.waiters.size).toBe(0);
|
|
|
|
vi.runOnlyPendingTimers();
|
|
vi.useRealTimers();
|
|
});
|
|
|
|
test("lists available providers via RPC", async () => {
|
|
const logger = createMockLogger();
|
|
const mock = createMockTransport();
|
|
|
|
const client = new DaemonClient({
|
|
url: "ws://test",
|
|
logger,
|
|
reconnect: { enabled: false },
|
|
transportFactory: () => mock.transport,
|
|
});
|
|
clients.push(client);
|
|
|
|
const connectPromise = client.connect();
|
|
mock.triggerOpen();
|
|
await connectPromise;
|
|
|
|
const promise = client.listAvailableProviders();
|
|
expect(mock.sent).toHaveLength(1);
|
|
|
|
const request = JSON.parse(mock.sent[0]) as {
|
|
type: "session";
|
|
message: { type: "list_available_providers_request"; requestId: string };
|
|
};
|
|
expect(request.message.type).toBe("list_available_providers_request");
|
|
|
|
mock.triggerMessage(
|
|
JSON.stringify({
|
|
type: "session",
|
|
message: {
|
|
type: "list_available_providers_response",
|
|
payload: {
|
|
providers: [
|
|
{ provider: "claude", available: true, error: null },
|
|
{ provider: "codex", available: false, error: "Missing binary" },
|
|
],
|
|
error: null,
|
|
fetchedAt: "2026-02-12T00:00:00.000Z",
|
|
requestId: request.message.requestId,
|
|
},
|
|
},
|
|
})
|
|
);
|
|
|
|
await expect(promise).resolves.toEqual({
|
|
providers: [
|
|
{ provider: "claude", available: true, error: null },
|
|
{ provider: "codex", available: false, error: "Missing binary" },
|
|
],
|
|
error: null,
|
|
fetchedAt: "2026-02-12T00:00:00.000Z",
|
|
requestId: request.message.requestId,
|
|
});
|
|
});
|
|
|
|
test("auto-acks terminal stream chunks after delivery", async () => {
|
|
const logger = createMockLogger();
|
|
const mock = createMockTransport();
|
|
|
|
const client = new DaemonClient({
|
|
url: "ws://test",
|
|
logger,
|
|
reconnect: { enabled: false },
|
|
transportFactory: () => mock.transport,
|
|
});
|
|
clients.push(client);
|
|
|
|
const connectPromise = client.connect();
|
|
mock.triggerOpen();
|
|
await connectPromise;
|
|
|
|
const seen: string[] = [];
|
|
const decoder = new TextDecoder();
|
|
const unsubscribe = client.onTerminalStreamData(7, (chunk) => {
|
|
seen.push(decoder.decode(chunk.data));
|
|
});
|
|
|
|
const payload = new TextEncoder().encode("hello");
|
|
mock.triggerMessage(
|
|
encodeBinaryMuxFrame({
|
|
channel: BinaryMuxChannel.Terminal,
|
|
messageType: TerminalBinaryMessageType.OutputUtf8,
|
|
streamId: 7,
|
|
offset: 10,
|
|
payload,
|
|
})
|
|
);
|
|
|
|
expect(seen).toEqual(["hello"]);
|
|
expect(mock.sent).toHaveLength(1);
|
|
const ackBytes = asUint8Array(mock.sent[0]);
|
|
expect(ackBytes).not.toBeNull();
|
|
const ackFrame = decodeBinaryMuxFrame(ackBytes!);
|
|
expect(ackFrame).not.toBeNull();
|
|
expect(ackFrame!.channel).toBe(BinaryMuxChannel.Terminal);
|
|
expect(ackFrame!.messageType).toBe(TerminalBinaryMessageType.Ack);
|
|
expect(ackFrame!.streamId).toBe(7);
|
|
expect(ackFrame!.offset).toBe(15);
|
|
unsubscribe();
|
|
});
|
|
|
|
test("acks buffered terminal chunks when handler is attached", async () => {
|
|
const logger = createMockLogger();
|
|
const mock = createMockTransport();
|
|
|
|
const client = new DaemonClient({
|
|
url: "ws://test",
|
|
logger,
|
|
reconnect: { enabled: false },
|
|
transportFactory: () => mock.transport,
|
|
});
|
|
clients.push(client);
|
|
|
|
const connectPromise = client.connect();
|
|
mock.triggerOpen();
|
|
await connectPromise;
|
|
|
|
mock.triggerMessage(
|
|
encodeBinaryMuxFrame({
|
|
channel: BinaryMuxChannel.Terminal,
|
|
messageType: TerminalBinaryMessageType.OutputUtf8,
|
|
streamId: 19,
|
|
offset: 0,
|
|
payload: new TextEncoder().encode("buffered"),
|
|
})
|
|
);
|
|
|
|
expect(mock.sent).toHaveLength(0);
|
|
|
|
const seen: string[] = [];
|
|
client.onTerminalStreamData(19, (chunk) => {
|
|
seen.push(new TextDecoder().decode(chunk.data));
|
|
});
|
|
|
|
expect(seen.join("")).toContain("buffered");
|
|
expect(mock.sent).toHaveLength(1);
|
|
const ackFrame = decodeBinaryMuxFrame(asUint8Array(mock.sent[0])!);
|
|
expect(ackFrame?.messageType).toBe(TerminalBinaryMessageType.Ack);
|
|
expect(ackFrame?.streamId).toBe(19);
|
|
expect(ackFrame?.offset).toBe(8);
|
|
});
|
|
|
|
test("stops delivering and acking after terminal_stream_exit", async () => {
|
|
const logger = createMockLogger();
|
|
const mock = createMockTransport();
|
|
|
|
const client = new DaemonClient({
|
|
url: "ws://test",
|
|
logger,
|
|
reconnect: { enabled: false },
|
|
transportFactory: () => mock.transport,
|
|
});
|
|
clients.push(client);
|
|
|
|
const connectPromise = client.connect();
|
|
mock.triggerOpen();
|
|
await connectPromise;
|
|
|
|
const seen: string[] = [];
|
|
const unsubscribe = client.onTerminalStreamData(23, (chunk) => {
|
|
seen.push(new TextDecoder().decode(chunk.data));
|
|
});
|
|
mock.triggerMessage(
|
|
encodeBinaryMuxFrame({
|
|
channel: BinaryMuxChannel.Terminal,
|
|
messageType: TerminalBinaryMessageType.OutputUtf8,
|
|
streamId: 23,
|
|
offset: 0,
|
|
payload: new TextEncoder().encode("before-exit"),
|
|
})
|
|
);
|
|
expect(seen).toEqual(["before-exit"]);
|
|
expect(mock.sent).toHaveLength(1);
|
|
mock.sent.length = 0;
|
|
|
|
mock.triggerMessage(
|
|
wrapSessionMessage({
|
|
type: "terminal_stream_exit",
|
|
payload: {
|
|
streamId: 23,
|
|
terminalId: "term-1",
|
|
},
|
|
})
|
|
);
|
|
|
|
mock.triggerMessage(
|
|
encodeBinaryMuxFrame({
|
|
channel: BinaryMuxChannel.Terminal,
|
|
messageType: TerminalBinaryMessageType.OutputUtf8,
|
|
streamId: 23,
|
|
offset: 12,
|
|
payload: new TextEncoder().encode("after-exit"),
|
|
})
|
|
);
|
|
|
|
expect(seen).toEqual(["before-exit"]);
|
|
expect(mock.sent).toHaveLength(0);
|
|
unsubscribe();
|
|
});
|
|
|
|
test("cleans local stream state even when detach reports success=false", async () => {
|
|
const logger = createMockLogger();
|
|
const mock = createMockTransport();
|
|
|
|
const client = new DaemonClient({
|
|
url: "ws://test",
|
|
logger,
|
|
reconnect: { enabled: false },
|
|
transportFactory: () => mock.transport,
|
|
});
|
|
clients.push(client);
|
|
|
|
const connectPromise = client.connect();
|
|
mock.triggerOpen();
|
|
await connectPromise;
|
|
|
|
const seen: string[] = [];
|
|
client.onTerminalStreamData(31, (chunk) => {
|
|
seen.push(new TextDecoder().decode(chunk.data));
|
|
});
|
|
|
|
const detachPromise = client.detachTerminalStream(31, "detach-31");
|
|
const detachRequest = JSON.parse(String(mock.sent[0])) as {
|
|
type: "session";
|
|
message: { type: string; streamId: number; requestId: string };
|
|
};
|
|
expect(detachRequest.message.type).toBe("detach_terminal_stream_request");
|
|
expect(detachRequest.message.streamId).toBe(31);
|
|
|
|
mock.triggerMessage(
|
|
wrapSessionMessage({
|
|
type: "detach_terminal_stream_response",
|
|
payload: {
|
|
streamId: 31,
|
|
success: false,
|
|
requestId: "detach-31",
|
|
},
|
|
})
|
|
);
|
|
|
|
const payload = await detachPromise;
|
|
expect(payload.success).toBe(false);
|
|
|
|
mock.sent.length = 0;
|
|
mock.triggerMessage(
|
|
encodeBinaryMuxFrame({
|
|
channel: BinaryMuxChannel.Terminal,
|
|
messageType: TerminalBinaryMessageType.OutputUtf8,
|
|
streamId: 31,
|
|
offset: 0,
|
|
payload: new TextEncoder().encode("after-detach"),
|
|
})
|
|
);
|
|
|
|
expect(seen).toEqual([]);
|
|
expect(mock.sent).toHaveLength(0);
|
|
});
|
|
|
|
test("parses canonical agent_stream tool_call payloads without crashing", async () => {
|
|
const logger = createMockLogger();
|
|
const mock = createMockTransport();
|
|
|
|
const client = new DaemonClient({
|
|
url: "ws://test",
|
|
logger,
|
|
reconnect: { enabled: false },
|
|
transportFactory: () => mock.transport,
|
|
});
|
|
clients.push(client);
|
|
|
|
const connectPromise = client.connect();
|
|
mock.triggerOpen();
|
|
await connectPromise;
|
|
|
|
const received: unknown[] = [];
|
|
const unsubscribe = client.on("agent_stream", (msg) => {
|
|
received.push(msg);
|
|
});
|
|
|
|
mock.triggerMessage(
|
|
wrapSessionMessage({
|
|
type: "agent_stream",
|
|
payload: {
|
|
agentId: "agent_cli",
|
|
timestamp: "2026-02-08T20:20:00.000Z",
|
|
event: {
|
|
type: "timeline",
|
|
provider: "codex",
|
|
item: {
|
|
type: "tool_call",
|
|
callId: "call_cli_stream",
|
|
name: "shell",
|
|
status: "running",
|
|
detail: {
|
|
type: "shell",
|
|
command: "pwd",
|
|
},
|
|
error: null,
|
|
},
|
|
},
|
|
},
|
|
})
|
|
);
|
|
|
|
unsubscribe();
|
|
|
|
expect(received).toHaveLength(1);
|
|
const streamMsg = received[0] as {
|
|
payload: {
|
|
event: {
|
|
type: "timeline";
|
|
item: {
|
|
type: "tool_call";
|
|
status: string;
|
|
error: unknown;
|
|
detail: {
|
|
type: string;
|
|
};
|
|
};
|
|
};
|
|
};
|
|
};
|
|
|
|
expect(streamMsg.payload.event.item.status).toBe("running");
|
|
expect(streamMsg.payload.event.item.error).toBeNull();
|
|
expect(streamMsg.payload.event.item.detail.type).toBe("shell");
|
|
expect(logger.warn).not.toHaveBeenCalled();
|
|
});
|
|
|
|
test("drops legacy agent_stream tool_call payloads and logs validation warning", async () => {
|
|
const logger = createMockLogger();
|
|
const mock = createMockTransport();
|
|
|
|
const client = new DaemonClient({
|
|
url: "ws://test",
|
|
logger,
|
|
reconnect: { enabled: false },
|
|
transportFactory: () => mock.transport,
|
|
});
|
|
clients.push(client);
|
|
|
|
const connectPromise = client.connect();
|
|
mock.triggerOpen();
|
|
await connectPromise;
|
|
|
|
const received: unknown[] = [];
|
|
const unsubscribe = client.on("agent_stream", (msg) => {
|
|
received.push(msg);
|
|
});
|
|
|
|
mock.triggerMessage(
|
|
wrapSessionMessage({
|
|
type: "agent_stream",
|
|
payload: {
|
|
agentId: "agent_cli",
|
|
timestamp: "2026-02-08T20:20:00.000Z",
|
|
event: {
|
|
type: "timeline",
|
|
provider: "codex",
|
|
item: {
|
|
type: "tool_call",
|
|
callId: "call_cli_stream_legacy",
|
|
name: "shell",
|
|
status: "inProgress",
|
|
detail: {
|
|
type: "unknown",
|
|
input: { command: "pwd" },
|
|
output: null,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
})
|
|
);
|
|
|
|
unsubscribe();
|
|
|
|
expect(received).toHaveLength(0);
|
|
expect(logger.warn).toHaveBeenCalled();
|
|
});
|
|
|
|
test("parses canonical fetch_agent_timeline_response payloads without crashing", async () => {
|
|
const logger = createMockLogger();
|
|
const mock = createMockTransport();
|
|
|
|
const client = new DaemonClient({
|
|
url: "ws://test",
|
|
logger,
|
|
reconnect: { enabled: false },
|
|
transportFactory: () => mock.transport,
|
|
});
|
|
clients.push(client);
|
|
|
|
const connectPromise = client.connect();
|
|
mock.triggerOpen();
|
|
await connectPromise;
|
|
|
|
const received: unknown[] = [];
|
|
const unsubscribe = client.on("fetch_agent_timeline_response", (msg) => {
|
|
received.push(msg);
|
|
});
|
|
|
|
mock.triggerMessage(
|
|
wrapSessionMessage({
|
|
type: "fetch_agent_timeline_response",
|
|
payload: {
|
|
requestId: "req-1",
|
|
agentId: "agent_cli",
|
|
direction: "tail",
|
|
projection: "projected",
|
|
epoch: "epoch-1",
|
|
reset: false,
|
|
staleCursor: false,
|
|
gap: false,
|
|
window: { minSeq: 1, maxSeq: 1, nextSeq: 2 },
|
|
startCursor: { epoch: "epoch-1", seq: 1 },
|
|
endCursor: { epoch: "epoch-1", seq: 1 },
|
|
hasOlder: false,
|
|
hasNewer: false,
|
|
entries: [
|
|
{
|
|
timestamp: "2026-02-08T20:20:00.000Z",
|
|
provider: "codex",
|
|
seqStart: 1,
|
|
seqEnd: 1,
|
|
sourceSeqRanges: [{ startSeq: 1, endSeq: 1 }],
|
|
collapsed: [],
|
|
item: {
|
|
type: "tool_call",
|
|
callId: "call_cli_snapshot",
|
|
name: "shell",
|
|
status: "running",
|
|
detail: {
|
|
type: "shell",
|
|
command: "pwd",
|
|
},
|
|
error: null,
|
|
},
|
|
},
|
|
],
|
|
error: null,
|
|
},
|
|
})
|
|
);
|
|
|
|
unsubscribe();
|
|
|
|
expect(received).toHaveLength(1);
|
|
const timelineMsg = received[0] as {
|
|
payload: {
|
|
entries: Array<{
|
|
item: {
|
|
type: "tool_call";
|
|
status: string;
|
|
error: unknown;
|
|
detail: {
|
|
type: string;
|
|
};
|
|
};
|
|
}>;
|
|
};
|
|
};
|
|
|
|
const firstEntry = timelineMsg.payload.entries[0];
|
|
expect(firstEntry?.item.type).toBe("tool_call");
|
|
if (firstEntry?.item.type === "tool_call") {
|
|
expect(firstEntry.item.status).toBe("running");
|
|
expect(firstEntry.item.error).toBeNull();
|
|
expect(firstEntry.item.detail.type).toBe("shell");
|
|
}
|
|
expect(logger.warn).not.toHaveBeenCalled();
|
|
});
|
|
|
|
test("drops invalid fetch_agent_timeline_response tool_call payloads and logs validation warning", async () => {
|
|
const logger = createMockLogger();
|
|
const mock = createMockTransport();
|
|
|
|
const client = new DaemonClient({
|
|
url: "ws://test",
|
|
logger,
|
|
reconnect: { enabled: false },
|
|
transportFactory: () => mock.transport,
|
|
});
|
|
clients.push(client);
|
|
|
|
const connectPromise = client.connect();
|
|
mock.triggerOpen();
|
|
await connectPromise;
|
|
|
|
const received: unknown[] = [];
|
|
const unsubscribe = client.on("fetch_agent_timeline_response", (msg) => {
|
|
received.push(msg);
|
|
});
|
|
|
|
mock.triggerMessage(
|
|
wrapSessionMessage({
|
|
type: "fetch_agent_timeline_response",
|
|
payload: {
|
|
requestId: "req-invalid",
|
|
agentId: "agent_cli",
|
|
direction: "tail",
|
|
projection: "projected",
|
|
epoch: "epoch-1",
|
|
reset: false,
|
|
staleCursor: false,
|
|
gap: false,
|
|
window: { minSeq: 1, maxSeq: 1, nextSeq: 2 },
|
|
startCursor: { epoch: "epoch-1", seq: 1 },
|
|
endCursor: { epoch: "epoch-1", seq: 1 },
|
|
hasOlder: false,
|
|
hasNewer: false,
|
|
entries: [
|
|
{
|
|
timestamp: "2026-02-08T20:20:00.000Z",
|
|
provider: "codex",
|
|
seqStart: 1,
|
|
seqEnd: 1,
|
|
sourceSeqRanges: [{ startSeq: 1, endSeq: 1 }],
|
|
collapsed: [],
|
|
item: {
|
|
type: "tool_call",
|
|
callId: "call_cli_invalid",
|
|
name: "shell",
|
|
status: "inProgress",
|
|
detail: {
|
|
type: "unknown",
|
|
input: { command: "pwd" },
|
|
output: null,
|
|
},
|
|
},
|
|
},
|
|
],
|
|
error: null,
|
|
},
|
|
})
|
|
);
|
|
|
|
unsubscribe();
|
|
|
|
expect(received).toHaveLength(0);
|
|
expect(logger.warn).toHaveBeenCalled();
|
|
});
|
|
});
|