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,