@oflow-ai/oflow-cli 0.1.0 → 0.1.2

package/dist/updater.js

@@ -0,0 +1,167 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkForUpdates = checkForUpdates;
+exports.performUpdate = performUpdate;
+const chalk_1 = __importDefault(require("chalk"));
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+const PACKAGE_NAME = '@oflow-ai/oflow-cli';
+const NPM_REGISTRY = 'https://registry.npmjs.org';
+/**
+ * 获取当前安装的版本
+ */
+async function getCurrentVersion() {
+    try {
+        const packageJson = require('../../package.json');
+        return packageJson.version;
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+/**
+ * 从npm获取最新版本
+ */
+async function getLatestVersion() {
+    try {
+        const { stdout } = await execAsync(`npm view ${PACKAGE_NAME} version`, {
+            timeout: 10000
+        });
+        return stdout.trim();
+    }
+    catch {
+        // 如果npm命令失败，尝试直接访问registry
+        try {
+            const https = require('https');
+            return new Promise((resolve, reject) => {
+                https.get(`${NPM_REGISTRY}/${PACKAGE_NAME.replace('/', '%2F')}/latest`, (res) => {
+                    let data = '';
+                    res.on('data', (chunk) => { data += chunk; });
+                    res.on('end', () => {
+                        try {
+                            const json = JSON.parse(data);
+                            resolve(json.version);
+                        }
+                        catch {
+                            reject(new Error('Failed to parse response'));
+                        }
+                    });
+                }).on('error', reject);
+            });
+        }
+        catch {
+            return '0.0.0';
+        }
+    }
+}
+/**
+ * 比较版本号
+ */
+function compareVersions(v1, v2) {
+    const parts1 = v1.split('.').map(Number);
+    const parts2 = v2.split('.').map(Number);
+    for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+        const p1 = parts1[i] || 0;
+        const p2 = parts2[i] || 0;
+        if (p1 > p2)
+            return 1;
+        if (p1 < p2)
+            return -1;
+    }
+    return 0;
+}
+/**
+ * 检查是否有更新
+ */
+async function checkForUpdates() {
+    const currentVersion = await getCurrentVersion();
+    // 检查缓存（每天只检查一次）
+    const cacheKey = 'oflow_last_update_check';
+    const cachedData = getCachedUpdateInfo(cacheKey);
+    if (cachedData && Date.now() - cachedData.timestamp < 24 * 60 * 60 * 1000) {
+        return {
+            hasUpdate: compareVersions(currentVersion, cachedData.latestVersion) < 0,
+            currentVersion,
+            latestVersion: cachedData.latestVersion
+        };
+    }
+    const latestVersion = await getLatestVersion();
+    // 缓存结果
+    setCachedUpdateInfo(cacheKey, {
+        latestVersion,
+        timestamp: Date.now()
+    });
+    return {
+        hasUpdate: compareVersions(currentVersion, latestVersion) < 0,
+        currentVersion,
+        latestVersion
+    };
+}
+/**
+ * 执行更新
+ */
+async function performUpdate() {
+    console.log(chalk_1.default.cyan('\n🔄 Updating oflow CLI...\n'));
+    try {
+        const { stdout, stderr } = await execAsync(`npm install -g ${PACKAGE_NAME}@latest`, {
+            timeout: 60000
+        });
+        console.log(chalk_1.default.green('\n✓ oflow CLI updated successfully!'));
+        console.log(chalk_1.default.gray('Please restart oflow to use the new version.\n'));
+        return { success: true, message: 'Update completed' };
+    }
+    catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        console.log(chalk_1.default.red('\n✗ Update failed'));
+        console.log(chalk_1.default.gray('You can manually update with: npm install -g @oflow-ai/oflow-cli@latest\n'));
+        return { success: false, message: errorMsg };
+    }
+}
+/**
+ * 获取缓存的更新信息
+ */
+function getCachedUpdateInfo(key) {
+    try {
+        const fs = require('fs');
+        const path = require('path');
+        const os = require('os');
+        const cacheFile = path.join(os.homedir(), '.oflow', 'update-cache.json');
+        if (fs.existsSync(cacheFile)) {
+            const data = JSON.parse(fs.readFileSync(cacheFile, 'utf-8'));
+            return data[key] || null;
+        }
+    }
+    catch {
+        // Ignore cache errors
+    }
+    return null;
+}
+/**
+ * 缓存更新信息
+ */
+function setCachedUpdateInfo(key, value) {
+    try {
+        const fs = require('fs');
+        const path = require('path');
+        const os = require('os');
+        const cacheDir = path.join(os.homedir(), '.oflow');
+        const cacheFile = path.join(cacheDir, 'update-cache.json');
+        if (!fs.existsSync(cacheDir)) {
+            fs.mkdirSync(cacheDir, { recursive: true });
+        }
+        let data = {};
+        if (fs.existsSync(cacheFile)) {
+            data = JSON.parse(fs.readFileSync(cacheFile, 'utf-8'));
+        }
+        data[key] = value;
+        fs.writeFileSync(cacheFile, JSON.stringify(data, null, 2));
+    }
+    catch {
+        // Ignore cache errors
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"updater.js","sourceRoot":"","sources":["../src/updater.ts"],"names":[],"mappings":"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","sourcesContent":["import chalk from 'chalk';\nimport { exec } from 'child_process';\nimport { promisify } from 'util';\n\nconst execAsync = promisify(exec);\n\nconst PACKAGE_NAME = '@oflow-ai/oflow-cli';\nconst NPM_REGISTRY = 'https://registry.npmjs.org';\n\ninterface UpdateInfo {\n  hasUpdate: boolean;\n  currentVersion: string;\n  latestVersion: string;\n}\n\n/**\n * 获取当前安装的版本\n */\nasync function getCurrentVersion(): Promise<string> {\n  try {\n    const packageJson = require('../../package.json');\n    return packageJson.version;\n  } catch {\n    return '0.0.0';\n  }\n}\n\n/**\n * 从npm获取最新版本\n */\nasync function getLatestVersion(): Promise<string> {\n  try {\n    const { stdout } = await execAsync(`npm view ${PACKAGE_NAME} version`, {\n      timeout: 10000\n    });\n    return stdout.trim();\n  } catch {\n    // 如果npm命令失败，尝试直接访问registry\n    try {\n      const https = require('https');\n      return new Promise((resolve, reject) => {\n        https.get(`${NPM_REGISTRY}/${PACKAGE_NAME.replace('/', '%2F')}/latest`, (res: any) => {\n          let data = '';\n          res.on('data', (chunk: string) => { data += chunk; });\n          res.on('end', () => {\n            try {\n              const json = JSON.parse(data);\n              resolve(json.version);\n            } catch {\n              reject(new Error('Failed to parse response'));\n            }\n          });\n        }).on('error', reject);\n      });\n    } catch {\n      return '0.0.0';\n    }\n  }\n}\n\n/**\n * 比较版本号\n */\nfunction compareVersions(v1: string, v2: string): number {\n  const parts1 = v1.split('.').map(Number);\n  const parts2 = v2.split('.').map(Number);\n\n  for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {\n    const p1 = parts1[i] || 0;\n    const p2 = parts2[i] || 0;\n    if (p1 > p2) return 1;\n    if (p1 < p2) return -1;\n  }\n  return 0;\n}\n\n/**\n * 检查是否有更新\n */\nexport async function checkForUpdates(): Promise<UpdateInfo> {\n  const currentVersion = await getCurrentVersion();\n  \n  // 检查缓存（每天只检查一次）\n  const cacheKey = 'oflow_last_update_check';\n  const cachedData = getCachedUpdateInfo(cacheKey);\n  \n  if (cachedData && Date.now() - cachedData.timestamp < 24 * 60 * 60 * 1000) {\n    return {\n      hasUpdate: compareVersions(currentVersion, cachedData.latestVersion) < 0,\n      currentVersion,\n      latestVersion: cachedData.latestVersion\n    };\n  }\n\n  const latestVersion = await getLatestVersion();\n  \n  // 缓存结果\n  setCachedUpdateInfo(cacheKey, { \n    latestVersion, \n    timestamp: Date.now() \n  });\n\n  return {\n    hasUpdate: compareVersions(currentVersion, latestVersion) < 0,\n    currentVersion,\n    latestVersion\n  };\n}\n\n/**\n * 执行更新\n */\nexport async function performUpdate(): Promise<{ success: boolean; message: string }> {\n  console.log(chalk.cyan('\\n🔄 Updating oflow CLI...\\n'));\n  \n  try {\n    const { stdout, stderr } = await execAsync(`npm install -g ${PACKAGE_NAME}@latest`, {\n      timeout: 60000\n    });\n    \n    console.log(chalk.green('\\n✓ oflow CLI updated successfully!'));\n    console.log(chalk.gray('Please restart oflow to use the new version.\\n'));\n    \n    return { success: true, message: 'Update completed' };\n  } catch (error) {\n    const errorMsg = error instanceof Error ? error.message : String(error);\n    console.log(chalk.red('\\n✗ Update failed'));\n    console.log(chalk.gray('You can manually update with: npm install -g @oflow-ai/oflow-cli@latest\\n'));\n    \n    return { success: false, message: errorMsg };\n  }\n}\n\n/**\n * 获取缓存的更新信息\n */\nfunction getCachedUpdateInfo(key: string): { latestVersion: string; timestamp: number } | null {\n  try {\n    const fs = require('fs');\n    const path = require('path');\n    const os = require('os');\n    \n    const cacheFile = path.join(os.homedir(), '.oflow', 'update-cache.json');\n    \n    if (fs.existsSync(cacheFile)) {\n      const data = JSON.parse(fs.readFileSync(cacheFile, 'utf-8'));\n      return data[key] || null;\n    }\n  } catch {\n    // Ignore cache errors\n  }\n  return null;\n}\n\n/**\n * 缓存更新信息\n */\nfunction setCachedUpdateInfo(key: string, value: { latestVersion: string; timestamp: number }): void {\n  try {\n    const fs = require('fs');\n    const path = require('path');\n    const os = require('os');\n    \n    const cacheDir = path.join(os.homedir(), '.oflow');\n    const cacheFile = path.join(cacheDir, 'update-cache.json');\n    \n    if (!fs.existsSync(cacheDir)) {\n      fs.mkdirSync(cacheDir, { recursive: true });\n    }\n    \n    let data: Record<string, any> = {};\n    if (fs.existsSync(cacheFile)) {\n      data = JSON.parse(fs.readFileSync(cacheFile, 'utf-8'));\n    }\n    \n    data[key] = value;\n    fs.writeFileSync(cacheFile, JSON.stringify(data, null, 2));\n  } catch {\n    // Ignore cache errors\n  }\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oflow-ai/oflow-cli",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "oFlow CLI - AI-powered terminal assistant for developers",
   "keywords": [
     "ai",