The best way to control Claude Code, Codex and more from any computer or phone
fix(server): a duplicate variable row no longer deletes a stored secret (#31337)
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Julius Marminge committed
Nov 8, 2026 at 18:05 UTC
8e1581ad8cbca6a2c0f91a0c16fe8f15ec87afff
2 files changed
+144
-9
apps/server/src/serverSettings.test.ts
+110
@@ -8,6 +8,7 @@ import {
8
ProjectId,
9
ProjectScript,
10
ProviderDriverKind,
11
+ type ProviderInstanceEnvironment,
12
ProviderInstanceId,
13
resolveProviderInstanceEnabled,
14
SecretProviderId,
@@ -1282,6 +1283,115 @@ it.layer(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))("server settings"
1283
}).pipe(Effect.provide(layerServerSettings())),
1284
);
1285
1286
+ it.effect.each(
1287
+ [
1288
+ { label: "redacted then empty sensitive", duplicate: { value: "", sensitive: true } },
1289
+ {
1290
+ label: "empty sensitive then redacted",
1291
+ duplicate: { value: "", sensitive: true },
1292
+ redactedLast: true,
1293
+ },
1294
+ { label: "redacted then plain", duplicate: { value: "plain-foo", sensitive: false } },
1295
+ {
1296
+ label: "plain then redacted",
1297
+ duplicate: { value: "plain-foo", sensitive: false },
1298
+ redactedLast: true,
1299
+ },
1300
+ {
1301
+ label: "secret reference then redacted",
1302
+ duplicate: {
1303
+ value: { provider: SecretProviderId.make("personal"), reference: "op://Private/FOO" },
1304
+ sensitive: true,
1305
+ },
1306
+ redactedLast: true,
1307
+ },
1308
+ {
1309
+ label: "inline seed, redacted then empty sensitive",
1310
+ duplicate: { value: "", sensitive: true },
1311
+ inline: '[{"name":"FOO","value":"stored-foo","sensitive":true}]',
1312
+ },
1313
+ {
1314
+ label: "inline seed with an empty duplicate, redacted then empty sensitive",
1315
+ duplicate: { value: "", sensitive: true },
1316
+ inline:
1317
+ '[{"name":"FOO","value":"stored-foo","sensitive":true},{"name":"FOO","value":"","sensitive":true}]',
1318
+ },
1319
+ {
1320
+ label: "inline seed with an empty duplicate, new value then redacted",
1321
+ duplicate: { value: "new-foo", sensitive: true },
1322
+ redactedLast: true,
1323
+ inline:
1324
+ '[{"name":"FOO","value":"stored-foo","sensitive":true},{"name":"FOO","value":"","sensitive":true}]',
1325
+ expected: "new-foo",
1326
+ },
1327
+ ].map((testCase) => [testCase.label, testCase] as const),
1328
+ )(
1329
+ "keeps a stored secret a redacted row still claims when a duplicate name is saved (%s)",
1330
+ ([, { duplicate, redactedLast, inline, expected = "stored-foo" }]) =>
1331
+ Effect.gen(function* () {
1332
+ const service = yield* ServerSettingsModule.ServerSettingsService;
1333
+ const instanceId = ProviderInstanceId.make("codex_personal");
1334
+ const save = (environment: ProviderInstanceEnvironment) =>
1335
+ service.updateSettings({
1336
+ providerInstances: {
1337
+ [instanceId]: { driver: ProviderDriverKind.make("codex"), environment, config: {} },
1338
+ },
1339
+ });
1340
+ if (inline) {
1341
+ const config = yield* ServerConfig.ServerConfig;
1342
+ const fs = yield* FileSystem.FileSystem;
1343
+ yield* fs.writeFileString(
1344
+ config.settingsPath,
1345
+ `{"providerInstances":{"codex_personal":{"driver":"codex","environment":${inline},"config":{}}}}`,
1346
+ );
1347
+ yield* service.getSettings;
1348
+ } else {
1349
+ yield* save([{ name: "FOO", value: "stored-foo", sensitive: true }]);
1350
+ }
1351
+ const redacted = { name: "FOO", value: "", sensitive: true, valueRedacted: true };
1352
+ const copy = { name: "FOO", ...duplicate };
1353
+ yield* save(redactedLast ? [copy, redacted] : [redacted, copy]);
1354
+
1355
+ const reloaded = yield* Effect.gen(function* () {
1356
+ const fresh = yield* ServerSettingsModule.ServerSettingsService;
1357
+ return yield* fresh.getSettings;
1358
+ }).pipe(
1359
+ Effect.provide(
1360
+ Layer.fresh(ServerSettingsModule.layer).pipe(
1361
+ Layer.provide(Layer.merge(ServerSecretStore.layer, ManagedPolicy.layerTest())),
1362
+ ),
1363
+ ),
1364
+ );
1365
+ assert.equal(
1366
+ reloaded.providerInstances[instanceId]?.environment?.[redactedLast ? 1 : 0]?.value,
1367
+ expected,
1368
+ );
1369
+ }).pipe(Effect.provide(layerServerSettings())),
1370
+ );
1371
+
1372
+ it.effect("removes a kept secret once every row with its name is deleted", () =>
1373
+ Effect.gen(function* () {
1374
+ const service = yield* ServerSettingsModule.ServerSettingsService;
1375
+ const store = yield* ServerSecretStore.ServerSecretStore;
1376
+ const instanceId = ProviderInstanceId.make("codex_personal");
1377
+ const save = (environment: ProviderInstanceEnvironment) =>
1378
+ service.updateSettings({
1379
+ providerInstances: {
1380
+ [instanceId]: { driver: ProviderDriverKind.make("codex"), environment, config: {} },
1381
+ },
1382
+ });
1383
+ yield* save([{ name: "FOO", value: "stored-foo", sensitive: true }]);
1384
+ yield* save([
1385
+ { name: "FOO", value: "", sensitive: true, valueRedacted: true },
1386
+ { name: "FOO", value: "plain-foo", sensitive: false },
1387
+ ]);
1388
+ const secretName = "provider-env-Y29kZXhfcGVyc29uYWw-Rk9P";
1389
+ assert.isTrue(Option.isSome(yield* store.get(secretName)));
1390
+ yield* save([]);
1391
+ assert.isTrue(Option.isNone(yield* store.get(secretName)));
1392
+ }).pipe(Effect.provide(layerServerSettingsWithSecrets())),
1393
+ );
1394
+
1395
it.effect.each([true, false])(
1396
"preserves duplicate secret operation order (sensitive last: %s)",
1397
(sensitiveLast) =>
apps/server/src/serverSettings.ts
+34
-9
@@ -1027,13 +1027,22 @@ const make = Effect.gen(function* () {
1027
1028
const persistSettingsSecrets = (current: ServerSettings, next: ServerSettings) =>
1029
Effect.sync(() => {
1030
+ // Only sensitive rows own a stored secret; a plain duplicate must not hide one from cleanup.
1031
const previous = new Map<string, SettingsSecret>();
1032
+ const inlineValues = new Map<string, string>();
1033
mapSettingsSecrets(current, (secret) => {
1034
+ if (!secret.sensitive) return secret;
1035
previous.set(secret.secretName, secret);
1036
+ if (!secret.redacted && secret.value.length > 0) {
1037
+ inlineValues.set(secret.secretName, secret.value);
1038
+ }
1039
return secret;
1040
});
1041
const changes: SecretChange[] = [];
1042
const nextSecretNames = new Set<string>();
1043
+ const keptSecretNames = new Set<string>();
1044
+ const writtenSecretNames = new Set<string>();
1045
+ const inlineWrites = new Map<string, SecretChange>();
1046
const settings = mapSettingsSecrets(withEchoedSecretReferences(current, next), (secret) => {
1047
const metadata = {
1048
secretName: secret.secretName,
@@ -1048,24 +1057,34 @@ const make = Effect.gen(function* () {
1057
changes.push({ ...metadata, kind: "remove", operation: "remove-secret" });
1058
return { value: secret.value, redacted: false };
1059
}
1051
- const old = previous.get(secret.secretName);
1052
- const inlineValue =
1053
- old?.sensitive && !old.redacted && old.value.length > 0 ? old.value : undefined;
1054
- const value = secret.redacted ? inlineValue : secret.value;
1055
- if (value === undefined) {
1060
+ if (secret.redacted) {
1061
+ keptSecretNames.add(secret.secretName);
1062
nextSecretNames.add(secret.secretName);
1063
+ const inlineValue = inlineValues.get(secret.secretName);
1064
+ if (inlineValue !== undefined) {
1065
+ inlineWrites.set(secret.secretName, {
1066
+ ...metadata,
1067
+ kind: "write",
1068
+ value: textEncoder.encode(inlineValue),
1069
+ });
1070
+ }
1071
return { value: "", redacted: true };
1072
}
1059
- if (value.length === 0) {
1073
+ if (secret.value.length === 0) {
1074
changes.push({ ...metadata, kind: "remove", operation: "remove-secret" });
1075
return { value: "", redacted: false };
1076
}
1077
nextSecretNames.add(secret.secretName);
1064
- changes.push({ ...metadata, kind: "write", value: textEncoder.encode(value) });
1078
+ writtenSecretNames.add(secret.secretName);
1079
+ changes.push({ ...metadata, kind: "write", value: textEncoder.encode(secret.value) });
1080
return { value: "", redacted: true };
1081
});
1082
+ // A legacy inline value only moves to the store when no row in this save replaces it.
1083
+ for (const [secretName, change] of inlineWrites) {
1084
+ if (!writtenSecretNames.has(secretName)) changes.push(change);
1085
+ }
1086
for (const secret of previous.values()) {
1068
- if (!secret.sensitive || nextSecretNames.has(secret.secretName)) continue;
1087
+ if (nextSecretNames.has(secret.secretName)) continue;
1088
if (changes.some((change) => change.secretName === secret.secretName)) continue;
1089
changes.push({
1090
kind: "remove",
@@ -1079,7 +1098,13 @@ const make = Effect.gen(function* () {
1098
: {}),
1099
});
1100
}
1082
- return { settings, changes };
1101
+ return {
1102
+ settings,
1103
+ // A redacted row still claims its stored secret, so a duplicate row must not remove it.
1104
+ changes: changes.filter(
1105
+ (change) => change.kind === "write" || !keptSecretNames.has(change.secretName),
1106
+ ),
1107
+ };
1108
});
1109
1110
const rollbackSettingsSecretWrites = (