@yanzc/claude-pro 0.5.2 → 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`，**点它**或按 `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.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/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, 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,7 +1084,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 +1098,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);
   }

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

@@ -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);