plugin-updater 1.0.38 → 1.0.39

package/dist/config.d.ts

@@ -0,0 +1,8 @@
+import type { Plugin } from "./types.js";
+export declare function readOpencodeJson(configDir: string): {
+    plugins: string[];
+    raw: Record<string, unknown>;
+};
+export declare function writeOpencodeJson(configDir: string, data: Record<string, unknown>): void;
+export declare function getPluginsPath(configDir: string): string;
+export declare function getPlugins(configDir: string): Plugin[];

package/dist/config.js

@@ -0,0 +1,48 @@
+import fs from "fs";
+import path from "path";
+import { isOpencodeHookInvocation } from "./env.js";
+import { writeLog } from "./log.js";
+export function readOpencodeJson(configDir) {
+    const ocPath = path.join(configDir, "opencode.json");
+    if (!fs.existsSync(ocPath))
+        return { plugins: [], raw: {} };
+    try {
+        const stripped = fs.readFileSync(ocPath, "utf8").replace(/^\s*\/\/[^\n]*/gm, "");
+        const parsed = JSON.parse(stripped);
+        const plugins = (parsed.plugin || []);
+        return { plugins: plugins.filter((p) => typeof p === "string"), raw: parsed };
+    }
+    catch {
+        return { plugins: [], raw: {} };
+    }
+}
+export function writeOpencodeJson(configDir, data) {
+    const ocPath = path.join(configDir, "opencode.json");
+    fs.writeFileSync(ocPath, JSON.stringify(data, null, 2), "utf8");
+}
+export function getPluginsPath(configDir) {
+    if (isOpencodeHookInvocation(configDir))
+        return "";
+    const preferred = path.join(configDir, "config", "plugins.json");
+    const fallback = path.join(configDir, "plugins.json");
+    if (fs.existsSync(preferred))
+        return preferred;
+    if (fs.existsSync(fallback))
+        return fallback;
+    return preferred;
+}
+// single source of truth for the git-plugin list; consumers (loaders, TUI)
+// must read through this rather than touching plugins.json directly
+export function getPlugins(configDir) {
+    if (isOpencodeHookInvocation(configDir))
+        return [];
+    const file = getPluginsPath(configDir);
+    try {
+        if (fs.existsSync(file))
+            return JSON.parse(fs.readFileSync(file, "utf-8"));
+    }
+    catch (e) {
+        writeLog(`Failed to parse ${file}: ${e.message}`, true);
+    }
+    return [];
+}

package/dist/daemon.d.ts

@@ -0,0 +1 @@
+export declare function startDeclaredDaemon(sourceDir: string, configDir: string, pluginName: string): Promise<void>;

package/dist/daemon.js

@@ -0,0 +1,55 @@
+import fs from "fs";
+import path from "path";
+import { getAppName } from "./env.js";
+import { writeLog } from "./log.js";
+async function isDaemonHealthy(url) {
+    try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 1500);
+        const res = await fetch(url, { signal: controller.signal });
+        clearTimeout(timer);
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+// idempotent: health-check the declared endpoint, spawn detached only if down.
+// the daemon outlives this process so the proxy persists across the session.
+export async function startDeclaredDaemon(sourceDir, configDir, pluginName) {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(sourceDir, "package.json"), "utf8"));
+        const daemon = pkg.claudeHub?.daemon;
+        if (!daemon?.script)
+            return;
+        const healthUrl = daemon.healthCheckUrl
+            || (daemon.port ? `http://127.0.0.1:${daemon.port}/health` : "");
+        if (healthUrl && (await isDaemonHealthy(healthUrl))) {
+            writeLog(`Daemon for ${pluginName} already running`);
+            return;
+        }
+        const scriptPath = path.join(sourceDir, daemon.script);
+        if (!fs.existsSync(scriptPath)) {
+            writeLog(`Daemon script missing for ${pluginName}: ${scriptPath}`, true);
+            return;
+        }
+        const runtime = daemon.runtime || "node";
+        const { spawn } = await import("child_process");
+        const child = spawn(runtime, [scriptPath], {
+            cwd: sourceDir,
+            detached: true,
+            stdio: "ignore",
+            env: {
+                ...process.env,
+                HUB_CONFIG_DIR: configDir,
+                HUB_APP_NAME: getAppName() === "claude" ? "Claude Code" : "OpenCode",
+                ...(daemon.port ? { HUB_PROXY_PORT: String(daemon.port) } : {}),
+            },
+        });
+        child.unref();
+        writeLog(`Started daemon for ${pluginName} (${runtime} ${daemon.script})`);
+    }
+    catch (e) {
+        writeLog(`Daemon start failed for ${pluginName}: ${e.message}`, true);
+    }
+}

package/dist/deploy.d.ts

@@ -0,0 +1 @@
+export declare function deployToExecutionDir(pluginName: string, executionPath: string, changed: boolean, configDir: string): Promise<boolean>;

package/dist/deploy.js

@@ -0,0 +1,135 @@
+import fs from "fs";
+import path from "path";
+import { execSync } from "child_process";
+import { getAppName, getReposDir } from "./env.js";
+import { writeLog } from "./log.js";
+import { buildInTempDir } from "./git.js";
+import { startDeclaredDaemon } from "./daemon.js";
+async function callPluginCleanup(pluginExecutionFile, configDir) {
+    if (!fs.existsSync(pluginExecutionFile))
+        return;
+    try {
+        const mod = await import(pluginExecutionFile);
+        if (typeof mod.cleanup === "function") {
+            writeLog(`Calling cleanup() on ${pluginExecutionFile}`);
+            await mod.cleanup(configDir);
+            writeLog(`cleanup() complete for ${pluginExecutionFile}`);
+        }
+    }
+    catch (e) {
+        writeLog(`cleanup() call failed for ${pluginExecutionFile}: ${e.message}`, true);
+    }
+}
+// under claude, deployed plugins declare env/daemon in package.json#claudeHub;
+// merge the env into settings.json so providers work without a login
+function applyClaudeManifest(sourceDir, configDir, pluginName) {
+    if (getAppName() !== "claude")
+        return;
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(sourceDir, "package.json"), "utf8"));
+        const manifest = pkg.claudeHub;
+        if (!manifest?.env || typeof manifest.env !== "object")
+            return;
+        const settingsPath = path.join(configDir, "settings.json");
+        let settings = {};
+        try {
+            settings = JSON.parse(fs.readFileSync(settingsPath, "utf8"));
+        }
+        catch { /* fresh file */ }
+        const env = (settings.env ?? {});
+        for (const [key, value] of Object.entries(manifest.env)) {
+            env[key] = String(value);
+            writeLog(`settings.json env ${key} set by ${pluginName}`);
+        }
+        settings.env = env;
+        fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), "utf8");
+    }
+    catch (e) {
+        writeLog(`claudeHub manifest handling failed for ${pluginName}: ${e.message}`, true);
+    }
+}
+export async function deployToExecutionDir(pluginName, executionPath, changed, configDir) {
+    const sourceDir = path.join(getReposDir(), pluginName);
+    if (!fs.existsSync(sourceDir))
+        return false;
+    const packageJsonPath = path.join(sourceDir, "package.json");
+    let entryFile = "index.js";
+    const pluginExecutionFile = path.join(executionPath, `${pluginName}.js`);
+    if (!changed && fs.existsSync(pluginExecutionFile)) {
+        writeLog(`Skipping install/build for ${pluginName} (no changes and deployed file exists)`);
+    }
+    else if (fs.existsSync(packageJsonPath)) {
+        try {
+            buildInTempDir(pluginName, sourceDir);
+            const runtimeDeps = JSON.parse(fs.readFileSync(packageJsonPath, "utf8")).dependencies;
+            if (runtimeDeps && Object.keys(runtimeDeps).length > 0) {
+                writeLog(`Installing runtime dependencies for ${pluginName}`);
+                execSync("npm install --omit=dev", { cwd: sourceDir, stdio: "pipe" });
+                writeLog(`Finished runtime dependencies for ${pluginName}`);
+            }
+        }
+        catch (error) {
+            const err = error;
+            const stderr = err.stderr ? err.stderr.toString().trim() : "";
+            const stdout = err.stdout ? err.stdout.toString().trim() : "";
+            writeLog(`Build/Install failed for ${pluginName}: ${err.message}`, true);
+            if (stderr)
+                writeLog(`npm stderr: ${stderr}`, true);
+            if (stdout)
+                writeLog(`npm stdout: ${stdout}`, true);
+        }
+    }
+    if (fs.existsSync(packageJsonPath)) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+            if (pkg.main)
+                entryFile = pkg.main;
+        }
+        catch { /* ignore */ }
+    }
+    const distPath = path.join(sourceDir, "dist");
+    let deploySource = path.join(sourceDir, entryFile);
+    if (fs.existsSync(path.join(distPath, entryFile))) {
+        deploySource = path.join(distPath, entryFile);
+    }
+    else if (fs.existsSync(path.join(distPath, "index.js"))) {
+        deploySource = path.join(distPath, "index.js");
+    }
+    if (!fs.existsSync(executionPath))
+        fs.mkdirSync(executionPath, { recursive: true });
+    await callPluginCleanup(pluginExecutionFile, configDir);
+    try {
+        writeLog(`Running copy for ${pluginName}`);
+        fs.copyFileSync(deploySource, pluginExecutionFile);
+        writeLog(`Finished copy for ${pluginName}`);
+    }
+    catch (e) {
+        writeLog(`Copy failed for ${pluginName}: ${e.message}`, true);
+    }
+    applyClaudeManifest(sourceDir, configDir, pluginName);
+    await startDeclaredDaemon(sourceDir, configDir, pluginName);
+    // Claude Code never imports deployed plugin files, so under claude the
+    // updater is the runtime and invokes the plugin's activate() itself
+    if (getAppName() === "claude") {
+        try {
+            const deployed = await import(pluginExecutionFile);
+            if (typeof deployed.activate === "function") {
+                writeLog(`Activating ${pluginName}`);
+                // tells the plugin the updater is the caller, so it must not start
+                // another earlyLaunch and recurse back into the updater
+                process.env.PLUGIN_UPDATER_ACTIVATION = "1";
+                try {
+                    await deployed.activate();
+                }
+                finally {
+                    delete process.env.PLUGIN_UPDATER_ACTIVATION;
+                }
+                writeLog(`Activated ${pluginName}`);
+            }
+        }
+        catch (e) {
+            writeLog(`Activation failed for ${pluginName}: ${e.message}`, true);
+        }
+    }
+    return true;
+}

package/dist/env.d.ts

@@ -0,0 +1,5 @@
+export declare function setEarlyLaunchConfigDir(dir: string): void;
+export declare function getAppName(): string;
+export declare function getAppConfigDir(appName: string): string;
+export declare function getReposDir(): string;
+export declare function isOpencodeHookInvocation(firstArgument: unknown): boolean;

package/dist/env.js

@@ -0,0 +1,32 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+// set by earlyLaunch/direct-update so all path resolution targets that dir
+let earlyLaunchConfigDir = null;
+export function setEarlyLaunchConfigDir(dir) {
+    earlyLaunchConfigDir = dir;
+}
+// the CLI runs without "claude" in argv, so it forces the app via env
+export function getAppName() {
+    const override = process.env.PLUGIN_UPDATER_APP;
+    if (override === "claude" || override === "opencode")
+        return override;
+    return process.argv.join(" ").includes("claude") ? "claude" : "opencode";
+}
+export function getAppConfigDir(appName) {
+    if (earlyLaunchConfigDir)
+        return earlyLaunchConfigDir;
+    const home = os.homedir();
+    const directPath = path.join(home, `.${appName}`);
+    const configPath = path.join(home, ".config", appName);
+    return fs.existsSync(directPath) ? directPath : configPath;
+}
+export function getReposDir() {
+    return path.join(getAppConfigDir(getAppName()), "repos");
+}
+// opencode invokes every exported function as a plugin hook, passing a context
+// object instead of our protocol arguments; exports detect that and return an
+// inert value so opencode gets a valid (empty) plugin instance
+export function isOpencodeHookInvocation(firstArgument) {
+    return typeof firstArgument !== "string";
+}

package/dist/git.d.ts

@@ -0,0 +1,6 @@
+export declare function executeGit(command: string, cwd: string): boolean;
+export declare function updatePlugin(pluginName: string, gitUrl: string, branch: string | undefined, commitHash: string | null, updateInterval?: number): {
+    success: boolean;
+    changed: boolean;
+};
+export declare function buildInTempDir(pluginName: string, sourceDir: string): void;

package/dist/git.js

@@ -0,0 +1,128 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { execSync } from "child_process";
+import { getReposDir } from "./env.js";
+import { writeLog } from "./log.js";
+const BUILD_OUTPUT_DIRS = ["dist", path.join("core", "dist")];
+export function executeGit(command, cwd) {
+    writeLog(`Executing git: ${command} in ${cwd}`);
+    try {
+        execSync(command, {
+            cwd,
+            stdio: "pipe",
+            env: { ...process.env, GCM_INTERACTIVE: "never", GIT_TERMINAL_PROMPT: "0" },
+        });
+        return true;
+    }
+    catch (error) {
+        const err = error;
+        const stderr = err.stderr ? err.stderr.toString().trim() : "";
+        writeLog(`Git error in ${cwd}: ${err.message} | stderr: ${stderr}`, true);
+        return false;
+    }
+}
+export function updatePlugin(pluginName, gitUrl, branch, commitHash, updateInterval = 1) {
+    const reposDir = getReposDir();
+    const targetDir = path.join(reposDir, pluginName);
+    const lastCheckFile = path.join(targetDir, ".lastcheck");
+    let didChange = false;
+    if (!fs.existsSync(targetDir)) {
+        if (!fs.existsSync(reposDir))
+            fs.mkdirSync(reposDir, { recursive: true });
+        const branchFlag = branch ? `--branch ${branch}` : "";
+        const cloned = executeGit(`git clone --recurse-submodules ${branchFlag} ${gitUrl} ${pluginName}`, reposDir);
+        if (!cloned)
+            return { success: false, changed: false };
+        fs.writeFileSync(lastCheckFile, Date.now().toString());
+        didChange = true;
+    }
+    else {
+        const lastCheck = fs.existsSync(lastCheckFile)
+            ? parseInt(fs.readFileSync(lastCheckFile, "utf8"), 10)
+            : 0;
+        const intervalMs = updateInterval * 3_600_000;
+        const elapsed = Date.now() - lastCheck;
+        if (elapsed < intervalMs) {
+            writeLog(`Fast-path: ${pluginName} skipping update check (checked ${Math.floor(elapsed / 60_000)} min ago, interval ${updateInterval}h)`);
+            return { success: true, changed: false };
+        }
+        fs.writeFileSync(lastCheckFile, Date.now().toString());
+        executeGit("git fetch origin", targetDir);
+        let beforeHash = "";
+        try {
+            beforeHash = execSync("git rev-parse HEAD", { cwd: targetDir }).toString().trim();
+        }
+        catch { /* ignore */ }
+        if (commitHash) {
+            executeGit(`git checkout ${commitHash}`, targetDir);
+        }
+        else if (branch) {
+            executeGit(`git checkout ${branch}`, targetDir);
+            executeGit(`git pull --ff-only origin ${branch}`, targetDir);
+        }
+        else {
+            // the updater owns repos/: hard-sync to the remote so force-pushed
+            // branches and rewritten submodule history cannot strand the clone
+            executeGit("git fetch origin", targetDir);
+            executeGit("git checkout main || git checkout master", targetDir);
+            executeGit("git reset --hard @{upstream}", targetDir);
+        }
+        executeGit("git submodule sync --recursive", targetDir);
+        const submodulesOk = executeGit("git submodule update --init --recursive --force", targetDir);
+        if (!submodulesOk) {
+            writeLog(`Submodule sync failed for ${pluginName}, recloning`, true);
+            try {
+                fs.rmSync(targetDir, { recursive: true, force: true });
+            }
+            catch { /* ignore */ }
+            const recloneBranchFlag = branch ? `--branch ${branch}` : "";
+            executeGit(`git clone --recurse-submodules ${recloneBranchFlag} ${gitUrl} ${pluginName}`, reposDir);
+            fs.writeFileSync(lastCheckFile, Date.now().toString());
+            didChange = true;
+        }
+        let afterHash = "";
+        try {
+            afterHash = execSync("git rev-parse HEAD", { cwd: targetDir }).toString().trim();
+        }
+        catch { /* ignore */ }
+        if (beforeHash !== afterHash)
+            didChange = true;
+    }
+    return { success: true, changed: didChange };
+}
+// npm install creates node_modules/.bin symlinks, which fail on filesystems
+// without symlink support (e.g. Windows-backed Docker bind mounts) — build in
+// the OS temp dir and copy the outputs back instead
+export function buildInTempDir(pluginName, sourceDir) {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), `plugin-updater-${pluginName}-`));
+    try {
+        fs.cpSync(sourceDir, tempDir, {
+            recursive: true,
+            filter: (src) => {
+                const name = path.basename(src);
+                return name !== ".git" && name !== "node_modules";
+            },
+        });
+        writeLog(`Running npm install for ${pluginName}`);
+        execSync("npm install", { cwd: tempDir, stdio: "pipe" });
+        writeLog(`Finished npm install for ${pluginName}`);
+        const pkg = JSON.parse(fs.readFileSync(path.join(tempDir, "package.json"), "utf8"));
+        if (pkg.scripts?.build) {
+            execSync("npm run build", { cwd: tempDir, stdio: "pipe" });
+            writeLog(`Finished npm run build for ${pluginName}`);
+        }
+        else {
+            writeLog(`Skipped npm run build for ${pluginName} (no build script found)`);
+        }
+        for (const outputDir of BUILD_OUTPUT_DIRS) {
+            const builtDir = path.join(tempDir, outputDir);
+            if (fs.existsSync(builtDir)) {
+                fs.cpSync(builtDir, path.join(sourceDir, outputDir), { recursive: true });
+            }
+        }
+    }
+    finally {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+}

package/dist/index.d.ts

@@ -1,24 +1,6 @@
-interface Plugin {
-    name: string;
-    url?: string;
-    branch?: string;
-    enabled?: boolean;
-    autoUpdate?: boolean;
-    updateInterval?: number;
-}
-interface NpmPlugin {
-    name: string;
-    version: string;
-    installed: boolean;
-    raw: string;
-}
-export declare function getNpmPlugins(configDir: string): NpmPlugin[];
-export declare function installNpmPlugin(name: string, configDir: string): string;
-export declare function uninstallNpmPlugin(name: string, configDir: string): string;
-export declare function updateNpmPlugin(name: string, configDir: string, updateInterval?: number): string;
+import type { Plugin } from "./types.js";
+export { getNpmPlugins, installNpmPlugin, uninstallNpmPlugin, updateNpmPlugin } from "./npm.js";
+export { getPlugins, getPluginsPath } from "./config.js";
 export declare function updatePluginPublic(pluginName: string, gitUrl: string, branch?: string, commitHash?: string): Promise<void | object>;
 export declare function earlyLaunch(configDir: string, plugins: Plugin[]): Promise<void | object>;
-export declare function getPluginsPath(configDir: string): string;
-export declare function getPlugins(configDir: string): Plugin[];
 export declare function activate(opencodeHookInput?: unknown): Promise<void | object>;
-export {};

package/dist/index.js

@@ -1,538 +1,13 @@
-import fs from "fs";
+import { getAppConfigDir, getAppName, isOpencodeHookInvocation, setEarlyLaunchConfigDir } from "./env.js";
+import { writeLog } from "./log.js";
+import { getPlugins, readOpencodeJson } from "./config.js";
+import { selfUpdate, updateNpmPlugin } from "./npm.js";
+import { updatePlugin } from "./git.js";
+import { deployToExecutionDir } from "./deploy.js";
 import path from "path";
-import os from "os";
-import { execSync } from "child_process";
-let EARLY_LAUNCH_CONFIG_DIR = null;
-let PLUGIN_CONFIG = null;
-const START_TIME = new Date().toISOString().replace(/:/g, "-").split(".")[0];
-// the CLI runs without "claude" in argv, so it forces the app via env
-function getAppName() {
-    const override = process.env.PLUGIN_UPDATER_APP;
-    if (override === "claude" || override === "opencode")
-        return override;
-    return process.argv.join(" ").includes("claude") ? "claude" : "opencode";
-}
-function getPluginConfig() {
-    if (PLUGIN_CONFIG !== null)
-        return PLUGIN_CONFIG;
-    try {
-        const configDir = getAppConfigDir(getAppName());
-        const preferred = path.join(configDir, "config", "plugin-updater.json");
-        const fallback = path.join(configDir, "plugin-updater.json");
-        const p = fs.existsSync(preferred) ? preferred : fs.existsSync(fallback) ? fallback : null;
-        PLUGIN_CONFIG = p ? JSON.parse(fs.readFileSync(p, "utf8")) : {};
-    }
-    catch {
-        PLUGIN_CONFIG = {};
-    }
-    return PLUGIN_CONFIG ?? {};
-}
-function getAppConfigDir(appName) {
-    if (EARLY_LAUNCH_CONFIG_DIR)
-        return EARLY_LAUNCH_CONFIG_DIR;
-    const home = os.homedir();
-    const directPath = path.join(home, `.${appName}`);
-    const configPath = path.join(home, ".config", appName);
-    return fs.existsSync(directPath) ? directPath : configPath;
-}
-function writeLog(message, isError = false) {
-    const loggingEnabled = getPluginConfig().logging !== false;
-    try {
-        if (loggingEnabled) {
-            const date = new Date();
-            const dateStr = date.toISOString().split("T")[0];
-            const configDir = getAppConfigDir(getAppName());
-            const logsDir = path.join(configDir, "logs", dateStr);
-            if (!fs.existsSync(logsDir))
-                fs.mkdirSync(logsDir, { recursive: true });
-            const logFile = path.join(logsDir, `plugin-updater-${START_TIME}.log`);
-            const prefix = isError ? "[ERROR]" : "[INFO]";
-            fs.appendFileSync(logFile, `[${date.toISOString()}] ${prefix} ${message}\n`);
-        }
-    }
-    catch { /* never crash on log failure */ }
-    if (process.env.PLUGIN_UPDATER_LIBRARY_MODE === "1" && process.env.PLUGIN_UPDATER_CLI !== "1")
-        return;
-    if (isError)
-        console.error(message);
-    else if (loggingEnabled)
-        console.log(message);
-}
-let NPM_GLOBAL_ROOT = null;
-function getReposDir() {
-    return path.join(getAppConfigDir(getAppName()), "repos");
-}
-function executeGit(command, cwd) {
-    writeLog(`Executing git: ${command} in ${cwd}`);
-    try {
-        execSync(command, {
-            cwd,
-            stdio: "pipe",
-            env: { ...process.env, GCM_INTERACTIVE: "never", GIT_TERMINAL_PROMPT: "0" },
-        });
-        return true;
-    }
-    catch (error) {
-        const err = error;
-        const stderr = err.stderr ? err.stderr.toString().trim() : "";
-        writeLog(`Git error in ${cwd}: ${err.message} | stderr: ${stderr}`, true);
-        return false;
-    }
-}
-function getNpmGlobalRoot() {
-    if (NPM_GLOBAL_ROOT !== null)
-        return NPM_GLOBAL_ROOT;
-    try {
-        NPM_GLOBAL_ROOT = execSync("npm root -g", { stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
-    }
-    catch {
-        NPM_GLOBAL_ROOT = "";
-    }
-    return NPM_GLOBAL_ROOT;
-}
-function resolveNpmPluginVersion(name, configDir) {
-    try {
-        // opencode installs npm plugins into ~/.cache/opencode/packages/<name>@<spec>/
-        const packageCache = path.join(os.homedir(), ".cache", "opencode", "packages");
-        if (fs.existsSync(packageCache)) {
-            for (const entry of fs.readdirSync(packageCache)) {
-                if (entry !== name && !entry.startsWith(`${name}@`))
-                    continue;
-                const cachedPkg = path.join(packageCache, entry, "node_modules", name, "package.json");
-                if (fs.existsSync(cachedPkg)) {
-                    return JSON.parse(fs.readFileSync(cachedPkg, "utf8")).version || "";
-                }
-            }
-        }
-        const cacheDir = path.join(configDir, "cache", "node_modules");
-        const globalNpm = getNpmGlobalRoot();
-        const candidates = [
-            path.join(cacheDir, name, "package.json"),
-            path.join(configDir, "node_modules", name, "package.json"),
-            globalNpm ? path.join(globalNpm, name, "package.json") : "",
-        ].filter((p) => p !== "");
-        for (const p of candidates) {
-            if (fs.existsSync(p)) {
-                return JSON.parse(fs.readFileSync(p, "utf8")).version || "";
-            }
-        }
-        // Try resolving via node resolution as last resort
-        try {
-            const resolved = require.resolve(path.join(name, "package.json"));
-            return JSON.parse(fs.readFileSync(resolved, "utf8")).version || "";
-        }
-        catch { /* not resolvable */ }
-    }
-    catch { /* ignore */ }
-    return "";
-}
-function readOpencodeJson(configDir) {
-    const ocPath = path.join(configDir, "opencode.json");
-    if (!fs.existsSync(ocPath))
-        return { plugins: [], raw: {} };
-    try {
-        const stripped = fs.readFileSync(ocPath, "utf8").replace(/^\s*\/\/[^\n]*/gm, "");
-        const parsed = JSON.parse(stripped);
-        const plugins = (parsed.plugin || []);
-        return { plugins: plugins.filter((p) => typeof p === "string"), raw: parsed };
-    }
-    catch {
-        return { plugins: [], raw: {} };
-    }
-}
-function writeOpencodeJson(configDir, data) {
-    const ocPath = path.join(configDir, "opencode.json");
-    fs.writeFileSync(ocPath, JSON.stringify(data, null, 2), "utf8");
-}
-// ── Public API ────────────────────────────────────────────────────────────────
-// opencode invokes every exported function as a plugin hook, passing a context
-// object instead of our protocol arguments; exports detect that and return an
-// inert value so opencode gets a valid (empty) plugin instance
-function isOpencodeHookInvocation(firstArgument) {
-    return typeof firstArgument !== "string";
-}
-export function getNpmPlugins(configDir) {
-    if (isOpencodeHookInvocation(configDir))
-        return [];
-    const { plugins } = readOpencodeJson(configDir);
-    return plugins.map((raw) => {
-        const name = raw.replace(/@[^@/]+$/, "") || raw;
-        const version = resolveNpmPluginVersion(name, configDir);
-        return { name, version, installed: version !== "", raw };
-    });
-}
-export function installNpmPlugin(name, configDir) {
-    if (isOpencodeHookInvocation(name))
-        return "";
-    writeLog(`Installing npm plugin: ${name}`);
-    try {
-        const { plugins, raw } = readOpencodeJson(configDir);
-        if (!plugins.includes(name)) {
-            raw.plugin = [...plugins, name];
-            writeOpencodeJson(configDir, raw);
-        }
-        execSync(`npm install -g ${name}`, { stdio: "pipe" });
-        writeLog(`Installed npm plugin: ${name}`);
-        return "";
-    }
-    catch (e) {
-        const msg = e.message;
-        writeLog(`Failed to install ${name}: ${msg}`, true);
-        return msg;
-    }
-}
-export function uninstallNpmPlugin(name, configDir) {
-    if (isOpencodeHookInvocation(name))
-        return "";
-    writeLog(`Uninstalling npm plugin: ${name}`);
-    try {
-        const { plugins, raw } = readOpencodeJson(configDir);
-        raw.plugin = plugins.filter((p) => {
-            const pName = p.replace(/@[^@/]+$/, "") || p;
-            return pName !== name;
-        });
-        writeOpencodeJson(configDir, raw);
-        execSync(`npm uninstall -g ${name}`, { stdio: "pipe" });
-        writeLog(`Uninstalled npm plugin: ${name}`);
-        return "";
-    }
-    catch (e) {
-        const msg = e.message;
-        writeLog(`Failed to uninstall ${name}: ${msg}`, true);
-        return msg;
-    }
-}
-export function updateNpmPlugin(name, configDir, updateInterval = 1) {
-    if (isOpencodeHookInvocation(name))
-        return "";
-    writeLog(`Updating npm plugin: ${name}`);
-    const checkFile = path.join(configDir, "cache", `.npm-lastcheck-${name.replace(/[^a-z0-9]/gi, "_")}`);
-    try {
-        if (!fs.existsSync(path.join(configDir, "cache"))) {
-            fs.mkdirSync(path.join(configDir, "cache"), { recursive: true });
-        }
-        const lastCheck = fs.existsSync(checkFile)
-            ? parseInt(fs.readFileSync(checkFile, "utf8"), 10)
-            : 0;
-        const elapsed = Date.now() - lastCheck;
-        if (elapsed < updateInterval * 3_600_000) {
-            writeLog(`Skipping npm update for ${name} (checked ${Math.floor(elapsed / 60_000)} min ago)`);
-            return "";
-        }
-        fs.writeFileSync(checkFile, Date.now().toString());
-        execSync(`npm update -g ${name}`, { stdio: "pipe" });
-        writeLog(`Updated npm plugin: ${name}`);
-        return "";
-    }
-    catch (e) {
-        const msg = e.message;
-        writeLog(`Failed to update ${name}: ${msg}`, true);
-        return msg;
-    }
-}
-function selfUpdate(configDir) {
-    writeLog("Running self-update for plugin-updater");
-    updateNpmPlugin("plugin-updater", configDir);
-}
-function updatePlugin(pluginName, gitUrl, branch, commitHash, updateInterval = 1) {
-    const reposDir = getReposDir();
-    const targetDir = path.join(reposDir, pluginName);
-    const lastCheckFile = path.join(targetDir, ".lastcheck");
-    let didChange = false;
-    if (!fs.existsSync(targetDir)) {
-        if (!fs.existsSync(reposDir))
-            fs.mkdirSync(reposDir, { recursive: true });
-        const branchFlag = branch ? `--branch ${branch}` : "";
-        const cloned = executeGit(`git clone --recurse-submodules ${branchFlag} ${gitUrl} ${pluginName}`, reposDir);
-        if (!cloned)
-            return { success: false, changed: false };
-        fs.writeFileSync(lastCheckFile, Date.now().toString());
-        didChange = true;
-    }
-    else {
-        const lastCheck = fs.existsSync(lastCheckFile)
-            ? parseInt(fs.readFileSync(lastCheckFile, "utf8"), 10)
-            : 0;
-        const intervalMs = updateInterval * 3_600_000;
-        const elapsed = Date.now() - lastCheck;
-        if (elapsed < intervalMs) {
-            writeLog(`Fast-path: ${pluginName} skipping update check (checked ${Math.floor(elapsed / 60_000)} min ago, interval ${updateInterval}h)`);
-            return { success: true, changed: false };
-        }
-        fs.writeFileSync(lastCheckFile, Date.now().toString());
-        executeGit("git fetch origin", targetDir);
-        let beforeHash = "";
-        try {
-            beforeHash = execSync("git rev-parse HEAD", { cwd: targetDir }).toString().trim();
-        }
-        catch { /* ignore */ }
-        if (commitHash) {
-            executeGit(`git checkout ${commitHash}`, targetDir);
-        }
-        else if (branch) {
-            executeGit(`git checkout ${branch}`, targetDir);
-            executeGit(`git pull --ff-only origin ${branch}`, targetDir);
-        }
-        else {
-            // the updater owns repos/: hard-sync to the remote so force-pushed
-            // branches and rewritten submodule history cannot strand the clone
-            executeGit("git fetch origin", targetDir);
-            executeGit("git checkout main || git checkout master", targetDir);
-            executeGit("git reset --hard @{upstream}", targetDir);
-        }
-        executeGit("git submodule sync --recursive", targetDir);
-        const submodulesOk = executeGit("git submodule update --init --recursive --force", targetDir);
-        if (!submodulesOk) {
-            writeLog(`Submodule sync failed for ${pluginName}, recloning`, true);
-            try {
-                fs.rmSync(targetDir, { recursive: true, force: true });
-            }
-            catch { /* ignore */ }
-            const recloneBranchFlag = branch ? `--branch ${branch}` : "";
-            executeGit(`git clone --recurse-submodules ${recloneBranchFlag} ${gitUrl} ${pluginName}`, reposDir);
-            fs.writeFileSync(lastCheckFile, Date.now().toString());
-            didChange = true;
-        }
-        let afterHash = "";
-        try {
-            afterHash = execSync("git rev-parse HEAD", { cwd: targetDir }).toString().trim();
-        }
-        catch { /* ignore */ }
-        if (beforeHash !== afterHash)
-            didChange = true;
-    }
-    return { success: true, changed: didChange };
-}
-async function callPluginCleanup(pluginExecutionFile, configDir) {
-    if (!fs.existsSync(pluginExecutionFile))
-        return;
-    try {
-        const mod = await import(pluginExecutionFile);
-        if (typeof mod.cleanup === "function") {
-            writeLog(`Calling cleanup() on ${pluginExecutionFile}`);
-            await mod.cleanup(configDir);
-            writeLog(`cleanup() complete for ${pluginExecutionFile}`);
-        }
-    }
-    catch (e) {
-        writeLog(`cleanup() call failed for ${pluginExecutionFile}: ${e.message}`, true);
-    }
-}
-const BUILD_OUTPUT_DIRS = ["dist", path.join("core", "dist")];
-// npm install creates node_modules/.bin symlinks, which fail on filesystems
-// without symlink support (e.g. Windows-backed Docker bind mounts) — build in
-// the OS temp dir and copy the outputs back instead
-function buildInTempDir(pluginName, sourceDir) {
-    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), `plugin-updater-${pluginName}-`));
-    try {
-        fs.cpSync(sourceDir, tempDir, {
-            recursive: true,
-            filter: (src) => {
-                const name = path.basename(src);
-                return name !== ".git" && name !== "node_modules";
-            },
-        });
-        writeLog(`Running npm install for ${pluginName}`);
-        execSync("npm install", { cwd: tempDir, stdio: "pipe" });
-        writeLog(`Finished npm install for ${pluginName}`);
-        const pkg = JSON.parse(fs.readFileSync(path.join(tempDir, "package.json"), "utf8"));
-        if (pkg.scripts?.build) {
-            execSync("npm run build", { cwd: tempDir, stdio: "pipe" });
-            writeLog(`Finished npm run build for ${pluginName}`);
-        }
-        else {
-            writeLog(`Skipped npm run build for ${pluginName} (no build script found)`);
-        }
-        for (const outputDir of BUILD_OUTPUT_DIRS) {
-            const builtDir = path.join(tempDir, outputDir);
-            if (fs.existsSync(builtDir)) {
-                fs.cpSync(builtDir, path.join(sourceDir, outputDir), { recursive: true });
-            }
-        }
-    }
-    finally {
-        fs.rmSync(tempDir, { recursive: true, force: true });
-    }
-}
-async function deployToExecutionDir(pluginName, executionPath, changed, configDir) {
-    const sourceDir = path.join(getReposDir(), pluginName);
-    if (!fs.existsSync(sourceDir))
-        return false;
-    const packageJsonPath = path.join(sourceDir, "package.json");
-    let entryFile = "index.js";
-    const pluginExecutionFile = path.join(executionPath, `${pluginName}.js`);
-    if (!changed && fs.existsSync(pluginExecutionFile)) {
-        writeLog(`Skipping install/build for ${pluginName} (no changes and deployed file exists)`);
-    }
-    else {
-        if (fs.existsSync(packageJsonPath)) {
-            try {
-                buildInTempDir(pluginName, sourceDir);
-                const runtimeDeps = JSON.parse(fs.readFileSync(packageJsonPath, "utf8")).dependencies;
-                if (runtimeDeps && Object.keys(runtimeDeps).length > 0) {
-                    writeLog(`Installing runtime dependencies for ${pluginName}`);
-                    execSync("npm install --omit=dev", { cwd: sourceDir, stdio: "pipe" });
-                    writeLog(`Finished runtime dependencies for ${pluginName}`);
-                }
-            }
-            catch (error) {
-                const err = error;
-                const stderr = err.stderr ? err.stderr.toString().trim() : "";
-                const stdout = err.stdout ? err.stdout.toString().trim() : "";
-                writeLog(`Build/Install failed for ${pluginName}: ${err.message}`, true);
-                if (stderr)
-                    writeLog(`npm stderr: ${stderr}`, true);
-                if (stdout)
-                    writeLog(`npm stdout: ${stdout}`, true);
-            }
-        }
-    }
-    if (fs.existsSync(packageJsonPath)) {
-        try {
-            const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
-            if (pkg.main)
-                entryFile = pkg.main;
-        }
-        catch { /* ignore */ }
-    }
-    const distPath = path.join(sourceDir, "dist");
-    let deploySource = path.join(sourceDir, entryFile);
-    if (fs.existsSync(path.join(distPath, entryFile))) {
-        deploySource = path.join(distPath, entryFile);
-    }
-    else if (fs.existsSync(path.join(distPath, "index.js"))) {
-        deploySource = path.join(distPath, "index.js");
-    }
-    if (!fs.existsSync(executionPath))
-        fs.mkdirSync(executionPath, { recursive: true });
-    await callPluginCleanup(pluginExecutionFile, configDir);
-    try {
-        writeLog(`Running copy for ${pluginName}`);
-        fs.copyFileSync(deploySource, pluginExecutionFile);
-        writeLog(`Finished copy for ${pluginName}`);
-    }
-    catch (e) {
-        const err = e;
-        writeLog(`Copy failed for ${pluginName}: ${err.message}`, true);
-    }
-    applyClaudeManifest(sourceDir, configDir, pluginName);
-    await startDeclaredDaemon(sourceDir, configDir, pluginName);
-    // Claude Code never imports deployed plugin files, so under claude the
-    // updater is the runtime and invokes the plugin's activate() itself
-    if (getAppName() === "claude") {
-        try {
-            const deployed = await import(pluginExecutionFile);
-            if (typeof deployed.activate === "function") {
-                writeLog(`Activating ${pluginName}`);
-                // tells the plugin the updater is the caller, so it must not start
-                // another earlyLaunch and recurse back into the updater
-                process.env.PLUGIN_UPDATER_ACTIVATION = "1";
-                try {
-                    await deployed.activate();
-                }
-                finally {
-                    delete process.env.PLUGIN_UPDATER_ACTIVATION;
-                }
-                writeLog(`Activated ${pluginName}`);
-            }
-        }
-        catch (e) {
-            writeLog(`Activation failed for ${pluginName}: ${e.message}`, true);
-        }
-    }
-    return true;
-}
-function applyClaudeManifest(sourceDir, configDir, pluginName) {
-    if (getAppName() !== "claude")
-        return;
-    try {
-        const pkg = JSON.parse(fs.readFileSync(path.join(sourceDir, "package.json"), "utf8"));
-        const manifest = pkg.claudeHub;
-        if (!manifest)
-            return;
-        if (manifest.env && typeof manifest.env === "object") {
-            const settingsPath = path.join(configDir, "settings.json");
-            let settings = {};
-            try {
-                settings = JSON.parse(fs.readFileSync(settingsPath, "utf8"));
-            }
-            catch { /* fresh file */ }
-            const env = (settings.env ?? {});
-            for (const [key, value] of Object.entries(manifest.env)) {
-                env[key] = String(value);
-                writeLog(`settings.json env ${key} set by ${pluginName}`);
-            }
-            settings.env = env;
-            fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), "utf8");
-        }
-    }
-    catch (e) {
-        writeLog(`claudeHub manifest handling failed for ${pluginName}: ${e.message}`, true);
-    }
-}
-async function isDaemonHealthy(url) {
-    try {
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), 1500);
-        const res = await fetch(url, { signal: controller.signal });
-        clearTimeout(timer);
-        return res.ok;
-    }
-    catch {
-        return false;
-    }
-}
-// idempotent: health-check the declared endpoint, spawn detached only if down.
-// the daemon outlives this process so the proxy persists across the session.
-async function startDeclaredDaemon(sourceDir, configDir, pluginName) {
-    try {
-        const pkg = JSON.parse(fs.readFileSync(path.join(sourceDir, "package.json"), "utf8"));
-        const daemon = pkg.claudeHub?.daemon;
-        if (!daemon?.script)
-            return;
-        const healthUrl = daemon.healthCheckUrl
-            || (daemon.port ? `http://127.0.0.1:${daemon.port}/health` : "");
-        if (healthUrl && (await isDaemonHealthy(healthUrl))) {
-            writeLog(`Daemon for ${pluginName} already running`);
-            return;
-        }
-        const scriptPath = path.join(sourceDir, daemon.script);
-        if (!fs.existsSync(scriptPath)) {
-            writeLog(`Daemon script missing for ${pluginName}: ${scriptPath}`, true);
-            return;
-        }
-        const runtime = daemon.runtime || "node";
-        const { spawn } = await import("child_process");
-        const child = spawn(runtime, [scriptPath], {
-            cwd: sourceDir,
-            detached: true,
-            stdio: "ignore",
-            env: {
-                ...process.env,
-                HUB_CONFIG_DIR: configDir,
-                HUB_APP_NAME: getAppName() === "claude" ? "Claude Code" : "OpenCode",
-                ...(daemon.port ? { HUB_PROXY_PORT: String(daemon.port) } : {}),
-            },
-        });
-        child.unref();
-        writeLog(`Started daemon for ${pluginName} (${runtime} ${daemon.script})`);
-    }
-    catch (e) {
-        writeLog(`Daemon start failed for ${pluginName}: ${e.message}`, true);
-    }
-}
-async function pluginUpdaterEntry(input) {
-    const appName = getAppName();
-    const configDir = getAppConfigDir(appName);
-    const pluginsDir = path.join(configDir, "plugin");
-    writeLog(`Starting plugin updater for ${appName}`);
-    if (input?.action === "updatePlugin" && input.configDir && input.pluginName && input.gitUrl) {
-        EARLY_LAUNCH_CONFIG_DIR = input.configDir;
-        writeLog(`Direct update request for ${input.pluginName}`);
-        const updateResult = updatePlugin(input.pluginName, input.gitUrl, input.branch, input.commitHash ?? null);
-        await deployToExecutionDir(input.pluginName, pluginsDir, updateResult.changed, input.configDir);
-    }
-}
+// re-exported public API (consumers import these from "plugin-updater")
+export { getNpmPlugins, installNpmPlugin, uninstallNpmPlugin, updateNpmPlugin } from "./npm.js";
+export { getPlugins, getPluginsPath } from "./config.js";
 export async function updatePluginPublic(pluginName, gitUrl, branch, commitHash) {
     if (isOpencodeHookInvocation(pluginName))
         return {};
@@ -547,11 +22,10 @@ export async function updatePluginPublic(pluginName, gitUrl, branch, commitHash)
 export async function earlyLaunch(configDir, plugins) {
     if (isOpencodeHookInvocation(configDir))
         return {};
-    EARLY_LAUNCH_CONFIG_DIR = configDir;
+    setEarlyLaunchConfigDir(configDir);
     writeLog("Starting earlyLaunch updater sequence");
-    // Self-update first
     selfUpdate(configDir);
-    // Update npm plugins listed in opencode.json
+    // npm plugins listed in opencode.json
     const { plugins: npmNames } = readOpencodeJson(configDir);
     for (const raw of npmNames) {
         const name = raw.replace(/@[^@/]+$/, "") || raw;
@@ -565,7 +39,6 @@ export async function earlyLaunch(configDir, plugins) {
             writeLog(`Failed npm update for ${name}: ${e.message}`, true);
         }
     }
-    // Git plugins
     if (!plugins || !Array.isArray(plugins)) {
         writeLog("No git plugins provided to earlyLaunch", true);
         return;
@@ -594,37 +67,10 @@ export async function earlyLaunch(configDir, plugins) {
             await deployToExecutionDir(plugin.name, path.join(configDir, "plugin"), updateResult.changed, configDir);
         }
         catch (e) {
-            const err = e;
-            writeLog(`Failed to process ${plugin.name}: ${err.message}`, true);
+            writeLog(`Failed to process ${plugin.name}: ${e.message}`, true);
         }
     }
 }
-export function getPluginsPath(configDir) {
-    if (isOpencodeHookInvocation(configDir))
-        return "";
-    const preferred = path.join(configDir, "config", "plugins.json");
-    const fallback = path.join(configDir, "plugins.json");
-    if (fs.existsSync(preferred))
-        return preferred;
-    if (fs.existsSync(fallback))
-        return fallback;
-    return preferred;
-}
-// single source of truth for the git-plugin list; consumers (loaders, TUI)
-// must read through this rather than touching plugins.json directly
-export function getPlugins(configDir) {
-    if (isOpencodeHookInvocation(configDir))
-        return [];
-    const file = getPluginsPath(configDir);
-    try {
-        if (fs.existsSync(file))
-            return JSON.parse(fs.readFileSync(file, "utf-8"));
-    }
-    catch (e) {
-        writeLog(`Failed to parse ${file}: ${e.message}`, true);
-    }
-    return [];
-}
 export async function activate(opencodeHookInput) {
     // module load below calls activate() with no argument; opencode passes a
     // context object when re-invoking the export — return an inert plugin instance

package/dist/log.d.ts

@@ -0,0 +1,2 @@
+export declare function getPluginConfig(): Record<string, unknown>;
+export declare function writeLog(message: string, isError?: boolean): void;

package/dist/log.js

@@ -0,0 +1,43 @@
+import fs from "fs";
+import path from "path";
+import { getAppConfigDir, getAppName } from "./env.js";
+const START_TIME = new Date().toISOString().replace(/:/g, "-").split(".")[0];
+let pluginConfig = null;
+export function getPluginConfig() {
+    if (pluginConfig !== null)
+        return pluginConfig;
+    try {
+        const configDir = getAppConfigDir(getAppName());
+        const preferred = path.join(configDir, "config", "plugin-updater.json");
+        const fallback = path.join(configDir, "plugin-updater.json");
+        const p = fs.existsSync(preferred) ? preferred : fs.existsSync(fallback) ? fallback : null;
+        pluginConfig = p ? JSON.parse(fs.readFileSync(p, "utf8")) : {};
+    }
+    catch {
+        pluginConfig = {};
+    }
+    return pluginConfig ?? {};
+}
+export function writeLog(message, isError = false) {
+    const loggingEnabled = getPluginConfig().logging !== false;
+    try {
+        if (loggingEnabled) {
+            const date = new Date();
+            const dateStr = date.toISOString().split("T")[0];
+            const configDir = getAppConfigDir(getAppName());
+            const logsDir = path.join(configDir, "logs", dateStr);
+            if (!fs.existsSync(logsDir))
+                fs.mkdirSync(logsDir, { recursive: true });
+            const logFile = path.join(logsDir, `plugin-updater-${START_TIME}.log`);
+            const prefix = isError ? "[ERROR]" : "[INFO]";
+            fs.appendFileSync(logFile, `[${date.toISOString()}] ${prefix} ${message}\n`);
+        }
+    }
+    catch { /* never crash on log failure */ }
+    if (process.env.PLUGIN_UPDATER_LIBRARY_MODE === "1" && process.env.PLUGIN_UPDATER_CLI !== "1")
+        return;
+    if (isError)
+        console.error(message);
+    else if (loggingEnabled)
+        console.log(message);
+}

package/dist/npm.d.ts

@@ -0,0 +1,8 @@
+import type { NpmPlugin } from "./types.js";
+export declare function getNpmGlobalRoot(): string;
+export declare function resolveNpmPluginVersion(name: string, configDir: string): string;
+export declare function getNpmPlugins(configDir: string): NpmPlugin[];
+export declare function installNpmPlugin(name: string, configDir: string): string;
+export declare function uninstallNpmPlugin(name: string, configDir: string): string;
+export declare function updateNpmPlugin(name: string, configDir: string, updateInterval?: number): string;
+export declare function selfUpdate(configDir: string): void;

package/dist/npm.js

@@ -0,0 +1,137 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { execSync } from "child_process";
+import { isOpencodeHookInvocation } from "./env.js";
+import { writeLog } from "./log.js";
+import { readOpencodeJson, writeOpencodeJson } from "./config.js";
+let npmGlobalRoot = null;
+export function getNpmGlobalRoot() {
+    if (npmGlobalRoot !== null)
+        return npmGlobalRoot;
+    try {
+        npmGlobalRoot = execSync("npm root -g", { stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
+    }
+    catch {
+        npmGlobalRoot = "";
+    }
+    return npmGlobalRoot;
+}
+export function resolveNpmPluginVersion(name, configDir) {
+    try {
+        // opencode installs npm plugins into ~/.cache/opencode/packages/<name>@<spec>/
+        const packageCache = path.join(os.homedir(), ".cache", "opencode", "packages");
+        if (fs.existsSync(packageCache)) {
+            for (const entry of fs.readdirSync(packageCache)) {
+                if (entry !== name && !entry.startsWith(`${name}@`))
+                    continue;
+                const cachedPkg = path.join(packageCache, entry, "node_modules", name, "package.json");
+                if (fs.existsSync(cachedPkg)) {
+                    return JSON.parse(fs.readFileSync(cachedPkg, "utf8")).version || "";
+                }
+            }
+        }
+        const cacheDir = path.join(configDir, "cache", "node_modules");
+        const globalNpm = getNpmGlobalRoot();
+        const candidates = [
+            path.join(cacheDir, name, "package.json"),
+            path.join(configDir, "node_modules", name, "package.json"),
+            globalNpm ? path.join(globalNpm, name, "package.json") : "",
+        ].filter((p) => p !== "");
+        for (const p of candidates) {
+            if (fs.existsSync(p)) {
+                return JSON.parse(fs.readFileSync(p, "utf8")).version || "";
+            }
+        }
+        try {
+            const resolved = require.resolve(path.join(name, "package.json"));
+            return JSON.parse(fs.readFileSync(resolved, "utf8")).version || "";
+        }
+        catch { /* not resolvable */ }
+    }
+    catch { /* ignore */ }
+    return "";
+}
+export function getNpmPlugins(configDir) {
+    if (isOpencodeHookInvocation(configDir))
+        return [];
+    const { plugins } = readOpencodeJson(configDir);
+    return plugins.map((raw) => {
+        const name = raw.replace(/@[^@/]+$/, "") || raw;
+        const version = resolveNpmPluginVersion(name, configDir);
+        return { name, version, installed: version !== "", raw };
+    });
+}
+export function installNpmPlugin(name, configDir) {
+    if (isOpencodeHookInvocation(name))
+        return "";
+    writeLog(`Installing npm plugin: ${name}`);
+    try {
+        const { plugins, raw } = readOpencodeJson(configDir);
+        if (!plugins.includes(name)) {
+            raw.plugin = [...plugins, name];
+            writeOpencodeJson(configDir, raw);
+        }
+        execSync(`npm install -g ${name}`, { stdio: "pipe" });
+        writeLog(`Installed npm plugin: ${name}`);
+        return "";
+    }
+    catch (e) {
+        const msg = e.message;
+        writeLog(`Failed to install ${name}: ${msg}`, true);
+        return msg;
+    }
+}
+export function uninstallNpmPlugin(name, configDir) {
+    if (isOpencodeHookInvocation(name))
+        return "";
+    writeLog(`Uninstalling npm plugin: ${name}`);
+    try {
+        const { plugins, raw } = readOpencodeJson(configDir);
+        raw.plugin = plugins.filter((p) => {
+            const pName = p.replace(/@[^@/]+$/, "") || p;
+            return pName !== name;
+        });
+        writeOpencodeJson(configDir, raw);
+        execSync(`npm uninstall -g ${name}`, { stdio: "pipe" });
+        writeLog(`Uninstalled npm plugin: ${name}`);
+        return "";
+    }
+    catch (e) {
+        const msg = e.message;
+        writeLog(`Failed to uninstall ${name}: ${msg}`, true);
+        return msg;
+    }
+}
+export function updateNpmPlugin(name, configDir, updateInterval = 1) {
+    if (isOpencodeHookInvocation(name))
+        return "";
+    writeLog(`Updating npm plugin: ${name}`);
+    const checkFile = path.join(configDir, "cache", `.npm-lastcheck-${name.replace(/[^a-z0-9]/gi, "_")}`);
+    try {
+        if (!fs.existsSync(path.join(configDir, "cache"))) {
+            fs.mkdirSync(path.join(configDir, "cache"), { recursive: true });
+        }
+        const lastCheck = fs.existsSync(checkFile)
+            ? parseInt(fs.readFileSync(checkFile, "utf8"), 10)
+            : 0;
+        const elapsed = Date.now() - lastCheck;
+        if (elapsed < updateInterval * 3_600_000) {
+            writeLog(`Skipping npm update for ${name} (checked ${Math.floor(elapsed / 60_000)} min ago)`);
+            return "";
+        }
+        fs.writeFileSync(checkFile, Date.now().toString());
+        execSync(`npm update -g ${name}`, { stdio: "pipe" });
+        writeLog(`Updated npm plugin: ${name}`);
+        return "";
+    }
+    catch (e) {
+        const msg = e.message;
+        writeLog(`Failed to update ${name}: ${msg}`, true);
+        return msg;
+    }
+}
+export function selfUpdate(configDir) {
+    writeLog("Running self-update for plugin-updater");
+    updateNpmPlugin("plugin-updater", configDir);
+}

package/dist/types.d.ts

@@ -0,0 +1,20 @@
+export interface Plugin {
+    name: string;
+    url?: string;
+    branch?: string;
+    enabled?: boolean;
+    autoUpdate?: boolean;
+    updateInterval?: number;
+}
+export interface NpmPlugin {
+    name: string;
+    version: string;
+    installed: boolean;
+    raw: string;
+}
+export interface DaemonManifest {
+    script: string;
+    runtime?: string;
+    port?: number;
+    healthCheckUrl?: string;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plugin-updater",
-  "version": "1.0.38",
+  "version": "1.0.39",
   "description": "Plugin lifecycle manager for OpenCode and Claude Code launchers",
   "type": "module",
   "main": "dist/index.js",