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

main
ts 176 lines 6.67 KB
Raw
1 import {
2 AuthRelayReadScope,
3 AuthRelayConfigureScope,
4 AuthRelayWriteScope,
5 EnvironmentCloudEndpointUnavailableError,
6 EnvironmentHttpApi,
7 EnvironmentHttpBadRequestError,
8 EnvironmentHttpConflictError,
9 EnvironmentHttpForbiddenError,
10 EnvironmentHttpInternalServerError,
11 EnvironmentHttpUnauthorizedError,
12 } from "@t3tools/contracts";
13 import * as Effect from "effect/Effect";
14 import * as HttpEffect from "effect/http/HttpEffect";
15 import { HttpServerResponse } from "effect/http";
16 import * as HttpApiBuilder from "effect/http-api/HttpApiBuilder";
17
18 import { requireEnvironmentScope } from "../auth/http.ts";
19 import * as EnvironmentAuth from "../auth/EnvironmentAuth.ts";
20 import * as ManagedLimits from "../policy/managedLimits.ts";
21 import * as CloudLink from "./CloudLink.ts";
22 import * as ConnectReachability from "./ConnectReachability.ts";
23 import type { RelayRequestError } from "./relayResponse.ts";
24 import { traceRelayRequest } from "./traceRelayRequest.ts";
25
26 const CLOUD_CREDENTIAL_RESPONSE_HEADERS = {
27 "cache-control": "no-store",
28 pragma: "no-cache",
29 } as const;
30
31 const appendCloudCredentialResponseHeaders = HttpEffect.appendPreResponseHandler(
32 (_request, response) =>
33 Effect.succeed(HttpServerResponse.setHeaders(response, CLOUD_CREDENTIAL_RESPONSE_HEADERS)),
34 );
35
36 const internalServerError = (error: { readonly message: string }, cause: unknown) =>
37 Effect.logError(error.message, { cause }).pipe(
38 Effect.andThen(Effect.fail(new EnvironmentHttpInternalServerError({ message: error.message }))),
39 );
40
41 const relayFailure = (error: RelayRequestError) => {
42 const message = error.message;
43 switch (error.rejection) {
44 case "unauthorized":
45 return Effect.fail(new EnvironmentHttpUnauthorizedError({ message }));
46 case "forbidden":
47 return Effect.fail(new EnvironmentHttpForbiddenError({ message }));
48 case "rejected":
49 return Effect.fail(new EnvironmentHttpBadRequestError({ message }));
50 case "unavailable":
51 return Effect.fail(new EnvironmentHttpInternalServerError({ message }));
52 }
53 };
54
55 const badRequest = (error: { readonly message: string }) =>
56 Effect.fail(new EnvironmentHttpBadRequestError({ message: error.message }));
57 const unauthorized = (error: { readonly message: string }) =>
58 Effect.fail(new EnvironmentHttpUnauthorizedError({ message: error.message }));
59 const conflict = (error: { readonly message: string }) =>
60 Effect.fail(new EnvironmentHttpConflictError({ message: error.message }));
61
62 const connectErrorCases = {
63 CloudLinkRelayConfigInvalidError: badRequest,
64 CloudLinkOriginInvalidError: badRequest,
65 CloudLinkNotLinkedError: badRequest,
66 CloudLinkAccountMismatchError: conflict,
67 CloudLinkAuthorizationMissingError: unauthorized,
68 CloudLinkProofRejectedError: unauthorized,
69 CloudLinkProofReplayedError: conflict,
70 CloudLinkTunnelSupersededError: conflict,
71 ManagedPolicyRefusedError: (error: ManagedLimits.ManagedPolicyRefusedError) =>
72 Effect.fail(new EnvironmentHttpForbiddenError({ message: error.message })),
73 CloudLinkInternalError: (error: CloudLink.CloudLinkInternalError) =>
74 internalServerError(error, error.cause),
75 RelayRequestError: relayFailure,
76 } as const;
77
78 type ConnectFailure =
79 | Exclude<CloudLink.CloudLinkError, CloudLink.CloudLinkEndpointUnavailableError>
80 | EnvironmentAuth.ServerAuthInternalError
81 | ManagedLimits.ManagedPolicyRefusedError
82 | RelayRequestError;
83
84 const toHttpError = <A, R>(effect: Effect.Effect<A, ConnectFailure, R>) =>
85 effect.pipe(
86 Effect.catchTags(connectErrorCases),
87 Effect.catchIf(EnvironmentAuth.isServerAuthInternalError, (error) =>
88 internalServerError(error, error),
89 ),
90 );
91
92 const toHttpErrorOrUnavailable = <A, R>(
93 effect: Effect.Effect<A, ConnectFailure | CloudLink.CloudLinkEndpointUnavailableError, R>,
94 ) =>
95 effect.pipe(
96 Effect.catchTags({
97 ...connectErrorCases,
98 CloudLinkEndpointUnavailableError: (error) =>
99 Effect.fail(
100 new EnvironmentCloudEndpointUnavailableError({
101 message: error.message,
102 endpointRuntimeStatus: error.endpointRuntimeStatus,
103 }),
104 ),
105 }),
106 Effect.catchIf(EnvironmentAuth.isServerAuthInternalError, (error) =>
107 internalServerError(error, error),
108 ),
109 );
110
111 export const layer = HttpApiBuilder.group(
112 EnvironmentHttpApi,
113 "connect",
114 Effect.fnUntraced(function* (handlers) {
115 const cloudLink = yield* CloudLink.CloudLink;
116 const reachability = yield* ConnectReachability.ConnectReachability;
117 return handlers
118 .handle("linkProof", ({ payload }) =>
119 Effect.gen(function* () {
120 yield* requireEnvironmentScope(AuthRelayConfigureScope);
121 const proof = yield* toHttpError(cloudLink.linkProof(payload));
122 yield* appendCloudCredentialResponseHeaders;
123 return proof;
124 }),
125 )
126 .handle("relayConfig", ({ payload }) =>
127 Effect.gen(function* () {
128 yield* requireEnvironmentScope(AuthRelayConfigureScope);
129 return yield* toHttpErrorOrUnavailable(cloudLink.applyRelayConfig(payload));
130 }),
131 )
132 .handle("linkState", () =>
133 Effect.gen(function* () {
134 const principal = yield* requireEnvironmentScope(AuthRelayReadScope);
135 const state = yield* toHttpError(cloudLink.linkState());
136 // Linking also writes relay preferences, so configure alone cannot finish it.
137 const linkableHere =
138 principal.scopes.has(AuthRelayConfigureScope) &&
139 principal.scopes.has(AuthRelayWriteScope);
140 return { ...state, linkableHere };
141 }),
142 )
143 .handle("checkReachability", () =>
144 requireEnvironmentScope(AuthRelayReadScope).pipe(Effect.andThen(reachability.check)),
145 )
146 .handle("unlink", () =>
147 requireEnvironmentScope(AuthRelayWriteScope).pipe(
148 Effect.andThen(toHttpError(cloudLink.unlink())),
149 ),
150 )
151 .handle("preferences", ({ payload }) =>
152 requireEnvironmentScope(AuthRelayWriteScope).pipe(
153 Effect.andThen(toHttpError(cloudLink.updatePreferences(payload))),
154 ),
155 )
156 .handle("liveActivityPreference", ({ payload }) =>
157 requireEnvironmentScope(AuthRelayWriteScope).pipe(
158 Effect.andThen(
159 toHttpError(cloudLink.updateLiveActivityPreference(payload.liveActivitiesEnabled)),
160 ),
161 ),
162 )
163 .handle("health", ({ payload }) =>
164 toHttpError(cloudLink.answerHealthRequest(payload)).pipe(
165 Effect.tap(() => appendCloudCredentialResponseHeaders),
166 ),
167 )
168 .handle("t3MintCredential", ({ payload }) =>
169 traceRelayRequest(
170 toHttpError(cloudLink.mintCredential(payload)).pipe(
171 Effect.tap(() => appendCloudCredentialResponseHeaders),
172 ),
173 ),
174 );
175 }),
176 );