@meistrari/remy-cli 1.20.0 → 1.21.0-rc.0

package/README.md

@@ -36,6 +36,16 @@ remy
 
 On first use, Remy opens browser-based device authorization, validates your Coding Agent identity, and opens the session dashboard. Later, the same command takes you straight to that dashboard.
 
+## Update Remy
+
+Run `remy update` to install a newer CLI release using the package manager that owns your installation (mise, Bun, pnpm, or npm). No sign-in is required. Use `remy --version` to print the installed version.
+
+Stable versions check npm’s `latest` channel. Release candidates check both `rc` and `latest` and choose the newer version; Remy never downgrades. To switch from stable to RC, use the explicit `@rc` install command above.
+
+Each interactive `remy` or `remy dashboard` startup checks for an update before sign-in or the splash. When one is available, type `y` or `yes`, then Enter, to upgrade. Press Enter or type `n` to continue with the current version. Lookup failures or a two-second timeout let startup continue. After a successful upgrade, Remy exits and asks you to run it again. Installation failures exit with an error so you can resolve the package-manager problem and retry.
+
+Help, version, sign-in/out, direct session commands, and redirected/noninteractive invocations do not run startup checks or prompt. Development checkouts skip checks; local project and temporary `bunx`/`npx` installations must be updated through their original caller. Remy refuses to install if it cannot identify the owning manager.
+
 ## Your everyday workflow
 
 The dashboard is the starting point for all interactive work. It refreshes the visible session page every 10 seconds, so new sessions and status changes appear while you keep it open. If an update fails, Remy keeps showing the last successful list and retries on the next interval.
@@ -187,6 +197,8 @@ remy help | --help | -h
 remy login [--env production|staging] [--api-url <url> --auth-api-url <url> --requester-application-id <uuid> --target-application-id <uuid>]
 remy logout [--api-url <url>]
 remy whoami
+remy update
+remy --version | -v
 remy dashboard
 remy new [--repository <owner/name> ... --installation <id> --model <name> --reasoning-effort <low|medium|high|xhigh> --attach <path> ... --no-tui --json] <prompt>
 remy --session <session-id> [--no-tui] [--json] [prompt]

package/dist/remy.js

@@ -17,10 +17,10 @@ var __export = (target, all) => {
 
 // src/commands.ts
 import { randomUUID as randomUUID5 } from "crypto";
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 import { mkdir as mkdir6, readFile as readFile5, readdir as readdir3, rename as rename4, unlink as unlink3, writeFile as writeFile4 } from "fs/promises";
 import { homedir as homedir3, tmpdir as tmpdir2 } from "os";
-import { dirname as dirname6, join as join7 } from "path";
+import { dirname as dirname6, join as join8 } from "path";
 
 // ../../node_modules/.bun/@meistrari+auth-cli@1.6.1+aff0271b2b55d60c/node_modules/@meistrari/auth-cli/dist/index.mjs
 import { setTimeout as setTimeout2 } from "timers/promises";
@@ -34234,6 +34234,141 @@ function formatSessionJson({
   })}
 `;
 }
+// src/version.ts
+var remyCliVersion = "1.21.0-rc.0";
+
+// src/self-update.ts
+import { spawn } from "child_process";
+import { realpath } from "fs/promises";
+import { join as join3, relative, isAbsolute } from "path";
+import { createInterface } from "readline/promises";
+var {semver } = globalThis.Bun;
+var packageName = "@meistrari/remy-cli";
+var versionSchema = exports_external2.string().regex(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-rc\.(0|[1-9]\d*))?$/);
+var tagsSchema = exports_external2.object({ latest: versionSchema, rc: versionSchema.optional() });
+function createCliUpdates({
+  currentVersion,
+  entryPath,
+  fetchClient,
+  runProcess,
+  confirm
+}) {
+  return {
+    currentVersion,
+    confirm,
+    async check(signal) {
+      if (currentVersion === "0.0.0")
+        return null;
+      const response = await fetchClient(`https://registry.npmjs.org/-/package/${encodeURIComponent(packageName)}/dist-tags`, {
+        signal: AbortSignal.any([signal, AbortSignal.timeout(2000)]),
+        headers: { accept: "application/json" }
+      });
+      if (!response.ok)
+        throw new Error(`Cannot check Remy releases (HTTP ${response.status}).`);
+      const tags = tagsSchema.parse(await response.json());
+      const latest = currentVersion.includes("-rc.") && tags.rc && semver.order(tags.rc, tags.latest) > 0 ? tags.rc : tags.latest;
+      return semver.order(latest, currentVersion) > 0 ? latest : null;
+    },
+    async install(version5, signal) {
+      versionSchema.parse(version5);
+      if (currentVersion === "0.0.0")
+        throw new Error("This is a development checkout. Update the checkout instead of running remy update.");
+      const runningEntry = await realpath(entryPath);
+      const probeSignal = AbortSignal.any([signal, AbortSignal.timeout(5000)]);
+      const probe = async (argv2) => {
+        try {
+          const result2 = await runProcess({ argv: argv2, signal: probeSignal, display: false });
+          return result2.exitCode === 0 ? result2.stdout.trim() : "";
+        } catch {
+          signal.throwIfAborted();
+          return "";
+        }
+      };
+      const matchesEntry = async (candidate) => {
+        try {
+          return await realpath(candidate) === runningEntry;
+        } catch {
+          return false;
+        }
+      };
+      let argv;
+      let updatedEntry = runningEntry;
+      const miseRoot = await probe(["mise", "where", `npm:${packageName}@${currentVersion}`]);
+      const miseRelative = miseRoot ? relative(miseRoot, runningEntry) : "";
+      const usesMise = miseRoot !== "" && miseRelative !== "" && !miseRelative.startsWith("..") && !isAbsolute(miseRelative);
+      if (usesMise) {
+        argv = ["mise", "upgrade", `npm:${packageName}@${version5}`, "--bump", "--no-prune"];
+      } else {
+        const bunBin = await probe(["bun", "pm", "bin", "-g"]);
+        if (bunBin && await matchesEntry(join3(bunBin, "remy"))) {
+          argv = ["bun", "add", "--global", `${packageName}@${version5}`];
+          updatedEntry = join3(bunBin, "remy");
+        }
+        for (const manager of ["pnpm", "npm"]) {
+          if (argv)
+            break;
+          const root = await probe([manager, "root", "--global"]);
+          const candidate = join3(root, packageName, "dist", "remy.js");
+          if (root && await matchesEntry(candidate)) {
+            argv = [manager, "install", "--global", `${packageName}@${version5}`];
+            updatedEntry = candidate;
+          }
+        }
+      }
+      signal.throwIfAborted();
+      if (!argv)
+        throw new Error("Cannot identify the manager for this Remy installation. Reinstall @meistrari/remy-cli with the manager you originally used (mise, bun, pnpm, or npm). Local and temporary bunx/npx installs must be updated by their caller.");
+      const result = await runProcess({ argv, signal, display: true });
+      if (result.exitCode !== 0)
+        throw new Error(`Remy update failed: ${argv[0]} exited with code ${result.exitCode}. Resolve the package manager error and retry remy update.`);
+      if (usesMise) {
+        const located = await runProcess({ argv: ["mise", "where", `npm:${packageName}@${version5}`], signal, display: false });
+        if (located.exitCode !== 0 || !located.stdout.trim())
+          throw new Error("Update finished but the new mise installation could not be located. Check remy --version before retrying.");
+        updatedEntry = join3(located.stdout.trim(), miseRelative);
+      }
+      const verified = await runProcess({ argv: [process.execPath, updatedEntry, "--version"], signal, display: false });
+      if (verified.exitCode !== 0 || verified.stdout.trim() !== version5)
+        throw new Error("The package manager finished, but the installed Remy version could not be verified. Check remy --version before retrying.");
+    }
+  };
+}
+var runUpdateProcess = async ({ argv, signal, display }) => {
+  signal.throwIfAborted();
+  return await new Promise((resolve, reject) => {
+    const [executable, ...args] = argv;
+    if (!executable) {
+      reject(new Error("Missing update executable."));
+      return;
+    }
+    const child = spawn(executable, args, { signal, stdio: ["ignore", "pipe", display ? "inherit" : "ignore"] });
+    let stdout = "";
+    child.stdout?.on("data", (chunk) => {
+      if (display)
+        process.stderr.write(chunk);
+      else
+        stdout += chunk.toString();
+    });
+    child.on("error", reject);
+    child.on("close", (code) => resolve({ exitCode: code ?? 1, stdout }));
+  });
+};
+async function confirmCliUpdate({ version: version5, signal, interrupt }) {
+  const prompt = createInterface({ input: process.stdin, output: process.stderr });
+  prompt.once("SIGINT", interrupt);
+  const closed = new Promise((resolve) => prompt.once("close", () => resolve("")));
+  try {
+    const answer = await Promise.race([
+      prompt.question(`Remy ${version5} is available. Upgrade now? [y/N] `, { signal }),
+      closed
+    ]);
+    signal.throwIfAborted();
+    return /^y(?:es)?$/i.test(answer.trim());
+  } finally {
+    prompt.close();
+    process.stdin.pause();
+  }
+}
 
 // src/session-agent-options.ts
 function newSessionModelLabel(model) {
@@ -34252,7 +34387,7 @@ var defaultNewSessionAgent = {
 // src/sessions/session-controller.ts
 import { randomUUID as randomUUID3 } from "crypto";
 import { mkdir as mkdir4, readFile as readFile4, rename as rename3, writeFile as writeFile2 } from "fs/promises";
-import { dirname as dirname4, join as join3 } from "path";
+import { dirname as dirname4, join as join4 } from "path";
 
 // ../../packages/supervisor-protocol/src/agent-event-wrapper.ts
 var wrappedSessionStartedAgentEventSchema = sessionStartedAgentEventSchema.extend({
@@ -36103,7 +36238,7 @@ function resolveSessionCachePath({
   sessionId
 }) {
   const stateBase = resolveStateBase(environment);
-  return join3(stateBase, "remy", "sessions", `${sessionId}.json`);
+  return join4(stateBase, "remy", "sessions", `${sessionId}.json`);
 }
 async function readSessionCache(path) {
   try {
@@ -36121,7 +36256,7 @@ async function writeSessionCache({
 }) {
   const directory = dirname4(path);
   await mkdir4(directory, { recursive: true, mode: 448 });
-  const temporaryPath = join3(directory, `.session.${process.pid}.${randomUUID3()}.tmp`);
+  const temporaryPath = join4(directory, `.session.${process.pid}.${randomUUID3()}.tmp`);
   await writeFile2(temporaryPath, `${JSON.stringify(cache, null, 4)}
 `, { mode: 384 });
   await rename3(temporaryPath, path);
@@ -36140,7 +36275,7 @@ function resolveStateBase(environment) {
   }
   if (!environment.HOME)
     throw new Error("HOME is required when XDG_STATE_HOME is not set; refusing to write Remy session cache in the current directory.");
-  return join3(environment.HOME, ".local/state");
+  return join4(environment.HOME, ".local/state");
 }
 function isMissingFileError2(error93) {
   return error93 instanceof Error && "code" in error93 && error93.code === "ENOENT";
@@ -36159,7 +36294,7 @@ async function sleepMs(ms, signal) {
 
 // src/sessions/downloads.ts
 import { link, mkdir as mkdir5, mkdtemp, open as open4, rm } from "fs/promises";
-import { basename as basename2, extname, join as join4, resolve } from "path";
+import { basename as basename2, extname, join as join5, resolve } from "path";
 var downloadGrantSchema = exports_external2.object({
   url: exports_external2.url(),
   method: exports_external2.literal("GET"),
@@ -36182,16 +36317,16 @@ async function downloadSessionFile({ client, sessionId, file: file3, directory,
     throw new Error(`File download failed (HTTP ${bytes.status}). Try again to request a fresh download.`);
   const destination = resolve(directory);
   await mkdir5(destination, { recursive: true });
-  const staging = await mkdtemp(join4(destination, ".remy-download-"));
+  const staging = await mkdtemp(join5(destination, ".remy-download-"));
   try {
-    const temporaryPath = join4(staging, "content");
+    const temporaryPath = join5(staging, "content");
     await saveDownloadStream({ body: bytes.body, path: temporaryPath, signal });
     const filename = safeFilename(file3.filename);
     const extension = extname(filename);
     const stem = filename.slice(0, filename.length - extension.length);
     for (let suffix = 0;suffix < 1000; suffix += 1) {
       signal.throwIfAborted();
-      const path = join4(destination, suffix === 0 ? filename : `${stem} (${suffix})${extension}`);
+      const path = join5(destination, suffix === 0 ? filename : `${stem} (${suffix})${extension}`);
       try {
         await link(temporaryPath, path);
         return path;
@@ -37597,7 +37732,7 @@ function renderPathCompletionMenu({ completions, selectedIndex, width, maxRows }
 // src/tui/path-completion.ts
 import { readdir } from "fs/promises";
 import { homedir } from "os";
-import { basename as basename3, dirname as dirname5, isAbsolute, join as join5, relative, resolve as resolve2, sep } from "path";
+import { basename as basename3, dirname as dirname5, isAbsolute as isAbsolute2, join as join6, relative as relative2, resolve as resolve2, sep } from "path";
 var maximumCandidates = 50;
 async function completePathToken({ text, cwd, homeDirectory = homedir() }) {
   const token = activePathToken(text);
@@ -37605,8 +37740,8 @@ async function completePathToken({ text, cwd, homeDirectory = homedir() }) {
     return [];
   const pathText = token.startsWith("@") ? token.slice(1) : token;
   const pathUsesTilde = pathText === "~" || pathText.startsWith("~/");
-  const expandedPath = pathText === "~" ? homeDirectory : pathText.startsWith("~/") ? join5(homeDirectory, pathText.slice(2)) : pathText;
-  const absolutePath = isAbsolute(expandedPath) ? expandedPath : resolve2(cwd, expandedPath);
+  const expandedPath = pathText === "~" ? homeDirectory : pathText.startsWith("~/") ? join6(homeDirectory, pathText.slice(2)) : pathText;
+  const absolutePath = isAbsolute2(expandedPath) ? expandedPath : resolve2(cwd, expandedPath);
   const directory = pathText === "" || pathText === "~" || pathText.endsWith("/") ? absolutePath : dirname5(absolutePath);
   const prefix = pathText === "" || pathText === "~" || pathText.endsWith("/") ? "" : basename3(absolutePath);
   let entries;
@@ -37616,8 +37751,8 @@ async function completePathToken({ text, cwd, homeDirectory = homedir() }) {
     return [];
   }
   return entries.filter((entry) => entry.name.toLowerCase().startsWith(prefix.toLowerCase())).sort((left, right) => left.name.localeCompare(right.name)).slice(0, maximumCandidates).map((entry) => {
-    const completedPath = join5(directory, entry.name);
-    const replacementPath = pathUsesTilde ? `~/${relative(homeDirectory, completedPath)}` : isAbsolute(pathText) ? completedPath : relative(cwd, completedPath) || entry.name;
+    const completedPath = join6(directory, entry.name);
+    const replacementPath = pathUsesTilde ? `~/${relative2(homeDirectory, completedPath)}` : isAbsolute2(pathText) ? completedPath : relative2(cwd, completedPath) || entry.name;
     const normalized = replacementPath.split(sep).join("/");
     const suffix = entry.isDirectory() ? "/" : "";
     const completed = `${normalized}${suffix}`;
@@ -40517,7 +40652,7 @@ import { Buffer as Buffer2 } from "buffer";
 import { randomUUID as randomUUID4 } from "crypto";
 import { mkdtemp as mkdtemp2, open as open5, readdir as readdir2, rm as rm2, stat, writeFile as writeFile3 } from "fs/promises";
 import { homedir as homedir2, tmpdir } from "os";
-import { basename as basename4, isAbsolute as isAbsolute2, join as join6, resolve as resolve3 } from "path";
+import { basename as basename4, isAbsolute as isAbsolute3, join as join7, resolve as resolve3 } from "path";
 var directoryArchiveMediaType = "application/gzip";
 var directoryArchiveSuffix = ".tar.gz";
 var maxPortableFilenameBytes = 255;
@@ -40561,7 +40696,7 @@ async function writePastedImage({
   const extension = extensionForMediaType(mediaType);
   if (!extension)
     throw new Error(`Unsupported pasted image MIME type: ${mediaType}`);
-  const filePath = join6(temporaryDirectory, `remy-paste-${randomUUID4()}.${extension}`);
+  const filePath = join7(temporaryDirectory, `remy-paste-${randomUUID4()}.${extension}`);
   await writeFile3(filePath, bytes, { mode: 384 });
   return filePath;
 }
@@ -40646,9 +40781,9 @@ async function createDirectoryArchive(directoryPath) {
   });
   if (Object.keys(files).length === 0)
     throw new Error(`Directory attachment contains no regular files: ${directoryPath}`);
-  const temporaryDirectory = await mkdtemp2(join6(tmpdir(), "remy-directory-attachment-"));
+  const temporaryDirectory = await mkdtemp2(join7(tmpdir(), "remy-directory-attachment-"));
   const filename = directoryArchiveFilename(rootName);
-  const archivePath = join6(temporaryDirectory, filename);
+  const archivePath = join7(temporaryDirectory, filename);
   try {
     await Bun.Archive.write(archivePath, files, { compress: "gzip" });
     if ((await stat(archivePath)).size > fileUploadMaxBytes)
@@ -40670,7 +40805,7 @@ async function collectDirectoryFiles({
   entries.sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0);
   let byteSize = collectedByteSize;
   for (const entry of entries) {
-    const entryPath = join6(directoryPath, entry.name);
+    const entryPath = join7(directoryPath, entry.name);
     const entryArchivePath = `${archivePath}/${entry.name}`;
     if (entry.isDirectory()) {
       byteSize = await collectDirectoryFiles({
@@ -40739,7 +40874,7 @@ function truncateUtf8(value, maxBytes) {
 function promptFilePaths({ text, cwd, selectedPaths }) {
   const paths = new Map;
   for (const selectedPath of selectedPaths)
-    paths.set(isAbsolute2(selectedPath) ? selectedPath : resolve3(cwd, selectedPath), true);
+    paths.set(isAbsolute3(selectedPath) ? selectedPath : resolve3(cwd, selectedPath), true);
   const tokens = text.match(/[([{]*@?(?:"[^"]*"|'[^']*'|`[^`]*`)|(?:\\.|[^\s\\])+/g) ?? [];
   for (const quotedToken of tokens) {
     const wrappedToken = quotedToken.replace(/^[([{]+/, "").replace(/[),.;:!?\]}]+$/, "");
@@ -40748,12 +40883,12 @@ function promptFilePaths({ text, cwd, selectedPaths }) {
     const pathText = token.startsWith("@") ? token.slice(1) : token;
     if (!pathText)
       continue;
-    const explicit = token.startsWith("@") || pathText.startsWith("./") || pathText.startsWith("../") || isAbsolute2(pathText) || pathText.startsWith("~/");
+    const explicit = token.startsWith("@") || pathText.startsWith("./") || pathText.startsWith("../") || isAbsolute3(pathText) || pathText.startsWith("~/");
     const pathShaped = explicit || pathText.includes("/") || pathText.includes("\\") || pathText.includes(".");
     if (!pathShaped)
       continue;
-    const expandedPath = pathText.startsWith("~/") ? join6(homedir2(), pathText.slice(2)) : pathText;
-    const filePath = isAbsolute2(expandedPath) ? expandedPath : resolve3(cwd, expandedPath);
+    const expandedPath = pathText.startsWith("~/") ? join7(homedir2(), pathText.slice(2)) : pathText;
+    const filePath = isAbsolute3(expandedPath) ? expandedPath : resolve3(cwd, expandedPath);
     paths.set(filePath, paths.get(filePath) || explicit);
   }
   return [...paths].map(([filePath, explicit]) => ({ filePath, explicit }));
@@ -40775,6 +40910,7 @@ function isPng(bytes) {
 
 // src/tui/remy-splash.ts
 import { bold as bold6, BoxRenderable as BoxRenderable4, fg as fg11, NativeImage, StyledText as StyledText10, TextRenderable as TextRenderable5, bg as bg4 } from "@opentui/core";
+
 // src/tui/remy-mark.ts
 var remyPixelFieldSource = new URL("../assets/remy-pixel-field.png", import.meta.url);
 function shouldShowRemySplash({ width, height }) {
@@ -40792,7 +40928,6 @@ var compactMarkRows = 9;
 var compactMinWidth = 48;
 var compactMinHeight = 20;
 var markBrightnessGain = 4.2;
-var remyCliVersion = "1.20.0";
 async function showRemySplash({
   createRenderer = createRemyRenderer,
   durationMs = splashDurationMs,
@@ -41149,6 +41284,34 @@ async function dispatchCliCommandWithShutdown({
     dependencies.output.writeStdout(helpUsage(command.topic));
     return 0;
   }
+  if (command.name === "version") {
+    dependencies.output.writeStdout(`${dependencies.updates.currentVersion}
+`);
+    return 0;
+  }
+  if (command.name === "update") {
+    if (dependencies.updates.currentVersion === "0.0.0")
+      throw new Error("This is a development checkout. Update the checkout instead of running remy update.");
+    const version5 = await dependencies.updates.check(dependencies.abortSignal);
+    if (version5)
+      await installCliUpdate({ dependencies, version: version5 });
+    else
+      dependencies.output.writeStdout(`Remy ${dependencies.updates.currentVersion} is up to date.
+`);
+    return 0;
+  }
+  if (command.name === "dashboard" && isInteractiveTerminal(dependencies)) {
+    let version5 = null;
+    try {
+      version5 = await dependencies.updates.check(dependencies.abortSignal);
+    } catch {
+      throwIfAborted2(dependencies.abortSignal);
+    }
+    if (version5 && await dependencies.updates.confirm({ version: version5, signal: dependencies.abortSignal, interrupt })) {
+      await installCliUpdate({ dependencies, version: version5 });
+      return 0;
+    }
+  }
   if (command.name === "login")
     return await openExplicitLogin({ dependencies, flags: command.flags, interrupt });
   if (command.name === "logout")
@@ -41168,6 +41331,13 @@ async function dispatchCliCommandWithShutdown({
     return await attachSession({ dependencies, sessionId: command.sessionId, noTui: command.noTui, json: command.json, prompt: command.prompt });
   return await createNewSession({ dependencies, command });
 }
+async function installCliUpdate({ dependencies, version: version5 }) {
+  dependencies.output.writeStderr(`Updating Remy ${dependencies.updates.currentVersion} to ${version5}...
+`);
+  await dependencies.updates.install(version5, dependencies.abortSignal);
+  dependencies.output.writeStdout(`Remy updated to ${version5}. Run remy again to use the new version.
+`);
+}
 function createCliShutdown({ abortSignal }) {
   const controller = new AbortController;
   const abortFromProcess = (signal) => {
@@ -41307,7 +41477,7 @@ ${approvalUrl}
           tokenPath: paths.tokenPath,
           candidatePath: candidateTokenPath,
           backupPath: previousTokenPath,
-          quarantinePath: join7(dirname6(paths.tokenPath), `.tokens.quarantine.${process.pid}.${randomUUID5()}.json`)
+          quarantinePath: join8(dirname6(paths.tokenPath), `.tokens.quarantine.${process.pid}.${randomUUID5()}.json`)
         };
         await writeCredentialPromotionJournal({ stateDirectory: dirname6(paths.tokenPath), journal, ...dependencies.credentialStateFilesystem });
         journalPrepared = true;
@@ -42199,7 +42369,7 @@ async function runAttachedSession({
               client: operations.client,
               sessionId,
               file: file3,
-              directory: join7(dependencies.environment.HOME ?? homedir3(), "Downloads"),
+              directory: join8(dependencies.environment.HOME ?? homedir3(), "Downloads"),
               signal,
               fetchClient: globalThis.fetch
             }),
@@ -42424,10 +42594,10 @@ async function collectAllUsers({
   }
 }
 function resolveSessionCachePathForCommand({ dependencies, sessionId }) {
-  const stateBase = dependencies.environment.XDG_STATE_HOME ?? (dependencies.environment.HOME ? join7(dependencies.environment.HOME, ".local/state") : undefined);
+  const stateBase = dependencies.environment.XDG_STATE_HOME ?? (dependencies.environment.HOME ? join8(dependencies.environment.HOME, ".local/state") : undefined);
   if (!stateBase)
     throw new Error("HOME is required when XDG_STATE_HOME is not set; refusing to read Remy session cache.");
-  return join7(stateBase, "remy", "sessions", `${sessionId}.json`);
+  return join8(stateBase, "remy", "sessions", `${sessionId}.json`);
 }
 function isInteractiveTerminal(dependencies) {
   return dependencies.isTerminal?.() ?? (process.stdin.isTTY === true && process.stdout.isTTY === true);
@@ -42445,6 +42615,18 @@ function parseCommand(argv) {
       throw new Error(`${commandName} does not accept arguments.`);
     return { name: "help", topic: "root" };
   }
+  if (commandName === "--version" || commandName === "-v") {
+    if (rest.length > 0)
+      throw new Error(`${commandName} does not accept arguments.`);
+    return { name: "version" };
+  }
+  if (commandName === "update") {
+    if (isHelpRequest(rest))
+      return { name: "help", topic: "update" };
+    if (rest.length > 0)
+      throw new Error("remy update does not accept arguments.");
+    return { name: "update" };
+  }
   if (commandName === "dashboard") {
     if (isHelpRequest(rest))
       return { name: "help", topic: "dashboard" };
@@ -42477,7 +42659,7 @@ function parseCommand(argv) {
   }
   if (commandName.startsWith("--"))
     throw new Error(`Unknown root flag ${commandName}. Use --session <session-id> to attach or remy new to create a session.`);
-  throw new Error(`Unknown command ${commandName}. Expected login, logout, whoami, or new.`);
+  throw new Error(`Unknown command ${commandName}. Expected dashboard, login, logout, whoami, new, or update.`);
 }
 function isHelpRequest(argv) {
   return argv.length === 1 && isHelpFlag(argv[0]);
@@ -42486,6 +42668,17 @@ function isHelpFlag(value) {
   return value === "--help" || value === "-h";
 }
 function helpUsage(topic) {
+  if (topic === "update") {
+    return `Usage: remy update
+
+Install a newer Remy CLI release using the original package manager (mise, bun, pnpm, or npm).
+Stable installations stay on latest; RC installations also check rc. No sign-in is required.
+After updating, run Remy again. Local and temporary installations must be updated by their caller.
+
+Options:
+  --help, -h                               Show this help
+`;
+  }
   if (topic === "login") {
     return `Usage: remy login [options]
 
@@ -42577,6 +42770,8 @@ Commands:
                                             Sign in
   remy logout [--api-url <url>]              Sign out
   remy whoami                                Show signed-in identity
+  remy update                                Update the installed CLI
+  remy --version                             Show the installed version
   remy help                                  Show this help
 
 Options:
@@ -42701,7 +42896,7 @@ async function readOptionalCliConfiguration(path) {
 async function createCandidateTokenPath(activeTokenPath) {
   const directory = dirname6(activeTokenPath);
   await mkdir6(directory, { recursive: true, mode: 448 });
-  return join7(directory, `.tokens.${process.pid}.${randomUUID5()}.tmp`);
+  return join8(directory, `.tokens.${process.pid}.${randomUUID5()}.tmp`);
 }
 async function removeCandidateToken({
   path,
@@ -42730,7 +42925,7 @@ async function removeCommittedTokenRecoveryArtifacts({
   for (const entry of entries) {
     if (!isCommittedTokenRecoveryArtifact(entry))
       continue;
-    await removeCandidateToken({ path: join7(directory, entry), removeTokenFile });
+    await removeCandidateToken({ path: join8(directory, entry), removeTokenFile });
   }
 }
 function isCommittedTokenRecoveryArtifact(entry) {
@@ -42801,6 +42996,13 @@ function createDefaultCommandDependencies(argv, sourceEnvironment) {
   };
   return {
     argv,
+    updates: createCliUpdates({
+      currentVersion: remyCliVersion,
+      entryPath: process.argv[1] ?? "",
+      fetchClient: fetch,
+      runProcess: runUpdateProcess,
+      confirm: confirmCliUpdate
+    }),
     environment: {
       HOME: environment.HOME,
       XDG_CONFIG_HOME: environment.XDG_CONFIG_HOME,
@@ -42833,7 +43035,7 @@ async function runBrowserLauncher(command) {
   if (!executable)
     throw new Error("Browser launcher command is empty.");
   return await new Promise((resolve4, reject) => {
-    const child = spawn(executable, arguments_, { stdio: "ignore" });
+    const child = spawn2(executable, arguments_, { stdio: "ignore" });
     child.once("error", reject);
     child.once("exit", (code) => resolve4(code ?? 1));
   });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@meistrari/remy-cli",
-    "version": "1.20.0",
+    "version": "1.21.0-rc.0",
     "description": "Remy, the Coding Agent terminal client.",
     "type": "module",
     "bin": {