plugin-updater 1.0.0 → 1.0.9

package/.github/workflows/publish.yml

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,7 @@
+<?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

@@ -0,0 +1,8 @@
+<?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

@@ -0,0 +1,9 @@
+<?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

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

package/SPEC.md

@@ -0,0 +1,13 @@
+# 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,32 +1,78 @@
 const fs = require('fs');
 const path = require('path');
+const os = require('os');
 const { execSync } = require('child_process');
 
-const REPOS_DIR = path.join(require('os').homedir(), '.config', 'github');
+let EARLY_LAUNCH_CONFIG_DIR = null;
 
-function executeGit(cmd, dir) {
+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 {
-    return execSync(cmd, { cwd: dir, timeout: 60000, stdio: "ignore" });
+    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-${dateStr}.log`);
+    const prefix = isError ? "[ERROR]" : "[INFO]";
+    const logMsg = `[${date.toISOString()}] ${prefix} ${message}\n`;
+    
+    fs.appendFileSync(logFile, logMsg);
   } catch (e) {
-    console.error(`[Updater] Git command failed: ${cmd} in ${dir}`);
+    // Silent fallback if logging fails
+  }
+  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: "ignore" });
+    return true;
+  } catch (error) {
+    writeLog(`Git error in ${cwd}: ${error.message}`, true);
     return false;
   }
 }
 
-module.exports = {
+const updaterAPI = {
   name: "plugin-updater",
 
-  /**
-   * Called by the launcher (OpenCode/Claude Code) to sync a specific plugin
-   */
+  earlyLaunch: function(configDir) {
+    EARLY_LAUNCH_CONFIG_DIR = configDir;
+    global.__PLUGIN_UPDATER_HANDLED_BY_HUB__ = true;
+  },
+
   updatePlugin: function(pluginName, gitUrl, branch = null, commitHash = null) {
-    const targetDir = path.join(REPOS_DIR, pluginName);
+    const reposDir = getReposDir();
+    const targetDir = path.join(reposDir, pluginName);
     
-    // 1. Ensure directory exists and clone or pull
     if (!fs.existsSync(targetDir)) {
-      if (!fs.existsSync(REPOS_DIR)) fs.mkdirSync(REPOS_DIR, { recursive: true });
+      if (!fs.existsSync(reposDir)) fs.mkdirSync(reposDir, { recursive: true });
       const branchFlag = branch ? `--branch ${branch}` : "";
-      executeGit(`git clone --recurse-submodules ${branchFlag} ${gitUrl} ${pluginName}`, REPOS_DIR);
+      executeGit(`git clone --recurse-submodules ${branchFlag} ${gitUrl} ${pluginName}`, reposDir);
     } else {
       executeGit("git fetch origin", targetDir);
       if (commitHash) {
@@ -40,53 +86,134 @@ module.exports = {
       }
       executeGit("git submodule update --init --recursive", targetDir);
     }
-
     return true;
   },
 
-  /**
-   * Called to deploy the compiled output to the execution directory
-   */
   deployToExecutionDir: function(pluginName, executionPath) {
-    const sourceDir = path.join(REPOS_DIR, pluginName);
+    const sourceDir = path.join(getReposDir(), pluginName);
     if (!fs.existsSync(sourceDir)) return false;
 
-    // Build if package.json exists
-    if (fs.existsSync(path.join(sourceDir, "package.json"))) {
+    const packageJsonPath = path.join(sourceDir, "package.json");
+    if (fs.existsSync(packageJsonPath)) {
       try {
+        writeLog(`Running npm install for ${pluginName}`);
         execSync("npm install", { cwd: sourceDir, stdio: "ignore" });
-        execSync("npm run build", { cwd: sourceDir, stdio: "ignore" });
-      } catch (e) {
-        // Fallback or ignore if no build step
+        writeLog(`Finished npm install for ${pluginName}`);
+        
+        // Safely check if a build script exists before executing
+        const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        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);
       }
     }
 
-    // Determine deployment source (prefer dist, fallback to root)
     const distPath = path.join(sourceDir, "dist");
     const deploySource = fs.existsSync(distPath) ? distPath : sourceDir;
+    const pluginExecutionPath = path.join(executionPath, pluginName);
 
-    // Copy to execution path
-    if (!fs.existsSync(executionPath)) {
-      fs.mkdirSync(executionPath, { recursive: true });
+    if (!fs.existsSync(pluginExecutionPath)) {
+      fs.mkdirSync(pluginExecutionPath, { recursive: true });
     }
 
     try {
-      // Platform agnostic copy (using Node fs)
-      fs.cpSync(deploySource, executionPath, { recursive: true, force: true });
-      return true;
+      writeLog(`Running cpSync for ${pluginName}`);
+      fs.cpSync(deploySource, pluginExecutionPath, { recursive: true, force: true });
+      writeLog(`Finished cpSync for ${pluginName}`);
     } catch (e) {
-      console.error(`[Updater] Deploy failed: ${e.message}`);
-      return false;
+      writeLog(`cpSync failed for ${pluginName}: ${e.message}`, true);
+    }
+    return true;
+  },
+
+  rebuild: function(pluginName) {
+    const isClaude = process.argv.join(' ').includes('claude');
+    const configDir = getAppConfigDir(isClaude ? "claude" : "opencode");
+    this.deployToExecutionDir(pluginName, path.join(configDir, "plugin"));
+    return "Rebuilt " + pluginName;
+  },
+
+  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 this.rebuild(pluginName);
     }
+    return "Repo not found";
   },
 
-  /**
-   * Specific logic to install/update the launcher itself
-   */
-  installLauncher: function() {
-    // Logic to install opencode-hub / claude-hub if they are missing
-    this.updatePlugin("core-hub", "https://github.com/intisy/core-hub.git");
-    this.updatePlugin("opencode-hub", "https://github.com/intisy/opencode-hub.git");
-    this.updatePlugin("claude-hub", "https://github.com/intisy/claude-hub.git");
+  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);
+    if (fs.existsSync(pluginExecutionPath)) {
+      try { fs.rmSync(pluginExecutionPath, { recursive: true, force: true }); } catch (e) {}
+    }
+  },
+
+  uninstall: function(plugin) {
+    this.disable(plugin);
+    const targetDir = path.join(getReposDir(), plugin.name);
+    if (fs.existsSync(targetDir)) {
+      try { fs.rmSync(targetDir, { recursive: true, force: true }); } catch (e) {}
+    }
   }
 };
+
+const pluginUpdaterEntry = async function(input) {
+  const configDir = (input && input.configDir) ? input.configDir : path.dirname(getReposDir());
+  
+  // 1. GUARANTEE BASE DIRECTORIES EXIST ON LAUNCH
+  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 });
+
+  if (!global.__PLUGIN_UPDATER_HANDLED_BY_HUB__) {
+    updaterAPI.earlyLaunch(configDir);
+
+    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;
+            updaterAPI.updatePlugin(plugin.name, plugin.url, branch, commit);
+            updaterAPI.deployToExecutionDir(plugin.name, pluginsDir);
+          }
+        }
+      } catch (e) {
+        writeLog(`Failed to parse plugins.json: ${e.message}`, true);
+      }
+    }
+  }
+  return {};
+};
+
+const apiMethods = { ...updaterAPI };
+delete apiMethods.name;
+Object.assign(pluginUpdaterEntry, apiMethods);
+
+// Guarantee the entry point can be activated as a standard plugin
+pluginUpdaterEntry.activate = async function() { return await pluginUpdaterEntry(); };
+
+module.exports = pluginUpdaterEntry;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plugin-updater",
-  "version": "1.0.0",
+  "version": "1.0.9",
   "description": "Plugin lifecycle manager for OpenCode and Claude Code launchers",
   "main": "index.js",
   "license": "MIT",
@@ -9,5 +9,11 @@
     "type": "git",
     "url": "git+https://github.com/intisy/plugin-updater.git"
   },
-  "keywords": ["opencode", "claude", "plugin", "updater", "lifecycle"]
+  "keywords": [
+    "opencode",
+    "claude",
+    "plugin",
+    "updater",
+    "lifecycle"
+  ]
 }