Skip to content

Commit d3f6ace

Browse files
only21milcodexmaria-rcks
authored
fix(web): respect provider permissions in bulk updates (pingdotgg#23183)
Co-authored-by: GPT-6.1 Sol <[email protected]> Co-authored-by: maria-rcks <[email protected]>
1 parent e03b696 commit d3f6ace

2 files changed

Lines changed: 160 additions & 2 deletions

File tree

Lines changed: 153 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,153 @@
1+
import { RegistryContext } from "@effect/atom-react";
2+
import {
3+
AuthProvidersManageScope,
4+
type AuthSessionState,
5+
EnvironmentId,
6+
ProviderDriverKind,
7+
ProviderInstanceId,
8+
type ServerProvider,
9+
} from "@t3tools/contracts";
10+
import { AsyncResult, Atom } from "effect/reactivity";
11+
import { useEffect } from "react";
12+
import { expect, it, vi } from "vite-plus/test";
13+
14+
import { act, render } from "../../test/render";
15+
16+
const state = vi.hoisted(() => ({
17+
environments: [] as {
18+
environmentId: EnvironmentId;
19+
label: string;
20+
connection: { phase: "connected" | "disconnected" };
21+
}[],
22+
providers: new Map<EnvironmentId, ReadonlyArray<ServerProvider>>(),
23+
requests: [] as EnvironmentId[],
24+
sessions: new Map<EnvironmentId, Atom.Writable<AsyncResult.AsyncResult<AuthSessionState>>>(),
25+
}));
26+
27+
vi.mock(import("~/state/environments"), () => ({
28+
useEnvironments: (() => ({ environments: state.environments })) as never,
29+
useEnvironmentProviders: () => state.providers,
30+
}));
31+
vi.mock(import("@t3tools/client-runtime/state/session"), async (original) => {
32+
const actual = await original();
33+
return {
34+
...actual,
35+
createEnvironmentSessionAtoms: ((
36+
...args: Parameters<typeof actual.createEnvironmentSessionAtoms>
37+
) => ({
38+
...actual.createEnvironmentSessionAtoms(...args),
39+
sessionStateAtom: (id: EnvironmentId) => state.sessions.get(id)!,
40+
})) as typeof actual.createEnvironmentSessionAtoms,
41+
};
42+
});
43+
vi.mock(import("~/state/server"), () => ({
44+
serverEnvironment: { updateProvider: {} } as never,
45+
}));
46+
vi.mock(import("~/state/use-atom-command"), () => ({
47+
useAtomCommand: (() =>
48+
async ({ environmentId }: { environmentId: EnvironmentId }) => {
49+
state.requests.push(environmentId);
50+
return AsyncResult.success(undefined);
51+
}) as never,
52+
}));
53+
54+
import { appAtomRegistry } from "~/rpc/atomRegistry";
55+
import { useProviderUpdates } from "./ProviderUpdatesAction";
56+
57+
const provider: ServerProvider = {
58+
instanceId: ProviderInstanceId.make("codex"),
59+
driver: ProviderDriverKind.make("codex"),
60+
enabled: true,
61+
installed: true,
62+
version: "1.0.0",
63+
status: "ready",
64+
auth: { status: "authenticated" },
65+
checkedAt: "2026-10-21T00:00:00.000Z",
66+
models: [],
67+
slashCommands: [],
68+
skills: [],
69+
versionAdvisory: {
70+
status: "behind_latest",
71+
currentVersion: "1.0.0",
72+
latestVersion: "1.1.0",
73+
updateCommand: "npm install -g @openai/codex",
74+
canUpdate: true,
75+
checkedAt: "2026-10-21T00:00:00.000Z",
76+
message: "Update available.",
77+
},
78+
};
79+
80+
function session(
81+
scopes: NonNullable<AuthSessionState["scopes"]>,
82+
): AsyncResult.AsyncResult<AuthSessionState> {
83+
return AsyncResult.success<AuthSessionState>({
84+
authenticated: true,
85+
scopes,
86+
auth: {
87+
policy: "remote-reachable",
88+
bootstrapMethods: ["one-time-token"],
89+
sessionMethods: ["bearer-access-token"],
90+
sessionCookieName: "t3_session",
91+
},
92+
});
93+
}
94+
95+
function setup() {
96+
state.environments = [
97+
{ environmentId: EnvironmentId.make("read-only"), label: "Read only" },
98+
{ environmentId: EnvironmentId.make("writable"), label: "Writable" },
99+
{ environmentId: EnvironmentId.make("unresolved"), label: "Unresolved" },
100+
].map((environment) => ({ ...environment, connection: { phase: "connected" } }));
101+
state.providers = new Map(
102+
state.environments.map(({ environmentId }) => [environmentId, [provider]]),
103+
);
104+
state.requests = [];
105+
const sessions = new Map<EnvironmentId, Atom.Writable<AsyncResult.AsyncResult<AuthSessionState>>>(
106+
[
107+
[state.environments[0]!.environmentId, Atom.make(session(["orchestration:read"]))],
108+
[state.environments[1]!.environmentId, Atom.make(session([AuthProvidersManageScope]))],
109+
[
110+
state.environments[2]!.environmentId,
111+
Atom.make<AsyncResult.AsyncResult<AuthSessionState>>(
112+
AsyncResult.initial<AuthSessionState>(),
113+
),
114+
],
115+
],
116+
);
117+
state.sessions = sessions;
118+
return { sessions };
119+
}
120+
121+
it("bulk provider updates exclude connections without a confirmed management grant", async () => {
122+
const fixture = setup();
123+
let updates!: ReturnType<typeof useProviderUpdates>;
124+
function Probe() {
125+
const nextUpdates = useProviderUpdates();
126+
useEffect(() => {
127+
updates = nextUpdates;
128+
}, [nextUpdates]);
129+
return null;
130+
}
131+
await using _screen = await render(
132+
<RegistryContext.Provider value={appAtomRegistry}>
133+
<Probe />
134+
</RegistryContext.Provider>,
135+
);
136+
137+
const writableId = state.environments[1]!.environmentId;
138+
expect(updates.machines.map(({ environmentId }) => environmentId)).toEqual([writableId]);
139+
await act(async () => {
140+
await updates.updateAll({ quiet: true });
141+
});
142+
expect(state.requests).toEqual([writableId]);
143+
144+
await act(() => {
145+
appAtomRegistry.set(fixture.sessions.get(writableId)!, session(["orchestration:read"]));
146+
});
147+
expect(updates.machines).toEqual([]);
148+
state.requests = [];
149+
await act(async () => {
150+
await updates.updateAll({ quiet: true });
151+
});
152+
expect(state.requests).toEqual([]);
153+
});

‎apps/web/src/components/ProviderUpdatesAction.tsx‎

Lines changed: 7 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,10 @@
1-
import { PROVIDER_DISPLAY_NAMES } from "@t3tools/contracts";
1+
import { AuthProvidersManageScope, PROVIDER_DISPLAY_NAMES } from "@t3tools/contracts";
22
import { settlePromise } from "@t3tools/client-runtime/state/runtime";
33
import { useRef, useState } from "react";
44

55
import { useEnvironmentProviders, useEnvironments } from "~/state/environments";
66
import { serverEnvironment } from "~/state/server";
7+
import { useEnvironmentsWithScope } from "~/state/session";
78
import { useAtomCommand } from "~/state/use-atom-command";
89
import {
910
canOneClickUpdateProviderCandidate,
@@ -17,13 +18,17 @@ import { Tooltip, TooltipPopup, TooltipTrigger } from "./ui/tooltip";
1718

1819
export function useProviderUpdates() {
1920
const { environments } = useEnvironments();
21+
const manageableIds = useEnvironmentsWithScope(environments, AuthProvidersManageScope);
2022
const providersByEnvironment = useEnvironmentProviders();
2123
const updateProvider = useAtomCommand(serverEnvironment.updateProvider, {
2224
reportFailure: false,
2325
});
2426
const machines = environments.flatMap((environment) => {
2527
const providers = providersByEnvironment.get(environment.environmentId) ?? [];
26-
if (environment.connection.phase !== "connected") {
28+
if (
29+
environment.connection.phase !== "connected" ||
30+
!manageableIds.has(environment.environmentId)
31+
) {
2732
return [];
2833
}
2934
const candidates = collectProviderUpdateCandidates(providers).filter((candidate) =>

0 commit comments

Comments
 (0)