@devries-cameron20 / t3code-1 / commits / f390ae7f15
Fork 0

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

fix(ssh): an older client no longer replaces a newer running SSH server (#29428)

Julius Marminge committed Nov 16, 2026 at 19:44 UTC f390ae7f1507872e0799685d3806fc309dad0d75
4 files changed +265 -4
apps/server/src/cli/sshHelper.test.ts new
+21
@@ -0,0 +1,21 @@
1 +import { assert, it } from "@effect/vitest";
2 +
3 +import { keepsRunningServer } from "./sshHelper.ts";
4 +
5 +const runtime = (fields: Record<string, unknown>) =>
6 + JSON.stringify({ version: 1, pid: 42, port: 3773, ...fields });
7 +
8 +it("keeps a same-or-newer server and replaces an older or unidentified one", () => {
9 + assert.isTrue(keepsRunningServer(runtime({ serverVersion: "0.1.6" }), 42, "0.1.6"));
10 + assert.isTrue(
11 + keepsRunningServer(runtime({ serverVersion: "0.1.7-nightly.20261102.4080" }), 42, "0.1.6"),
12 + );
13 + assert.isFalse(
14 + keepsRunningServer(runtime({ serverVersion: "0.1.7-nightly.20261102.4080" }), 42, "0.1.7"),
15 + );
16 + assert.isFalse(keepsRunningServer(runtime({ serverVersion: "0.1.5" }), 42, "0.1.6"));
17 + assert.isFalse(keepsRunningServer(runtime({ serverVersion: "0.1.6" }), 7, "0.1.6"));
18 + assert.isFalse(keepsRunningServer(runtime({}), 42, "0.1.6"));
19 + assert.isFalse(keepsRunningServer(runtime({ serverVersion: "latest" }), 42, "0.1.6"));
20 + assert.isFalse(keepsRunningServer("", 42, "0.1.6"));
21 +});
apps/server/src/cli/sshHelper.ts
+40 -1
@@ -7,8 +7,11 @@ import * as NodeNet from "node:net";
7
8 import * as Effect from "effect/Effect";
9 import * as Option from "effect/Option";
10 +import * as Schema from "effect/Schema";
11 import { Argument, Command } from "effect/cli";
12
13 +import packageJson from "../../package.json" with { type: "json" };
14 +import { compareExactServiceVersions, isExactServiceVersion } from "../cloud/serviceProtocol.ts";
15 import * as DesktopUpdateMarker from "../desktopUpdate/DesktopUpdateMarker.ts";
16 import { serviceLauncherIsServing, stateDirOwned } from "../serviceLauncher.ts";
17
@@ -128,6 +131,35 @@ const runtimePort = Command.make("runtime-port", {
131 ),
132 );
133
134 +const decodeRunningServer = Schema.decodeUnknownOption(
135 + Schema.fromJsonString(Schema.Struct({ pid: Schema.Number, serverVersion: Schema.String })),
136 +);
137 +
138 +/** True when the runtime file names `pid` and a server version at or above `ownVersion`. */
139 +export const keepsRunningServer = (runtimeJson: string, pid: number, ownVersion: string) =>
140 + Option.match(decodeRunningServer(runtimeJson), {
141 + onNone: () => false,
142 + onSome: (runtime) =>
143 + runtime.pid === pid &&
144 + isExactServiceVersion(runtime.serverVersion) &&
145 + compareExactServiceVersions(runtime.serverVersion, ownVersion) >= 0,
146 + });
147 +
148 +/** Exits 0 when the managed server `pid` runs this version or a newer one, else 1. */
149 +const keepServer = Command.make("keep-server", {
150 + runtimeFile: Argument.String("runtime-file"),
151 + pid: Argument.Int("pid"),
152 +}).pipe(
153 + Command.withHandler(({ runtimeFile, pid }) =>
154 + Effect.sync(() => {
155 + const runtimeJson = NodeFS.existsSync(runtimeFile)
156 + ? NodeFS.readFileSync(runtimeFile, "utf8")
157 + : "";
158 + if (!keepsRunningServer(runtimeJson, pid, packageJson.version)) process.exitCode = 1;
159 + }),
160 + ),
161 +);
162 +
163 const updateRemaining = Command.make("update-remaining", {
164 markerFile: Argument.String("marker-file"),
165 }).pipe(
@@ -158,5 +190,12 @@ const homeOwned = Command.make("home-owned", {
190
191 export const sshHelperCommand = Command.make("__ssh-helper").pipe(
192 Command.unlisted,
161 - Command.withSubcommands([pickPort, waitReady, runtimePort, updateRemaining, homeOwned]),
193 + Command.withSubcommands([
194 + pickPort,
195 + waitReady,
196 + runtimePort,
197 + updateRemaining,
198 + homeOwned,
199 + keepServer,
200 + ]),
201 );
packages/ssh/src/tunnel.test.ts
+196
@@ -1,6 +1,7 @@
1 // @effect-diagnostics nodeBuiltinImport:off - Runs the generated runner in a real shell.
2 import * as NodeChildProcess from "node:child_process";
3 import * as NodeFS from "node:fs";
4 +import * as NodeNet from "node:net";
5 import * as NodeOS from "node:os";
6 import * as NodePath from "node:path";
7
@@ -1406,6 +1407,201 @@ server.listen(Number(flag("--port") ?? 0), "127.0.0.1", () => {
1407 // bind unless both sockets set SO_REUSEPORT, so on Linux the preload adds it to
1408 // the picker's probe and the holder sets it too.
1409
1410 +// Reuse decisions live in generated shell, so drive the real launch script in
1411 +// a temporary HOME. Each archive version gets a pre-installed fake runtime
1412 +// whose server writes the default runtime file the way `t3 serve` does.
1413 +describe("archive launch script", () => {
1414 + const windowsHost = HostProcess.Platform.defaultValue() === "win32";
1415 + const FAKE_T3 = `const fs = require("node:fs");
1416 +const http = require("node:http");
1417 +const net = require("node:net");
1418 +const path = require("node:path");
1419 +const [version, ...args] = process.argv.slice(2);
1420 +const flag = (name) => args[args.indexOf(name) + 1];
1421 +const probe = (port) =>
1422 + new Promise((resolve) => {
1423 + http
1424 + .get({ hostname: "127.0.0.1", port, path: "/", timeout: 1000 }, (response) => {
1425 + response.resume();
1426 + resolve(response.statusCode === 200);
1427 + })
1428 + .once("error", () => resolve(false));
1429 + });
1430 +const canBind = (port) =>
1431 + new Promise((resolve) => {
1432 + const server = net.createServer();
1433 + server.once("error", () => resolve(false));
1434 + server.listen(port, "127.0.0.1", () => server.close(() => resolve(true)));
1435 + });
1436 +(async () => {
1437 + if (args[0] === "--version") return console.log(version);
1438 + if (args[0] === "serve") {
1439 + const server = http.createServer((_request, response) => response.end("ok"));
1440 + server.listen(Number(flag("--port")), "127.0.0.1", () => {
1441 + const port = server.address().port;
1442 + const userdata = path.join(flag("--base-dir"), "userdata");
1443 + fs.mkdirSync(userdata, { recursive: true });
1444 + fs.writeFileSync(
1445 + path.join(userdata, "server-runtime.json"),
1446 + JSON.stringify({
1447 + version: 1,
1448 + pid: process.pid,
1449 + port,
1450 + origin: "http://127.0.0.1:" + port,
1451 + startedAt: new Date().toISOString(),
1452 + serverVersion: version,
1453 + }),
1454 + );
1455 + });
1456 + return;
1457 + }
1458 + const [helper, a, b, c] = args.slice(1);
1459 + if (helper === "pick-port") {
1460 + const start = Number(fs.existsSync(a) ? fs.readFileSync(a, "utf8") : b);
1461 + for (let port = start; port < start + Number(c); port += 1) {
1462 + if (await canBind(port)) return process.stdout.write(String(port));
1463 + }
1464 + } else if (helper === "wait-ready") {
1465 + const deadline = Date.now() + Number(b);
1466 + while (Date.now() < deadline) {
1467 + if (await probe(Number(a))) return;
1468 + await new Promise((resolve) => setTimeout(resolve, 100));
1469 + }
1470 + } else if (helper === "runtime-port") {
1471 + try {
1472 + const runtime = JSON.parse(fs.readFileSync(a, "utf8"));
1473 + process.kill(runtime.pid, 0);
1474 + return process.stdout.write(runtime.pid + " " + runtime.port);
1475 + } catch {}
1476 + } else if (helper === "keep-server") {
1477 + try {
1478 + const runtime = JSON.parse(fs.readFileSync(a, "utf8"));
1479 + const order = runtime.serverVersion.localeCompare(version, "en", { numeric: true });
1480 + if (String(runtime.pid) === b && order >= 0) return;
1481 + } catch {}
1482 + }
1483 + process.exitCode = 1;
1484 +})();
1485 +`;
1486 +
1487 + const isAlive = (pid: number) => {
1488 + try {
1489 + process.kill(pid, 0);
1490 + return true;
1491 + } catch {
1492 + return false;
1493 + }
1494 + };
1495 +
1496 + const freeLoopbackPort = Effect.callback<number>((resume) => {
1497 + const server = NodeNet.createServer();
1498 + server.listen(0, "127.0.0.1", () => {
1499 + const address = server.address();
1500 + server.close(() =>
1501 + resume(Effect.succeed(typeof address === "object" && address ? address.port : 0)),
1502 + );
1503 + });
1504 + });
1505 +
1506 + const runScript = (home: string, args: ReadonlyArray<string>) =>
1507 + Effect.gen(function* () {
1508 + const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
1509 + const child = yield* spawner.spawn(ChildProcess.make("sh", args, { env: { HOME: home } }));
1510 + const collect = (stream: Stream.Stream<Uint8Array, PlatformError.PlatformError>) =>
1511 + stream.pipe(Stream.decodeText(), Stream.mkString);
1512 + const [stdout, stderr, exitCode] = yield* Effect.all(
1513 + [collect(child.stdout), collect(child.stderr), child.exitCode.pipe(Effect.map(Number))],
1514 + { concurrency: "unbounded" },
1515 + );
1516 + return { stdout, stderr, exitCode };
1517 + });
1518 +
1519 + // Installs a fake runtime per version so the runner never downloads. The
1520 + // seeded remembered port keeps the test off the default 3773, which a live
1521 + // T3 on this machine may own.
1522 + const prepareLaunch = (versions: ReadonlyArray<string>) =>
1523 + Effect.gen(function* () {
1524 + const fs = yield* FileSystem.FileSystem;
1525 + const root = yield* fs.makeTempDirectoryScoped({ prefix: "t3-archive-launch-" });
1526 + const home = `${root}/home`;
1527 + const stateDir = `${home}/.t3/ssh-launch/test-state`;
1528 + const fakeT3 = `${root}/fake-t3.cjs`;
1529 + yield* fs.makeDirectory(stateDir, { recursive: true });
1530 + yield* fs.writeFileString(`${stateDir}/port`, `${yield* freeLoopbackPort}\n`);
1531 + yield* fs.writeFileString(fakeT3, FAKE_T3);
1532 + for (const version of versions) {
1533 + const runtimeDir = `${home}/.t3/runtime/versions/${version}`;
1534 + yield* fs.makeDirectory(runtimeDir, { recursive: true });
1535 + yield* fs.writeFileString(
1536 + `${runtimeDir}/t3`,
1537 + `#!/bin/sh\nexec node '${fakeT3}' '${version}' "$@"\n`,
1538 + );
1539 + yield* fs.chmod(`${runtimeDir}/t3`, 0o755);
1540 + yield* fs.writeFileString(`${runtimeDir}/.install-complete`, `${version}\n`);
1541 + }
1542 + const readManagedPid = fs
1543 + .readFileString(`${stateDir}/pid`)
1544 + .pipe(Effect.map((pid) => Number(pid.trim())));
1545 + const readServerVersion = fs
1546 + .readFileString(`${home}/.t3/userdata/server-runtime.json`)
1547 + .pipe(Effect.map((raw) => (JSON.parse(raw) as { serverVersion: string }).serverVersion));
1548 + // Launched servers outlive the script, so stop each PID it recorded.
1549 + const launchedPids = new Set<number>();
1550 + yield* Effect.addFinalizer(() =>
1551 + readManagedPid.pipe(
1552 + Effect.map((pid) => [...launchedPids, pid]),
1553 + Effect.orElseSucceed(() => [...launchedPids]),
1554 + Effect.map((pids) => {
1555 + for (const pid of pids) {
1556 + if (isAlive(pid)) process.kill(pid, "SIGKILL");
1557 + }
1558 + }),
1559 + ),
1560 + );
1561 + const connect = (archiveVersion: string) =>
1562 + Effect.gen(function* () {
1563 + const launch = `${root}/launch-${archiveVersion}.sh`;
1564 + yield* fs.writeFileString(launch, SshTunnel.buildRemoteLaunchScript({ archiveVersion }));
1565 + const result = yield* runScript(home, [launch, "test-state"]);
1566 + assert.equal(result.exitCode, 0, result.stderr);
1567 + const pid = yield* readManagedPid;
1568 + launchedPids.add(pid);
1569 + return pid;
1570 + });
1571 + return { connect, readManagedPid, readServerVersion };
1572 + });
1573 +
1574 + it.live.skipIf(windowsHost)(
1575 + "a reconnect from an older client keeps a newer managed server running",
1576 + () =>
1577 + Effect.gen(function* () {
1578 + const { connect, readServerVersion } = yield* prepareLaunch(["0.1.5", "0.1.6"]);
1579 + const newerPid = yield* connect("0.1.6");
1580 + assert.equal(yield* readServerVersion, "0.1.6");
1581 +
1582 + const pidAfterOlderClient = yield* connect("0.1.5");
1583 + assert.isTrue(
1584 + isAlive(newerPid),
1585 + "the 0.1.6 managed server was killed by a 0.1.5 reconnect",
1586 + );
1587 + assert.equal(pidAfterOlderClient, newerPid);
1588 + assert.equal(yield* readServerVersion, "0.1.6");
1589 + }).pipe(Effect.provide(NodeServices.layer)),
1590 + );
1591 +
1592 + it.live.skipIf(windowsHost)("a newer client still replaces an older managed server", () =>
1593 + Effect.gen(function* () {
1594 + const { connect, readServerVersion } = yield* prepareLaunch(["0.1.5", "0.1.6"]);
1595 + const olderPid = yield* connect("0.1.5");
1596 +
1597 + const newerPid = yield* connect("0.1.6");
1598 + assert.notEqual(newerPid, olderPid);
1599 + assert.isFalse(isAlive(olderPid));
1600 + assert.equal(yield* readServerVersion, "0.1.6");
1601 + }).pipe(Effect.provide(NodeServices.layer)),
1602 + );
1603 +});
1604 +
1605 describe("SSH launch during desktop update", () => {
1606 it.effect("archive launcher reuses the replacement without host Node", () =>
1607 Effect.gen(function* () {
packages/ssh/src/tunnel.ts
+8 -3
@@ -715,6 +715,11 @@ server_running() {
715 *Z*) return 1 ;;
716 esac
717 }
718 +# An older client replacing a same-or-newer server would run below the database's migrations.
719 +keeps_running_server() {
720 + [ "$T3_ARCHIVE_MODE" = "1" ] &&
721 + "$RUNNER_FILE" __ssh-helper keep-server "$DEFAULT_RUNTIME_FILE" "$REMOTE_PID" >/dev/null 2>&1
722 +}
723 @@T3_MANAGED_SERVER_RUNNING_SCRIPT@@
724 # Both are SQLite locks the OS drops with their holder: a server holds
725 # server-owner.sqlite, and a boot service holds service-serving.lock from
@@ -878,8 +883,8 @@ if [ "$REMOTE_MANAGED" = "external" ]; then
883 fi
884 elif [ -n "$REMOTE_PORT" ] && managed_server_running "$REMOTE_PID"; then
885 # Reconnect owns the local tunnel, not the lifetime of an already running
881 - # server. A changed runner is the update path and still replaces it.
882 - if [ "$RUNNER_CHANGED" -eq 1 ]; then
886 + # server. A changed runner is the update path and replaces an older server.
887 + if [ "$RUNNER_CHANGED" -eq 1 ] && ! keeps_running_server; then
888 kill "$REMOTE_PID" 2>/dev/null || true
889 wait_for_pid_exit "$REMOTE_PID"
890 REMOTE_PID=""
@@ -1106,7 +1111,7 @@ export function buildRemoteNodeEnvScript(input?: RemoteT3RunnerOptions): string
1111 );
1112 }
1113
1109 -function buildRemoteLaunchScript(input?: RemoteT3RunnerOptions): string {
1114 +export function buildRemoteLaunchScript(input?: RemoteT3RunnerOptions): string {
1115 return applyScriptPlaceholders(REMOTE_LAUNCH_SCRIPT, {
1116 T3_UPDATE_MARKER_FILE: DESKTOP_UPDATE_IN_PROGRESS_MARKER_FILE,
1117 T3_UPDATE_TTL_MS: String(DESKTOP_UPDATE_IN_PROGRESS_TTL_MS),