The best way to control Claude Code, Codex and more from any computer or phone

main
ts 653 lines 21.1 KB
Raw
1 import {
2 DEFAULT_MODEL_BY_PROVIDER,
3 ProjectId,
4 ProviderDriverKind,
5 ProviderInstanceId,
6 type ServerProvider,
7 } from "@t3tools/contracts";
8 import { describe, expect, it } from "vite-plus/test";
9 import {
10 applyProviderInstanceSettings,
11 brandProviderInstanceEntries,
12 deriveProviderEntriesByEnvironment,
13 deriveProviderInstanceEntries,
14 getDefaultProviderInstanceModel,
15 isProviderInstancePickerReady,
16 resolveDefaultProviderModelSelection,
17 resolveSelectableProviderInstance,
18 shouldShowInstanceBadge,
19 } from "./providerInstances";
20
21 function provider(input: {
22 provider: ProviderDriverKind;
23 instanceId: string;
24 enabled?: boolean;
25 availability?: ServerProvider["availability"];
26 displayName?: string;
27 accentColor?: string;
28 status?: ServerProvider["status"];
29 models?: ServerProvider["models"];
30 supportsTextGeneration?: boolean;
31 }): ServerProvider {
32 return {
33 instanceId: ProviderInstanceId.make(input.instanceId),
34 driver: input.provider,
35 ...(input.supportsTextGeneration === undefined
36 ? {}
37 : { supportsTextGeneration: input.supportsTextGeneration }),
38 ...(input.displayName ? { displayName: input.displayName } : {}),
39 ...(input.accentColor ? { accentColor: input.accentColor } : {}),
40 enabled: input.enabled ?? true,
41 installed: true,
42 version: null,
43 status: input.status ?? "ready",
44 ...(input.availability ? { availability: input.availability } : {}),
45 auth: { status: "authenticated" },
46 checkedAt: "2026-01-01T00:00:00.000Z",
47 models: input.models ?? [],
48 slashCommands: [],
49 skills: [],
50 };
51 }
52
53 const model = (slug: string, isCustom = false, isDefault = false) => ({
54 slug,
55 name: slug,
56 isCustom,
57 ...(isDefault ? { isDefault: true } : {}),
58 capabilities: {},
59 });
60
61 describe("isProviderInstancePickerReady", () => {
62 it("rejects a disabled instance even while its last probe status is ready", () => {
63 const [entry] = deriveProviderInstanceEntries([
64 provider({
65 provider: ProviderDriverKind.make("codex"),
66 instanceId: "codex",
67 enabled: false,
68 }),
69 ]);
70
71 expect(entry?.status).toBe("ready");
72 expect(entry && isProviderInstancePickerReady(entry)).toBe(false);
73 });
74
75 it("offers a warning provider's models on its usable sub-providers only", () => {
76 const backendModel = (slug: string, subProvider: string) => ({ ...model(slug), subProvider });
77 const fx = (models: ServerProvider["models"]) => ({
78 ...provider({
79 provider: ProviderDriverKind.make("fx"),
80 instanceId: "fx",
81 status: "warning",
82 models,
83 }),
84 subProviders: [
85 { name: "Gateway" },
86 { name: "Codex", unavailableReason: "Signed out. Run `fx login codex` on this machine." },
87 ],
88 });
89 const ready = (snapshot: ServerProvider) =>
90 deriveProviderInstanceEntries([snapshot]).map(isProviderInstancePickerReady)[0];
91
92 expect(
93 ready(fx([model("default", false, true), backendModel("openai/gpt-5.5", "Gateway")])),
94 ).toBe(true);
95 expect(ready(fx([model("default", false, true), backendModel("gpt-5.5", "Codex")]))).toBe(
96 false,
97 );
98 });
99
100 it("keeps offering the models a refresh retained when the catalog did not arrive in time", () => {
101 const [entry] = deriveProviderInstanceEntries([
102 {
103 ...provider({
104 provider: ProviderDriverKind.make("codex"),
105 instanceId: "codex",
106 status: "warning",
107 models: [model("gpt-5.5", false, true), model("gpt-5.4")],
108 }),
109 message: "Codex did not return its model catalog in time.",
110 },
111 ]);
112
113 expect(entry && isProviderInstancePickerReady(entry)).toBe(true);
114 expect(
115 entry && isProviderInstancePickerReady({ ...entry, models: [model("bailian", true)] }),
116 ).toBe(true);
117 expect(entry && isProviderInstancePickerReady({ ...entry, models: [] })).toBe(false);
118 });
119
120 it("offers a failed provider's models only while the server marks them retained", () => {
121 const failed = provider({
122 provider: ProviderDriverKind.make("codex"),
123 instanceId: "codex",
124 status: "error",
125 models: [model("gpt-5.5", false, true)],
126 });
127 const ready = (snapshot: ServerProvider) =>
128 deriveProviderInstanceEntries([snapshot]).map(isProviderInstancePickerReady)[0];
129
130 expect(ready({ ...failed, modelsRetained: true })).toBe(true);
131 expect(ready(failed)).toBe(false);
132 expect(ready({ ...failed, status: "warning", auth: { status: "unknown" } })).toBe(false);
133 });
134 });
135
136 describe("applyProviderInstanceSettings", () => {
137 it("uses settings when a streamed snapshot still reports a disabled default as enabled", () => {
138 const entries = deriveProviderInstanceEntries([
139 provider({ provider: ProviderDriverKind.make("codex"), instanceId: "codex" }),
140 ]);
141 const [entry] = applyProviderInstanceSettings(
142 entries,
143 {
144 providerInstances: {
145 [ProviderInstanceId.make("codex")]: {
146 driver: ProviderDriverKind.make("codex"),
147 enabled: false,
148 },
149 },
150 projectSettingsOverrides: {},
151 },
152 null,
153 );
154
155 expect(entry?.enabled).toBe(false);
156 });
157
158 it.each(["constructor", "toString"])(
159 "treats a removed custom instance named %s as disabled",
160 (instanceId) => {
161 const entries = deriveProviderInstanceEntries([
162 provider({
163 provider: ProviderDriverKind.make("claudeAgent"),
164 instanceId,
165 }),
166 ]);
167 const [entry] = applyProviderInstanceSettings(
168 entries,
169 {
170 providerInstances: {},
171 projectSettingsOverrides: {},
172 },
173 null,
174 );
175
176 expect(entry?.enabled).toBe(false);
177 },
178 );
179
180 // regression: #8337 provider ids matching Object.prototype keys resolved to prototype members
181 it("uses settings for a configured custom instance named constructor", () => {
182 const instanceId = ProviderInstanceId.make("constructor");
183 const entries = deriveProviderInstanceEntries([
184 provider({
185 provider: ProviderDriverKind.make("claudeAgent"),
186 instanceId,
187 }),
188 ]);
189 const [entry] = applyProviderInstanceSettings(
190 entries,
191 {
192 providerInstances: {
193 [instanceId]: {
194 driver: ProviderDriverKind.make("claudeAgent"),
195 enabled: false,
196 },
197 },
198 projectSettingsOverrides: {},
199 },
200 null,
201 );
202
203 expect(entry?.enabled).toBe(false);
204 });
205
206 it("uses the driver default for an unconfigured built-in default instance", () => {
207 const entries = deriveProviderInstanceEntries([
208 provider({ provider: ProviderDriverKind.make("codex"), instanceId: "codex", enabled: false }),
209 provider({ provider: ProviderDriverKind.make("grok"), instanceId: "grok", enabled: true }),
210 ]);
211 const [codex, grok] = applyProviderInstanceSettings(
212 entries,
213 {
214 providerInstances: {},
215 projectSettingsOverrides: {},
216 },
217 null,
218 );
219
220 expect(codex?.enabled).toBe(true);
221 expect(grok?.enabled).toBe(false);
222 });
223 });
224
225 describe("deriveProviderEntriesByEnvironment", () => {
226 it("resolves registry branding from each environment's settings", () => {
227 const instanceId = "custom-acp";
228 const snapshot = provider({ provider: ProviderDriverKind.make("acpRegistry"), instanceId });
229 const byEnvironment = deriveProviderEntriesByEnvironment(
230 ["devin", "other-agent"].map(
231 (agentId) =>
232 [
233 agentId,
234 [snapshot],
235 {
236 providerInstances: {
237 [instanceId]: {
238 driver: ProviderDriverKind.make("acpRegistry"),
239 enabled: true,
240 config: { agentId, registryIconUrl: `https://example.com/${agentId}.svg` },
241 },
242 },
243 projectSettingsOverrides: {},
244 },
245 ] as const,
246 ),
247 );
248 expect(byEnvironment.get("devin")?.get(instanceId)?.acpRegistryAgentId).toBe("devin");
249 expect(byEnvironment.get("devin")?.get(instanceId)?.acpRegistryIconUrl).toBe(
250 "https://example.com/devin.svg",
251 );
252 expect(byEnvironment.get("other-agent")?.get(instanceId)?.acpRegistryAgentId).toBe(
253 "other-agent",
254 );
255 });
256
257 // regression: #7292 sidebar provider icons resolved from the wrong environment
258 it("keeps same-id default instances distinct per environment", () => {
259 const byEnvironment = deriveProviderEntriesByEnvironment([
260 [
261 "local",
262 [
263 provider({
264 provider: ProviderDriverKind.make("claude"),
265 instanceId: "claude",
266 displayName: "Claude Local",
267 accentColor: "#112233",
268 }),
269 ],
270 ],
271 [
272 "remote",
273 [
274 provider({
275 provider: ProviderDriverKind.make("claude"),
276 instanceId: "claude",
277 displayName: "Claude Remote",
278 accentColor: "#445566",
279 }),
280 ],
281 ],
282 ]);
283
284 expect(byEnvironment.get("local")?.get("claude")?.displayName).toBe("Claude Local");
285 expect(byEnvironment.get("local")?.get("claude")?.accentColor).toBe("#112233");
286 expect(byEnvironment.get("remote")?.get("claude")?.displayName).toBe("Claude Remote");
287 expect(byEnvironment.get("remote")?.get("claude")?.accentColor).toBe("#445566");
288 });
289
290 it("keeps an instance a project turns on as a sibling for the instance badge", () => {
291 const codex = ProviderDriverKind.make("codex");
292 const byEnvironment = deriveProviderEntriesByEnvironment([
293 [
294 "local",
295 [
296 provider({ provider: codex, instanceId: "codex" }),
297 provider({ provider: codex, instanceId: "codex_work" }),
298 ],
299 {
300 providerInstances: {
301 [ProviderInstanceId.make("codex_work")]: { driver: codex, enabled: false },
302 },
303 projectSettingsOverrides: {
304 [ProjectId.make("project-work")]: {
305 providerInstances: { [ProviderInstanceId.make("codex_work")]: { enabled: true } },
306 },
307 },
308 },
309 ],
310 ]);
311 const entries = byEnvironment.get("local");
312 const personal = entries?.get("codex");
313
314 expect(personal && shouldShowInstanceBadge(personal, entries?.values() ?? [])).toBe(true);
315 });
316 });
317
318 describe("brandProviderInstanceEntries", () => {
319 it("keeps an instance a project turns on as a sibling for the instance badge", () => {
320 const codex = ProviderDriverKind.make("codex");
321 const settings = {
322 providerInstances: {
323 [ProviderInstanceId.make("codex_work")]: { driver: codex, enabled: false },
324 },
325 projectSettingsOverrides: {
326 [ProjectId.make("project-work")]: {
327 providerInstances: { [ProviderInstanceId.make("codex_work")]: { enabled: true } },
328 },
329 },
330 };
331 const entries = brandProviderInstanceEntries(
332 deriveProviderInstanceEntries([
333 provider({ provider: codex, instanceId: "codex" }),
334 provider({ provider: codex, instanceId: "codex_work" }),
335 ]),
336 settings,
337 );
338 const personal = entries.find((entry) => entry.instanceId === "codex");
339
340 expect(personal && shouldShowInstanceBadge(personal, entries)).toBe(true);
341 });
342 });
343
344 describe("resolveSelectableProviderInstance", () => {
345 it("falls back to the first enabled and available instance", () => {
346 const disabled = ProviderInstanceId.make("codex");
347 const fallback = ProviderInstanceId.make("claudeAgent");
348 const providers = [
349 provider({
350 provider: ProviderDriverKind.make("codex"),
351 instanceId: disabled,
352 enabled: false,
353 }),
354 provider({ provider: ProviderDriverKind.make("claudeAgent"), instanceId: fallback }),
355 ];
356
357 expect(resolveSelectableProviderInstance(providers, disabled)).toBe(fallback);
358 });
359
360 it("prefers a ready instance over an enabled one whose driver cannot start", () => {
361 const notInstalled = ProviderInstanceId.make("codex");
362 const ready = ProviderInstanceId.make("claudeAgent");
363 const providers = [
364 provider({
365 provider: ProviderDriverKind.make("codex"),
366 instanceId: notInstalled,
367 status: "error",
368 }),
369 provider({ provider: ProviderDriverKind.make("claudeAgent"), instanceId: ready }),
370 ];
371
372 expect(resolveSelectableProviderInstance(providers, undefined)).toBe(ready);
373 });
374
375 it("keeps a requested instance even when its probe errored", () => {
376 const requested = ProviderInstanceId.make("codex");
377 const providers = [
378 provider({
379 provider: ProviderDriverKind.make("codex"),
380 instanceId: requested,
381 status: "error",
382 }),
383 provider({ provider: ProviderDriverKind.make("claudeAgent"), instanceId: "claudeAgent" }),
384 ];
385
386 expect(resolveSelectableProviderInstance(providers, requested)).toBe(requested);
387 });
388
389 // regression: #4117 users without Codex got a broken default provider
390 it("does not invent an errored instance as a new-user default", () => {
391 const notInstalled = ProviderInstanceId.make("codex");
392 const providers = [
393 provider({
394 provider: ProviderDriverKind.make("codex"),
395 instanceId: notInstalled,
396 status: "error",
397 }),
398 ];
399
400 expect(resolveSelectableProviderInstance(providers, undefined)).toBeUndefined();
401 });
402
403 it("does not return disabled, unavailable, or unknown instances when none are sendable", () => {
404 const disabled = ProviderInstanceId.make("codex");
405 const unavailable = ProviderInstanceId.make("claudeAgent");
406 const unknown = ProviderInstanceId.make("removed_instance");
407 const providers = [
408 provider({
409 provider: ProviderDriverKind.make("codex"),
410 instanceId: disabled,
411 enabled: false,
412 }),
413 provider({
414 provider: ProviderDriverKind.make("claudeAgent"),
415 instanceId: unavailable,
416 availability: "unavailable",
417 }),
418 ];
419
420 expect(resolveSelectableProviderInstance(providers, disabled)).toBeUndefined();
421 expect(resolveSelectableProviderInstance(providers, unavailable)).toBeUndefined();
422 expect(resolveSelectableProviderInstance(providers, unknown)).toBeUndefined();
423 });
424 });
425
426 describe("getDefaultProviderInstanceModel", () => {
427 it("uses the instance's own models, not the default instance of the kind", () => {
428 const providers = [
429 provider({
430 provider: ProviderDriverKind.make("claudeAgent"),
431 instanceId: "claude_openrouter",
432 models: [model("openai/gpt-5.5", true), model("claude-opus-4-8")],
433 }),
434 provider({
435 provider: ProviderDriverKind.make("claudeAgent"),
436 instanceId: "claudeAgent",
437 models: [model("claude-sonnet-5")],
438 }),
439 ];
440
441 expect(
442 getDefaultProviderInstanceModel(providers, ProviderInstanceId.make("claude_openrouter")),
443 ).toBe("claude-opus-4-8");
444 });
445
446 it("falls back to the driver default when the instance reports no models", () => {
447 const providers = [
448 provider({ provider: ProviderDriverKind.make("claudeAgent"), instanceId: "claudeAgent" }),
449 ];
450
451 const resolved = getDefaultProviderInstanceModel(
452 providers,
453 ProviderInstanceId.make("claudeAgent"),
454 );
455 expect(resolved).toBe(DEFAULT_MODEL_BY_PROVIDER[ProviderDriverKind.make("claudeAgent")]);
456 });
457
458 it("honors the instance's declared default before model-list order", () => {
459 const providers = [
460 provider({
461 provider: ProviderDriverKind.make("claudeAgent"),
462 instanceId: "claudeAgent",
463 models: [model("claude-sonnet-5"), model("claude-opus-4-8", false, true)],
464 }),
465 ];
466
467 expect(getDefaultProviderInstanceModel(providers, ProviderInstanceId.make("claudeAgent"))).toBe(
468 "claude-opus-4-8",
469 );
470 });
471 });
472
473 describe("resolveDefaultProviderModelSelection", () => {
474 // regression: #4117 users without Codex got a broken default provider
475 it.each([
476 ["codex", "codex", "gpt-5.6"],
477 ["claudeAgent", "claudeAgent", "claude-fable-5"],
478 ["cursor", "cursor", "composer-2"],
479 ])("uses the only available %s instance", (driver, instanceId, modelSlug) => {
480 const providers = [
481 provider({
482 provider: ProviderDriverKind.make(driver),
483 instanceId,
484 models: [model(modelSlug, false, true)],
485 }),
486 ];
487
488 expect(resolveDefaultProviderModelSelection(providers, null)).toEqual({
489 instanceId,
490 model: modelSlug,
491 });
492 });
493
494 it("preserves a valid stored selection including its options", () => {
495 const providers = [
496 provider({
497 provider: ProviderDriverKind.make("claudeAgent"),
498 instanceId: "claudeAgent",
499 models: [model("claude-opus-4-8")],
500 }),
501 ];
502 const stored = {
503 instanceId: ProviderInstanceId.make("claudeAgent"),
504 model: "custom-model",
505 options: [{ id: "effort", value: "high" }],
506 };
507
508 expect(resolveDefaultProviderModelSelection(providers, stored)).toBe(stored);
509 });
510
511 it("replaces a stale stored instance with the first ready instance and its model", () => {
512 const providers = [
513 provider({
514 provider: ProviderDriverKind.make("codex"),
515 instanceId: "codex",
516 status: "warning",
517 models: [model("gpt-5.6")],
518 }),
519 provider({
520 provider: ProviderDriverKind.make("claudeAgent"),
521 instanceId: "claudeAgent",
522 models: [model("claude-opus-4-8", false, true)],
523 }),
524 ];
525
526 expect(
527 resolveDefaultProviderModelSelection(providers, {
528 instanceId: ProviderInstanceId.make("removed-provider"),
529 model: "stale-model",
530 }),
531 ).toEqual({ instanceId: "claudeAgent", model: "claude-opus-4-8" });
532 });
533
534 // regression: #4117 users without Codex got a broken default provider
535 it.each([{ enabled: false }, { availability: "unavailable" as const }])(
536 "replaces an unavailable stored instance deterministically",
537 (requestedState) => {
538 const providers = [
539 provider({
540 provider: ProviderDriverKind.make("codex"),
541 instanceId: "codex",
542 models: [model("gpt-5.6")],
543 ...requestedState,
544 }),
545 provider({
546 provider: ProviderDriverKind.make("claudeAgent"),
547 instanceId: "claudeAgent",
548 models: [model("claude-opus-4-8", false, true)],
549 }),
550 ];
551
552 expect(
553 resolveDefaultProviderModelSelection(providers, {
554 instanceId: ProviderInstanceId.make("codex"),
555 model: "gpt-5.6",
556 }),
557 ).toEqual({ instanceId: "claudeAgent", model: "claude-opus-4-8" });
558 },
559 );
560
561 it("returns no selection for empty, disabled, unavailable, or error-only profiles", () => {
562 expect(resolveDefaultProviderModelSelection([], null)).toBeNull();
563 expect(
564 resolveDefaultProviderModelSelection(
565 [
566 provider({
567 provider: ProviderDriverKind.make("codex"),
568 instanceId: "codex",
569 enabled: false,
570 }),
571 ],
572 null,
573 ),
574 ).toBeNull();
575 expect(
576 resolveDefaultProviderModelSelection(
577 [
578 provider({
579 provider: ProviderDriverKind.make("codex"),
580 instanceId: "codex",
581 availability: "unavailable",
582 }),
583 ],
584 null,
585 ),
586 ).toBeNull();
587 expect(
588 resolveDefaultProviderModelSelection(
589 [
590 provider({
591 provider: ProviderDriverKind.make("codex"),
592 instanceId: "codex",
593 status: "error",
594 }),
595 ],
596 null,
597 ),
598 ).toBeNull();
599 });
600 });
601
602 describe("provider icon metadata", () => {
603 it("clears stale registry branding when an instance switches to a local command", () => {
604 const instanceId = ProviderInstanceId.make("custom-acp");
605 const driver = ProviderDriverKind.make("acpRegistry");
606 const iconUrl = "https://cdn.agentclientprotocol.com/registry/icons/swe-agent.svg";
607 const snapshots = deriveProviderInstanceEntries([
608 { ...provider({ provider: driver, instanceId }), iconUrl },
609 ]);
610 const registryConfig = { agentId: "swe-agent", registryIconUrl: iconUrl };
611 const brandedEntries = applyProviderInstanceSettings(
612 snapshots,
613 {
614 providerInstances: { [instanceId]: { driver, enabled: true, config: registryConfig } },
615 projectSettingsOverrides: {},
616 },
617 null,
618 );
619 expect(brandedEntries[0]?.acpRegistryAgentId).toBe("swe-agent");
620 expect(brandedEntries[0]?.acpRegistryIconUrl).toBe(iconUrl);
621
622 const [localEntry] = applyProviderInstanceSettings(
623 brandedEntries,
624 {
625 providerInstances: {
626 [instanceId]: {
627 driver,
628 enabled: false,
629 config: { ...registryConfig, source: "local", commandPath: "dsh" },
630 },
631 },
632 projectSettingsOverrides: {},
633 },
634 null,
635 );
636 expect(localEntry?.acpRegistryAgentId).toBeUndefined();
637 expect(localEntry?.acpRegistryIconUrl).toBeUndefined();
638 expect(localEntry?.enabled).toBe(false);
639 expect(localEntry?.snapshot).toBe(snapshots[0]?.snapshot);
640
641 const [restoredEntry] = applyProviderInstanceSettings(
642 localEntry ? [localEntry] : [],
643 {
644 providerInstances: { [instanceId]: { driver, enabled: true, config: registryConfig } },
645 projectSettingsOverrides: {},
646 },
647 null,
648 );
649 expect(restoredEntry?.acpRegistryAgentId).toBe("swe-agent");
650 expect(restoredEntry?.acpRegistryIconUrl).toBe(iconUrl);
651 expect(restoredEntry?.enabled).toBe(true);
652 });
653 });