@devries-cameron20 / t3code Mirror · read-only
Fork 0

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

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 04:45 UTC

main
ts 240 lines 9.7 KB
Raw
1 import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
2 import * as NodeServices from "@effect/platform-node/NodeServices";
3 import {
4 EnvironmentHttpApi,
5 EnvironmentId,
6 type AuthMcpClientAccess,
7 type ExecutionEnvironmentDescriptor,
8 } from "@t3tools/contracts";
9 import * as Context from "effect/Context";
10 import * as Deferred from "effect/Deferred";
11 import * as Effect from "effect/Effect";
12 import * as Layer from "effect/Layer";
13 import * as Queue from "effect/Queue";
14 import * as Ref from "effect/Ref";
15 import * as FetchHttpClient from "effect/http/FetchHttpClient";
16 import * as HttpRouter from "effect/http/HttpRouter";
17 import * as HttpServer from "effect/http/HttpServer";
18 import * as HttpServerRequest from "effect/http/HttpServerRequest";
19 import * as HttpApi from "effect/http-api/HttpApi";
20 import * as HttpApiBuilder from "effect/http-api/HttpApiBuilder";
21
22 import * as EnvironmentAuth from "../auth/EnvironmentAuth.ts";
23 import * as AuthHttp from "../auth/http.ts";
24 import * as McpOAuth from "../auth/McpOAuth.ts";
25 import * as McpOAuthHttp from "../auth/mcpOAuthHttp.ts";
26 import type * as SqlClient from "effect/sql/SqlClient";
27 import * as ServerSecretStore from "../auth/ServerSecretStore.ts";
28 import * as CloudLink from "../cloud/CloudLink.ts";
29 import * as ServerConfig from "../config.ts";
30 import * as ServerEnvironment from "../environment/ServerEnvironment.ts";
31 import * as ServerHttp from "../http.ts";
32 import * as McpHttpServer from "../mcp/McpHttpServer.ts";
33 import * as McpSessionRegistry from "../mcp/McpSessionRegistry.ts";
34 import * as Sqlite from "../persistence/Sqlite.ts";
35 import * as PeerHttp from "./http.ts";
36 import * as PeerClientPairing from "./PeerClientPairing.ts";
37 import * as PeerLinks from "./PeerLinks.ts";
38 import * as ServerSettings from "../serverSettings.ts";
39 import * as PeerMcpClient from "./PeerMcpClient.ts";
40 import * as ManagedPolicy from "../policy/ManagedPolicy.ts";
41
42 class PeerTestApi extends HttpApi.make("environment")
43 .add(EnvironmentHttpApi.groups.metadata)
44 .add(EnvironmentHttpApi.groups.mcpOAuth)
45 .add(EnvironmentHttpApi.groups.peerLink) {}
46
47 export const descriptorOf = (
48 environmentId: string,
49 label: string,
50 capabilities: Partial<ExecutionEnvironmentDescriptor["capabilities"]> = {},
51 ): ExecutionEnvironmentDescriptor => ({
52 environmentId: EnvironmentId.make(environmentId),
53 label,
54 platform: { os: "linux", arch: "x64" },
55 serverVersion: "0.0.0-test",
56 capabilities: {
57 repositoryIdentity: true,
58 mcpModeLimitHeader: true,
59 linkFence: true,
60 ...capabilities,
61 },
62 });
63
64 /** An environment's own sessions and pairing links, on a database and secret store of its own. */
65 export const layerEnvironmentAuth = (prefix: string) =>
66 EnvironmentAuth.layer.pipe(
67 Layer.provide(ManagedPolicy.layerTest()),
68 Layer.provideMerge(ServerSettings.layerTest({ linkedEnvironmentsEnabled: true })),
69 Layer.provide(Sqlite.layerMemory),
70 Layer.provideMerge(ServerSecretStore.layer),
71 Layer.provideMerge(ServerEnvironment.layerIdentity),
72 Layer.provideMerge(ServerConfig.layerTest(process.cwd(), { prefix })),
73 Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
74 Layer.fresh,
75 );
76
77 /**
78 * The environment a link points at, as it runs: its descriptor, MCP OAuth,
79 * and `/mcp` with `tools` behind the real client authenticator, on a real
80 * socket. The descriptor can be swapped, as when its address comes to answer
81 * as another environment, and every bearer it receives is recorded.
82 */
83 export const servePeer = <E, R, E2 = never, R2 = never>(
84 initial: ExecutionEnvironmentDescriptor,
85 tools: Layer.Layer<never, E, R>,
86 /** More of its HTTP routes, whose handlers get the same auth and settings. */
87 routes: Layer.Layer<never, E2, R2> = Layer.empty,
88 ) =>
89 Effect.gen(function* () {
90 const descriptor = yield* Ref.make(initial);
91 const bearers = yield* Ref.make<ReadonlyArray<string>>([]);
92 const probes = yield* Ref.make(0);
93 const asleep = yield* Ref.make(false);
94 const unanswered = yield* Queue.unbounded<void>();
95 const wake = yield* Deferred.make<void>();
96 const layerEnvironment = Layer.succeed(ServerEnvironment.ServerEnvironment, {
97 getEnvironmentId: Ref.get(descriptor).pipe(Effect.map((current) => current.environmentId)),
98 getDescriptor: Ref.get(descriptor),
99 });
100 const authContext = yield* Layer.build(layerEnvironmentAuth("t3-peer-link-peer-"));
101 const layerRecordBearers = HttpRouter.middleware(
102 (httpEffect) =>
103 Effect.gen(function* () {
104 const request = yield* HttpServerRequest.HttpServerRequest;
105 if (request.url.startsWith("/.well-known/t3/environment")) {
106 yield* Ref.update(probes, (count) => count + 1);
107 if (yield* Ref.get(asleep)) {
108 yield* Queue.offer(unanswered, undefined);
109 yield* Deferred.await(wake);
110 return yield* Effect.die("the peer was closed while asleep");
111 }
112 }
113 const authorization = request.headers.authorization;
114 if (authorization !== undefined) {
115 yield* Ref.update(bearers, (seen) => [...seen, authorization]);
116 }
117 return yield* httpEffect;
118 }),
119 { global: true },
120 );
121 const layerRoutes = Layer.mergeAll(
122 HttpApiBuilder.layer(PeerTestApi).pipe(
123 Layer.provide(
124 McpOAuthHttp.layer.pipe(
125 Layer.provide(McpOAuth.layer),
126 Layer.provide(
127 Layer.mock(CloudLink.CloudLink)({
128 linkState: () =>
129 Effect.succeed({
130 linked: false,
131 cloudUserId: null,
132 relayUrl: null,
133 relayIssuer: null,
134 publishAgentActivity: false,
135 }),
136 }),
137 ),
138 ),
139 ),
140 Layer.provide(PeerHttp.layer.pipe(Layer.provide(PeerClientPairing.layerIssuer))),
141 Layer.provide(ServerHttp.layerServerEnvironmentHttpApi),
142 Layer.provide(AuthHttp.layerAuthenticatedAuth),
143 ),
144 McpHttpServer.layerMcpTransport(tools).pipe(
145 Layer.provide(
146 Layer.mock(McpSessionRegistry.McpSessionRegistry)({
147 resolve: () => Effect.undefined,
148 }),
149 ),
150 Layer.provide(McpOAuth.layerMcpClientAuthenticator),
151 ),
152 routes,
153 ).pipe(
154 Layer.provide(layerRecordBearers),
155 Layer.provide(layerEnvironment),
156 Layer.provide(Layer.succeedContext(authContext)),
157 );
158 // Fresh, so the peer never shares a toolkit or MCP server with the
159 // environment that links to it in the same test.
160 yield* HttpRouter.serve(layerRoutes, { disableListenLog: true, disableLogger: true }).pipe(
161 Layer.provide(Layer.succeedContext(authContext)),
162 Layer.fresh,
163 Layer.build,
164 );
165 // An unanswered request would hold the server open past the test.
166 yield* Effect.addFinalizer(() => Deferred.succeed(wake, undefined));
167 const address = (yield* HttpServer.HttpServer).address;
168 if (address._tag === "UnixPathAddress") return yield* Effect.die("expected a TCP address");
169 const url = `http://127.0.0.1:${address.port}`;
170 const auth = Context.get(authContext, EnvironmentAuth.EnvironmentAuth);
171 return {
172 url,
173 auth,
174 /** Its settings, as for turning its Linked environments beta off. */
175 settings: Context.get(authContext, ServerSettings.ServerSettingsService),
176 descriptor,
177 bearers,
178 /** How often its descriptor was asked for, as a probe of whether it answers. */
179 probes,
180 /** While set, its descriptor never answers, as a machine that is asleep. */
181 asleep,
182 /** One entry per descriptor request it left unanswered while asleep. */
183 unanswered,
184 /** The sessions linking created there, which its Connections lists. */
185 linkedSessions: auth
186 .listSessions()
187 .pipe(
188 Effect.map((sessions) =>
189 sessions.filter((session) => session.client.label?.startsWith("T3 Code · ")),
190 ),
191 ),
192 };
193 });
194
195 export type ServedPeer = Effect.Success<ReturnType<typeof servePeer>>;
196
197 /**
198 * The environment that links: its own database and secret store, reaching
199 * peers over plain HTTP. Provide it to anything built on its links.
200 */
201 export const layerLinkingEnvironment = <E = never>(
202 descriptor: ExecutionEnvironmentDescriptor,
203 secrets: typeof ServerSecretStore.layer = ServerSecretStore.layer,
204 database: Layer.Layer<
205 SqlClient.SqlClient,
206 E | Layer.Error<typeof Sqlite.layerMemory>
207 > = Sqlite.layerMemory,
208 ) =>
209 PeerMcpClient.layer.pipe(
210 Layer.provideMerge(PeerLinks.layer),
211 Layer.provideMerge(ServerSettings.layerTest({ linkedEnvironmentsEnabled: true })),
212 Layer.provideMerge(database),
213 Layer.provide(Layer.mergeAll(secrets, FetchHttpClient.layer)),
214 // Peers here are served on 127.0.0.1, so only `localhost` stands for this machine.
215 Layer.provide(Layer.succeed(PeerLinks.LoopbackHost, (host) => host === "localhost")),
216 // Services that act for this environment, such as delegation, name it too.
217 Layer.provideMerge(
218 Layer.succeed(ServerEnvironment.ServerEnvironment, {
219 getEnvironmentId: Effect.succeed(descriptor.environmentId),
220 getDescriptor: Effect.succeed(descriptor),
221 }),
222 ),
223 Layer.provide(ServerConfig.layerTest(process.cwd(), { prefix: "t3-peer-link-here-" })),
224 Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
225 Layer.fresh,
226 );
227
228 /** Links `links` to `peer` with a fresh pairing code from it. */
229 export const linkTo = (
230 links: PeerLinks.PeerLinks["Service"],
231 peer: ServedPeer,
232 access: AuthMcpClientAccess = "auto",
233 ) =>
234 peer.auth
235 .issuePairingCredential()
236 .pipe(
237 Effect.flatMap((pairing) =>
238 links.link({ url: peer.url, pairingCode: pairing.credential, access }),
239 ),
240 );