lark-remote 0.1.4 → 0.1.5

package/dist/update/install.js

@@ -0,0 +1,93 @@
+import { execFile, execFileSync } from 'node:child_process';
+import { getLogger } from '../logger/index.js';
+/**
+ * Detect which package manager to use for global install.
+ *
+ * Priority:
+ * 1. Environment variable override (LARK_REMOTE_MANAGED_BY)
+ * 2. `which` availability: npm → bun → pnpm
+ */
+export function detectPackageManager() {
+    // 1. Env override (highest priority)
+    const env = process.env.LARK_REMOTE_MANAGED_BY;
+    if (env === 'npm' || env === 'bun' || env === 'pnpm')
+        return env;
+    // 2. which availability detection
+    const candidates = ['npm', 'bun', 'pnpm'];
+    for (const cmd of candidates) {
+        try {
+            execFileSync('which', [cmd], { stdio: 'pipe', timeout: 3000 });
+            return cmd;
+        }
+        catch {
+            // Not found, try next
+        }
+    }
+    return null;
+}
+/** Get the install command for a package manager. */
+function getInstallCommand(pm) {
+    switch (pm) {
+        case 'npm':
+            return { cmd: 'npm', args: ['install', '-g', 'lark-remote@latest'] };
+        case 'bun':
+            return { cmd: 'bun', args: ['install', '-g', 'lark-remote@latest'] };
+        case 'pnpm':
+            return { cmd: 'pnpm', args: ['add', '-g', 'lark-remote@latest'] };
+    }
+}
+/**
+ * Run the global install command to upgrade lark-remote to the latest version.
+ *
+ * @param opts.packageManager - Override detected package manager
+ * @param opts.execFn - Override execFile for testing
+ */
+export function runInstallLatest(opts) {
+    // If packageManager is explicitly null, skip detection and fail immediately.
+    // If undefined (not provided), run detection.
+    let pm;
+    if (opts?.packageManager === null) {
+        pm = null;
+    }
+    else if (opts?.packageManager) {
+        pm = opts.packageManager;
+    }
+    else {
+        pm = detectPackageManager();
+    }
+    if (!pm) {
+        return Promise.resolve({
+            success: false,
+            error: '未检测到可用的包管理器（npm/bun/pnpm），请手动执行 npm install -g lark-remote@latest',
+        });
+    }
+    const { cmd, args } = getInstallCommand(pm);
+    const execFn = opts?.execFn ?? ((...args) => execFile(...args));
+    const logger = getLogger();
+    logger.info(`[update] running: ${cmd} ${args.join(' ')}`);
+    return new Promise((resolve) => {
+        execFn(cmd, args, { timeout: 120_000, encoding: 'utf8' }, // 2 min timeout for npm install
+        (err, _stdout, _stderr) => {
+            if (err) {
+                const msg = err.message || String(_stderr);
+                logger.error(`[update] install failed: ${msg}`);
+                // Detect common errors and give actionable advice
+                if (msg.includes('EACCES') || msg.includes('permission')) {
+                    resolve({
+                        success: false,
+                        error: `权限不足，尝试 sudo ${cmd} ${args.join(' ')}`,
+                    });
+                    return;
+                }
+                resolve({
+                    success: false,
+                    error: msg.split('\n')[0], // First line only
+                });
+                return;
+            }
+            logger.info(`[update] install succeeded`);
+            resolve({ success: true });
+        });
+    });
+}
+//# sourceMappingURL=install.js.map

package/dist/update/startup-hint.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Format an update hint string for the startup notification.
+ * Returns null if no newer version is available.
+ */
+export declare function formatUpdateHint(current: string, latest: string): string | null;

package/dist/update/startup-hint.js

@@ -0,0 +1,11 @@
+import { isNewer } from './version-check.js';
+/**
+ * Format an update hint string for the startup notification.
+ * Returns null if no newer version is available.
+ */
+export function formatUpdateHint(current, latest) {
+    if (!isNewer(current, latest))
+        return null;
+    return `📦 有新版本 ${latest} 可用（当前 ${current}），发送 /update 升级`;
+}
+//# sourceMappingURL=startup-hint.js.map

package/dist/update/version-check.d.ts

@@ -0,0 +1,31 @@
+/** Cache TTL for version check results (1 hour). */
+export declare const CACHE_TTL_MS: number;
+/** Cache file schema. */
+export interface UpdateCache {
+    latestVersion: string;
+    checkedAt: string;
+}
+/** Result of a version check. */
+export interface VersionCheckResult {
+    current: string;
+    latest: string;
+}
+/**
+ * Compare two semver strings (major.minor.patch).
+ * Returns true if latest > current, false if latest <= current,
+ * null if either version is not a valid semver string.
+ */
+export declare function isNewer(current: string, latest: string): boolean | null;
+/**
+ * Check the latest available version of lark-remote.
+ * Uses a local cache file with 1-hour TTL to avoid frequent network requests.
+ *
+ * @param opts.cachePath - Path to cache file (default: <configDir>/update-cache.json)
+ * @param opts.bypassCache - If true, always fetch from registry
+ * @param opts.registryUrl - Override registry URL (for testing)
+ */
+export declare function checkLatestVersion(opts?: {
+    cachePath?: string;
+    bypassCache?: boolean;
+    registryUrl?: string;
+}): Promise<VersionCheckResult>;

package/dist/update/version-check.js

@@ -0,0 +1,149 @@
+import https from 'node:https';
+import http from 'node:http';
+import fs from 'node:fs';
+import { getVersion } from '../config/dir.js';
+import { getLogger } from '../logger/index.js';
+import { atomicWrite } from '../persistence/atomic-write.js';
+/** Cache TTL for version check results (1 hour). */
+export const CACHE_TTL_MS = 60 * 60 * 1000;
+/** Default npm registry endpoint for latest version query. */
+const DEFAULT_REGISTRY_URL = 'https://registry.npmjs.org/lark-remote/latest';
+/**
+ * Compare two semver strings (major.minor.patch).
+ * Returns true if latest > current, false if latest <= current,
+ * null if either version is not a valid semver string.
+ */
+export function isNewer(current, latest) {
+    const parse = (v) => {
+        // Split core and pre-release suffix; compare the core numerically and treat
+        // a release as newer than any pre-release of the same core version.
+        const [core, pre = ''] = v.trim().split('-', 2);
+        const parts = core.split('.');
+        if (parts.length !== 3)
+            return null;
+        const nums = parts.map((p) => (/^\d+$/.test(p) ? Number(p) : NaN));
+        if (nums.some((n) => !Number.isInteger(n) || n < 0))
+            return null;
+        return { nums: nums, pre };
+    };
+    const c = parse(current);
+    const l = parse(latest);
+    if (!c || !l)
+        return null;
+    for (let i = 0; i < 3; i++) {
+        if (l.nums[i] > c.nums[i])
+            return true;
+        if (l.nums[i] < c.nums[i])
+            return false;
+    }
+    // Equal core version: a release beats a pre-release of the same version.
+    if (c.pre !== l.pre)
+        return l.pre === '';
+    return false;
+}
+/**
+ * Fetch the latest version from npm registry.
+ * Returns the version string.
+ */
+function fetchLatestVersion(registryUrl) {
+    return new Promise((resolve, reject) => {
+        const mod = registryUrl.startsWith('https') ? https : http;
+        const req = mod.get(registryUrl, { timeout: 10_000 }, (res) => {
+            if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                // Follow one redirect
+                fetchLatestVersion(res.headers.location).then(resolve, reject);
+                return;
+            }
+            if (res.statusCode !== 200) {
+                reject(new Error(`npm registry returned status ${res.statusCode}`));
+                return;
+            }
+            let data = '';
+            res.on('data', (chunk) => {
+                data += chunk.toString();
+            });
+            res.on('end', () => {
+                try {
+                    const parsed = JSON.parse(data);
+                    if (!parsed.version) {
+                        reject(new Error('npm registry response missing version field'));
+                        return;
+                    }
+                    resolve(parsed.version);
+                }
+                catch (err) {
+                    reject(new Error(`npm registry response parse error: ${err.message}`));
+                }
+            });
+        });
+        req.on('error', reject);
+        req.on('timeout', () => {
+            req.destroy();
+            reject(new Error('npm registry request timed out'));
+        });
+    });
+}
+/**
+ * Read cached version check result. Returns null if cache is missing,
+ * expired, or corrupt.
+ */
+function readCache(cachePath) {
+    try {
+        if (!fs.existsSync(cachePath))
+            return null;
+        const raw = fs.readFileSync(cachePath, 'utf8');
+        const cached = JSON.parse(raw);
+        if (!cached.latestVersion || !cached.checkedAt)
+            return null;
+        return cached;
+    }
+    catch {
+        return null;
+    }
+}
+/** Write version check result to cache file. */
+function writeCache(cachePath, latestVersion) {
+    try {
+        const cache = {
+            latestVersion,
+            checkedAt: new Date().toISOString(),
+        };
+        atomicWrite(cachePath, JSON.stringify(cache), 'utf8');
+    }
+    catch (err) {
+        getLogger().warn(`[update] failed to write cache: ${err.message}`);
+    }
+}
+/**
+ * Check the latest available version of lark-remote.
+ * Uses a local cache file with 1-hour TTL to avoid frequent network requests.
+ *
+ * @param opts.cachePath - Path to cache file (default: <configDir>/update-cache.json)
+ * @param opts.bypassCache - If true, always fetch from registry
+ * @param opts.registryUrl - Override registry URL (for testing)
+ */
+export async function checkLatestVersion(opts) {
+    const current = getVersion();
+    const registryUrl = opts?.registryUrl ?? DEFAULT_REGISTRY_URL;
+    const cachePath = opts?.cachePath;
+    // Try cache first (unless bypassed)
+    if (cachePath && !opts?.bypassCache) {
+        const cached = readCache(cachePath);
+        if (cached) {
+            const age = Date.now() - new Date(cached.checkedAt).getTime();
+            if (age < CACHE_TTL_MS) {
+                getLogger().info(`[update] using cached latest version: ${cached.latestVersion}`);
+                return { current, latest: cached.latestVersion };
+            }
+        }
+    }
+    // Fetch from registry
+    getLogger().info(`[update] checking latest version from ${registryUrl}`);
+    const latest = await fetchLatestVersion(registryUrl);
+    // Update cache
+    if (cachePath) {
+        writeCache(cachePath, latest);
+    }
+    return { current, latest };
+}
+//# sourceMappingURL=version-check.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lark-remote",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Feishu (Lark) private-chat bridge to local coding agents — Claude Code / Codex / opencode / pi / kimi, with live-streaming CardKit 2.0 cards",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -24,7 +24,6 @@
     "CHANGELOG.md"
   ],
   "scripts": {
-    "prepare": "husky",
     "dev": "bun src/index.ts",
     "build": "rm -rf dist && tsc && chmod +x dist/index.js dist/cli.js",
     "typecheck": "tsc --noEmit",
@@ -108,21 +107,9 @@
     "eslint": "^10.7.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-prettier": "^5.5.6",
-    "husky": "^9.1.7",
-    "lint-staged": "^17.3.0",
     "prettier": "^3.9.5",
     "typescript": "^6.0.0",
     "typescript-eslint": "^8.63.0",
     "vitest": "^4.1.10"
-  },
-  "lint-staged": {
-    "src/**/*.ts": [
-      "eslint --fix",
-      "prettier --write"
-    ],
-    "tests/**/*.ts": [
-      "eslint --fix",
-      "prettier --write"
-    ]
   }
 }