import { Option, Schema } from "effect";import {  normalizeExecutorServerConnection,  type ExecutorServerConnection,  type ExecutorServerConnectionInput,} from "./server-connection"; export const EXECUTOR_SERVER_PROFILES_STORAGE_KEY = "executor.serverConnections.v1"; export interface ExecutorServerProfilesSnapshot {  readonly activeKey: string | null;  readonly profiles: readonly ExecutorServerConnection[];} export interface ExecutorServerProfileStorage {  readonly getItem: (key: string) => string | null;  readonly setItem: (key: string, value: string) => void;} const PersistedBasicAuth = Schema.Struct({  kind: Schema.Literal("basic"),  username: Schema.optional(Schema.String),  password: Schema.String,}); const PersistedBearerAuth = Schema.Struct({  kind: Schema.Literal("bearer"),  token: Schema.String,}); const PersistedAuth = Schema.Union([PersistedBasicAuth, PersistedBearerAuth]); const PersistedConnection = Schema.Struct({  kind: Schema.optional(Schema.Literals(["http", "desktop-sidecar"])),  key: Schema.optional(Schema.String),  origin: Schema.optional(Schema.String),  apiBaseUrl: Schema.optional(Schema.String),  displayName: Schema.optional(Schema.String),  auth: Schema.optional(PersistedAuth),}); const PersistedProfiles = Schema.Struct({  version: Schema.Literal(1),  activeKey: Schema.optional(Schema.NullOr(Schema.String)),  profiles: Schema.Array(PersistedConnection),}); const decodeProfilesJson = Schema.decodeUnknownOption(Schema.fromJsonString(PersistedProfiles)); const EMPTY_PROFILES: ExecutorServerProfilesSnapshot = {  activeKey: null,  profiles: [],}; const hasHttpScheme = (value: string): boolean => /^https?:\/\//.test(value.trim()); const canParseOrigin = (origin: string | undefined): boolean => {  if (origin === undefined) return true;  const trimmed = origin.trim();  if (!trimmed) return true;  return URL.canParse(hasHttpScheme(trimmed) ? trimmed : `http://${trimmed}`);}; const canParseApiBaseUrl = (apiBaseUrl: string | undefined): boolean => {  if (apiBaseUrl === undefined) return true;  const trimmed = apiBaseUrl.trim();  if (!trimmed) return true;  return hasHttpScheme(trimmed) && URL.canParse(trimmed);}; const normalizeConnectionOption = (  input: ExecutorServerConnectionInput,): ExecutorServerConnection | null => {  if (!canParseOrigin(input.origin) || !canParseApiBaseUrl(input.apiBaseUrl)) return null;  return normalizeExecutorServerConnection(input);}; const asConnectionInput = (  connection: ExecutorServerConnection,): ExecutorServerConnectionInput => ({  kind: connection.kind,  key: connection.key,  origin: connection.origin,  apiBaseUrl: connection.apiBaseUrl,  displayName: connection.displayName,  ...(connection.auth ? { auth: connection.auth } : {}),}); export const parseExecutorServerProfilesSnapshot = (  raw: string | null | undefined,): ExecutorServerProfilesSnapshot => {  if (!raw) return EMPTY_PROFILES;  const decoded = decodeProfilesJson(raw);  if (Option.isNone(decoded)) return EMPTY_PROFILES;  return normalizeExecutorServerProfilesSnapshot(decoded.value);}; export const serializeExecutorServerProfilesSnapshot = (  snapshot: ExecutorServerProfilesSnapshot,): string => {  // Custom server auth is intentionally persisted with the profile so local-dev  // and advanced remote endpoints do not force reauth on every reload. Desktop  // stores this payload through its Electron store; web falls back to  // localStorage for the same format.  const persisted = {    version: 1,    activeKey: snapshot.activeKey,    profiles: snapshot.profiles.map(asConnectionInput),  };  return JSON.stringify(persisted);}; export const normalizeExecutorServerProfilesSnapshot = (input: {  readonly activeKey?: string | null;  readonly profiles?: readonly ExecutorServerConnectionInput[];}): ExecutorServerProfilesSnapshot => {  const deduped = new Map<string, ExecutorServerConnection>();  for (const profile of input.profiles ?? []) {    const normalized = normalizeConnectionOption(profile);    if (!normalized) continue;    deduped.set(normalized.key, normalized);  }   const profiles = [...deduped.values()];  const activeKey =    input.activeKey && deduped.has(input.activeKey) ? input.activeKey : (profiles[0]?.key ?? null);   return { activeKey, profiles };}; export const readExecutorServerProfiles = (  storage: ExecutorServerProfileStorage | null | undefined,  storageKey = EXECUTOR_SERVER_PROFILES_STORAGE_KEY,): ExecutorServerProfilesSnapshot => {  if (!storage) return EMPTY_PROFILES;  return parseExecutorServerProfilesSnapshot(storage.getItem(storageKey));}; export const writeExecutorServerProfiles = (  storage: ExecutorServerProfileStorage | null | undefined,  snapshot: ExecutorServerProfilesSnapshot,  storageKey = EXECUTOR_SERVER_PROFILES_STORAGE_KEY,): void => {  if (!storage) return;  storage.setItem(storageKey, serializeExecutorServerProfilesSnapshot(snapshot));}; export const getActiveExecutorServerProfile = (  snapshot: ExecutorServerProfilesSnapshot,): ExecutorServerConnection | null =>  snapshot.profiles.find((profile) => profile.key === snapshot.activeKey) ?? null; export const upsertExecutorServerProfile = (  snapshot: ExecutorServerProfilesSnapshot,  input: ExecutorServerConnectionInput,  options: {    readonly makeActive?: boolean;  } = {},): ExecutorServerProfilesSnapshot | null => {  const normalized = normalizeConnectionOption(input);  if (!normalized) return null;  const profiles = new Map(snapshot.profiles.map((profile) => [profile.key, profile]));  profiles.set(normalized.key, normalized);  const activeKey =    options.makeActive === false ? (snapshot.activeKey ?? normalized.key) : normalized.key;  return normalizeExecutorServerProfilesSnapshot({    activeKey,    profiles: [...profiles.values()],  });}; export const selectExecutorServerProfile = (  snapshot: ExecutorServerProfilesSnapshot,  key: string,): ExecutorServerProfilesSnapshot => {  if (!snapshot.profiles.some((profile) => profile.key === key)) return snapshot;  return { ...snapshot, activeKey: key };}; export const removeExecutorServerProfile = (  snapshot: ExecutorServerProfilesSnapshot,  key: string,): ExecutorServerProfilesSnapshot => {  const profiles = snapshot.profiles.filter((profile) => profile.key !== key);  return normalizeExecutorServerProfilesSnapshot({    activeKey: snapshot.activeKey === key ? null : snapshot.activeKey,    profiles,  });};