@yanzc/claude-pro 0.5.3 → 0.5.5

package/README.md

@@ -28,7 +28,12 @@ npm install -g @yanzc/claude-pro
 claude-pro                 # 在任意项目目录里运行
 ```
 
-自动更新（与 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 检出）的副本从不自动更新。
+自动更新（与 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 检出）的副本从不自动更新。
 
 从源码运行：
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yanzc/claude-pro",
-  "version": "0.5.3",
+  "version": "0.5.5",
   "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/agent.js

@@ -7,7 +7,7 @@ import { streamMessage, contextTokens, isAbort } from './api.js';
 import { compactPrompt, partialCompactPrompt, partialSummaryMessage, continuationMessage, PLAN_MODE_REMINDER, SUMMARY_SYSTEM } from './prompts.js';
 import { toolResultsDir } from './session.js';
 import { rebuildFileState } from './filestate.js';
-import { CacheStats } from './cache.js';
+import { CacheStats, TTL_MS } from './cache.js';
 import { resolvePath } from './utils/paths.js';
 import { fitImagesIn } from './utils/images.js';
 
@@ -359,6 +359,14 @@ export class Agent {
     return out;
   }
 
+  // Is the conversation's prompt cache known to have run out? From the last request of this process when there was
+  // one, else (a resumed or restarted conversation) from when the last message was added, which is after its
+  // request started: that guess errs towards warm. Not knowing counts as warm.
+  cacheExpired(now = Date.now()) {
+    if (this.cache.expected != null) return now >= this.cache.expiresAt;
+    return this.lastActivityAt > 0 && now - this.lastActivityAt >= TTL_MS[this.config.cacheTtl('main')];
+  }
+
   // A new request from the user goes back to the effort the user chose, after the Effort tool changed it for
   // the one before. A request that a restart continues keeps it.
   endEffortBoost() {
@@ -728,8 +736,12 @@ export class Agent {
   // the biggest request there is). Only if that does not give a summary (the model went on calling tools, or
   // the request is too long by the size of the instruction) the plainer request is made: a short system prompt
   // and no effort, which cannot share the cache, but is smaller and cannot be led astray by the main prompt.
+  // The messages are marked for the cache only where that can be read: no request after the summary starts with
+  // this history, so writing it (25% over the plain input price) pays only for reading what is already there.
+  // When the cache is known to have run out, and in the plain request, only the tools and system prompt are marked.
   async requestSummary(messages, { signal, onEvent }) {
-    const call = (request) => streamMessage(this.config, { model: this.model, tools: this.toolSchemas(), messages, cacheBucket: 'other', ...(this.effort ? { effort: this.effort } : {}), ...request }, { signal, onEvent });
+    const cacheMessages = !this.cacheExpired();
+    const call = (request) => streamMessage(this.config, { model: this.model, tools: this.toolSchemas(), messages, cacheBucket: 'other', cacheMessages, ...(this.effort ? { effort: this.effort } : {}), ...request }, { signal, onEvent });
     try {
       const res = await call({ system: this.currentSystem() });
       this.recordUsage(res, 'summary');
@@ -737,7 +749,7 @@ export class Agent {
     } catch (err) {
       if (isAbort(err) || signal?.aborted || !err.promptTooLong) throw err;
     }
-    const res = await call({ system: SUMMARY_SYSTEM, effort: null });
+    const res = await call({ system: SUMMARY_SYSTEM, effort: null, cacheMessages: false });
     this.recordUsage({ ...res, cache: { ...res.cache, caching: false } }, 'summary'); // made to miss: not a miss to report
     return res;
   }

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/ui/repl.js

@@ -31,7 +31,7 @@ import { readClipboardImage, imageFromFile, watchClipboard, writeClipboard, read
 import { fitImagesIn } from '../utils/images.js';
 import { downloadsDir, filesToSend, formatBytes } from '../utils/downloads.js';
 import { copyUnique } from '../transfer.js';
-import { checkForUpdate, CHECK_EVERY_MS } 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';
@@ -400,7 +400,7 @@ export class App {
   async startPeer() {
     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');
@@ -886,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;
@@ -985,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();
     });
   }
@@ -996,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;
@@ -1005,27 +1019,34 @@ 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.
-  // `quiet`: a periodic check, which says nothing when the install fails (it is tried again in a minute).
+  // 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('An update is already being installed.'); return; }
+    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 && !quiet)) this.notice(`Could not update ${APP_NAME}${r.version ? ` to ${r.version}` : ''}: ${r.error}`, 'warn');
     } else if (force) {
@@ -1033,6 +1054,58 @@ export class App {
     }
   }
 
+  // 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);
@@ -1501,6 +1574,7 @@ export class App {
       this.runAgent(this.agent.drainNotifications());
     } else {
       this.maybeAutoReload();
+      this.maybeInstallUpdate();
     }
   }
 
@@ -2081,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,9 +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 (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.
+// 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';
@@ -14,6 +15,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 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
 
@@ -42,6 +45,40 @@ 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 */ } }
 
@@ -75,16 +112,41 @@ 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())) {
@@ -97,6 +159,6 @@ export async function checkForUpdate({ force = false, env = process.env, onInsta
     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 });
+  writeState({ ...readState(), installed: latest });
   return { status: 'updated', version: latest };
 }