The best way to control Claude Code, Codex and more from any computer or phone

main
ts 170 lines 6.86 KB
Raw
1 // Reads secrets that settings point at through a configured secret provider. Each read, including
2 // a failed one, is held for the server's life so rebuilds never re-prompt an unlock; `invalidate`
3 // (the Settings refresh) and a `fresh` read are the only ways to read again.
4 import type { SecretReference, ServerSettings } from "@t3tools/contracts";
5 import * as Context from "effect/Context";
6 import * as Effect from "effect/Effect";
7 import * as Layer from "effect/Layer";
8 import * as Option from "effect/Option";
9 import * as Schema from "effect/Schema";
10 import * as Semaphore from "effect/Semaphore";
11
12 import type { SecretProviderDriver, SecretProviderDriverServices } from "./driver.ts";
13
14 export class SecretResolver extends Context.Service<
15 SecretResolver,
16 {
17 /**
18 * Values in input order; `undefined` marks a reference that could not be read. `fresh` asks the
19 * provider again and returns what it answered, but an unreadable or empty answer does not
20 * replace a value that is already held.
21 */
22 readonly read: (
23 references: ReadonlyArray<SecretReference>,
24 options?: { readonly fresh?: boolean },
25 ) => Effect.Effect<ReadonlyArray<string | undefined>>;
26 /** Forgets the given references, or every reference, so the next read asks the provider again. */
27 readonly invalidate: (references?: ReadonlyArray<SecretReference>) => Effect.Effect<void>;
28 /** The name the user gave a secret provider, or its id when it has none or is gone. */
29 readonly label: (provider: SecretReference["provider"]) => Effect.Effect<string>;
30 }
31 >()("@t3tools/secret-provider-core/server/SecretResolver") {}
32
33 const cacheKey = (reference: SecretReference) =>
34 `${reference.provider}\u0000${reference.reference}`;
35
36 interface CachedSecret {
37 // A provider whose config changed, such as another account, reads again.
38 readonly config: string;
39 readonly value: string | undefined;
40 }
41
42 const decodeConfigWith = Schema.decodeUnknownOption<Schema.Codec<unknown, unknown>>;
43
44 interface ReadablePlan {
45 readonly driver: SecretProviderDriver;
46 readonly config: unknown;
47 readonly configKey: string;
48 }
49
50 export const make = Effect.fn("SecretResolver.make")(function* (options: {
51 readonly drivers: ReadonlyArray<SecretProviderDriver>;
52 readonly secretProviders: Effect.Effect<ServerSettings["secretProviders"]>;
53 }) {
54 const context = yield* Effect.context<SecretProviderDriverServices>();
55 const driversByKind = new Map(
56 options.drivers.map((driver) => [
57 driver.kind,
58 { driver, decodeConfig: decodeConfigWith(driver.definition.configSchema) },
59 ]),
60 );
61 const cache = new Map<string, CachedSecret>();
62 const semaphore = yield* Semaphore.make(1);
63
64 // Only a provider this build can read is cached; anything else fails fast and is checked again
65 // on the next read.
66 const planFor = (
67 providers: ServerSettings["secretProviders"],
68 reference: SecretReference,
69 ): ReadablePlan | undefined => {
70 const provider = providers[reference.provider];
71 const entry = provider === undefined ? undefined : driversByKind.get(provider.kind);
72 if (provider === undefined || entry === undefined) return undefined;
73 const { driver, decodeConfig } = entry;
74 if (!driver.definition.isReference(reference.reference)) return undefined;
75 const config = decodeConfig(provider.config);
76 return Option.isNone(config)
77 ? undefined
78 : { driver, config: config.value, configKey: JSON.stringify(config.value) };
79 };
80
81 const isCached = (reference: SecretReference, plan: ReadablePlan) =>
82 cache.get(cacheKey(reference))?.config === plan.configKey;
83
84 const answer = (
85 references: ReadonlyArray<SecretReference>,
86 plans: ReadonlyArray<ReadablePlan | undefined>,
87 ) =>
88 references.map((reference, index) => {
89 const plan = plans[index];
90 return plan !== undefined && isCached(reference, plan)
91 ? cache.get(cacheKey(reference))?.value
92 : undefined;
93 });
94
95 // Cache hits answer without the lock, so a read waiting on an unlock never stalls a cached one.
96 const read: SecretResolver["Service"]["read"] = Effect.fn("SecretResolver.read")(function* (
97 references,
98 readOptions,
99 ) {
100 const fresh = readOptions?.fresh === true;
101 const providers = yield* options.secretProviders;
102 const plans = references.map((reference) => planFor(providers, reference));
103 const isMissing = (reference: SecretReference, index: number) => {
104 const plan = plans[index];
105 return plan !== undefined && (fresh || !isCached(reference, plan));
106 };
107 if (!references.some(isMissing)) return answer(references, plans);
108
109 return yield* semaphore.withPermits(1)(
110 Effect.gen(function* () {
111 const wanted = new Map<
112 string,
113 {
114 readonly plan: ReadablePlan;
115 readonly byReference: Map<string, Array<SecretReference>>;
116 }
117 >();
118 references.forEach((reference, index) => {
119 const plan = plans[index];
120 if (plan === undefined || !isMissing(reference, index)) return;
121 const group = wanted.get(reference.provider) ?? { plan, byReference: new Map() };
122 group.byReference.set(reference.reference, [
123 ...(group.byReference.get(reference.reference) ?? []),
124 reference,
125 ]);
126 wanted.set(reference.provider, group);
127 });
128 const answered = new Map<string, string | undefined>();
129 for (const { plan, byReference } of wanted.values()) {
130 const values = yield* plan.driver.read(plan.config, [...byReference.keys()]);
131 [...byReference.values()].forEach((sameReference, index) => {
132 const value = values[index];
133 const readable = value !== undefined && value.trim() !== "";
134 for (const reference of sameReference) {
135 answered.set(cacheKey(reference), value);
136 if (!fresh || readable || !isCached(reference, plan)) {
137 cache.set(cacheKey(reference), { config: plan.configKey, value });
138 }
139 }
140 });
141 }
142 return fresh
143 ? references.map((reference) => answered.get(cacheKey(reference)))
144 : answer(references, plans);
145 }),
146 );
147 }, Effect.provideContext(context));
148
149 const invalidate: SecretResolver["Service"]["invalidate"] = (references) =>
150 semaphore.withPermits(1)(
151 Effect.sync(() => {
152 if (references === undefined) cache.clear();
153 else for (const reference of references) cache.delete(cacheKey(reference));
154 }),
155 );
156
157 const label: SecretResolver["Service"]["label"] = (provider) =>
158 options.secretProviders.pipe(
159 Effect.map(
160 (providers) =>
161 (Object.hasOwn(providers, provider) ? providers[provider]?.label.trim() : undefined) ||
162 provider,
163 ),
164 );
165
166 return SecretResolver.of({ read, invalidate, label });
167 });
168
169 export const layer = (options: Parameters<typeof make>[0]) =>
170 Layer.effect(SecretResolver, make(options));