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

main
ts 433 lines 14 KB
Raw
1 import { assert, describe, it } from "@effect/vitest";
2 import * as NodeServices from "@effect/platform-node/NodeServices";
3 import { ProviderDriverKind } from "@t3tools/contracts";
4 import * as ModelCatalog from "@t3tools/provider-core/server/ModelCatalog";
5 import * as Effect from "effect/Effect";
6 import * as FileSystem from "effect/FileSystem";
7 import * as Layer from "effect/Layer";
8 import * as Path from "effect/Path";
9 import * as TestClock from "effect/testing/TestClock";
10 import { HttpClient, HttpClientResponse } from "effect/http";
11
12 import * as ServerConfig from "../config.ts";
13 import * as ServerSettings from "../serverSettings.ts";
14 import * as ModelManifest from "./ModelManifest.ts";
15
16 describe("resolveProviderCatalog", () => {
17 it.each([
18 { releasedAt: "2026-01-01", now: "2026-01-01T00:00:00Z", badge: "new" },
19 { releasedAt: "2026-01-01", now: "2026-01-07T23:59:59.999Z", badge: "new" },
20 { releasedAt: "2026-01-01", now: "2026-01-08T00:00:00Z", badge: undefined },
21 { releasedAt: "2026-01-01", now: "2026-02-01T00:00:00Z", badge: undefined },
22 { releasedAt: "2026-01-02T00:00:00Z", now: "2026-01-01T00:00:00Z", badge: undefined },
23 { releasedAt: undefined, now: "2026-01-01T00:00:00Z", badge: undefined },
24 { releasedAt: "invalid", now: "2026-01-01T00:00:00Z", badge: undefined },
25 ])("derives the new badge from releasedAt=$releasedAt at $now", ({ releasedAt, now, badge }) => {
26 const manifest: ModelManifest.ModelManifestData = {
27 version: 1,
28 currentModels: {},
29 providers: {
30 synthetic: {
31 profiles: {},
32 models: [
33 {
34 slug: "model-next",
35 name: "Model Next",
36 status: "current",
37 ...(releasedAt === undefined ? {} : { releasedAt }),
38 },
39 {
40 slug: "model-legacy",
41 name: "Model Legacy",
42 status: "legacy",
43 releasedAt: now,
44 },
45 ],
46 },
47 },
48 };
49 const catalog = ModelManifest.resolveProviderCatalog(
50 manifest,
51 ProviderDriverKind.make("synthetic"),
52 Date.parse(now),
53 );
54 assert.strictEqual(catalog?.models[0]?.badge, badge);
55 assert.strictEqual(catalog?.models[1]?.badge, undefined);
56 });
57
58 it.effect("expires badges when rereading a cached manifest without a refresh", () => {
59 const manifest: ModelManifest.ModelManifestData = {
60 version: 1,
61 currentModels: {},
62 providers: {
63 synthetic: {
64 profiles: {},
65 models: [
66 {
67 slug: "model-next",
68 name: "Model Next",
69 status: "current",
70 releasedAt: "1970-01-01T00:00:00Z",
71 },
72 ],
73 },
74 },
75 };
76 return Effect.gen(function* () {
77 const service = yield* ModelCatalog.ModelCatalog;
78 const readCatalog = service.current(ProviderDriverKind.make("synthetic"));
79 assert.strictEqual((yield* readCatalog)?.models[0]?.badge, "new");
80 yield* TestClock.adjust("7 days");
81 assert.strictEqual((yield* readCatalog)?.models[0]?.badge, undefined);
82 }).pipe(
83 Effect.provide(
84 ModelManifest.layerModelCatalog.pipe(
85 Layer.provide(
86 Layer.succeed(ModelManifest.ModelManifest, {
87 current: Effect.succeed(manifest),
88 refresh: Effect.die("Catalog reads must not refresh the manifest"),
89 forceRefresh: Effect.die("Catalog reads must not refresh the manifest"),
90 refreshOnDemand: Effect.die("Catalog reads must not refresh the manifest"),
91 refreshInBackground: Effect.die("Catalog reads must not refresh the manifest"),
92 }),
93 ),
94 ),
95 ),
96 );
97 });
98
99 it("rejects invalid catalog references", () => {
100 const invalidCatalog = (input: {
101 readonly models: NonNullable<ModelManifest.ModelManifestData["providers"]>[string]["models"];
102 readonly defaultChat?: string;
103 }): ModelManifest.ModelManifestData => ({
104 version: 1,
105 currentModels: {},
106 providers: {
107 synthetic: {
108 ...(input.defaultChat ? { defaults: { chat: input.defaultChat } } : {}),
109 profiles: {},
110 models: input.models,
111 },
112 },
113 });
114
115 for (const invalid of [
116 invalidCatalog({
117 models: [
118 { slug: "duplicate", name: "First", status: "current" },
119 { slug: "duplicate", name: "Second", status: "current" },
120 ],
121 }),
122 invalidCatalog({
123 models: [
124 {
125 slug: "missing-profile",
126 name: "Missing Profile",
127 status: "current",
128 profile: "missing",
129 },
130 ],
131 }),
132 invalidCatalog({
133 models: [{ slug: "present", name: "Present", status: "current" }],
134 defaultChat: "absent",
135 }),
136 ]) {
137 assert.isNull(
138 ModelManifest.resolveProviderCatalog(invalid, ProviderDriverKind.make("synthetic")),
139 );
140 }
141 });
142 });
143
144 const REMOTE_UPDATED_AT = "2099-01-01T00:00:00Z";
145
146 const REMOTE_MANIFEST: ModelManifest.ModelManifestData = {
147 version: 1,
148 updatedAt: REMOTE_UPDATED_AT,
149 currentModels: {
150 codex: ["remote-model"],
151 claudeAgent: ["remote-agent-model"],
152 },
153 };
154
155 const REMOTE_CLAUDE_MANIFEST: ModelManifest.ModelManifestData = {
156 version: 1,
157 updatedAt: REMOTE_UPDATED_AT,
158 currentModels: {},
159 providers: {
160 claudeAgent: {
161 profiles: {
162 synthetic: {
163 adapter: { claudeCode: { effortMap: { extreme: "high" } } },
164 },
165 },
166 models: [
167 {
168 slug: "remote-only-model",
169 name: "Remote Only Model",
170 status: "current",
171 profile: "synthetic",
172 },
173 ],
174 },
175 },
176 };
177
178 const remoteClaudeManifestWithCompatibility = (
179 compatibility: unknown,
180 ): ModelManifest.ModelManifestData => ({
181 ...REMOTE_CLAUDE_MANIFEST,
182 providers: {
183 claudeAgent: {
184 profiles: REMOTE_CLAUDE_MANIFEST.providers!.claudeAgent!.profiles,
185 models: REMOTE_CLAUDE_MANIFEST.providers!.claudeAgent!.models.map((model) => ({
186 ...model,
187 adapter: { claudeCode: compatibility },
188 })),
189 },
190 },
191 });
192
193 const INVALID_REMOTE_MANIFESTS: ReadonlyArray<ModelManifest.ModelManifestData> = [
194 {
195 ...REMOTE_CLAUDE_MANIFEST,
196 providers: {
197 claudeAgent: {
198 profiles: {
199 synthetic: {
200 adapter: { claudeCode: { effortMap: { extreme: 123 } } },
201 },
202 },
203 models: REMOTE_CLAUDE_MANIFEST.providers!.claudeAgent!.models,
204 },
205 },
206 },
207 {
208 ...REMOTE_CLAUDE_MANIFEST,
209 providers: {
210 claudeAgent: {
211 profiles: {},
212 models: REMOTE_CLAUDE_MANIFEST.providers!.claudeAgent!.models,
213 },
214 },
215 },
216 {
217 ...REMOTE_CLAUDE_MANIFEST,
218 providers: {
219 claudeAgent: {
220 profiles: REMOTE_CLAUDE_MANIFEST.providers!.claudeAgent!.profiles,
221 models: [
222 ...REMOTE_CLAUDE_MANIFEST.providers!.claudeAgent!.models,
223 {
224 slug: "remote-only-model",
225 name: "Duplicate Remote Model",
226 status: "current",
227 profile: "synthetic",
228 },
229 ],
230 },
231 },
232 },
233 {
234 ...REMOTE_CLAUDE_MANIFEST,
235 providers: {
236 claudeAgent: {
237 defaults: { chat: "absent-model" },
238 profiles: REMOTE_CLAUDE_MANIFEST.providers!.claudeAgent!.profiles,
239 models: REMOTE_CLAUDE_MANIFEST.providers!.claudeAgent!.models,
240 },
241 },
242 },
243 remoteClaudeManifestWithCompatibility({ minVersion: "2.x" }),
244 remoteClaudeManifestWithCompatibility({ maxVersionExclusive: "2.x" }),
245 remoteClaudeManifestWithCompatibility({
246 minVersion: "2.2",
247 maxVersionExclusive: "2.1",
248 }),
249 ];
250
251 const layerHttpClient = (handler: () => Response) =>
252 Layer.succeed(
253 HttpClient.HttpClient,
254 HttpClient.make((request) => Effect.succeed(HttpClientResponse.fromWeb(request, handler()))),
255 );
256
257 const layerService = (input: {
258 readonly prefix: string;
259 readonly response: () => Response;
260 readonly settings?: Parameters<typeof ServerSettings.layerTest>[0];
261 }) =>
262 ServerConfig.layerTest(process.cwd(), { prefix: input.prefix }).pipe(
263 Layer.provideMerge(NodeServices.layer),
264 Layer.provideMerge(ServerSettings.layerTest(input.settings ?? {})),
265 Layer.provideMerge(layerHttpClient(input.response)),
266 );
267
268 describe("ModelManifest service", () => {
269 it.effect("prefers a fetched manifest over the bundle and caches it to disk", () =>
270 Effect.gen(function* () {
271 const service = yield* ModelManifest.make;
272 const refreshed = yield* service.refresh;
273 assert.deepStrictEqual(refreshed, REMOTE_MANIFEST);
274
275 const rebooted = yield* ModelManifest.make;
276 assert.deepStrictEqual(yield* rebooted.current, REMOTE_MANIFEST);
277 }).pipe(
278 Effect.scoped,
279 Effect.provide(
280 layerService({
281 prefix: "model-manifest-fetch-test",
282 response: () => Response.json(REMOTE_MANIFEST),
283 }),
284 ),
285 ),
286 );
287
288 it.effect(
289 "ignores older remote edits without replacing the current manifest or disk cache",
290 () => {
291 let remote = { ...REMOTE_MANIFEST, updatedAt: "2000-01-01T00:00:00Z" };
292 return Effect.gen(function* () {
293 const service = yield* ModelManifest.make;
294 assert.deepStrictEqual(yield* service.refresh, ModelManifest.BUNDLED_MODEL_MANIFEST);
295 assert.deepStrictEqual(yield* service.current, ModelManifest.BUNDLED_MODEL_MANIFEST);
296
297 remote = { ...REMOTE_MANIFEST, updatedAt: REMOTE_UPDATED_AT };
298 assert.deepStrictEqual(yield* service.forceRefresh, REMOTE_MANIFEST);
299 remote = { ...REMOTE_MANIFEST, updatedAt: ModelManifest.BUNDLED_MODEL_MANIFEST.updatedAt! };
300 assert.deepStrictEqual(yield* service.forceRefresh, REMOTE_MANIFEST);
301 const rebooted = yield* ModelManifest.make;
302 assert.deepStrictEqual(yield* rebooted.current, REMOTE_MANIFEST);
303 }).pipe(
304 Effect.scoped,
305 Effect.provide(
306 layerService({
307 prefix: "model-manifest-stale-fetch-test",
308 response: () => Response.json(remote),
309 }),
310 ),
311 );
312 },
313 );
314
315 it.effect("preserves the last-good remote cache when later payloads are invalid", () => {
316 let responseIndex = 0;
317 const responses = [REMOTE_CLAUDE_MANIFEST, ...INVALID_REMOTE_MANIFESTS];
318
319 return Effect.gen(function* () {
320 const service = yield* ModelManifest.make;
321 assert.deepStrictEqual(yield* service.refresh, REMOTE_CLAUDE_MANIFEST);
322
323 for (const _invalid of INVALID_REMOTE_MANIFESTS) {
324 yield* TestClock.adjust("1 hour");
325 responseIndex += 1;
326 assert.deepStrictEqual(yield* service.refresh, REMOTE_CLAUDE_MANIFEST);
327 }
328
329 const rebooted = yield* ModelManifest.make;
330 assert.deepStrictEqual(yield* rebooted.current, REMOTE_CLAUDE_MANIFEST);
331 }).pipe(
332 Effect.scoped,
333 Effect.provide(
334 layerService({
335 prefix: "model-manifest-last-good-test",
336 response: () => Response.json(responses[responseIndex]),
337 }),
338 ),
339 );
340 });
341
342 it.effect("refetches for an opened model picker after five minutes, not an hour", () => {
343 let fetches = 0;
344 return Effect.gen(function* () {
345 const service = yield* ModelManifest.make;
346 yield* service.refresh;
347 yield* TestClock.adjust("4 minutes");
348 yield* service.refreshOnDemand;
349 assert.strictEqual(fetches, 1);
350
351 yield* TestClock.adjust("1 minute");
352 yield* service.refresh;
353 assert.strictEqual(fetches, 1);
354 yield* service.refreshOnDemand;
355 assert.strictEqual(fetches, 2);
356 }).pipe(
357 Effect.scoped,
358 Effect.provide(
359 layerService({
360 prefix: "model-manifest-on-demand-test",
361 response: () => {
362 fetches += 1;
363 return Response.json(REMOTE_MANIFEST);
364 },
365 }),
366 ),
367 );
368 });
369
370 it.effect("drops a disk cache of a manifest older than the bundled one", () =>
371 Effect.gen(function* () {
372 const fs = yield* FileSystem.FileSystem;
373 const path = yield* Path.Path;
374 const config = yield* ServerConfig.ServerConfig;
375 const cachePath = path.join(config.stateDir, "model-manifest.json");
376 const { updatedAt: _undated, ...undatedManifest } = REMOTE_MANIFEST;
377 for (const stale of [
378 undatedManifest,
379 { ...REMOTE_MANIFEST, updatedAt: "2000-01-01T00:00:00Z" },
380 // The last bundle before Antigravity below 1.5 became broken.
381 { ...REMOTE_MANIFEST, updatedAt: "2026-11-14T15:58:47Z" },
382 ]) {
383 yield* fs.writeFileString(
384 cachePath,
385 yield* ModelManifest.encodeManifestCache({ fetchedAtMs: 0, manifest: stale }),
386 );
387 const service = yield* ModelManifest.make;
388 assert.deepStrictEqual(yield* service.current, ModelManifest.BUNDLED_MODEL_MANIFEST);
389 }
390
391 yield* fs.writeFileString(
392 cachePath,
393 yield* ModelManifest.encodeManifestCache({ fetchedAtMs: 0, manifest: REMOTE_MANIFEST }),
394 );
395 const later = yield* ModelManifest.make;
396 assert.deepStrictEqual(yield* later.current, REMOTE_MANIFEST);
397 }).pipe(
398 Effect.scoped,
399 Effect.provide(
400 layerService({
401 prefix: "model-manifest-newer-bundle-test",
402 response: () => Response.json(REMOTE_MANIFEST),
403 }),
404 ),
405 ),
406 );
407
408 it.effect("does not fetch when provider update checks are disabled", () =>
409 Effect.gen(function* () {
410 let fetchCount = 0;
411 const service = yield* ModelManifest.make.pipe(
412 Effect.provide(
413 layerHttpClient(() => {
414 fetchCount += 1;
415 return Response.json(REMOTE_MANIFEST);
416 }),
417 ),
418 );
419 assert.deepStrictEqual(yield* service.refresh, ModelManifest.BUNDLED_MODEL_MANIFEST);
420 assert.deepStrictEqual(yield* service.forceRefresh, ModelManifest.BUNDLED_MODEL_MANIFEST);
421 assert.strictEqual(fetchCount, 0);
422 }).pipe(
423 Effect.scoped,
424 Effect.provide(
425 layerService({
426 prefix: "model-manifest-optout-test",
427 response: () => Response.json(REMOTE_MANIFEST),
428 settings: { enableProviderUpdateChecks: false },
429 }),
430 ),
431 ),
432 );
433 });