import { EnvironmentId } from "@t3tools/contracts";import { describe, expect, it, vi } from "vitest"; import { createEnvironmentConnection } from "./connection";import type { WsRpcClient } from "~/rpc/wsRpcClient"; function createTestClient(options?: {  readonly getSnapshot?: () => Promise<{ readonly snapshotSequence: number }>;  readonly replayEvents?: () => Promise<ReadonlyArray<any>>;}) {  const lifecycleListeners = new Set<(event: any) => void>();  const configListeners = new Set<(event: any) => void>();  const terminalListeners = new Set<(event: any) => void>();  let domainResubscribe: (() => void) | undefined;   const getSnapshot = vi.fn(    options?.getSnapshot ??      (async () =>        ({          snapshotSequence: 1,          projects: [],          threads: [],        }) as any),  );  const replayEvents = vi.fn(options?.replayEvents ?? (async () => []));   const client = {    dispose: vi.fn(async () => undefined),    reconnect: vi.fn(async () => undefined),    server: {      getConfig: vi.fn(async () => ({        environment: {          environmentId: EnvironmentId.makeUnsafe("env-1"),        },      })),      subscribeConfig: (listener: (event: any) => void) => {        configListeners.add(listener);        return () => configListeners.delete(listener);      },      subscribeLifecycle: (listener: (event: any) => void) => {        lifecycleListeners.add(listener);        return () => lifecycleListeners.delete(listener);      },      subscribeAuthAccess: () => () => undefined,      refreshProviders: vi.fn(async () => undefined),      upsertKeybinding: vi.fn(async () => undefined),      getSettings: vi.fn(async () => undefined),      updateSettings: vi.fn(async () => undefined),    },    orchestration: {      getSnapshot,      dispatchCommand: vi.fn(async () => undefined),      getTurnDiff: vi.fn(async () => undefined),      getFullThreadDiff: vi.fn(async () => undefined),      replayEvents,      onDomainEvent: vi.fn((_: (event: any) => void, options?: { onResubscribe?: () => void }) => {        domainResubscribe = options?.onResubscribe;        return () => {          if (domainResubscribe === options?.onResubscribe) {            domainResubscribe = undefined;          }        };      }),    },    terminal: {      open: vi.fn(async () => undefined),      write: vi.fn(async () => undefined),      resize: vi.fn(async () => undefined),      clear: vi.fn(async () => undefined),      restart: vi.fn(async () => undefined),      close: vi.fn(async () => undefined),      onEvent: (listener: (event: any) => void) => {        terminalListeners.add(listener);        return () => terminalListeners.delete(listener);      },    },    projects: {      searchEntries: vi.fn(async () => []),      writeFile: vi.fn(async () => undefined),    },    shell: {      openInEditor: vi.fn(async () => undefined),    },    git: {      pull: vi.fn(async () => undefined),      refreshStatus: vi.fn(async () => undefined),      onStatus: vi.fn(() => () => undefined),      runStackedAction: vi.fn(async () => ({}) as any),      listBranches: vi.fn(async () => []),      createWorktree: vi.fn(async () => undefined),      removeWorktree: vi.fn(async () => undefined),      createBranch: vi.fn(async () => undefined),      checkout: vi.fn(async () => undefined),      init: vi.fn(async () => undefined),      resolvePullRequest: vi.fn(async () => undefined),      preparePullRequestThread: vi.fn(async () => undefined),    },  } as unknown as WsRpcClient;   return {    client,    getSnapshot,    replayEvents,    emitWelcome: (environmentId: EnvironmentId) => {      for (const listener of lifecycleListeners) {        listener({          type: "welcome",          payload: {            environment: {              environmentId,            },          },        });      }    },    emitConfigSnapshot: (environmentId: EnvironmentId) => {      for (const listener of configListeners) {        listener({          type: "snapshot",          config: {            environment: {              environmentId,            },          },        });      }    },    triggerDomainResubscribe: () => {      domainResubscribe?.();    },  };} describe("createEnvironmentConnection", () => {  it("bootstraps a snapshot immediately for a new connection", async () => {    const environmentId = EnvironmentId.makeUnsafe("env-1");    const { client, getSnapshot } = createTestClient();    const syncSnapshot = vi.fn();     const connection = createEnvironmentConnection({      kind: "saved",      knownEnvironment: {        id: "env-1",        label: "Remote env",        source: "manual",        target: {          httpBaseUrl: "http://example.test",          wsBaseUrl: "ws://example.test",        },        environmentId,      },      client,      applyEventBatch: vi.fn(),      syncSnapshot,      applyTerminalEvent: vi.fn(),    });     await Promise.resolve();    await Promise.resolve();     expect(getSnapshot).toHaveBeenCalledTimes(1);    expect(syncSnapshot).toHaveBeenCalledWith(      expect.objectContaining({ snapshotSequence: 1 }),      environmentId,    );     await connection.dispose();  });   it("rejects welcome/config identity drift", async () => {    const environmentId = EnvironmentId.makeUnsafe("env-1");    const { client, emitWelcome } = createTestClient();     const connection = createEnvironmentConnection({      kind: "saved",      knownEnvironment: {        id: "env-1",        label: "Remote env",        source: "manual",        target: {          httpBaseUrl: "http://example.test",          wsBaseUrl: "ws://example.test",        },        environmentId,      },      client,      applyEventBatch: vi.fn(),      syncSnapshot: vi.fn(),      applyTerminalEvent: vi.fn(),    });     expect(() => emitWelcome(EnvironmentId.makeUnsafe("env-2"))).toThrow(      "Environment connection env-1 changed identity to env-2 via server lifecycle welcome.",    );     await connection.dispose();  });   it("rejects ensureBootstrapped when snapshot recovery fails", async () => {    const environmentId = EnvironmentId.makeUnsafe("env-1");    const snapshotError = new Error("snapshot failed");    const { client } = createTestClient({      getSnapshot: async () => {        throw snapshotError;      },    });     const connection = createEnvironmentConnection({      kind: "saved",      knownEnvironment: {        id: "env-1",        label: "Remote env",        source: "manual",        target: {          httpBaseUrl: "http://example.test",          wsBaseUrl: "ws://example.test",        },        environmentId,      },      client,      applyEventBatch: vi.fn(),      syncSnapshot: vi.fn(),      applyTerminalEvent: vi.fn(),    });     await expect(connection.ensureBootstrapped()).rejects.toThrow("snapshot failed");     await connection.dispose();  });   it("retries replay recovery after transport disconnects during resubscribe", async () => {    const environmentId = EnvironmentId.makeUnsafe("env-1");    let replayAttempts = 0;    const applyEventBatch = vi.fn();    const { client, replayEvents, triggerDomainResubscribe } = createTestClient({      replayEvents: async () => {        replayAttempts += 1;        if (replayAttempts === 1) {          throw new Error("SocketCloseError: 1006");        }         return [          {            sequence: 2,            type: "thread.created",            payload: {},          },        ];      },    });     const connection = createEnvironmentConnection({      kind: "saved",      knownEnvironment: {        id: "env-1",        label: "Remote env",        source: "manual",        target: {          httpBaseUrl: "http://example.test",          wsBaseUrl: "ws://example.test",        },        environmentId,      },      client,      applyEventBatch,      syncSnapshot: vi.fn(),      applyTerminalEvent: vi.fn(),    });     await Promise.resolve();    await Promise.resolve();     triggerDomainResubscribe();     await vi.waitFor(() => {      expect(replayEvents).toHaveBeenCalledTimes(2);      expect(applyEventBatch).toHaveBeenCalledWith(        [          expect.objectContaining({            sequence: 2,          }),        ],        environmentId,      );    });     await connection.dispose();  });  it("swallows replay recovery failures triggered by resubscribe", async () => {    const environmentId = EnvironmentId.makeUnsafe("env-1");    const snapshotError = new Error("snapshot failed");    let snapshotCalls = 0;    const { client, triggerDomainResubscribe } = createTestClient({      getSnapshot: async () => {        snapshotCalls += 1;        if (snapshotCalls === 1) {          return {            snapshotSequence: 1,            projects: [],            threads: [],          } as any;        }         throw snapshotError;      },      replayEvents: async () => {        throw new Error("SocketCloseError: 1006");      },    });     const connection = createEnvironmentConnection({      kind: "saved",      knownEnvironment: {        id: "env-1",        label: "Remote env",        source: "manual",        target: {          httpBaseUrl: "http://example.test",          wsBaseUrl: "ws://example.test",        },        environmentId,      },      client,      applyEventBatch: vi.fn(),      syncSnapshot: vi.fn(),      applyTerminalEvent: vi.fn(),    });     await Promise.resolve();    await Promise.resolve();     const onUnhandledRejection = vi.fn();    process.on("unhandledRejection", onUnhandledRejection);     try {      triggerDomainResubscribe();      await new Promise((resolve) => setTimeout(resolve, 0));      await new Promise((resolve) => setTimeout(resolve, 0));    } finally {      process.off("unhandledRejection", onUnhandledRejection);    }     expect(onUnhandledRejection).not.toHaveBeenCalled();     await connection.dispose();  });});