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

main
ts 275 lines 11.1 KB
Raw
1 import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
2 import * as NodeServices from "@effect/platform-node/NodeServices";
3 import { assert, it } from "@effect/vitest";
4 import * as Deferred from "effect/Deferred";
5 import * as Effect from "effect/Effect";
6 import * as FileSystem from "effect/FileSystem";
7 import * as Layer from "effect/Layer";
8 import * as Option from "effect/Option";
9 import * as Ref from "effect/Ref";
10 import * as PlatformError from "effect/PlatformError";
11
12 import * as ServerConfig from "../config.ts";
13 import * as ServerSecretStore from "./ServerSecretStore.ts";
14
15 const layerServerConfig = () =>
16 ServerConfig.layerTest(process.cwd(), { prefix: "t3-secret-store-test-" });
17
18 const layerServerSecretStore = () => Layer.provide(ServerSecretStore.layer, layerServerConfig());
19
20 const layerPermissionDeniedFileSystem = Layer.effect(
21 FileSystem.FileSystem,
22 Effect.gen(function* () {
23 const fileSystem = yield* FileSystem.FileSystem;
24
25 return {
26 ...fileSystem,
27 readFile: (path) =>
28 Effect.fail(
29 PlatformError.systemError({
30 _tag: "PermissionDenied",
31 module: "FileSystem",
32 method: "readFile",
33 pathOrDescriptor: path,
34 description: "Permission denied while reading secret file.",
35 }),
36 ),
37 } satisfies FileSystem.FileSystem;
38 }),
39 ).pipe(Layer.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)));
40
41 const layerPermissionDeniedSecretStore = () =>
42 ServerSecretStore.layer.pipe(
43 Layer.provide(layerServerConfig()),
44 Layer.provideMerge(layerPermissionDeniedFileSystem),
45 );
46
47 const layerRenameFailureFileSystem = Layer.effect(
48 FileSystem.FileSystem,
49 Effect.gen(function* () {
50 const fileSystem = yield* FileSystem.FileSystem;
51
52 return {
53 ...fileSystem,
54 rename: (from, to) =>
55 Effect.fail(
56 PlatformError.systemError({
57 _tag: "PermissionDenied",
58 module: "FileSystem",
59 method: "rename",
60 pathOrDescriptor: `${String(from)} -> ${String(to)}`,
61 description: "Permission denied while persisting secret file.",
62 }),
63 ),
64 } satisfies FileSystem.FileSystem;
65 }),
66 ).pipe(Layer.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)));
67
68 const layerRenameFailureSecretStore = () =>
69 ServerSecretStore.layer.pipe(
70 Layer.provide(layerServerConfig()),
71 Layer.provideMerge(layerRenameFailureFileSystem),
72 );
73
74 const layerConcurrentReadMissFileSystem = Layer.effect(
75 FileSystem.FileSystem,
76 Effect.gen(function* () {
77 const fileSystem = yield* FileSystem.FileSystem;
78 const readCountRef = yield* Ref.make(0);
79 const readBarrier = yield* Deferred.make<void>();
80
81 return {
82 ...fileSystem,
83 readFile: (path) =>
84 /[\\/]session-signing-key\.bin$/.test(String(path))
85 ? Ref.updateAndGet(readCountRef, (count) => count + 1).pipe(
86 Effect.flatMap((count) => {
87 if (count > 2) {
88 return fileSystem.readFile(path);
89 }
90 return Effect.gen(function* () {
91 if (count === 2) {
92 yield* Deferred.succeed(readBarrier, void 0);
93 }
94 yield* Deferred.await(readBarrier);
95 return yield* PlatformError.systemError({
96 _tag: "NotFound",
97 module: "FileSystem",
98 method: "readFile",
99 pathOrDescriptor: String(path),
100 description: "Secret file does not exist yet.",
101 });
102 });
103 }),
104 )
105 : fileSystem.readFile(path),
106 } satisfies FileSystem.FileSystem;
107 }),
108 ).pipe(Layer.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)));
109
110 const layerConcurrentCreateSecretStore = () =>
111 ServerSecretStore.layer.pipe(
112 Layer.provide(layerServerConfig()),
113 Layer.provideMerge(layerConcurrentReadMissFileSystem),
114 );
115
116 // Both callers read the empty secret before either repairs it, and the second removal of the
117 // secret file waits until the first caller has returned its key.
118 const layerConcurrentEmptyRepairFileSystem = (firstReturned: Deferred.Deferred<void>) =>
119 Layer.effect(
120 FileSystem.FileSystem,
121 Effect.gen(function* () {
122 const fileSystem = yield* FileSystem.FileSystem;
123 const readCountRef = yield* Ref.make(0);
124 const removeCountRef = yield* Ref.make(0);
125 const readBarrier = yield* Deferred.make<void>();
126 const isSecretPath = (path: string) => /[\\/]session-signing-key\.bin$/.test(path);
127
128 return {
129 ...fileSystem,
130 readFile: (path) =>
131 isSecretPath(path)
132 ? Ref.updateAndGet(readCountRef, (count) => count + 1).pipe(
133 Effect.flatMap((count) =>
134 count > 2
135 ? fileSystem.readFile(path)
136 : Effect.gen(function* () {
137 if (count === 2) {
138 yield* Deferred.succeed(readBarrier, void 0);
139 }
140 yield* Deferred.await(readBarrier);
141 return yield* fileSystem.readFile(path);
142 }),
143 ),
144 )
145 : fileSystem.readFile(path),
146 remove: (path, options) =>
147 isSecretPath(path)
148 ? Ref.updateAndGet(removeCountRef, (count) => count + 1).pipe(
149 Effect.flatMap((count) =>
150 count > 1 ? Deferred.await(firstReturned) : Effect.void,
151 ),
152 Effect.flatMap(() => fileSystem.remove(path, options)),
153 )
154 : fileSystem.remove(path, options),
155 } satisfies FileSystem.FileSystem;
156 }),
157 ).pipe(Layer.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)));
158
159 const layerConcurrentEmptyRepairSecretStore = (firstReturned: Deferred.Deferred<void>) =>
160 ServerSecretStore.layer.pipe(
161 Layer.provide(layerServerConfig()),
162 Layer.provideMerge(layerConcurrentEmptyRepairFileSystem(firstReturned)),
163 );
164
165 it.layer(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))("ServerSecretStore.layer", (it) => {
166 it.effect("reuses an existing secret instead of regenerating it", () =>
167 Effect.gen(function* () {
168 const secretStore = yield* ServerSecretStore.ServerSecretStore;
169
170 const first = yield* secretStore.getOrCreateRandom("session-signing-key", 32);
171 const second = yield* secretStore.getOrCreateRandom("session-signing-key", 32);
172
173 assert.deepEqual(Array.from(second), Array.from(first));
174 }).pipe(Effect.provide(layerServerSecretStore())),
175 );
176
177 it.effect("refuses a name that would leave the secrets directory", () =>
178 Effect.gen(function* () {
179 const secretStore = yield* ServerSecretStore.ServerSecretStore;
180 const value = new TextEncoder().encode("planted");
181 for (const name of ["marker-x/../session-signing-key", "marker-x\\..\\session-signing-key"]) {
182 for (const write of [secretStore.create, secretStore.set]) {
183 assert.equal((yield* write(name, value).pipe(Effect.flip))._tag, "SecretStoreNameError");
184 }
185 assert.equal((yield* secretStore.get(name).pipe(Effect.flip))._tag, "SecretStoreNameError");
186 assert.equal(
187 (yield* secretStore.remove(name).pipe(Effect.flip))._tag,
188 "SecretStoreNameError",
189 );
190 }
191 assert.isTrue(Option.isNone(yield* secretStore.get("session-signing-key")));
192 }).pipe(Effect.provide(layerServerSecretStore())),
193 );
194
195 it.effect("replaces an empty persisted secret with a fresh random one", () =>
196 Effect.gen(function* () {
197 const secretStore = yield* ServerSecretStore.ServerSecretStore;
198 yield* secretStore.set("session-signing-key", new Uint8Array());
199
200 const secret = yield* secretStore.getOrCreateRandom("session-signing-key", 32);
201 const persisted = yield* secretStore.get("session-signing-key");
202
203 assert.equal(secret.byteLength, 32);
204 assert.deepEqual(Array.from(Option.getOrThrow(persisted)), Array.from(secret));
205 }).pipe(Effect.provide(layerServerSecretStore())),
206 );
207
208 it.effect("keeps the repaired secret when concurrent callers find it empty", () =>
209 Effect.gen(function* () {
210 const firstReturned = yield* Deferred.make<void>();
211 yield* Effect.gen(function* () {
212 const secretStore = yield* ServerSecretStore.ServerSecretStore;
213 yield* secretStore.set("session-signing-key", new Uint8Array());
214 const getOrCreate = secretStore
215 .getOrCreateRandom("session-signing-key", 32)
216 .pipe(Effect.tap(() => Deferred.succeed(firstReturned, void 0)));
217
218 const [first, second] = yield* Effect.all([getOrCreate, getOrCreate], {
219 concurrency: "unbounded",
220 });
221 const persisted = Option.getOrThrow(yield* secretStore.get("session-signing-key"));
222
223 assert.deepEqual(Array.from(first), Array.from(persisted));
224 assert.deepEqual(Array.from(second), Array.from(persisted));
225 }).pipe(Effect.provide(layerConcurrentEmptyRepairSecretStore(firstReturned)));
226 }),
227 );
228
229 it.effect("returns the persisted secret when concurrent creators race", () =>
230 Effect.gen(function* () {
231 const secretStore = yield* ServerSecretStore.ServerSecretStore;
232
233 const [first, second] = yield* Effect.all(
234 [
235 secretStore.getOrCreateRandom("session-signing-key", 32),
236 secretStore.getOrCreateRandom("session-signing-key", 32),
237 ],
238 { concurrency: "unbounded" },
239 );
240 const persisted = yield* secretStore.get("session-signing-key");
241 const persistedBytes = Option.getOrThrow(persisted);
242
243 assert.deepEqual(Array.from(first), Array.from(persistedBytes));
244 assert.deepEqual(Array.from(second), Array.from(persistedBytes));
245 }).pipe(Effect.provide(layerConcurrentCreateSecretStore())),
246 );
247
248 it.effect("propagates read failures other than missing-file errors", () =>
249 Effect.gen(function* () {
250 const secretStore = yield* ServerSecretStore.ServerSecretStore;
251
252 const error = yield* Effect.flip(secretStore.getOrCreateRandom("session-signing-key", 32));
253
254 assert.instanceOf(error, ServerSecretStore.SecretStoreReadError);
255 assert.include(error.message, "Failed to read secret session-signing-key.");
256 assert.instanceOf(error.cause, PlatformError.PlatformError);
257 assert.equal((error.cause as PlatformError.PlatformError).reason._tag, "PermissionDenied");
258 }).pipe(Effect.provide(layerPermissionDeniedSecretStore())),
259 );
260
261 it.effect("propagates write failures instead of treating them as success", () =>
262 Effect.gen(function* () {
263 const secretStore = yield* ServerSecretStore.ServerSecretStore;
264
265 const error = yield* Effect.flip(
266 secretStore.set("session-signing-key", Uint8Array.from([1, 2, 3])),
267 );
268
269 assert.instanceOf(error, ServerSecretStore.SecretStorePersistError);
270 assert.include(error.message, "Failed to persist secret session-signing-key.");
271 assert.instanceOf(error.cause, PlatformError.PlatformError);
272 assert.equal((error.cause as PlatformError.PlatformError).reason._tag, "PermissionDenied");
273 }).pipe(Effect.provide(layerRenameFailureSecretStore())),
274 );
275 });