clawt 2.17.1 → 2.19.0

package/tests/unit/utils/formatter.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi } from 'vitest';
-import { formatWorktreeStatus, printSuccess, printError, printWarning, printInfo, printSeparator, printDoubleSeparator, isWorktreeIdle, formatDuration, formatRelativeTime } from '../../../src/utils/formatter.js';
+import { formatWorktreeStatus, printSuccess, printError, printWarning, printInfo, printSeparator, printDoubleSeparator, isWorktreeIdle, formatDuration, formatRelativeTime, formatDiskSize, formatLocalISOString } from '../../../src/utils/formatter.js';
 import { createWorktreeStatus } from '../../helpers/fixtures.js';
 
 describe('formatWorktreeStatus', () => {
@@ -177,3 +177,93 @@ describe('formatRelativeTime', () => {
     expect(formatRelativeTime(future.toISOString())).toBe('刚刚');
   });
 });
+
+describe('formatDiskSize', () => {
+  it('0 字节时返回 "0 B"', () => {
+    expect(formatDiskSize(0)).toBe('0 B');
+  });
+
+  it('小于 1 KB 时以 B 为单位', () => {
+    expect(formatDiskSize(1)).toBe('1 B');
+    expect(formatDiskSize(512)).toBe('512 B');
+    expect(formatDiskSize(1023)).toBe('1023 B');
+  });
+
+  it('恰好 1 KB 时返回 "1.0 KB"', () => {
+    expect(formatDiskSize(1024)).toBe('1.0 KB');
+  });
+
+  it('KB 范围内保留一位小数', () => {
+    expect(formatDiskSize(1536)).toBe('1.5 KB');
+    expect(formatDiskSize(10240)).toBe('10.0 KB');
+    expect(formatDiskSize(1024 * 1024 - 1)).toBe('1024.0 KB');
+  });
+
+  it('恰好 1 MB 时返回 "1.0 MB"', () => {
+    expect(formatDiskSize(1024 * 1024)).toBe('1.0 MB');
+  });
+
+  it('MB 范围内保留一位小数', () => {
+    expect(formatDiskSize(1.5 * 1024 * 1024)).toBe('1.5 MB');
+    expect(formatDiskSize(256 * 1024 * 1024)).toBe('256.0 MB');
+    expect(formatDiskSize(1024 * 1024 * 1024 - 1)).toBe('1024.0 MB');
+  });
+
+  it('恰好 1 GB 时返回 "1.0 GB"', () => {
+    expect(formatDiskSize(1024 * 1024 * 1024)).toBe('1.0 GB');
+  });
+
+  it('GB 范围内保留一位小数', () => {
+    expect(formatDiskSize(1.5 * 1024 * 1024 * 1024)).toBe('1.5 GB');
+    expect(formatDiskSize(10 * 1024 * 1024 * 1024)).toBe('10.0 GB');
+  });
+});
+
+describe('formatLocalISOString', () => {
+  it('返回值包含日期和时间部分', () => {
+    const date = new Date('2025-06-15T10:30:00Z');
+    const result = formatLocalISOString(date);
+    // 结果应符合 ISO 8601 带时区偏移的格式
+    expect(result).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}[+-]\d{2}:\d{2}$/);
+  });
+
+  it('返回值不以 Z 结尾（应包含时区偏移）', () => {
+    const date = new Date();
+    const result = formatLocalISOString(date);
+    expect(result).not.toMatch(/Z$/);
+  });
+
+  it('时区偏移格式为 +HH:MM 或 -HH:MM', () => {
+    const date = new Date();
+    const result = formatLocalISOString(date);
+    const tzPart = result.slice(-6);
+    expect(tzPart).toMatch(/^[+-]\d{2}:\d{2}$/);
+  });
+
+  it('时区偏移量与本机 getTimezoneOffset 一致', () => {
+    const date = new Date('2025-01-01T12:00:00Z');
+    const result = formatLocalISOString(date);
+    const tzPart = result.slice(-6);
+    const sign = tzPart[0];
+    const hours = parseInt(tzPart.slice(1, 3), 10);
+    const minutes = parseInt(tzPart.slice(4, 6), 10);
+
+    // 从偏移字符串反推总分钟数
+    const totalMinutesFromResult = (sign === '+' ? 1 : -1) * (hours * 60 + minutes);
+    const expectedMinutes = -date.getTimezoneOffset();
+    expect(totalMinutesFromResult).toBe(expectedMinutes);
+  });
+
+  it('不同日期对象产生不同的输出', () => {
+    const date1 = new Date('2025-01-01T00:00:00Z');
+    const date2 = new Date('2025-06-15T12:30:00Z');
+    expect(formatLocalISOString(date1)).not.toBe(formatLocalISOString(date2));
+  });
+
+  it('毫秒部分被保留', () => {
+    const date = new Date('2025-03-20T08:15:30.123Z');
+    const result = formatLocalISOString(date);
+    // 毫秒值应出现在结果中
+    expect(result).toContain('.123');
+  });
+});

package/tests/unit/utils/fs.test.ts

@@ -6,15 +6,17 @@ vi.mock('node:fs', () => ({
   mkdirSync: vi.fn(),
   readdirSync: vi.fn(),
   rmdirSync: vi.fn(),
+  statSync: vi.fn(),
 }));
 
-import { existsSync, mkdirSync, readdirSync, rmdirSync } from 'node:fs';
-import { ensureDir, removeEmptyDir } from '../../../src/utils/fs.js';
+import { existsSync, mkdirSync, readdirSync, rmdirSync, statSync } from 'node:fs';
+import { ensureDir, removeEmptyDir, calculateDirSize } from '../../../src/utils/fs.js';
 
 const mockedExistsSync = vi.mocked(existsSync);
 const mockedMkdirSync = vi.mocked(mkdirSync);
 const mockedReaddirSync = vi.mocked(readdirSync);
 const mockedRmdirSync = vi.mocked(rmdirSync);
+const mockedStatSync = vi.mocked(statSync);
 
 describe('ensureDir', () => {
   it('目录不存在时创建', () => {
@@ -52,3 +54,124 @@ describe('removeEmptyDir', () => {
     expect(mockedReaddirSync).not.toHaveBeenCalled();
   });
 });
+
+/**
+ * 创建模拟的 Dirent 对象
+ * @param {string} name - 文件/目录名
+ * @param {'file' | 'directory'} type - 类型
+ * @returns {import('node:fs').Dirent} 模拟的 Dirent 对象
+ */
+function createMockDirent(name: string, type: 'file' | 'directory') {
+  return {
+    name,
+    isFile: () => type === 'file',
+    isDirectory: () => type === 'directory',
+    isBlockDevice: () => false,
+    isCharacterDevice: () => false,
+    isSymbolicLink: () => false,
+    isFIFO: () => false,
+    isSocket: () => false,
+    parentPath: '',
+    path: '',
+  } as import('node:fs').Dirent;
+}
+
+describe('calculateDirSize', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('空目录返回 0', () => {
+    mockedReaddirSync.mockReturnValue([]);
+    expect(calculateDirSize('/tmp/empty')).toBe(0);
+  });
+
+  it('只有文件时累加所有文件大小', () => {
+    mockedReaddirSync.mockReturnValue([
+      createMockDirent('a.txt', 'file'),
+      createMockDirent('b.txt', 'file'),
+    ]);
+    mockedStatSync
+      .mockReturnValueOnce({ size: 100 } as import('node:fs').Stats)
+      .mockReturnValueOnce({ size: 200 } as import('node:fs').Stats);
+
+    expect(calculateDirSize('/tmp/dir')).toBe(300);
+  });
+
+  it('递归计算子目录中的文件大小', () => {
+    // 第一次调用：顶层目录包含一个文件和一个子目录
+    mockedReaddirSync
+      .mockReturnValueOnce([
+        createMockDirent('file.txt', 'file'),
+        createMockDirent('subdir', 'directory'),
+      ])
+      // 第二次调用：子目录包含一个文件
+      .mockReturnValueOnce([
+        createMockDirent('nested.txt', 'file'),
+      ]);
+
+    mockedStatSync
+      .mockReturnValueOnce({ size: 500 } as import('node:fs').Stats)
+      .mockReturnValueOnce({ size: 300 } as import('node:fs').Stats);
+
+    expect(calculateDirSize('/tmp/dir')).toBe(800);
+  });
+
+  it('readdirSync 抛出异常时返回 0', () => {
+    mockedReaddirSync.mockImplementation(() => {
+      throw new Error('权限不足');
+    });
+    expect(calculateDirSize('/tmp/no-access')).toBe(0);
+  });
+
+  it('statSync 对个别文件抛出异常时跳过该文件继续计算', () => {
+    mockedReaddirSync.mockReturnValue([
+      createMockDirent('good.txt', 'file'),
+      createMockDirent('bad.txt', 'file'),
+      createMockDirent('ok.txt', 'file'),
+    ]);
+    mockedStatSync
+      .mockReturnValueOnce({ size: 100 } as import('node:fs').Stats)
+      .mockImplementationOnce(() => { throw new Error('无法访问'); })
+      .mockReturnValueOnce({ size: 200 } as import('node:fs').Stats);
+
+    expect(calculateDirSize('/tmp/dir')).toBe(300);
+  });
+
+  it('多层嵌套目录正确累加', () => {
+    // 顶层：子目录 a
+    mockedReaddirSync
+      .mockReturnValueOnce([
+        createMockDirent('a', 'directory'),
+      ])
+      // a 目录：文件 + 子目录 b
+      .mockReturnValueOnce([
+        createMockDirent('x.txt', 'file'),
+        createMockDirent('b', 'directory'),
+      ])
+      // b 目录：一个文件
+      .mockReturnValueOnce([
+        createMockDirent('y.txt', 'file'),
+      ]);
+
+    mockedStatSync
+      .mockReturnValueOnce({ size: 1000 } as import('node:fs').Stats)
+      .mockReturnValueOnce({ size: 2000 } as import('node:fs').Stats);
+
+    expect(calculateDirSize('/tmp/root')).toBe(3000);
+  });
+
+  it('只包含子目录（无直接文件）时正确递归', () => {
+    mockedReaddirSync
+      .mockReturnValueOnce([
+        createMockDirent('sub', 'directory'),
+      ])
+      .mockReturnValueOnce([
+        createMockDirent('inner.txt', 'file'),
+      ]);
+
+    mockedStatSync.mockReturnValueOnce({ size: 42 } as import('node:fs').Stats);
+
+    expect(calculateDirSize('/tmp/dir')).toBe(42);
+  });
+});

package/tests/unit/utils/update-checker.test.ts

@@ -0,0 +1,439 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { IncomingMessage, ClientRequest } from 'node:http';
+import { EventEmitter } from 'node:events';
+
+// mock node:fs
+vi.mock('node:fs', () => ({
+  readFileSync: vi.fn(),
+  writeFileSync: vi.fn(),
+}));
+
+// mock node:child_process
+vi.mock('node:child_process', () => ({
+  execSync: vi.fn(),
+}));
+
+// mock node:https
+vi.mock('node:https', () => ({
+  request: vi.fn(),
+}));
+
+// mock chalk（测试环境已通过 FORCE_COLOR=0 禁用颜色，但仍需确保不产生转义码）
+vi.mock('chalk', () => ({
+  default: {
+    red: (s: string) => s,
+    green: (s: string) => s,
+    cyan: (s: string) => s,
+  },
+}));
+
+// mock string-width（纯 ASCII 场景下直接返回字符串长度即可）
+vi.mock('string-width', () => ({
+  default: (s: string) => s.length,
+}));
+
+// mock 常量路径
+vi.mock('../../../src/constants/index.js', async (importOriginal) => {
+  const original = await importOriginal<typeof import('../../../src/constants/index.js')>();
+  return {
+    ...original,
+    UPDATE_CHECK_PATH: '/tmp/test-update-check.json',
+  };
+});
+
+import { readFileSync, writeFileSync } from 'node:fs';
+import { execSync } from 'node:child_process';
+import { request } from 'node:https';
+import { checkForUpdates } from '../../../src/utils/update-checker.js';
+
+const mockedReadFileSync = vi.mocked(readFileSync);
+const mockedWriteFileSync = vi.mocked(writeFileSync);
+const mockedExecSync = vi.mocked(execSync);
+const mockedRequest = vi.mocked(request);
+
+/**
+ * 创建一个模拟的 https 响应，返回指定的 JSON 数据
+ * @param {string} body - 响应体内容
+ * @returns {{ req: EventEmitter, res: EventEmitter }} 模拟的请求和响应对象
+ */
+function createMockHttpResponse(body: string): { req: EventEmitter & { end: ReturnType<typeof vi.fn>; destroy: ReturnType<typeof vi.fn> }; res: EventEmitter } {
+  const req = Object.assign(new EventEmitter(), {
+    end: vi.fn(),
+    destroy: vi.fn(),
+  });
+  const res = new EventEmitter();
+
+  mockedRequest.mockImplementation((_url: unknown, _opts: unknown, cb?: (res: IncomingMessage) => void) => {
+    // 在下一个微任务中触发回调，模拟异步行为
+    queueMicrotask(() => {
+      cb?.(res as unknown as IncomingMessage);
+      res.emit('data', Buffer.from(body));
+      res.emit('end');
+    });
+    return req as unknown as ClientRequest;
+  });
+
+  return { req, res };
+}
+
+/**
+ * 创建一个会触发错误的模拟 https 请求
+ * @returns {{ req: EventEmitter }} 模拟的请求对象
+ */
+function createMockHttpError(): { req: EventEmitter & { end: ReturnType<typeof vi.fn>; destroy: ReturnType<typeof vi.fn> } } {
+  const req = Object.assign(new EventEmitter(), {
+    end: vi.fn(),
+    destroy: vi.fn(),
+  });
+
+  mockedRequest.mockImplementation(() => {
+    queueMicrotask(() => {
+      req.emit('error', new Error('network error'));
+    });
+    return req as unknown as ClientRequest;
+  });
+
+  return { req };
+}
+
+/**
+ * 创建一个会触发超时的模拟 https 请求
+ * @returns {{ req: EventEmitter }} 模拟的请求对象
+ */
+function createMockHttpTimeout(): { req: EventEmitter & { end: ReturnType<typeof vi.fn>; destroy: ReturnType<typeof vi.fn> } } {
+  const req = Object.assign(new EventEmitter(), {
+    end: vi.fn(),
+    destroy: vi.fn(),
+  });
+
+  mockedRequest.mockImplementation(() => {
+    queueMicrotask(() => {
+      req.emit('timeout');
+    });
+    return req as unknown as ClientRequest;
+  });
+
+  return { req };
+}
+
+beforeEach(() => {
+  vi.spyOn(console, 'log').mockImplementation(() => {});
+});
+
+// ========== 缓存读取与过期判断 ==========
+
+describe('checkForUpdates - 缓存逻辑', () => {
+  it('缓存不存在时请求 registry', async () => {
+    // 缓存文件不存在
+    mockedReadFileSync.mockImplementation(() => { throw new Error('ENOENT'); });
+    createMockHttpResponse(JSON.stringify({ version: '2.17.1' }));
+    mockedExecSync.mockImplementation(() => { throw new Error('not found'); });
+
+    await checkForUpdates('2.17.1');
+
+    expect(mockedRequest).toHaveBeenCalled();
+  });
+
+  it('缓存有效且无新版本时不打印提示', async () => {
+    const cache = {
+      lastCheck: Date.now(),
+      latestVersion: '2.17.1',
+      currentVersion: '2.17.1',
+    };
+    mockedReadFileSync.mockReturnValue(JSON.stringify(cache));
+
+    await checkForUpdates('2.17.1');
+
+    // 不应请求 registry
+    expect(mockedRequest).not.toHaveBeenCalled();
+    // 不应打印任何内容（无新版本）
+    expect(console.log).not.toHaveBeenCalled();
+  });
+
+  it('缓存有效且有新版本时打印提示', async () => {
+    const cache = {
+      lastCheck: Date.now(),
+      latestVersion: '2.18.0',
+      currentVersion: '2.17.1',
+    };
+    mockedReadFileSync.mockReturnValue(JSON.stringify(cache));
+    mockedExecSync.mockImplementation(() => { throw new Error('not found'); });
+
+    await checkForUpdates('2.17.1');
+
+    // 不应请求 registry（缓存有效）
+    expect(mockedRequest).not.toHaveBeenCalled();
+    // 应打印更新提示
+    expect(console.log).toHaveBeenCalled();
+    const allOutput = (console.log as ReturnType<typeof vi.fn>).mock.calls.map((c: unknown[]) => c[0]).join('\n');
+    expect(allOutput).toContain('2.18.0');
+    expect(allOutput).toContain('2.17.1');
+  });
+
+  it('缓存过期（超过 24h）时请求 registry', async () => {
+    const cache = {
+      lastCheck: Date.now() - 25 * 60 * 60 * 1000, // 25 小时前
+      latestVersion: '2.17.1',
+      currentVersion: '2.17.1',
+    };
+    mockedReadFileSync.mockReturnValue(JSON.stringify(cache));
+    createMockHttpResponse(JSON.stringify({ version: '2.17.1' }));
+    mockedExecSync.mockImplementation(() => { throw new Error('not found'); });
+
+    await checkForUpdates('2.17.1');
+
+    expect(mockedRequest).toHaveBeenCalled();
+  });
+
+  it('本地版本变化时视为缓存过期', async () => {
+    const cache = {
+      lastCheck: Date.now(), // 时间未过期
+      latestVersion: '2.18.0',
+      currentVersion: '2.16.0', // 与当前版本 2.17.1 不一致
+    };
+    mockedReadFileSync.mockReturnValue(JSON.stringify(cache));
+    createMockHttpResponse(JSON.stringify({ version: '2.18.0' }));
+    mockedExecSync.mockImplementation(() => { throw new Error('not found'); });
+
+    await checkForUpdates('2.17.1');
+
+    // 即使时间未过期，版本不一致也应重新请求
+    expect(mockedRequest).toHaveBeenCalled();
+  });
+
+  it('缓存文件损坏时请求 registry', async () => {
+    mockedReadFileSync.mockReturnValue('invalid json {{{');
+    createMockHttpResponse(JSON.stringify({ version: '2.17.1' }));
+    mockedExecSync.mockImplementation(() => { throw new Error('not found'); });
+
+    await checkForUpdates('2.17.1');
+
+    expect(mockedRequest).toHaveBeenCalled();
+  });
+});
+
+// ========== 网络请求逻辑 ==========
+
+describe('checkForUpdates - 网络请求', () => {
+  beforeEach(() => {
+    // 确保缓存不存在，强制走网络请求
+    mockedReadFileSync.mockImplementation(() => { throw new Error('ENOENT'); });
+    mockedExecSync.mockImplementation(() => { throw new Error('not found'); });
+  });
+
+  it('请求成功且有新版本时写入缓存并打印提示', async () => {
+    createMockHttpResponse(JSON.stringify({ version: '2.18.0' }));
+
+    await checkForUpdates('2.17.1');
+
+    // 应写入缓存
+    expect(mockedWriteFileSync).toHaveBeenCalledWith(
+      '/tmp/test-update-check.json',
+      expect.stringContaining('"latestVersion": "2.18.0"'),
+      'utf-8',
+    );
+    // 应打印提示
+    expect(console.log).toHaveBeenCalled();
+    const allOutput = (console.log as ReturnType<typeof vi.fn>).mock.calls.map((c: unknown[]) => c[0]).join('\n');
+    expect(allOutput).toContain('2.18.0');
+  });
+
+  it('请求成功但版本相同时写入缓存但不打印提示', async () => {
+    createMockHttpResponse(JSON.stringify({ version: '2.17.1' }));
+
+    await checkForUpdates('2.17.1');
+
+    // 应写入缓存
+    expect(mockedWriteFileSync).toHaveBeenCalled();
+    // 不应打印提示（版本相同）
+    expect(console.log).not.toHaveBeenCalled();
+  });
+
+  it('网络请求失败时静默忽略', async () => {
+    createMockHttpError();
+
+    await checkForUpdates('2.17.1');
+
+    // 不应写入缓存
+    expect(mockedWriteFileSync).not.toHaveBeenCalled();
+    // 不应打印提示
+    expect(console.log).not.toHaveBeenCalled();
+  });
+
+  it('网络请求超时时静默忽略并销毁连接', async () => {
+    const { req } = createMockHttpTimeout();
+
+    await checkForUpdates('2.17.1');
+
+    expect(req.destroy).toHaveBeenCalled();
+    expect(mockedWriteFileSync).not.toHaveBeenCalled();
+  });
+
+  it('registry 返回无效 JSON 时静默忽略', async () => {
+    createMockHttpResponse('not valid json');
+
+    await checkForUpdates('2.17.1');
+
+    expect(mockedWriteFileSync).not.toHaveBeenCalled();
+    expect(console.log).not.toHaveBeenCalled();
+  });
+
+  it('registry 返回的 JSON 中无 version 字段时静默忽略', async () => {
+    createMockHttpResponse(JSON.stringify({ name: 'clawt' }));
+
+    await checkForUpdates('2.17.1');
+
+    expect(mockedWriteFileSync).not.toHaveBeenCalled();
+  });
+});
+
+// ========== 版本比较逻辑 ==========
+
+describe('checkForUpdates - 版本比较', () => {
+  beforeEach(() => {
+    mockedExecSync.mockImplementation(() => { throw new Error('not found'); });
+  });
+
+  it('major 版本更高时提示更新', async () => {
+    const cache = { lastCheck: Date.now(), latestVersion: '3.0.0', currentVersion: '2.17.1' };
+    mockedReadFileSync.mockReturnValue(JSON.stringify(cache));
+
+    await checkForUpdates('2.17.1');
+
+    const allOutput = (console.log as ReturnType<typeof vi.fn>).mock.calls.map((c: unknown[]) => c[0]).join('\n');
+    expect(allOutput).toContain('3.0.0');
+  });
+
+  it('minor 版本更高时提示更新', async () => {
+    const cache = { lastCheck: Date.now(), latestVersion: '2.18.0', currentVersion: '2.17.1' };
+    mockedReadFileSync.mockReturnValue(JSON.stringify(cache));
+
+    await checkForUpdates('2.17.1');
+
+    expect(console.log).toHaveBeenCalled();
+  });
+
+  it('patch 版本更高时提示更新', async () => {
+    const cache = { lastCheck: Date.now(), latestVersion: '2.17.2', currentVersion: '2.17.1' };
+    mockedReadFileSync.mockReturnValue(JSON.stringify(cache));
+
+    await checkForUpdates('2.17.1');
+
+    expect(console.log).toHaveBeenCalled();
+  });
+
+  it('版本相同时不提示', async () => {
+    const cache = { lastCheck: Date.now(), latestVersion: '2.17.1', currentVersion: '2.17.1' };
+    mockedReadFileSync.mockReturnValue(JSON.stringify(cache));
+
+    await checkForUpdates('2.17.1');
+
+    expect(console.log).not.toHaveBeenCalled();
+  });
+
+  it('本地版本更高时不提示', async () => {
+    const cache = { lastCheck: Date.now(), latestVersion: '2.16.0', currentVersion: '2.17.1' };
+    mockedReadFileSync.mockReturnValue(JSON.stringify(cache));
+
+    await checkForUpdates('2.17.1');
+
+    expect(console.log).not.toHaveBeenCalled();
+  });
+});
+
+// ========== 包管理器检测 ==========
+
+describe('checkForUpdates - 包管理器检测', () => {
+  beforeEach(() => {
+    // 缓存有效且有新版本，确保走到打印提示逻辑
+    const cache = { lastCheck: Date.now(), latestVersion: '3.0.0', currentVersion: '2.17.1' };
+    mockedReadFileSync.mockReturnValue(JSON.stringify(cache));
+  });
+
+  it('pnpm 全局安装时提示使用 pnpm 命令', async () => {
+    mockedExecSync.mockImplementation((cmd: string) => {
+      if (typeof cmd === 'string' && cmd.includes('pnpm')) {
+        return 'clawt@2.17.1';
+      }
+      throw new Error('not found');
+    });
+
+    await checkForUpdates('2.17.1');
+
+    const allOutput = (console.log as ReturnType<typeof vi.fn>).mock.calls.map((c: unknown[]) => c[0]).join('\n');
+    expect(allOutput).toContain('pnpm add -g clawt');
+  });
+
+  it('yarn 全局安装时提示使用 yarn 命令', async () => {
+    mockedExecSync.mockImplementation((cmd: string) => {
+      if (typeof cmd === 'string' && cmd.includes('pnpm')) {
+        throw new Error('not found');
+      }
+      if (typeof cmd === 'string' && cmd.includes('yarn')) {
+        return 'info "clawt@2.17.1"';
+      }
+      throw new Error('not found');
+    });
+
+    await checkForUpdates('2.17.1');
+
+    const allOutput = (console.log as ReturnType<typeof vi.fn>).mock.calls.map((c: unknown[]) => c[0]).join('\n');
+    expect(allOutput).toContain('yarn global add clawt');
+  });
+
+  it('npm 全局安装时提示使用 npm 命令', async () => {
+    mockedExecSync.mockImplementation(() => {
+      throw new Error('not found');
+    });
+
+    await checkForUpdates('2.17.1');
+
+    const allOutput = (console.log as ReturnType<typeof vi.fn>).mock.calls.map((c: unknown[]) => c[0]).join('\n');
+    expect(allOutput).toContain('npm i -g clawt');
+  });
+});
+
+// ========== 提示框输出格式 ==========
+
+describe('checkForUpdates - 提示框格式', () => {
+  it('提示框包含完整的边框结构', async () => {
+    const cache = { lastCheck: Date.now(), latestVersion: '2.18.0', currentVersion: '2.17.1' };
+    mockedReadFileSync.mockReturnValue(JSON.stringify(cache));
+    mockedExecSync.mockImplementation(() => { throw new Error('not found'); });
+
+    await checkForUpdates('2.17.1');
+
+    const calls = (console.log as ReturnType<typeof vi.fn>).mock.calls.map((c: unknown[]) => c[0]);
+    // 应包含顶部和底部边框
+    expect(calls.some((line: string) => typeof line === 'string' && line.startsWith('╭') && line.endsWith('╮'))).toBe(true);
+    expect(calls.some((line: string) => typeof line === 'string' && line.startsWith('╰') && line.endsWith('╯'))).toBe(true);
+    // 应包含版本信息和更新命令
+    const allOutput = calls.join('\n');
+    expect(allOutput).toContain('2.17.1');
+    expect(allOutput).toContain('2.18.0');
+    expect(allOutput).toContain('npm i -g clawt');
+  });
+});
+
+// ========== 容错：异常不影响 CLI ==========
+
+describe('checkForUpdates - 容错性', () => {
+  it('writeFileSync 抛出异常时不影响执行', async () => {
+    mockedReadFileSync.mockImplementation(() => { throw new Error('ENOENT'); });
+    createMockHttpResponse(JSON.stringify({ version: '2.18.0' }));
+    mockedWriteFileSync.mockImplementation(() => { throw new Error('EACCES'); });
+    mockedExecSync.mockImplementation(() => { throw new Error('not found'); });
+
+    // 不应抛出异常
+    await expect(checkForUpdates('2.17.1')).resolves.toBeUndefined();
+    // 仍应打印提示
+    expect(console.log).toHaveBeenCalled();
+  });
+
+  it('任何未预期的异常都不会导致 checkForUpdates 抛出', async () => {
+    mockedReadFileSync.mockImplementation(() => { throw new TypeError('unexpected'); });
+    mockedRequest.mockImplementation(() => { throw new Error('unexpected'); });
+
+    await expect(checkForUpdates('2.17.1')).resolves.toBeUndefined();
+  });
+});