@ulthon/ul-opencode-event 0.1.17 → 0.1.19

package/dist/config.js

@@ -180,6 +180,7 @@ export function loadConfig() {
     // Merge top-level fields (language, timezone) — project config takes priority
     const mergedLanguage = projectConfig?.language ?? globalConfig?.language;
     const mergedTimezone = projectConfig?.timezone ?? globalConfig?.timezone;
+    const mergedAutoUpdate = projectConfig?.auto_update ?? globalConfig?.auto_update;
     // Merge includeSessionTypes — project overrides global
     const rawIncludeSessionTypes = projectConfig?.includeSessionTypes ?? globalConfig?.includeSessionTypes;
     // Deprecation warning for old field
@@ -192,6 +193,7 @@ export function loadConfig() {
         channels: enabledChannels,
         ...(mergedLanguage !== undefined && { language: mergedLanguage }),
         ...(mergedTimezone !== undefined && { timezone: mergedTimezone }),
+        ...(mergedAutoUpdate !== undefined ? { auto_update: mergedAutoUpdate } : { auto_update: true }),
         includeSessionTypes: validateIncludeSessionTypes(rawIncludeSessionTypes),
     };
 }

package/dist/dingtalk.js

@@ -91,8 +91,8 @@ export function createDingTalkFormatter(config) {
                 // Default: escape special characters and pass through
                 processedLines.push(escapeMarkdown(trimmed));
             }
-            // 3. Join and truncate
-            let text = processedLines.join('\n');
+            // 3. Join with double newlines (DingTalk Markdown requires \n\n for line breaks)
+            let text = processedLines.join('\n\n');
             if (text.length > MAX_CONTENT_LENGTH) {
                 text = text.slice(0, TRUNCATE_KEEP_LENGTH) + TRUNCATE_SUFFIX;
             }

package/dist/index.js

@@ -3,6 +3,7 @@ import { createEventHandler } from './handler.js';
 import { getDefaultTimezone } from './locales.js';
 import { DEFAULT_SESSION_TYPES } from './types.js';
 import { logger, DEBUG_ENABLED } from './logger.js';
+import { runAutoUpdate } from './updater.js';
 /**
  * Resolve session type from SDK Session info.
  * - undefined/missing sessionInfo → 'unknown' (race condition or file.edited)
@@ -204,6 +205,10 @@ function formatError(error) {
     }
     return String(error);
 }
+/**
+ * Guard flag to ensure auto-update only runs once per plugin load
+ */
+let hasCheckedUpdate = false;
 /**
  * Notification Plugin for OpenCode
  * Listens for session events and sends notifications via configured channels
@@ -238,6 +243,20 @@ export const NotificationPlugin = async (ctx) => {
             }
             if (event.type === 'session.created') {
                 sessionMap.set(event.properties.info.id, event.properties.info);
+                // Auto-update check (runs once, first main session only)
+                if (!hasCheckedUpdate) {
+                    hasCheckedUpdate = true;
+                    const info = event.properties.info;
+                    const isCliMode = process.env.OPENCODE_CLI_RUN_MODE === 'true';
+                    const isSubSession = info.parentID !== undefined && info.parentID !== '';
+                    if (!isCliMode && !isSubSession) {
+                        setTimeout(() => {
+                            runAutoUpdate(ctx, config.auto_update ?? true).catch((err) => {
+                                logger.error(`Auto-update check failed: ${err}`);
+                            });
+                        }, 0);
+                    }
+                }
             }
             else if (event.type === 'session.updated') {
                 sessionMap.set(event.properties.info.id, event.properties.info);

package/dist/types.d.ts

@@ -23,6 +23,8 @@ export interface NotificationConfig {
     timezone?: string;
     language?: LocaleType;
     includeSessionTypes?: SessionType[];
+    /** 自动更新开关（默认 true） */
+    auto_update?: boolean;
 }
 /**
  * Generic channel interface

package/dist/updater.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Auto-update module for @ulthon/ul-opencode-event.
+ *
+ * Checks npm registry for new versions, manages a 24h cache,
+ * and optionally runs `bun install` to auto-update.
+ *
+ * Zero runtime dependencies — only Node.js built-ins + project logger.
+ */
+/**
+ * Read the current installed version from this module's package.json
+ * by walking up from `import.meta.url`.
+ */
+export declare function getCurrentVersion(): string | null;
+/**
+ * Fetch the latest version string from the npm dist-tags API.
+ * Returns `null` on any error (network, parse, timeout).
+ */
+export declare function getLatestVersion(): Promise<string | null>;
+export declare function getCachedCheck(): {
+    latestVersion: string;
+    timestamp: number;
+} | null;
+export declare function setCachedCheck(latestVersion: string): void;
+export declare function isCacheValid(): boolean;
+/**
+ * Execute `bun install` in the given workspace directory.
+ * Uses Bun.spawn if available, otherwise falls back to child_process.spawn.
+ */
+export declare function runBunInstall(workspaceDir: string): Promise<boolean>;
+/**
+ * Orchestrates the full auto-update flow:
+ * 1. Skip checks (dev mode, pinned version)
+ * 2. Get current version
+ * 3. Check cache, fetch latest if stale
+ * 4. Compare versions
+ * 5. Notify or auto-update
+ */
+export declare function runAutoUpdate(ctx: any, autoUpdate: boolean): Promise<void>;

package/dist/updater.js

@@ -0,0 +1,385 @@
+/**
+ * Auto-update module for @ulthon/ul-opencode-event.
+ *
+ * Checks npm registry for new versions, manages a 24h cache,
+ * and optionally runs `bun install` to auto-update.
+ *
+ * Zero runtime dependencies — only Node.js built-ins + project logger.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { fileURLToPath } from 'url';
+import { logger } from './logger.js';
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const PACKAGE_NAME = '@ulthon/ul-opencode-event';
+const NPM_REGISTRY_URL = `https://registry.npmjs.org/-/package/${encodeURIComponent(PACKAGE_NAME)}/dist-tags`;
+const NPM_FETCH_TIMEOUT = 5000; // 5 seconds
+const BUN_INSTALL_TIMEOUT = 60000; // 60 seconds
+const CACHE_TTL = 24 * 60 * 60 * 1000; // 24 hours in ms
+// ---------------------------------------------------------------------------
+// Helpers: cache paths
+// ---------------------------------------------------------------------------
+function getCacheDir() {
+    return process.env.OPENCODE_DATA_DIR ?? path.join(os.homedir(), '.local', 'share', 'opencode');
+}
+function getCacheFilePath() {
+    return path.join(getCacheDir(), 'ul-opencode-event-update-cache.json');
+}
+function getUserConfigDir() {
+    return path.join(os.homedir(), '.config', 'opencode');
+}
+// ---------------------------------------------------------------------------
+// Exported: version resolution
+// ---------------------------------------------------------------------------
+/**
+ * Read the current installed version from this module's package.json
+ * by walking up from `import.meta.url`.
+ */
+export function getCurrentVersion() {
+    try {
+        let dir = path.dirname(fileURLToPath(import.meta.url));
+        for (let i = 0; i < 10; i++) {
+            const pkgPath = path.join(dir, 'package.json');
+            try {
+                const raw = fs.readFileSync(pkgPath, 'utf-8');
+                const pkg = JSON.parse(raw);
+                if (pkg.name === PACKAGE_NAME) {
+                    return pkg.version ?? null;
+                }
+            }
+            catch {
+                // package.json not found here, walk up
+            }
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                break; // filesystem root
+            dir = parent;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+// ---------------------------------------------------------------------------
+// Exported: npm registry fetch
+// ---------------------------------------------------------------------------
+/**
+ * Fetch the latest version string from the npm dist-tags API.
+ * Returns `null` on any error (network, parse, timeout).
+ */
+export async function getLatestVersion() {
+    try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), NPM_FETCH_TIMEOUT);
+        const resp = await fetch(NPM_REGISTRY_URL, {
+            signal: controller.signal,
+            headers: { Accept: 'application/json' },
+        });
+        clearTimeout(timer);
+        if (!resp.ok) {
+            logger.debug(`[updater] npm registry returned status ${resp.status}`);
+            return null;
+        }
+        const data = (await resp.json());
+        return typeof data.latest === 'string' ? data.latest : null;
+    }
+    catch (err) {
+        logger.debug(`[updater] Failed to fetch latest version: ${err}`);
+        return null;
+    }
+}
+// ---------------------------------------------------------------------------
+// Exported: cache read / write / validity
+// ---------------------------------------------------------------------------
+export function getCachedCheck() {
+    try {
+        const raw = fs.readFileSync(getCacheFilePath(), 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export function setCachedCheck(latestVersion) {
+    try {
+        const obj = { latestVersion, timestamp: Date.now() };
+        fs.mkdirSync(path.dirname(getCacheFilePath()), { recursive: true });
+        fs.writeFileSync(getCacheFilePath(), JSON.stringify(obj, null, 2), 'utf-8');
+    }
+    catch (err) {
+        logger.error(`[updater] Failed to write update cache: ${err}`);
+    }
+}
+export function isCacheValid() {
+    const cached = getCachedCheck();
+    if (!cached)
+        return false;
+    return Date.now() - cached.timestamp < CACHE_TTL;
+}
+function readPluginList(directory) {
+    const results = [];
+    const candidates = [
+        path.join(directory, '.opencode', 'settings.json'),
+        path.join(getUserConfigDir(), 'settings.json'),
+    ];
+    for (const cfgPath of candidates) {
+        try {
+            const raw = fs.readFileSync(cfgPath, 'utf-8');
+            const settings = JSON.parse(raw);
+            if (Array.isArray(settings.plugin)) {
+                results.push(...settings.plugin);
+            }
+        }
+        catch {
+            // file missing or invalid — skip
+        }
+    }
+    return results;
+}
+function isLocalDevMode(directory) {
+    try {
+        const plugins = readPluginList(directory);
+        return plugins.some((entry) => entry.startsWith('file://') && entry.includes('ul-opencode-event'));
+    }
+    catch {
+        return false;
+    }
+}
+const EXACT_SEMVER_RE = /^\d+\.\d+\.\d+(-[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?$/;
+function isPinnedVersion(directory) {
+    try {
+        const plugins = readPluginList(directory);
+        return plugins.some((entry) => {
+            // Match patterns like @ulthon/ul-opencode-event@1.2.3 or @ulthon/ul-opencode-event@1.2.3-beta.1
+            if (!entry.includes('ul-opencode-event'))
+                return false;
+            const atIndex = entry.lastIndexOf('@');
+            if (atIndex <= 0)
+                return false; // no version part or starts with @ (scoped package)
+            const version = entry.slice(atIndex + 1);
+            // For scoped packages like @ulthon/ul-opencode-event@1.2.3, the lastIndexOf('@')
+            // will find the second @. But we need to make sure the prefix is the scoped package.
+            // So we check the version part matches exact semver.
+            return EXACT_SEMVER_RE.test(version);
+        });
+    }
+    catch {
+        return false;
+    }
+}
+// ---------------------------------------------------------------------------
+// Helper: package invalidation
+// ---------------------------------------------------------------------------
+function invalidatePackage() {
+    try {
+        const dirs = [
+            path.join(getCacheDir(), 'packages', 'node_modules', PACKAGE_NAME),
+            path.join(getUserConfigDir(), 'node_modules', PACKAGE_NAME),
+        ];
+        for (const pkgDir of dirs) {
+            try {
+                if (fs.existsSync(pkgDir)) {
+                    fs.rmSync(pkgDir, { recursive: true, force: true });
+                    logger.info(`[updater] Invalidated package at ${pkgDir}`);
+                }
+            }
+            catch (err) {
+                logger.debug(`[updater] Could not remove ${pkgDir}: ${err}`);
+            }
+        }
+        // Also remove bun.lock / bun.lockb from workspace dirs
+        const workspaceDirs = [
+            path.join(getCacheDir(), 'packages'),
+            getUserConfigDir(),
+        ];
+        for (const wsDir of workspaceDirs) {
+            for (const lockFile of ['bun.lock', 'bun.lockb']) {
+                const lockPath = path.join(wsDir, lockFile);
+                try {
+                    if (fs.existsSync(lockPath)) {
+                        fs.rmSync(lockPath, { force: true });
+                        logger.info(`[updater] Removed ${lockPath}`);
+                    }
+                }
+                catch (err) {
+                    logger.debug(`[updater] Could not remove ${lockPath}: ${err}`);
+                }
+            }
+        }
+    }
+    catch (err) {
+        logger.error(`[updater] Package invalidation failed: ${err}`);
+    }
+}
+// ---------------------------------------------------------------------------
+// Helper: resolve workspace directory
+// ---------------------------------------------------------------------------
+function resolveWorkspaceDir() {
+    const configDir = getUserConfigDir();
+    const packagesDir = path.join(getCacheDir(), 'packages');
+    // Check if installed in config dir
+    const configPkg = path.join(configDir, 'node_modules', PACKAGE_NAME, 'package.json');
+    if (fs.existsSync(configPkg))
+        return configDir;
+    // Check packages dir (node_modules style)
+    const packagesPkg = path.join(packagesDir, 'node_modules', PACKAGE_NAME, 'package.json');
+    if (fs.existsSync(packagesPkg))
+        return packagesDir;
+    // Check packages dir (flat)
+    const flatPkg = path.join(packagesDir, 'package.json');
+    if (fs.existsSync(flatPkg))
+        return packagesDir;
+    // Default to config dir
+    return configDir;
+}
+// ---------------------------------------------------------------------------
+// Exported: bun install
+// ---------------------------------------------------------------------------
+/**
+ * Execute `bun install` in the given workspace directory.
+ * Uses Bun.spawn if available, otherwise falls back to child_process.spawn.
+ */
+export async function runBunInstall(workspaceDir) {
+    try {
+        const { spawn } = await import('child_process');
+        return await new Promise((resolve) => {
+            const spawnOptions = {
+                cwd: workspaceDir,
+                windowsHide: true,
+                shell: true,
+            };
+            const child = spawn('bun', ['install'], spawnOptions);
+            let stdout = '';
+            let stderr = '';
+            child.stdout?.on('data', (data) => {
+                stdout += data.toString();
+            });
+            child.stderr?.on('data', (data) => {
+                stderr += data.toString();
+            });
+            // Timeout guard
+            const timer = setTimeout(() => {
+                child.kill('SIGKILL');
+                logger.warn('[updater] bun install timed out after 60s');
+                resolve(false);
+            }, BUN_INSTALL_TIMEOUT);
+            child.on('close', (code) => {
+                clearTimeout(timer);
+                if (code === 0) {
+                    resolve(true);
+                }
+                else {
+                    logger.warn(`[updater] bun install exited with code ${code}`);
+                    if (stderr)
+                        logger.debug(`[updater] bun install stderr: ${stderr}`);
+                    if (stdout)
+                        logger.debug(`[updater] bun install stdout: ${stdout}`);
+                    resolve(false);
+                }
+            });
+            child.on('error', (err) => {
+                clearTimeout(timer);
+                logger.error(`[updater] bun install spawn error: ${err}`);
+                resolve(false);
+            });
+        });
+    }
+    catch (err) {
+        logger.error(`[updater] bun install failed: ${err}`);
+        return false;
+    }
+}
+// ---------------------------------------------------------------------------
+// Helper: toast notification
+// ---------------------------------------------------------------------------
+async function showToast(ctx, title, message, variant, duration) {
+    try {
+        await ctx.client.tui
+            .showToast({ body: { title, message, variant, duration } })
+            .catch(() => { });
+    }
+    catch {
+        logger.info(`[updater] ${title}: ${message}`);
+    }
+}
+// ---------------------------------------------------------------------------
+// Main entry point
+// ---------------------------------------------------------------------------
+/**
+ * Orchestrates the full auto-update flow:
+ * 1. Skip checks (dev mode, pinned version)
+ * 2. Get current version
+ * 3. Check cache, fetch latest if stale
+ * 4. Compare versions
+ * 5. Notify or auto-update
+ */
+export async function runAutoUpdate(ctx, autoUpdate) {
+    try {
+        // 1. Skip checks
+        if (isLocalDevMode(ctx.directory)) {
+            logger.info('[updater] Local development mode detected, skipping update check');
+            return;
+        }
+        if (isPinnedVersion(ctx.directory)) {
+            logger.info('[updater] Pinned version detected, skipping auto-update');
+            // Still check and notify, but don't auto-install
+            autoUpdate = false;
+        }
+        // 2. Get current version
+        const currentVersion = getCurrentVersion();
+        if (!currentVersion) {
+            logger.debug('[updater] Could not determine current version');
+            return;
+        }
+        // 3. Check cache first
+        let latestVersion = null;
+        if (isCacheValid()) {
+            const cached = getCachedCheck();
+            if (cached) {
+                latestVersion = cached.latestVersion;
+                logger.debug(`[updater] Using cached version info: ${latestVersion}`);
+            }
+        }
+        // 4. Fetch latest if no valid cache
+        if (!latestVersion) {
+            latestVersion = await getLatestVersion();
+            if (latestVersion) {
+                setCachedCheck(latestVersion);
+            }
+        }
+        if (!latestVersion) {
+            logger.debug('[updater] Could not fetch latest version');
+            return;
+        }
+        // 5. Compare versions (simple string equality)
+        if (currentVersion === latestVersion) {
+            logger.debug(`[updater] Already on latest version: ${currentVersion}`);
+            return;
+        }
+        logger.info(`[updater] Update available: ${currentVersion} -> ${latestVersion}`);
+        // 6. If auto-update disabled, just notify
+        if (!autoUpdate) {
+            await showToast(ctx, `ul-opencode-event ${latestVersion}`, `Update available: v${currentVersion} -> v${latestVersion}\nRun: npm update @ulthon/ul-opencode-event`, 'info', 8000);
+            return;
+        }
+        // 7. Auto-update: invalidate + bun install
+        invalidatePackage();
+        const workspaceDir = resolveWorkspaceDir();
+        const success = await runBunInstall(workspaceDir);
+        if (success) {
+            await showToast(ctx, 'ul-opencode-event Updated!', `v${currentVersion} -> v${latestVersion}\nRestart OpenCode to apply.`, 'success', 8000);
+            logger.info(`[updater] Update installed: ${currentVersion} -> ${latestVersion}`);
+        }
+        else {
+            await showToast(ctx, 'ul-opencode-event Update Failed', `Failed to install v${latestVersion}. Run manually: npm update @ulthon/ul-opencode-event`, 'error', 8000);
+            logger.warn('[updater] bun install failed, update not installed');
+        }
+    }
+    catch (err) {
+        logger.error(`[updater] Auto-update check failed: ${err}`);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ulthon/ul-opencode-event",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "description": "OpenCode notification plugin - sends notifications via email or DingTalk when session events occur",
   "author": "augushong",
   "license": "MIT",