@devries-cameron20 / t3code-1 / commits / 0bd581b078
Fork 0

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

fix(server): regenerate an empty persisted secret instead of failing startup (#32053)

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

Julius Marminge committed Nov 14, 2026 at 20:40 UTC 0bd581b078f22dbd33e8b14ce930a5eb55c6fca1
2 files changed +100
apps/server/src/auth/ServerSecretStore.test.ts
+83
@@ -113,6 +113,55 @@ const layerConcurrentCreateSecretStore = () =>
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* () {
@@ -125,6 +174,40 @@ it.layer(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))("ServerSecretStor
174 }).pipe(Effect.provide(layerServerSecretStore())),
175 );
176
177 + it.effect("replaces an empty persisted secret with a fresh random one", () =>
178 + Effect.gen(function* () {
179 + const secretStore = yield* ServerSecretStore.ServerSecretStore;
180 + yield* secretStore.set("session-signing-key", new Uint8Array());
181 +
182 + const secret = yield* secretStore.getOrCreateRandom("session-signing-key", 32);
183 + const persisted = yield* secretStore.get("session-signing-key");
184 +
185 + assert.equal(secret.byteLength, 32);
186 + assert.deepEqual(Array.from(Option.getOrThrow(persisted)), Array.from(secret));
187 + }).pipe(Effect.provide(layerServerSecretStore())),
188 + );
189 +
190 + it.effect("keeps the repaired secret when concurrent callers find it empty", () =>
191 + Effect.gen(function* () {
192 + const firstReturned = yield* Deferred.make<void>();
193 + yield* Effect.gen(function* () {
194 + const secretStore = yield* ServerSecretStore.ServerSecretStore;
195 + yield* secretStore.set("session-signing-key", new Uint8Array());
196 + const getOrCreate = secretStore
197 + .getOrCreateRandom("session-signing-key", 32)
198 + .pipe(Effect.tap(() => Deferred.succeed(firstReturned, void 0)));
199 +
200 + const [first, second] = yield* Effect.all([getOrCreate, getOrCreate], {
201 + concurrency: "unbounded",
202 + });
203 + const persisted = Option.getOrThrow(yield* secretStore.get("session-signing-key"));
204 +
205 + assert.deepEqual(Array.from(first), Array.from(persisted));
206 + assert.deepEqual(Array.from(second), Array.from(persisted));
207 + }).pipe(Effect.provide(layerConcurrentEmptyRepairSecretStore(firstReturned)));
208 + }),
209 + );
210 +
211 it.effect("returns the persisted secret when concurrent creators race", () =>
212 Effect.gen(function* () {
213 const secretStore = yield* ServerSecretStore.ServerSecretStore;
apps/server/src/auth/ServerSecretStore.ts
+17
@@ -8,6 +8,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
@@ -169,6 +170,9 @@ export const make = Effect.gen(function* () {
170 );
171
172 const resolveSecretPath = (name: string) => path.join(serverConfig.secretsDir, `${name}.bin`);
173 + const emptySecretRepair = yield* Semaphore.make(1);
174 + const isMissingOrNonEmpty = (secret: Option.Option<Uint8Array>) =>
175 + Option.isNone(secret) || secret.value.byteLength > 0;
176
177 const get: ServerSecretStore["Service"]["get"] = (name) =>
178 fileSystem.readFile(resolveSecretPath(name)).pipe(
@@ -263,6 +267,19 @@ export const make = Effect.gen(function* () {
267
268 const getOrCreateRandom: ServerSecretStore["Service"]["getOrCreateRandom"] = (name, bytes) =>
269 get(name).pipe(
270 + // Older builds could persist a 0-byte secret, which is never a usable key. Re-read under
271 + // the permit, and keep it until an interrupted removal settles, so a caller that saw the
272 + // empty file cannot remove a key another caller created.
273 + Effect.filterOrElse(isMissingOrNonEmpty, () =>
274 + emptySecretRepair.withPermits(1)(
275 + get(name).pipe(
276 + Effect.filterOrElse(isMissingOrNonEmpty, () =>
277 + remove(name).pipe(Effect.as(Option.none<Uint8Array>())),
278 + ),
279 + Effect.uninterruptible,
280 + ),
281 + ),
282 + ),
283 Effect.flatMap(
284 Option.match({
285 onSome: Effect.succeed,