plugin-updater 1.0.19 → 1.0.22

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+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;
+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 {};

package/dist/index.js

@@ -0,0 +1,390 @@
+import fs from "fs";
+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];
+function getPluginConfig() {
+    if (PLUGIN_CONFIG !== null)
+        return PLUGIN_CONFIG;
+    try {
+        const isClaude = process.argv.join(" ").includes("claude");
+        const appName = isClaude ? "claude" : "opencode";
+        const configDir = getAppConfigDir(appName);
+        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 isClaude = process.argv.join(" ").includes("claude");
+            const appName = isClaude ? "claude" : "opencode";
+            const configDir = getAppConfigDir(appName);
+            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 (isError)
+        console.error(message);
+    else if (loggingEnabled)
+        console.log(message);
+}
+function getReposDir() {
+    const isClaude = process.argv.join(" ").includes("claude");
+    const appName = isClaude ? "claude" : "opencode";
+    return path.join(getAppConfigDir(appName), "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 resolveNpmPluginVersion(name, configDir) {
+    try {
+        const cacheDir = path.join(configDir, "cache", "node_modules");
+        const globalNpm = process.platform === "win32"
+            ? path.join(os.homedir(), "AppData", "Roaming", "npm", "node_modules")
+            : path.join("/usr", "lib", "node_modules");
+        const candidates = [
+            path.join(cacheDir, name, "package.json"),
+            path.join(configDir, "node_modules", name, "package.json"),
+            path.join(globalNpm, name, "package.json"),
+        ];
+        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 ────────────────────────────────────────────────────────────────
+export function getNpmPlugins(configDir) {
+    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) {
+    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) {
+    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) {
+    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}` : "";
+        executeGit(`git clone --recurse-submodules ${branchFlag} ${gitUrl} ${pluginName}`, reposDir);
+        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 {
+            executeGit("git checkout main || git checkout master", targetDir);
+            executeGit("git pull --ff-only", targetDir);
+        }
+        executeGit("git submodule update --init --recursive", targetDir);
+        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);
+    }
+}
+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 {
+                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)`);
+                }
+            }
+            catch (error) {
+                const err = error;
+                writeLog(`Build/Install failed for ${pluginName}: ${err.message}`, 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);
+    }
+    return true;
+}
+async function pluginUpdaterEntry(input) {
+    const isClaude = process.argv.join(" ").includes("claude");
+    const appName = isClaude ? "claude" : "opencode";
+    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);
+    }
+}
+export async function updatePluginPublic(pluginName, gitUrl, branch, commitHash) {
+    writeLog(`Public API update call for ${pluginName}`);
+    const appName = process.argv.join(" ").includes("claude") ? "claude" : "opencode";
+    const configDir = getAppConfigDir(appName);
+    const result = updatePlugin(pluginName, gitUrl, branch, commitHash ?? null);
+    await deployToExecutionDir(pluginName, path.join(configDir, "plugin"), result.changed, configDir);
+}
+export async function earlyLaunch(configDir, plugins) {
+    EARLY_LAUNCH_CONFIG_DIR = configDir;
+    writeLog("Starting earlyLaunch updater sequence");
+    // Self-update first
+    selfUpdate(configDir);
+    // Update npm plugins listed in opencode.json
+    const { plugins: npmNames } = readOpencodeJson(configDir);
+    for (const raw of npmNames) {
+        const name = raw.replace(/@[^@/]+$/, "") || raw;
+        if (name === "plugin-updater")
+            continue; // already self-updated above
+        writeLog(`npm earlyLaunch update for ${name}`);
+        try {
+            updateNpmPlugin(name, configDir);
+        }
+        catch (e) {
+            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;
+    }
+    for (const plugin of plugins) {
+        if (!plugin.enabled)
+            continue;
+        if (plugin.autoUpdate === false)
+            continue;
+        if (!plugin.url)
+            continue;
+        writeLog(`Processing earlyLaunch for ${plugin.name}`);
+        try {
+            const updateResult = updatePlugin(plugin.name, plugin.url, plugin.branch, null, plugin.updateInterval ?? 1);
+            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);
+        }
+    }
+}
+pluginUpdaterEntry(null);

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "plugin-updater",
-  "version": "1.0.19",
+  "version": "1.0.22",
   "description": "Plugin lifecycle manager for OpenCode and Claude Code launchers",
   "type": "module",
-  "main": "index.js",
+  "main": "dist/index.js",
   "license": "MIT",
   "author": "intisy",
   "repository": {
@@ -16,5 +16,21 @@
     "plugin",
     "updater",
     "lifecycle"
-  ]
+  ],
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.0.0"
+  }
 }

package/.github/workflows/publish.yml

@@ -1,29 +0,0 @@
-name: Publish to npm
-
-on:
-  push:
-    tags:
-      - 'v*'
-
-permissions:
-  id-token: write
-  contents: read
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/setup-node@v4
-        with:
-          node-version: '24'
-          registry-url: 'https://registry.npmjs.org'
-
-      - name: Set version from tag
-        run: |
-          VERSION="${{ github.ref_name }}"
-          VERSION="${VERSION#v}"
-          npm version $VERSION --allow-same-version --no-git-tag-version
-
-      - run: npm publish --provenance --access public

package/.idea/misc.xml

@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="KubernetesApiProvider"><![CDATA[{}]]></component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_25" default="true" project-jdk-name="25" project-jdk-type="JavaSDK">
-    <output url="file://$PROJECT_DIR$/out" />
-  </component>
-</project>

package/.idea/modules.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/plugin-updater.iml" filepath="$PROJECT_DIR$/.idea/plugin-updater.iml" />
-    </modules>
-  </component>
-</project>

package/.idea/plugin-updater.iml

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="JAVA_MODULE" version="4">
-  <component name="NewModuleRootManager" inherit-compiler-output="true">
-    <exclude-output />
-    <content url="file://$MODULE_DIR$" />
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-</module>

package/.idea/vcs.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="" vcs="Git" />
-  </component>
-</project>

package/SPEC.md

@@ -1,13 +0,0 @@
-# Plugin Updater - Specifications & Test Requirements
-
-## Goal
-Reliable core update mechanism for all OpenCode and Claude Code plugins.
-
-## Requirements
-- [ ] **Installation Order**: Must be installed FIRST in OpenCode, as it is responsible for installing all other plugins.
-- [ ] **Reliability**: Must never fail or crash, as the entire ecosystem depends on it.
-- [ ] **Launch Detection (Early Launch)**: 
-  - The updater exports an `earlyLaunch(configDir)` function. 
-  - Hub plugins (opencode-hub / claude-hub) MUST detect the updater and call `earlyLaunch` before OpenCode invokes it, deferring update flow management to the Hub.
-  - If launched directly via the normal application command (no hub / optional dependency), the updater executes its update routine automatically and MUST NOT install the Hub, as the Hub is strictly optional.
-  - Path resolution relies on the `configDir` passed by `earlyLaunch` or inferred from `process.argv`/input, NEVER relying on static environment variables like `CC_LAUNCHER`.

package/index.js

@@ -1,227 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-import { execSync } from 'child_process';
-
-let EARLY_LAUNCH_CONFIG_DIR = null;
-const START_TIME = new Date().toISOString().replace(/:/g, '-').split('.')[0];
-
-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) {
-  try {
-    const date = new Date();
-    const dateStr = date.toISOString().split('T')[0];
-    const isClaude = process.argv.join(' ').includes('claude');
-    const appName = isClaude ? "claude" : "opencode";
-    const configDir = getAppConfigDir(appName);
-
-    const logsDir = path.join(configDir, "logs", dateStr);
-    if (!fs.existsSync(logsDir)) {
-      fs.mkdirSync(logsDir, { recursive: true });
-    }
-
-    const logFile = path.join(logsDir, `updater-${START_TIME}.log`);
-    const prefix = isError ? "[ERROR]" : "[INFO]";
-    const logMsg = `[${date.toISOString()}] ${prefix} ${message}\n`;
-
-    fs.appendFileSync(logFile, logMsg);
-  } catch (e) {
-  }
-  if (isError) console.error(message);
-  else console.log(message);
-}
-
-function getReposDir() {
-  const isClaude = process.argv.join(' ').includes('claude');
-  const appName = isClaude ? "claude" : "opencode";
-  return path.join(getAppConfigDir(appName), "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 stderr = error.stderr ? error.stderr.toString().trim() : '';
-    writeLog(`Git error in ${cwd}: ${error.message} | stderr: ${stderr}`, true);
-    return false;
-  }
-}
-
-function updatePlugin(pluginName, gitUrl, branch, commitHash) {
-  const reposDir = getReposDir();
-  const targetDir = path.join(reposDir, pluginName);
-
-  if (!fs.existsSync(targetDir)) {
-    if (!fs.existsSync(reposDir)) fs.mkdirSync(reposDir, { recursive: true });
-    const branchFlag = branch ? `--branch ${branch}` : "";
-    executeGit(`git clone --recurse-submodules ${branchFlag} ${gitUrl} ${pluginName}`, reposDir);
-  } else {
-    executeGit("git fetch origin", targetDir);
-    if (commitHash) {
-      executeGit(`git checkout ${commitHash}`, targetDir);
-    } else if (branch) {
-      executeGit(`git checkout ${branch}`, targetDir);
-      executeGit(`git pull --ff-only origin ${branch}`, targetDir);
-    } else {
-      executeGit("git checkout main || git checkout master", targetDir);
-      executeGit("git pull --ff-only", targetDir);
-    }
-    executeGit("git submodule update --init --recursive", targetDir);
-  }
-  return true;
-}
-
-function deployToExecutionDir(pluginName, executionPath) {
-  const sourceDir = path.join(getReposDir(), pluginName);
-  if (!fs.existsSync(sourceDir)) return false;
-
-  const packageJsonPath = path.join(sourceDir, "package.json");
-  let entryFile = "index.js";
-
-  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 && 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)`);
-      }
-    } catch (error) {
-      writeLog(`Build/Install failed for ${pluginName}: ${error.message}`, true);
-    }
-  }
-
-  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");
-  }
-
-  const pluginExecutionFile = path.join(executionPath, `${pluginName}.js`);
-
-  if (!fs.existsSync(executionPath)) {
-    fs.mkdirSync(executionPath, { recursive: true });
-  }
-
-  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);
-  }
-  return true;
-}
-
-async function pluginUpdaterEntry(input) {
-  const isClaude = process.argv.join(' ').includes('claude');
-  const configDir = getAppConfigDir(isClaude ? "claude" : "opencode");
-
-  const reposDir = path.join(configDir, "repos");
-  const pluginsDir = path.join(configDir, "plugin");
-  if (!fs.existsSync(reposDir)) fs.mkdirSync(reposDir, { recursive: true });
-  if (!fs.existsSync(pluginsDir)) fs.mkdirSync(pluginsDir, { recursive: true });
-
-  writeLog(`plugin-updater activated. configDir=${configDir}`);
-
-  if (!global.__PLUGIN_UPDATER_HANDLED_BY_HUB__) {
-    EARLY_LAUNCH_CONFIG_DIR = configDir;
-    global.__PLUGIN_UPDATER_HANDLED_BY_HUB__ = true;
-
-    const pluginsJsonPath = path.join(configDir, "config", "plugins.json");
-    if (fs.existsSync(pluginsJsonPath)) {
-      try {
-        const plugins = JSON.parse(fs.readFileSync(pluginsJsonPath, "utf-8"));
-        for (const plugin of plugins) {
-          if (plugin.url && plugin.enabled !== false && plugin.type !== "npm") {
-            const branch = plugin.branch || null;
-            const commit = plugin.commit || null;
-            updatePlugin(plugin.name, plugin.url, branch, commit);
-            deployToExecutionDir(plugin.name, pluginsDir);
-          }
-        }
-      } catch (e) {
-        writeLog(`Failed to parse plugins.json: ${e.message}`, true);
-      }
-    }
-  }
-
-  return {};
-}
-
-pluginUpdaterEntry.earlyLaunch = function(configDir) {
-  EARLY_LAUNCH_CONFIG_DIR = configDir;
-  global.__PLUGIN_UPDATER_HANDLED_BY_HUB__ = true;
-};
-pluginUpdaterEntry.updatePlugin = updatePlugin;
-pluginUpdaterEntry.deployToExecutionDir = deployToExecutionDir;
-pluginUpdaterEntry.rebuild = function(pluginName) {
-  const isClaude = process.argv.join(' ').includes('claude');
-  const configDir = getAppConfigDir(isClaude ? "claude" : "opencode");
-  deployToExecutionDir(pluginName, path.join(configDir, "plugin"));
-  return "Rebuilt " + pluginName;
-};
-pluginUpdaterEntry.downgrade = function(pluginName, commitHash) {
-  const reposDir = getReposDir();
-  const targetDir = path.join(reposDir, pluginName);
-  if (fs.existsSync(targetDir)) {
-    executeGit(`git fetch origin`, targetDir);
-    executeGit(`git checkout ${commitHash}`, targetDir);
-    executeGit(`git submodule update --init --recursive`, targetDir);
-    return pluginUpdaterEntry.rebuild(pluginName);
-  }
-  return "Repo not found";
-};
-pluginUpdaterEntry.disable = function(plugin) {
-  const isClaude = process.argv.join(' ').includes('claude');
-  const configDir = getAppConfigDir(isClaude ? "claude" : "opencode");
-  const pluginsJsonPath = path.join(configDir, "config", "plugins.json");
-  if (fs.existsSync(pluginsJsonPath)) {
-    let plugins = JSON.parse(fs.readFileSync(pluginsJsonPath, "utf-8"));
-    const pluginIndex = plugins.findIndex(p => p.name === plugin.name);
-    if (pluginIndex >= 0) {
-      plugins[pluginIndex].enabled = false;
-      fs.writeFileSync(pluginsJsonPath, JSON.stringify(plugins, null, 2), "utf-8");
-    }
-  }
-  const pluginExecutionPath = path.join(configDir, "plugin", `${plugin.name}.js`);
-  if (fs.existsSync(pluginExecutionPath)) {
-    try { fs.rmSync(pluginExecutionPath, { force: true }); } catch (e) {}
-  }
-};
-pluginUpdaterEntry.uninstall = function(plugin) {
-  pluginUpdaterEntry.disable(plugin);
-  const targetDir = path.join(getReposDir(), plugin.name);
-  if (fs.existsSync(targetDir)) {
-    try { fs.rmSync(targetDir, { recursive: true, force: true }); } catch (e) {}
-  }
-};
-
-export default pluginUpdaterEntry;