@yanzc/claude-pro 0.5.2 → 0.5.4

package/README.md

@@ -28,7 +28,12 @@ npm install -g @yanzc/claude-pro
 claude-pro                 # 在任意项目目录里运行
 ```
 
-自动更新（与 Claude Code 一样）：用 npm 全局安装的版本每 6 小时最多查一次 npm 上的最新版，有新版就在后台 `npm install -g @yanzc/claude-pro@新版本`，装好后在会话空闲时自动重启加载，对话保留。`/update` 立即检查；`CLAUDE_PRO_AUTO_UPDATE=0` 或 `DISABLE_AUTOUPDATER=1` 关闭。从源码运行（git 检出）的副本从不自动更新。
+自动更新（与 Claude Code 一样）：用 npm 全局安装的版本在启动时、以及运行中**每 5 分钟**查一次 npm 上的最新版（同一台电脑上的所有会话共用这个间隔，查到的新版本号也共享；查询绕过 npm 的 CDN 缓存）。
+- **不打断工作**：发现新版后先记下，底部显示 `update x.y.z ready · installs when idle`；**等这个会话和这台电脑上其他开着的会话都空闲**（没有在执行任务、没有等待回答的问题、没有后台 agent/命令/文件传输）才安装，有会话在忙就每 30 秒再看一次，本会话一轮结束时也会再试。
+- **安装中有提示**：底部显示 `⇣ updating claude-pro to x.y.z…`（`npm install -g --prefer-online`），装好后提示并自动重启加载，对话保留；重启后显示 `↻ Restarted: updated to claude-pro x.y.z`。
+- **多个终端**：同一时间只有一个会话去安装（加锁），其他会话看到程序文件变了，会提示"x.y.z 已由另一个窗口安装"，各自在空闲时重启；正在工作的会话等它的任务结束才重启。
+- npm 刚发布时安装包要几分钟才能下载，期间安装失败会在 1 分钟后重试。所以发布后一般 5–10 分钟内各个客户端就用上新版。
+- `/update` 立即检查；`CLAUDE_PRO_AUTO_UPDATE=0` 或 `DISABLE_AUTOUPDATER=1` 关闭。从源码运行（git 检出）的副本从不自动更新。
 
 从源码运行：
 
@@ -234,7 +239,7 @@ claude-pro config set ANTHROPIC_MODEL deepseek-pro --project
 - 流式 Markdown 渲染（代码高亮、表格、中文宽度对齐），思考过程折叠显示（`ctrl+o` 展开）
 - `Esc` 中断；忙碌时输入的消息会排队并插入当前任务
 - `!` Bash 模式、`#` 写入记忆（CLAUDE.md）、`\`+回车 或 `ctrl+j` 换行、粘贴大段文本折叠为 `[Pasted text #1 +42 lines]`
-- **全屏模式（默认，和 Claude Code 的 `/tui fullscreen` 一样）**：程序画在终端的备用屏幕上（像 vim），输入框固定在窗口最底下，不随输出或终端滚动条移动；对话在程序里滚动：鼠标滚轮（每格 `CLAUDE_PRO_SCROLL_SPEED` 行，默认 3）、`PgUp`/`PgDn`（半屏）、`Ctrl+Home`（对话开头）、`Ctrl+End`（回到最新）。往上翻时新输出不会把画面拉回底部，底部浮着 `Jump to bottom (ctrl+End) ↓ · N new lines`，**点它**或按 `Ctrl+End` 回到底部；发消息时自动回到底部。**选中文字直接用鼠标拖**（不用按 Shift），松开就复制到剪贴板；双击选一个词，三击选一整行；拖到对话区上下边缘会跟着滚动。选中的部分反色显示，点一下别处、按 `Esc` 或任意键就消失；有选中时 `Ctrl+C` 是复制（不会中断任务）。仍可按住 Shift 拖动用终端自己的选中。退出后终端回到启动前的样子（对话不留在终端滚动记录里）。`/tui default` 切回经典模式（对话写进终端自己的滚动记录，输入框在窗口底部、靠空行顶到底；`CLAUDE_PRO_PIN_INPUT=0` 让它紧跟在输出下面），`/tui fullscreen` 切回全屏，选择会记住（`CLAUDE_PRO_TUI`）
+- **全屏模式（默认，和 Claude Code 的 `/tui fullscreen` 一样）**：程序画在终端的备用屏幕上（像 vim），输入框固定在窗口最底下，不随输出或终端滚动条移动；对话在程序里滚动：鼠标滚轮（每格 `CLAUDE_PRO_SCROLL_SPEED` 行，默认 3）、`PgUp`/`PgDn`（半屏）、`Ctrl+Home`（对话开头）、`Ctrl+End`（回到最新）。往上翻时新输出不会把画面拉回底部，底部浮着 `Jump to bottom (ctrl+End) ↓ · N new lines`，**点它**或按 `Ctrl+End` 回到底部；发消息时自动回到底部。**选中文字直接用鼠标拖**（不用按 Shift），松开就复制到剪贴板；双击选一个词，三击选一整行；拖到对话区上下边缘会跟着滚动。选中的部分反色显示，点一下别处、按 `Esc` 或任意键就消失；有选中时 `Ctrl+C` 是复制（不会中断任务）。**右键**和在终端里一样：有选中时复制，没有时把剪贴板的文字粘贴进输入框（和 `Ctrl+V` 相同）。仍可按住 Shift 拖动用终端自己的选中。退出后终端回到启动前的样子（对话不留在终端滚动记录里）。`/tui default` 切回经典模式（对话写进终端自己的滚动记录，输入框在窗口底部、靠空行顶到底；`CLAUDE_PRO_PIN_INPUT=0` 让它紧跟在输出下面），`/tui fullscreen` 切回全屏，选择会记住（`CLAUDE_PRO_TUI`）
 - `ctrl+c` 或连按两次 `Esc` 清掉的草稿不会丢：在空输入框按 `↑` 找回（连同粘贴的文本和图片），中间发过别的消息也可以
 - `@文件` 补全并附加内容：走的就是 `Read` 工具，等于模型自己读了这个文件。最多带前 2000 行（被截断时会明确告诉模型，并把该文件记为"只读了一部分"，之后 `Write` 不会去覆盖没给它看过的行）；图片作为图片附加；二进制文件和超过 512KB 的文本会被跳过并提示原因；`@目录` 列出目录内容
 - `alt+v` 粘贴剪贴板里的图片（截图用 `Win+Shift+S`），输入框里显示为 `[Image #1]`；超过 1568px 的图会自动缩小。把图片文件拖进终端（或粘贴图片路径）也会作为图片附加

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yanzc/claude-pro",
-  "version": "0.5.2",
+  "version": "0.5.4",
   "description": "claude-pro: a self-implemented coding agent for Anthropic-compatible APIs or local Claude Code subscription login. Full access with no permission prompts; file edits are checkpointed and can be rewound.",
   "type": "module",
   "repository": {

package/src/peers.js

@@ -75,10 +75,12 @@ export function findPeer(peers, ref) {
 export class PeerNode {
   // onMessage(msg): msg = {id, kind: 'task'|'reply', text, inReplyTo, from: {id, name, cwd}}
   // `id`: the id this session had before a restart, so that answers on their way still find it.
-  constructor({ cwd, name, id, onMessage }) {
+  // getStatus(): {busy}, what GET /status answers (an update waits until no session of the machine is busy).
+  constructor({ cwd, name, id, onMessage, getStatus }) {
     this.cwd = cwd;
     this.wantedName = name || null;
     this.onMessage = onMessage;
+    this.getStatus = getStatus;
     this.id = /^[0-9a-f]{12}$/.test(id || '') ? id : crypto.randomBytes(6).toString('hex');
     this.token = crypto.randomBytes(16).toString('hex');
     this.name = null;
@@ -134,6 +136,12 @@ export class PeerNode {
 
   handle(req, res) {
     const reply = (code, body) => { res.writeHead(code, { 'content-type': 'application/json' }); res.end(JSON.stringify(body)); };
+    if (req.method === 'GET' && req.url === '/status') {
+      if (req.headers.authorization !== `Bearer ${this.token}`) return reply(401, { error: 'bad token' });
+      let status = {};
+      try { status = this.getStatus?.() || {}; } catch { /* nothing to say */ }
+      return reply(200, { busy: Boolean(status.busy) });
+    }
     if (req.method !== 'POST' || req.url !== '/message') return reply(404, { error: 'not found' });
     if (req.headers.authorization !== `Bearer ${this.token}`) return reply(401, { error: 'bad token' });
     let body = '';
@@ -152,6 +160,23 @@ export class PeerNode {
     });
   }
 
+  // Whether a session of this machine is working now. A session that does not answer (gone, or a version without
+  // /status) counts as idle: it cannot hold an update back forever.
+  status(peer) {
+    return new Promise((resolve) => {
+      const req = http.get({ host: '127.0.0.1', port: peer.port, path: '/status', timeout: 2000, headers: { authorization: `Bearer ${peer.token}` } }, (res) => {
+        let out = '';
+        res.setEncoding('utf8');
+        res.on('data', (d) => { out += d; });
+        res.on('end', () => {
+          try { resolve(res.statusCode === 200 ? { busy: Boolean(JSON.parse(out).busy) } : { busy: false }); } catch { resolve({ busy: false }); }
+        });
+      });
+      req.on('timeout', () => req.destroy());
+      req.on('error', () => resolve({ busy: false }));
+    });
+  }
+
   // Send to a peer (an entry of peers(), or its name). Resolves with {id} (the id the receiver gave the message).
   async send(target, { text, kind = 'task', inReplyTo = null, files = [] }) {
     const peer = typeof target === 'string' ? findPeer(this.peers(), target) : target;

package/src/selfcheck.js

@@ -10,6 +10,9 @@ const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 async function check() {
   const problems = [];
   const fail = (text) => problems.push(text);
+  // The App starts as a session does (the fullscreen renderer, the update timer, ...), so that code only a real
+  // start runs is checked too, but this process must not show up as a session, go online or install an update.
+  Object.assign(process.env, { CLAUDE_PRO_PEERS: '0', CLAUDE_PRO_ONLINE: '0', CLAUDE_PRO_AUTO_UPDATE: '0' });
 
   let App;
   try {
@@ -25,7 +28,7 @@ async function check() {
   const stdin = new PassThrough();
   Object.assign(stdin, { isTTY: true, setRawMode() {} });
 
-  const app = new App({ flags: { noMcp: true }, cwd: process.cwd(), stdin, stdout, noProcessExit: true });
+  const app = new App({ flags: { noMcp: true }, cwd: process.cwd(), stdin, stdout, selfCheck: true });
   let exited;
   try {
     exited = app.start('');

package/src/ui/repl.js

@@ -27,11 +27,11 @@ import { ripgrepPath } from '../utils/shell.js';
 import { describePause, formatClock, humanDuration, resumeText, shouldAnnounce } from '../ratelimit.js';
 import { shutdownBackgroundShells, listBackgroundShells } from '../tools/bash.js';
 import { estimateTokens } from '../agent.js';
-import { readClipboardImage, imageFromFile, watchClipboard, writeClipboard } from '../utils/clipboard.js';
+import { readClipboardImage, imageFromFile, watchClipboard, writeClipboard, readClipboardText } from '../utils/clipboard.js';
 import { fitImagesIn } from '../utils/images.js';
 import { downloadsDir, filesToSend, formatBytes } from '../utils/downloads.js';
 import { copyUnique } from '../transfer.js';
-import { checkForUpdate } from '../updater.js';
+import { checkForUpdate, installUpdate, installedVersion, isNewer, CHECK_EVERY_MS } from '../updater.js';
 import { PeerNode, peersEnabled, findPeer, resolvePeer, machineName, cleanName, peerMessagePrompt } from '../peers.js';
 import { RemoteControl, transcriptItems, onlineEnabled, REMOTE_WIDTH } from '../remote.js';
 import { qrLines } from '../qr.js';
@@ -143,12 +143,16 @@ class FileIndex {
 }
 
 export class App {
-  constructor({ flags, cwd, stdin = process.stdin, stdout = process.stdout, noProcessExit = false }) {
+  // `noProcessExit`: the tests, which drive the App themselves; it never ends the process, and it has no peers, no
+  // gateway connection, no update checks and the default renderer. `selfCheck` (see selfcheck.js): it never ends the
+  // process either, but otherwise starts as a session does, so that code only a real start runs is checked too.
+  constructor({ flags, cwd, stdin = process.stdin, stdout = process.stdout, noProcessExit = false, selfCheck = false }) {
     this.flags = flags;
     this.cwd = cwd;
     this.stdin = stdin;
     this.stdout = stdout;
-    this.noProcessExit = noProcessExit;
+    this.noProcessExit = noProcessExit || selfCheck;
+    this.driven = noProcessExit;
     this.screen = new Screen(stdout);
     this.busy = false;
     this.controller = null;
@@ -249,6 +253,7 @@ export class App {
     // Keys typed while starting up stay buffered in stdin until we listen. Mouse reports (fullscreen: the wheel)
     // are taken out before the keys are read.
     const keys = mouseFilter(stdin, (m) => this.onMouse(m));
+    this.keys = keys;
     readline.emitKeypressEvents(keys);
     keys.on('keypress', (str, key) => {
       if (/^\x1b\[\d+;\d+R$/.test(key?.sequence || '')) return; // a late answer to the cursor position query, not a key
@@ -279,7 +284,12 @@ export class App {
     }
     this.fileIndex.refresh();
     this.startSourceWatch();
-    if (!this.noProcessExit && !this.flags.restart) this.autoUpdate();
+    if (!this.driven) {
+      if (!this.flags.restart) this.autoUpdate();
+      // and every few minutes while it runs, so that a release reaches a session that stays open for days
+      this.updateTimer = setInterval(() => { if (!this.exiting) this.autoUpdate({ quiet: true }); }, CHECK_EVERY_MS);
+      this.updateTimer.unref?.();
+    }
     return new Promise((resolve) => { this.resolveExit = resolve; });
   }
 
@@ -388,9 +398,9 @@ export class App {
   // Register this session so that the other sessions on the machine can send it tasks. Not in the tests
   // (which drive the App themselves) and not with CLAUDE_PRO_PEERS=0.
   async startPeer() {
-    if (this.noProcessExit || !peersEnabled()) return;
+    if (this.driven || !peersEnabled()) return;
     try {
-      this.peers = await new PeerNode({ cwd: this.cwd, name: this.flags.restart?.peerName, id: this.flags.restart?.peerId, onMessage: (msg) => this.onPeerMessage(msg) }).start();
+      this.peers = await new PeerNode({ cwd: this.cwd, name: this.flags.restart?.peerName, id: this.flags.restart?.peerId, onMessage: (msg) => this.onPeerMessage(msg), getStatus: () => ({ busy: this.working() }) }).start();
     } catch (e) {
       this.peers = null;
       this.notice(`Other sessions cannot reach this one: ${e.message}`, 'warn');
@@ -706,12 +716,12 @@ export class App {
   // Online at the gateway (see remote.js) from the start: by itself when this computer is logged in to the gateway
   // (CLAUDE_PRO_ONLINE=0 turns that off), with --rc (which prints the link too), and after a restart as before (with
   // the same id, so that open pages and messages on their way find it again). It does not hold up the start. Never
-  // in the tests and the self-check, which drive the App themselves.
+  // in the tests, which drive the App themselves, nor in the self-check, which sets CLAUDE_PRO_ONLINE=0.
   autoStartRemote(restart) {
     const carried = restart?.remote;
     if (carried?.off) { this.remoteStopped = true; return; }
     const explicit = Boolean(this.flags.remoteControl);
-    if (this.noProcessExit && !explicit) return;
+    if (this.driven && !explicit) return;
     if (!explicit && !carried?.id && !(onlineEnabled(this.config.env) && readGatewayLogin(this.config.gatewayUrl))) return;
     this.startRemote({ id: carried?.id, quiet: !explicit || Boolean(carried?.id), persistent: !explicit }).catch((e) => {
       this.notice(`${explicit ? 'Remote control could not start' : 'This session could not go online at the gateway'}: ${e.message}${e.code === 'NO_GATEWAY_LOGIN' ? '' : ' (/rc tries again)'}`, 'warn');
@@ -876,8 +886,15 @@ export class App {
   // ---------------------------------------------------------------- restarting (see restart.js)
 
   // What a restart would kill: agents and shells that are still running in the background.
+  // Something is going on that an update must not cut into: a turn, a question waiting for an answer, messages
+  // waiting to be sent, background agents and shells, files on their way.
+  working() {
+    return Boolean(this.busy || this.dialogs.length || this.queue.length || this.restartBlockers().length);
+  }
+
   restartBlockers() {
     const found = [];
+    for (const t of this.transfers.values()) found.push(`files on their way ${t.direction === 'up' ? 'to' : 'from'} &${t.label}`);
     for (const t of this.runtime.tasks.running()) found.push(`background agent ${t.id} "${t.description}"`);
     for (const s of listBackgroundShells()) if (s.status === 'running') found.push(`background shell ${s.id} (${String(s.command).slice(0, 40)})`);
     return found;
@@ -975,6 +992,13 @@ export class App {
     if (!canRestart() || /^(0|false|no|off)$/i.test(this.config.env.CLAUDE_PRO_AUTO_RESTART || '')) return;
     this.sourceWatch = watchSource(INSTALL_DIR, (file) => {
       this.sourceChanged = file || true;
+      // another window (or npm) installed a new version: say so, and load it once this session is idle
+      const disk = installedVersion();
+      if (disk !== VERSION && isNewer(disk, VERSION) && this.updateRestart !== disk) {
+        this.updateRestart = disk;
+        this.pendingUpdate = null;
+        this.notice(`${APP_NAME} ${disk} was installed (by another window or npm); this one restarts to load it ${this.working() ? 'once its work is done' : 'now'}.`);
+      }
       if (!this.busy) this.maybeAutoReload();
     });
   }
@@ -986,7 +1010,7 @@ export class App {
     const changed = this.sourceChanged;
     this.sourceChanged = null;
     this.reloading = true;
-    this.flash('Source changed: checking the new code…');
+    this.flash(this.updateRestart ? `Updated to ${this.updateRestart}: checking it starts, then restarting…` : 'Source changed: checking the new code…');
     let check;
     try { check = await runSelfCheck(); } finally { this.reloading = false; }
     if (this.exiting) return;
@@ -995,33 +1019,93 @@ export class App {
       return;
     }
     if (this.busy || this.dialogs.length) { this.sourceChanged = changed; return; } // something started meanwhile: later
-    this.requestRestart({ reason: 'source changed', force: true });
+    this.requestRestart({ reason: this.updateRestart ? `updated to ${APP_NAME} ${this.updateRestart}` : 'source changed', force: true });
   }
 
-  // A newer version on npm is installed in the background (see updater.js) and loaded by a restart once the
-  // session is idle. `force`: the /update command, which also says when there is nothing to do.
-  async autoUpdate({ force = false } = {}) {
-    if (this.updating) { if (force) this.notice('An update is already being installed.'); return; }
+  // A newer version on npm (see updater.js): it is installed once no session of this machine is working, and then
+  // loaded by a restart (this session's; the others restart when they see the files change). `force`: the /update
+  // command, which also says when there is nothing to do. `quiet`: the periodic check, which says nothing when an
+  // install fails (it is tried again in a minute).
+  async autoUpdate({ force = false, quiet = false } = {}) {
+    if (this.updating) { if (force) this.notice(`${APP_NAME} ${this.updating} is being installed.`); return; }
     let r;
     try {
-      r = await checkForUpdate({ force, env: { ...process.env, ...this.config.env }, onInstalling: (v) => { this.updating = true; this.flash(`Installing ${APP_NAME} ${v}…`); } });
+      r = await checkForUpdate({ force, env: { ...process.env, ...this.config.env } });
     } catch (e) {
       r = { status: 'failed', error: e.message };
-    } finally {
-      this.updating = false;
     }
     if (this.exiting) return;
-    if (r.status === 'updated') {
-      this.notice(`${APP_NAME} was updated to ${r.version} (from ${VERSION}); it is loaded by a restart as soon as the session is idle.`);
-      if (canRestart()) { this.sourceChanged = true; if (!this.busy) this.maybeAutoReload(); }
-      else this.notice('Restart the program to use it.');
+    if (r.status === 'available') {
+      if (this.pendingUpdate !== r.version) {
+        this.pendingUpdate = r.version;
+        this.updateQuiet = quiet;
+        this.screen.schedule();
+      }
+      if (force && this.working()) this.notice(`${APP_NAME} ${r.version} is out: it is installed as soon as this session's work is done.`);
+      await this.maybeInstallUpdate({ force });
+    } else if (r.status === 'installed') {
+      if (force || this.updateRestart !== r.version) this.notice(`${APP_NAME} ${r.version} is installed already; this session restarts to load it ${this.working() ? 'once its work is done' : 'now'}.`);
+      this.updateRestart = r.version;
+      if (canRestart()) { this.sourceChanged ||= true; if (!this.busy) this.maybeAutoReload(); }
     } else if (r.status === 'failed') {
-      if (force || r.version) this.notice(`Could not update ${APP_NAME}${r.version ? ` to ${r.version}` : ''}: ${r.error}`, 'warn');
+      if (force || (r.version && !quiet)) this.notice(`Could not update ${APP_NAME}${r.version ? ` to ${r.version}` : ''}: ${r.error}`, 'warn');
     } else if (force) {
       this.notice(r.status === 'dev' ? `This copy runs from a source checkout (${INSTALL_DIR}): update it with git.` : `${APP_NAME} ${VERSION} is the latest version.`);
     }
   }
 
+  // Install the version found (pendingUpdate) if nothing is going on: in this session, and in the other sessions
+  // of this machine, whose files it replaces under them. Called again when this session's turn ends, and every
+  // half minute while another session works.
+  async maybeInstallUpdate({ force = false } = {}) {
+    const version = this.pendingUpdate;
+    if (!version || this.updating || this.exiting || this.restartRequest) return;
+    if (this.working()) return; // the end of the turn calls this again
+    const local = this.peers?.peers() || [];
+    const busy = [];
+    for (const p of local) if ((await this.peers.status(p)).busy) busy.push(p.name);
+    if (this.pendingUpdate !== version || this.updating || this.exiting) return;
+    if (busy.length) {
+      if (this.updateWaitingFor !== busy.join(',')) {
+        this.updateWaitingFor = busy.join(',');
+        this.screen.schedule();
+        if (force) this.notice(`${APP_NAME} ${version} is installed once &${busy.join(', &')} ${busy.length === 1 ? 'is' : 'are'} done working.`);
+      }
+      clearTimeout(this.updateRetry);
+      this.updateRetry = setTimeout(() => this.maybeInstallUpdate(), 30_000);
+      this.updateRetry.unref?.();
+      return;
+    }
+    if (this.working()) return;
+    this.updateWaitingFor = null;
+    this.updating = version;
+    this.screen.schedule();
+    let r;
+    try {
+      r = await installUpdate(version);
+    } catch (e) {
+      r = { status: 'failed', version, error: e.message };
+    } finally {
+      this.updating = null;
+      this.screen.schedule();
+    }
+    if (this.exiting) return;
+    if (r.status === 'locked') return; // another window is installing it: its files changing tell this one
+    if (r.status === 'updated' || r.status === 'installed') {
+      this.pendingUpdate = null;
+      this.updateRestart = r.version;
+      if (canRestart()) {
+        this.notice(`${APP_NAME} was updated to ${r.version} (from ${VERSION}); restarting to load it. The conversation carries over.`);
+        this.sourceChanged = true;
+        this.maybeAutoReload();
+      } else {
+        this.notice(`${APP_NAME} was updated to ${r.version}: restart the program to use it.`);
+      }
+      return;
+    }
+    if (force || !this.updateQuiet) this.notice(`Could not update ${APP_NAME} to ${version}: ${r.error}`, 'warn');
+  }
+
   printWelcome() {
     const cfg = this.config;
     const w = Math.min(this.width - 1, 76);
@@ -1073,7 +1157,7 @@ export class App {
   // Fullscreen (see screen.js) unless CLAUDE_PRO_TUI=default, as Claude Code's /tui: the input box fixed at the
   // bottom of the window, the conversation scrolled inside the program. Not in the tests that drive the App.
   fullscreenWanted() {
-    const mode = String(this.config.env.CLAUDE_PRO_TUI || (this.noProcessExit ? 'default' : 'fullscreen')).toLowerCase();
+    const mode = String(this.config.env.CLAUDE_PRO_TUI || (this.driven ? 'default' : 'fullscreen')).toLowerCase();
     return mode === 'fullscreen' && this.stdout.isTTY !== false;
   }
 
@@ -1087,6 +1171,22 @@ export class App {
       this.screen.scrollBy(m.button & 1 ? -speed : speed);
       return;
     }
+    // A right click, which the terminal no longer gets: what it did there. With a selection it copies it;
+    // without one it pastes the clipboard's text, as the terminal's own paste (ctrl+v) arrives, so that it is
+    // handled the same way (long text folded, an image path attached, into a dialog's answer box).
+    if ((m.button & 3) === 2 && !(m.button & 32) && !m.release) {
+      if (this.screen.selection) {
+        this.copyText(this.screen.selectedText());
+        this.screen.clearSelection();
+        return;
+      }
+      readClipboardText().then((text) => {
+        if (!text || this.exiting) return;
+        const clean = text.replace(/\x1b\[20[01]~/g, '').replace(/\r\n|\n/g, '\r');
+        this.keys.write(`\x1b[200~${clean}\x1b[201~`);
+      });
+      return;
+    }
     const r = this.screen.mouse(m);
     if (r?.copy) this.copyText(r.copy);
   }
@@ -1474,6 +1574,7 @@ export class App {
       this.runAgent(this.agent.drainNotifications());
     } else {
       this.maybeAutoReload();
+      this.maybeInstallUpdate();
     }
   }
 
@@ -2054,6 +2155,11 @@ export class App {
       left += c.dim(' · ') + c.green(`⇄ ${this.remote.viewers} watching`);
     }
     if (this.transfers.size && !flash) left += c.dim(' · ') + this.transferStatus();
+    if (!flash) {
+      if (this.updating) left += c.dim(' · ') + c.blue(`⇣ updating ${APP_NAME} to ${this.updating}…`);
+      else if (this.updateRestart && this.sourceChanged && !this.restartRequest) left += c.dim(' · ') + c.blue(`↻ ${this.updateRestart} installed: restarts ${this.working() ? 'when the work is done' : 'now'}`);
+      else if (this.pendingUpdate) left += c.dim(' · ') + c.dim(`update ${this.pendingUpdate} ready · ${this.updateWaitingFor ? `installs when &${this.updateWaitingFor.split(',')[0]} is idle` : 'installs when idle'}`);
+    }
     const cfg = this.config;
     const threshold = cfg.autoCompactThreshold(cfg.mainModel);
     const used = this.agent.contextEstimate;

package/src/updater.js

@@ -1,7 +1,10 @@
 // Auto-update, as in Claude Code: an interactive session installed with `npm i -g claude-pro` looks for a newer
-// version on the npm registry (at most once every few hours), installs it in the background, and the session
-// then loads it with a restart once it is idle (the conversation carries over). A git checkout (the
-// development copy) is never touched. Off with CLAUDE_PRO_AUTO_UPDATE=0 or DISABLE_AUTOUPDATER=1.
+// version on the npm registry (when it starts and every few minutes while it runs; the sessions of a machine share
+// the interval, and what one finds the others see in the state file). It is installed only once no session of the
+// machine is working (App.maybeInstallUpdate asks them), by one session at a time (a lock file), and the session
+// then loads it with a restart (the conversation carries over); the others see the files change and restart too,
+// each once it is idle (App.startSourceWatch). A git checkout (the development copy) is never touched. Off with
+// CLAUDE_PRO_AUTO_UPDATE=0 or DISABLE_AUTOUPDATER=1.
 
 import fs from 'node:fs';
 import path from 'node:path';
@@ -12,7 +15,10 @@ import { CONFIG_DIR, INSTALL_DIR, VERSION } from './config.js';
 // The name on npm (scoped: npm refused plain `claude-pro` as too close to another package's name).
 export const PACKAGE_NAME = JSON.parse(fs.readFileSync(path.join(INSTALL_DIR, 'package.json'), 'utf8')).name;
 const STATE_FILE = path.join(CONFIG_DIR, 'update-check.json');
-const CHECK_EVERY_MS = 6 * 3600_000;
+const LOCK_FILE = path.join(CONFIG_DIR, 'update.lock');
+const LOCK_STALE_MS = 15 * 60_000;
+export const CHECK_EVERY_MS = 5 * 60_000; // a release reaches the running sessions within minutes
+const RETRY_FAILED_MS = 60_000; // a release's tarball can take minutes to be downloadable after it is published
 
 export function autoUpdateEnabled(env = process.env) {
   if (/^(1|true|yes)$/i.test(env.DISABLE_AUTOUPDATER || '')) return false;
@@ -39,12 +45,48 @@ export function isNewer(latest, current) {
   return false;
 }
 
+// The version installed on disk now (another session may have updated it since this one started).
+export function installedVersion(dir = INSTALL_DIR) {
+  try { return JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8')).version; } catch { return VERSION; }
+}
+
+function alive(pid) {
+  try { process.kill(pid, 0); return true; } catch (e) { return e.code === 'EPERM'; }
+}
+
+// One session of the machine installs at a time. A lock left by a session that died, or one that is very old, is taken over.
+function takeLock() {
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      fs.mkdirSync(CONFIG_DIR, { recursive: true });
+      fs.writeFileSync(LOCK_FILE, JSON.stringify({ pid: process.pid, at: Date.now() }), { flag: 'wx' });
+      return true;
+    } catch (e) {
+      if (e.code !== 'EEXIST') return false;
+      let held = {};
+      try { held = JSON.parse(fs.readFileSync(LOCK_FILE, 'utf8')); } catch { /* unreadable: stale */ }
+      if (alive(held.pid) && Date.now() - (held.at || 0) < LOCK_STALE_MS) return false;
+      try { fs.unlinkSync(LOCK_FILE); } catch { /* someone else took it over */ }
+    }
+  }
+  return false;
+}
+
+function releaseLock() {
+  try {
+    const held = JSON.parse(fs.readFileSync(LOCK_FILE, 'utf8'));
+    if (held.pid === process.pid) fs.unlinkSync(LOCK_FILE);
+  } catch { /* gone already */ }
+}
+
 function readState() { try { return JSON.parse(fs.readFileSync(STATE_FILE, 'utf8')); } catch { return {}; } }
 function writeState(s) { try { fs.mkdirSync(CONFIG_DIR, { recursive: true }); fs.writeFileSync(STATE_FILE, JSON.stringify(s)); } catch { /* ignore */ } }
 
 export function latestVersion({ timeoutMs = 10_000 } = {}) {
   return new Promise((resolve, reject) => {
-    const req = https.get(`https://registry.npmjs.org/${PACKAGE_NAME.replace('/', '%2f')}/latest`, { headers: { accept: 'application/json' }, timeout: timeoutMs }, (res) => {
+    // past the registry's CDN cache, which can answer with the version before the one just published
+    const url = `https://registry.npmjs.org/${PACKAGE_NAME.replace('/', '%2f')}/latest?t=${Date.now()}`;
+    const req = https.get(url, { headers: { accept: 'application/json', 'cache-control': 'no-cache' }, timeout: timeoutMs }, (res) => {
       let body = '';
       res.setEncoding('utf8');
       res.on('data', (d) => { body += d; });
@@ -70,24 +112,53 @@ function runNpm(args, { timeoutMs = 300_000 } = {}) {
   });
 }
 
-// Look for a newer version and install it. Resolves with {status: 'disabled'|'dev'|'skipped'|'current'|'updated'|'failed', version, error}.
-// `force`: check now, whatever the last check was (the /update command).
-export async function checkForUpdate({ force = false, env = process.env, onInstalling } = {}) {
+// Look for a newer version. Resolves with {status: 'disabled'|'dev'|'skipped'|'current'|'available'|'installed', version}:
+// 'available' to be installed (installUpdate), 'installed' when it is on disk already (another session installed
+// it: a restart loads it). Within the interval the registry is not asked again, but what another session found is
+// still 'available'. `force`: ask now, whatever the last check was (the /update command).
+export async function checkForUpdate({ force = false, env = process.env } = {}) {
   if (!force && !autoUpdateEnabled(env)) return { status: 'disabled' };
   if (!installedByNpm()) return { status: 'dev' };
   const state = readState();
-  if (!force && state.checkedAt && Date.now() - state.checkedAt < CHECK_EVERY_MS) return { status: 'skipped' };
-  writeState({ ...state, checkedAt: Date.now() });
-  const latest = await latestVersion();
+  let latest;
+  if (!force && state.checkedAt && Date.now() - state.checkedAt < CHECK_EVERY_MS) {
+    if (!state.available) return { status: 'skipped' };
+    latest = state.available;
+  } else {
+    writeState({ ...state, checkedAt: Date.now() });
+    latest = await latestVersion();
+    writeState({ ...readState(), available: latest });
+  }
   if (!isNewer(latest, VERSION)) return { status: 'current', version: latest };
+  if (!isNewer(latest, installedVersion())) return { status: 'installed', version: installedVersion() };
+  return { status: 'available', version: latest };
+}
+
+// Install `version` with npm. Resolves with {status: 'updated'|'installed'|'locked'|'failed', version, error}:
+// 'locked' while another session of the machine is installing.
+export async function installUpdate(version, { onInstalling } = {}) {
+  if (!takeLock()) return { status: 'locked', version };
+  try {
+    if (!isNewer(version, installedVersion())) return { status: 'installed', version: installedVersion() };
+    return await install(version, onInstalling);
+  } finally {
+    releaseLock();
+  }
+}
+
+async function install(latest, onInstalling) {
   // Only a global install is updated by `npm i -g`: one in a project's node_modules belongs to that project.
   const root = await runNpm(['root', '-g'], { timeoutMs: 30_000 });
   if (!root.ok || path.resolve(root.output.split(/\r?\n/).pop()) !== path.resolve(modulesDir())) {
     return { status: 'failed', version: latest, error: `this copy (${INSTALL_DIR}) is not the global npm install; update it with npm yourself` };
   }
   onInstalling?.(latest);
-  const r = await runNpm(['install', '-g', `${PACKAGE_NAME}@${latest}`]);
-  if (!r.ok) return { status: 'failed', version: latest, error: r.output.split('\n').slice(-5).join('\n') };
-  writeState({ checkedAt: Date.now(), installed: latest });
+  // --prefer-online: not npm's own cache of the package's versions, which may not know this one yet
+  const r = await runNpm(['install', '-g', '--prefer-online', `${PACKAGE_NAME}@${latest}`]);
+  if (!r.ok) {
+    writeState({ ...readState(), checkedAt: Date.now() - CHECK_EVERY_MS + RETRY_FAILED_MS }); // again in a minute
+    return { status: 'failed', version: latest, error: r.output.split('\n').slice(-5).join('\n') };
+  }
+  writeState({ ...readState(), installed: latest });
   return { status: 'updated', version: latest };
 }

package/src/utils/clipboard.js

@@ -164,6 +164,35 @@ export async function writeClipboard(text) {
   return false;
 }
 
+// The text on the system clipboard ('' when there is none), for a right click in the fullscreen renderer, which
+// gets the mouse instead of the terminal: Windows PowerShell (written out as UTF-8), pbpaste on macOS,
+// wl-paste / xclip / xsel elsewhere.
+export async function readClipboardText() {
+  const tries = process.platform === 'win32'
+    ? [['powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', '$t = Get-Clipboard -Raw; if ($t) { $b = [Text.Encoding]::UTF8.GetBytes($t); $o = [Console]::OpenStandardOutput(); $o.Write($b, 0, $b.Length) }']]]
+    : process.platform === 'darwin'
+      ? [['pbpaste', []]]
+      : [['wl-paste', ['--no-newline']], ['xclip', ['-selection', 'clipboard', '-o']], ['xsel', ['--clipboard', '--output']]];
+  for (const [cmd, args] of tries) {
+    const text = await new Promise((resolve) => {
+      const chunks = [];
+      let child;
+      try {
+        child = spawn(cmd, args, { windowsHide: true, stdio: ['ignore', 'pipe', 'ignore'] });
+      } catch {
+        resolve(null);
+        return;
+      }
+      const timer = setTimeout(() => child.kill(), 10_000);
+      child.stdout.on('data', (d) => chunks.push(d));
+      child.on('error', () => { clearTimeout(timer); resolve(null); });
+      child.on('close', (code) => { clearTimeout(timer); resolve(code === 0 ? Buffer.concat(chunks).toString('utf8') : null); });
+    });
+    if (text !== null) return text;
+  }
+  return '';
+}
+
 // Returns {image} on success, {error: string} on failure, or {error: null} when the clipboard has no image.
 export async function readClipboardImage({ source } = {}) {
   if (process.platform === 'win32') return readWindows(source);