The best way to control Claude Code, Codex and more from any computer or phone
fix(ssh): wait for a boot service's server instead of starting a second one (#36672)
Julius Marminge committed
Nov 14, 2026 at 03:30 UTC
0c306f45203eb14b71902de9ccfbbfa2afe716af
10 files changed
+201
-9
apps/server/src/cli/sshHelper.ts
+15
-1
@@ -10,6 +10,7 @@ import * as Option from "effect/Option";
10
import { Argument, Command } from "effect/cli";
11
12
import * as DesktopUpdateMarker from "../desktopUpdate/DesktopUpdateMarker.ts";
13
+import { serviceLauncherIsServing, stateDirOwned } from "../serviceLauncher.ts";
14
15
const canBind = (port: number) =>
16
new Promise<boolean>((resolve) => {
@@ -142,7 +143,20 @@ const updateRemaining = Command.make("update-remaining", {
143
Command.provide(DesktopUpdateMarker.layer),
144
);
145
146
+/** Exits 0 while a server holds this home or a boot service is about to start one. */
147
+const homeOwned = Command.make("home-owned", {
148
+ baseDir: Argument.String("base-dir"),
149
+}).pipe(
150
+ Command.withHandler(({ baseDir }) =>
151
+ Effect.promise(async () => {
152
+ if (!((await serviceLauncherIsServing(baseDir)) || (await stateDirOwned(baseDir)))) {
153
+ process.exitCode = 1;
154
+ }
155
+ }),
156
+ ),
157
+);
158
+
159
export const sshHelperCommand = Command.make("__ssh-helper").pipe(
160
Command.unlisted,
147
- Command.withSubcommands([pickPort, waitReady, runtimePort, updateRemaining]),
161
+ Command.withSubcommands([pickPort, waitReady, runtimePort, updateRemaining, homeOwned]),
162
);
apps/server/src/cloud/selfUpdate.test.ts
+12
-1
@@ -223,9 +223,20 @@ it.layer(NodeServices.layer)("server self update", (it) => {
223
// regression: #34502 a remote update never replaces the launcher, so it can be older than the server
224
it.effect("names its launcher's protocol to the staged preflight, not its own", () =>
225
Effect.gen(function* () {
226
- const { selfUpdate, preflightProtocols } = yield* makeHarness({ launcherProtocol: 3 });
226
+ const { selfUpdate, preflightProtocols, baseDir } = yield* makeHarness({
227
+ launcherProtocol: 3,
228
+ });
229
+ yield* TestClock.setTime(5_000);
230
expect((yield* selfUpdate.update({ targetVersion: "1.1.0" })).updateId).toBe("launcher-id");
231
expect(preflightProtocols).toEqual(["3"]);
232
+ // That launcher holds no lock between its servers; SSH launches wait on this marker instead.
233
+ const fs = yield* FileSystem.FileSystem;
234
+ const path = yield* Path.Path;
235
+ expect(
236
+ JSON.parse(
237
+ yield* fs.readFileString(path.join(baseDir, "runtime", "desktop-update-in-progress")),
238
+ ),
239
+ ).toEqual({ startedAt: 5_000, expiresAt: 65_000 });
240
}),
241
);
242
apps/server/src/cloud/selfUpdate.ts
+9
@@ -1,4 +1,5 @@
1
import {
2
+ DESKTOP_UPDATE_IN_PROGRESS_MARKER_FILE,
3
ServerSelfUpdateError,
4
type ServerSelfUpdateCapability,
5
type ServerSelfUpdateInput,
@@ -29,6 +30,7 @@ import {
30
import packageJson from "../../package.json" with { type: "json" };
31
import * as ServerConfig from "../config.ts";
32
import * as DesktopAppUpdate from "../desktopUpdate/DesktopAppUpdate.ts";
33
+import * as DesktopUpdateMarker from "../desktopUpdate/DesktopUpdateMarker.ts";
34
import { databaseMigrationHead } from "../persistence/databaseMigrationHead.ts";
35
import * as ManagedPolicy from "../policy/ManagedPolicy.ts";
36
import { managedUpdateMirror, managedUpdateRefusal } from "../policy/managedUpdates.ts";
@@ -338,6 +340,13 @@ export const make = Effect.fn("cloud.server_self_update.make")(function* () {
340
error,
341
),
342
),
343
+ // The launcher stops this server next; one from before its serving lock holds nothing
344
+ // until the new server starts, so this marker is what an SSH launch waits on.
345
+ Effect.tap(() =>
346
+ DesktopUpdateMarker.publish(
347
+ path.join(serverConfig.baseDir, "runtime", DESKTOP_UPDATE_IN_PROGRESS_MARKER_FILE),
348
+ ).pipe(Effect.provideService(FileSystem.FileSystem, fs), Effect.ignore({ log: true })),
349
+ ),
350
Effect.tap(() => onHandoffAccepted()),
351
),
352
);
apps/server/src/cloud/serviceProtocol.ts
+3
@@ -23,6 +23,9 @@ export const SERVICE_STOP_MARKER_FILE = ".service-stopping";
23
export const SERVICE_RESTART_PENDING_FILE = ".restart-pending";
24
/** Held by a Windows launcher while it runs: Task Scheduler tracks only the task's console host. */
25
export const SERVICE_LAUNCHER_LOCK_FILE = "service-launcher.lock";
26
+/** Held by a launcher while it has, or is about to start, a server: an SSH launch waits for that
27
+ server instead of starting its own. Released while the launcher idles. */
28
+export const SERVICE_SERVING_LOCK_FILE = "service-serving.lock";
29
30
const unquoteSystemdValue = (raw: string) =>
31
(raw.startsWith('"') && raw.endsWith('"')
apps/server/src/desktopUpdate/DesktopUpdateMarker.ts
+18
@@ -10,6 +10,24 @@ import * as Schema from "effect/Schema";
10
const UpdateMarker = Schema.fromJsonString(
11
Schema.Struct({ startedAt: Schema.Number, expiresAt: Schema.Number }),
12
);
13
+const encodeUpdateMarker = Schema.encodeEffect(UpdateMarker);
14
+
15
+/**
16
+ * Makes SSH launches wait for the server that replaces this one instead of starting their own.
17
+ * The server writes it, so it also covers a boot service whose launcher predates its own lock.
18
+ */
19
+export const publish = Effect.fn("DesktopUpdateMarker.publish")(function* (markerFile: string) {
20
+ const fileSystem = yield* FileSystem.FileSystem;
21
+ const startedAt = yield* Clock.currentTimeMillis;
22
+ const contents = yield* encodeUpdateMarker({
23
+ startedAt,
24
+ expiresAt: startedAt + DESKTOP_UPDATE_IN_PROGRESS_TTL_MS,
25
+ });
26
+ // Renamed into place: a launch must never read a half-written marker.
27
+ const temporary = `${markerFile}.tmp`;
28
+ yield* fileSystem.writeFileString(temporary, contents);
29
+ yield* fileSystem.rename(temporary, markerFile);
30
+});
31
32
export class DesktopUpdateMarker extends Context.Service<
33
DesktopUpdateMarker,
apps/server/src/serviceLauncher.test.ts
+4
@@ -29,6 +29,7 @@ import {
29
readServiceState,
30
registerServiceTask,
31
serviceLauncherIsRunning,
32
+ serviceLauncherIsServing,
33
serviceLauncherLockPath,
34
stateDirOwned,
35
writeServiceState,
@@ -954,8 +955,11 @@ process.exit(0);
955
});
956
yield* Effect.promise(() => refused.promise);
957
assert.isFalse(completed);
958
+ // An idle launcher must not make an SSH launch wait for a server it is not starting.
959
+ assert.isFalse(yield* Effect.promise(() => serviceLauncherIsServing(root)));
960
otherOwner.close();
961
yield* Effect.promise(() => owned.promise);
962
+ assert.isTrue(yield* Effect.promise(() => serviceLauncherIsServing(root)));
963
yield* Effect.promise(() => launcher.stop("SIGTERM"));
964
yield* Effect.promise(() => running);
965
assert.strictEqual(spawnedChildren.length - spawnsBefore, 2);
apps/server/src/serviceLauncher.ts
+30
-1
@@ -30,6 +30,7 @@ import {
30
serviceUnitLogPathOf,
31
SERVICE_ENV_FILE,
32
SERVICE_LAUNCHER_LOCK_FILE,
33
+ SERVICE_SERVING_LOCK_FILE,
34
SERVICE_LAUNCHER_CONTEXT_ENV,
35
SERVICE_LAUNCHER_PROTOCOL,
36
SERVICE_STATE_FILE,
@@ -758,11 +759,12 @@ export const serviceLauncherLockPath = (baseDir: string) =>
759
// An exclusive SQLite transaction, like the server's owner lock: the OS drops it when the holder dies.
760
async function tryAcquireSqliteLock(
761
lockPath: string,
762
+ busyTimeoutMs = 0,
763
): Promise<{ readonly close: () => void } | undefined> {
764
const { DatabaseSync } = await import("node:sqlite");
765
const db = new DatabaseSync(lockPath);
766
try {
765
- db.exec("PRAGMA busy_timeout = 0; BEGIN EXCLUSIVE;");
767
+ db.exec(`PRAGMA busy_timeout = ${busyTimeoutMs}; BEGIN EXCLUSIVE;`);
768
return db;
769
} catch (cause) {
770
db.close();
@@ -778,6 +780,13 @@ export async function serviceLauncherIsRunning(lockPath: string): Promise<boolea
780
return lock === undefined;
781
}
782
783
+const servingLockPath = (baseDir: string) =>
784
+ NodePath.join(baseDir, "runtime", SERVICE_SERVING_LOCK_FILE);
785
+
786
+/** Whether a launcher has, or is about to start, a server for this home. An idle one does not. */
787
+export const serviceLauncherIsServing = (baseDir: string): Promise<boolean> =>
788
+ serviceLauncherIsRunning(servingLockPath(baseDir)).catch(() => false);
789
+
790
/** Resolves once no launcher holds the lock; the caller bounds the wait through `signal`. */
791
export async function waitForServiceLauncherExit(
792
lockPath: string,
@@ -857,6 +866,7 @@ export class Launcher {
866
#stateDirFreeProbes = 0;
867
readonly #output: number | undefined;
868
readonly #lockPath: string | undefined;
869
+ #servingLock: { readonly close: () => void } | undefined;
870
readonly #stopChildOverIpc: boolean;
871
872
constructor(
@@ -910,6 +920,7 @@ export class Launcher {
920
}
921
}
922
} finally {
923
+ this.#releaseServing();
924
process.off("SIGTERM", onSigterm);
925
process.off("SIGINT", onSigint);
926
}
@@ -927,6 +938,19 @@ export class Launcher {
938
return undefined;
939
}
940
941
+ // Advisory: without it an SSH launch may start its own server, as it does beside no service.
942
+ async #claimServing(): Promise<void> {
943
+ // An SSH launch probes this lock for a moment; wait out that probe.
944
+ this.#servingLock ??= await tryAcquireSqliteLock(servingLockPath(this.#baseDir), 250).catch(
945
+ () => undefined,
946
+ );
947
+ }
948
+
949
+ #releaseServing(): void {
950
+ this.#servingLock?.close();
951
+ this.#servingLock = undefined;
952
+ }
953
+
954
#terminate(child: NodeChildProcess.ChildProcess, signal: NodeJS.Signals = "SIGTERM") {
955
return terminateChild(child, signal, this.#stopChildOverIpc);
956
}
@@ -1022,6 +1046,7 @@ export class Launcher {
1046
// A stop during the probe must not arm a retry that outlives it.
1047
if (this.#stopRequested) return true;
1048
this.#clearTimer();
1049
+ this.#releaseServing();
1050
this.#log(`[service-launcher] ${reason} Waiting for free space before retrying.\n`);
1051
this.#timer = setInterval(
1052
() =>
@@ -1029,6 +1054,7 @@ export class Launcher {
1054
if (this.#child !== null || this.#stopping) return;
1055
if ((await this.#serviceStartDiskSpaceBlocker()) !== undefined) return;
1056
this.#clearTimer();
1057
+ await this.#claimServing();
1058
await retry();
1059
}),
1060
DISK_SPACE_RETRY_MS,
@@ -1057,6 +1083,7 @@ export class Launcher {
1083
}
1084
1085
async #recover(): Promise<void> {
1086
+ await this.#claimServing();
1087
// Clear old stop markers to preserve future tunnels; clear restart-pending only for the awaited version to avoid CLI races.
1088
await NodeFSP.rm(stopMarkerPath(this.#baseDir), { force: true }).catch(() => undefined);
1089
const restartPending = restartPendingPath(this.#baseDir);
@@ -1426,6 +1453,7 @@ export class Launcher {
1453
await this.#repointServiceUnit(next.activeVersion);
1454
}
1455
}
1456
+ this.#releaseServing();
1457
this.#log(
1458
"[service-launcher] Another T3 Code server owns this T3 home. This service starts again once it stops.\n",
1459
);
@@ -1450,6 +1478,7 @@ export class Launcher {
1478
this.#stateDirFreeProbes = owned ? 0 : this.#stateDirFreeProbes + 1;
1479
if (this.#stateDirFreeProbes < 2) return;
1480
this.#clearTimer();
1481
+ await this.#claimServing();
1482
this.#log("[service-launcher] The T3 home is free again. Starting the server.\n");
1483
const update = this.#state.update;
1484
if (update?.status === "pending") await this.#startTrial(update);
packages/ssh/src/launcherTestHarness.ts
+18
-2
@@ -3,6 +3,7 @@ import * as NodeFS from "node:fs";
3
import * as NodePath from "node:path";
4
import * as NodeURL from "node:url";
5
import * as NodeChildProcess from "node:child_process";
6
+import * as NodeSqlite from "node:sqlite";
7
import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
8
import * as NodeServices from "@effect/platform-node/NodeServices";
9
import * as Effect from "effect/Effect";
@@ -58,6 +59,12 @@ export const captureLauncherFor = Effect.fn("test.captureLauncher")(function* (
59
60
export const captureLauncher = captureLauncherFor({ nodeScriptPath: "/fake/server.ts" });
61
62
+function holdLock(path: string) {
63
+ const db = new NodeSqlite.DatabaseSync(path);
64
+ db.exec("BEGIN EXCLUSIVE;");
65
+ return { [Symbol.dispose]: () => db.close() };
66
+}
67
+
68
export function runLauncher(
69
script: string,
70
options: {
@@ -68,6 +75,9 @@ export function runLauncher(
75
readonly clockJump?: number;
76
readonly readyAt?: number;
77
readonly initialPort?: number;
78
+ // A boot service between two servers holds the home with no runtime record yet.
79
+ readonly serviceServing?: boolean;
80
+ readonly allowFailure?: boolean;
81
// The desktop publishes runtime and removes the marker right after the first runtime read.
82
readonly publishAfterFirstRuntimeRead?: boolean;
83
},
@@ -192,6 +202,7 @@ if [ "$1" = --version ]; then printf 1.2.3; exit; fi
202
[ "$1" = __ssh-helper ]
203
case "$2" in
204
update-remaining) printf 'marker %s\\n' "$(cat "$HOME/clock")" >> "$HOME/events"; exec "$TEST_REAL_NODE" --require "$HOME/clock.cjs" "$HOME/helper.ts" "$2" "$3" ;;
205
+ home-owned) exec "$TEST_REAL_NODE" "$HOME/helper.ts" "$2" "$3" ;;
206
runtime-port | pick-port | wait-ready) exec "$HOME/bin/test-node" - "$3" ;;
207
*) exit 1 ;;
208
esac
@@ -199,6 +210,9 @@ esac
210
{ mode: 0o755 },
211
);
212
}
213
+ using _serving = options.serviceServing
214
+ ? holdLock(NodePath.join(runtime, "service-serving.lock"))
215
+ : undefined;
216
const result = NodeChildProcess.spawnSync("/bin/sh", ["-s", "--", "test-target"], {
217
input: `kill() {
218
if [ "$1" = -0 ]; then command kill "$@"; else
@@ -222,12 +236,14 @@ ${script}`,
236
TEST_PUBLISH_AFTER_FIRST_READ: options.publishAfterFirstRuntimeRead ? "1" : "0",
237
},
238
});
225
- if (result.error || result.status !== 0)
239
+ if (result.error || (result.status !== 0 && !options.allowFailure))
240
throw new Error(
241
`launcher failed: ${result.error ?? result.status}\n${result.stderr}\n${result.stdout}\n${NodeFS.readFileSync(NodePath.join(home, "events"), "utf8")}`,
242
);
243
return {
230
- output: JSON.parse(result.stdout.trim()),
244
+ status: result.status,
245
+ stderr: result.stderr,
246
+ output: result.status === 0 ? JSON.parse(result.stdout.trim()) : undefined,
247
events: NodeFS.readFileSync(NodePath.join(home, "events"), "utf8").trim().split("\n"),
248
now: Number(NodeFS.readFileSync(NodePath.join(home, "clock"), "utf8")),
249
markerExists: NodeFS.existsSync(markerPath),
packages/ssh/src/tunnel.test.ts
+27
@@ -1520,6 +1520,33 @@ describe("SSH launch during desktop update", () => {
1520
}),
1521
);
1522
1523
+ it.effect.each([false, true])(
1524
+ "waits for a boot service between two servers (archive: %s)",
1525
+ (archive) =>
1526
+ Effect.gen(function* () {
1527
+ const script = yield* archive
1528
+ ? captureLauncherFor({ archiveVersion: "1.2.3" })
1529
+ : captureLauncher;
1530
+ const result = runLauncher(script, { archive, serviceServing: true, readyAt: 5_000 });
1531
+ assert.deepEqual(result.output, { remotePort: 4888, serverKind: "external" });
1532
+ assert.equal(result.now, 5_000);
1533
+ assert.isFalse(result.events.some((event) => event.startsWith("start ")));
1534
+ }),
1535
+ );
1536
+
1537
+ it.effect("fails without starting a second server when the home's owner never answers", () =>
1538
+ Effect.gen(function* () {
1539
+ const result = runLauncher(yield* captureLauncher, {
1540
+ serviceServing: true,
1541
+ allowFailure: true,
1542
+ });
1543
+ assert.equal(result.status, 1);
1544
+ assert.include(result.stderr, "no second server was started");
1545
+ assert.equal(result.now, 60_000);
1546
+ assert.isFalse(result.events.some((event) => event.startsWith("start ")));
1547
+ }),
1548
+ );
1549
+
1550
it.effect("starts immediately without a marker", () =>
1551
Effect.gen(function* () {
1552
const result = runLauncher(yield* captureLauncher, {});
packages/ssh/src/tunnel.ts
+65
-4
@@ -82,20 +82,28 @@ const REMOTE_UPDATE_WAIT_MS =
82
DESKTOP_UPDATE_IN_PROGRESS_TTL_MS +
83
2 * (REMOTE_REUSE_READY_TIMEOUT_MS + SSH_READY_PROBE_TIMEOUT_MS) +
84
1_000;
85
+// A launch waits this long for a server that holds the home to answer; its
86
+// last poll adds a reuse probe.
87
+const REMOTE_OWNER_WAIT_MS =
88
+ REMOTE_READY_TIMEOUT_MS + REMOTE_REUSE_READY_TIMEOUT_MS + SSH_READY_PROBE_TIMEOUT_MS;
89
// A launch holds the home lock through up to two reuse probes, readiness, two
86
-// server exit waits, the runtime record wait, and the update wait; each probe
87
-// may overrun its deadline by one request.
90
+// server exit waits, the runtime record wait, the update wait, and the owner
91
+// wait; each probe may overrun its deadline by one request.
92
const REMOTE_LAUNCH_LOCK_WAIT_SECONDS = Math.ceil(
93
(REMOTE_READY_TIMEOUT_MS +
94
2 * REMOTE_REUSE_READY_TIMEOUT_MS +
95
2 * REMOTE_PID_EXIT_WAIT_MS +
96
REMOTE_RUNTIME_RECORD_WAIT_SECONDS * 1000 +
97
4 * SSH_READY_PROBE_TIMEOUT_MS +
94
- REMOTE_UPDATE_WAIT_MS) /
98
+ REMOTE_UPDATE_WAIT_MS +
99
+ REMOTE_OWNER_WAIT_MS) /
100
1000,
101
);
102
const REMOTE_LAUNCH_TIMEOUT_MS =
98
- REMOTE_LAUNCH_LOCK_WAIT_SECONDS * 1000 + REMOTE_UPDATE_WAIT_MS + REMOTE_LAUNCH_BASE_TIMEOUT_MS;
103
+ REMOTE_LAUNCH_LOCK_WAIT_SECONDS * 1000 +
104
+ REMOTE_UPDATE_WAIT_MS +
105
+ REMOTE_OWNER_WAIT_MS +
106
+ REMOTE_LAUNCH_BASE_TIMEOUT_MS;
107
108
export interface RemoteT3RunnerOptions {
109
readonly nodeScriptPath?: string | null;
@@ -708,6 +716,39 @@ server_running() {
716
esac
717
}
718
@@T3_MANAGED_SERVER_RUNNING_SCRIPT@@
719
+# Both are SQLite locks the OS drops with their holder: a server holds
720
+# server-owner.sqlite, and a boot service holds service-serving.lock from
721
+# before it starts a server, between two of them during its own update, until
722
+# it stops or idles behind another server.
723
+home_owned() {
724
+ if [ "$T3_ARCHIVE_MODE" = "1" ]; then
725
+ "$RUNNER_FILE" __ssh-helper home-owned "$DEFAULT_SERVER_HOME" 2>/dev/null
726
+ return
727
+ fi
728
+ node - "$DEFAULT_SERVER_HOME" 2>/dev/null <<'NODE'
729
+const fs = require("node:fs");
730
+const path = require("node:path");
731
+const { DatabaseSync } = require("node:sqlite");
732
+const held = (file) => {
733
+ if (!fs.existsSync(file)) return false;
734
+ const db = new DatabaseSync(file);
735
+ try {
736
+ db.exec("PRAGMA busy_timeout = 0; BEGIN EXCLUSIVE;");
737
+ return false;
738
+ } catch (error) {
739
+ return error?.errcode === 5;
740
+ } finally {
741
+ db.close();
742
+ }
743
+};
744
+const home = process.argv[2];
745
+process.exitCode =
746
+ held(path.join(home, "runtime", "service-serving.lock")) ||
747
+ held(path.join(home, "userdata", "server-owner.sqlite"))
748
+ ? 0
749
+ : 1;
750
+NODE
751
+}
752
resolve_default_runtime_port() {
753
if [ "$T3_ARCHIVE_MODE" = "1" ]; then
754
"$RUNNER_FILE" __ssh-helper runtime-port "$DEFAULT_RUNTIME_FILE"
@@ -896,6 +937,25 @@ if [ -z "$REMOTE_PORT" ]; then
937
REMOTE_MANAGED=""
938
fi
939
fi
940
+# A server that holds the home without answering yet is still starting, and a
941
+# boot service holds it between two servers while it updates. A second server
942
+# would lose the home to it or take the home from it, so wait while the home is
943
+# held and start one only once it is free. The managed server an update just
944
+# stopped may still be exiting. The sleep count bounds a host clock that stops.
945
+OWNER_WAITED=0
946
+OWNER_DEADLINE=$(($(date +%s) + @@T3_READY_TIMEOUT_SECONDS@@))
947
+while [ -z "$REMOTE_PORT" ] && ! managed_server_running "$(cat "$PID_FILE" 2>/dev/null || true)" && home_owned; do
948
+ if adopt_default_server; then break; fi
949
+ REMOTE_PID=""
950
+ REMOTE_PORT=""
951
+ REMOTE_MANAGED=""
952
+ if [ "$OWNER_WAITED" -ge @@T3_READY_TIMEOUT_SECONDS@@ ] || [ "$(date +%s)" -ge "$OWNER_DEADLINE" ]; then
953
+ printf 'A T3 server or boot service holds %s but did not become ready, so no second server was started. Retry once it has started.\\n' "$DEFAULT_SERVER_HOME" >&2
954
+ exit 1
955
+ fi
956
+ sleep 1
957
+ OWNER_WAITED=$((OWNER_WAITED + 1))
958
+done
959
if [ -z "$REMOTE_PORT" ]; then
960
REMOTE_PORT="$(pick_port)" || true
961
if [ -z "$REMOTE_PORT" ]; then
@@ -1060,6 +1120,7 @@ function buildRemoteLaunchScript(input?: RemoteT3RunnerOptions): string {
1120
T3_DEFAULT_REMOTE_PORT: String(DEFAULT_REMOTE_PORT),
1121
T3_REMOTE_PORT_SCAN_WINDOW: String(REMOTE_PORT_SCAN_WINDOW),
1122
T3_READY_TIMEOUT_MS: String(REMOTE_READY_TIMEOUT_MS),
1123
+ T3_READY_TIMEOUT_SECONDS: String(REMOTE_READY_TIMEOUT_MS / 1000),
1124
T3_REUSE_READY_TIMEOUT_MS: String(REMOTE_REUSE_READY_TIMEOUT_MS),
1125
T3_READY_PROBE_TIMEOUT_MS: String(SSH_READY_PROBE_TIMEOUT_MS),
1126
T3_PID_EXIT_WAIT_TICKS: String(REMOTE_PID_EXIT_WAIT_MS / 100),