Skip to content
Source
Sign inSign up
pingdotgg/t3code
Open History to see the last commit

OpenCode2Server.ts

166 lines5.8 KB

1// One OpenCode 2 process serves all directories; share it across instance threads.
2import type { OpenCodeClient } from "@opencode/client/effect";
3import * as Context from "effect/Context";
4import * as SecureRandom from "effect/crypto/SecureRandom";
5import * as Effect from "effect/Effect";
6import * as Base64Url from "effect/encoding/Base64Url";
7import * as P from "effect/Predicate";
8import * as Redacted from "effect/Redacted";
9import * as HttpClientError from "effect/http/HttpClientError";
10​
11import * as OpenCodeRuntime from "../OpenCodeRuntime.ts";
12import * as OpenCodeServerOwner from "../OpenCodeServerOwner.ts";
13import * as OpenCode2Client from "./OpenCode2Client.ts";
14​
15const INFO_TIMEOUT = "5 seconds";
16​
17export interface OpenCode2Connection extends OpenCode2Client.OpenCode2Api {
18 readonly url: string;
19 readonly version: string;
20 readonly external: boolean;
22​
23export class OpenCode2Server extends Context.Service<
24 OpenCode2Server,
25 {
26 readonly withConnection: <A, E, R>(
27 use: (connection: OpenCode2Connection) => Effect.Effect<A, E, R>,
28 ) => Effect.Effect<A, E | OpenCodeRuntime.OpenCodeRuntimeError, R>;
29 }
30>()("@t3tools/provider-opencode/server/v2/OpenCode2Server") {}
31​
32/**
33 * OpenCode 2 always requires one and prints a generated one to stdout
34 * otherwise, so T3 supplies its own and keeps it in memory.
35 */
36const generatePassword = Effect.gen(function* () {
37 const random = yield* SecureRandom.SecureRandom;
38 const bytes = yield* random.randomBytes(32);
39 return Redacted.make(Base64Url.encode(bytes), { label: "OPENCODE_PASSWORD" });
40});
41​
42/** OPENCODE_PASSWORD overrides OPENCODE_SERVER_PASSWORD; drop the inherited 1.x variable. */
43export const serverEnvironment = (
44 environment: NodeJS.ProcessEnv,
45 password: Redacted.Redacted,
46): NodeJS.ProcessEnv => {
47 const { OPENCODE_SERVER_PASSWORD: _inherited, ...rest } = environment;
48 return { ...rest, OPENCODE_PASSWORD: Redacted.value(password) };
49};
50​
51const httpFailureOf = (cause: unknown): HttpClientError.HttpClientError | undefined => {
52 if (HttpClientError.isHttpClientError(cause)) return cause;
53 if (
54 P.isTagged(cause, "ClientError") &&
55 P.hasProperty(cause, "cause") &&
56 HttpClientError.isHttpClientError(cause.cause)
57 ) {
58 return cause.cause;
59 }
60 return undefined;
61};
62​
63// Empty 401s still reject passwords; undecodable 2xx may be 1.x HTML, not OpenCode 2.
64const describeInfoFailure = (cause: unknown) => {
65 const failure = httpFailureOf(cause);
66 if (failure?.reason._tag === "TransportError") {
67 return "Could not reach the OpenCode server.";
68 }
69 const status = failure?.response?.status;
70 if (status === 401) return "The OpenCode server rejected the server password.";
71 if (status !== undefined && (status < 200 || status >= 300)) {
72 return `The OpenCode server returned HTTP ${status}.`;
73 }
74 return "The server is not an OpenCode 2 server.";
75};
76​
77/** Only server info proves readiness; keep credential-bearing failure details out of client text. */
78export const verifyServer = (client: OpenCodeClient) =>
79 client.server.info().pipe(
80 Effect.timeoutOrElse({
81 duration: INFO_TIMEOUT,
82 orElse: () =>
83 Effect.fail(
84 new OpenCodeRuntime.OpenCodeRuntimeError({
85 operation: "server.info",
86 detail: "Timed out waiting for the OpenCode server.",
87 }),
88 ),
89 }),
90 Effect.catchTags({
91 UnauthorizedError: (cause) =>
92 Effect.fail(
93 new OpenCodeRuntime.OpenCodeRuntimeError({
94 operation: "server.info",
95 detail: "The OpenCode server rejected the server password.",
96 cause,
97 }),
98 ),
99 }),
100 Effect.mapError((cause) =>
101 OpenCodeRuntime.isOpenCodeRuntimeError(cause)
102 ? cause
103 : new OpenCodeRuntime.OpenCodeRuntimeError({
104 operation: "server.info",
105 detail: describeInfoFailure(cause),
106 cause,
107 }),
108 ),
109 Effect.map((info) => info.version),
110 );
111​
112export const make = Effect.fn("OpenCode2Server.make")(function* (input: {
113 readonly binaryPath: string;
114 readonly serverUrl: string;
115 readonly serverPassword: string;
116 readonly directory: string;
117 readonly environment: NodeJS.ProcessEnv;
118}) {
119 const opencode = yield* OpenCode2Client.OpenCode2Client;
120 const connectTo = Effect.fn("OpenCode2Server.connectTo")(function* (
121 url: string,
122 password: Redacted.Redacted,
123 external: boolean,
124 ) {
125 const api = yield* opencode.connect({ baseUrl: url, password });
126 const version = yield* verifyServer(api.client);
127 return { ...api, url, version, external } satisfies OpenCode2Connection;
128 });
129 let latest: OpenCode2Connection | undefined;
130 const remember = (connection: OpenCode2Connection) =>
131 Effect.sync(() => {
132 latest = connection;
133 return connection.version;
134 });
135​
136 const serverUrl = input.serverUrl.trim();
137 if (serverUrl.length > 0) {
138 const connect = connectTo(serverUrl, Redacted.make(input.serverPassword), true).pipe(
139 Effect.tap(remember),
140 );
141 return OpenCode2Server.of({
142 withConnection: Effect.fn("OpenCode2Server.withConnection")(function (use) {
143 return Effect.suspend(() => (latest === undefined ? connect : Effect.succeed(latest))).pipe(
144 Effect.flatMap(use),
145 );
146 }),
147 });
148 }
149​
150 const password = yield* generatePassword;
151 const owner = yield* OpenCodeServerOwner.make({
152 binaryPath: input.binaryPath,
153 directory: input.directory,
154 environment: serverEnvironment(input.environment, password),
155 verify: (url) => connectTo(url, password, false).pipe(Effect.flatMap(remember)),
156 });
157 return OpenCode2Server.of({
158 withConnection: Effect.fn("OpenCode2Server.withConnection")(function (use) {
159 return owner.withServer((server) =>
160 latest?.url === server.url
161 ? use(latest)
162 : Effect.die(new Error("OpenCode 2 server was lent before verification.")),
163 );
164 }),
165 });
166});