import {  bootstrapRemoteBearerSession,  fetchRemoteEnvironmentDescriptor,  fetchRemoteSessionState,  issueRemoteWebSocketTicket,} from "@t3tools/client-runtime";import {  DesktopDiscoveredSshHostSchema,  DesktopSshBearerBootstrapInputSchema,  DesktopSshBearerRequestInputSchema,  DesktopSshEnvironmentEnsureInputSchema,  DesktopSshEnvironmentEnsureResultSchema,  DesktopSshEnvironmentTargetSchema,  DesktopSshHttpBaseUrlInputSchema,  DesktopSshPasswordPromptCancelledType,  DesktopSshPasswordPromptResolutionInputSchema,  ExecutionEnvironmentDescriptor,  AuthAccessTokenResult,  AuthSessionState,  AuthWebSocketTicketResult,} from "@t3tools/contracts";import { resolveLoopbackSshHttpBaseUrl } from "@t3tools/ssh/tunnel";import * as Data from "effect/Data";import * as Effect from "effect/Effect";import * as Schema from "effect/Schema"; import * as IpcChannels from "../channels.ts";import { makeIpcMethod } from "../DesktopIpc.ts";import * as DesktopSshEnvironment from "../../ssh/DesktopSshEnvironment.ts";import * as DesktopSshPasswordPrompts from "../../ssh/DesktopSshPasswordPrompts.ts"; type DesktopSshEnvironmentRequestOperation =  | "fetch-environment-descriptor"  | "bootstrap-bearer-session"  | "fetch-session-state"  | "issue-websocket-ticket"; export class DesktopSshEnvironmentRequestError extends Data.TaggedError(  "DesktopSshEnvironmentRequestError",)<{  readonly operation: DesktopSshEnvironmentRequestOperation;  readonly cause: unknown;}> {  override get message() {    return `SSH remote API request failed during ${this.operation}.`;  }} const withLoopbackSshApi =  <A, E, R>(    operation: DesktopSshEnvironmentRequestOperation,    use: (httpBaseUrl: string) => Effect.Effect<A, E, R>,  ) =>  (httpBaseUrl: string): Effect.Effect<A, DesktopSshEnvironmentRequestError, R> =>    resolveLoopbackSshHttpBaseUrl(httpBaseUrl).pipe(      Effect.flatMap(use),      Effect.mapError((cause) => new DesktopSshEnvironmentRequestError({ operation, cause })),    ); export const discoverSshHosts = makeIpcMethod({  channel: IpcChannels.DISCOVER_SSH_HOSTS_CHANNEL,  payload: Schema.Void,  result: Schema.Array(DesktopDiscoveredSshHostSchema),  handler: Effect.fn("desktop.ipc.sshEnvironment.discoverHosts")(function* () {    const sshEnvironment = yield* DesktopSshEnvironment.DesktopSshEnvironment;    return yield* sshEnvironment.discoverHosts();  }),}); export const ensureSshEnvironment = makeIpcMethod({  channel: IpcChannels.ENSURE_SSH_ENVIRONMENT_CHANNEL,  payload: DesktopSshEnvironmentEnsureInputSchema,  result: DesktopSshEnvironmentEnsureResultSchema,  handler: Effect.fn("desktop.ipc.sshEnvironment.ensureEnvironment")(function* ({    target,    options,  }) {    const sshEnvironment = yield* DesktopSshEnvironment.DesktopSshEnvironment;    return yield* sshEnvironment.ensureEnvironment(target, options).pipe(      Effect.catch((error) =>        DesktopSshEnvironment.isDesktopSshPasswordPromptCancellation(error)          ? Effect.succeed({              type: DesktopSshPasswordPromptCancelledType,              message: error.message,            })          : Effect.fail(error),      ),    );  }),}); export const disconnectSshEnvironment = makeIpcMethod({  channel: IpcChannels.DISCONNECT_SSH_ENVIRONMENT_CHANNEL,  payload: DesktopSshEnvironmentTargetSchema,  result: Schema.Void,  handler: Effect.fn("desktop.ipc.sshEnvironment.disconnectEnvironment")(function* (target) {    const sshEnvironment = yield* DesktopSshEnvironment.DesktopSshEnvironment;    yield* sshEnvironment.disconnectEnvironment(target);  }),}); export const fetchSshEnvironmentDescriptor = makeIpcMethod({  channel: IpcChannels.FETCH_SSH_ENVIRONMENT_DESCRIPTOR_CHANNEL,  payload: DesktopSshHttpBaseUrlInputSchema,  result: ExecutionEnvironmentDescriptor,  handler: Effect.fn("desktop.ipc.sshEnvironment.fetchDescriptor")(function* ({ httpBaseUrl }) {    return yield* withLoopbackSshApi("fetch-environment-descriptor", (resolvedHttpBaseUrl) =>      fetchRemoteEnvironmentDescriptor({ httpBaseUrl: resolvedHttpBaseUrl }),    )(httpBaseUrl);  }),}); export const bootstrapSshBearerSession = makeIpcMethod({  channel: IpcChannels.BOOTSTRAP_SSH_BEARER_SESSION_CHANNEL,  payload: DesktopSshBearerBootstrapInputSchema,  result: AuthAccessTokenResult,  handler: Effect.fn("desktop.ipc.sshEnvironment.bootstrapBearerSession")(function* ({    httpBaseUrl,    credential,  }) {    return yield* withLoopbackSshApi("bootstrap-bearer-session", (resolvedHttpBaseUrl) =>      bootstrapRemoteBearerSession({        httpBaseUrl: resolvedHttpBaseUrl,        credential,      }),    )(httpBaseUrl);  }),}); export const fetchSshSessionState = makeIpcMethod({  channel: IpcChannels.FETCH_SSH_SESSION_STATE_CHANNEL,  payload: DesktopSshBearerRequestInputSchema,  result: AuthSessionState,  handler: Effect.fn("desktop.ipc.sshEnvironment.fetchSessionState")(function* ({    httpBaseUrl,    bearerToken,  }) {    return yield* withLoopbackSshApi("fetch-session-state", (resolvedHttpBaseUrl) =>      fetchRemoteSessionState({        httpBaseUrl: resolvedHttpBaseUrl,        bearerToken,      }),    )(httpBaseUrl);  }),}); export const issueSshWebSocketTicket = makeIpcMethod({  channel: IpcChannels.ISSUE_SSH_WEBSOCKET_TOKEN_CHANNEL,  payload: DesktopSshBearerRequestInputSchema,  result: AuthWebSocketTicketResult,  handler: Effect.fn("desktop.ipc.sshEnvironment.issueWebSocketTicket")(function* ({    httpBaseUrl,    bearerToken,  }) {    return yield* withLoopbackSshApi("issue-websocket-ticket", (resolvedHttpBaseUrl) =>      issueRemoteWebSocketTicket({        httpBaseUrl: resolvedHttpBaseUrl,        bearerToken,      }),    )(httpBaseUrl);  }),}); export const resolveSshPasswordPrompt = makeIpcMethod({  channel: IpcChannels.RESOLVE_SSH_PASSWORD_PROMPT_CHANNEL,  payload: DesktopSshPasswordPromptResolutionInputSchema,  result: Schema.Void,  handler: Effect.fn("desktop.ipc.sshEnvironment.resolvePasswordPrompt")(function* ({    requestId,    password,  }) {    const prompts = yield* DesktopSshPasswordPrompts.DesktopSshPasswordPrompts;    yield* prompts.resolve({ requestId, password });  }),});