The best way to control Claude Code, Codex and more from any computer or phone
| 1 | import { |
| 2 | resolveEnvironmentMachineKind, |
| 3 | type EnvironmentId, |
| 4 | type EnvironmentMachineKind, |
| 5 | type ServerConfig, |
| 6 | type ServerProvider, |
| 7 | } from "@t3tools/contracts"; |
| 8 | import { Atom } from "effect/reactivity"; |
| 9 | |
| 10 | export type ThreadListProvider = Pick< |
| 11 | ServerProvider, |
| 12 | "instanceId" | "driver" | "enabled" | "displayName" | "accentColor" | "iconUrl" |
| 13 | >; |
| 14 | |
| 15 | const capabilityKeys = ["threadAutoSettleOptOut"] as const; |
| 16 | |
| 17 | function selectEnvironment(config: ServerConfig, isConnected: boolean) { |
| 18 | return { |
| 19 | isConnected, |
| 20 | providers: config.providers.map( |
| 21 | ({ instanceId, driver, enabled, displayName, accentColor, iconUrl }) => ({ |
| 22 | instanceId, |
| 23 | driver, |
| 24 | enabled, |
| 25 | displayName, |
| 26 | accentColor, |
| 27 | iconUrl, |
| 28 | }), |
| 29 | ), |
| 30 | machineKind: resolveEnvironmentMachineKind(config), |
| 31 | capabilities: config.environment.capabilities, |
| 32 | snoozePresets: config.settings.snoozePresets, |
| 33 | }; |
| 34 | } |
| 35 | |
| 36 | type ListEnvironment = ReturnType<typeof selectEnvironment>; |
| 37 | |
| 38 | function sameProviders( |
| 39 | left: ReadonlyArray<ThreadListProvider>, |
| 40 | right: ReadonlyArray<ThreadListProvider>, |
| 41 | ) { |
| 42 | return ( |
| 43 | left.length === right.length && |
| 44 | left.every((provider, index) => { |
| 45 | const other = right[index]!; |
| 46 | return ( |
| 47 | provider.instanceId === other.instanceId && |
| 48 | provider.driver === other.driver && |
| 49 | provider.enabled === other.enabled && |
| 50 | provider.displayName === other.displayName && |
| 51 | provider.accentColor === other.accentColor && |
| 52 | provider.iconUrl === other.iconUrl |
| 53 | ); |
| 54 | }) |
| 55 | ); |
| 56 | } |
| 57 | |
| 58 | function collectEnvironments(environments: ReadonlyMap<EnvironmentId, ListEnvironment>) { |
| 59 | const providersByEnvironmentId = new Map<EnvironmentId, ReadonlyArray<ThreadListProvider>>(); |
| 60 | const machineByEnvironmentId = new Map<EnvironmentId, EnvironmentMachineKind>(); |
| 61 | // Every protocol-2 server supports these thread actions; they only wait for its config. |
| 62 | const loadedEnvironmentIds = new Set<EnvironmentId>(); |
| 63 | const autoSettleOptOutEnvironmentIds = new Set<EnvironmentId>(); |
| 64 | const reorderableEnvironmentIds = new Set<EnvironmentId>(); |
| 65 | const snoozePresetsByEnvironmentId = new Map<EnvironmentId, ListEnvironment["snoozePresets"]>(); |
| 66 | for (const [ |
| 67 | id, |
| 68 | { providers, machineKind, capabilities, isConnected, snoozePresets }, |
| 69 | ] of environments) { |
| 70 | providersByEnvironmentId.set(id, providers); |
| 71 | snoozePresetsByEnvironmentId.set(id, snoozePresets); |
| 72 | machineByEnvironmentId.set(id, machineKind); |
| 73 | loadedEnvironmentIds.add(id); |
| 74 | if (capabilities.threadAutoSettleOptOut === true) autoSettleOptOutEnvironmentIds.add(id); |
| 75 | if (isConnected) reorderableEnvironmentIds.add(id); |
| 76 | } |
| 77 | return { |
| 78 | providersByEnvironmentId, |
| 79 | machineByEnvironmentId, |
| 80 | settlementEnvironmentIds: loadedEnvironmentIds, |
| 81 | snoozeEnvironmentIds: loadedEnvironmentIds, |
| 82 | pinningEnvironmentIds: loadedEnvironmentIds, |
| 83 | autoSettleOptOutEnvironmentIds, |
| 84 | pinReorderEnvironmentIds: reorderableEnvironmentIds, |
| 85 | activeReorderEnvironmentIds: reorderableEnvironmentIds, |
| 86 | titleRegenerationEnvironmentIds: loadedEnvironmentIds, |
| 87 | snoozePresetsByEnvironmentId, |
| 88 | }; |
| 89 | } |
| 90 | |
| 91 | export function createThreadListEnvironmentsAtom( |
| 92 | configsAtom: Atom.Atom<ReadonlyMap<EnvironmentId, ServerConfig>>, |
| 93 | connectedEnvironmentIdsAtom: Atom.Atom<ReadonlyArray<EnvironmentId>>, |
| 94 | ) { |
| 95 | let previous = new Map<EnvironmentId, ListEnvironment>(); |
| 96 | let result = collectEnvironments(previous); |
| 97 | return Atom.make((get) => { |
| 98 | const configs = get(configsAtom); |
| 99 | const connectedEnvironmentIds = new Set(get(connectedEnvironmentIdsAtom)); |
| 100 | const next = new Map<EnvironmentId, ListEnvironment>(); |
| 101 | let changed = configs.size !== previous.size; |
| 102 | for (const [id, config] of configs) { |
| 103 | const selected = selectEnvironment(config, connectedEnvironmentIds.has(id)); |
| 104 | const prior = previous.get(id); |
| 105 | if (prior && sameProviders(prior.providers, selected.providers)) { |
| 106 | selected.providers = prior.providers; |
| 107 | } |
| 108 | if (prior && JSON.stringify(prior.snoozePresets) === JSON.stringify(selected.snoozePresets)) { |
| 109 | selected.snoozePresets = prior.snoozePresets; |
| 110 | } |
| 111 | const unchanged = |
| 112 | prior && |
| 113 | prior.providers === selected.providers && |
| 114 | prior.machineKind === selected.machineKind && |
| 115 | prior.isConnected === selected.isConnected && |
| 116 | prior.snoozePresets === selected.snoozePresets && |
| 117 | capabilityKeys.every( |
| 118 | (key) => (prior.capabilities[key] === true) === (selected.capabilities[key] === true), |
| 119 | ); |
| 120 | next.set(id, unchanged ? prior : selected); |
| 121 | if (!unchanged) changed = true; |
| 122 | } |
| 123 | if (changed) { |
| 124 | previous = next; |
| 125 | result = collectEnvironments(next); |
| 126 | } |
| 127 | return result; |
| 128 | }).pipe(Atom.withLabel("thread-list-environments")); |
| 129 | } |