| import { describe, expect, it, vi } from "vitest"; |
| import { WebSocket } from "ws"; |
| import { createDeferred, withTestTimeout } from "../../../test/helpers/promise.js"; |
| import { type NodeInvokeResult, NodeRegistry } from "../node-registry.js"; |
| import { createNodeRelayBackend } from "./node-relay.js"; |
|
|
| describe("createNodeRelayBackend", () => { |
| it("waits for pairing validation and dispatch instead of the final node exit", async () => { |
| const pairingState = createDeferred<{ identity: string; generation: string }>(); |
| const frames: string[] = []; |
| const resolveCurrentPairingState = vi.fn(async () => await pairingState.promise); |
| const registry = new NodeRegistry({ |
| resolveCurrentPairingState, |
| }); |
| registry.register( |
| { |
| connId: "conn-validated", |
| usesSharedGatewayAuth: false, |
| socket: { |
| readyState: WebSocket.OPEN, |
| send(frame: unknown) { |
| if (typeof frame === "string") { |
| frames.push(frame); |
| } |
| }, |
| }, |
| connect: { |
| client: { id: "openclaw-node-host", mode: "node" }, |
| device: { id: "node-validated" }, |
| commands: ["codex.terminal.resume.v1"], |
| }, |
| } as never, |
| { pairingIdentity: "identity-a", pairingGeneration: "generation-a" }, |
| ); |
|
|
| const opening = createNodeRelayBackend({ |
| registry, |
| isDispatchAuthorized: () => true, |
| nodeId: "node-validated", |
| expectedConnId: "conn-validated", |
| expectedPairingGeneration: "generation-a", |
| command: "codex.terminal.resume.v1", |
| params: { threadId: "thread" }, |
| }); |
| await vi.waitFor(() => |
| expect(resolveCurrentPairingState).toHaveBeenCalledWith("node-validated"), |
| ); |
| expect(frames).toEqual([]); |
|
|
| pairingState.resolve({ identity: "identity-a", generation: "generation-a" }); |
| const backend = await withTestTimeout( |
| opening, |
| 500, |
| "timed out waiting for node terminal dispatch readiness", |
| ); |
|
|
| expect(JSON.parse(frames[0] ?? "{}")).toMatchObject({ |
| event: "node.invoke.request", |
| payload: { |
| nodeId: "node-validated", |
| command: "codex.terminal.resume.v1", |
| }, |
| }); |
| backend.kill(); |
| registry.unregister("conn-validated"); |
| }); |
|
|
| it.each([ |
| "codex.terminal.resume.v1", |
| "codex.terminal.start.v1", |
| "anthropic.claude.terminal.start.v1", |
| ])("%s relays progress, input, resize, cancellation, and exit", async (command) => { |
| const invokeResult = createDeferred<NodeInvokeResult>(); |
| let onProgress: ((chunk: string) => void) | undefined; |
| let signal: AbortSignal | undefined; |
| const sendInvokeInput = vi.fn(); |
| const registry = { |
| invoke: vi.fn( |
| (params: { |
| onDispatchReady?: (id: string) => void; |
| onProgress?: (chunk: string) => void; |
| signal?: AbortSignal; |
| }) => { |
| onProgress = params.onProgress; |
| signal = params.signal; |
| params.onDispatchReady?.("invoke-1"); |
| return invokeResult.promise; |
| }, |
| ), |
| sendInvokeInput, |
| } as unknown as NodeRegistry; |
| const backend = await createNodeRelayBackend({ |
| registry, |
| isDispatchAuthorized: () => true, |
| nodeId: "node-1", |
| expectedConnId: "conn-1", |
| command, |
| params: command.includes(".start.") |
| ? { cwd: "/node/work", cols: 80, rows: 24 } |
| : { threadId: "thread" }, |
| }); |
| const data = vi.fn(); |
| const exit = vi.fn(); |
| backend.onData(data); |
| backend.onExit(exit); |
|
|
| onProgress?.(""); |
| onProgress?.("hello"); |
| expect(data).toHaveBeenCalledWith("hello"); |
| backend.write("keys"); |
| backend.resize(100, 30); |
| expect(sendInvokeInput).toHaveBeenNthCalledWith(1, "invoke-1", { |
| kind: "data", |
| data: "keys", |
| }); |
| expect(sendInvokeInput).toHaveBeenNthCalledWith(2, "invoke-1", { |
| kind: "resize", |
| cols: 100, |
| rows: 30, |
| }); |
|
|
| invokeResult.resolve({ ok: true, payloadJSON: JSON.stringify({ exitCode: 7, signal: 15 }) }); |
| await vi.waitFor(() => expect(exit).toHaveBeenCalledWith({ exitCode: 7, signal: 15 })); |
|
|
| backend.kill(); |
| expect(signal?.aborted).toBe(true); |
| }); |
|
|
| it("maps node disconnect failures to terminal errors", async () => { |
| const registry = { |
| invoke: vi.fn((params: { onDispatchReady?: (id: string) => void }) => { |
| params.onDispatchReady?.("invoke-2"); |
| return Promise.resolve({ |
| ok: false, |
| error: { code: "NOT_CONNECTED", message: "node disconnected" }, |
| }); |
| }), |
| sendInvokeInput: vi.fn(), |
| } as unknown as NodeRegistry; |
| const backend = await createNodeRelayBackend({ |
| registry, |
| isDispatchAuthorized: () => true, |
| nodeId: "node-1", |
| expectedConnId: "conn-1", |
| command: "anthropic.claude.terminal.resume.v1", |
| params: {}, |
| }); |
| const exit = vi.fn(); |
| backend.onExit(exit); |
| await vi.waitFor(() => |
| expect(exit).toHaveBeenCalledWith({ error: "NOT_CONNECTED: node disconnected" }), |
| ); |
| }); |
|
|
| it("pins the expected connection and reports route changes through onExit", async () => { |
| const invoke = vi.fn((params: { onDispatchReady?: (id: string) => void }) => { |
| params.onDispatchReady?.("invoke-route-changed"); |
| return Promise.resolve({ |
| ok: false, |
| error: { code: "ROUTE_CHANGED", message: "node connection changed before dispatch" }, |
| }); |
| }); |
| const registry = { invoke, sendInvokeInput: vi.fn() } as unknown as NodeRegistry; |
| const backend = await createNodeRelayBackend({ |
| registry, |
| isDispatchAuthorized: () => true, |
| nodeId: "node-1", |
| expectedConnId: "conn-authorized", |
| expectedPairingGeneration: "generation-authorized", |
| command: "codex.terminal.resume.v1", |
| params: {}, |
| }); |
| const exit = vi.fn(); |
| backend.onExit(exit); |
|
|
| expect(invoke).toHaveBeenCalledWith( |
| expect.objectContaining({ |
| nodeId: "node-1", |
| expectedConnId: "conn-authorized", |
| expectedPairingGeneration: "generation-authorized", |
| }), |
| ); |
| await vi.waitFor(() => |
| expect(exit).toHaveBeenCalledWith({ |
| error: "ROUTE_CHANGED: node connection changed before dispatch", |
| }), |
| ); |
| }); |
|
|
| it("bounds output buffered before onData registration", async () => { |
| let onProgress: ((chunk: string) => void) | undefined; |
| const registry = { |
| invoke: vi.fn( |
| (params: { |
| onDispatchReady?: (id: string) => void; |
| onProgress?: (chunk: string) => void; |
| }) => { |
| onProgress = params.onProgress; |
| params.onDispatchReady?.("invoke-buffered"); |
| return Promise.resolve({ ok: true }); |
| }, |
| ), |
| sendInvokeInput: vi.fn(), |
| } as unknown as NodeRegistry; |
| const backend = await createNodeRelayBackend({ |
| registry, |
| isDispatchAuthorized: () => true, |
| nodeId: "node-1", |
| expectedConnId: "conn-1", |
| command: "codex.terminal.resume.v1", |
| params: {}, |
| }); |
| const chunkChars = 256 * 1024; |
| onProgress?.("a".repeat(chunkChars)); |
| onProgress?.("b".repeat(chunkChars)); |
| onProgress?.("c".repeat(chunkChars)); |
| const data = vi.fn(); |
|
|
| backend.onData(data); |
|
|
| expect(data.mock.calls.map(([chunk]) => chunk)).toEqual([ |
| "b".repeat(chunkChars), |
| "c".repeat(chunkChars), |
| ]); |
|
|
| const surrogateBackend = await createNodeRelayBackend({ |
| registry, |
| isDispatchAuthorized: () => true, |
| nodeId: "node-1", |
| expectedConnId: "conn-1", |
| command: "codex.terminal.resume.v1", |
| params: {}, |
| }); |
| const capChars = 512 * 1024; |
| onProgress?.(`x😀${"y".repeat(capChars - 1)}`); |
| const surrogateData = vi.fn(); |
|
|
| surrogateBackend.onData(surrogateData); |
|
|
| expect(surrogateData).toHaveBeenCalledWith("y".repeat(capChars - 1)); |
| }); |
|
|
| it("never splits a surrogate pair at the input chunk boundary", async () => { |
| const sendInvokeInput = vi.fn(); |
| const registry = { |
| invoke: vi.fn((params: { onDispatchReady?: (id: string) => void }) => { |
| params.onDispatchReady?.("invoke-input"); |
| return Promise.resolve({ ok: true }); |
| }), |
| sendInvokeInput, |
| } as unknown as NodeRegistry; |
| const backend = await createNodeRelayBackend({ |
| registry, |
| isDispatchAuthorized: () => true, |
| nodeId: "node-1", |
| expectedConnId: "conn-1", |
| command: "codex.terminal.resume.v1", |
| params: {}, |
| }); |
| const input = `${"a".repeat(2047)}😀b`; |
|
|
| backend.write(input); |
|
|
| const chunks = sendInvokeInput.mock.calls.map( |
| (call) => (call[1] as { kind: "data"; data: string }).data, |
| ); |
| expect(chunks.join("")).toBe(input); |
| expect(chunks).toEqual(["a".repeat(2047), "😀b"]); |
| }); |
| }); |
|
|
