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

main
ts 376 lines 11.9 KB
Raw
1 import * as Context from "effect/Context";
2 import * as SecureRandom from "effect/crypto/SecureRandom";
3 import * as Effect from "effect/Effect";
4 import * as FileSystem from "effect/FileSystem";
5 import * as Layer from "effect/Layer";
6 import * as Option from "effect/Option";
7 import * as Path from "effect/Path";
8 import * as Predicate from "effect/Predicate";
9 import * as PlatformError from "effect/PlatformError";
10 import * as Schema from "effect/Schema";
11 import * as Semaphore from "effect/Semaphore";
12
13 import * as ServerConfig from "../config.ts";
14
15 const secretStoreErrorContext = {
16 resource: Schema.String,
17 cause: Schema.Defect(),
18 };
19
20 export class SecretStoreSecureError extends Schema.TaggedError<SecretStoreSecureError>()(
21 "SecretStoreSecureError",
22 {
23 ...secretStoreErrorContext,
24 },
25 ) {
26 override get message(): string {
27 return `Failed to secure ${this.resource}.`;
28 }
29 }
30
31 export class SecretStoreNameError extends Schema.TaggedError<SecretStoreNameError>()(
32 "SecretStoreNameError",
33 {
34 resource: Schema.String,
35 },
36 ) {
37 override get message(): string {
38 return `Refused ${this.resource}: a secret name cannot contain a path separator.`;
39 }
40 }
41
42 export class SecretStoreReadError extends Schema.TaggedError<SecretStoreReadError>()(
43 "SecretStoreReadError",
44 {
45 ...secretStoreErrorContext,
46 },
47 ) {
48 override get message(): string {
49 return `Failed to read ${this.resource}.`;
50 }
51 }
52
53 export class SecretStoreTemporaryPathError extends Schema.TaggedError<SecretStoreTemporaryPathError>()(
54 "SecretStoreTemporaryPathError",
55 {
56 ...secretStoreErrorContext,
57 },
58 ) {
59 override get message(): string {
60 return `Failed to create temporary path for ${this.resource}.`;
61 }
62 }
63
64 export class SecretStorePersistError extends Schema.TaggedError<SecretStorePersistError>()(
65 "SecretStorePersistError",
66 {
67 ...secretStoreErrorContext,
68 },
69 ) {
70 override get message(): string {
71 return `Failed to persist ${this.resource}.`;
72 }
73 }
74
75 export class SecretStoreRandomGenerationError extends Schema.TaggedError<SecretStoreRandomGenerationError>()(
76 "SecretStoreRandomGenerationError",
77 {
78 ...secretStoreErrorContext,
79 },
80 ) {
81 override get message(): string {
82 return `Failed to generate random bytes for ${this.resource}.`;
83 }
84 }
85
86 export class SecretStoreConcurrentReadError extends Schema.TaggedError<SecretStoreConcurrentReadError>()(
87 "SecretStoreConcurrentReadError",
88 {
89 resource: Schema.String,
90 },
91 ) {
92 override get message(): string {
93 return `Failed to read ${this.resource} after concurrent creation.`;
94 }
95 }
96
97 export class SecretStoreRemoveError extends Schema.TaggedError<SecretStoreRemoveError>()(
98 "SecretStoreRemoveError",
99 {
100 ...secretStoreErrorContext,
101 },
102 ) {
103 override get message(): string {
104 return `Failed to remove ${this.resource}.`;
105 }
106 }
107
108 export class SecretStoreDecodeError extends Schema.TaggedError<SecretStoreDecodeError>()(
109 "SecretStoreDecodeError",
110 {
111 ...secretStoreErrorContext,
112 },
113 ) {
114 override get message(): string {
115 return `Failed to decode ${this.resource}.`;
116 }
117 }
118
119 export class SecretStoreEncodeError extends Schema.TaggedError<SecretStoreEncodeError>()(
120 "SecretStoreEncodeError",
121 {
122 ...secretStoreErrorContext,
123 },
124 ) {
125 override get message(): string {
126 return `Failed to encode ${this.resource}.`;
127 }
128 }
129
130 export const SecretStoreError = Schema.Union([
131 SecretStoreSecureError,
132 SecretStoreNameError,
133 SecretStoreReadError,
134 SecretStoreTemporaryPathError,
135 SecretStorePersistError,
136 SecretStoreRandomGenerationError,
137 SecretStoreConcurrentReadError,
138 SecretStoreRemoveError,
139 SecretStoreDecodeError,
140 SecretStoreEncodeError,
141 ]);
142 export type SecretStoreError = typeof SecretStoreError.Type;
143 export const isSecretStoreError = Schema.is(SecretStoreError);
144
145 const isPlatformError = (value: unknown): value is PlatformError.PlatformError =>
146 Predicate.isTagged(value, "PlatformError");
147
148 export const isSecretAlreadyExistsError = (error: SecretStoreError): boolean =>
149 "cause" in error && isPlatformError(error.cause) && error.cause.reason._tag === "AlreadyExists";
150
151 export class ServerSecretStore extends Context.Service<
152 ServerSecretStore,
153 {
154 readonly directory?: string;
155 readonly get: (name: string) => Effect.Effect<Option.Option<Uint8Array>, SecretStoreError>;
156 readonly set: (name: string, value: Uint8Array) => Effect.Effect<void, SecretStoreError>;
157 readonly create: (name: string, value: Uint8Array) => Effect.Effect<void, SecretStoreError>;
158 readonly getOrCreateRandom: (
159 name: string,
160 bytes: number,
161 ) => Effect.Effect<Uint8Array, SecretStoreError>;
162 readonly remove: (name: string) => Effect.Effect<void, SecretStoreError>;
163 }
164 >()("t3/auth/ServerSecretStore") {}
165
166 /** @public */
167 export const make = Effect.gen(function* () {
168 const crypto = yield* SecureRandom.SecureRandom;
169 const fileSystem = yield* FileSystem.FileSystem;
170 const path = yield* Path.Path;
171 const serverConfig = yield* ServerConfig.ServerConfig;
172
173 yield* fileSystem.makeDirectory(serverConfig.secretsDir, { recursive: true });
174 yield* fileSystem.chmod(serverConfig.secretsDir, 0o700).pipe(
175 Effect.mapError(
176 (cause) =>
177 new SecretStoreSecureError({
178 resource: `secrets directory ${serverConfig.secretsDir}`,
179 cause,
180 }),
181 ),
182 );
183
184 // Some names carry text from outside the server; one with a separator would leave the directory.
185 const resolveSecretPath = (name: string): Effect.Effect<string, SecretStoreNameError> =>
186 /[/\\\0]/.test(name)
187 ? Effect.fail(new SecretStoreNameError({ resource: `secret ${JSON.stringify(name)}` }))
188 : Effect.succeed(path.join(serverConfig.secretsDir, `${name}.bin`));
189 const emptySecretRepair = yield* Semaphore.make(1);
190 const isMissingOrNonEmpty = (secret: Option.Option<Uint8Array>) =>
191 Option.isNone(secret) || secret.value.byteLength > 0;
192
193 const get: ServerSecretStore["Service"]["get"] = (name) =>
194 resolveSecretPath(name).pipe(
195 Effect.flatMap((secretPath) =>
196 fileSystem.readFile(secretPath).pipe(
197 Effect.map((bytes) => Option.some(Uint8Array.from(bytes))),
198 Effect.catch((cause) =>
199 cause.reason._tag === "NotFound"
200 ? Effect.succeedNone
201 : Effect.fail(
202 new SecretStoreReadError({
203 resource: `secret ${name}`,
204 cause,
205 }),
206 ),
207 ),
208 ),
209 ),
210 Effect.withSpan("ServerSecretStore.get"),
211 );
212
213 const set: ServerSecretStore["Service"]["set"] = (name, value) =>
214 resolveSecretPath(name).pipe(
215 Effect.flatMap((secretPath) => setAt(name, secretPath, value)),
216 Effect.withSpan("ServerSecretStore.set"),
217 );
218
219 const setAt = (name: string, secretPath: string, value: Uint8Array) =>
220 crypto.uuidV4().pipe(
221 Effect.mapError(
222 (cause) =>
223 new SecretStoreTemporaryPathError({
224 resource: `secret ${name}`,
225 cause,
226 }),
227 ),
228 Effect.flatMap((uuid) => {
229 const tempPath = `${secretPath}.${uuid}.tmp`;
230 return Effect.gen(function* () {
231 yield* fileSystem.writeFile(tempPath, value);
232 yield* fileSystem.chmod(tempPath, 0o600);
233 yield* fileSystem.rename(tempPath, secretPath);
234 yield* fileSystem.chmod(secretPath, 0o600);
235 }).pipe(
236 Effect.catch((cause) =>
237 fileSystem.remove(tempPath).pipe(
238 Effect.ignore,
239 Effect.flatMap(() =>
240 Effect.fail(
241 new SecretStorePersistError({
242 resource: `secret ${name}`,
243 cause,
244 }),
245 ),
246 ),
247 ),
248 ),
249 );
250 }),
251 );
252
253 // `link` publishes the fully written temp file under the final name, or fails with
254 // AlreadyExists, so a concurrent reader never observes a partially written secret.
255 const create: ServerSecretStore["Service"]["create"] = (name, value) =>
256 resolveSecretPath(name).pipe(Effect.flatMap((secretPath) => createAt(name, secretPath, value)));
257
258 const createAt = (name: string, secretPath: string, value: Uint8Array) =>
259 crypto.uuidV4().pipe(
260 Effect.mapError(
261 (cause) =>
262 new SecretStoreTemporaryPathError({
263 resource: `secret ${name}`,
264 cause,
265 }),
266 ),
267 Effect.flatMap((uuid) => {
268 const tempPath = `${secretPath}.${uuid}.tmp`;
269 return Effect.gen(function* () {
270 yield* Effect.scoped(
271 Effect.gen(function* () {
272 const file = yield* fileSystem.open(tempPath, { flag: "wx", mode: 0o600 });
273 yield* file.writeAll(value);
274 yield* file.sync;
275 }),
276 );
277 yield* fileSystem.chmod(tempPath, 0o600);
278 yield* fileSystem.link(tempPath, secretPath);
279 }).pipe(
280 Effect.ensuring(fileSystem.remove(tempPath).pipe(Effect.ignore)),
281 Effect.mapError(
282 (cause) =>
283 new SecretStorePersistError({
284 resource: `secret ${name}`,
285 cause,
286 }),
287 ),
288 );
289 }),
290 );
291
292 const getOrCreateRandom: ServerSecretStore["Service"]["getOrCreateRandom"] = (name, bytes) =>
293 get(name).pipe(
294 // Older builds could persist a 0-byte secret, which is never a usable key. Re-read under
295 // the permit, and keep it until an interrupted removal settles, so a caller that saw the
296 // empty file cannot remove a key another caller created.
297 Effect.filterOrElse(isMissingOrNonEmpty, () =>
298 emptySecretRepair.withPermits(1)(
299 get(name).pipe(
300 Effect.filterOrElse(isMissingOrNonEmpty, () =>
301 remove(name).pipe(Effect.as(Option.none<Uint8Array>())),
302 ),
303 Effect.uninterruptible,
304 ),
305 ),
306 ),
307 Effect.flatMap(
308 Option.match({
309 onSome: Effect.succeed,
310 onNone: () =>
311 crypto.randomBytes(bytes).pipe(
312 Effect.mapError(
313 (cause) =>
314 new SecretStoreRandomGenerationError({
315 resource: `secret ${name}`,
316 cause,
317 }),
318 ),
319 Effect.flatMap((generated) =>
320 create(name, generated).pipe(
321 Effect.as(Uint8Array.from(generated)),
322 Effect.catchIf(isSecretStoreError, (error) =>
323 isSecretAlreadyExistsError(error)
324 ? get(name).pipe(
325 Effect.flatMap(
326 Option.match({
327 onSome: Effect.succeed,
328 onNone: () =>
329 Effect.fail(
330 new SecretStoreConcurrentReadError({
331 resource: `secret ${name}`,
332 }),
333 ),
334 }),
335 ),
336 )
337 : Effect.fail(error),
338 ),
339 ),
340 ),
341 ),
342 }),
343 ),
344 Effect.withSpan("ServerSecretStore.getOrCreateRandom"),
345 );
346
347 const remove: ServerSecretStore["Service"]["remove"] = (name) =>
348 resolveSecretPath(name).pipe(
349 Effect.flatMap((secretPath) =>
350 fileSystem.remove(secretPath).pipe(
351 Effect.catch((cause) =>
352 cause.reason._tag === "NotFound"
353 ? Effect.void
354 : Effect.fail(
355 new SecretStoreRemoveError({
356 resource: `secret ${name}`,
357 cause,
358 }),
359 ),
360 ),
361 ),
362 ),
363 Effect.withSpan("ServerSecretStore.remove"),
364 );
365
366 return ServerSecretStore.of({
367 directory: serverConfig.secretsDir,
368 get,
369 set,
370 create,
371 getOrCreateRandom,
372 remove,
373 });
374 });
375
376 export const layer = Layer.effect(ServerSecretStore, make);