@devries-cameron20 / t3code Mirror · read-only / commits / b5256ad09c
Fork 0

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, 23:30 UTC

fix(opencode): verify CLI updates when loopback server is still running (#22839)

Co-authored-by: maria-rcks <maria@kuuro.net> Co-authored-by: Julius Marminge <julius0216@outlook.com>

intrepid37 committed Nov 11, 2026 at 04:37 UTC b5256ad09c0553347a6ddfd2d30de9b9c12c79d5
9 files changed +241 -25
apps/server/src/provider/providerMaintenanceRunner.test.ts
+25 -5
@@ -978,6 +978,12 @@ describe("providerMaintenanceRunner", () => {
978 });
979
980 it.effect.each([
981 + {
982 + mode: "default-precurrent",
983 + version: "1.14.19",
984 + installation: { installedVersion: "1.14.20" },
985 + status: "succeeded",
986 + },
987 {
988 mode: "default",
989 version: "1.14.19",
@@ -1033,7 +1039,11 @@ it.effect.each([
1039 ...registry,
1040 refreshInstance: () =>
1041 Ref.updateAndGet(providersRef, (providers) =>
1036 - providers.map((provider) => ({ ...provider, checkedAt: "2026-04-10T00:00:01.000Z" })),
1042 + providers.map((provider) => ({
1043 + ...provider,
1044 + ...(mode === "default-precurrent" ? installation : {}),
1045 + checkedAt: "2026-04-10T00:00:01.000Z",
1046 + })),
1047 ),
1048 getProviderMaintenanceCapabilitiesForInstance: () => Effect.succeed(pinnedCapabilities),
1049 refreshAfterUpdate: () =>
@@ -1059,17 +1069,27 @@ it.effect.each([
1069
1070 const result = yield* updater.updateProvider({
1071 provider: OPENCODE_DRIVER,
1062 - ...(mode === "default" ? {} : { targetVersion: "1.14.20" }),
1072 + ...(mode.startsWith("default") ? {} : { targetVersion: "1.14.20" }),
1073 });
1074
1065 - assert.deepStrictEqual(calls, [
1066 - `npm install -g opencode-ai@${mode === "default" ? "latest" : "1.14.20"}`,
1067 - ]);
1075 + assert.deepStrictEqual(
1076 + calls,
1077 + mode === "default-precurrent"
1078 + ? []
1079 + : [`npm install -g opencode-ai@${mode.startsWith("default") ? "latest" : "1.14.20"}`],
1080 + );
1081 const provider = result.providers[0];
1082 assert.ok(provider);
1083 assert.strictEqual(provider.updateState?.status, status);
1084 + if (mode === "default" || mode === "default-precurrent" || mode === "targeted") {
1085 + assert.strictEqual(
1086 + provider.updateState?.message,
1087 + "OpenCode CLI updated. Restart the configured local OpenCode server to use the new version.",
1088 + );
1089 + }
1090 assert.strictEqual(provider.version, version);
1091 assert.strictEqual("installedVersion" in provider, mode !== "legacy");
1092 + if (mode === "default-precurrent") return;
1093 assert.strictEqual(
1094 provider.versionAdvisory?.status,
1095 mode === "unknown" ? "unknown" : "current",
apps/server/src/provider/providerMaintenanceRunner.ts
+18 -2
@@ -94,6 +94,18 @@ interface VerifiedProviderRefresh {
94
95 const nowIso = Effect.map(DateTime.now, DateTime.formatIso);
96
97 +const OPENCODE_SERVER_RESTART_MESSAGE =
98 + "OpenCode CLI updated. Restart the configured local OpenCode server to use the new version.";
99 +
100 +const needsOpenCodeServerRestart = (providers: ReadonlyArray<ServerProvider>) =>
101 + providers.some(
102 + (provider) =>
103 + provider.driver === ProviderDriverKind.make("opencode") &&
104 + provider.installedVersion != null &&
105 + provider.version != null &&
106 + provider.installedVersion !== provider.version,
107 + );
108 +
109 const runProviderMaintenanceCommandWithSpawner = Effect.fn("ProviderMaintenanceRunner.runCommand")(
110 function* (input: {
111 readonly spawner: ChildProcessSpawner.ChildProcessSpawner["Service"];
@@ -527,7 +539,9 @@ export const make = Effect.fn("ProviderMaintenanceRunner.make")(function* () {
539 status: "succeeded",
540 startedAt,
541 finishedAt: yield* nowIso,
530 - message: "Already up to date.",
542 + message: needsOpenCodeServerRestart(precheck.verifiedProviders)
543 + ? OPENCODE_SERVER_RESTART_MESSAGE
544 + : "Already up to date.",
545 }),
546 );
547 }
@@ -600,7 +614,9 @@ export const make = Effect.fn("ProviderMaintenanceRunner.make")(function* () {
614 ? "Update command completed, but T3 Code could not verify the provider version."
615 : stillOutdated
616 ? "Update command completed, but T3 Code still detects an outdated provider version."
603 - : "Provider updated.",
617 + : needsOpenCodeServerRestart(verifiedProviders)
618 + ? OPENCODE_SERVER_RESTART_MESSAGE
619 + : "Provider updated.",
620 output: commandOutput(result),
621 }),
622 );
apps/web/src/components/ProviderUpdateLaunchNotification.logic.test.ts
+35
@@ -318,6 +318,41 @@ describe("getProviderUpdateRunToastView", () => {
318 result,
319 });
320
321 + it("preserves the local server restart instruction after a successful update", () => {
322 + const message =
323 + "OpenCode CLI updated. Restart the configured local OpenCode server to use the new version.";
324 + const updated = {
325 + ...provider({
326 + driver: driver("opencode"),
327 + version: "2.1.2",
328 + advisoryStatus: "current",
329 + updateState: updateState("succeeded", message),
330 + }),
331 + installedVersion: "2.2.5",
332 + };
333 + expect(
334 + getProviderUpdateRunToastView([
335 + run("Linux", "opencode", AsyncResult.success({ providers: [updated] })),
336 + run("Laptop", "opencode", AsyncResult.success({ providers: [updated] })),
337 + ]),
338 + ).toMatchObject({
339 + type: "success",
340 + description: `Linux · OpenCode: ${message}\nLaptop · OpenCode: ${message}`,
341 + });
342 + expect(
343 + getProviderUpdateSidebarPillView([updated], {
344 + visibleAfterIso: sessionStartedAt,
345 + }),
346 + ).toMatchObject({ title: "OpenCode updated: v2.2.5", description: message });
347 +
348 + const restarted = { ...updated, version: "2.2.5" };
349 + expect(
350 + getProviderUpdateRunToastView([
351 + run("Linux", "opencode", AsyncResult.success({ providers: [restarted] })),
352 + ]),
353 + ).toMatchObject({ description: "New sessions will use the updated provider." });
354 + });
355 +
356 it("lists every failed update and ignores interrupted ones", () => {
357 const view = getProviderUpdateRunToastView([
358 run(
apps/web/src/components/ProviderUpdateLaunchNotification.logic.ts
+37 -12
@@ -78,11 +78,24 @@ function dedupeProvidersByDriver<T extends ServerProvider>(providers: ReadonlyAr
78 return [...latestProviderByDriver.values()];
79 }
80
81 -function getProviderUpdatedTitle(provider: Pick<ServerProvider, "driver" | "version">): string {
81 +function getProviderUpdatedTitle(
82 + provider: Pick<ServerProvider, "driver" | "version" | "installedVersion">,
83 +): string {
84 const providerName = PROVIDER_DISPLAY_NAMES[provider.driver] ?? provider.driver;
83 - return provider.version
84 - ? `${providerName} updated: ${formatVersion(provider.version)}`
85 - : `${providerName} updated`;
85 + const version = provider.installedVersion ?? provider.version;
86 + return version ? `${providerName} updated: ${formatVersion(version)}` : `${providerName} updated`;
87 +}
88 +
89 +// Only OpenCode reports an installed CLI apart from a running external server.
90 +export function getProviderRestartNotice(
91 + provider: Pick<ServerProvider, "version" | "installedVersion" | "updateState">,
92 +): string | null {
93 + return provider.updateState?.status === "succeeded" &&
94 + provider.installedVersion != null &&
95 + provider.version != null &&
96 + provider.installedVersion !== provider.version
97 + ? provider.updateState.message
98 + : null;
99 }
100
101 function getProviderUpdatedDescription(providerCount: number): string {
@@ -200,7 +213,8 @@ export interface ProviderUpdateRun {
213 export function getProviderUpdateRunOutcome(
214 run: ProviderUpdateRun,
215 ):
203 - | { readonly status: "interrupted" | "updated" }
216 + | { readonly status: "interrupted" }
217 + | { readonly status: "updated"; readonly message: string | null }
218 | { readonly status: "failed"; readonly line: string } {
219 if (isAtomCommandInterrupted(run.result)) return { status: "interrupted" };
220 const label = `${run.machineLabel} · ${PROVIDER_DISPLAY_NAMES[run.driver] ?? run.driver}`;
@@ -211,11 +225,13 @@ export function getProviderUpdateRunOutcome(
225 line: `${label}: ${error instanceof Error ? error.message : "Provider update failed."}`,
226 };
227 }
214 - const updateState = run.result.value.providers.find(
215 - (provider) => provider.instanceId === run.instanceId,
216 - )?.updateState;
228 + const provider = run.result.value.providers.find(
229 + (candidate) => candidate.instanceId === run.instanceId,
230 + );
231 + const updateState = provider?.updateState;
232 + const restartNotice = provider ? getProviderRestartNotice(provider) : null;
233 return updateState?.status === "succeeded"
218 - ? { status: "updated" }
234 + ? { status: "updated", message: restartNotice ? `${label}: ${restartNotice}` : null }
235 : {
236 status: "failed",
237 line: `${label}: ${updateState?.message ?? "Provider update did not finish."}`,
@@ -236,11 +252,18 @@ export function getProviderUpdateRunToastView(runs: ReadonlyArray<ProviderUpdate
252 const failureLines = settled.flatMap((outcome) =>
253 outcome.status === "failed" ? [outcome.line] : [],
254 );
255 + const successMessages = [
256 + ...new Set(
257 + settled.flatMap((outcome) =>
258 + outcome.status === "updated" && outcome.message ? [outcome.message] : [],
259 + ),
260 + ),
261 + ];
262 if (failureLines.length === 0) {
263 return {
264 type: "success",
265 title: settled.length === 1 ? "Provider updated" : `${settled.length} providers updated`,
243 - description: getProviderUpdatedDescription(settled.length),
266 + description: successMessages.join("\n") || getProviderUpdatedDescription(settled.length),
267 };
268 }
269 return {
@@ -251,7 +274,7 @@ export function getProviderUpdateRunToastView(runs: ReadonlyArray<ProviderUpdate
274 : settled.length === 1
275 ? "Provider update failed"
276 : "Provider updates failed",
254 - description: failureLines.join("\n"),
277 + description: [...failureLines, ...successMessages].join("\n"),
278 };
279 }
280
@@ -398,7 +421,9 @@ export function getProviderUpdateSidebarPillView(
421 succeededProviders.length === 1
422 ? getProviderUpdatedTitle(succeededProvider)
423 : `${succeededProviders.length} providers updated`,
401 - description: getProviderUpdatedDescription(succeededProviders.length),
424 + description:
425 + [...new Set(succeededProviders.map(getProviderRestartNotice).filter(Boolean))].join("\n") ||
426 + getProviderUpdatedDescription(succeededProviders.length),
427 dismissAfterVisibleMs: PROVIDER_UPDATE_SUCCESS_VISIBLE_MS,
428 });
429 }
apps/web/src/components/settings/ProviderInstanceCard.tsx
+8
@@ -70,6 +70,7 @@ import { SettingResetButton, SettingsRow, SettingsSection } from "./settingsLayo
70 import { AcpSessionManagementSection } from "./AcpSessionManagementSection";
71 import { FoldedSettingsSection } from "./FoldedSettingsSection";
72 import { readCodexSetupMode } from "./CodexSetupSection.logic";
73 +import { getProviderRestartNotice } from "../ProviderUpdateLaunchNotification.logic";
74 import {
75 getProviderVersionAdvisoryPresentation,
76 PROVIDER_STATUS_STYLES,
@@ -770,6 +771,8 @@ export function ProviderInstanceCard({
771 !isUpdating && (updateState?.status === "failed" || updateState?.status === "unchanged")
772 ? updateState.message
773 : null;
774 + const restartNotice =
775 + enabled && !isUpdating && liveProvider ? getProviderRestartNotice(liveProvider) : null;
776 const hasCompatibilityWarning =
777 compatibility !== undefined &&
778 compatibility.status !== "supported" &&
@@ -1212,6 +1215,11 @@ export function ProviderInstanceCard({
1215 {editorStatusNode}
1216 </div>
1217 </ProviderStatusDiagnostic>
1218 + {restartNotice ? (
1219 + <p aria-live="polite" className="text-xs leading-snug [overflow-wrap:anywhere]">
1220 + {restartNotice}
1221 + </p>
1222 + ) : null}
1223 {urlAuthAction && onAcceptUrlAuth ? (
1224 <div className="grid max-w-xl gap-1.5 pt-1 text-xs">
1225 <p>{urlAuthAction.message}</p>
docs/user/providers-opencode.md
+6
@@ -41,6 +41,12 @@ settings. T3 Code uses only that configured password for an external server; it
41 does not forward a local `OPENCODE_SERVER_PASSWORD`. If connection or version checks
42 fail, check the URL, credentials, and OpenCode version, then refresh provider status.
43
44 +When **Server URL** points to a locally running server (such as `127.0.0.1`),
45 +the update button upgrades its installed CLI without terminating the running server.
46 +The server can still report the previous version until you restart it. T3 Code
47 +shows that restart requirement instead of treating the CLI update as a failure.
48 +Restart the server when active sessions can safely be interrupted.
49 +
50 After a lost connection, send another prompt to reconnect to the same OpenCode
51 session.
52
packages/provider-opencode/src/server/driver.test.ts
+69 -3
@@ -35,11 +35,23 @@ import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderS
35 import * as ProviderEventLoggers from "@t3tools/provider-core/server/ProviderEventLoggers";
36 import * as ProviderMaintenance from "@t3tools/provider-core/server/maintenanceResolver";
37 import * as OpenCodeRuntime from "./OpenCodeRuntime.ts";
38 +import { OpenCodeDriver, isLocalOpenCodeServerUrl, openCodeUpdateFor } from "./driver.ts";
39 import * as OpenCodeServerLedger from "./OpenCodeServerLedger.ts";
40 import { OPENCODE_2_RESPONSES, replayOpenCodeServer } from "./probeResponses.fixture.ts";
40 -import { OpenCodeDriver, openCodeUpdateFor } from "./driver.ts";
41 import * as TestProviderHost from "@t3tools/provider-testing/TestProviderHost";
42
43 +it("only probes a locally configured OpenCode server's installed CLI", () => {
44 + assert.isTrue(isLocalOpenCodeServerUrl("http://127.0.0.1:35768"));
45 + assert.isTrue(isLocalOpenCodeServerUrl("http://127.255.255.254:4096"));
46 + assert.isFalse(isLocalOpenCodeServerUrl("http://127.example.com:4096"));
47 + assert.isFalse(isLocalOpenCodeServerUrl("http://128.0.0.1:4096"));
48 + assert.isTrue(isLocalOpenCodeServerUrl("http://localhost:4096"));
49 + assert.isTrue(isLocalOpenCodeServerUrl("http://[::1]:4096"));
50 + assert.isFalse(isLocalOpenCodeServerUrl("https://remote.example.com:4096"));
51 + assert.isFalse(isLocalOpenCodeServerUrl(""));
52 + assert.isFalse(isLocalOpenCodeServerUrl("file:///tmp/opencode"));
53 +});
54 +
55 const serverStarts: Array<string> = [];
56 const reachedServer = (operation: string) =>
57 Effect.sync(() => serverStarts.push(operation)).pipe(
@@ -70,12 +82,12 @@ const layer = Layer.mergeAll(
82 Layer.succeed(OpenCodeRuntime.OpenCodeRuntime, openCode2Runtime),
83 ).pipe(Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)));
84
73 -const create = (config: Partial<OpenCodeSettings>, http: HttpClient.HttpClient) =>
85 +const create = (config: Partial<OpenCodeSettings>, http: HttpClient.HttpClient, enabled = true) =>
86 OpenCodeDriver.create({
87 instanceId: ProviderInstanceId.make("opencode-test"),
88 displayName: undefined,
89 environment: [],
78 - enabled: true,
90 + enabled,
91 config: { ...OpenCodeDriver.defaultConfig(), ...config },
92 }).pipe(Effect.provideService(HttpClient.HttpClient, http));
93
@@ -187,6 +199,60 @@ it.layer(layer)("OpenCodeDriver runtime selection", (it) => {
199 }).pipe(Effect.scoped),
200 );
201
202 + it.effect.each(["2.1.2", null])(
203 + "reports the installed CLI version independently of the loopback server (%s)",
204 + (installedVersion) =>
205 + Effect.gen(function* () {
206 + const probeOffline: Array<string | undefined> = [];
207 + const runtime = {
208 + ...openCode2Runtime,
209 + runOpenCodeCommand: (input) =>
210 + Effect.sync(() => {
211 + probeOffline.push(input.environment?.MISE_OFFLINE);
212 + return {
213 + stdout:
214 + installedVersion === null ? "unrecognized" : `opencode v${installedVersion}\n`,
215 + stderr: "",
216 + code: 0,
217 + };
218 + }),
219 + } as OpenCodeRuntime.OpenCodeRuntime["Service"];
220 + const instance = yield* create(
221 + { serverUrl: "http://127.0.0.1:4096" },
222 + replayOpenCodeServer(OPENCODE_2_RESPONSES, ""),
223 + ).pipe(Effect.provideService(OpenCodeRuntime.OpenCodeRuntime, runtime));
224 +
225 + const snapshot = yield* instance.snapshot.refresh;
226 + assert.strictEqual(snapshot.version, "2.0.18");
227 + assert.strictEqual(snapshot.installedVersion, installedVersion ?? undefined);
228 + const maintenance = yield* instance.snapshot.resolveMaintenance({ fresh: true });
229 + assert.strictEqual(maintenance.packageName, "@opencode/cli");
230 + assert.isNotEmpty(probeOffline);
231 + assert.isTrue(probeOffline.every((offline) => offline === "1"));
232 + }).pipe(Effect.scoped),
233 + );
234 +
235 + it.effect("skips the installed CLI probe when a localhost provider is disabled", () =>
236 + Effect.gen(function* () {
237 + const probed: string[] = [];
238 + const runtime = {
239 + ...openCode2Runtime,
240 + runOpenCodeCommand: () =>
241 + Effect.sync(() => {
242 + probed.push("--version");
243 + return { stdout: "opencode v2.1.2\n", stderr: "", code: 0 };
244 + }),
245 + } as OpenCodeRuntime.OpenCodeRuntime["Service"];
246 + const instance = yield* create({ serverUrl: "http://127.0.0.1:4096" }, noHttp, false).pipe(
247 + Effect.provideService(OpenCodeRuntime.OpenCodeRuntime, runtime),
248 + );
249 +
250 + const snapshot = yield* instance.snapshot.refresh;
251 + assert.isFalse(snapshot.enabled);
252 + assert.deepStrictEqual(probed, []);
253 + }).pipe(Effect.scoped),
254 + );
255 +
256 it.effect("opens a session through OpenCode 2 that a lazy mise shim installs on first use", () =>
257 Effect.gen(function* () {
258 serverStarts.length = 0;
packages/provider-opencode/src/server/driver.ts
+42 -2
@@ -42,6 +42,7 @@ import * as OpenCodeRuntime from "./OpenCodeRuntime.ts";
42 import {
43 makeOpenCodeRuntimeProbe,
44 probeOpenCodeRuntime,
45 + probeOpenCodeBinary,
46 type ProbedOpenCode,
47 } from "./versionProbe.ts";
48 import * as OpenCodeServerOwner from "./OpenCodeServerOwner.ts";
@@ -72,6 +73,18 @@ const decodeOpenCodeSettings = Schema.decodeSync(OpenCodeSettings);
73
74 const DRIVER_KIND = ProviderDriverKind.make("opencode");
75
76 +// A loopback server runs on this environment, but can outlive its CLI installation.
77 +// Its reported version may therefore differ from the installed executable after an update.
78 +export function isLocalOpenCodeServerUrl(serverUrl: string): boolean {
79 + const url = URL.parse(serverUrl.trim());
80 + if (url?.protocol !== "http:" && url?.protocol !== "https:") return false;
81 + return (
82 + url.hostname === "localhost" ||
83 + url.hostname === "[::1]" ||
84 + /^127\.(?:\d{1,3}\.){2}\d{1,3}$/.test(url.hostname)
85 + );
86 +}
87 +
88 function isOpenCodeNativeCommandPath(commandPath: string): boolean {
89 const normalized = normalizeCommandPath(commandPath);
90 return (
@@ -283,7 +296,17 @@ export const OpenCodeDriver: ProviderDriver<
296 Effect.provideService(Path.Path, pathService),
297 );
298 const cachedMaintenance = yield* makeCachedProviderMaintenanceResolution(
286 - maintenanceFor(runtimeProbe.get),
299 + maintenanceFor(
300 + isLocalOpenCodeServerUrl(effectiveConfig.serverUrl)
301 + ? probeOpenCodeBinary(
302 + effectiveConfig.binaryPath,
303 + providerProbeEnvironment(processEnv),
304 + ).pipe(
305 + Effect.provideService(OpenCodeRuntime.OpenCodeRuntime, openCodeRuntime),
306 + Effect.catch(() => runtimeProbe.get),
307 + )
308 + : runtimeProbe.get,
309 + ),
310 );
311 const resolveMaintenance = (options?: { readonly fresh?: boolean }) =>
312 !effectiveConfig.enabled
@@ -397,6 +420,19 @@ export const OpenCodeDriver: ProviderDriver<
420 );
421 const checkProvider = Effect.all(
422 {
423 + // A configured loopback server reports its running version. Probe the local
424 + // CLI separately so a completed npm update is not mistaken for a failure
425 + // while that independently managed server still runs the previous binary.
426 + installedVersion:
427 + effectiveConfig.enabled && isLocalOpenCodeServerUrl(effectiveConfig.serverUrl)
428 + ? probeOpenCodeBinary(
429 + effectiveConfig.binaryPath,
430 + providerProbeEnvironment(processEnv),
431 + ).pipe(
432 + Effect.map((probed) => probed.version),
433 + Effect.orElseSucceed(() => undefined),
434 + )
435 + : Effect.void,
436 provider: checkOpenCodeProviderStatus(
437 effectiveConfig,
438 host.paths.cwd,
@@ -410,7 +446,11 @@ export const OpenCodeDriver: ProviderDriver<
446 },
447 { concurrency: "unbounded" },
448 ).pipe(
413 - Effect.map(({ provider, usageLimits }) => ({ ...provider, usageLimits })),
449 + Effect.map(({ provider, usageLimits, installedVersion }) => ({
450 + ...provider,
451 + usageLimits,
452 + ...(installedVersion === undefined ? {} : { installedVersion }),
453 + })),
454 Effect.map(stampIdentity),
455 Effect.provideService(OpenCodeServerOwner.OpenCodeServerOwner, serverOwner),
456 Effect.provideService(OpenCodeRuntime.OpenCodeRuntime, openCodeRuntime),
packages/provider-opencode/src/server/versionProbe.ts
+1 -1
@@ -55,7 +55,7 @@ function classifyOpenCodeProbeResponse(
55 return probed(Option.getOrUndefined(version));
56 }
57
58 -const probeOpenCodeBinary = Effect.fn("probeOpenCodeBinary")(function* (
58 +export const probeOpenCodeBinary = Effect.fn("probeOpenCodeBinary")(function* (
59 binaryPath: string,
60 environment: NodeJS.ProcessEnv | undefined,
61 ) {