tmux-ide 2.9.2 → 2.9.4

package/packages/daemon/src/lib/daemon-service.ts

@@ -0,0 +1,301 @@
+import {
+  accessSync,
+  constants,
+  openSync,
+  closeSync,
+  fstatSync,
+  mkdirSync,
+  readFileSync,
+  unlinkSync,
+  writeFileSync,
+  renameSync,
+  rmSync,
+  realpathSync,
+  linkSync,
+} from "node:fs";
+import { randomUUID } from "node:crypto";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+import { z } from "zod";
+import {
+  getCanonicalDaemonInfoPath,
+  inspectCanonicalDaemonInfo,
+  probeCanonicalDaemonIdentity,
+  releaseCanonicalDaemonSupervision,
+  reserveCanonicalDaemonSupervision,
+  type CanonicalDaemonInfoState,
+} from "./canonical-daemon.ts";
+import { createDaemonServiceManager } from "./daemon-service-manager.ts";
+import { planDaemonService, type DaemonServicePlan } from "./daemon-service-plan.ts";
+import { resolveRuntimeNamespace } from "./runtime-namespace.ts";
+import { IdeError } from "./errors.ts";
+import { acquirePrivateOperationLock } from "./private-operation-lock.ts";
+
+const RecordSchema = z.strictObject({
+  version: z.literal(1),
+  removing: z.boolean().optional(),
+  executable: z.string().min(1),
+  contents: z
+    .string()
+    .min(1)
+    .max(64 * 1024),
+});
+
+export interface DaemonServiceDependencies {
+  plan(executable: string): DaemonServicePlan;
+  manager: typeof createDaemonServiceManager;
+  inspect: typeof inspectCanonicalDaemonInfo;
+  reserve: typeof reserveCanonicalDaemonSupervision;
+  release: typeof releaseCanonicalDaemonSupervision;
+  probe: typeof probeCanonicalDaemonIdentity;
+  recordPath: string;
+  waitMs: number;
+}
+
+function defaults(): DaemonServiceDependencies {
+  const namespace = resolveRuntimeNamespace();
+  return {
+    plan: (executable) =>
+      planDaemonService({
+        platform: process.platform,
+        uid: process.getuid?.() ?? 0,
+        home: homedir(),
+        configHome: process.env.XDG_CONFIG_HOME || undefined,
+        executable,
+        path: process.env.PATH || "/usr/bin:/bin",
+        namespace,
+      }),
+    manager: createDaemonServiceManager,
+    inspect: inspectCanonicalDaemonInfo,
+    reserve: reserveCanonicalDaemonSupervision,
+    release: releaseCanonicalDaemonSupervision,
+    probe: probeCanonicalDaemonIdentity,
+    recordPath: join(dirname(getCanonicalDaemonInfoPath()), "service.json"),
+    waitMs: 30_000,
+  };
+}
+
+function refused(message: string): never {
+  throw new IdeError(message, { code: "DAEMON_SERVICE_REFUSED" });
+}
+
+function ownedFile(path: string): string | null {
+  let descriptor: number | undefined;
+  try {
+    descriptor = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    const stat = fstatSync(descriptor);
+    if (
+      !stat.isFile() ||
+      stat.uid !== process.getuid?.() ||
+      (stat.mode & 0o022) !== 0 ||
+      stat.size > 128 * 1024
+    )
+      refused(`Service file is not a bounded, user-owned regular file: ${path}`);
+    return readFileSync(descriptor, "utf8");
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return null;
+    throw error;
+  } finally {
+    if (descriptor !== undefined) closeSync(descriptor);
+  }
+}
+
+function boundTo(state: CanonicalDaemonInfoState, id: string): boolean {
+  return state.status === "reserved"
+    ? state.reservation.supervisionId === id
+    : state.status === "valid" && state.info.supervisionId === id;
+}
+
+/** Explicit OS supervision. Never starts a detached daemon or signals a guessed PID. */
+export async function manageDaemonService(
+  action: "install" | "status" | "restart" | "remove",
+  executable?: string,
+  deps: DaemonServiceDependencies = defaults(),
+) {
+  const previousRecord = ownedFile(deps.recordPath);
+  const record = previousRecord === null ? null : RecordSchema.parse(JSON.parse(previousRecord));
+  if (record?.removing && action !== "remove" && action !== "status")
+    refused("Service removal is incomplete; finish remove before installing or restarting");
+  if (!record && action !== "install") {
+    if (action === "status") return { status: "not-installed" as const };
+    refused("No managed service is installed in this daemon namespace");
+  }
+  if (action === "install" && !executable)
+    refused("Service installation requires an absolute stable CLI launcher path");
+  if (record && executable && record.executable !== executable)
+    refused(
+      "A different launcher is already registered; remove the stopped service before changing it",
+    );
+  const plan = deps.plan(record?.executable ?? executable!);
+  if (plan.recordPath !== deps.recordPath) refused("Service namespace changed during resolution");
+  const contents = record?.contents ?? plan.contents;
+  const manager = deps.manager(plan);
+  const assertFiles = (allowMissingUnit = false) => {
+    const unit = ownedFile(plan.unitPath);
+    if (unit !== contents && !((record?.removing || allowMissingUnit) && unit === null))
+      refused("Service definition is missing or modified; refusing to control it");
+    if (record && ownedFile(plan.recordPath) !== previousRecord)
+      refused("Service ownership record changed");
+  };
+  const inspectManager = async () => {
+    const state = await manager.inspect();
+    // systemd reports its generated search-path symlink for units enabled by
+    // absolute path. Resolve that link to the owned definition; the definition
+    // itself still has to pass our no-follow private-file and content checks.
+    if (
+      state.loaded &&
+      (!state.definitionPath || realpathSync(state.definitionPath) !== realpathSync(plan.unitPath))
+    )
+      refused("The service manager loaded a different definition; refusing to control it");
+    return state;
+  };
+  const ready = async (previousInstance?: string) => {
+    const deadline = Date.now() + deps.waitMs;
+    do {
+      const state = deps.inspect();
+      if (!boundTo(state, plan.supervisionId))
+        refused("Service reservation changed during startup");
+      if (state.status === "valid" && state.info.instanceId !== previousInstance) {
+        const identity = await deps.probe(state.info);
+        const service = await inspectManager();
+        if (
+          identity &&
+          service.active &&
+          service.pid === state.info.pid &&
+          identity.pid === state.info.pid &&
+          identity.instanceId === state.info.instanceId &&
+          identity.startedAt === state.info.startedAt &&
+          identity.protocolVersion === state.info.protocolVersion
+        )
+          return {
+            status: "running" as const,
+            manager: plan.manager,
+            target: plan.target,
+            pid: state.info.pid,
+            instanceId: state.info.instanceId,
+          };
+      }
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    } while (Date.now() < deadline);
+    refused(
+      "Service did not publish a verified daemon before the deadline; inspect service logs, then retry restart or remove",
+    );
+  };
+  await manager.available();
+  const service = await inspectManager();
+  const allowMissingUnit = action === "remove" && !service.loaded;
+  if (record) assertFiles(allowMissingUnit);
+  if (action === "status") {
+    const state = deps.inspect();
+    const identity =
+      service.active && state.status === "valid" && boundTo(state, plan.supervisionId)
+        ? await deps.probe(state.info)
+        : null;
+    const verified =
+      identity !== null &&
+      state.status === "valid" &&
+      service.pid === state.info.pid &&
+      identity.pid === state.info.pid &&
+      identity.instanceId === state.info.instanceId &&
+      identity.startedAt === state.info.startedAt &&
+      identity.protocolVersion === state.info.protocolVersion;
+    return {
+      status: verified
+        ? ("running" as const)
+        : service.active
+          ? ("active-unverified" as const)
+          : ("stopped" as const),
+      manager: plan.manager,
+      target: plan.target,
+      pid: service.pid,
+      reservationMatches: boundTo(state, plan.supervisionId),
+      unitPath: plan.unitPath,
+    };
+  }
+  if (!record && (service.loaded || ownedFile(plan.unitPath) !== null))
+    refused("A service definition already exists without this namespace's ownership record");
+  if (
+    record &&
+    !boundTo(deps.inspect(), plan.supervisionId) &&
+    !(record.removing && action === "remove" && deps.inspect().status === "missing")
+  )
+    refused("Service reservation is missing or belongs to another owner");
+  if (!record) {
+    accessSync(plan.executable, constants.X_OK);
+    // Canonical reservation admission rejects live, uncertain and foreign owners.
+    deps.reserve(plan.supervisionId);
+  }
+  const lock = `${plan.recordPath}.lock`;
+  const releaseLock = await acquirePrivateOperationLock(lock, 1000);
+  let wroteRecord = false;
+  let wroteUnit = false;
+  let activationAttempted = false;
+  try {
+    if (record) assertFiles(allowMissingUnit);
+    if (action === "install" && !record) {
+      writeFileSync(
+        plan.recordPath,
+        JSON.stringify({ version: 1, executable: plan.executable, contents }) + "\n",
+        { flag: "wx", mode: 0o600 },
+      );
+      wroteRecord = true;
+      mkdirSync(dirname(plan.unitPath), { recursive: true, mode: 0o700 });
+      const unitStage = `${plan.unitPath}.${randomUUID()}.tmp`;
+      writeFileSync(unitStage, contents, { flag: "wx", mode: 0o600 });
+      try {
+        linkSync(unitStage, plan.unitPath);
+      } finally {
+        unlinkSync(unitStage);
+      }
+      wroteUnit = true;
+      activationAttempted = true;
+      await manager.install();
+      return await ready();
+    }
+    if (action === "remove") {
+      if (service.loaded) await manager.stop();
+      let stopped = await inspectManager();
+      const stopDeadline = Date.now() + deps.waitMs;
+      while ((stopped.active || stopped.pid !== null) && Date.now() < stopDeadline) {
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        stopped = await inspectManager();
+      }
+      if (stopped.active || stopped.pid !== null)
+        refused("Service manager has not confirmed the daemon stopped; reservation retained");
+      assertFiles(allowMissingUnit);
+      const removalRecord = JSON.stringify({ ...record!, removing: true }) + "\n";
+      const temporaryRecord = `${plan.recordPath}.${randomUUID()}.tmp`;
+      writeFileSync(temporaryRecord, removalRecord, { flag: "wx", mode: 0o600 });
+      try {
+        if (ownedFile(plan.recordPath) !== previousRecord)
+          refused("Service ownership record changed during removal");
+        renameSync(temporaryRecord, plan.recordPath);
+      } finally {
+        rmSync(temporaryRecord, { force: true });
+      }
+      if (ownedFile(plan.unitPath) !== null) unlinkSync(plan.unitPath);
+      await manager.reload();
+      if ((await inspectManager()).loaded)
+        refused("Service remains loaded after removal; reservation retained");
+      if (deps.inspect().status !== "missing") deps.release(plan.supervisionId);
+      unlinkSync(plan.recordPath);
+      return { status: "removed" as const, target: plan.target };
+    }
+    const before = deps.inspect();
+    if (action === "install" && service.active) return await ready();
+    if (service.loaded) await manager.restart(service.pid !== null);
+    else await manager.install();
+    return await ready(before.status === "valid" ? before.info.instanceId : undefined);
+  } catch (error) {
+    // Never discard ownership after an uncertain OS activation. The retained
+    // record/reservation gives the explicit remove/restart commands a recovery path.
+    if (!activationAttempted && wroteRecord) {
+      if (wroteUnit && ownedFile(plan.unitPath) === contents) unlinkSync(plan.unitPath);
+      unlinkSync(plan.recordPath);
+      deps.release(plan.supervisionId);
+    }
+    throw error;
+  } finally {
+    releaseLock();
+  }
+}

package/packages/daemon/src/lib/install-origin.ts

@@ -2,6 +2,7 @@ import { existsSync, readFileSync, realpathSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 export type InstallOrigin =
+  | "installer"
   | "npm"
   | "pnpm"
   | "bun"
@@ -12,6 +13,10 @@ export type InstallOrigin =
   | "unknown";
 /** Conservative layout evidence; an arbitrary node_modules directory is not a global install. */
 export function detectPackageManager(path: string): Exclude<InstallOrigin, "dev"> {
+  if (
+    /\/share\/tmux-ide\/releases\/install-[^/]+\/npm\/lib\/node_modules\/tmux-ide\/bin$/.test(path)
+  )
+    return "installer";
   if (/\/(?:Cellar|Caskroom)\//.test(path)) return "homebrew";
   if (/\/_npx\//.test(path)) return "npx";
   if (/\/(?:\.yarn|yarn)\//.test(path)) return "yarn";

package/packages/daemon/src/lib/local-fleet-request.ts

@@ -1,4 +1,9 @@
-import { SavedMachineRegistrySchema, type SavedMachine } from "@tmux-ide/contracts/saved-machines";
+import {
+  SavedMachineRegistrySchema,
+  type SavedMachine,
+  SavedMachineMutationSchema,
+  type SavedMachineMutation,
+} from "@tmux-ide/contracts/saved-machines";
 import {
   canonicalDaemonUrl,
   isCanonicalDaemonAlive,
@@ -8,6 +13,17 @@ import {
 /** Intentional local registry mutation. Never uses selected-machine authority. */
 export async function saveMachineProfiles(machines: readonly SavedMachine[]) {
   const registry = SavedMachineRegistrySchema.parse({ version: 1, machines });
+  return writeLocalMachineRegistry("POST", { registry });
+}
+
+export async function mutateMachineProfile(change: SavedMachineMutation) {
+  return writeLocalMachineRegistry("PATCH", { change: SavedMachineMutationSchema.parse(change) });
+}
+
+async function writeLocalMachineRegistry(
+  method: "POST" | "PATCH",
+  payload: Record<string, unknown>,
+) {
   const daemon = readCanonicalDaemonInfo();
   if (!daemon?.authToken || !(await isCanonicalDaemonAlive(daemon)))
     throw new Error("Start a local tmux-ide daemon to save machine profiles.");
@@ -16,14 +32,14 @@ export async function saveMachineProfiles(machines: readonly SavedMachine[]) {
       canonicalDaemonUrl("http", daemon.bindHostname, daemon.port) +
         "/api/resources/saved-machines",
       {
-        method: "POST",
+        method,
         redirect: "error",
         signal: AbortSignal.timeout(5000),
         headers: {
           Authorization: `Bearer ${daemon.authToken}`,
           "Content-Type": "application/json",
         },
-        body: JSON.stringify({ expectedInstanceId: daemon.instanceId, registry }),
+        body: JSON.stringify({ expectedInstanceId: daemon.instanceId, ...payload }),
       },
     );
     if (!response.ok) {

package/packages/daemon/src/lib/log.ts

@@ -152,16 +152,16 @@ export function getLogStreamFailures(): readonly StreamName[] {
 function markStreamFailed(name: StreamName, error: unknown): void {
   if (streamState[name].failed) return;
   streamState[name].failed = true;
-  const detail = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+  const detail = sanitizeLogMessage(
+    error instanceof Error ? `${error.name}: ${error.message}` : String(error),
+    secrets,
+    budget,
+  );
   const warning = `[log.ts] ${name} write failed (${detail}); further records are retained in memory only\n`;
   const other: StreamName = name === "stdout" ? "stderr" : "stdout";
-  if (!streamState[other].failed) {
-    try {
-      process[other].write(warning);
-    } catch {
-      streamState[other].failed = true;
-    }
-  }
+  // The fallback can fail asynchronously too. Install the same error handling
+  // before writing it; failed flags prevent a warning loop if both streams fail.
+  if (!streamState[other].failed) writeToStream(other, warning);
 }
 
 function writeToStream(name: StreamName, line: string): void {
@@ -221,7 +221,11 @@ function writeStructuredLog(
       // Avoid recursion via the logger; write directly to stderr.
       writeToStream(
         "stderr",
-        `[log.ts] subscriber threw: ${err instanceof Error ? err.message : String(err)}\n`,
+        `[log.ts] subscriber threw: ${sanitizeLogMessage(
+          err instanceof Error ? err.message : String(err),
+          secrets,
+          budget,
+        )}\n`,
       );
     }
   }

package/packages/daemon/src/lib/managed-installer-update.ts

@@ -0,0 +1,79 @@
+import { mkdtempSync, readFileSync, realpathSync, rmSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { tmpdir } from "node:os";
+import { execFileSync } from "node:child_process";
+
+export const MANAGED_INSTALLER_URL = "https://tmux-ide.com/install.sh";
+
+/** Only the active release of a marked installation may update its prefix. */
+export function managedInstallerPrefix(cliPath: string): string | null {
+  const match =
+    /^(.*)\/share\/tmux-ide\/releases\/(install-[A-Za-z0-9]{6})\/npm\/lib\/node_modules\/tmux-ide\/bin$/.exec(
+      cliPath,
+    );
+  if (!match) return null;
+  const prefix = match[1] || "/";
+  const root = join(prefix, "share/tmux-ide");
+  const release = join(root, "releases", match[2]!);
+  try {
+    if (realpathSync(join(root, "current")) !== release) return null;
+    if (realpathSync(release) !== release) return null;
+    if (readFileSync(join(root, "installer-v1"), "utf8") !== "1\n") return null;
+    if (readFileSync(join(release, ".installer-release-v1"), "utf8") !== "1\n") return null;
+    if (
+      !readFileSync(join(prefix, "bin/tmux-ide"), "utf8")
+        .split("\n")
+        .includes("# tmux-ide universal installer v1")
+    )
+      return null;
+    if (
+      JSON.parse(readFileSync(join(dirname(cliPath), "package.json"), "utf8")).name !== "tmux-ide"
+    )
+      return null;
+    return prefix;
+  } catch {
+    return null;
+  }
+}
+
+/** Download completely before execution; the canonical installer owns activation and rollback. */
+export function runManagedInstallerUpdate(
+  prefix: string,
+  channel: string,
+  json: boolean,
+  execute: typeof execFileSync = execFileSync,
+): void {
+  const temporary = mkdtempSync(join(tmpdir(), "tmux-ide-update-"));
+  const script = join(temporary, "install.sh");
+  try {
+    execute(
+      "curl",
+      [
+        "--fail",
+        "--location",
+        "--silent",
+        "--show-error",
+        "--proto",
+        "=https",
+        "--proto-redir",
+        "=https",
+        "--connect-timeout",
+        "15",
+        "--max-time",
+        "180",
+        "--output",
+        script,
+        MANAGED_INSTALLER_URL,
+      ],
+      { stdio: ["ignore", 2, 2] },
+    );
+    if (!readFileSync(script, "utf8").startsWith("#!/bin/sh\n"))
+      throw new Error("Installer download was not a shell script; installation unchanged");
+    execute("/bin/sh", ["-n", script], { stdio: ["ignore", 2, 2] });
+    execute("/bin/sh", [script, "--prefix", prefix, "--version", channel], {
+      stdio: json ? ["ignore", 2, 2] : "inherit",
+    });
+  } finally {
+    rmSync(temporary, { recursive: true, force: true });
+  }
+}

package/packages/daemon/src/lib/{tui-download-lock.ts → private-operation-lock.ts}

@@ -26,7 +26,7 @@ function trusted(path: string, directory: boolean) {
     (value.mode & 0o777) !== (directory ? 0o700 : 0o600) ||
     (!directory && value.nlink !== 1)
   )
-    throw new Error("unsafe TUI download lock");
+    throw new Error("unsafe private operation lock");
   return value;
 }
 function readOwner(path: string): { pid: number; ino: number; dev: number } {
@@ -35,15 +35,15 @@ function readOwner(path: string): { pid: number; ino: number; dev: number } {
   try {
     const actual = fstatSync(fd);
     if (actual.ino !== before.ino || actual.dev !== before.dev || actual.size > 32) {
-      throw new Error("unsafe TUI download lock");
+      throw new Error("unsafe private operation lock");
     }
     const bytes = Buffer.alloc(33);
     const length = readSync(fd, bytes, 0, bytes.length, 0);
     const text = bytes.subarray(0, length).toString("utf8");
-    if (!/^[1-9][0-9]*\n$/.test(text)) throw new Error("invalid TUI download lock owner");
+    if (!/^[1-9][0-9]*\n$/.test(text)) throw new Error("invalid private operation lock owner");
     const pid = Number(text.trim());
     if (!Number.isSafeInteger(pid) || pid > 2147483647)
-      throw new Error("invalid TUI download lock owner");
+      throw new Error("invalid private operation lock owner");
     return { pid, ino: actual.ino, dev: actual.dev };
   } finally {
     closeSync(fd);
@@ -88,7 +88,7 @@ function cleanStaging(
   try {
     const current = trusted(path, true);
     if (current.ino !== expected.ino || current.dev !== expected.dev)
-      throw new Error("TUI download staging lock changed");
+      throw new Error("private operation staging lock changed");
     try {
       unlinkSync(join(path, name));
     } catch (error) {
@@ -102,7 +102,10 @@ function cleanStaging(
 }
 
 /** Publish a populated private directory atomically; age never proves owner death. */
-export async function acquireTuiDownloadLock(lock: string, waitMs: number): Promise<() => void> {
+export async function acquirePrivateOperationLock(
+  lock: string,
+  waitMs: number,
+): Promise<() => void> {
   const deadline = Date.now() + waitMs;
   const nonce = randomUUID();
   const name = `owner-${nonce}`;
@@ -116,7 +119,7 @@ export async function acquireTuiDownloadLock(lock: string, waitMs: number): Prom
     writeFileSync(join(staging, name), `${process.pid}\n`, { flag: "wx", mode: 0o600 });
     while (true) {
       if (attempted && Date.now() >= deadline)
-        throw new Error("timed out waiting for another TUI download");
+        throw new Error("timed out waiting for another private operation");
       attempted = true;
       try {
         const existing = lstatSync(lock);
@@ -154,7 +157,7 @@ export async function acquireTuiDownloadLock(lock: string, waitMs: number): Prom
           }
           if (names.length !== 1 || !/^owner-[0-9a-f-]{36}$/.test(names[0]!)) {
             // Empty is only a retirement gap; the next atomic rename can claim it.
-            if (names.length !== 0) throw new Error("invalid TUI download lock inventory");
+            if (names.length !== 0) throw new Error("invalid private operation lock inventory");
           } else {
             const owner = readOwner(join(lock, names[0]!));
             if (dead(owner.pid)) {
@@ -164,7 +167,7 @@ export async function acquireTuiDownloadLock(lock: string, waitMs: number): Prom
                 current.dev !== owner.dev ||
                 current.pid !== owner.pid
               ) {
-                throw new Error("TUI download lock changed");
+                throw new Error("private operation lock changed");
               }
               retire(lock, names[0]!, entry);
             }
@@ -182,7 +185,7 @@ export async function acquireTuiDownloadLock(lock: string, waitMs: number): Prom
               current.dev !== owner.dev ||
               current.pid !== owner.pid
             ) {
-              throw new Error("TUI download lock changed");
+              throw new Error("private operation lock changed");
             }
             try {
               unlinkSync(lock);
@@ -194,7 +197,8 @@ export async function acquireTuiDownloadLock(lock: string, waitMs: number): Prom
       } catch (error) {
         if (code(error) !== "ENOENT") throw error;
       }
-      if (Date.now() >= deadline) throw new Error("timed out waiting for another TUI download");
+      if (Date.now() >= deadline)
+        throw new Error("timed out waiting for another private operation");
       await new Promise((resolve) =>
         setTimeout(resolve, Math.min(50, Math.max(0, deadline - Date.now()))),
       );

package/packages/daemon/src/lib/remote-daemon-info.ts

@@ -1,4 +1,4 @@
-import { type CanonicalDaemonInfo } from "@tmux-ide/contracts";
+import { DAEMON_WIRE_PROTOCOL_VERSION, type CanonicalDaemonInfo } from "@tmux-ide/contracts";
 import {
   canonicalDaemonUrl,
   isCanonicalDaemonAlive,
@@ -35,9 +35,9 @@ export async function readRemoteDaemonHandshake(
       "daemon-missing",
     );
   const parsed = RemoteDaemonHandshakeSchema.safeParse({ version: 1, daemon: info });
-  if (!parsed.success)
+  if (!parsed.success || info.protocolVersion !== DAEMON_WIRE_PROTOCOL_VERSION)
     throw new RemoteDaemonInfoError(
-      "The daemon does not support authenticated SSH discovery.",
+      "The daemon does not support this authenticated SSH discovery protocol.",
       "incompatible",
     );
   try {

package/packages/daemon/src/lib/remote-daemon-lifecycle.ts

@@ -1,5 +1,6 @@
 import { spawn } from "node:child_process";
 import { SavedMachineSchema } from "@tmux-ide/contracts/saved-machines";
+import { remoteTmuxIdeCommand } from "./remote-tmux-command.ts";
 
 /** Only explicit user actions call this; catalog discovery and retries never do. */
 export async function startInstalledRemoteDaemon(
@@ -21,12 +22,11 @@ export async function startInstalledRemoteDaemon(
         "BatchMode=yes",
         "-o",
         "ConnectTimeout=10",
+        "-o",
+        "ForkAfterAuthentication=no",
         "--",
         alias,
-        "tmux-ide",
-        "update",
-        "--daemon",
-        "--json",
+        remoteTmuxIdeCommand("start"),
       ],
       { stdio: ["ignore", "pipe", "pipe"] },
     );

package/packages/daemon/src/lib/remote-tmux-command.ts

@@ -0,0 +1,12 @@
+import { shellEscape } from "./shell.ts";
+
+/** Fixed commands only. SSH normally omits interactive shell PATH setup. */
+export function remoteTmuxIdeCommand(operation: "discover" | "start"): string {
+  const args = operation === "discover" ? "remote-daemon-info --json" : "update --daemon --json";
+  // Respect the host's existing installation preference, then try the installer
+  // and common package-manager prefixes. Never source shell profiles.
+  const script =
+    'export PATH="${PATH:-/usr/bin:/bin}:$HOME/.local/bin:/opt/homebrew/bin:/usr/local/bin:/home/linuxbrew/.linuxbrew/bin:$HOME/.npm-global/bin"; ' +
+    `exec tmux-ide ${args}`;
+  return `/bin/sh -c ${shellEscape(script)}`;
+}