plugin-updater 1.0.31 → 1.0.33

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+process.env.PLUGIN_UPDATER_LIBRARY_MODE = "1";
+process.env.PLUGIN_UPDATER_CLI = "1";
+import fs from "fs";
+import path from "path";
+import os from "os";
+function parseArgs(argv) {
+    const parsed = { command: argv[0] ?? "", urls: [] };
+    for (let i = 1; i < argv.length; i++) {
+        if (argv[i] === "--app")
+            parsed.app = argv[++i];
+        else if (argv[i] === "--branch")
+            parsed.branch = argv[++i];
+        else
+            parsed.urls.push(argv[i]);
+    }
+    return parsed;
+}
+function detectApp(explicit) {
+    if (explicit === "claude" || explicit === "opencode")
+        return explicit;
+    if (explicit)
+        throw new Error(`Unknown app "${explicit}" - use claude or opencode`);
+    const hasClaude = fs.existsSync(path.join(os.homedir(), ".claude"));
+    const hasOpencode = fs.existsSync(path.join(os.homedir(), ".opencode"))
+        || fs.existsSync(path.join(os.homedir(), ".config", "opencode"));
+    if (hasClaude && !hasOpencode)
+        return "claude";
+    if (hasOpencode && !hasClaude)
+        return "opencode";
+    throw new Error("Cannot detect the app automatically - pass --app claude or --app opencode");
+}
+function getConfigDir(app) {
+    const home = os.homedir();
+    const directPath = path.join(home, `.${app}`);
+    const configPath = path.join(home, ".config", app);
+    return fs.existsSync(directPath) ? directPath : app === "claude" ? directPath : configPath;
+}
+function readJson(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, "utf8").replace(/^\s*\/\/[^\n]*/gm, ""));
+    }
+    catch {
+        return null;
+    }
+}
+function pluginsJsonPath(configDir) {
+    return path.join(configDir, "config", "plugins.json");
+}
+function ensurePluginsJson(configDir) {
+    const file = pluginsJsonPath(configDir);
+    if (!fs.existsSync(path.dirname(file)))
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+    if (!fs.existsSync(file))
+        fs.writeFileSync(file, "[]\n", "utf8");
+}
+function registerClaudeHook(configDir) {
+    const settingsPath = path.join(configDir, "settings.json");
+    const settings = (fs.existsSync(settingsPath) ? readJson(settingsPath) : {}) ?? {};
+    const hooks = (settings.hooks ?? {});
+    const sessionStart = (hooks.SessionStart ?? []);
+    if (!JSON.stringify(sessionStart).includes("plugin-updater run")) {
+        sessionStart.push({ hooks: [{ type: "command", command: "npx -y plugin-updater run --app claude" }] });
+    }
+    hooks.SessionStart = sessionStart;
+    settings.hooks = hooks;
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), "utf8");
+    console.log(`Registered SessionStart hook in ${settingsPath}`);
+}
+function registerOpencodePlugin(configDir) {
+    const ocPath = path.join(configDir, "opencode.json");
+    const oc = (fs.existsSync(ocPath) ? readJson(ocPath) : {}) ?? {};
+    const plugins = Array.isArray(oc.plugin) ? oc.plugin : [];
+    if (!plugins.some((p) => p === "plugin-updater" || p.startsWith("plugin-updater@"))) {
+        plugins.unshift("plugin-updater");
+    }
+    oc.plugin = plugins;
+    if (!oc.$schema)
+        oc.$schema = "https://opencode.ai/config.json";
+    fs.writeFileSync(ocPath, JSON.stringify(oc, null, 2), "utf8");
+    console.log(`Registered plugin-updater in ${ocPath}`);
+}
+function addPluginEntry(configDir, url, branch) {
+    const cleanUrl = url.replace(/\.git$/, "");
+    const name = cleanUrl.split("/").pop() ?? cleanUrl;
+    ensurePluginsJson(configDir);
+    const file = pluginsJsonPath(configDir);
+    const entries = readJson(file) ?? [];
+    if (!entries.some((e) => e.name === name)) {
+        const entry = { name, url: cleanUrl, enabled: true, autoUpdate: true };
+        if (branch)
+            entry.branch = branch;
+        entries.push(entry);
+        fs.writeFileSync(file, JSON.stringify(entries, null, 2), "utf8");
+        console.log(`Added ${name} to ${file}`);
+    }
+    else {
+        console.log(`${name} already present in ${file}`);
+    }
+    return { name, url: cleanUrl, branch };
+}
+async function main() {
+    const parsed = parseArgs(process.argv.slice(2));
+    if (!["init", "add", "run"].includes(parsed.command)) {
+        console.log("usage: plugin-updater <init|add|run> [git-urls...] [--app claude|opencode] [--branch name]");
+        process.exit(parsed.command ? 1 : 0);
+    }
+    const app = detectApp(parsed.app);
+    process.env.PLUGIN_UPDATER_APP = app;
+    const configDir = getConfigDir(app);
+    if (!fs.existsSync(configDir))
+        fs.mkdirSync(configDir, { recursive: true });
+    console.log(`App: ${app} (${configDir})`);
+    const updater = await import("./index.js");
+    if (parsed.command === "init") {
+        ensurePluginsJson(configDir);
+        if (app === "claude")
+            registerClaudeHook(configDir);
+        else
+            registerOpencodePlugin(configDir);
+        for (const url of parsed.urls) {
+            const entry = addPluginEntry(configDir, url, parsed.branch);
+            console.log(`Setting up ${entry.name}...`);
+            await updater.updatePluginPublic(entry.name, entry.url, entry.branch);
+        }
+        console.log("Init complete.");
+    }
+    else if (parsed.command === "add") {
+        if (parsed.urls.length === 0)
+            throw new Error("add requires at least one git url");
+        for (const url of parsed.urls) {
+            const entry = addPluginEntry(configDir, url, parsed.branch);
+            console.log(`Setting up ${entry.name}...`);
+            await updater.updatePluginPublic(entry.name, entry.url, entry.branch);
+        }
+    }
+    else {
+        const entries = readJson(pluginsJsonPath(configDir)) ?? [];
+        await updater.earlyLaunch(configDir, entries);
+    }
+}
+main().catch((e) => {
+    console.error(String(e.message ?? e));
+    process.exit(1);
+});

package/dist/index.js

@@ -5,13 +5,18 @@ 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 isClaude = process.argv.join(" ").includes("claude");
-        const appName = isClaude ? "claude" : "opencode";
-        const configDir = getAppConfigDir(appName);
+        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;
@@ -36,9 +41,7 @@ function writeLog(message, isError = false) {
         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 configDir = getAppConfigDir(getAppName());
             const logsDir = path.join(configDir, "logs", dateStr);
             if (!fs.existsSync(logsDir))
                 fs.mkdirSync(logsDir, { recursive: true });
@@ -48,7 +51,7 @@ function writeLog(message, isError = false) {
         }
     }
     catch { /* never crash on log failure */ }
-    if (process.env.PLUGIN_UPDATER_LIBRARY_MODE === "1")
+    if (process.env.PLUGIN_UPDATER_LIBRARY_MODE === "1" && process.env.PLUGIN_UPDATER_CLI !== "1")
         return;
     if (isError)
         console.error(message);
@@ -57,9 +60,7 @@ function writeLog(message, isError = false) {
 }
 let NPM_GLOBAL_ROOT = null;
 function getReposDir() {
-    const isClaude = process.argv.join(" ").includes("claude");
-    const appName = isClaude ? "claude" : "opencode";
-    return path.join(getAppConfigDir(appName), "repos");
+    return path.join(getAppConfigDir(getAppName()), "repos");
 }
 function executeGit(command, cwd) {
     writeLog(`Executing git: ${command} in ${cwd}`);
@@ -365,6 +366,12 @@ async function deployToExecutionDir(pluginName, executionPath, changed, configDi
         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;
@@ -406,11 +413,57 @@ async function deployToExecutionDir(pluginName, executionPath, changed, configDi
         const err = e;
         writeLog(`Copy failed for ${pluginName}: ${err.message}`, true);
     }
+    applyClaudeManifest(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}`);
+                await deployed.activate();
+                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");
+        }
+        if (manifest.daemon?.script) {
+            writeLog(`${pluginName} defines a daemon (${manifest.daemon.script}) which the updater does not manage yet`, true);
+        }
+    }
+    catch (e) {
+        writeLog(`claudeHub manifest handling failed for ${pluginName}: ${e.message}`, true);
+    }
+}
 async function pluginUpdaterEntry(input) {
-    const isClaude = process.argv.join(" ").includes("claude");
-    const appName = isClaude ? "claude" : "opencode";
+    const appName = getAppName();
     const configDir = getAppConfigDir(appName);
     const pluginsDir = path.join(configDir, "plugin");
     writeLog(`Starting plugin updater for ${appName}`);
@@ -425,8 +478,7 @@ 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);
+    const configDir = getAppConfigDir(getAppName());
     // interval 0: an explicit update request must never fast-path-skip
     const result = updatePlugin(pluginName, gitUrl, branch, commitHash ?? null, 0);
     await deployToExecutionDir(pluginName, path.join(configDir, "plugin"), result.changed, configDir);
@@ -487,8 +539,7 @@ export async function activate(opencodeHookInput) {
     // 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 appName = getAppName();
     const configDir = getAppConfigDir(appName);
     writeLog(`Plugin updater activating for ${appName}`);
     const pluginsJsonPath = path.join(configDir, "config", "plugins.json");

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "plugin-updater",
-  "version": "1.0.31",
+  "version": "1.0.33",
   "description": "Plugin lifecycle manager for OpenCode and Claude Code launchers",
   "type": "module",
   "main": "dist/index.js",
+  "bin": {
+    "plugin-updater": "dist/cli.js"
+  },
   "license": "MIT",
   "author": "intisy",
   "repository": {