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, 03:37 UTC
| 1 | import * as NodeCrypto from "@effect/platform-node/NodeCrypto"; |
| 2 | import * as NodeServices from "@effect/platform-node/NodeServices"; |
| 3 | import { describe, expect, it } from "@effect/vitest"; |
| 4 | import { |
| 5 | AuthAccessTokenType, |
| 6 | AuthEnvironmentBootstrapTokenType, |
| 7 | AuthTokenExchangeGrantType, |
| 8 | EnvironmentHttpApi, |
| 9 | EnvironmentId, |
| 10 | } from "@t3tools/contracts"; |
| 11 | import { |
| 12 | RelayEnvironmentLinkProofPayload, |
| 13 | type RelayLinkProofRequest, |
| 14 | } from "@t3tools/contracts/relay"; |
| 15 | import * as Effect from "effect/Effect"; |
| 16 | import * as TestClock from "effect/testing/TestClock"; |
| 17 | import * as Layer from "effect/Layer"; |
| 18 | import * as Schema from "effect/Schema"; |
| 19 | import { HttpClient, HttpServer } from "effect/http"; |
| 20 | import * as Etag from "effect/http/Etag"; |
| 21 | import * as HttpPlatform from "effect/http/HttpPlatform"; |
| 22 | import * as HttpRouter from "effect/http/HttpRouter"; |
| 23 | import * as HttpApi from "effect/http-api/HttpApi"; |
| 24 | import * as HttpApiBuilder from "effect/http-api/HttpApiBuilder"; |
| 25 | import * as NetAddress from "effect/net/NetAddress"; |
| 26 | import { decodeRelayJwt, RELAY_LINK_PROOF_TYP, verifyRelayJwt } from "@t3tools/shared/relayJwt"; |
| 27 | |
| 28 | import * as EnvironmentKeys from "./environmentKeys.ts"; |
| 29 | import * as EnvironmentAuth from "../auth/EnvironmentAuth.ts"; |
| 30 | import * as AuthHttp from "../auth/http.ts"; |
| 31 | import * as ServerSecretStore from "../auth/ServerSecretStore.ts"; |
| 32 | import * as ServerConfig from "../config.ts"; |
| 33 | import * as ServerEnvironment from "../environment/ServerEnvironment.ts"; |
| 34 | import * as SqlitePersistence from "../persistence/Sqlite.ts"; |
| 35 | import * as AgentAwarenessRelay from "../relay/AgentAwarenessRelay.ts"; |
| 36 | import * as CliTokenManager from "./CliTokenManager.ts"; |
| 37 | import * as CloudLink from "./CloudLink.ts"; |
| 38 | import * as ConnectHttp from "./http.ts"; |
| 39 | import * as ConnectReachability from "./ConnectReachability.ts"; |
| 40 | import * as ManagedEndpointRuntime from "./ManagedEndpointRuntime.ts"; |
| 41 | import * as ManagedPolicy from "../policy/ManagedPolicy.ts"; |
| 42 | import * as ServerSettings from "../serverSettings.ts"; |
| 43 | |
| 44 | const DESKTOP_BOOTSTRAP_TOKEN = "test-desktop-bootstrap-token"; |
| 45 | const NON_LOOPBACK_ORIGIN = "http://172.24.162.233:3773"; |
| 46 | const proofRequest: RelayLinkProofRequest = { |
| 47 | challenge: "test-challenge", |
| 48 | relayIssuer: "https://relay.example.test", |
| 49 | endpoint: { |
| 50 | providerKind: "cloudflare_tunnel", |
| 51 | httpBaseUrl: "https://environment.example.test", |
| 52 | wsBaseUrl: "wss://environment.example.test", |
| 53 | }, |
| 54 | origin: { localHttpHost: "127.0.0.1", localHttpPort: 3773 }, |
| 55 | }; |
| 56 | const decodeLinkProofPayload = Schema.decodeUnknownEffect(RelayEnvironmentLinkProofPayload); |
| 57 | |
| 58 | class LinkProofTestApi extends HttpApi.make("environment").add( |
| 59 | EnvironmentHttpApi.groups.auth, |
| 60 | EnvironmentHttpApi.groups.connect, |
| 61 | ) {} |
| 62 | |
| 63 | const layerConfig = Layer.effect( |
| 64 | ServerConfig.ServerConfig, |
| 65 | Effect.gen(function* () { |
| 66 | const config = yield* ServerConfig.ServerConfig; |
| 67 | return { |
| 68 | ...config, |
| 69 | mode: "desktop" as const, |
| 70 | host: "0.0.0.0", |
| 71 | port: 3773, |
| 72 | desktopBootstrapToken: DESKTOP_BOOTSTRAP_TOKEN, |
| 73 | }; |
| 74 | }), |
| 75 | ).pipe(Layer.provide(ServerConfig.layerTest(process.cwd(), { prefix: "t3-link-proof-test-" }))); |
| 76 | |
| 77 | // Real credential issuance, verification, origin checks and signing; no relay or tunnel is started. |
| 78 | const layerLinkProofRoutes = HttpApiBuilder.layer(LinkProofTestApi).pipe( |
| 79 | Layer.provide([AuthHttp.layer, ConnectHttp.layer]), |
| 80 | Layer.provide(AuthHttp.layerAuthenticatedAuth), |
| 81 | Layer.provide(CloudLink.layer), |
| 82 | Layer.provide(ServerSettings.ServerSettingsService.layerTest()), |
| 83 | Layer.provide(EnvironmentKeys.layer), |
| 84 | Layer.provide( |
| 85 | Layer.mock(ConnectReachability.ConnectReachability)({ latest: Effect.succeedNone }), |
| 86 | ), |
| 87 | Layer.provide(EnvironmentAuth.layer), |
| 88 | Layer.provide([ |
| 89 | ManagedPolicy.layerTest(), |
| 90 | SqlitePersistence.layerMemory, |
| 91 | ServerEnvironment.layerIdentity, |
| 92 | Layer.mock(ServerEnvironment.ServerEnvironment)({ |
| 93 | getDescriptor: Effect.succeed({ |
| 94 | environmentId: EnvironmentId.make("wsl-environment"), |
| 95 | label: "WSL", |
| 96 | platform: { os: "linux", arch: "x64" }, |
| 97 | serverVersion: "0.0.0-test", |
| 98 | capabilities: { repositoryIdentity: false }, |
| 99 | }), |
| 100 | }), |
| 101 | Layer.mock(ManagedEndpointRuntime.CloudManagedEndpointRuntime)({ |
| 102 | withLinkStateLock: (effect) => effect, |
| 103 | }), |
| 104 | Layer.mock(CliTokenManager.CloudCliTokenManager)({}), |
| 105 | Layer.mock(AgentAwarenessRelay.AgentAwarenessRelay)({}), |
| 106 | Layer.mock(HttpServer.HttpServer)({ |
| 107 | address: NetAddress.inetAddressFromIpStringUnsafe("0.0.0.0", 3773), |
| 108 | }), |
| 109 | Layer.succeed( |
| 110 | HttpClient.HttpClient, |
| 111 | HttpClient.make(() => Effect.die("Unexpected relay call")), |
| 112 | ), |
| 113 | ]), |
| 114 | Layer.provideMerge(ServerSecretStore.layer), |
| 115 | Layer.provide(layerConfig), |
| 116 | Layer.provideMerge(HttpPlatform.layer.pipe(Layer.provideMerge(Etag.layerWeak))), |
| 117 | Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)), |
| 118 | ); |
| 119 | |
| 120 | const responseJson = (response: Response) => Effect.promise(() => response.json()); |
| 121 | |
| 122 | // Scoped: the web handler and its layer are disposed when the test's scope closes. |
| 123 | const linkProofClient = Effect.gen(function* () { |
| 124 | const { handler } = yield* Effect.acquireRelease( |
| 125 | Effect.sync(() => HttpRouter.toWebHandler(layerLinkProofRoutes, { disableLogger: true })), |
| 126 | (web) => Effect.promise(() => web.dispose()), |
| 127 | ); |
| 128 | const post = ( |
| 129 | path: string, |
| 130 | payload: unknown, |
| 131 | headers?: Record<string, string>, |
| 132 | origin = NON_LOOPBACK_ORIGIN, |
| 133 | ) => |
| 134 | Effect.promise(() => |
| 135 | handler( |
| 136 | new Request(`${origin}${path}`, { |
| 137 | method: "POST", |
| 138 | headers: { "content-type": "application/json", ...headers }, |
| 139 | body: JSON.stringify(payload), |
| 140 | }), |
| 141 | ), |
| 142 | ); |
| 143 | const exchange = Effect.fnUntraced(function* (credential: string, scope?: string) { |
| 144 | const response = yield* Effect.promise(() => |
| 145 | handler( |
| 146 | new Request(`${NON_LOOPBACK_ORIGIN}/oauth/token`, { |
| 147 | method: "POST", |
| 148 | body: new URLSearchParams({ |
| 149 | grant_type: AuthTokenExchangeGrantType, |
| 150 | subject_token: credential, |
| 151 | subject_token_type: AuthEnvironmentBootstrapTokenType, |
| 152 | requested_token_type: AuthAccessTokenType, |
| 153 | ...(scope ? { scope } : {}), |
| 154 | }), |
| 155 | }), |
| 156 | ), |
| 157 | ); |
| 158 | expect(response.status).toBe(200); |
| 159 | const payload = (yield* responseJson(response)) as { access_token: string }; |
| 160 | return payload.access_token; |
| 161 | }); |
| 162 | const linkableHere = (token: string) => |
| 163 | Effect.promise(() => |
| 164 | handler( |
| 165 | new Request(`${NON_LOOPBACK_ORIGIN}/api/connect/link-state`, { |
| 166 | headers: { authorization: `Bearer ${token}` }, |
| 167 | }), |
| 168 | ), |
| 169 | ).pipe( |
| 170 | Effect.flatMap(responseJson), |
| 171 | Effect.map((state) => (state as { linkableHere?: boolean }).linkableHere), |
| 172 | ); |
| 173 | return { post, exchange, linkableHere }; |
| 174 | }); |
| 175 | |
| 176 | describe("link proof over a non-loopback transport", () => { |
| 177 | it.effect( |
| 178 | "signs this server's loopback origin for a remote client allowed to configure the relay", |
| 179 | () => |
| 180 | Effect.gen(function* () { |
| 181 | const { post, exchange } = yield* linkProofClient; |
| 182 | const admin = yield* exchange(DESKTOP_BOOTSTRAP_TOKEN); |
| 183 | const paired = yield* post( |
| 184 | "/api/auth/pairing-token", |
| 185 | { scopes: ["relay:read", "relay:configure"] }, |
| 186 | { authorization: `Bearer ${admin}` }, |
| 187 | ); |
| 188 | expect(paired.status).toBe(200); |
| 189 | const { credential } = (yield* responseJson(paired)) as { credential: string }; |
| 190 | const token = yield* exchange(credential); |
| 191 | // The caller's origin and forwarding headers must not steer the tunnel elsewhere. |
| 192 | const response = yield* post( |
| 193 | "/api/connect/link-proof", |
| 194 | { ...proofRequest, origin: { localHttpHost: "172.24.162.233", localHttpPort: 5432 } }, |
| 195 | { authorization: `Bearer ${token}`, "x-forwarded-host": "evil.example.test" }, |
| 196 | ); |
| 197 | expect(response.status).toBe(200); |
| 198 | expect(response.headers.get("cache-control")).toBe("no-store"); |
| 199 | const proof = (yield* responseJson(response)) as string; |
| 200 | const unverified = yield* decodeRelayJwt(proof).pipe( |
| 201 | Effect.flatMap(decodeLinkProofPayload), |
| 202 | ); |
| 203 | yield* TestClock.setTime(unverified.iat * 1_000); |
| 204 | const verified = yield* verifyRelayJwt(RelayEnvironmentLinkProofPayload, { |
| 205 | publicKey: unverified.environmentPublicKey, |
| 206 | token: proof, |
| 207 | typ: RELAY_LINK_PROOF_TYP, |
| 208 | issuer: "t3-env:wsl-environment", |
| 209 | audience: proofRequest.relayIssuer, |
| 210 | }); |
| 211 | expect(verified).toMatchObject({ |
| 212 | origin: { localHttpHost: "127.0.0.1", localHttpPort: 3773 }, |
| 213 | endpoint: proofRequest.endpoint, |
| 214 | challenge: proofRequest.challenge, |
| 215 | }); |
| 216 | }).pipe(Effect.provide(NodeCrypto.layerSignature)), |
| 217 | ); |
| 218 | |
| 219 | it.effect("offers Turn on to any session allowed to configure the relay", () => |
| 220 | Effect.gen(function* () { |
| 221 | const { post, exchange, linkableHere } = yield* linkProofClient; |
| 222 | const desktop = yield* exchange(DESKTOP_BOOTSTRAP_TOKEN); |
| 223 | const pair = (scopes: ReadonlyArray<string>) => |
| 224 | post("/api/auth/pairing-token", { scopes }, { authorization: `Bearer ${desktop}` }).pipe( |
| 225 | Effect.flatMap(responseJson), |
| 226 | Effect.flatMap((paired) => exchange((paired as { credential: string }).credential)), |
| 227 | ); |
| 228 | expect(yield* linkableHere(desktop)).toBe(true); |
| 229 | const remote = yield* pair(["relay:read", "relay:write", "relay:configure"]); |
| 230 | expect(yield* linkableHere(remote)).toBe(true); |
| 231 | expect(yield* linkableHere(yield* pair(["relay:read", "relay:write"]))).toBe(false); |
| 232 | expect(yield* linkableHere(yield* pair(["relay:read", "relay:configure"]))).toBe(false); |
| 233 | }), |
| 234 | ); |
| 235 | |
| 236 | it.effect("requires relay configuration permission even for desktop bootstrap", () => |
| 237 | Effect.gen(function* () { |
| 238 | const { post, exchange } = yield* linkProofClient; |
| 239 | const token = yield* exchange(DESKTOP_BOOTSTRAP_TOKEN, "relay:write"); |
| 240 | const response = yield* post("/api/connect/link-proof", proofRequest, { |
| 241 | authorization: `Bearer ${token}`, |
| 242 | }); |
| 243 | expect(response.status).toBe(403); |
| 244 | expect(yield* responseJson(response)).toMatchObject({ |
| 245 | code: "insufficient_scope", |
| 246 | requiredScope: "relay:write", |
| 247 | requiredPermission: "relay:configure", |
| 248 | }); |
| 249 | }), |
| 250 | ); |
| 251 | |
| 252 | it.effect("allows relay writers to set preferences without creating a link", () => |
| 253 | Effect.gen(function* () { |
| 254 | const { post, exchange } = yield* linkProofClient; |
| 255 | const path = "/api/connect/live-activity-preference"; |
| 256 | const payload = { liveActivitiesEnabled: true }; |
| 257 | const readToken = yield* exchange(DESKTOP_BOOTSTRAP_TOKEN, "relay:read"); |
| 258 | const denied = yield* post(path, payload, { authorization: `Bearer ${readToken}` }); |
| 259 | expect(denied.status).toBe(403); |
| 260 | |
| 261 | const writeToken = yield* exchange(DESKTOP_BOOTSTRAP_TOKEN, "relay:write"); |
| 262 | const unlinked = yield* post(path, payload, { authorization: `Bearer ${writeToken}` }); |
| 263 | expect(unlinked.status).toBe(200); |
| 264 | expect(yield* responseJson(unlinked)).toEqual({ ok: false }); |
| 265 | }), |
| 266 | ); |
| 267 | |
| 268 | it.effect("requires explicit permission to configure the relay", () => |
| 269 | Effect.gen(function* () { |
| 270 | const { post, exchange } = yield* linkProofClient; |
| 271 | const admin = yield* exchange(DESKTOP_BOOTSTRAP_TOKEN); |
| 272 | const paired = yield* post( |
| 273 | "/api/auth/pairing-token", |
| 274 | {}, |
| 275 | { authorization: `Bearer ${admin}` }, |
| 276 | ); |
| 277 | expect(paired.status).toBe(200); |
| 278 | const { credential } = (yield* responseJson(paired)) as { credential: string }; |
| 279 | const token = yield* exchange(credential); |
| 280 | const response = yield* post( |
| 281 | "/api/connect/relay-config", |
| 282 | { |
| 283 | relayUrl: "https://relay.example.test", |
| 284 | cloudUserId: "test-link-owner", |
| 285 | environmentCredential: "test-environment-credential", |
| 286 | cloudMintPublicKey: "test-public-key", |
| 287 | endpointRuntime: null, |
| 288 | }, |
| 289 | { authorization: `Bearer ${token}` }, |
| 290 | ); |
| 291 | expect(response.status).toBe(403); |
| 292 | expect(yield* responseJson(response)).toMatchObject({ |
| 293 | code: "insufficient_scope", |
| 294 | requiredPermission: "relay:configure", |
| 295 | }); |
| 296 | }), |
| 297 | ); |
| 298 | |
| 299 | it.effect("rejects unauthenticated requests", () => |
| 300 | Effect.gen(function* () { |
| 301 | const { post } = yield* linkProofClient; |
| 302 | const response = yield* post("/api/connect/link-proof", proofRequest); |
| 303 | expect(response.status).toBe(401); |
| 304 | }), |
| 305 | ); |
| 306 | }); |