import {  ConnectionBlockedError,  ConnectionTransientError,} from "@t3tools/client-runtime/connection";import {  AuthStandardClientScopes,  DesktopSshPasswordPromptCancellationError,  EnvironmentId,  type DesktopBridge,  type DesktopSshEnvironmentTarget,} from "@t3tools/contracts";import { describe, expect, it } from "@effect/vitest";import * as Effect from "effect/Effect"; import { provisionDesktopSshEnvironment } from "./platform.ts"; const TARGET: DesktopSshEnvironmentTarget = {  alias: "devbox",  hostname: "devbox.example.test",  username: "developer",  port: 22,}; function makeBridge(  calls: string[],  options?: { readonly descriptorError?: unknown; readonly ensureError?: unknown },): DesktopBridge {  return {    ensureSshEnvironment: async (target: DesktopSshEnvironmentTarget) => {      calls.push("ensure");      if (options?.ensureError !== undefined) {        throw options.ensureError;      }      return {        target,        httpBaseUrl: "http://127.0.0.1:3201/",        wsBaseUrl: "ws://127.0.0.1:3201/",        pairingToken: "pairing-token",      };    },    fetchSshEnvironmentDescriptor: async () => {      calls.push("descriptor");      if (options?.descriptorError !== undefined) {        throw options.descriptorError;      }      return {        environmentId: EnvironmentId.make("environment-ssh"),        label: "SSH environment",        platform: {          os: "linux",          arch: "x64",        },        serverVersion: "0.0.0-test",        capabilities: {          repositoryIdentity: true,        },      };    },    bootstrapSshBearerSession: async () => {      calls.push("token");      return {        access_token: "bearer-token",        issued_token_type: "urn:ietf:params:oauth:token-type:access_token",        token_type: "Bearer",        expires_in: 3_600,        scope: AuthStandardClientScopes.join(" "),      };    },  } as unknown as DesktopBridge;} describe("desktop SSH pairing", () => {  it.effect("fetches the descriptor before consuming the one-time credential", () =>    Effect.gen(function* () {      const calls: string[] = [];       const provisioned = yield* provisionDesktopSshEnvironment(makeBridge(calls), TARGET);       expect(provisioned.environmentId).toBe(EnvironmentId.make("environment-ssh"));      expect(calls).toEqual(["ensure", "descriptor", "token"]);    }),  );   it.effect("does not consume the credential when descriptor discovery fails", () =>    Effect.gen(function* () {      const calls: string[] = [];       yield* provisionDesktopSshEnvironment(        makeBridge(calls, { descriptorError: new Error("descriptor unavailable") }),        TARGET,      ).pipe(Effect.flip);       expect(calls).toEqual(["ensure", "descriptor"]);    }),  );   it.effect("preserves SSH preparation causes without exposing their message", () =>    Effect.gen(function* () {      const cause = new Error("descriptor response contained a private endpoint");       const error = yield* provisionDesktopSshEnvironment(        makeBridge([], { descriptorError: cause }),        TARGET,      ).pipe(Effect.flip);       expect(error).toBeInstanceOf(ConnectionTransientError);      expect(error.detail).toBe("Could not prepare the SSH environment.");      expect(error.message).toBe("Connection attempt failed (remote-unavailable).");      expect(error.message).not.toContain(cause.message);      expect(error.cause).toBe(cause);    }),  );   it.effect("classifies password prompt cancellation from its tag and preserves its cause", () =>    Effect.gen(function* () {      const promptCause = new Error("password prompt closed");      const cancellation = new DesktopSshPasswordPromptCancellationError({        reason: "window-closed",        requestId: "prompt-1",        destination: "developer@devbox.example.test",        cause: promptCause,      });       const error = yield* provisionDesktopSshEnvironment(        makeBridge([], { ensureError: cancellation }),        TARGET,      ).pipe(Effect.flip);       expect(error).toBeInstanceOf(ConnectionBlockedError);      expect(error.detail).toBe(        "SSH authentication did not complete for developer@devbox.example.test.",      );      expect(error.message).toBe("Connection attempt blocked (authentication).");      expect(error.cause).toBe(cancellation);      expect(cancellation.cause).toBe(promptCause);    }),  );   it.effect("does not infer cancellation from an unstructured error message", () =>    Effect.gen(function* () {      const cause = new Error("remote operation was cancelled");       const error = yield* provisionDesktopSshEnvironment(        makeBridge([], { ensureError: cause }),        TARGET,      ).pipe(Effect.flip);       expect(error).toBeInstanceOf(ConnectionTransientError);      expect(error.cause).toBe(cause);    }),  );});