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

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

fix(server): SSH hosts no longer keep every old 300 MB runtime after desktop updates (#23113)

Co-authored-by: PR Batch Tester <agent@local.test> Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

shivam committed Oct 22, 2026 at 14:19 UTC ff525478e236ec0df4c4920eb03ac3961ea714a2
2 files changed +120 -12
apps/server/src/cloud/selfUpdate.test.ts
+88
@@ -9,9 +9,11 @@ import * as FileSystem from "effect/FileSystem";
9 import * as Fiber from "effect/Fiber";
10 import * as Path from "effect/Path";
11 import * as Stream from "effect/Stream";
12 +import * as TestClock from "effect/testing/TestClock";
13 import { HttpClient, HttpClientResponse } from "effect/http";
14 import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner";
15
16 +import packageJson from "../../package.json" with { type: "json" };
17 import * as ServerConfig from "../config.ts";
18 import * as DesktopAppUpdate from "../desktopUpdate/DesktopAppUpdate.ts";
19 import * as ProcessRunner from "../processRunner.ts";
@@ -386,3 +388,89 @@ it.layer(NodeServices.layer)("server self update", (it) => {
388 }),
389 );
390 });
391 +
392 +it.layer(NodeServices.layer)("pruning runtimes on start", (it) => {
393 + const staleVersion = "0.0.1";
394 + const otherProcesses = ProcessRunner.ProcessRunner.of({
395 + run: () =>
396 + Effect.succeed({
397 + stdout: "p42\nftxt\nn/bin/sh\n",
398 + stderr: "",
399 + code: ChildProcessSpawner.ExitCode(0),
400 + timedOut: false,
401 + stdoutTruncated: false,
402 + stderrTruncated: false,
403 + stdoutInvalidUtf8: false,
404 + stderrInvalidUtf8: false,
405 + }),
406 + });
407 +
408 + const pruneOnStart = Effect.fn("test.prune_on_start")(function* (input: {
409 + readonly executable: "own runtime" | "elsewhere";
410 + readonly managed?: boolean;
411 + readonly symlinkedHome?: boolean;
412 + }) {
413 + const fs = yield* FileSystem.FileSystem;
414 + const path = yield* Path.Path;
415 + const tempDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-prune-on-start-" });
416 + const realHome = path.join(tempDir, "home");
417 + const baseDir = input.symlinkedHome ? path.join(tempDir, "linked-home") : realHome;
418 + const versionsDir = path.join(baseDir, "runtime", "versions");
419 + yield* TestClock.setTime(24 * 60 * 60 * 1000);
420 + for (const version of [staleVersion, packageJson.version]) {
421 + const directory = path.join(realHome, "runtime", "versions", version);
422 + yield* fs.makeDirectory(directory, { recursive: true });
423 + yield* fs.writeFileString(path.join(directory, "t3"), "");
424 + const sentinel = path.join(directory, ".install-complete");
425 + yield* fs.writeFileString(sentinel, `${version}\n`);
426 + yield* fs.utimes(sentinel, 0, 0);
427 + }
428 + if (input.symlinkedHome) yield* fs.symlink(realHome, baseDir);
429 + // Like `process.execPath`, the running runtime is reported by its real path.
430 + const executablePath =
431 + input.executable === "own runtime"
432 + ? yield* fs.realPath(path.join(versionsDir, packageJson.version, "t3"))
433 + : "/usr/local/bin/node";
434 + const removed = yield* ServerSelfUpdate.pruneRuntimesOnStart({
435 + baseDir,
436 + managed: input.managed ?? false,
437 + }).pipe(
438 + Effect.provideService(HostProcess.ExecutablePath, executablePath),
439 + Effect.provideService(HostProcess.Platform, "darwin"),
440 + Effect.provideService(HostProcess.Environment, {}),
441 + Effect.provideService(ProcessRunner.ProcessRunner, otherProcesses),
442 + );
443 + return { removed, remaining: (yield* fs.readDirectory(versionsDir)).toSorted() };
444 + });
445 +
446 + // The SSH launcher runs `t3 serve` straight from the pinned runtime, with no boot service.
447 + it.effect("prunes for a server started from its home's pinned runtime", () =>
448 + Effect.gen(function* () {
449 + const { removed, remaining } = yield* pruneOnStart({ executable: "own runtime" });
450 + expect(removed).toEqual([staleVersion]);
451 + expect(remaining).toEqual([packageJson.version]);
452 + }),
453 + );
454 +
455 + it.effect("recognizes its runtime through a symlinked T3 home", () =>
456 + Effect.gen(function* () {
457 + const { removed } = yield* pruneOnStart({ executable: "own runtime", symlinkedHome: true });
458 + expect(removed).toEqual([staleVersion]);
459 + }),
460 + );
461 +
462 + it.effect("prunes for a boot-service server wherever it runs from", () =>
463 + Effect.gen(function* () {
464 + const { removed } = yield* pruneOnStart({ executable: "elsewhere", managed: true });
465 + expect(removed).toEqual([staleVersion]);
466 + }),
467 + );
468 +
469 + it.effect("leaves runtimes alone for an unmanaged server started elsewhere", () =>
470 + Effect.gen(function* () {
471 + const { removed, remaining } = yield* pruneOnStart({ executable: "elsewhere" });
472 + expect(removed).toEqual([]);
473 + expect(remaining).toEqual([staleVersion, packageJson.version].toSorted());
474 + }),
475 + );
476 +});
apps/server/src/cloud/selfUpdate.ts
+32 -12
@@ -33,6 +33,7 @@ import {
33 ensurePinnedRuntimeInstalled,
34 pinnedRuntimeCommand,
35 PinnedRuntimeInstallError,
36 + pinnedRuntimePaths,
37 PinnedRuntimePreflightBlockedError,
38 prunePinnedRuntimes,
39 } from "./pinnedRuntime.ts";
@@ -173,6 +174,34 @@ export const withRunningThreadContinuation = Effect.fn(
174 });
175 });
176
177 +/**
178 + * A server starting from the runtime its launcher settled on means runtimes left by earlier
179 + * updates can go. The boot service says so through its IPC context. The SSH launcher and the
180 + * install script's `t3` start this home's pinned runtime directly, without one.
181 + */
182 +export const pruneRuntimesOnStart = Effect.fn("cloud.server_self_update.prune_on_start")(
183 + function* (input: { readonly baseDir: string; readonly managed: boolean }) {
184 + const fs = yield* FileSystem.FileSystem;
185 + const path = yield* Path.Path;
186 + const platform = yield* HostProcess.Platform;
187 + const executablePath = yield* HostProcess.ExecutablePath;
188 + const { entryPath } = pinnedRuntimePaths(path, input.baseDir, packageJson.version, platform);
189 + // The executable path is resolved, so it names the real path of a symlinked T3 home.
190 + const realEntryPath = yield* fs.realPath(entryPath).pipe(Effect.orElseSucceed(() => entryPath));
191 + if (!input.managed && executablePath !== entryPath && executablePath !== realEntryPath) {
192 + return [];
193 + }
194 + const removed = yield* prunePinnedRuntimes({
195 + baseDir: input.baseDir,
196 + keep: [packageJson.version],
197 + });
198 + if (removed.length > 0) {
199 + yield* Effect.logInfo("Removed unused t3 runtimes.", { versions: removed });
200 + }
201 + return removed;
202 + },
203 +);
204 +
205 export const make = Effect.fn("cloud.server_self_update.make")(function* () {
206 const serverConfig = yield* ServerConfig.ServerConfig;
207 const desktopAppUpdate = yield* DesktopAppUpdate.DesktopAppUpdate;
@@ -188,18 +217,9 @@ export const make = Effect.fn("cloud.server_self_update.make")(function* () {
217 );
218 const inFlight = yield* Ref.make(false);
219
191 - // A managed server starting means its launcher has settled on a version, so runtimes left by
192 - // earlier updates can go.
193 - if (launcher.managed) {
194 - yield* prunePinnedRuntimes({ baseDir: serverConfig.baseDir, keep: [packageJson.version] }).pipe(
195 - Effect.tap((removed) =>
196 - removed.length === 0
197 - ? Effect.void
198 - : Effect.logInfo("Removed unused t3 runtimes.", { versions: removed }),
199 - ),
200 - Effect.forkScoped,
201 - );
202 - }
220 + yield* pruneRuntimesOnStart({ baseDir: serverConfig.baseDir, managed: launcher.managed }).pipe(
221 + Effect.forkScoped,
222 + );
223
224 const capability: ServerSelfUpdateCapability | null =
225 serverConfig.mode === "desktop" ? "desktop-managed" : launcher.managed ? "boot-service" : null;