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, 09:45 UTC
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),