fix(opencode): leave configured server updates to their owner

apps/mobile/src/features/settings/SettingsEnvironmentDetailRouteScreen.tsx

@@ -376,7 +376,8 @@ function EnvironmentDetail({ environmentId }: { readonly environmentId: Environm
                           {provider.versionAdvisory?.status === "behind_latest" &&
                           !provider.versionAdvisory.canUpdate ? (
                             <Text className="text-sm text-foreground-muted">
-                              Update this provider on the environment's machine.
+                              {provider.versionAdvisory.message ??
+                                "Update this provider on the environment's machine."}
                             </Text>
                           ) : null}
                         </View>

docs/user/providers-opencode.md

@@ -13,8 +13,8 @@ the same provider settings work for OpenCode 1.x and 2.x. OpenCode 1.x shows
 
 OpenCode 2 is a separate package, `@opencode/cli`. To move from 1.x, install it
 yourself, for example `npm install -g @opencode/cli`. Then refresh provider status.
-T3 Code's update button updates whichever package you have installed. It never
-switches a 1.x install to 2.x.
+When T3 Code manages the local server, its update button updates whichever package
+you have installed. It never switches a 1.x install to 2.x.
 
 OpenCode 2 converts the shared OpenCode database to its own format the first time it
 runs. Don't run OpenCode 1.x and 2.x side by side on the same machine. Threads you
@@ -43,6 +43,12 @@ settings. T3 Code uses only that configured password for an external server; it
 does not forward a local `OPENCODE_SERVER_PASSWORD`. If connection or version checks
 fail, check the URL, credentials, and OpenCode version, then refresh provider status.
 
+With **Server URL** set, update the server through the app or tool that started it,
+then restart it when active sessions can safely be interrupted. This also applies
+to localhost: that server may use a different installation from the local CLI.
+T3 Code reports the running server's version and leaves its updates to you. After
+updating it, refresh provider status to check the new version.
+
 After a lost connection, send another prompt to reconnect to the same OpenCode
 session.
 

packages/provider-opencode/src/server/driver.test.ts

@@ -9,6 +9,7 @@ import { assert, it } from "@effect/vitest";
 import {
   DEFAULT_SERVER_SETTINGS,
   ProviderInstanceId,
+  type ResolvedProviderInstanceEnvironment,
   ProviderSessionId,
   ThreadId,
 } from "@t3tools/contracts";
@@ -23,6 +24,7 @@ import * as Layer from "effect/Layer";
 import * as Logger from "effect/Logger";
 import * as References from "effect/References";
 import * as Stream from "effect/Stream";
+import * as Sink from "effect/Sink";
 import * as TestClock from "effect/testing/TestClock";
 import * as HttpClient from "effect/http/HttpClient";
 import * as HttpClientResponse from "effect/http/HttpClientResponse";
@@ -36,8 +38,8 @@ import * as ProviderEventLoggers from "@t3tools/provider-core/server/ProviderEve
 import * as ProviderMaintenance from "@t3tools/provider-core/server/maintenanceResolver";
 import * as OpenCodeRuntime from "./OpenCodeRuntime.ts";
 import * as OpenCodeServerLedger from "./OpenCodeServerLedger.ts";
-import { OPENCODE_2_RESPONSES, replayOpenCodeServer } from "./probeResponses.fixture.ts";
 import { OpenCodeDriver, openCodeUpdateFor } from "./driver.ts";
+import { OPENCODE_2_RESPONSES, replayOpenCodeServer } from "./probeResponses.fixture.ts";
 import * as TestProviderHost from "@t3tools/provider-testing/TestProviderHost";
 
 const serverStarts: Array<string> = [];
@@ -70,17 +72,34 @@ const layer = Layer.mergeAll(
   Layer.succeed(OpenCodeRuntime.OpenCodeRuntime, openCode2Runtime),
 ).pipe(Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)));
 
-const create = (config: Partial<OpenCodeSettings>, http: HttpClient.HttpClient) =>
+const create = (
+  config: Partial<OpenCodeSettings>,
+  http: HttpClient.HttpClient,
+  environment: ResolvedProviderInstanceEnvironment = [],
+) =>
   OpenCodeDriver.create({
     instanceId: ProviderInstanceId.make("opencode-test"),
     displayName: undefined,
-    environment: [],
+    environment,
     enabled: true,
     config: { ...OpenCodeDriver.defaultConfig(), ...config },
   }).pipe(Effect.provideService(HttpClient.HttpClient, http));
 
 const noHttp = HttpClient.make(() => Effect.die("A local binary must not be probed over HTTP"));
 
+const nativeInstall = Effect.gen(function* () {
+  const fileSystem = yield* FileSystem.FileSystem;
+  const root = yield* fileSystem.makeTempDirectoryScoped({ prefix: "t3-opencode-update-owner-" });
+  const directory = NodePath.join(root, ".opencode", "bin");
+  yield* fileSystem.makeDirectory(directory, { recursive: true });
+  const binaryPath = NodePath.join(
+    directory,
+    HostProcess.Platform.defaultValue() === "win32" ? "opencode.exe" : "opencode",
+  );
+  yield* fileSystem.writeFileString(binaryPath, "fixture");
+  yield* fileSystem.chmod(binaryPath, 0o755);
+  return binaryPath;
+});
 it.live("discovers models through a home-relative OpenCode wrapper", () =>
   Effect.gen(function* () {
     const fs = yield* FileSystem.FileSystem;
@@ -158,6 +177,114 @@ it.live("discovers models through a home-relative OpenCode wrapper", () =>
 );
 
 it.layer(layer)("OpenCodeDriver runtime selection", (it) => {
+  it.effect.each(["http://127.0.0.1:4096", "https://server.example.test"])(
+    "keeps updates owned by the configured server at %s",
+    (serverUrl) =>
+      Effect.gen(function* () {
+        const binaryPath = yield* nativeInstall;
+        const cliProbes: string[] = [];
+        const runtime = {
+          ...openCode2Runtime,
+          runOpenCodeCommand: () => {
+            cliProbes.push("--version");
+            return Effect.succeed({ stdout: "opencode v2.1.3\n", stderr: "", code: 0 });
+          },
+        } as OpenCodeRuntime.OpenCodeRuntime["Service"];
+        const responses = {
+          ...OPENCODE_2_RESPONSES,
+          "/api/info": {
+            ...OPENCODE_2_RESPONSES["/api/info"],
+            body: OPENCODE_2_RESPONSES["/api/info"].body.replace("2.0.18", "2.0.32"),
+          },
+        };
+        const latestVersions = yield* ProviderLatestVersions.make([["@opencode/cli", "9.9.9"]]);
+        const npmPath = NodePath.join(NodePath.dirname(binaryPath), "npm");
+        yield* (yield* FileSystem.FileSystem).writeFileString(npmPath, "fixture");
+        yield* (yield* FileSystem.FileSystem).chmod(npmPath, 0o755);
+        const spawner = ChildProcessSpawner.make((command) => {
+          assert.strictEqual(command._tag, "StandardCommand");
+          if (command._tag !== "StandardCommand") return Effect.die("unexpected pipeline");
+          assert.strictEqual(command.command, npmPath);
+          assert.deepStrictEqual(command.args, [
+            "view",
+            "--global",
+            "--json",
+            "@opencode/cli@latest",
+            "version",
+          ]);
+          return Effect.succeed(
+            ChildProcessSpawner.makeHandle({
+              pid: ChildProcessSpawner.ProcessId(1),
+              exitCode: Effect.succeed(ChildProcessSpawner.ExitCode(0)),
+              isRunning: Effect.succeed(false),
+              kill: () => Effect.void,
+              unref: Effect.succeed(Effect.void),
+              stdin: Sink.drain,
+              stdout: Stream.encodeText(Stream.make('"2.1.3"')),
+              stderr: Stream.empty,
+              all: Stream.empty,
+              getInputFd: () => Sink.drain,
+              getOutputFd: () => Stream.empty,
+            }),
+          );
+        });
+        const instance = yield* create(
+          { binaryPath, serverUrl },
+          replayOpenCodeServer(responses, ""),
+          [{ name: "PATH", value: NodePath.dirname(binaryPath), sensitive: false }],
+        ).pipe(
+          Effect.provideService(OpenCodeRuntime.OpenCodeRuntime, runtime),
+          Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
+          Effect.provideService(ProviderLatestVersions.ProviderLatestVersions, latestVersions),
+        );
+        const maintenance = yield* instance.snapshot.resolveMaintenance({ fresh: true });
+        assert.strictEqual(maintenance.packageName, "@opencode/cli");
+        assert.isNull(maintenance.update);
+
+        for (const runningVersion of ["2.0.32", "2.0.32", "2.1.3"]) {
+          responses["/api/info"].body = OPENCODE_2_RESPONSES["/api/info"].body.replace(
+            "2.0.18",
+            runningVersion,
+          );
+          const enriched = yield* instance.snapshot.streamChanges.pipe(
+            Stream.filter(
+              (snapshot) => snapshot.versionAdvisory?.currentVersion === runningVersion,
+            ),
+            Stream.take(1),
+            Stream.runCollect,
+            Effect.forkChild({ startImmediately: true }),
+          );
+          yield* instance.snapshot.refresh;
+          const [snapshot] = yield* Fiber.join(enriched);
+          assert.ok(snapshot);
+          assert.strictEqual(snapshot.version, runningVersion);
+          assert.strictEqual(snapshot.versionAdvisory?.canUpdate, false);
+          assert.strictEqual(snapshot.versionAdvisory?.canInstallVersion, false);
+          assert.isNull(snapshot.versionAdvisory?.updateCommand);
+          assert.strictEqual(
+            snapshot.versionAdvisory?.status,
+            runningVersion === "2.1.3" ? "current" : "behind_latest",
+          );
+          if (runningVersion !== "2.1.3") {
+            assert.include(snapshot.versionAdvisory?.message ?? "", "Version 2.1.3 is out.");
+            assert.include(snapshot.versionAdvisory?.message ?? "", "configured OpenCode server");
+            assert.include(snapshot.versionAdvisory?.message ?? "", "refresh provider status");
+          }
+        }
+        assert.deepStrictEqual(cliProbes, []);
+      }).pipe(Effect.scoped),
+  );
+
+  it.effect("still offers native CLI updates when T3 manages the local server", () =>
+    Effect.gen(function* () {
+      const binaryPath = yield* nativeInstall;
+      const instance = yield* create({ binaryPath, serverUrl: " " }, noHttp);
+      const maintenance = yield* instance.snapshot.resolveMaintenance({ fresh: true });
+      assert.strictEqual(maintenance.update?.executable, binaryPath);
+      assert.deepStrictEqual(maintenance.update?.args, ["upgrade"]);
+    }).pipe(Effect.scoped),
+  );
+
   it.effect("never starts a 1.x server for an OpenCode 2 instance", () =>
     Effect.gen(function* () {
       serverStarts.length = 0;

packages/provider-opencode/src/server/driver.ts

@@ -216,6 +216,7 @@ export const OpenCodeDriver: ProviderDriver<
       enabled,
       binaryPath: expandHomePath(config.binaryPath, yield* HostProcess.HomeDirectory),
     } satisfies OpenCodeSettings;
+    const isExternalServer = effectiveConfig.serverUrl.trim().length > 0;
     const runtimeProbe = yield* makeOpenCodeRuntimeProbe(
       probeOpenCodeRuntime(effectiveConfig, processEnv).pipe(
         Effect.provideService(HttpClient.HttpClient, httpClient),
@@ -233,10 +234,15 @@ export const OpenCodeDriver: ProviderDriver<
         Effect.flatMap((generation) =>
           Option.isNone(generation)
             ? Effect.succeed(noUpdate)
-            : resolveProviderMaintenanceCapabilitiesEffect(openCodeUpdateFor(generation.value), {
-                binaryPath: effectiveConfig.binaryPath,
-                env: processEnv,
-              }),
+            : isExternalServer
+              ? // Even loopback URLs can point to another installation or a forwarded server.
+                resolveProviderMaintenanceCapabilitiesEffect(openCodeUpdateFor(generation.value), {
+                  binaryPath: null,
+                }).pipe(Effect.provideService(HostProcess.Environment, processEnv))
+              : resolveProviderMaintenanceCapabilitiesEffect(openCodeUpdateFor(generation.value), {
+                  binaryPath: effectiveConfig.binaryPath,
+                  env: processEnv,
+                }),
         ),
         Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
         Effect.provideService(FileSystem.FileSystem, fileSystem),
@@ -466,7 +472,19 @@ export const OpenCodeDriver: ProviderDriver<
           ),
           Effect.provideService(HttpClient.HttpClient, httpClient),
           Effect.provideService(ProviderLatestVersions.ProviderLatestVersions, latestVersions),
-          Effect.flatMap((enrichedSnapshot) => publishSnapshot(enrichedSnapshot)),
+          Effect.flatMap((enrichedSnapshot) =>
+            publishSnapshot(
+              isExternalServer && enrichedSnapshot.versionAdvisory?.status === "behind_latest"
+                ? {
+                    ...enrichedSnapshot,
+                    versionAdvisory: {
+                      ...enrichedSnapshot.versionAdvisory,
+                      message: `Version ${enrichedSnapshot.versionAdvisory.latestVersion} is out. Update the configured OpenCode server with the app or tool that started it. Restart that server when active sessions can be interrupted, then refresh provider status.`,
+                    },
+                  }
+                : enrichedSnapshot,
+            ),
+          ),
         ),
     }).pipe(
       Effect.mapError(