@zhizai/cli 0.0.6 → 0.0.7

package/README.md

@@ -82,12 +82,17 @@ zhizai note get <id> --field summary
 
 ### 4. 接入本机 AI
 
+CLI 首次安装请用 npm（见上文「安装」）。`setup` 负责同步 Skills 与授权，**不会**在 CLI 已可用时重复 npm 重装。
+
 ```bash
 # 预览将执行的操作
 zhizai setup --dry-run -o json
 
-# 正式安装 Skill
+# 同步 Skill 并引导授权（CLI 已就绪时跳过重装）
 zhizai setup
+
+# 升级或修复 CLI 二进制（显式触发 npm 重装）
+zhizai setup --force-cli-install
 ```
 
 `setup` 会把原子 Skill 安装到 Cursor、Claude Code、Codex 等本机 AI 环境，并引导完成授权。
@@ -116,7 +121,7 @@ zhizai setup
 | `zhizai knowledge list [--received]` | 笔记集列表（我创建的 / 收到的） |
 | `zhizai knowledge get <id>` | 笔记集详情 |
 | `zhizai knowledge notes <id>` | 笔记集内笔记 |
-| `zhizai setup [--dry-run]` | 为本机 AI 安装原子 Skill 并引导授权 |
+| `zhizai setup [--dry-run] [--force-cli-install]` | 同步原子 Skill 并引导授权；CLI 已就绪时跳过重装 |
 
 ### 规划中
 

package/bin/zhizai.js

@@ -4,6 +4,7 @@
 'use strict';
 
 const { spawn } = require('child_process');
+const fs = require('fs');
 const path = require('path');
 const os = require('os');
 
@@ -11,9 +12,29 @@ const platform = os.platform();
 const binaryName = platform === 'win32' ? 'zhizai.exe' : 'zhizai';
 const binaryPath = path.join(__dirname, binaryName);
 
+function failMissing() {
+  console.error('无法启动智在记录：CLI 可执行文件缺失。');
+  console.error('可能原因：安装中断或文件被移除。');
+  console.error('请重新执行: npm install -g @zhizai/cli@latest');
+  console.error('错误码：CLI_BINARY_MISSING');
+  process.exit(1);
+}
+
+if (!fs.existsSync(binaryPath)) {
+  failMissing();
+}
+
 const child = spawn(binaryPath, process.argv.slice(2), {
   stdio: 'inherit',
-  windowsHide: true
+  windowsHide: true,
+});
+
+child.on('error', (err) => {
+  if (err && err.code === 'ENOENT') {
+    failMissing();
+  }
+  console.error('无法启动智在记录：', err.message);
+  process.exit(1);
 });
 
 child.on('exit', (code, signal) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhizai/cli",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "CLI tool for 智在记录 — manage notes and knowledge from the terminal and AI agents",
   "keywords": [
     "zhizai",

package/scripts/postinstall.js

@@ -6,6 +6,7 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const http = require('http');
 const https = require('https');
 const crypto = require('crypto');
 const { spawnSync } = require('child_process');
@@ -14,6 +15,34 @@ const pkg = require('../package.json');
 const VERSION = pkg.version;
 const REPO = 'BoteAI/zhizai-cli';
 
+const DEFAULT_CONNECT_TIMEOUT_MS = 15000;
+const DEFAULT_IDLE_TIMEOUT_MS = 30000;
+const DEFAULT_TOTAL_TIMEOUT_MS = 5 * 60 * 1000;
+const DEFAULT_RETRIES = 3;
+const RETRY_BACKOFF_MS = [500, 1000, 2000];
+const NON_RETRYABLE_STATUS = new Set([401, 403, 404]);
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+function getProtocolModule(urlString) {
+  const protocol = new URL(urlString).protocol;
+  if (protocol === 'http:') return http;
+  if (protocol === 'https:') return https;
+  throw new Error(`Unsupported protocol: ${protocol}`);
+}
+
+function versionMatches(out, expected) {
+  const m = String(out).trim().match(/^zhizai version\s+v?(\S+)/i);
+  if (!m) return false;
+  return m[1] === String(expected).replace(/^v/, '');
+}
+
+function parseVersionFromOutput(out, expectedVersion) {
+  return versionMatches(out, expectedVersion);
+}
+
 function getPlatform() {
   const platform = os.platform();
   const arch = os.arch();
@@ -47,6 +76,209 @@ function getWindowsExtractArgs(archivePath, destinationPath) {
   ];
 }
 
+function unlinkQuiet(filePath) {
+  try { fs.unlinkSync(filePath); } catch (_) {}
+}
+
+function reportProgress(downloaded, contentLength, onProgress) {
+  if (contentLength != null) {
+    console.error(`Downloaded ${downloaded}/${contentLength} bytes`);
+  } else {
+    console.error(`Downloaded ${downloaded} bytes`);
+  }
+  if (onProgress) onProgress({ downloaded, contentLength });
+}
+
+function isNonRetryableError(err) {
+  const statusCode = err && err.statusCode;
+  if (statusCode != null && NON_RETRYABLE_STATUS.has(statusCode)) return true;
+  const message = String((err && err.message) || err);
+  return /HTTP (401|403|404)/.test(message);
+}
+
+function downloadOnce(url, destination, options, redirects = 0) {
+  if (redirects > 5) return Promise.reject(new Error('Too many redirects'));
+
+  const {
+    connectTimeoutMs,
+    idleTimeoutMs,
+    totalTimeoutMs,
+    onProgress,
+  } = options;
+
+  return new Promise((resolve, reject) => {
+    let request = null;
+    let response = null;
+    let output = null;
+    let connected = false;
+    let downloaded = 0;
+    let contentLength = null;
+    let lastProgressTime = 0;
+    let idleTimer = null;
+    let totalTimer = null;
+    let connectTimer = null;
+    let settled = false;
+
+    function finish(err, value) {
+      if (settled) return;
+      settled = true;
+      clearTimeout(idleTimer);
+      clearTimeout(totalTimer);
+      clearTimeout(connectTimer);
+      if (err) reject(err);
+      else resolve(value);
+    }
+
+    function cleanupPartial() {
+      unlinkQuiet(destination);
+    }
+
+    function destroyStreams() {
+      if (response) {
+        try { response.destroy(); } catch (_) {}
+      }
+      if (request) {
+        try { request.destroy(); } catch (_) {}
+      }
+      if (output) {
+        try { output.destroy(); } catch (_) {}
+      }
+    }
+
+    function failTimeout(stage) {
+      destroyStreams();
+      cleanupPartial();
+      finish(new Error(`${stage} timeout`));
+    }
+
+    function resetIdleTimer() {
+      clearTimeout(idleTimer);
+      idleTimer = setTimeout(() => failTimeout('Idle'), idleTimeoutMs);
+    }
+
+    function maybeReportProgress(force = false) {
+      const now = Date.now();
+      if (!force && now - lastProgressTime < 500) return;
+      lastProgressTime = now;
+      reportProgress(downloaded, contentLength, onProgress);
+    }
+
+    totalTimer = setTimeout(() => failTimeout('Total'), totalTimeoutMs);
+
+    const protocol = getProtocolModule(url);
+    request = protocol.get(url, { headers: { 'User-Agent': '@zhizai/cli installer' } }, res => {
+      connected = true;
+      clearTimeout(connectTimer);
+      response = res;
+
+      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        res.resume();
+        destroyStreams();
+        clearTimeout(idleTimer);
+        clearTimeout(totalTimer);
+        clearTimeout(connectTimer);
+        settled = true;
+        downloadOnce(new URL(res.headers.location, url).toString(), destination, options, redirects + 1)
+          .then(resolve, reject);
+        return;
+      }
+
+      if (res.statusCode !== 200) {
+        res.resume();
+        destroyStreams();
+        cleanupPartial();
+        const err = new Error(`HTTP ${res.statusCode}: ${url}`);
+        err.statusCode = res.statusCode;
+        finish(err);
+        return;
+      }
+
+      const lengthHeader = res.headers['content-length'];
+      if (lengthHeader != null && lengthHeader !== '') {
+        const parsed = Number(lengthHeader);
+        if (!Number.isNaN(parsed)) contentLength = parsed;
+      }
+
+      output = fs.createWriteStream(destination, { mode: 0o600 });
+      resetIdleTimer();
+
+      res.on('data', chunk => {
+        downloaded += chunk.length;
+        resetIdleTimer();
+        maybeReportProgress();
+      });
+
+      res.pipe(output);
+
+      output.on('finish', () => {
+        output.close(() => {
+          maybeReportProgress(true);
+          finish(null, undefined);
+        });
+      });
+
+      output.on('error', err => {
+        destroyStreams();
+        cleanupPartial();
+        finish(err);
+      });
+
+      res.on('error', err => {
+        destroyStreams();
+        cleanupPartial();
+        finish(err);
+      });
+    });
+
+    connectTimer = setTimeout(() => {
+      if (!connected) failTimeout('Connect');
+    }, connectTimeoutMs);
+
+    request.on('socket', socket => {
+      socket.once('connect', () => {
+        connected = true;
+        clearTimeout(connectTimer);
+        resetIdleTimer();
+      });
+    });
+
+    request.on('error', err => {
+      destroyStreams();
+      cleanupPartial();
+      finish(err);
+    });
+  });
+}
+
+async function download(url, destination, options = {}, redirects = 0) {
+  const opts = {
+    connectTimeoutMs: DEFAULT_CONNECT_TIMEOUT_MS,
+    idleTimeoutMs: DEFAULT_IDLE_TIMEOUT_MS,
+    totalTimeoutMs: DEFAULT_TOTAL_TIMEOUT_MS,
+    retries: DEFAULT_RETRIES,
+    onProgress: null,
+    ...options,
+  };
+
+  if (redirects > 5) throw new Error('Too many redirects');
+
+  const maxRetries = opts.retries;
+  let lastError;
+
+  for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
+    try {
+      return await downloadOnce(url, destination, opts, redirects);
+    } catch (err) {
+      lastError = err;
+      if (isNonRetryableError(err) || attempt >= maxRetries) throw err;
+      const delay = RETRY_BACKOFF_MS[Math.min(attempt, RETRY_BACKOFF_MS.length - 1)];
+      await sleep(delay);
+    }
+  }
+
+  throw lastError;
+}
+
 async function installArchive({ platform, binDir, binaryName, binaryPath, url, tmpFile }) {
   try {
     await download(url, tmpFile);
@@ -60,13 +292,12 @@ async function installArchive({ platform, binDir, binaryName, binaryPath, url, t
     if (!fs.existsSync(binaryPath)) {
       throw new Error(`Binary missing after extract: ${binaryPath}`);
     }
-    // chmod is meaningful on Unix; Windows may not need it.
     if (platform.platform !== 'windows') {
       fs.chmodSync(binaryPath, 0o755);
     }
     console.log(`zhizai installed at ${binaryPath}`);
   } finally {
-    try { fs.unlinkSync(tmpFile); } catch (_) {}
+    unlinkQuiet(tmpFile);
   }
 }
 
@@ -76,7 +307,6 @@ async function main() {
   const binaryName = getBinaryName(platform);
   const binaryPath = path.join(binDir, binaryName);
   const url = getDownloadURL(platform);
-  // Expand-Archive on Windows requires a .zip extension; tar.gz similarly.
   const archiveExt = platform.platform === 'windows' ? '.zip' : '.tar.gz';
   const tmpFile = path.join(os.tmpdir(), `zhizai-download-${Date.now()}${archiveExt}`);
 
@@ -84,7 +314,7 @@ async function main() {
     try {
       const result = spawnSync(binaryPath, ['version'], { encoding: 'utf8' });
       const out = (result.stdout || '').trim();
-      if (result.status === 0 && out.includes(VERSION)) {
+      if (result.status === 0 && versionMatches(out, VERSION)) {
         console.log(`zhizai v${VERSION} already installed, skipping download.`);
         return;
       }
@@ -104,27 +334,6 @@ function run(command, args) {
   if (result.status !== 0) throw new Error(`${command} exited with status ${result.status}`);
 }
 
-function download(url, destination, redirects = 0) {
-  if (redirects > 5) return Promise.reject(new Error('Too many redirects'));
-  return new Promise((resolve, reject) => {
-    const request = https.get(url, { headers: { 'User-Agent': '@zhizai/cli installer' } }, response => {
-      if (response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
-        response.resume();
-        return resolve(download(new URL(response.headers.location, url).toString(), destination, redirects + 1));
-      }
-      if (response.statusCode !== 200) {
-        response.resume();
-        return reject(new Error(`HTTP ${response.statusCode}: ${url}`));
-      }
-      const output = fs.createWriteStream(destination, { mode: 0o600 });
-      response.pipe(output);
-      output.on('finish', () => output.close(resolve));
-      output.on('error', reject);
-    });
-    request.on('error', reject);
-  });
-}
-
 async function verifyChecksum(assetURL, assetName, archivePath) {
   const checksumPath = `${archivePath}.checksums`;
   try {
@@ -139,10 +348,22 @@ async function verifyChecksum(assetURL, assetName, archivePath) {
     const actual = crypto.createHash('sha256').update(fs.readFileSync(archivePath)).digest('hex');
     if (actual !== expected) throw new Error(`Checksum mismatch for ${assetName}`);
   } finally {
-    try { fs.unlinkSync(checksumPath); } catch (_) {}
+    unlinkQuiet(checksumPath);
   }
 }
 
+module.exports = {
+  download,
+  downloadOnce,
+  versionMatches,
+  parseVersionFromOutput,
+  getPlatform,
+  getBinaryName,
+  getDownloadURL,
+  verifyChecksum,
+  installArchive,
+};
+
 if (require.main === module) {
   main().catch(err => {
     console.error('Failed to install zhizai:', err.message);

package/skills/zhizai-auth/SKILL.md

@@ -8,16 +8,20 @@ description: 安装和连接智在记录，完成网页授权登录、环境诊
 
 通过官方 `zhizai` CLI 完成真实操作。机器调用优先使用 `-o json`。
 
+**安装与升级：** 首次安装 CLI 用 `npm install -g @zhizai/cli@latest`。`zhizai setup` 默认同步 Skills 并引导授权；CLI 已可用时**不会**重复 npm 重装。需要升级或修复二进制时用 `zhizai setup --force-cli-install`。
+
 ## 路由
 
 | 意图 | 命令 |
 |---|---|
+| 首次安装 CLI | `npm install -g @zhizai/cli@latest` |
 | 登录 | `zhizai auth login` |
 | 无头/连接器登录 | `zhizai auth login --no-open` |
 | 查看状态 | `zhizai auth status` |
 | 退出 | `zhizai auth logout` |
 | 诊断 | `zhizai doctor -o json` |
 | 能力契约 | `zhizai capabilities -o json` |
-| 安装 Skill | `zhizai setup` |
+| 同步 Skill / 授权 | `zhizai setup` |
+| 升级或修复 CLI | `zhizai setup --force-cli-install` |
 
 默认使用网页设备授权。`--no-open` 时不打开浏览器，打印 `[verify_url]` / `[device_code]` / `[expires_in]` / `[interval]` 供宿主展示，后台继续轮询。仅当网页授权失败时，再提示用户使用 `zhizai auth login --api-key <key>`。