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

main
ts 131 lines 4.43 KB
Raw
1 import type { HttpEffect } from "alchemy/Http";
2 import * as Effect from "effect/Effect";
3 import { HttpServerRequest } from "effect/http/HttpServerRequest";
4 import * as HttpServerResponse from "effect/http/HttpServerResponse";
5 import * as Result from "effect/Result";
6 import {
7 PRIVATE_HOST_SUFFIX,
8 RPC_ERROR_TAG,
9 RPC_PATH_PREFIX,
10 RPC_TOKEN_ENV,
11 RPC_TOKEN_HEADER,
12 } from "./rpc-token.ts";
13
14 const header = (headers: Record<string, string | undefined>, name: string): string =>
15 headers[name] ?? headers[name.toLowerCase()] ?? "";
16
17 const hostnameOf = (host: string): string => {
18 const trimmed = host.trim();
19 if (trimmed.startsWith("[")) {
20 const end = trimmed.indexOf("]");
21 return end === -1 ? trimmed : trimmed.slice(1, end);
22 }
23 const colon = trimmed.lastIndexOf(":");
24 if (colon > 0 && trimmed.includes(".")) return trimmed.slice(0, colon);
25 return trimmed;
26 };
27
28 const isPrivateMesh = (host: string): boolean => hostnameOf(host).endsWith(PRIVATE_HOST_SUFFIX);
29
30 const tokensEqual = (left: string, right: string): boolean => {
31 if (left.length !== right.length) return false;
32 let mismatch = 0;
33 for (let i = 0; i < left.length; i++) {
34 mismatch |= left.charCodeAt(i) ^ right.charCodeAt(i);
35 }
36 return mismatch === 0;
37 };
38
39 const unauthorized = HttpServerResponse.text("Unauthorized", { status: 401 });
40
41 /**
42 * Serve schemaless RPC only on the private mesh, and only with the
43 * host's {@link RPC_TOKEN_ENV}. Public `*.up.railway.app` requests to
44 * `/__rpc__/*` get 401 even if they guess the path or the token.
45 *
46 * Implemented here (not `alchemy/Rpc.serveRpc`) so canvas Functions stay
47 * under the 96KB start-command cap. Value methods only — no streams.
48 *
49 * Importing this module registers the Function-runtime hook. Tagged
50 * Functions that host RPC methods must import it (or `bindFunction`,
51 * which re-exports this module).
52 */
53 export const serveRailwayRpc = <Req = never>(
54 shape: Record<string, unknown>,
55 fallback: HttpEffect<Req>,
56 ): HttpEffect<Req> =>
57 Effect.gen(function* () {
58 const request = yield* HttpServerRequest;
59 const prefixAt = request.url.indexOf(RPC_PATH_PREFIX);
60 if (prefixAt === -1) {
61 return yield* fallback;
62 }
63
64 const headers = request.headers as Record<string, string | undefined>;
65 const hostHeader = header(headers, "host");
66 const host =
67 hostHeader.length > 0
68 ? hostHeader
69 : yield* Effect.sync(() => {
70 try {
71 return new URL(request.url).host;
72 } catch {
73 return "";
74 }
75 });
76 const forwarded = header(headers, "x-forwarded-host");
77 const expected = yield* Effect.sync(() => process.env[RPC_TOKEN_ENV] ?? "");
78 const provided = header(headers, RPC_TOKEN_HEADER);
79 if (
80 !isPrivateMesh(host) ||
81 (forwarded.length > 0 && !isPrivateMesh(forwarded)) ||
82 expected.length === 0 ||
83 provided.length === 0 ||
84 !tokensEqual(provided, expected)
85 ) {
86 return unauthorized;
87 }
88
89 let name = request.url.slice(prefixAt + RPC_PATH_PREFIX.length);
90 const queryAt = name.indexOf("?");
91 if (queryAt !== -1) name = name.slice(0, queryAt);
92 name = decodeURIComponent(name);
93
94 const method = shape[name];
95 if (typeof method !== "function") {
96 return HttpServerResponse.text(`Unknown RPC method "${name}"`, {
97 status: 404,
98 });
99 }
100
101 const text = yield* request.text;
102 let args: unknown[] = [];
103 if (text.length > 0) {
104 const parsed = yield* Effect.result(Effect.try(() => JSON.parse(text) as unknown[]));
105 if (Result.isFailure(parsed)) {
106 return HttpServerResponse.text(`Invalid RPC arguments for "${name}"`, {
107 status: 400,
108 });
109 }
110 args = parsed.success;
111 }
112
113 const invoked = (method as (...a: unknown[]) => unknown)(...args);
114 if (!Effect.isEffect(invoked)) {
115 return yield* HttpServerResponse.json(invoked ?? null);
116 }
117 // oxlint-disable-next-line effecttsgo/unsafe-effect-type-assertion -- RPC methods are pre-provided service Effects
118 const result = yield* Effect.result(invoked as Effect.Effect<unknown, unknown>);
119 if (Result.isSuccess(result)) {
120 return yield* HttpServerResponse.json(result.success ?? null);
121 }
122 return yield* HttpServerResponse.json({
123 _tag: RPC_ERROR_TAG,
124 error: result.failure,
125 });
126 });
127
128 /** Register private-mesh RPC on this Function/Service isolate. */
129 export const enableRailwayRpc = (): void => {
130 (globalThis as any).__R = serveRailwayRpc;
131 };