fix(ssh): use the remote service home for launch and pairing

apps/server/src/cli/sshHelper.ts

@@ -6,10 +6,61 @@ import * as NodeHttp from "node:http";
 import * as NodeNet from "node:net";
 
 import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
 import * as Option from "effect/Option";
+import * as HostProcess from "@t3tools/shared/HostProcess";
 import { Argument, Command } from "effect/cli";
 
+import { bootServiceBaseDirOf, bootServiceUnitPath } from "../cloud/bootService.ts";
 import * as DesktopUpdateMarker from "../desktopUpdate/DesktopUpdateMarker.ts";
+import { resolveBaseDir } from "../os-jank.ts";
+import * as ProcessRunner from "../processRunner.ts";
+
+/** Resolve once at launch; pairing must use that same home even in a non-login shell. */
+export const resolveSshServerHome = Effect.gen(function* () {
+  const environment = yield* HostProcess.Environment;
+  if (environment.T3CODE_HOME?.trim()) return yield* resolveBaseDir(environment.T3CODE_HOME);
+  const fs = yield* FileSystem.FileSystem;
+  const uid = yield* HostProcess.UserId;
+  const processRunner = yield* ProcessRunner.ProcessRunner;
+  // A non-login SSH session may lack this, so `busctl --user` cannot find the user bus.
+  const userManagerEnv =
+    (yield* HostProcess.Platform) === "linux" &&
+    !environment.XDG_RUNTIME_DIR &&
+    uid !== undefined &&
+    !(uid === 0 && environment.SUDO_USER)
+      ? { XDG_RUNTIME_DIR: `/run/user/${uid}` }
+      : undefined;
+  const serviceFile = yield* bootServiceUnitPath().pipe(
+    Effect.provideService(ProcessRunner.ProcessRunner, {
+      run: (request) =>
+        processRunner.run({ ...request, env: { ...userManagerEnv, ...request.env } }),
+    }),
+  );
+  const service =
+    serviceFile === undefined
+      ? ""
+      : yield* fs.readFileString(serviceFile).pipe(
+          Effect.catchIf(
+            (error) => error.reason._tag === "NotFound",
+            () => Effect.succeed(""),
+          ),
+        );
+  return yield* resolveBaseDir(bootServiceBaseDirOf(service));
+});
+
+const homeDir = Command.make("home-dir").pipe(
+  Command.withHandler(() =>
+    resolveSshServerHome.pipe(
+      Effect.provide(ProcessRunner.layer),
+      Effect.tap((home) =>
+        Effect.sync(() => {
+          process.stdout.write(home);
+        }),
+      ),
+    ),
+  ),
+);
 
 const canBind = (port: number) =>
   new Promise<boolean>((resolve) => {
@@ -144,5 +195,5 @@ const updateRemaining = Command.make("update-remaining", {
 
 export const sshHelperCommand = Command.make("__ssh-helper").pipe(
   Command.unlisted,
-  Command.withSubcommands([pickPort, waitReady, runtimePort, updateRemaining]),
+  Command.withSubcommands([pickPort, waitReady, runtimePort, updateRemaining, homeDir]),
 );

apps/server/src/cloud/bootService.test.ts

@@ -2,7 +2,7 @@
 import * as NodeChildProcess from "node:child_process";
 import * as NodeSqlite from "node:sqlite";
 import * as NodeServices from "@effect/platform-node/NodeServices";
-import { expect, it } from "@effect/vitest";
+import { assert, expect, it } from "@effect/vitest";
 import * as HostProcess from "@t3tools/shared/HostProcess";
 import * as Clock from "effect/Clock";
 import * as ConfigProvider from "effect/ConfigProvider";
@@ -20,6 +20,7 @@ import { vi } from "vite-plus/test";
 import * as ProcessRunner from "../processRunner.ts";
 import { serviceLauncherLockPath } from "../serviceLauncher.ts";
 import * as BootService from "./bootService.ts";
+import { resolveSshServerHome } from "../cli/sshHelper.ts";
 import { pinnedRuntimePaths } from "./pinnedRuntime.ts";
 import {
   disabledServiceTask,
@@ -1664,3 +1665,90 @@ process.disconnect();
     }),
   );
 });
+
+it.effect.each(["linux", "darwin"] as const)(
+  "resolves the %s service home and gives an explicit environment home precedence",
+  (platform) =>
+    Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const directory = yield* fs.makeTempDirectoryScoped({ prefix: "t3-ssh-helper-test-" });
+      const serviceHome = path.join(directory, 'T3 "Data" & 100%');
+      const servicePath =
+        platform === "darwin"
+          ? path.join(directory, "Library/LaunchAgents/com.t3tools.t3code.service.plist")
+          : path.join(directory, ".config/systemd/user/t3code.service");
+      // No reachable systemd manager, so Linux falls back to the XDG config directory.
+      const runner = ProcessRunner.ProcessRunner.of({
+        run: () =>
+          Effect.succeed({
+            stdout: "",
+            stderr: "",
+            code: ChildProcessSpawner.ExitCode(1),
+            timedOut: false,
+            stdoutTruncated: false,
+            stderrTruncated: false,
+            stdoutInvalidUtf8: false,
+            stderrInvalidUtf8: false,
+          }),
+      });
+      const resolve = (environment: NodeJS.ProcessEnv = {}) =>
+        resolveSshServerHome.pipe(
+          Effect.provideService(ProcessRunner.ProcessRunner, runner),
+          Effect.provideService(HostProcess.HomeDirectory, directory),
+          Effect.provideService(HostProcess.Platform, platform),
+          Effect.provideService(HostProcess.Environment, environment),
+        );
+      assert.strictEqual(yield* resolve(), path.join(directory, ".t3"));
+      const plan = {
+        baseDir: serviceHome,
+        program: ["/fake/t3"],
+        logPath: "/fake/log",
+        unitPath: servicePath,
+      };
+      yield* fs.makeDirectory(path.dirname(servicePath), { recursive: true });
+      yield* fs.writeFileString(
+        servicePath,
+        platform === "darwin"
+          ? BootService.renderBootServicePlist(plan, { homeDir: directory, environmentPath: "" })
+          : BootService.renderBootServiceUnit(plan),
+      );
+      assert.strictEqual(yield* resolve(), serviceHome);
+      assert.strictEqual(
+        yield* resolve({ T3CODE_HOME: "~/explicit home" }),
+        path.join(directory, "explicit home"),
+      );
+      assert.strictEqual(yield* resolve({ T3CODE_HOME: " " }), serviceHome);
+      if (platform === "linux") {
+        // A non-login SSH shell has no XDG_RUNTIME_DIR; the user manager is still found.
+        const managerDirectory = path.join(directory, "relocated config/systemd/user");
+        yield* fs.makeDirectory(managerDirectory, { recursive: true });
+        yield* fs.rename(servicePath, path.join(managerDirectory, "t3code.service"));
+        const managerRunner = ProcessRunner.ProcessRunner.of({
+          run: (request) =>
+            Effect.succeed({
+              stdout: JSON.stringify({ data: [managerDirectory, managerDirectory + ".control"] }),
+              stderr: "",
+              code: ChildProcessSpawner.ExitCode(
+                request.env?.XDG_RUNTIME_DIR === "/run/user/1234" ? 0 : 1,
+              ),
+              timedOut: false,
+              stdoutTruncated: false,
+              stderrTruncated: false,
+              stdoutInvalidUtf8: false,
+              stderrInvalidUtf8: false,
+            }),
+        });
+        assert.strictEqual(
+          yield* resolveSshServerHome.pipe(
+            Effect.provideService(ProcessRunner.ProcessRunner, managerRunner),
+            Effect.provideService(HostProcess.HomeDirectory, directory),
+            Effect.provideService(HostProcess.Platform, "linux"),
+            Effect.provideService(HostProcess.UserId, 1234),
+            Effect.provideService(HostProcess.Environment, {}),
+          ),
+          serviceHome,
+        );
+      }
+    }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)),
+);

packages/ssh/src/launcherTestHarness.ts

@@ -102,6 +102,7 @@ Date.now = () => Number(fs.readFileSync(process.env.HOME + '/clock', 'utf8'));
       options.archive ? "test-node" : "node",
       `
 case "\${2:-}" in
+  __ssh-helper) [ "$3" = home-dir ] && printf '%s' "$HOME/.t3" ;;
   */server-runtime.json)
     # A started server publishes its runtime record, which the launch waits for.
     # The fake nohup runs in the background, so wait for it instead of racing it.
@@ -191,6 +192,7 @@ set -eu
 if [ "$1" = --version ]; then printf 1.2.3; exit; fi
 [ "$1" = __ssh-helper ]
 case "$2" in
+  home-dir) printf '%s' "$HOME/.t3" ;;
   update-remaining) printf 'marker %s\\n' "$(cat "$HOME/clock")" >> "$HOME/events"; exec "$TEST_REAL_NODE" --require "$HOME/clock.cjs" "$HOME/helper.ts" "$2" "$3" ;;
   runtime-port | pick-port | wait-ready) exec "$HOME/bin/test-node" - "$3" ;;
   *) exit 1 ;;