import {  DesktopCloudAuthFetchInputSchema,  DesktopCloudAuthFetchResultSchema,} from "@t3tools/contracts";import {  clerkFrontendApiHostnameFromPublishableKey,  isAllowedClerkFrontendApiHostname,} from "@t3tools/shared/relayAuth";import * as Data from "effect/Data";import * as Effect from "effect/Effect";import { identity } from "effect/Function";import * as Layer from "effect/Layer";import * as Option from "effect/Option";import * as Schema from "effect/Schema";import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http"; import * as DesktopCloudAuth from "../../app/DesktopCloudAuth.ts";import * as DesktopCloudAuthTokenStore from "../../app/DesktopCloudAuthTokenStore.ts";import * as IpcChannels from "../channels.ts";import { makeIpcMethod } from "../DesktopIpc.ts"; declare const __T3CODE_BUILD_CLERK_PUBLISHABLE_KEY__: string | undefined; export class DesktopCloudAuthFetchError extends Data.TaggedError("DesktopCloudAuthFetchError")<{  readonly reason: string;  readonly cause?: unknown;}> {  override get message() {    return this.reason;  }} function configuredClerkFrontendApiHostname(): string | null {  const publishableKey =    process.env.T3CODE_CLERK_PUBLISHABLE_KEY?.trim() ||    (typeof __T3CODE_BUILD_CLERK_PUBLISHABLE_KEY__ === "undefined"      ? ""      : __T3CODE_BUILD_CLERK_PUBLISHABLE_KEY__.trim());  if (!publishableKey) return null;   return clerkFrontendApiHostnameFromPublishableKey(publishableKey);} const allowedClerkFrontendApiHosts = (hostname: string): boolean =>  isAllowedClerkFrontendApiHostname(hostname, configuredClerkFrontendApiHostname()); export function validateClerkFrontendApiUrl(rawUrl: string): URL {  const url = new URL(rawUrl);  if (url.protocol !== "https:" || !allowedClerkFrontendApiHosts(url.hostname)) {    throw new DesktopCloudAuthFetchError({      reason: "Desktop cloud auth fetch is restricted to Clerk Frontend API HTTPS hosts.",    });  }  return url;} function executeCloudAuthFetch(url: URL, input: typeof DesktopCloudAuthFetchInputSchema.Type) {  return Effect.gen(function* () {    const method = (input.method ?? "GET") as "GET" | "POST";    const headers = new Headers(input.headers);    const response = yield* HttpClientRequest.make(method)(url).pipe(      HttpClientRequest.setHeaders(Object.fromEntries(headers.entries())),      input.body === undefined        ? identity        : HttpClientRequest.bodyText(input.body, headers.get("content-type") ?? undefined),      HttpClient.execute,      Effect.mapError(        (cause) =>          new DesktopCloudAuthFetchError({            reason: "Desktop cloud auth fetch failed to execute.",            cause,          }),      ),    );     const body = yield* response.text.pipe(      Effect.mapError(        (cause) =>          new DesktopCloudAuthFetchError({            reason: "Desktop cloud auth fetch response could not be read.",            cause,          }),      ),    );     return {      ok: response.status >= 200 && response.status < 300,      status: response.status,      statusText: "",      headers: response.headers,      body,    };  });} const electronNetFetchLayer = Layer.unwrap(  Effect.gen(function* () {    const electronFetch = yield* Effect.promise(async () => {      const electron = (await import("electron")) as {        readonly net?: { readonly fetch?: typeof globalThis.fetch };      };      return typeof electron.net?.fetch === "function"        ? electron.net.fetch.bind(electron.net)        : null;    }).pipe(Effect.catchCause(() => Effect.succeed(null)));     if (!electronFetch) {      yield* Effect.logWarning(        "electron.net.fetch is not available, falling back to global fetch. This may cause unexpected errors.",      );    }     return FetchHttpClient.layer.pipe(      Layer.provide(Layer.succeed(FetchHttpClient.Fetch, electronFetch ?? globalThis.fetch)),    );  }),); export const createCloudAuthRequest = makeIpcMethod({  channel: IpcChannels.CREATE_CLOUD_AUTH_REQUEST_CHANNEL,  payload: Schema.Void,  result: Schema.String,  handler: Effect.fn("desktop.ipc.cloudAuth.createRequest")(function* () {    const cloudAuth = yield* DesktopCloudAuth.DesktopCloudAuth;    return yield* cloudAuth.createRequest;  }),}); export const getCloudAuthToken = makeIpcMethod({  channel: IpcChannels.GET_CLOUD_AUTH_TOKEN_CHANNEL,  payload: Schema.Void,  result: Schema.NullOr(Schema.String),  handler: Effect.fn("desktop.ipc.cloudAuth.getToken")(function* () {    const tokenStore = yield* DesktopCloudAuthTokenStore.DesktopCloudAuthTokenStore;    return Option.getOrNull(yield* tokenStore.get);  }),}); export const setCloudAuthToken = makeIpcMethod({  channel: IpcChannels.SET_CLOUD_AUTH_TOKEN_CHANNEL,  payload: Schema.String,  result: Schema.Boolean,  handler: Effect.fn("desktop.ipc.cloudAuth.setToken")(function* (token) {    const tokenStore = yield* DesktopCloudAuthTokenStore.DesktopCloudAuthTokenStore;    return yield* tokenStore.set(token);  }),}); export const clearCloudAuthToken = makeIpcMethod({  channel: IpcChannels.CLEAR_CLOUD_AUTH_TOKEN_CHANNEL,  payload: Schema.Void,  result: Schema.Void,  handler: Effect.fn("desktop.ipc.cloudAuth.clearToken")(function* () {    const tokenStore = yield* DesktopCloudAuthTokenStore.DesktopCloudAuthTokenStore;    yield* tokenStore.clear;  }),}); export const fetchCloudAuth = makeIpcMethod({  channel: IpcChannels.FETCH_CLOUD_AUTH_CHANNEL,  payload: DesktopCloudAuthFetchInputSchema,  result: DesktopCloudAuthFetchResultSchema,  handler: Effect.fn("desktop.ipc.cloudAuth.fetch")(function* (input) {    const url = yield* Effect.try({      try: () => validateClerkFrontendApiUrl(input.url),      catch: (cause) =>        cause instanceof DesktopCloudAuthFetchError          ? cause          : new DesktopCloudAuthFetchError({              reason: "Desktop cloud auth fetch received an invalid URL.",              cause,            }),    });     return yield* executeCloudAuthFetch(url, input).pipe(Effect.provide(electronNetFetchLayer));  }),});