opencoding-agent 1.0.3 → 1.0.4

package/dist/src/hooks/auto-update/cache.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Invalidates the current package by removing its directory from OpenCode's cache.
+ * This forces a clean state so OpenCode re-downloads the plugin on next run.
+ * @param packageName The name of the package to invalidate.
+ */
+export declare function invalidatePackage(packageName?: string): boolean;

package/dist/src/hooks/auto-update/cache.js

@@ -0,0 +1,24 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { CACHE_DIR, PACKAGE_NAME } from './constants';
+/**
+ * Invalidates the current package by removing its directory from OpenCode's cache.
+ * This forces a clean state so OpenCode re-downloads the plugin on next run.
+ * @param packageName The name of the package to invalidate.
+ */
+export function invalidatePackage(packageName = PACKAGE_NAME) {
+    try {
+        const pkgDir = path.join(CACHE_DIR, 'node_modules', packageName);
+        if (fs.existsSync(pkgDir)) {
+            fs.rmSync(pkgDir, { recursive: true, force: true });
+            console.log(`[auto-update] Package cache removed: ${pkgDir}`);
+            return true;
+        }
+        console.log(`[auto-update] Package not found in cache: ${packageName}`);
+        return false;
+    }
+    catch (err) {
+        console.error('[auto-update] Failed to invalidate package:', err);
+        return false;
+    }
+}

package/dist/src/hooks/auto-update/checker.d.ts

@@ -0,0 +1,18 @@
+export interface PackageJson {
+    name?: string;
+    version?: string;
+    [key: string]: unknown;
+}
+export interface NpmDistTags {
+    latest: string;
+    [key: string]: string;
+}
+export declare function getCachedVersion(): string | null;
+/**
+ * Fetches the latest version for a specific channel from the NPM registry.
+ */
+export declare function getLatestVersion(channel?: string): Promise<string | null>;
+/**
+ * Checks if the plugin is running in local development mode (e.g. from a file path).
+ */
+export declare function isLocalDevMode(directory: string): boolean;

package/dist/src/hooks/auto-update/checker.js

@@ -0,0 +1,128 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { INSTALLED_PACKAGE_JSON, NPM_FETCH_TIMEOUT, NPM_REGISTRY_URL, PACKAGE_NAME, USER_OPENCODE_CONFIG, USER_OPENCODE_CONFIG_JSONC } from './constants';
+/**
+ * Strips single and multi-line comments from a JSON string.
+ */
+function stripJsonComments(text) {
+    return text.replace(/\/\/.*|\/\*[\s\S]*?\*\//g, "");
+}
+/**
+ * Resolves the installed version from node_modules, with memoization.
+ */
+let cachedPackageVersion = null;
+export function getCachedVersion() {
+    if (cachedPackageVersion)
+        return cachedPackageVersion;
+    try {
+        if (fs.existsSync(INSTALLED_PACKAGE_JSON)) {
+            const content = fs.readFileSync(INSTALLED_PACKAGE_JSON, 'utf-8');
+            const pkg = JSON.parse(content);
+            if (pkg.version) {
+                cachedPackageVersion = pkg.version;
+                return pkg.version;
+            }
+        }
+    }
+    catch {
+        /* empty */
+    }
+    try {
+        const currentDir = path.dirname(fileURLToPath(import.meta.url));
+        const pkgPath = findPackageJsonUp(currentDir);
+        if (pkgPath) {
+            const content = fs.readFileSync(pkgPath, 'utf-8');
+            const pkg = JSON.parse(content);
+            if (pkg.version) {
+                cachedPackageVersion = pkg.version;
+                return pkg.version;
+            }
+        }
+    }
+    catch (err) {
+        console.warn('[auto-update] Failed to resolve version from current directory:', err);
+    }
+    return null;
+}
+/**
+ * Recursively searches upwards for a package.json belonging to this plugin.
+ */
+function findPackageJsonUp(startPath) {
+    try {
+        const stat = fs.statSync(startPath);
+        let dir = stat.isDirectory() ? startPath : path.dirname(startPath);
+        for (let i = 0; i < 10; i++) {
+            const pkgPath = path.join(dir, 'package.json');
+            if (fs.existsSync(pkgPath)) {
+                try {
+                    const content = fs.readFileSync(pkgPath, 'utf-8');
+                    const pkg = JSON.parse(content);
+                    if (pkg.name === PACKAGE_NAME)
+                        return pkgPath;
+                }
+                catch {
+                    /* empty */
+                }
+            }
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    catch {
+        /* empty */
+    }
+    return null;
+}
+/**
+ * Fetches the latest version for a specific channel from the NPM registry.
+ */
+export async function getLatestVersion(channel = 'latest') {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), NPM_FETCH_TIMEOUT);
+    try {
+        const response = await fetch(NPM_REGISTRY_URL, {
+            signal: controller.signal,
+            headers: { Accept: 'application/json' },
+        });
+        if (!response.ok)
+            return null;
+        const data = (await response.json());
+        return data[channel] ?? data.latest ?? null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+/**
+ * Checks if the plugin is running in local development mode (e.g. from a file path).
+ */
+export function isLocalDevMode(directory) {
+    const configPaths = [
+        path.join(directory, '.opencode', 'opencode.json'),
+        path.join(directory, '.opencode', 'opencode.jsonc'),
+        USER_OPENCODE_CONFIG,
+        USER_OPENCODE_CONFIG_JSONC,
+    ];
+    for (const configPath of configPaths) {
+        try {
+            if (fs.existsSync(configPath)) {
+                const content = fs.readFileSync(configPath, 'utf-8');
+                const json = JSON.parse(stripJsonComments(content));
+                const plugins = json.plugin ?? [];
+                if (plugins.some((p) => p.startsWith('/') || p.startsWith('file://'))) {
+                    return true;
+                }
+            }
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    return false;
+}

package/dist/src/hooks/auto-update/constants.d.ts

@@ -0,0 +1,9 @@
+export declare const PACKAGE_NAME = "opencoding-agent";
+export declare const NPM_REGISTRY_URL = "https://registry.npmjs.org/-/package/opencoding-agent/dist-tags";
+export declare const NPM_FETCH_TIMEOUT = 3000;
+/** The directory used by OpenCode to cache node_modules for plugins. */
+export declare const CACHE_DIR: string;
+/** Path to this plugin's package.json within the OpenCode cache. */
+export declare const INSTALLED_PACKAGE_JSON: string;
+export declare const USER_OPENCODE_CONFIG: string;
+export declare const USER_OPENCODE_CONFIG_JSONC: string;

package/dist/src/hooks/auto-update/constants.js

@@ -0,0 +1,23 @@
+import * as os from 'node:os';
+import * as path from 'node:path';
+export const PACKAGE_NAME = 'opencoding-agent';
+export const NPM_REGISTRY_URL = `https://registry.npmjs.org/-/package/${PACKAGE_NAME}/dist-tags`;
+export const NPM_FETCH_TIMEOUT = 3000;
+function getCacheDir() {
+    if (process.platform === 'win32') {
+        return path.join(process.env.LOCALAPPDATA ?? os.homedir(), 'opencode');
+    }
+    return path.join(os.homedir(), '.cache', 'opencode');
+}
+/** The directory used by OpenCode to cache node_modules for plugins. */
+export const CACHE_DIR = getCacheDir();
+/** Path to this plugin's package.json within the OpenCode cache. */
+export const INSTALLED_PACKAGE_JSON = path.join(CACHE_DIR, 'node_modules', PACKAGE_NAME, 'package.json');
+function getConfigDir() {
+    const userConfigDir = process.env.XDG_CONFIG_HOME
+        ? process.env.XDG_CONFIG_HOME
+        : path.join(os.homedir(), '.config');
+    return path.join(userConfigDir, 'opencode');
+}
+export const USER_OPENCODE_CONFIG = path.join(getConfigDir(), 'opencode.json');
+export const USER_OPENCODE_CONFIG_JSONC = path.join(getConfigDir(), 'opencode.jsonc');

package/dist/src/hooks/auto-update/index.d.ts

@@ -0,0 +1,15 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+/**
+ * Creates an OpenCode hook that checks for plugin updates and invalidates cache if available.
+ *
+ * @param ctx The plugin input context.
+ * @returns A hook object for the session.created event.
+ */
+export declare function createAutoUpdateHook(ctx: PluginInput): {
+    event: ({ event }: {
+        event: {
+            type: string;
+            properties?: unknown;
+        };
+    }) => void;
+};

package/dist/src/hooks/auto-update/index.js

@@ -0,0 +1,52 @@
+import { getCachedVersion, getLatestVersion, isLocalDevMode } from './checker';
+import { invalidatePackage } from './cache';
+/**
+ * Creates an OpenCode hook that checks for plugin updates and invalidates cache if available.
+ *
+ * @param ctx The plugin input context.
+ * @returns A hook object for the session.created event.
+ */
+export function createAutoUpdateHook(ctx) {
+    let hasChecked = false;
+    return {
+        event: ({ event }) => {
+            // Only run once per process when a session is created
+            if (event.type !== 'session.created')
+                return;
+            if (hasChecked)
+                return;
+            hasChecked = true;
+            // Run check in the background
+            setTimeout(async () => {
+                // Skip check if in local development mode
+                if (isLocalDevMode(ctx.directory)) {
+                    console.log('[auto-update] Local development mode detected. Skipping check.');
+                    return;
+                }
+                const currentVersion = getCachedVersion();
+                const latestVersion = await getLatestVersion();
+                if (!currentVersion || !latestVersion) {
+                    console.log('[auto-update] Could not determine versions. Skipping.');
+                    return;
+                }
+                if (currentVersion !== latestVersion) {
+                    console.log(`[auto-update] Update available: ${currentVersion} → ${latestVersion}`);
+                    // Show toast notification
+                    ctx.client.tui.showToast({
+                        body: {
+                            title: 'opencoding-agent Update!',
+                            message: `v${latestVersion} is available. Restart OpenCode to apply.`,
+                            variant: 'info',
+                            duration: 8000,
+                        },
+                    }).catch(() => { });
+                    // Invalidate cache
+                    invalidatePackage();
+                }
+                else {
+                    console.log(`[auto-update] Already on latest version: ${currentVersion}`);
+                }
+            }, 0);
+        },
+    };
+}

package/dist/src/index.js

@@ -2,6 +2,7 @@ import { injectAgents } from "./agents";
 import { catalogTools } from "./tools/catalog";
 import { createBuiltinMcps } from "./mcp";
 import { loadPluginConfig } from "./config";
+import { createAutoUpdateHook } from "./hooks/auto-update";
 /**
  * opencoding-agent Plugin
  *
@@ -12,6 +13,8 @@ const OpencodingAgentPlugin = async (ctx) => {
     const pluginConfig = loadPluginConfig(ctx.directory);
     const mcps = createBuiltinMcps(pluginConfig.disabled_mcps);
     const mcpNames = Object.keys(mcps);
+    // Initialize auto-update hook
+    const autoUpdateHook = createAutoUpdateHook(ctx);
     return {
         name: "opencoding-agent",
         // Config hook: Injected once during initialization
@@ -52,6 +55,10 @@ const OpencodingAgentPlugin = async (ctx) => {
                 }
             });
         },
+        // Session events
+        event: async (input) => {
+            await autoUpdateHook.event(input);
+        },
         // Register custom tools
         tool: {
             ...catalogTools,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencoding-agent",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "main": "dist/index.js",
   "devDependencies": {
     "@opencode-ai/plugin": "^1.0.0",