import { parseSemver } from "@t3tools/shared/semver";
import * as Cache from "effect/Cache";
import * as Duration from "effect/Duration";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Option from "effect/Option";
import * as Schema from "effect/Schema";
import * as HttpClient from "effect/http/HttpClient";
import * as HttpClientRequest from "effect/http/HttpClientRequest";
import * as OpenCodeRuntime from "./OpenCodeRuntime.ts";
import { parseGenericCliVersion } from "@t3tools/provider-core/server/snapshotProbe";
export interface ProbedOpenCode {
readonly generation: "v1" | "v2";
readonly version: string;
}
// Meant to stop a hung `--version`; wrapped installs can take several seconds to start cold.
const OPENCODE_VERSION_PROBE_TIMEOUT = "10 seconds";
const OPENCODE_SERVER_PROBE_TIMEOUT = "5 seconds";
// 2.x's own CLI decodes `{version, pid}` from `/api/info`; requiring both keeps unrelated JSON out.
const decodeApiInfo = Schema.decodeUnknownOption(
Schema.fromJsonString(Schema.Struct({ version: Schema.String, pid: Schema.Int })),
);
const decodeGlobalHealth = Schema.decodeUnknownOption(
Schema.fromJsonString(Schema.Struct({ healthy: Schema.Literal(true), version: Schema.String })),
);
function probed(version: string | null | undefined): ProbedOpenCode | undefined {
const major = parseSemver(version ?? "")?.major;
if (!version || major === undefined) return undefined;
return { generation: major >= 2 ? "v2" : "v1", version };
}
export const classifyOpenCodeCliVersion = (output: string) =>
probed(parseGenericCliVersion(output));
// Cross-version paths return HTML 200s, so require JSON; either version returns 401 for bad passwords.
function classifyOpenCodeProbeResponse(
path: "/api/info" | "/global/health",
response: {
readonly status: number;
readonly contentType: string | undefined;
readonly body: string;
},
): ProbedOpenCode | "unauthorized" | undefined {
if (response.status === 401) return "unauthorized";
const mediaType = response.contentType?.split(";")[0]?.trim().toLowerCase();
if (response.status !== 200 || mediaType !== "application/json") return undefined;
const version: Option.Option<string> =
path === "/api/info"
? Option.map(decodeApiInfo(response.body), (info) => info.version)
: Option.map(decodeGlobalHealth(response.body), (health) => health.version);
return probed(Option.getOrUndefined(version));
}
const probeOpenCodeBinary = Effect.fn("probeOpenCodeBinary")(function* (
binaryPath: string,
environment: NodeJS.ProcessEnv | undefined,
) {
const runtime = yield* OpenCodeRuntime.OpenCodeRuntime;
const { stdout } = yield* runtime
.runOpenCodeCommand({
binaryPath,
args: ["--version"],
...(environment === undefined ? {} : { environment }),
})
.pipe(
Effect.timeoutOrElse({
duration: OPENCODE_VERSION_PROBE_TIMEOUT,
orElse: () =>
Effect.fail(
new OpenCodeRuntime.OpenCodeRuntimeError({
operation: "probeOpenCodeBinary",
detail: `OpenCode CLI version probe timed out after ${OPENCODE_VERSION_PROBE_TIMEOUT}.`,
}),
),
}),
);
const result = classifyOpenCodeCliVersion(stdout);
if (result) return result;
return yield* new OpenCodeRuntime.OpenCodeRuntimeError({
operation: "probeOpenCodeBinary",
detail: `Unable to determine OpenCode version from \`opencode --version\` output. T3 Code requires OpenCode v${OpenCodeRuntime.MINIMUM_OPENCODE_VERSION} or newer.`,
});
});
// Use fixed status text; underlying errors may expose URLs, credentials, or password headers.
const probeOpenCodeServer = Effect.fn("probeOpenCodeServer")(function* (
serverUrl: string,
serverPassword: string,
) {
const client = yield* HttpClient.HttpClient;
const baseUrl = URL.parse(serverUrl.trim());
if (baseUrl?.protocol !== "http:" && baseUrl?.protocol !== "https:") {
return yield* new OpenCodeRuntime.OpenCodeRuntimeError({
operation: "probeOpenCodeServer",
detail: "The OpenCode server URL is not a valid http:// or https:// URL.",
});
}
// UTF-8, as the 1.x SDK client sends it; `HttpClientRequest.basicAuth` uses Latin-1 `btoa`.
const authorization = serverPassword
? `Basic ${Buffer.from(`opencode:${serverPassword}`, "utf8").toString("base64")}`
: undefined;
for (const path of ["/api/info", "/global/health"] as const) {
const url = new URL(baseUrl);
url.pathname = `${url.pathname.replace(/\/+$/, "")}${path}`;
const request = HttpClientRequest.get(url.href);
const result = yield* client
.execute(
authorization
? HttpClientRequest.setHeader(request, "authorization", authorization)
: request,
)
.pipe(
Effect.flatMap((response) =>
Effect.map(response.text, (body) =>
classifyOpenCodeProbeResponse(path, {
status: response.status,
contentType: response.headers["content-type"],
body,
}),
),
),
Effect.mapError(
(cause) =>
new OpenCodeRuntime.OpenCodeRuntimeError({
operation: "probeOpenCodeServer",
detail: "Couldn't reach the OpenCode server.",
cause,
}),
),
Effect.timeoutOrElse({
duration: OPENCODE_SERVER_PROBE_TIMEOUT,
orElse: () =>
Effect.fail(
new OpenCodeRuntime.OpenCodeRuntimeError({
operation: "probeOpenCodeServer",
detail: "Timed out while checking the OpenCode server version.",
}),
),
}),
);
if (result === "unauthorized") {
return yield* new OpenCodeRuntime.OpenCodeRuntimeError({
operation: "probeOpenCodeServer",
detail: "401 Unauthorized: the OpenCode server rejected the password.",
});
}
if (result !== undefined) return result;
}
return yield* new OpenCodeRuntime.OpenCodeRuntimeError({
operation: "probeOpenCodeServer",
detail: `The server did not identify itself as OpenCode. T3 Code requires OpenCode v${OpenCodeRuntime.MINIMUM_OPENCODE_VERSION} or newer.`,
});
});
export const probeOpenCodeRuntime = (
settings: {
readonly binaryPath: string;
readonly serverUrl: string;
readonly serverPassword: string;
},
environment?: NodeJS.ProcessEnv,
): Effect.Effect<
ProbedOpenCode,
OpenCodeRuntime.OpenCodeRuntimeError,
HttpClient.HttpClient | OpenCodeRuntime.OpenCodeRuntime
> =>
settings.serverUrl.trim().length > 0
? probeOpenCodeServer(settings.serverUrl, settings.serverPassword)
: probeOpenCodeBinary(settings.binaryPath, environment);
// Only 2.x is kept: 1.x can be upgraded in place while T3 runs, and 2.x converts the shared
// database, so going back is unsupported.
export const makeOpenCodeRuntimeProbe = <E>(probe: Effect.Effect<ProbedOpenCode, E>) =>
Effect.map(
Cache.makeWith(() => probe, {
capacity: 1,
timeToLive: (exit) =>
Exit.isSuccess(exit) && exit.value.generation === "v2" ? Duration.infinity : Duration.zero,
}),
(cache) => ({
get: Cache.get(cache, undefined),
refresh: Cache.refresh(cache, undefined),
lastSuccess: Cache.getSuccess(cache, undefined),
}),
);