plugin-updater 1.0.24 → 1.0.26

package/dist/index.d.ts

@@ -16,7 +16,7 @@ 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 updatePluginPublic(pluginName: string, gitUrl: string, branch?: string, commitHash?: string): Promise<void>;
-export declare function earlyLaunch(configDir: string, plugins: Plugin[]): Promise<void>;
-export declare function activate(): Promise<void>;
+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 activate(opencodeHookInput?: unknown): Promise<void | object>;
 export {};

package/dist/index.js

@@ -120,7 +120,15 @@ function writeOpencodeJson(configDir, data) {
     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;
@@ -129,6 +137,8 @@ export function getNpmPlugins(configDir) {
     });
 }
 export function installNpmPlugin(name, configDir) {
+    if (isOpencodeHookInvocation(name))
+        return "";
     writeLog(`Installing npm plugin: ${name}`);
     try {
         const { plugins, raw } = readOpencodeJson(configDir);
@@ -147,6 +157,8 @@ export function installNpmPlugin(name, configDir) {
     }
 }
 export function uninstallNpmPlugin(name, configDir) {
+    if (isOpencodeHookInvocation(name))
+        return "";
     writeLog(`Uninstalling npm plugin: ${name}`);
     try {
         const { plugins, raw } = readOpencodeJson(configDir);
@@ -166,6 +178,8 @@ export function uninstallNpmPlugin(name, configDir) {
     }
 }
 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 {
@@ -262,6 +276,42 @@ async function callPluginCleanup(pluginExecutionFile, configDir) {
         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))
@@ -275,23 +325,17 @@ async function deployToExecutionDir(pluginName, executionPath, changed, configDi
     else {
         if (fs.existsSync(packageJsonPath)) {
             try {
-                writeLog(`Running npm install for ${pluginName}`);
-                execSync("npm install", { cwd: sourceDir, stdio: "ignore" });
-                writeLog(`Finished npm install for ${pluginName}`);
-                const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
-                if (pkg.main)
-                    entryFile = pkg.main;
-                if (pkg.scripts?.build) {
-                    execSync("npm run build", { cwd: sourceDir, stdio: "ignore" });
-                    writeLog(`Finished npm run build for ${pluginName}`);
-                }
-                else {
-                    writeLog(`Skipped npm run build for ${pluginName} (no build script found)`);
-                }
+                buildInTempDir(pluginName, sourceDir);
             }
             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);
             }
         }
     }
@@ -339,6 +383,8 @@ async function pluginUpdaterEntry(input) {
     }
 }
 export async function updatePluginPublic(pluginName, gitUrl, branch, commitHash) {
+    if (isOpencodeHookInvocation(pluginName))
+        return {};
     writeLog(`Public API update call for ${pluginName}`);
     const appName = process.argv.join(" ").includes("claude") ? "claude" : "opencode";
     const configDir = getAppConfigDir(appName);
@@ -346,6 +392,8 @@ export async function updatePluginPublic(pluginName, gitUrl, branch, commitHash)
     await deployToExecutionDir(pluginName, path.join(configDir, "plugin"), result.changed, configDir);
 }
 export async function earlyLaunch(configDir, plugins) {
+    if (isOpencodeHookInvocation(configDir))
+        return {};
     EARLY_LAUNCH_CONFIG_DIR = configDir;
     writeLog("Starting earlyLaunch updater sequence");
     // Self-update first
@@ -387,7 +435,11 @@ export async function earlyLaunch(configDir, plugins) {
         }
     }
 }
-export async function activate() {
+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
+    if (opencodeHookInput !== undefined)
+        return {};
     const isClaude = process.argv.join(" ").includes("claude");
     const appName = isClaude ? "claude" : "opencode";
     const configDir = getAppConfigDir(appName);

package/package.json

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