import * as Arr from "effect/Array";import { pipe } from "effect/Function";import * as Option from "effect/Option";import * as Schema from "effect/Schema";import * as SecureStore from "expo-secure-store";import { EnvironmentId, OrchestrationShellSnapshot } from "@t3tools/contracts"; import type { SavedRemoteConnection } from "./connection"; const CONNECTIONS_KEY = "t3code.connections";const PREFERENCES_KEY = "t3code.preferences";const SHELL_SNAPSHOT_CACHE_SCHEMA_VERSION = 1;const SHELL_SNAPSHOT_CACHE_DIRECTORY = "shell-snapshots"; export interface CachedShellSnapshot {  readonly schemaVersion: typeof SHELL_SNAPSHOT_CACHE_SCHEMA_VERSION;  readonly environmentId: EnvironmentId;  readonly snapshotReceivedAt: string;  readonly snapshot: OrchestrationShellSnapshot;} export interface MobilePreferences {  readonly terminalFontSize?: number;} const CachedShellSnapshotSchema = Schema.Struct({  schemaVersion: Schema.Literal(SHELL_SNAPSHOT_CACHE_SCHEMA_VERSION),  environmentId: EnvironmentId,  snapshotReceivedAt: Schema.String,  snapshot: OrchestrationShellSnapshot,});const decodeCachedShellSnapshot = Schema.decodeUnknownOption(CachedShellSnapshotSchema); async function readStorageItem(key: string): Promise<string | null> {  return await SecureStore.getItemAsync(key);} async function writeStorageItem(key: string, value: string): Promise<void> {  await SecureStore.setItemAsync(key, value);} async function readJsonStorageItem<T>(key: string): Promise<T | null> {  const raw = (await readStorageItem(key)) ?? "";  if (!raw.trim()) {    return null;  }   try {    return JSON.parse(raw) as T;  } catch {    return null;  }} function cachedShellSnapshotFileName(environmentId: EnvironmentId): string {  return `${encodeURIComponent(environmentId)}.json`;} async function getShellSnapshotCacheDirectory() {  const { Directory, Paths } = await import("expo-file-system");  const directory = new Directory(Paths.document, SHELL_SNAPSHOT_CACHE_DIRECTORY);  directory.create({ idempotent: true, intermediates: true });  return directory;} export async function loadCachedShellSnapshot(  environmentId: EnvironmentId,): Promise<CachedShellSnapshot | null> {  try {    const { File } = await import("expo-file-system");    const directory = await getShellSnapshotCacheDirectory();    const file = new File(directory, cachedShellSnapshotFileName(environmentId));    if (!file.exists) {      return null;    }     const parsed = JSON.parse(await file.text()) as unknown;    const decoded = decodeCachedShellSnapshot(parsed);    if (Option.isNone(decoded) || decoded.value.environmentId !== environmentId) {      return null;    }     return decoded.value;  } catch {    return null;  }} export async function saveCachedShellSnapshot(  environmentId: EnvironmentId,  snapshot: OrchestrationShellSnapshot,): Promise<void> {  try {    const { File } = await import("expo-file-system");    const directory = await getShellSnapshotCacheDirectory();    const file = new File(directory, cachedShellSnapshotFileName(environmentId));    const document: CachedShellSnapshot = {      schemaVersion: SHELL_SNAPSHOT_CACHE_SCHEMA_VERSION,      environmentId,      snapshotReceivedAt: new Date().toISOString(),      snapshot,    };     if (!file.exists) {      file.create({ intermediates: true, overwrite: true });    }    file.write(JSON.stringify(document));  } catch {    // Cache persistence is best-effort and should never block live data.  }} export async function clearCachedShellSnapshot(environmentId: EnvironmentId): Promise<void> {  try {    const { File } = await import("expo-file-system");    const directory = await getShellSnapshotCacheDirectory();    const file = new File(directory, cachedShellSnapshotFileName(environmentId));    if (file.exists) {      file.delete();    }  } catch {    // Ignore cache cleanup failures.  }} export async function loadSavedConnections(): Promise<ReadonlyArray<SavedRemoteConnection>> {  const parsed = await readJsonStorageItem<{    readonly connections?: ReadonlyArray<SavedRemoteConnection>;  }>(CONNECTIONS_KEY);  if (!parsed) {    return [];  }   return pipe(    parsed.connections ?? [],    Arr.filter((c) => !!c.environmentId && !!c.bearerToken?.trim()),  );} export async function saveConnection(connection: SavedRemoteConnection): Promise<void> {  const current = await loadSavedConnections();  const next = current.some((entry) => entry.environmentId === connection.environmentId)    ? pipe(        current,        Arr.map((entry) => (entry.environmentId === connection.environmentId ? connection : entry)),      )    : pipe(current, Arr.append(connection));   await writeStorageItem(CONNECTIONS_KEY, JSON.stringify({ connections: next }));} export async function clearSavedConnection(environmentId: EnvironmentId): Promise<void> {  const current = await loadSavedConnections();  const next = pipe(    current,    Arr.filter((entry) => entry.environmentId !== environmentId),  );  await writeStorageItem(CONNECTIONS_KEY, JSON.stringify({ connections: next }));} export async function loadPreferences(): Promise<MobilePreferences> {  const parsed = await readJsonStorageItem<MobilePreferences>(PREFERENCES_KEY);  if (!parsed || typeof parsed !== "object") {    return {};  }   if (typeof parsed.terminalFontSize === "number") {    return { terminalFontSize: parsed.terminalFontSize };  }   return {};} export async function savePreferencesPatch(  patch: Partial<MobilePreferences>,): Promise<MobilePreferences> {  const current = await loadPreferences();  const next: MobilePreferences = {    ...current,    ...patch,  };  await writeStorageItem(PREFERENCES_KEY, JSON.stringify(next));  return next;}