@devries-cameron20 / t3code-1 / commits / 8e1581ad8c
Fork 0

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 = (