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

main
ts 216 lines 8.62 KB
Raw
1 import * as NodeServices from "@effect/platform-node/NodeServices";
2 import { expect, it } from "@effect/vitest";
3 import {
4 DEFAULT_SERVER_SETTINGS,
5 ProviderInstanceId,
6 ProviderSessionId,
7 ThreadId,
8 } from "@t3tools/contracts";
9 import * as Effect from "effect/Effect";
10 import * as Layer from "effect/Layer";
11 import * as Queue from "effect/Queue";
12 import * as Stream from "effect/Stream";
13 import * as Sink from "effect/Sink";
14 import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner";
15 import * as HttpClient from "effect/http/HttpClient";
16 import { vi } from "vite-plus/test";
17 import * as IdAllocator from "@t3tools/provider-core/server/IdAllocator";
18 import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderSessions";
19 import * as ProviderEventLoggers from "@t3tools/provider-core/server/ProviderEventLoggers";
20 import * as ProviderLatestVersions from "@t3tools/provider-core/server/ProviderLatestVersions";
21 import * as TestProviderHost from "@t3tools/provider-testing/TestProviderHost";
22 import * as ProviderAdapter from "@t3tools/provider-core/server/ProviderAdapter";
23 import * as sdk from "./sdk.ts";
24 import { MuseDriver } from "./driver.ts";
25
26 vi.mock("./sdk.ts", { spy: true });
27
28 const layerTest = TestProviderHost.layer({
29 runBackgroundWork: false,
30 settings: { ...DEFAULT_SERVER_SETTINGS, enableProviderUpdateChecks: false },
31 }).pipe(
32 Layer.provideMerge(NodeServices.layer),
33 Layer.provideMerge(IdAllocator.layer),
34 Layer.provideMerge(McpProviderSessions.layer),
35 Layer.provideMerge(ProviderLatestVersions.layer),
36 Layer.provideMerge(
37 Layer.succeed(
38 ProviderEventLoggers.ProviderEventLoggers,
39 ProviderEventLoggers.NoOpProviderEventLoggers,
40 ),
41 ),
42 Layer.provideMerge(
43 Layer.succeed(
44 HttpClient.HttpClient,
45 HttpClient.make(() => Effect.die("Unexpected HTTP request")),
46 ),
47 ),
48 );
49
50 function nativeHost() {
51 let notify: Parameters<sdk.MuseSdkHost["connection"]["onNotification"]>[0] = () => {};
52 let close!: () => void;
53 const closed = new Promise<void>((resolve) => {
54 close = resolve;
55 });
56 const host: sdk.MuseSdkHost = {
57 connection: {
58 mintCommandId: () => "command",
59 request: async (method) =>
60 method.startsWith("session/")
61 ? {
62 session: { sessionId: "command", modelId: "muse-wonder-1.0", activeTurnId: null },
63 history: { items: [] },
64 }
65 : method === "model/list"
66 ? {
67 providerId: "meta",
68 models: [
69 {
70 modelId: "muse-wonder-1.0",
71 displayLabel: "Muse",
72 providerId: "meta",
73 isDefault: true,
74 },
75 ],
76 }
77 : {},
78 command: async (_method, params) => ({
79 session: { sessionId: params.sessionId, modelId: "muse-wonder-1.0", activeTurnId: null },
80 history: { items: [] },
81 }),
82 onNotification: (handler) => {
83 notify = handler;
84 },
85 onProtocolError: () => {},
86 onServerRequest: () => {},
87 closed,
88 },
89 initializeResult: { grantedCapabilities: [] },
90 exited: closed.then(() => ({ code: 0, signal: null })),
91 close: async () => {
92 close();
93 },
94 };
95 return {
96 host,
97 emit: (method: string, params: Record<string, unknown>) =>
98 notify({ jsonrpc: "2.0", method, params }),
99 };
100 }
101
102 it.layer(layerTest)("MuseDriver usage", (it) => {
103 it.effect(
104 "keeps the newest complete account report across late reports and refresh without probing for usage",
105 () =>
106 Effect.gen(function* () {
107 const hosts: ReturnType<typeof nativeHost>[] = [];
108 const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
109 using spawn = vi.spyOn(spawner, "spawn").mockImplementation(() =>
110 Effect.succeed(
111 ChildProcessSpawner.makeHandle({
112 pid: ChildProcessSpawner.ProcessId(1),
113 exitCode: Effect.succeed(ChildProcessSpawner.ExitCode(0)),
114 isRunning: Effect.succeed(false),
115 kill: () => Effect.void,
116 unref: Effect.succeed(Effect.void),
117 stdin: Sink.drain,
118 stdout: Stream.encodeText(Stream.make("muse 1.0.3-R2198.1")),
119 stderr: Stream.empty,
120 all: Stream.empty,
121 getInputFd: () => Sink.drain,
122 getOutputFd: () => Stream.empty,
123 }),
124 ),
125 );
126 const createHost: typeof sdk.createMuseSdkHost = async () => {
127 const fake = nativeHost();
128 hosts.push(fake);
129 return fake.host;
130 };
131 const original = (yield* Effect.promise(() => vi.importActual<typeof sdk>("./sdk.ts")))
132 .createMuseSdkHostEffect;
133 using _hostEffect = vi
134 .spyOn(sdk, "createMuseSdkHostEffect")
135 .mockImplementation((options) => original(options, createHost));
136 using _host = vi.spyOn(sdk, "createMuseSdkHost").mockImplementation(createHost);
137 const instanceId = ProviderInstanceId.make("muse-test");
138 const instance = yield* MuseDriver.create({
139 instanceId,
140 displayName: "Muse test",
141 enabled: true,
142 environment: [],
143 config: { ...MuseDriver.defaultConfig(), binaryPath: process.execPath },
144 });
145 yield* Stream.take(instance.snapshot.streamChanges, 1).pipe(Stream.runDrain);
146 expect((yield* instance.snapshot.getSnapshot).status).toBe("ready");
147 expect((yield* instance.snapshot.getSnapshot).usageLimits).toBeUndefined();
148 const policy = ProviderAdapter.ProviderAdapterV2RuntimePolicy.make({
149 runtimeMode: "full-access",
150 interactionMode: "default",
151 cwd: null,
152 });
153 const sessions = yield* Effect.forEach(
154 ["one", "two"],
155 Effect.fnUntraced(function* (id) {
156 const runtime = yield* instance.orchestrationAdapter.openSession({
157 threadId: ThreadId.make(id),
158 providerSessionId: ProviderSessionId.make(id),
159 modelSelection: { instanceId, model: "muse-wonder-1.0", options: [] },
160 runtimePolicy: policy,
161 });
162 const events = yield* Queue.unbounded<ProviderAdapter.ProviderAdapterV2Event>();
163 yield* runtime.events.pipe(
164 Stream.runForEach((event) => Queue.offer(events, event)),
165 Effect.forkScoped,
166 );
167 yield* runtime.ensureThread({
168 threadId: ThreadId.make(id),
169 modelSelection: { instanceId, model: "muse-wonder-1.0", options: [] },
170 runtimePolicy: policy,
171 });
172 return { fake: hosts.at(-1)!, events };
173 }),
174 );
175 const reading = (observedAtMs: number, usedPercent: number, tier: string) => ({
176 window: { usedPercent, windowDurationMins: 300, resetsAtMs: 1791465557000 },
177 weekly: { usedPercent: 50, resetsAtMs: 1791763200000 },
178 observedAtMs,
179 tier,
180 });
181 const publish = Effect.fnUntraced(function* (
182 index: number,
183 report: ReturnType<typeof reading>,
184 ) {
185 const session = sessions[index]!;
186 session.fake.emit("usage/changed", report);
187 // The following context event acknowledges that this host has processed the report.
188 session.fake.emit("session/contextUsage", {
189 sessionId: "command",
190 usedTokens: report.observedAtMs,
191 });
192 yield* Queue.take(session.events).pipe(
193 Effect.repeat({
194 until: (event) =>
195 event.type === "provider_thread.updated" &&
196 event.providerThread.contextUsage?.usedTokens === report.observedAtMs,
197 }),
198 );
199 });
200 yield* publish(1, reading(1791447762610, 70, "tier-2"));
201 const latest = yield* instance.snapshot.getSnapshot;
202 expect(latest.usageLimits?.unavailable).toBeUndefined();
203 expect(latest.usageLimits?.windows.map((window) => window.usedPercent)).toEqual([70, 50]);
204 expect(latest.auth.label).toBe("tier-2");
205 yield* publish(0, reading(1791447761610, 10, "tier-1"));
206 expect((yield* instance.snapshot.getSnapshot).usageLimits).toEqual(latest.usageLimits);
207 expect((yield* instance.snapshot.getSnapshot).auth.label).toBe("tier-2");
208 const callsBeforeUsageRefresh = spawn.mock.calls.length;
209 yield* instance.snapshot.refreshUsage!;
210 expect(spawn.mock.calls.length).toBe(callsBeforeUsageRefresh);
211 const refreshed = yield* instance.snapshot.refresh;
212 expect(refreshed.usageLimits).toEqual(latest.usageLimits);
213 expect(refreshed.auth.label).toBe("tier-2");
214 }),
215 );
216 });