@yanzc/claude-pro 0.5.1 → 0.5.3

package/README.md

@@ -28,7 +28,7 @@ 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 缓存），有新版就在后台 `npm install -g --prefer-online @yanzc/claude-pro@新版本`，装好后在会话空闲时自动重启加载，对话保留；同一台电脑上其他开着的会话看到文件变了，也会在空闲时自动重启。所以发布后几分钟内各个客户端就会用上新版（npm 刚发布时安装包要几分钟才能下载，期间安装失败会在 1 分钟后重试）。`/update` 立即检查；`CLAUDE_PRO_AUTO_UPDATE=0` 或 `DISABLE_AUTOUPDATER=1` 关闭。从源码运行（git 检出）的副本从不自动更新。
 
 从源码运行：
 
@@ -234,7 +234,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`；发消息时自动回到底部。程序接管了鼠标，**选中文字要按住 Shift 再拖动**（Windows Terminal、VS Code 终端都支持）。退出后终端回到启动前的样子（对话不留在终端滚动记录里）。`/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.1",
+  "version": "0.5.3",
   "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/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/supervisor.js

@@ -49,7 +49,7 @@ export function shouldSupervise(argv, env = process.env, isTty = (fd) => tty.isa
 function putTerminalRight() {
   // The child may have died with the terminal in the mode it had set for itself.
   // (the fullscreen renderer's alternate screen and mouse reporting included)
-  try { process.stdout.write('\x1b[?1000l\x1b[?1006l\x1b[?1049l\x1b[?2004l\x1b[?25h'); } catch { /* nothing to do */ }
+  try { process.stdout.write('\x1b[?1000l\x1b[?1002l\x1b[?1006l\x1b[?1049l\x1b[?2004l\x1b[?25h'); } catch { /* nothing to do */ }
   try { if (tty.isatty(0)) process.stdin.setRawMode(false); } catch { /* nothing to do */ }
 }
 

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 } 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, 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,7 +398,7 @@ 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();
     } catch (e) {
@@ -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');
@@ -1000,7 +1010,8 @@ export class App {
 
   // 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 } = {}) {
+  // `quiet`: a periodic check, which says nothing when the install fails (it is tried again in a minute).
+  async autoUpdate({ force = false, quiet = false } = {}) {
     if (this.updating) { if (force) this.notice('An update is already being installed.'); return; }
     let r;
     try {
@@ -1016,7 +1027,7 @@ export class App {
       if (canRestart()) { this.sourceChanged = true; if (!this.busy) this.maybeAutoReload(); }
       else this.notice('Restart the program to use it.');
     } 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.`);
     }
@@ -1073,29 +1084,66 @@ 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;
   }
 
-  // Fullscreen: the wheel scrolls the conversation (CLAUDE_PRO_SCROLL_SPEED rows a notch, 3 by default).
-  onMouse({ button }) {
-    if (!this.screen.full || this.exiting || !(button & 64) || button & 128) return;
-    const speed = Math.max(1, Math.min(20, Number(this.config.env.CLAUDE_PRO_SCROLL_SPEED) || 3));
-    this.screen.scrollBy(button & 1 ? -speed : speed);
+  // Fullscreen: the wheel scrolls the conversation (CLAUDE_PRO_SCROLL_SPEED rows a notch, 3 by default); a drag,
+  // a double or a triple click selects, and what is selected goes to the clipboard (see Screen.mouse).
+  onMouse(m) {
+    if (!this.screen.full || this.exiting) return;
+    if (m.button & 64) {
+      if (m.button & 128) return;
+      const speed = Math.max(1, Math.min(20, Number(this.config.env.CLAUDE_PRO_SCROLL_SPEED) || 3));
+      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);
+  }
+
+  copyText(text) {
+    writeClipboard(text).then((ok) => {
+      if (ok) this.flash(`Copied ${text.length.toLocaleString()} characters to the clipboard`);
+      else this.flash('Could not copy: no clipboard tool found (hold Shift and drag to select with the terminal)', 'warn');
+    });
   }
 
   onKey(str, key) {
     if (this.exiting) return;
     if (key.sequence === '\x1b[I') { this.focused = true; return; }
     if (key.sequence === '\x1b[O') { this.focused = false; return; }
-    if (key.ctrl && key.name === 'c') { this.onCtrlC(); return; }
     if (this.screen.full) {
       const half = Math.max(1, Math.floor((this.screen.lastArea || this.screen.height) / 2));
       if (key.name === 'pageup') { this.screen.scrollBy(half); return; }
       if (key.name === 'pagedown') { this.screen.scrollBy(-half); return; }
       if (key.ctrl && key.name === 'home') { this.screen.scrollBy('top'); return; }
       if (key.ctrl && key.name === 'end') { this.screen.scrollBy('bottom'); return; }
+      // A selection: ctrl+c copies it (and does not interrupt), esc only clears it, any other key clears it and
+      // then does what it does.
+      if (this.screen.selection) {
+        if (key.ctrl && key.name === 'c') { this.copyText(this.screen.selectedText()); this.screen.clearSelection(); return; }
+        this.screen.clearSelection();
+        if (key.name === 'escape') return;
+      }
     }
+    if (key.ctrl && key.name === 'c') { this.onCtrlC(); return; }
     const dialog = this.dialogs[0];
     if (dialog) {
       dialog.handleKey(str, key);

package/src/ui/screen.js

@@ -29,7 +29,7 @@
 // of a restart) goes on right below the output.
 
 import { PassThrough } from 'node:stream';
-import { ESC, wrapLine, termWidth, truncate, stringWidth } from './ansi.js';
+import { ESC, wrapLine, termWidth, truncate, stringWidth, stripAnsi, graphemes, graphemeWidth } from './ansi.js';
 
 const SYNC_START = '\x1b[?2026h';
 const SYNC_END = '\x1b[?2026l';
@@ -39,8 +39,24 @@ const RESIZE_MAX_WAIT_MS = 300; // ... or at the latest this long after it start
 const HISTORY_KEEP = 600; // static lines remembered for repainting (a screen shows far fewer)
 const HISTORY_LINE_CHARS = 20_000;
 const FULL_KEEP = 20_000; // fullscreen: lines of the conversation kept to scroll back through
-const ALT_ON = '\x1b[?1049h\x1b[?1000h\x1b[?1006h'; // the alternate screen, and mouse buttons and wheel reported (SGR)
-const ALT_OFF = '\x1b[?1000l\x1b[?1006l\x1b[?1049l';
+// The alternate screen, and the mouse reported (SGR): buttons, the wheel, and moves while a button is held (a drag).
+const ALT_ON = '\x1b[?1049h\x1b[?1002h\x1b[?1006h';
+const ALT_OFF = '\x1b[?1002l\x1b[?1006l\x1b[?1049l';
+const MULTI_CLICK_MS = 450;
+
+// The part of `plain` (no escape codes) between columns `from` (included) and `to` (not).
+function sliceCols(plain, from, to) {
+  let out = '';
+  let col = 0;
+  for (const g of graphemes(plain)) {
+    if (col >= to) break;
+    if (col >= from) out += g;
+    col += graphemeWidth(g);
+  }
+  return out;
+}
+
+const before = (a, b) => a.line < b.line || (a.line === b.line && (a.sub < b.sub || (a.sub === b.sub && a.col <= b.col)));
 const MOUSE = /\x1b\[<(\d+);(\d+);(\d+)([Mm])/g;
 
 // The keys of `stdin` without the mouse reports in it (SGR: ESC [ < b ; x ; y M/m), which go to
@@ -128,6 +144,11 @@ export class Screen {
     this.wrapped = []; // fullscreen: history[i] wrapped to wrapCols - 1, made when first needed
     this.wrapCols = 0;
     this.lastArea = 0; // fullscreen: rows the conversation had on screen at the last draw
+    this.viewMap = []; // fullscreen: what each row of the conversation area shows, {line, sub} (null: blank)
+    this.barRow = null; // fullscreen: the row of the "Jump to bottom" bar, when it is shown
+    this.selection = null; // fullscreen: {anchor, focus}, points {line, sub, col} of the conversation (history line, wrapped row, column)
+    this.dragging = false;
+    this.lastClick = { at: 0, x: 0, y: 0, count: 0 };
     this.cursorRow = 0; // row of the terminal cursor, relative to the top of the live region
     this.staticQueue = [];
     this.history = []; // the most recent static lines, for repainting after a resize
@@ -201,7 +222,7 @@ export class Screen {
   }
 
   wrappedAt(i, cols) {
-    if (this.wrapCols !== cols) { this.wrapped = []; this.wrapCols = cols; }
+    if (this.wrapCols !== cols) { this.wrapped = []; this.wrapCols = cols; this.selection = null; } // its rows are other rows now
     return (this.wrapped[i] ??= wrapLine(this.history[i], Math.max(1, cols - 1)));
   }
 
@@ -212,17 +233,149 @@ export class Screen {
     return n;
   }
 
-  // `rows` rows of the conversation, ending `this.scroll` rows above its end; padded below when it is shorter.
+  // `rows` rows of the conversation, ending `this.scroll` rows above its end, as {text, line, sub}; padded below
+  // with null when it is shorter.
   view(rows, cols) {
     const need = rows + this.scroll;
-    const got = [];
-    for (let i = this.history.length - 1; i >= 0 && got.length < need; i--) got.unshift(...this.wrappedAt(i, cols));
+    const chunks = [];
+    let count = 0;
+    for (let i = this.history.length - 1; i >= 0 && count < need; i--) {
+      const w = this.wrappedAt(i, cols);
+      chunks.push(w.map((text, sub) => ({ text, line: i, sub })));
+      count += w.length;
+    }
+    const got = chunks.reverse().flat();
     const end = Math.max(0, got.length - this.scroll);
     const shown = got.slice(Math.max(0, end - rows), end);
-    while (shown.length < rows) shown.push('');
+    while (shown.length < rows) shown.push(null);
     return shown;
   }
 
+  // ------------------------------------------------------------ selecting with the mouse (fullscreen)
+
+  // The selection in order: [start, end].
+  ordered() {
+    const { anchor, focus } = this.selection;
+    return before(anchor, focus) ? [anchor, focus] : [focus, anchor];
+  }
+
+  // The columns of row {line, sub} that are selected: [from, to), or null.
+  selectedCols(e) {
+    if (!this.selection) return null;
+    const [a, b] = this.ordered();
+    const row = { line: e.line, sub: e.sub, col: 0 };
+    if (before(row, { ...a, col: -1 }) || !before({ ...row, col: 0 }, { ...b, col: Infinity })) return null;
+    const from = e.line === a.line && e.sub === a.sub ? a.col : 0;
+    const to = e.line === b.line && e.sub === b.sub ? b.col + 1 : Infinity;
+    return to > from ? [from, to] : null;
+  }
+
+  paintRow(e) {
+    const cols = this.selectedCols(e);
+    if (!cols) return e.text;
+    const plain = stripAnsi(e.text);
+    return sliceCols(plain, 0, cols[0]) + '\x1b[7m' + sliceCols(plain, cols[0], cols[1]) + '\x1b[27m' + sliceCols(plain, cols[1], Infinity);
+  }
+
+  // The text selected, as it was printed: rows a long line was wrapped onto are joined again.
+  selectedText() {
+    if (!this.selection) return '';
+    const cols = this.width;
+    const [a, b] = this.ordered();
+    const lines = [];
+    for (let line = a.line; line <= b.line && line < this.history.length; line++) {
+      const rows = this.wrappedAt(line, cols);
+      let text = '';
+      rows.forEach((row, sub) => {
+        const range = this.selectedCols({ line, sub });
+        if (range) text += sliceCols(stripAnsi(row), range[0], range[1]);
+      });
+      lines.push(text.replace(/\s+$/, ''));
+    }
+    return lines.join('\n');
+  }
+
+  clearSelection() {
+    if (!this.selection) return false;
+    this.selection = null;
+    this.dragging = false;
+    this.draw();
+    return true;
+  }
+
+  // The point of the conversation at screen cell (x, y), 1-based: the nearest row that shows some of it.
+  pointAt(x, y) {
+    let i = Math.max(0, Math.min(this.lastArea - 1, y - 1));
+    while (i > 0 && !this.viewMap[i]) i--;
+    const e = this.viewMap[i];
+    return e ? { line: e.line, sub: e.sub, col: Math.max(0, x - 1) } : null;
+  }
+
+  // Word (`whole`: the whole line) around point `p`.
+  expand(p, whole) {
+    const rows = this.wrappedAt(p.line, this.width);
+    if (whole) return { anchor: { line: p.line, sub: 0, col: 0 }, focus: { line: p.line, sub: rows.length - 1, col: Infinity } };
+    const cells = [];
+    for (const g of graphemes(stripAnsi(rows[p.sub] || ''))) {
+      for (let k = 0; k < Math.max(1, graphemeWidth(g)); k++) cells.push(g);
+    }
+    const word = (g) => g !== undefined && !/\s/.test(g);
+    if (!word(cells[p.col])) return null;
+    let from = p.col;
+    let to = p.col;
+    while (word(cells[from - 1])) from--;
+    while (word(cells[to + 1])) to++;
+    return { anchor: { ...p, col: from }, focus: { ...p, col: to } };
+  }
+
+  // A mouse report (fullscreen). Returns {copy: text} when a selection was made, for the caller to put on the
+  // clipboard. Drag to select (the view scrolls at its edges), double-click a word, triple-click a line; a click
+  // clears the selection; a click on the "Jump to bottom" bar goes there.
+  mouse({ button, x, y, release }) {
+    if (!this.full || this.closed) return null;
+    if (button & 64) return null; // the wheel: the caller scrolls
+    const left = (button & 3) === 0;
+    if (!left) return null;
+    const motion = Boolean(button & 32);
+    if (!motion && !release) { // a press
+      const now = Date.now();
+      const c = this.lastClick;
+      const count = now - c.at < MULTI_CLICK_MS && Math.abs(c.x - x) <= 1 && c.y === y ? c.count + 1 : 1;
+      this.lastClick = { at: now, x, y, count };
+      if (this.barRow !== null && y - 1 === this.barRow) { this.selection = null; this.scrollBy('bottom'); return null; }
+      if (y - 1 >= this.lastArea) { this.clearSelection(); return null; } // the input box, the footer
+      const p = this.pointAt(x, y);
+      if (!p) { this.clearSelection(); return null; }
+      if (count >= 2) {
+        const sel = this.expand(p, count >= 3);
+        this.selection = sel;
+        this.dragging = false;
+        this.draw();
+        const text = sel ? this.selectedText() : '';
+        return text ? { copy: text } : null;
+      }
+      this.selection = { anchor: p, focus: { ...p }, moved: false };
+      this.dragging = true;
+      return null;
+    }
+    if (!this.dragging || !this.selection) return null;
+    if (motion) {
+      // past the top or the bottom of the conversation: it scrolls, and the selection goes on with it
+      if (y <= 1) this.scrollBy(1);
+      else if (y - 1 >= this.lastArea - 1 && this.scroll > 0) this.scrollBy(-1);
+      const p = this.pointAt(x, y);
+      if (p) { this.selection.focus = p; this.selection.moved = true; }
+      this.draw();
+      return null;
+    }
+    // released
+    this.dragging = false;
+    if (!this.selection.moved) { this.clearSelection(); return null; } // a plain click
+    this.lastClick.count = 0; // a drag: the next click starts a count of its own
+    const text = this.selectedText();
+    return text ? { copy: text } : null;
+  }
+
   // Scroll the conversation up (`rows` > 0) or down. 'top' and 'bottom' go to its ends.
   scrollBy(rows) {
     if (!this.full) return;
@@ -254,8 +407,11 @@ export class Screen {
     const layout = this.layoutLive(cols);
     const area = Math.max(0, screenRows - layout.rows.length);
     this.lastArea = area;
-    const top = this.view(area, cols);
-    if (this.scroll > 0 && area > 0) top[area - 1] = this.jumpBar(cols);
+    const shown = this.view(area, cols);
+    this.viewMap = shown;
+    const top = shown.map((e) => (e ? this.paintRow(e) : ''));
+    this.barRow = this.scroll > 0 && area > 0 ? area - 1 : null;
+    if (this.barRow !== null) top[this.barRow] = this.jumpBar(cols);
     const frame = [...top, ...layout.rows];
     let buf = SYNC_START + ESC.hideCursor + this.titleUpdate();
     if (full) { buf += '\x1b[2J'; this.frame = []; }
@@ -318,6 +474,10 @@ export class Screen {
       const drop = this.history.length - keep;
       this.history.splice(0, drop);
       this.wrapped.splice(0, drop);
+      if (this.selection) {
+        for (const p of [this.selection.anchor, this.selection.focus]) p.line -= drop;
+        if (this.selection.anchor.line < 0 || this.selection.focus.line < 0) this.selection = null;
+      }
     }
     return lines;
   }
@@ -472,6 +632,7 @@ export class Screen {
     if (this.full) {
       this.history = [];
       this.wrapped = [];
+      this.selection = null;
       this.scroll = 0;
       this.unseen = 0;
       this.staticQueue = [];

package/src/updater.js

@@ -1,6 +1,8 @@
 // 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
+// version on the npm registry (when it starts and every few minutes while it runs; the sessions of a machine share
+// the interval), installs it in the background, and the session then loads it with a restart once it is idle (the
+// conversation carries over). The other sessions of the machine see the files change and restart too (see
+// 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';
@@ -12,7 +14,8 @@ 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;
+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;
@@ -44,7 +47,9 @@ function writeState(s) { try { fs.mkdirSync(CONFIG_DIR, { recursive: true }); fs
 
 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; });
@@ -86,8 +91,12 @@ export async function checkForUpdate({ force = false, env = process.env, onInsta
     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') };
+  // --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({ checkedAt: Date.now(), installed: latest });
   return { status: 'updated', version: latest };
 }

package/src/utils/clipboard.js

@@ -135,6 +135,64 @@ async function readLinux() {
   return { error: null };
 }
 
+// Put `text` on the system clipboard (the fullscreen renderer's selection): Windows PowerShell (read as UTF-8 from
+// stdin, so any text and any length), pbcopy on macOS, wl-copy / xclip / xsel elsewhere. Resolves with whether
+// one of them took it.
+export async function writeClipboard(text) {
+  const tries = process.platform === 'win32'
+    ? [['powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', '$s=[IO.StreamReader]::new([Console]::OpenStandardInput(),[Text.Encoding]::UTF8).ReadToEnd(); Set-Clipboard -Value $s']]]
+    : process.platform === 'darwin'
+      ? [['pbcopy', []]]
+      : [['wl-copy', []], ['xclip', ['-selection', 'clipboard']], ['xsel', ['--clipboard', '--input']]];
+  for (const [cmd, args] of tries) {
+    const ok = await new Promise((resolve) => {
+      let child;
+      try {
+        child = spawn(cmd, args, { windowsHide: true, stdio: ['pipe', 'ignore', 'ignore'] });
+      } catch {
+        resolve(false);
+        return;
+      }
+      const timer = setTimeout(() => child.kill(), 10_000);
+      child.on('error', () => { clearTimeout(timer); resolve(false); });
+      child.on('close', (code) => { clearTimeout(timer); resolve(code === 0); });
+      child.stdin.on('error', () => {});
+      child.stdin.end(Buffer.from(process.platform === 'win32' ? text.replace(/\r?\n/g, '\r\n') : text, 'utf8'));
+    });
+    if (ok) return true;
+  }
+  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);