@puddle-code/cli 0.2.4 → 0.2.7

package/dist/index.js

@@ -3756,7 +3756,7 @@ var init_wrapper = __esm({
 
 // src/lib/ws-client.ts
 function connectGateway(port, authority) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const ws = new wrapper_default(`ws://127.0.0.1:${port}/ws`, {
       headers: { host: `localhost:${port}` }
     });
@@ -3781,7 +3781,7 @@ function connectGateway(port, authority) {
       }
       if (parsed.t === "authenticated") {
         clearTimeout(timer);
-        resolve5({
+        resolve6({
           send(message) {
             if (resource.valid() && ws.readyState === wrapper_default.OPEN)
               ws.send(JSON.stringify(message));
@@ -3855,7 +3855,7 @@ async function attachSession(opts) {
     rows: streams.stdout.rows ?? 24
   });
   gateway.send({ t: "attach", session: session.id, term, ...dims2() });
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     let settled = false;
     const finish = (outcome) => {
       if (settled) return;
@@ -3864,7 +3864,7 @@ async function attachSession(opts) {
       stdin.removeListener("data", onStdin);
       unResize?.();
       gateway.close();
-      resolve5(outcome);
+      resolve6(outcome);
     };
     gateway.onMessage((message) => {
       switch (message.t) {
@@ -3925,7 +3925,7 @@ import { createInterface } from "node:readline";
 import { Writable } from "node:stream";
 
 // ../shared/src/protocol.ts
-var PROTOCOL_VERSION = { major: 21, minor: 2 };
+var PROTOCOL_VERSION = { major: 21, minor: 3 };
 
 // ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -18754,6 +18754,7 @@ var agentTypeSchema = external_exports.object({
 var repoSchema = external_exports.object({
   id: rowId,
   path: external_exports.string(),
+  /** Empty follows the branch currently checked out at path, resolved for each new session. */
   default_base_branch: external_exports.string(),
   onboarding_notes: external_exports.string().nullable(),
   fetch_enabled: external_exports.boolean(),
@@ -18764,7 +18765,8 @@ var repoWithOrphansSchema = repoSchema.extend({
 });
 var createRepoRequestSchema = external_exports.object({
   path: external_exports.string().min(1),
-  default_base_branch: external_exports.string().min(1).optional(),
+  /** Empty follows the clone's current branch; omitted snapshots it at registration. */
+  default_base_branch: external_exports.string().optional(),
   onboarding_notes: external_exports.string().nullable().optional(),
   fetch_enabled: external_exports.boolean().optional()
 });
@@ -18805,7 +18807,8 @@ var repoWorktreesResponseSchema = external_exports.object({
   orphan_branches: external_exports.array(orphanBranchSchema)
 });
 var patchRepoRequestSchema = external_exports.object({
-  default_base_branch: external_exports.string().min(1).optional(),
+  /** Empty follows the clone's current branch; omitted leaves the setting unchanged. */
+  default_base_branch: external_exports.string().optional(),
   onboarding_notes: external_exports.string().nullable().optional(),
   fetch_enabled: external_exports.boolean().optional()
 });
@@ -20039,7 +20042,7 @@ var LocalTransport = class {
   kind = "local";
   label = "this machine";
   exec(command, opts = {}) {
-    return new Promise((resolve5) => {
+    return new Promise((resolve6) => {
       const child = spawn("sh", ["-c", command], { stdio: ["pipe", "pipe", "pipe"] });
       let stdout = "";
       let stderr = "";
@@ -20056,11 +20059,11 @@ var LocalTransport = class {
       child.stderr.on("data", (chunk) => stderr += chunk.toString());
       child.on("error", (err) => {
         if (timer) clearTimeout(timer);
-        resolve5({ code: -1, stdout, stderr: stderr + String(err) });
+        resolve6({ code: -1, stdout, stderr: stderr + String(err) });
       });
       child.on("close", (code) => {
         if (timer) clearTimeout(timer);
-        resolve5({ code: code ?? -1, stdout, stderr });
+        resolve6({ code: code ?? -1, stdout, stderr });
       });
       child.stdin.on("error", () => {
       });
@@ -20154,7 +20157,7 @@ var SshTransport = class {
    * live control socket behind.
    */
   open() {
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve6, reject) => {
       const child = spawn2(this.ssh, this.args(this.host, "true"), {
         // A GUI has no useful inherited terminal; OpenSSH calls its askpass
         // helper instead. The terminal CLI keeps byte-for-byte inheritance.
@@ -20166,7 +20169,7 @@ var SshTransport = class {
         (err) => reject(new CliError("ssh_unreachable", `could not run ${this.ssh}: ${err.message}`))
       );
       child.on("close", (code) => {
-        if (code === 0) resolve5();
+        if (code === 0) resolve6();
         else {
           reject(
             new CliError(
@@ -20182,13 +20185,13 @@ var SshTransport = class {
   /** Whether the master connection is still alive (-O check). */
   isAlive() {
     if (!this.hasControlMaster) return Promise.resolve(true);
-    return new Promise((resolve5) => {
+    return new Promise((resolve6) => {
       const child = spawn2(this.ssh, this.args("-O", "check", this.host), {
         stdio: "ignore",
         env: this.spawnEnv()
       });
-      child.on("error", () => resolve5(false));
-      child.on("close", (code) => resolve5(code === 0));
+      child.on("error", () => resolve6(false));
+      child.on("close", (code) => resolve6(code === 0));
     });
   }
   /**
@@ -20201,18 +20204,18 @@ var SshTransport = class {
    */
   cancelForward(localPort, remotePort) {
     if (!this.hasControlMaster) return Promise.resolve();
-    return new Promise((resolve5) => {
+    return new Promise((resolve6) => {
       const spec = `${localPort}:127.0.0.1:${remotePort}`;
       const child = spawn2(this.ssh, this.args("-O", "cancel", "-L", spec, this.host), {
         stdio: "ignore",
         env: this.spawnEnv()
       });
-      child.on("error", () => resolve5());
-      child.on("close", () => resolve5());
+      child.on("error", () => resolve6());
+      child.on("close", () => resolve6());
     });
   }
   exec(command, opts = {}) {
-    return new Promise((resolve5) => {
+    return new Promise((resolve6) => {
       const child = spawn2(this.ssh, this.args(this.host, "--", `sh -c ${shellQuote(command)}`), {
         stdio: ["pipe", "pipe", "pipe"],
         env: this.spawnEnv()
@@ -20232,11 +20235,11 @@ var SshTransport = class {
       child.stderr.on("data", (chunk) => stderr += chunk.toString());
       child.on("error", (err) => {
         if (timer) clearTimeout(timer);
-        resolve5({ code: -1, stdout, stderr: stderr + String(err) });
+        resolve6({ code: -1, stdout, stderr: stderr + String(err) });
       });
       child.on("close", (code) => {
         if (timer) clearTimeout(timer);
-        resolve5({ code: code ?? -1, stdout, stderr });
+        resolve6({ code: code ?? -1, stdout, stderr });
       });
       child.stdin.on("error", () => {
       });
@@ -20256,11 +20259,11 @@ var SshTransport = class {
     });
     let stdout = "";
     let stderr = "";
-    const result = new Promise((resolve5) => {
+    const result = new Promise((resolve6) => {
       child.stdout.on("data", (chunk) => stdout += chunk.toString());
       child.stderr.on("data", (chunk) => stderr += chunk.toString());
-      child.on("error", (err) => resolve5({ code: -1, stdout, stderr: stderr + String(err) }));
-      child.on("close", (code) => resolve5({ code: code ?? -1, stdout, stderr }));
+      child.on("error", (err) => resolve6({ code: -1, stdout, stderr: stderr + String(err) }));
+      child.on("close", (code) => resolve6({ code: code ?? -1, stdout, stderr }));
     });
     return {
       result,
@@ -20275,14 +20278,14 @@ var SshTransport = class {
   }
   async copyTo(localPath, destPath) {
     await this.exec(`mkdir -p $(dirname ${destPath})`, { timeoutMs: 15e3 });
-    await new Promise((resolve5, reject) => {
+    await new Promise((resolve6, reject) => {
       const child = spawn2(this.scp, [...this.controlArgs, localPath, `${this.host}:${destPath}`], {
         stdio: ["ignore", "ignore", "inherit"],
         env: this.spawnEnv()
       });
       child.on("error", reject);
       child.on("close", (code) => {
-        if (code === 0) resolve5();
+        if (code === 0) resolve6();
         else reject(new CliError("ssh_unreachable", `scp to ${this.host} failed (exit ${code})`));
       });
     });
@@ -20383,7 +20386,7 @@ async function registrationCode() {
   const readline = createInterface({ input: process.stdin, output: silent, terminal: true });
   try {
     return remoteSecretSchema.parse(
-      await new Promise((resolve5) => readline.question("", resolve5))
+      await new Promise((resolve6) => readline.question("", resolve6))
     );
   } finally {
     readline.close();
@@ -20507,6 +20510,8 @@ running in the background once ready, so the terminal may close (--foreground
 to stay attached; Ctrl-C then stops the cockpit). refresh stops a target's
 cockpit (even a wedged one) and runs the full launch flow again \u2014 tunnel,
 daemon restart if needed \u2014 keeping the old UI port so open tabs survive.
+An older host protocol prompts before updating its daemon; --no-upgrade
+aborts before prompting. Without a terminal, upgrade the daemon explicitly first.
 list shows running cockpits; kill stops one. Sessions keep running under a
 persistent supervisor; an SSH-attached daemon keeps their state for the next launch.
 
@@ -20516,7 +20521,7 @@ AppImage placed where you say (default ~/puddle), then opened in the file
 manager. Already installed and no @version \u2192 nothing changes.
 upgrade moves components to the newest release (or the named @version),
 installing any that are missing; with no component it covers everything
-installed on the target \u2014 the CLI last, via npm. cli and desktop are
+installed on the target \u2014 the CLI last, using its installation channel. cli and desktop are
 client-machine artefacts: user@host targets the daemon only. remove
 uninstalls a component after confirmation; 'daemon' stops it (interrupting
 its sessions), unregisters the supervisor, and keeps ~/.puddle's data \u2014
@@ -20703,7 +20708,7 @@ function parseArgs(argv) {
         throw new CliError(
           "bad_arguments",
           "install takes one of: daemon | desktop (with an optional @version)",
-          spec?.what === "cli" ? "the CLI installs itself via npm: npm install -g @puddle-code/cli" : "e.g. puddle install daemon@v0.0.32 user@host"
+          spec?.what === "cli" ? "install the CLI with the public install.sh or npm; update it with puddle upgrade cli" : "e.g. puddle install daemon@v0.0.32 user@host"
         );
       }
       return {
@@ -20780,6 +20785,182 @@ function argvFor(command) {
   return argv;
 }
 
+// src/cli/daemon-upgrade-prompt.ts
+import { randomUUID } from "node:crypto";
+
+// src/lib/handshake.ts
+init_types();
+var CLI_UPGRADE_COMMAND = "puddle upgrade cli";
+function decideHandshake(cli, daemon) {
+  if (daemon.major === cli.major) return { kind: "proceed" };
+  if (daemon.major < cli.major) return { kind: "upgrade-daemon" };
+  return { kind: "refuse-cli-outdated", command: CLI_UPGRADE_COMMAND };
+}
+function daemonUpgradeMessage(request) {
+  const { host, daemon, clientProtocol, liveSessions } = request;
+  return `${host} runs puddled ${daemon.version} (protocol ${daemon.protocol.major}.${daemon.protocol.minor}). This client uses protocol ${clientProtocol.major}.${clientProtocol.minor} and needs the same protocol major.
+
+Updating the host daemon will interrupt ${liveSessions} live session(s). Their saved state remains and they can resume after the update.`;
+}
+function verifyDaemonVersion(daemon) {
+  const decision = decideHandshake(PROTOCOL_VERSION, daemon.protocol);
+  if (decision.kind === "proceed") return daemon;
+  if (decision.kind === "refuse-cli-outdated") {
+    throw new CliError(
+      "cli_outdated",
+      `the daemon speaks protocol ${daemon.protocol.major}; this client speaks ${PROTOCOL_VERSION.major}`,
+      `update the desktop app, or update the CLI: ${decision.command}`
+    );
+  }
+  throw new CliError(
+    "protocol_mismatch",
+    `the daemon speaks protocol ${daemon.protocol.major}; this client speaks ${PROTOCOL_VERSION.major}`,
+    "reconnect to update the host daemon"
+  );
+}
+async function runHandshake(opts) {
+  const { version: daemon, liveSessions } = opts.inspection;
+  if (decideHandshake(PROTOCOL_VERSION, daemon.protocol).kind !== "upgrade-daemon") {
+    return verifyDaemonVersion(daemon);
+  }
+  if (opts.noUpgrade) {
+    throw new CliError(
+      "upgrade_failed",
+      `the daemon speaks protocol ${daemon.protocol.major} (client: ${PROTOCOL_VERSION.major}) and --no-upgrade is set`,
+      `re-run without --no-upgrade to update it (${liveSessions} live session(s) would be interrupted and can be resumed)`
+    );
+  }
+  const request = {
+    host: opts.host,
+    daemon,
+    clientProtocol: PROTOCOL_VERSION,
+    liveSessions
+  };
+  if (!await opts.confirmDaemonUpgrade?.(request)) {
+    throw new CliError(
+      "upgrade_failed",
+      `the daemon update on ${opts.host} was not approved`,
+      "launch again to approve the update, or run puddle upgrade daemon with the host as an optional argument"
+    );
+  }
+  const latest = await opts.reinspect?.();
+  if (latest && decideHandshake(PROTOCOL_VERSION, latest.version.protocol).kind !== "upgrade-daemon") {
+    return verifyDaemonVersion(latest.version);
+  }
+  const logger = opts.logger ?? silentLogger;
+  logger.info(
+    `updating puddled on ${opts.host} (protocol ${daemon.protocol.major} \u2192 ${PROTOCOL_VERSION.major}) \u2014 ${liveSessions} live session(s) will be interrupted and can be resumed`
+  );
+  try {
+    return verifyDaemonVersion(await opts.upgradeDaemon());
+  } catch (err) {
+    if (err instanceof CliError && ["cli_outdated", "protocol_mismatch"].includes(err.code)) {
+      throw new CliError(
+        "upgrade_failed",
+        `the daemon protocol is still incompatible after updating: ${err.message}`,
+        "inspect the daemon logs: puddle logs"
+      );
+    }
+    throw err;
+  }
+}
+
+// src/cli/prompt.ts
+init_types();
+import { createInterface as createInterface2 } from "node:readline";
+async function ask(question, def) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) return def;
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await new Promise(
+      (resolve6) => rl.question(`${question} [${def}] `, resolve6)
+    );
+    return answer.trim() === "" ? def : answer.trim();
+  } finally {
+    rl.close();
+  }
+}
+async function confirm(question, opts = {}) {
+  if (opts.skip === true) return true;
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    throw new CliError(
+      "bad_arguments",
+      "refusing to confirm without a terminal",
+      "pass --yes to proceed non-interactively"
+    );
+  }
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await new Promise(
+      (resolve6) => rl.question(`${question} [y/N] `, resolve6)
+    );
+    return /^y(es)?$/i.test(answer.trim());
+  } finally {
+    rl.close();
+  }
+}
+
+// src/cli/daemon-upgrade-prompt.ts
+var REQUEST = "puddle:confirm-daemon-upgrade";
+var RESPONSE = "puddle:daemon-upgrade-answer";
+async function askToUpgrade(message) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) return false;
+  return confirm(`${message}
+
+Update and connect?`);
+}
+var confirmDaemonUpgrade = async (request) => {
+  const message = daemonUpgradeMessage(request);
+  if (!process.send || !process.connected) return askToUpgrade(message);
+  return requestDaemonUpgradeApproval(message, process);
+};
+function requestDaemonUpgradeApproval(message, channel) {
+  if (!channel.send || !channel.connected) return Promise.resolve(false);
+  const id = randomUUID();
+  return new Promise((resolve6) => {
+    const finish = (approved) => {
+      channel.off("message", answered);
+      channel.off("disconnect", disconnected);
+      resolve6(approved);
+    };
+    const answered = (value) => {
+      if (!value || typeof value !== "object") return;
+      const response = value;
+      if (response.t === RESPONSE && response.id === id && typeof response.approved === "boolean")
+        finish(response.approved);
+    };
+    const disconnected = () => finish(false);
+    channel.on("message", answered);
+    channel.once("disconnect", disconnected);
+    channel.send({ t: REQUEST, id, message }, (err) => {
+      if (err) finish(false);
+    });
+  });
+}
+function relayDaemonUpgradePrompt(child, ask2 = askToUpgrade) {
+  let active = true;
+  let pending = false;
+  const receive = (value) => {
+    if (pending || !value || typeof value !== "object") return;
+    const request = value;
+    if (request.t !== REQUEST || typeof request.id !== "string" || typeof request.message !== "string")
+      return;
+    pending = true;
+    void ask2(request.message).catch(() => false).then((approved) => {
+      pending = false;
+      if (active && child.connected)
+        child.send({ t: RESPONSE, id: request.id, approved }, () => {
+        });
+    });
+  };
+  child.on("message", receive);
+  return () => {
+    active = false;
+    child.off("message", receive);
+    if (child.connected) child.disconnect();
+  };
+}
+
 // ../shared/src/node/security.ts
 import { createHash, randomBytes } from "node:crypto";
 import {
@@ -20867,14 +21048,14 @@ async function listenPrivate(path, onConnection) {
       privatePath(path);
       const before = lstatSync(path);
       if (!before.isSocket()) throw new Error("Puddle control path is not a socket");
-      const stale = await new Promise((resolve5, reject) => {
+      const stale = await new Promise((resolve6, reject) => {
         const probe = connect(path);
         probe.once("connect", () => {
           probe.destroy();
-          resolve5(false);
+          resolve6(false);
         });
         probe.once("error", (err) => {
-          if (err.code === "ECONNREFUSED" || err.code === "ENOENT") resolve5(true);
+          if (err.code === "ECONNREFUSED" || err.code === "ENOENT") resolve6(true);
           else reject(err);
         });
       });
@@ -20887,11 +21068,11 @@ async function listenPrivate(path, onConnection) {
     }
   }
   const server = createServer(onConnection);
-  await new Promise((resolve5, reject) => {
+  await new Promise((resolve6, reject) => {
     server.once("error", reject);
     server.listen(path, () => {
       server.off("error", reject);
-      resolve5();
+      resolve6();
     });
   });
   if (process.platform !== "win32") chmodSync(path, 384);
@@ -21005,7 +21186,7 @@ var HostControlClient = class {
       }
       this.channel = channel;
       this.until = performance.now() + CONNECTION_POLICY.leaseMs;
-      await new Promise((resolve5, reject) => {
+      await new Promise((resolve6, reject) => {
         let pendingAt = null;
         let initial = true;
         const send = (message, sentAt = performance.now()) => {
@@ -21036,8 +21217,8 @@ var HostControlClient = class {
               this.status = "protocol_mismatch";
               reject(
                 this.error(
-                  "cli_outdated",
-                  `Host protocol ${message.version.protocol.major} requires a compatible CLI`
+                  "protocol_mismatch",
+                  `Host protocol ${message.version.protocol.major} does not match client protocol ${PROTOCOL_VERSION.major}`
                 )
               );
               channel.destroy();
@@ -21058,7 +21239,7 @@ var HostControlClient = class {
                 if (this.channel !== channel) return;
                 this.status = "ready";
                 this.emit();
-                resolve5();
+                resolve6();
               }).catch(() => channel.destroy());
             }
           },
@@ -21155,7 +21336,7 @@ async function inspectLegacyHost(home) {
   };
   try {
     const version2 = versionResponseSchema.parse(await get("/api/version"));
-    const sessions = sessionSchema.array().parse(await get("/api/sessions"));
+    const sessions = sessionSchema.pick({ status: true }).array().parse(await get("/api/sessions"));
     return hostInspectionSchema.parse({
       t: "inspection",
       port,
@@ -21179,7 +21360,7 @@ async function inspectHostLocally(home) {
   }
   const socket = connect2(path);
   try {
-    const grant = await new Promise((resolve5, reject) => {
+    const grant = await new Promise((resolve6, reject) => {
       socket.setTimeout(5e3, () => socket.destroy(new Error("Host inspection timed out")));
       socket.once("error", reject);
       socket.once("close", () => reject(new Error("Host control closed")));
@@ -21189,7 +21370,7 @@ async function inspectHostLocally(home) {
           const message = controlResponseSchema.parse(value);
           if (message.t !== "authority" || !message.token)
             throw new Error("Host authority unavailable");
-          resolve5(message);
+          resolve6(message);
         },
         () => socket.destroy(new Error("Invalid host control response"))
       );
@@ -21200,7 +21381,7 @@ async function inspectHostLocally(home) {
       signal: AbortSignal.timeout(3e3)
     });
     if (!response.ok) throw new Error("Host inspection rejected");
-    const sessions = sessionSchema.array().parse(await response.json());
+    const sessions = sessionSchema.pick({ status: true }).array().parse(await response.json());
     return hostInspectionSchema.parse({
       t: "inspection",
       port: grant.port,
@@ -21302,9 +21483,9 @@ async function acquireAuthority(transport) {
 
 // src/cli/run.ts
 init_attach();
-import { existsSync as existsSync6 } from "node:fs";
-import { dirname as dirname10, join as join16 } from "node:path";
-import { fileURLToPath as fileURLToPath4 } from "node:url";
+import { existsSync as existsSync7 } from "node:fs";
+import { dirname as dirname12, join as join17 } from "node:path";
+import { fileURLToPath as fileURLToPath5 } from "node:url";
 
 // src/lib/browser.ts
 import { spawn as spawn3 } from "node:child_process";
@@ -21347,7 +21528,7 @@ import { readFileSync as readFileSync4 } from "node:fs";
 import { dirname as dirname4, join as join5 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function cliVersion() {
-  if (true) return "0.2.4";
+  if (true) return "0.2.7";
   const here = dirname4(fileURLToPath2(import.meta.url));
   for (const candidate of [
     join5(here, "..", "..", "package.json"),
@@ -21590,7 +21771,7 @@ function swapScript(staged2, opts) {
 }
 async function findInstalledDesktopApp(opts = {}) {
   if ((opts.platform ?? process.platform) !== "darwin") return null;
-  const { readFile: readFile2 } = await import("node:fs/promises");
+  const { readFile: readFile3 } = await import("node:fs/promises");
   const { homedir: homedir3 } = await import("node:os");
   const systemApplications = opts.systemApplicationsDir ?? "/Applications";
   const home = opts.homeDir ?? homedir3();
@@ -21599,7 +21780,7 @@ async function findInstalledDesktopApp(opts = {}) {
     join6(home, "Applications", "Puddle.app")
   ]) {
     try {
-      const plist = await readFile2(join6(appPath, "Contents/Info.plist"), "utf8");
+      const plist = await readFile3(join6(appPath, "Contents/Info.plist"), "utf8");
       const match = /<key>CFBundleShortVersionString<\/key>\s*<string>([^<]+)<\/string>/.exec(
         plist
       );
@@ -21627,12 +21808,12 @@ async function desktopAppInstallPath(opts = {}) {
   return join6(userApplications, "Puddle.app");
 }
 function isDesktopAppRunning(appPath) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     const child = spawn4("/usr/bin/pgrep", ["-f", `${appPath}/Contents/MacOS/`], {
       stdio: "ignore"
     });
-    child.on("error", () => resolve5(false));
-    child.on("exit", (code) => resolve5(code === 0));
+    child.on("error", () => resolve6(false));
+    child.on("exit", (code) => resolve6(code === 0));
   });
 }
 function fileSha256(path) {
@@ -21640,12 +21821,12 @@ function fileSha256(path) {
   return pipeline(createReadStream(path), hash2).then(() => hash2.digest("hex"));
 }
 function run(command, args) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const child = spawn4(command, args, { stdio: "ignore" });
     child.on("error", reject);
     child.on(
       "exit",
-      (code) => code === 0 ? resolve5() : reject(new CliError("not_installed", `${command} exited with ${code ?? "signal"}`))
+      (code) => code === 0 ? resolve6() : reject(new CliError("not_installed", `${command} exited with ${code ?? "signal"}`))
     );
   });
 }
@@ -21724,7 +21905,10 @@ var RELEASE_PROTOCOLS = {
   "0.2.1": { major: 19, minor: 0 },
   "0.2.2": { major: 20, minor: 0 },
   "0.2.3": { major: 20, minor: 0 },
-  "0.2.4": { major: 21, minor: 2 }
+  "0.2.4": { major: 21, minor: 2 },
+  "0.2.5": { major: 21, minor: 2 },
+  "0.2.6": { major: 21, minor: 2 },
+  "0.2.7": { major: 21, minor: 3 }
 };
 function validProtocol(value) {
   if (typeof value !== "object" || value === null) return false;
@@ -21837,7 +22021,7 @@ function formatComponentVersions(components) {
 import { join as join12 } from "node:path";
 
 // src/lib/attached-daemon.ts
-import { randomUUID } from "node:crypto";
+import { randomUUID as randomUUID2 } from "node:crypto";
 
 // src/lib/bootstrap.ts
 import { existsSync as existsSync3, readFileSync as readFileSync6 } from "node:fs";
@@ -21927,22 +22111,22 @@ function readInstallScript() {
 // src/lib/net.ts
 import { connect as connect4, createServer as createServer2 } from "node:net";
 function findFreePort() {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const srv = createServer2();
     srv.once("error", reject);
     srv.listen(0, "127.0.0.1", () => {
       const address = srv.address();
       const port = typeof address === "object" && address !== null ? address.port : 0;
-      srv.close(() => resolve5(port));
+      srv.close(() => resolve6(port));
     });
   });
 }
 function tcpListening(port, timeoutMs = 500) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     const sock = connect4({ host: "127.0.0.1", port });
     const done = (ok) => {
       sock.destroy();
-      resolve5(ok);
+      resolve6(ok);
     };
     sock.setTimeout(timeoutMs, () => done(false));
     sock.once("connect", () => done(true));
@@ -21978,35 +22162,50 @@ init_types();
 async function ensureDaemon(transport, opts) {
   const logger = opts.logger ?? silentLogger;
   const startTimeoutMs = opts.startTimeoutMs ?? (opts.attachedFallback === void 0 ? 2e4 : 5e3);
+  let mismatch;
   try {
     const authority = await acquireAuthority(transport);
     return { port: authority.port, authority, bootstrapped: false, daemonLifetime: "persistent" };
   } catch (err) {
-    if (err instanceof CliError && err.code === "cli_outdated") throw err;
+    if (err instanceof CliError && err.code === "protocol_mismatch") mismatch = err;
   }
   const inspection = await inspectHost(transport).catch((err) => {
-    if (err instanceof CliError) throw err;
+    if (err instanceof CliError || mismatch) throw err;
     return null;
   });
+  if (!inspection && mismatch) throw mismatch;
+  const install = async () => {
+    await installDaemon(transport, opts);
+    return waitAfterInstall(transport, opts, logger, true, startTimeoutMs);
+  };
   if (inspection) {
-    if (inspection.version.protocol.major > PROTOCOL_VERSION.major) {
-      throw new CliError("cli_outdated", "the host uses a newer protocol; update the CLI");
-    }
-    if (opts.noUpgrade) {
-      throw new CliError(
-        "upgrade_failed",
-        `the daemon speaks protocol ${inspection.version.protocol.major} and --no-upgrade is set`,
-        "run puddle launch without --no-upgrade"
-      );
+    let replacement;
+    try {
+      await runHandshake({
+        host: transport.label,
+        inspection,
+        noUpgrade: opts.noUpgrade,
+        confirmDaemonUpgrade: opts.confirmDaemonUpgrade,
+        reinspect: () => inspectHost(transport),
+        logger,
+        upgradeDaemon: async () => {
+          replacement = await install();
+          return replacement.authority.version;
+        }
+      });
+      if (replacement) return replacement;
+      const authority = await acquireAuthority(transport);
+      return { port: authority.port, authority, bootstrapped: false, daemonLifetime: "persistent" };
+    } catch (err) {
+      replacement?.authority.close();
+      await replacement?.lease?.stop();
+      throw err;
     }
-    logger.info(
-      `updating puddled \u2014 ${inspection.liveSessions} live session(s) will be interrupted and can be resumed`
-    );
-  } else if (await installedVersion(transport) !== null) {
+  }
+  if (await installedVersion(transport) !== null) {
     logger.info(`restarting puddled on ${transport.label}`);
   }
-  await installDaemon(transport, opts);
-  return waitAfterInstall(transport, opts, logger, true, startTimeoutMs);
+  return install();
 }
 async function waitAfterInstall(transport, opts, logger, bootstrapped, timeoutMs) {
   try {
@@ -22042,7 +22241,7 @@ async function waitForStartedDaemon(transport, timeoutMs, signal) {
       }
       return { port: authority.port, authority };
     } catch (err) {
-      if (err instanceof CliError && err.code === "cli_outdated") throw err;
+      if (err instanceof CliError && err.code === "protocol_mismatch") throw err;
     }
     await sleep(500);
   }
@@ -22055,23 +22254,6 @@ function startTimeout(transport) {
     transport.kind === "ssh" ? `inspect it with: puddle logs ${transport.label}` : "inspect it with: puddle logs"
   );
 }
-function makeUpgrader(transport, client, opts, lease) {
-  return async () => {
-    await installDaemon(transport, opts);
-    await lease?.ensureRunning();
-    const fresh = await waitForStartedDaemon(transport, 3e4);
-    client.setAuthority(fresh.authority);
-    const deadline = Date.now() + 3e4;
-    while (Date.now() < deadline) {
-      if (await client.responds()) return;
-      await sleep(500);
-    }
-    throw new CliError(
-      "daemon_start_timeout",
-      `puddled did not come back after updating on ${transport.label}`
-    );
-  };
-}
 
 // src/lib/attached-daemon.ts
 init_types();
@@ -22134,7 +22316,7 @@ var AttachedDaemon = class {
   }
   async launchAndWait(preferredPort) {
     const portFlag = preferredPort === void 0 ? "" : ` --port ${preferredPort}`;
-    const leasePidPath = `${hostPaths.home}/attached-${randomUUID()}.pid`;
+    const leasePidPath = `${hostPaths.home}/attached-${randomUUID2()}.pid`;
     this.leasePidPath = leasePidPath;
     const command = this.ssh.runAttached(
       `printf '%s\\n' "$$" > ${leasePidPath}; exec ${hostPaths.current}/puddled${portFlag} >> ${hostPaths.logs}/puddled.out.log 2>&1`
@@ -22230,10 +22412,6 @@ var DaemonClient = class {
     this.port = port;
     this.authority = authority;
   }
-  setAuthority(authority) {
-    this.authority.close();
-    this.authority = authority;
-  }
   setPort(port) {
     this.port = port;
   }
@@ -22275,21 +22453,6 @@ var DaemonClient = class {
   async liveSessions() {
     return (await this.sessions()).filter((s) => LIVE.has(s.status));
   }
-  async liveSessionCount() {
-    return (await this.sessions()).filter((s) => LIVE.has(s.status)).length;
-  }
-  /** Readiness requires an authenticated response; rejection never counts as ready. */
-  async responds() {
-    try {
-      const res = await fetch(`http://127.0.0.1:${this.port}/api/version`, {
-        headers: { authorization: `Bearer ${this.authority.credential()}` },
-        signal: AbortSignal.timeout(2e3)
-      });
-      return res.ok;
-    } catch {
-      return false;
-    }
-  }
 };
 async function readDaemonPort(transport) {
   const runtime = await transport.readFile(hostPaths.runtime);
@@ -22311,51 +22474,8 @@ async function readDaemonPort(transport) {
   return 7434;
 }
 
-// src/lib/handshake.ts
-init_types();
-var CLI_UPGRADE_COMMAND = "npm install -g @puddle-code/cli";
-function decideHandshake(cli, daemon) {
-  if (daemon.major === cli.major) return { kind: "proceed" };
-  if (daemon.major < cli.major) return { kind: "upgrade-daemon" };
-  return { kind: "refuse-cli-outdated", command: CLI_UPGRADE_COMMAND };
-}
-async function runHandshake(opts) {
-  const logger = opts.logger ?? silentLogger;
-  const daemon = await opts.client.version();
-  const decision = decideHandshake(PROTOCOL_VERSION, daemon.protocol);
-  if (decision.kind === "proceed") return daemon;
-  if (decision.kind === "refuse-cli-outdated") {
-    throw new CliError(
-      "cli_outdated",
-      `the daemon speaks protocol ${daemon.protocol.major}; this CLI speaks ${PROTOCOL_VERSION.major}`,
-      `update the CLI: ${decision.command}`
-    );
-  }
-  const liveSessions = await opts.client.liveSessionCount().catch(() => 0);
-  if (opts.noUpgrade) {
-    throw new CliError(
-      "upgrade_failed",
-      `the daemon speaks protocol ${daemon.protocol.major} (CLI: ${PROTOCOL_VERSION.major}) and --no-upgrade is set`,
-      `re-run without --no-upgrade to update it (${liveSessions} live session(s) would be interrupted and can be resumed)`
-    );
-  }
-  logger.info(
-    `updating puddled (protocol ${daemon.protocol.major} \u2192 ${PROTOCOL_VERSION.major}) \u2014 ${liveSessions} live session(s) will be interrupted and can be resumed`
-  );
-  await opts.upgradeDaemon({ from: daemon.version, liveSessions });
-  const after = await opts.client.version();
-  if (after.protocol.major !== PROTOCOL_VERSION.major) {
-    throw new CliError(
-      "upgrade_failed",
-      `the daemon still speaks protocol ${after.protocol.major} after updating`,
-      "inspect the daemon logs: puddle logs"
-    );
-  }
-  return after;
-}
-
 // src/lib/serve/ui-server.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 import { createServer as createServer3 } from "node:http";
 
 // src/lib/auth/launcher.ts
@@ -22391,7 +22511,7 @@ async function startLauncher(home, identity, invite) {
     path,
     close: async () => {
       for (const socket of sockets) socket.destroy();
-      await new Promise((resolve5) => server.close(() => resolve5()));
+      await new Promise((resolve6) => server.close(() => resolve6()));
     }
   };
 }
@@ -22401,14 +22521,14 @@ async function requestInvitation(home, path) {
     const stored = readPrivateJson(secretFile(home, path));
     pipeSecret = stored.secret;
   } else privatePath(path);
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     const socket = connect5(path);
     socket.setTimeout(5e3, () => socket.destroy(new Error("Launcher did not answer")));
     jsonLines(
       socket,
       (value) => {
         const message = launcherResponseSchema.parse(value);
-        resolve5(message.url);
+        resolve6(message.url);
         socket.end();
       },
       () => socket.destroy(new Error("Invalid launcher reply"))
@@ -22628,7 +22748,7 @@ function writeStore(file2, store) {
   renameSync3(tmp, file2);
 }
 function readBody(req) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     let size = 0;
     const chunks = [];
     req.on("data", (chunk) => {
@@ -22640,7 +22760,7 @@ function readBody(req) {
       }
       chunks.push(chunk);
     });
-    req.on("end", () => resolve5(Buffer.concat(chunks).toString("utf8")));
+    req.on("end", () => resolve6(Buffer.concat(chunks).toString("utf8")));
     req.on("error", reject);
   });
 }
@@ -23227,7 +23347,7 @@ async function startUiServer(opts) {
   const tracker = new ProxySocketTracker();
   const serveStatic = createStaticHandler(opts.assetsDir);
   const handleRemoteAccess = remoteAccessHandler(opts.remoteAccess);
-  const nonce = randomUUID2();
+  const nonce = randomUUID3();
   let origin = "";
   let proxyOrigin = "";
   let browsers;
@@ -23365,8 +23485,8 @@ async function startUiServer(opts) {
       browsers.close();
       bridge.close();
       tracker.destroyAll();
-      await new Promise((resolve5) => {
-        server.close(() => resolve5());
+      await new Promise((resolve6) => {
+        server.close(() => resolve6());
         server.closeAllConnections();
       });
     }
@@ -23376,15 +23496,15 @@ async function listen(server, startPort, strict, avoidPort) {
   for (let probe = 0; probe < MAX_PORT_PROBES; probe += 1) {
     const port = startPort + probe;
     if (!strict && port === avoidPort) continue;
-    const ok = await new Promise((resolve5, rejectListen) => {
+    const ok = await new Promise((resolve6, rejectListen) => {
       const onError = (err) => {
         server.off("listening", onListening);
-        if (err.code === "EADDRINUSE") resolve5(false);
+        if (err.code === "EADDRINUSE") resolve6(false);
         else rejectListen(err);
       };
       const onListening = () => {
         server.off("error", onError);
-        resolve5(true);
+        resolve6(true);
       };
       server.once("error", onError);
       server.once("listening", onListening);
@@ -23665,7 +23785,12 @@ async function connectRemote(opts) {
   let uiResource;
   let endpointResource;
   try {
-    const bootstrap = { tarball: opts.tarball, logger, noUpgrade: opts.noUpgrade };
+    const bootstrap = {
+      tarball: opts.tarball,
+      logger,
+      noUpgrade: opts.noUpgrade,
+      confirmDaemonUpgrade: opts.confirmDaemonUpgrade
+    };
     const attachedDaemon = new AttachedDaemon(ssh, logger);
     const endpoint = await ensureDaemon(ssh, {
       ...bootstrap,
@@ -23706,12 +23831,7 @@ async function connectRemote(opts) {
       logger
     });
     oauthForwardResource = oauthForward;
-    const daemon = await runHandshake({
-      client,
-      noUpgrade: opts.noUpgrade,
-      upgradeDaemon: makeUpgrader(ssh, client, bootstrap, endpoint.lease),
-      logger
-    });
+    const daemon = verifyDaemonVersion(await client.version());
     const avoidPort = await readDaemonPort(new LocalTransport());
     endpoint.authority.setVerifier(async () => {
       const generation = endpoint.authority.generation;
@@ -23734,7 +23854,7 @@ async function connectRemote(opts) {
         watchTunnel(replacement);
         await previous?.close();
       }
-      await client.version();
+      verifyDaemonVersion(await client.version());
     });
     const ui = await startUiServer({
       authority: endpoint.authority,
@@ -23936,24 +24056,26 @@ init_types();
 async function startLocal(opts) {
   const logger = opts.logger ?? silentLogger;
   const transport = new LocalTransport();
-  const bootstrap = { tarball: opts.tarball, logger, noUpgrade: opts.noUpgrade };
-  const endpoint = await ensureDaemon(transport, bootstrap);
+  const bootstrap = {
+    tarball: opts.tarball,
+    logger,
+    noUpgrade: opts.noUpgrade,
+    confirmDaemonUpgrade: opts.confirmDaemonUpgrade
+  };
+  let endpoint;
   try {
-    const client = new DaemonClient(endpoint.port, endpoint.authority);
-    const daemon = await runHandshake({
-      client,
-      noUpgrade: opts.noUpgrade,
-      upgradeDaemon: makeUpgrader(transport, client, bootstrap),
-      logger
-    });
+    endpoint = await ensureDaemon(transport, bootstrap);
+    const authority = endpoint.authority;
+    const client = new DaemonClient(endpoint.port, authority);
+    const daemon = verifyDaemonVersion(await client.version());
     let currentUi = void 0;
-    endpoint.authority.setVerifier(async () => {
-      client.setPort(endpoint.authority.port);
-      await client.version();
-      currentUi?.setTarget({ host: "127.0.0.1", port: endpoint.authority.port });
+    authority.setVerifier(async () => {
+      client.setPort(authority.port);
+      verifyDaemonVersion(await client.version());
+      currentUi?.setTarget({ host: "127.0.0.1", port: authority.port });
     });
     const ui = await startUiServer({
-      authority: endpoint.authority,
+      authority,
       identity: "local",
       refreshId: opts.refreshId,
       assetsDir: opts.assetsDir,
@@ -23982,12 +24104,12 @@ async function startLocal(opts) {
       },
       async stop() {
         await ui.close();
-        endpoint.authority.close();
+        authority.close();
         transport.dispose();
       }
     };
   } catch (err) {
-    endpoint.authority.close();
+    endpoint?.authority.close();
     transport.dispose();
     throw err;
   }
@@ -24017,12 +24139,170 @@ async function statusReport(client) {
 // src/cli/run.ts
 init_types();
 
-// src/cli/manage.ts
+// src/cli/manage-cli.ts
+init_types();
 import { spawn as spawn7 } from "node:child_process";
-import { existsSync as existsSync5 } from "node:fs";
-import { chmod as chmod2, copyFile, mkdir as mkdir2, rename, rm as rm2 } from "node:fs/promises";
+import { dirname as dirname10 } from "node:path";
+
+// src/lib/standalone-cli.ts
+init_types();
+import { spawn as spawn6 } from "node:child_process";
+import { existsSync as existsSync5, lstatSync as lstatSync2, readFileSync as readFileSync9, realpathSync as realpathSync2 } from "node:fs";
+import { mkdir as mkdir2, readFile as readFile2, rm as rm2, unlink } from "node:fs/promises";
+import { dirname as dirname9, isAbsolute, join as join15, resolve as resolve5 } from "node:path";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
+function standaloneInstallation(entryFile = fileURLToPath4(import.meta.url), execPath = process.execPath) {
+  const release = resolve5(dirname9(entryFile), "..");
+  if (!existsSync5(join15(release, "STANDALONE"))) return null;
+  try {
+    const root = resolve5(release, "..", "..");
+    const record2 = JSON.parse(readFileSync9(join15(root, "installation.json"), "utf8"));
+    if (readFileSync9(join15(release, "STANDALONE"), "utf8").trim() !== "puddle-cli" || readFileSync9(join15(root, "INSTALLATION"), "utf8").trim() !== "puddle-cli" || dirname9(release) !== join15(root, "versions") || realpathSync2(release) !== release || realpathSync2(execPath) !== join15(release, "bin/node") || record2.kind !== "puddle-cli" || typeof record2.launcher !== "string" || !isAbsolute(record2.launcher))
+      throw new Error("Installation metadata does not match this CLI");
+    return { root, release, launcher: record2.launcher };
+  } catch {
+    throw new CliError(
+      "not_installed",
+      "this standalone archive is not an installer-managed CLI",
+      "run the public install.sh to install the CLI before using upgrade or remove"
+    );
+  }
+}
+function upgradeStandaloneCli(installation, version2, repo) {
+  const script = readFileSync9(join15(installation.release, "cli/install-cli.sh"), "utf8");
+  const args = [
+    "-s",
+    "--",
+    "--prefix",
+    installation.root,
+    "--bin-dir",
+    dirname9(installation.launcher)
+  ];
+  if (version2 !== void 0) args.push("--version", version2);
+  if (repo !== void 0) args.push("--repo", repo);
+  return new Promise((resolve6, reject) => {
+    const child = spawn6("sh", args, { stdio: ["pipe", "inherit", "inherit"] });
+    child.on("error", reject);
+    child.stdin.on("error", (error51) => {
+      if (error51.code !== "EPIPE") reject(error51);
+    });
+    child.stdin.end(script);
+    child.on("exit", (code) => {
+      if (code === 0) resolve6(0);
+      else reject(new CliError("not_installed", `CLI installer exited with ${code ?? "a signal"}`));
+    });
+  });
+}
+function standaloneLauncher(root) {
+  const quoted = `'${join15(root, "current/puddle").replaceAll("'", "'\\''")}'`;
+  return `#!/bin/sh
+# puddle standalone launcher
+exec ${quoted} "$@"
+`;
+}
+async function removeStandaloneCli(installation) {
+  const lock = join15(installation.root, ".install-lock");
+  try {
+    await mkdir2(lock);
+  } catch {
+    throw new CliError("already_running", "another CLI installation operation is running");
+  }
+  try {
+    if (lstatSync2(installation.launcher).isSymbolicLink() || await readFile2(installation.launcher, "utf8") !== standaloneLauncher(installation.root))
+      throw new CliError("not_installed", "the CLI launcher was replaced; refusing removal");
+    await unlink(installation.launcher);
+    await rm2(installation.root, { recursive: true, force: true });
+  } finally {
+    await rm2(lock, { recursive: true, force: true });
+  }
+}
+
+// src/cli/manage-cli.ts
+function upgradeCli(version2, logger) {
+  const standalone = standaloneInstallation();
+  if (standalone) {
+    logger.info(`upgrading standalone CLI ${cliVersion()} to ${version2 ?? "the latest release"}`);
+    return upgradeStandaloneCli(standalone, version2, repoSlug());
+  }
+  const spec = `@puddle-code/cli@${version2 ?? "latest"}`;
+  logger.info(`puddle CLI ${cliVersion()} \u2014 asking npm for ${version2 ?? "the latest release"}`);
+  return new Promise((resolve6, reject) => {
+    const child = spawn7("npm", ["install", "-g", spec], { stdio: "inherit" });
+    child.on(
+      "error",
+      () => reject(
+        new CliError(
+          "not_installed",
+          "npm is not on PATH",
+          `the CLI is installed and upgraded via npm: npm install -g ${spec}`
+        )
+      )
+    );
+    child.on("exit", (code) => {
+      if (code === 0) {
+        logger.info("done \u2014 `puddle --version` shows the installed version");
+        resolve6(0);
+      } else {
+        reject(new CliError("not_installed", `npm install exited with ${code ?? "a signal"}`));
+      }
+    });
+  });
+}
+async function removeCli(yes, logger) {
+  const standalone = standaloneInstallation();
+  if (standalone) {
+    const proceed2 = await confirm(
+      `Remove the standalone CLI at ${standalone.root} and its launcher in ${dirname10(standalone.launcher)}? Close its cockpits first; daemons and their sessions are untouched.`,
+      { skip: yes }
+    );
+    if (!proceed2) {
+      logger.info("nothing removed");
+      return 0;
+    }
+    await removeStandaloneCli(standalone);
+    logger.info("removed the standalone CLI \u2014 daemon installations and data are untouched");
+    return 0;
+  }
+  const managed = await new Promise((resolve6) => {
+    const child = spawn7("npm", ["ls", "-g", "@puddle-code/cli", "--depth=0"], { stdio: "ignore" });
+    child.on("error", () => resolve6(false));
+    child.on("exit", (code) => resolve6(code === 0));
+  });
+  if (!managed) {
+    throw new CliError(
+      "not_installed",
+      "the puddle CLI is not an npm global install on this machine",
+      "a repo checkout or linked dev build is removed the way it was installed"
+    );
+  }
+  const proceed = await confirm(
+    `Remove the puddle CLI (npm uninstall -g @puddle-code/cli)? Running cockpits keep running until killed; daemons and their sessions are untouched.`,
+    { skip: yes }
+  );
+  if (!proceed) {
+    logger.info("nothing removed");
+    return 0;
+  }
+  return new Promise((resolve6, reject) => {
+    const child = spawn7("npm", ["uninstall", "-g", "@puddle-code/cli"], { stdio: "inherit" });
+    child.on("error", () => reject(new CliError("not_installed", "npm is not on PATH")));
+    child.on("exit", (code) => {
+      if (code === 0) {
+        logger.info("removed \u2014 daemons keep running (puddle remove daemon uninstalls one)");
+        resolve6(0);
+      } else {
+        reject(new CliError("not_installed", `npm uninstall exited with ${code ?? "a signal"}`));
+      }
+    });
+  });
+}
+
+// src/cli/manage.ts
+import { spawn as spawn9 } from "node:child_process";
+import { existsSync as existsSync6 } from "node:fs";
+import { chmod as chmod2, copyFile, mkdir as mkdir3, rename, rm as rm3 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 
 // src/lib/releases.ts
 init_types();
@@ -24155,9 +24435,9 @@ async function upgradeDaemon(transport, opts = {}) {
 }
 
 // src/cli/detach.ts
-import { spawn as spawn6 } from "node:child_process";
-import { closeSync as closeSync2, mkdirSync as mkdirSync6, openSync as openSync2, readFileSync as readFileSync9 } from "node:fs";
-import { dirname as dirname9 } from "node:path";
+import { spawn as spawn8 } from "node:child_process";
+import { closeSync as closeSync2, mkdirSync as mkdirSync6, openSync as openSync2, readFileSync as readFileSync10 } from "node:fs";
+import { dirname as dirname11 } from "node:path";
 init_types();
 var COCKPIT_CHILD_ENV = "PUDDLE_COCKPIT_CHILD";
 var READY_TIMEOUT_MS = 3e5;
@@ -24196,12 +24476,12 @@ async function launchDetached(opts) {
   }
   if (target !== "local") await new SshTransport(target).open();
   const logFile = cockpitLogPath(target);
-  mkdirSync6(dirname9(logFile), { recursive: true });
+  mkdirSync6(dirname11(logFile), { recursive: true });
   const fd = openSync2(logFile, "w");
   const argv = opts.argv ?? process.argv.slice(2);
-  const child = spawn6(process.execPath, [process.argv[1] ?? "", ...argv], {
+  const child = spawn8(process.execPath, [process.argv[1] ?? "", ...argv], {
     detached: true,
-    stdio: ["ignore", fd, fd],
+    stdio: ["ignore", fd, fd, "ipc"],
     env: { ...process.env, [COCKPIT_CHILD_ENV]: "1" }
   });
   closeSync2(fd);
@@ -24210,7 +24490,13 @@ async function launchDetached(opts) {
     throw new CliError("cockpit_launch_failed", "could not spawn the background cockpit process");
   }
   logger.info(`starting the cockpit for ${target} in the background\u2026`);
-  const record2 = await followStartup(target, child.pid, logFile);
+  const stopPromptRelay = relayDaemonUpgradePrompt(child);
+  let record2;
+  try {
+    record2 = await followStartup(target, child.pid, logFile);
+  } finally {
+    stopPromptRelay();
+  }
   if (record2 === null || record2.status !== "ready") {
     if (record2?.status === "error") {
       logger.warn(record2.message ?? "the cockpit failed to start");
@@ -24233,7 +24519,7 @@ async function followStartup(target, childPid, logFile) {
   let offset = 0;
   const relay = () => {
     try {
-      const buf = readFileSync9(logFile);
+      const buf = readFileSync10(logFile);
       if (buf.length > offset) {
         process.stderr.write(buf.subarray(offset));
         offset = buf.length;
@@ -24258,7 +24544,7 @@ async function followStartup(target, childPid, logFile) {
 }
 function spawnDetachedRefresh(target, argv, refreshId) {
   const logFile = cockpitLogPath(target);
-  mkdirSync6(dirname9(logFile), { recursive: true });
+  mkdirSync6(dirname11(logFile), { recursive: true });
   const fd = openSync2(logFile, "a");
   const env = {
     ...process.env,
@@ -24266,7 +24552,7 @@ function spawnDetachedRefresh(target, argv, refreshId) {
     PUDDLE_INTERNAL_REFRESH: "1"
   };
   delete env[COCKPIT_CHILD_ENV];
-  const child = spawn6(process.execPath, [process.argv[1] ?? "", ...argv], {
+  const child = spawn8(process.execPath, [process.argv[1] ?? "", ...argv], {
     detached: true,
     stdio: ["ignore", fd, fd],
     env
@@ -24299,41 +24585,6 @@ async function presentInvitation(record2, noBrowser, logger) {
   else openBrowser(url2);
 }
 
-// src/cli/prompt.ts
-init_types();
-import { createInterface as createInterface2 } from "node:readline";
-async function ask(question, def) {
-  if (!process.stdin.isTTY || !process.stdout.isTTY) return def;
-  const rl = createInterface2({ input: process.stdin, output: process.stdout });
-  try {
-    const answer = await new Promise(
-      (resolve5) => rl.question(`${question} [${def}] `, resolve5)
-    );
-    return answer.trim() === "" ? def : answer.trim();
-  } finally {
-    rl.close();
-  }
-}
-async function confirm(question, opts = {}) {
-  if (opts.skip === true) return true;
-  if (!process.stdin.isTTY || !process.stdout.isTTY) {
-    throw new CliError(
-      "bad_arguments",
-      "refusing to confirm without a terminal",
-      "pass --yes to proceed non-interactively"
-    );
-  }
-  const rl = createInterface2({ input: process.stdin, output: process.stdout });
-  try {
-    const answer = await new Promise(
-      (resolve5) => rl.question(`${question} [y/N] `, resolve5)
-    );
-    return /^y(es)?$/i.test(answer.trim());
-  } finally {
-    rl.close();
-  }
-}
-
 // src/cli/manage.ts
 function assertLocal(what, host, verb) {
   if (host === void 0 || host === "local") return;
@@ -24442,31 +24693,6 @@ async function runUpgrade(cmd, logger) {
   else if (process.platform === "darwin") logger.info("no desktop app installed \u2014 skipping");
   return upgradeCli(cmd.version, logger);
 }
-function upgradeCli(version2, logger) {
-  const spec = `@puddle-code/cli@${version2 ?? "latest"}`;
-  logger.info(`puddle CLI ${cliVersion()} \u2014 asking npm for ${version2 ?? "the latest release"}`);
-  return new Promise((resolve5, reject) => {
-    const child = spawn7("npm", ["install", "-g", spec], { stdio: "inherit" });
-    child.on(
-      "error",
-      () => reject(
-        new CliError(
-          "not_installed",
-          "npm is not on PATH",
-          `the CLI is installed and upgraded via npm: npm install -g ${spec}`
-        )
-      )
-    );
-    child.on("exit", (code) => {
-      if (code === 0) {
-        logger.info("done \u2014 `puddle --version` shows the installed version");
-        resolve5(0);
-      } else {
-        reject(new CliError("not_installed", `npm install exited with ${code ?? "a signal"}`));
-      }
-    });
-  });
-}
 async function setDesktop(opts, logger) {
   if (process.platform === "linux") {
     if (opts.verb !== "install") {
@@ -24538,22 +24764,22 @@ async function installDesktopAppImage(version2, logger) {
     );
   }
   const dir = expandHome2(await ask("Where should the AppImage be stored?", "~/puddle"));
-  const target = join15(dir, "Puddle.AppImage");
-  if (existsSync5(target) && version2 === void 0) {
+  const target = join16(dir, "Puddle.AppImage");
+  if (existsSync6(target) && version2 === void 0) {
     logger.info(`${target} already exists \u2014 the app updates itself in-app (its update toast)`);
     return 0;
   }
   logger.info(`installing Puddle ${update.version} to ${target}`);
   const staged2 = await stageDesktopUpdate(update, { logger });
-  await mkdir2(dir, { recursive: true });
-  await rm2(target, { force: true });
+  await mkdir3(dir, { recursive: true });
+  await rm3(target, { force: true });
   try {
     await rename(staged2.stagedPath, target);
   } catch {
     await copyFile(staged2.stagedPath, target);
     await chmod2(target, 493);
   }
-  await rm2(staged2.dir, { recursive: true, force: true });
+  await rm3(staged2.dir, { recursive: true, force: true });
   const protocol = componentProtocolForVersion(update.version);
   recordDesktopInstallation({
     path: target,
@@ -24561,14 +24787,14 @@ async function installDesktopAppImage(version2, logger) {
     ...protocol ? { protocol } : {}
   });
   logger.info(`installed \u2014 run it directly (${target}) or add it to your launcher`);
-  const opener = spawn7("xdg-open", [dir], { stdio: "ignore", detached: true });
+  const opener = spawn9("xdg-open", [dir], { stdio: "ignore", detached: true });
   opener.on("error", () => void 0);
   opener.unref();
   return 0;
 }
 function expandHome2(path) {
   if (path === "~") return homedir2();
-  return path.startsWith("~/") ? join15(homedir2(), path.slice(2)) : path;
+  return path.startsWith("~/") ? join16(homedir2(), path.slice(2)) : path;
 }
 async function runRemove(cmd, logger) {
   switch (cmd.what) {
@@ -24582,40 +24808,6 @@ async function runRemove(cmd, logger) {
       return removeDaemonCmd(cmd, logger);
   }
 }
-async function removeCli(yes, logger) {
-  const managed = await new Promise((resolve5) => {
-    const child = spawn7("npm", ["ls", "-g", "@puddle-code/cli", "--depth=0"], { stdio: "ignore" });
-    child.on("error", () => resolve5(false));
-    child.on("exit", (code) => resolve5(code === 0));
-  });
-  if (!managed) {
-    throw new CliError(
-      "not_installed",
-      "the puddle CLI is not an npm global install on this machine",
-      "a repo checkout or linked dev build is removed the way it was installed"
-    );
-  }
-  const proceed = await confirm(
-    `Remove the puddle CLI (npm uninstall -g @puddle-code/cli)? Running cockpits keep running until killed; daemons and their sessions are untouched.`,
-    { skip: yes }
-  );
-  if (!proceed) {
-    logger.info("nothing removed");
-    return 0;
-  }
-  return new Promise((resolve5, reject) => {
-    const child = spawn7("npm", ["uninstall", "-g", "@puddle-code/cli"], { stdio: "inherit" });
-    child.on("error", () => reject(new CliError("not_installed", "npm is not on PATH")));
-    child.on("exit", (code) => {
-      if (code === 0) {
-        logger.info("removed \u2014 daemons keep running (puddle remove daemon uninstalls one)");
-        resolve5(0);
-      } else {
-        reject(new CliError("not_installed", `npm uninstall exited with ${code ?? "a signal"}`));
-      }
-    });
-  });
-}
 async function removeDesktop(yes, logger) {
   if (process.platform !== "darwin") {
     throw new CliError(
@@ -24640,7 +24832,7 @@ async function removeDesktop(yes, logger) {
     logger.info("nothing removed");
     return 0;
   }
-  await rm2(installed.appPath, { recursive: true, force: true });
+  await rm3(installed.appPath, { recursive: true, force: true });
   await pruneDesktopUpdateCache([]);
   logger.info(`deleted ${installed.appPath} (recent hosts kept in ~/.puddle/recent-hosts.json)`);
   return 0;
@@ -24762,9 +24954,9 @@ function timestampedLogger() {
 
 // src/cli/run.ts
 function assetsDir() {
-  const here = dirname10(fileURLToPath4(import.meta.url));
-  for (const candidate of [join16(here, "public"), join16(here, "..", "..", "dist", "public")]) {
-    if (existsSync6(join16(candidate, "index.html"))) return candidate;
+  const here = dirname12(fileURLToPath5(import.meta.url));
+  for (const candidate of [join17(here, "public"), join17(here, "..", "..", "dist", "public")]) {
+    if (existsSync7(join17(candidate, "index.html"))) return candidate;
   }
   throw new CliError(
     "not_installed",
@@ -24798,7 +24990,7 @@ async function openTarget(host) {
   };
 }
 function runUntilInterrupted(stop, farewell) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     let stopping = false;
     process.on("SIGINT", () => {
       if (stopping) process.exit(130);
@@ -24806,10 +24998,10 @@ function runUntilInterrupted(stop, farewell) {
       process.stderr.write(`
 ${farewell}
 `);
-      void stop().then(resolve5);
+      void stop().then(resolve6);
     });
     process.on("SIGTERM", () => {
-      void stop().then(resolve5);
+      void stop().then(resolve6);
     });
   });
 }
@@ -25097,6 +25289,7 @@ async function runCockpit(command, target, terminal) {
     const common = {
       ...command,
       assetsDir: assetsDir(),
+      confirmDaemonUpgrade,
       logger,
       onRefreshRequest,
       refreshId: process.env.PUDDLE_REFRESH_ID