lark-remote 0.1.3 → 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/dist/workspace/index.d.ts

@@ -1,9 +1,18 @@
+/** Public view of a workspace entry returned by list(). */
+export interface WorkspaceEntry {
+    name: string;
+    path: string;
+    lastUsedAt: number;
+}
 /**
  * Persistent named-alias store for workspace directories.
  *
  * Atomic write (§9.10): writes a temp file then `fs.rename` so a crash
  * mid-write cannot leave a truncated JSON file. On load, a corrupt file
  * is treated as empty (with a warning) so the bridge can still start.
+ *
+ * Data migration: old format `{ alias: "path" }` is normalized to
+ * `{ alias: { path, lastUsedAt: 0 } }` on first load and persisted.
  */
 export declare class WorkspaceStore {
     private filePath;
@@ -15,5 +24,14 @@ export declare class WorkspaceStore {
     get(name: string): string | undefined;
     has(name: string): boolean;
     remove(name: string): void;
-    list(): [string, string][];
+    /**
+     * Update lastUsedAt to now for the given alias and persist.
+     * No-op if the alias does not exist.
+     */
+    touch(name: string): void;
+    /**
+     * List all workspace entries in insertion order.
+     * Sorting is the caller's responsibility (view concern).
+     */
+    list(): WorkspaceEntry[];
 }

package/dist/workspace/index.js

@@ -2,12 +2,16 @@ import path from 'node:path';
 import os from 'node:os';
 import { atomicWriteJson } from '../persistence/atomic-write.js';
 import { loadJsonFile } from '../persistence/load-json-file.js';
+import { getLogger } from '../logger/index.js';
 /**
  * Persistent named-alias store for workspace directories.
  *
  * Atomic write (§9.10): writes a temp file then `fs.rename` so a crash
  * mid-write cannot leave a truncated JSON file. On load, a corrupt file
  * is treated as empty (with a warning) so the bridge can still start.
+ *
+ * Data migration: old format `{ alias: "path" }` is normalized to
+ * `{ alias: { path, lastUsedAt: 0 } }` on first load and persisted.
  */
 export class WorkspaceStore {
     filePath;
@@ -21,9 +25,32 @@ export class WorkspaceStore {
         const parsed = loadJsonFile(this.filePath, undefined);
         if (!parsed)
             return;
+        let needsMigration = false;
         for (const [k, v] of Object.entries(parsed)) {
-            if (typeof v === 'string')
-                this.data.set(k, v);
+            if (typeof v === 'string') {
+                // Old format: string value → { path, lastUsedAt: 0 }
+                this.data.set(k, { path: v, lastUsedAt: 0 });
+                needsMigration = true;
+            }
+            else if (typeof v === 'object' &&
+                v !== null &&
+                typeof v.path === 'string') {
+                // New format: extract path and lastUsedAt (default 0 if missing)
+                const obj = v;
+                const lastUsedAt = typeof obj.lastUsedAt === 'number' ? obj.lastUsedAt : 0;
+                if (typeof obj.lastUsedAt !== 'number') {
+                    if (obj.lastUsedAt !== undefined) {
+                        getLogger().warn(`[workspace] "${k}" has invalid lastUsedAt (${JSON.stringify(obj.lastUsedAt)}), resetting to 0`);
+                    }
+                    needsMigration = true;
+                }
+                this.data.set(k, { path: obj.path, lastUsedAt });
+            }
+            // Non-string, non-object entries are silently skipped (existing behavior)
+        }
+        // Write back immediately if migration occurred
+        if (needsMigration) {
+            this.persist();
         }
     }
     persist() {
@@ -33,11 +60,11 @@ export class WorkspaceStore {
         atomicWriteJson(this.filePath, obj);
     }
     save(name, dirPath) {
-        this.data.set(name, dirPath);
+        this.data.set(name, { path: dirPath, lastUsedAt: 0 });
         this.persist();
     }
     get(name) {
-        return this.data.get(name);
+        return this.data.get(name)?.path;
     }
     has(name) {
         return this.data.has(name);
@@ -46,8 +73,27 @@ export class WorkspaceStore {
         this.data.delete(name);
         this.persist();
     }
+    /**
+     * Update lastUsedAt to now for the given alias and persist.
+     * No-op if the alias does not exist.
+     */
+    touch(name) {
+        const entry = this.data.get(name);
+        if (!entry)
+            return;
+        entry.lastUsedAt = Date.now();
+        this.persist();
+    }
+    /**
+     * List all workspace entries in insertion order.
+     * Sorting is the caller's responsibility (view concern).
+     */
     list() {
-        return [...this.data.entries()];
+        return [...this.data.entries()].map(([name, data]) => ({
+            name,
+            path: data.path,
+            lastUsedAt: data.lastUsedAt,
+        }));
     }
 }
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lark-remote",
-  "version": "0.1.3",
+  "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"
-    ]
   }
 }