@devries-cameron20 / t3code Mirror · read-only / commits / 0c306f4520
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, 14:45 UTC

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),