Skip to content

Commit baca7c3

Browse files
SARAsBooksclaude
authored andcommitted
fix(server): a Codex launcher that needs node recovers when the shell PATH arrives
An npm-installed Codex launcher spawns on the bare launchd PATH, then fails because node is only on the login-shell PATH. Its snapshot is installed with status "error", so the late-PATH rebuild skipped it and it stayed failed. Failed Codex checks are now rebuilt too. Other drivers are left alone: Cursor reports auth and catalog failures as "error", and a rebuild closes its sessions. Co-Authored-By: Claude Opus 5.5 <[email protected]>
1 parent afede16 commit baca7c3

2 files changed

Lines changed: 165 additions & 150 deletions

File tree

‎apps/server/src/provider/ProviderRegistry.test.ts‎

Lines changed: 154 additions & 146 deletions
Original file line numberDiff line numberDiff line change
@@ -1161,163 +1161,171 @@ it.layer(
11611161
);
11621162
});
11631163

1164-
it.effect.each(["replay", "in-flight missing", "in-flight installed"] as const)(
1165-
"recovers a copied driver environment after late PATH (%s)",
1166-
(mode) =>
1167-
Effect.gen(function* () {
1168-
const host = { PATH: "/early/bin", T3CODE_CODEX_LAUNCH_ARGS: "hidden" };
1169-
const environment = providerHostEnvironment(
1170-
{ organization: "PATH test", lockedSettings: [] },
1171-
host,
1172-
);
1173-
const updates = yield* DesktopTelemetryReceiver.makeDesktopShellEnvironmentUpdates(
1174-
host,
1175-
"linux",
1176-
);
1177-
const entered = yield* Deferred.make<void>();
1178-
const release = yield* Deferred.make<void>();
1179-
const finished = yield* Deferred.make<void>();
1180-
const paths: Array<string | undefined> = [];
1181-
let first = true;
1182-
const driverKind = ProviderDriverKind.make("pi");
1183-
const instanceId = ProviderInstanceId.make("late-path");
1184-
const driver: AnyProviderDriver = {
1185-
driverKind,
1186-
metadata: { displayName: "PATH fixture" },
1187-
configSchema: Schema.Unknown,
1188-
defaultConfig: () => ({}),
1189-
create: (input) =>
1190-
Effect.gen(function* () {
1191-
const copied = { ...environment };
1192-
paths.push(copied.PATH);
1193-
const installed =
1194-
mode === "in-flight installed" || copied.PATH?.includes("/late/bin") === true;
1195-
const snapshot: ServerProvider = {
1196-
instanceId,
1197-
driver: driverKind,
1198-
enabled: true,
1199-
installed: false,
1200-
status: "warning",
1201-
auth: { status: "unknown" },
1202-
version: null,
1203-
checkedAt: "2026-10-03T00:00:00.000Z",
1204-
models: [],
1205-
slashCommands: [],
1206-
skills: [],
1207-
};
1208-
const current = yield* Ref.make(snapshot);
1209-
return {
1210-
instanceId: input.instanceId,
1211-
driverKind,
1212-
enabled: true,
1213-
displayName: undefined,
1214-
continuationIdentity: { driverKind, continuationKey: "pi:late-path" },
1215-
snapshot: {
1216-
resolveMaintenance: () =>
1217-
Effect.succeed(
1218-
makeManualOnlyProviderMaintenanceCapabilities({
1219-
provider: driverKind,
1220-
packageName: null,
1221-
}),
1222-
),
1223-
getSnapshot: Ref.get(current),
1224-
refresh: Effect.gen(function* () {
1225-
if (first && mode !== "replay") {
1226-
first = false;
1227-
yield* Deferred.succeed(entered, undefined);
1228-
yield* Deferred.await(release);
1229-
}
1230-
const checked = {
1231-
...snapshot,
1232-
installed,
1233-
status: installed ? ("ready" as const) : ("error" as const),
1234-
};
1235-
yield* Ref.set(current, checked);
1236-
return checked;
1237-
}),
1238-
streamChanges: Stream.empty,
1239-
applyUsageLimits: () => Effect.void,
1240-
},
1241-
orchestrationAdapter: {} as ProviderInstance["orchestrationAdapter"],
1242-
textGeneration: {} as ProviderInstance["textGeneration"],
1243-
} satisfies ProviderInstance;
1244-
}),
1245-
};
1246-
const built = yield* ProviderInstanceRegistry.makeProviderInstanceRegistry({
1247-
drivers: [driver],
1248-
configMap: { [instanceId]: { driver: driverKind, enabled: true } },
1249-
}).pipe(Effect.provide(Layer.mock(SecretResolver.SecretResolver)({})));
1250-
yield* Effect.gen(function* () {
1251-
const registry = yield* ProviderRegistry.ProviderRegistry;
1252-
const running =
1253-
mode === "replay" ? undefined : yield* registry.refresh().pipe(Effect.forkScoped);
1254-
if (running) yield* Deferred.await(entered);
1255-
yield* updates.apply({
1256-
version: 1,
1257-
type: "shellEnvironment",
1258-
platform: "linux",
1259-
discovered: true,
1260-
environment: { PATH: "/early/bin:/late/bin" },
1261-
});
1262-
expect(paths).toEqual(["/early/bin"]);
1263-
if (mode === "replay") {
1264-
yield* Layer.build(
1265-
ProviderHostPathWatcher.layer.pipe(
1266-
Layer.provide(
1267-
DesktopTelemetryReceiver.layerTest({ pathChanges: updates.pathChanges }),
1268-
),
1269-
Layer.provide(
1270-
Layer.succeed(ProviderRegistry.ProviderRegistry, {
1271-
...registry,
1272-
rebuildMissingAndRefresh: registry.rebuildMissingAndRefresh.pipe(
1273-
Effect.tap(() => Deferred.succeed(finished, undefined)),
1274-
),
1275-
}),
1276-
),
1277-
),
1278-
);
1279-
} else {
1280-
yield* registry.rebuildMissingAndRefresh.pipe(
1281-
Effect.tap(() => Deferred.succeed(finished, undefined)),
1282-
Effect.forkScoped({ startImmediately: true }),
1283-
);
1284-
expect(paths).toEqual(["/early/bin"]);
1285-
}
1286-
yield* Deferred.succeed(release, undefined);
1287-
if (running) yield* Fiber.join(running);
1288-
yield* Deferred.await(finished);
1289-
expect(
1290-
(yield* registry.getProviders).find((row) => row.instanceId === instanceId)
1291-
?.installed,
1292-
).toBe(true);
1293-
expect(paths).toEqual(
1294-
mode === "in-flight installed"
1295-
? ["/early/bin"]
1296-
: ["/early/bin", "/early/bin:/late/bin"],
1297-
);
1298-
}).pipe(
1299-
Effect.provide(
1300-
ProviderRegistry.layer.pipe(
1164+
it.effect.each([
1165+
"replay",
1166+
"in-flight missing",
1167+
"in-flight installed",
1168+
"launcher",
1169+
"other error",
1170+
] as const)("recovers a copied driver environment after late PATH (%s)", (mode) =>
1171+
Effect.gen(function* () {
1172+
// "launcher": the Codex CLI is found on the early PATH, but its check fails until the
1173+
// late PATH brings the node its npm launcher runs. "other error" is the same failure on a
1174+
// driver whose errors may be auth or network, so it must not be rebuilt.
1175+
const failsEarly = mode === "launcher" || mode === "other error";
1176+
const replay = mode === "replay" || failsEarly;
1177+
const host = { PATH: "/early/bin", T3CODE_CODEX_LAUNCH_ARGS: "hidden" };
1178+
const environment = providerHostEnvironment(
1179+
{ organization: "PATH test", lockedSettings: [] },
1180+
host,
1181+
);
1182+
const updates = yield* DesktopTelemetryReceiver.makeDesktopShellEnvironmentUpdates(
1183+
host,
1184+
"linux",
1185+
);
1186+
const entered = yield* Deferred.make<void>();
1187+
const release = yield* Deferred.make<void>();
1188+
const finished = yield* Deferred.make<void>();
1189+
const paths: Array<string | undefined> = [];
1190+
let first = true;
1191+
const driverKind = ProviderDriverKind.make(mode === "launcher" ? "codex" : "pi");
1192+
const instanceId = ProviderInstanceId.make("late-path");
1193+
const driver: AnyProviderDriver = {
1194+
driverKind,
1195+
metadata: { displayName: "PATH fixture" },
1196+
configSchema: Schema.Unknown,
1197+
defaultConfig: () => ({}),
1198+
create: (input) =>
1199+
Effect.gen(function* () {
1200+
const copied = { ...environment };
1201+
paths.push(copied.PATH);
1202+
const late = copied.PATH?.includes("/late/bin") === true;
1203+
const installed = mode === "in-flight installed" || failsEarly || late;
1204+
const ready = failsEarly ? late : installed;
1205+
const snapshot: ServerProvider = {
1206+
instanceId,
1207+
driver: driverKind,
1208+
enabled: true,
1209+
installed: false,
1210+
status: "warning",
1211+
auth: { status: "unknown" },
1212+
version: null,
1213+
checkedAt: "2026-10-03T00:00:00.000Z",
1214+
models: [],
1215+
slashCommands: [],
1216+
skills: [],
1217+
};
1218+
const current = yield* Ref.make(snapshot);
1219+
return {
1220+
instanceId: input.instanceId,
1221+
driverKind,
1222+
enabled: true,
1223+
displayName: undefined,
1224+
continuationIdentity: { driverKind, continuationKey: `${driverKind}:late-path` },
1225+
snapshot: {
1226+
resolveMaintenance: () =>
1227+
Effect.succeed(
1228+
makeManualOnlyProviderMaintenanceCapabilities({
1229+
provider: driverKind,
1230+
packageName: null,
1231+
}),
1232+
),
1233+
getSnapshot: Ref.get(current),
1234+
refresh: Effect.gen(function* () {
1235+
if (first && !replay) {
1236+
first = false;
1237+
yield* Deferred.succeed(entered, undefined);
1238+
yield* Deferred.await(release);
1239+
}
1240+
const checked = {
1241+
...snapshot,
1242+
installed,
1243+
status: ready ? ("ready" as const) : ("error" as const),
1244+
};
1245+
yield* Ref.set(current, checked);
1246+
return checked;
1247+
}),
1248+
streamChanges: Stream.empty,
1249+
applyUsageLimits: () => Effect.void,
1250+
},
1251+
orchestrationAdapter: {} as ProviderInstance["orchestrationAdapter"],
1252+
textGeneration: {} as ProviderInstance["textGeneration"],
1253+
} satisfies ProviderInstance;
1254+
}),
1255+
};
1256+
const built = yield* ProviderInstanceRegistry.makeProviderInstanceRegistry({
1257+
drivers: [driver],
1258+
configMap: { [instanceId]: { driver: driverKind, enabled: true } },
1259+
}).pipe(Effect.provide(Layer.mock(SecretResolver.SecretResolver)({})));
1260+
yield* Effect.gen(function* () {
1261+
const registry = yield* ProviderRegistry.ProviderRegistry;
1262+
const running = replay ? undefined : yield* registry.refresh().pipe(Effect.forkScoped);
1263+
if (running) yield* Deferred.await(entered);
1264+
yield* updates.apply({
1265+
version: 1,
1266+
type: "shellEnvironment",
1267+
platform: "linux",
1268+
discovered: true,
1269+
environment: { PATH: "/early/bin:/late/bin" },
1270+
});
1271+
expect(paths).toEqual(["/early/bin"]);
1272+
if (replay) {
1273+
yield* Layer.build(
1274+
ProviderHostPathWatcher.layer.pipe(
13011275
Layer.provide(
1302-
Layer.succeed(ProviderInstanceRegistry.ProviderInstanceRegistry, built.registry),
1276+
DesktopTelemetryReceiver.layerTest({ pathChanges: updates.pathChanges }),
13031277
),
13041278
Layer.provide(
1305-
Layer.succeed(
1306-
ProviderInstanceRegistryMutator.ProviderInstanceRegistryMutator,
1307-
built.mutator,
1308-
),
1279+
Layer.succeed(ProviderRegistry.ProviderRegistry, {
1280+
...registry,
1281+
rebuildMissingAndRefresh: registry.rebuildMissingAndRefresh.pipe(
1282+
Effect.tap(() => Deferred.succeed(finished, undefined)),
1283+
),
1284+
}),
13091285
),
13101286
),
1311-
),
1287+
);
1288+
} else {
1289+
yield* registry.rebuildMissingAndRefresh.pipe(
1290+
Effect.tap(() => Deferred.succeed(finished, undefined)),
1291+
Effect.forkScoped({ startImmediately: true }),
1292+
);
1293+
expect(paths).toEqual(["/early/bin"]);
1294+
}
1295+
yield* Deferred.succeed(release, undefined);
1296+
if (running) yield* Fiber.join(running);
1297+
yield* Deferred.await(finished);
1298+
expect(
1299+
(yield* registry.getProviders).find((row) => row.instanceId === instanceId)?.installed,
1300+
).toBe(true);
1301+
expect(paths).toEqual(
1302+
mode === "in-flight installed" || mode === "other error"
1303+
? ["/early/bin"]
1304+
: ["/early/bin", "/early/bin:/late/bin"],
13121305
);
13131306
}).pipe(
1314-
Effect.scoped,
13151307
Effect.provide(
1316-
ServerConfig.layerTest(process.cwd(), { prefix: "t3-late-path-" }).pipe(
1317-
Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
1308+
ProviderRegistry.layer.pipe(
1309+
Layer.provide(
1310+
Layer.succeed(ProviderInstanceRegistry.ProviderInstanceRegistry, built.registry),
1311+
),
1312+
Layer.provide(
1313+
Layer.succeed(
1314+
ProviderInstanceRegistryMutator.ProviderInstanceRegistryMutator,
1315+
built.mutator,
1316+
),
1317+
),
13181318
),
13191319
),
1320+
);
1321+
}).pipe(
1322+
Effect.scoped,
1323+
Effect.provide(
1324+
ServerConfig.layerTest(process.cwd(), { prefix: "t3-late-path-" }).pipe(
1325+
Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
1326+
),
13201327
),
1328+
),
13211329
);
13221330

13231331
describe("Codex model inventories", () => {

‎apps/server/src/provider/ProviderRegistry.ts‎

Lines changed: 11 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -70,8 +70,9 @@ export class ProviderRegistry extends Context.Service<
7070
) => Effect.Effect<ReadonlyArray<ServerProvider>>;
7171

7272
/**
73-
* Rebuilds and re-checks enabled instances not yet found installed, after the host environment
74-
* changed. Drivers copy the environment when built, so only a rebuild sees a later PATH.
73+
* Rebuilds and re-checks enabled instances not yet found installed, plus failed Codex checks,
74+
* after the host environment changed. Drivers copy the environment when built, so only a rebuild
75+
* sees a later PATH.
7576
*/
7677
readonly rebuildMissingAndRefresh: Effect.Effect<ReadonlyArray<ServerProvider>>;
7778

@@ -698,7 +699,9 @@ export const layer = Layer.effect(
698699
return yield* instanceId === undefined ? refresh() : refreshInstance(instanceId);
699700
});
700701

701-
// Instances that found their CLI keep running; restarting them could end live sessions.
702+
// Instances whose check passed keep running; restarting them could end live sessions. A failed
703+
// Codex check is rebuilt too: its npm launcher spawns on the bare PATH but cannot find node.
704+
// Other drivers report auth and network failures as "error", and a rebuild would close sessions.
702705
const rebuildMissingAndRefresh = Effect.fn("rebuildMissingAndRefresh")(function* () {
703706
const instances = yield* instanceRegistry.listInstances;
704707
yield* refresh();
@@ -712,7 +715,11 @@ export const layer = Layer.effect(
712715
)
713716
return false;
714717
const snapshot = yield* instance.snapshot.getSnapshot;
715-
return !snapshot.installed;
718+
return (
719+
!snapshot.installed ||
720+
(instance.driverKind === ProviderDriverKind.make("codex") &&
721+
snapshot.status === "error")
722+
);
716723
}),
717724
);
718725
if (missing.length === 0) return yield* Ref.get(providersRef);

0 commit comments

Comments
 (0)