plugin-updater 1.3.5 → 1.4.1

package/README.md

@@ -91,7 +91,7 @@ Deployed automatically to both apps on each `earlyLaunch` (`~/.config/opencode/c
 
 ## Configuration
 
-> Config files are **auto-created with defaults on first run** (via core `ensureConfig`). **Global console logging** for every plugin is toggled in `config/settings.json` (`logConsole: true`, the opencode.json-equivalent).
+> Config files are **never auto-created on launch** — settings are registered with defaults (core `defineConfig`) and edited in the loader's **Plugins → Configure** screen (or `/<plugin>-config`); a file is written only when you change a value. **Global console logging** for every plugin is toggled in `config/settings.json` (`logConsole: true`, the opencode.json-equivalent).
 
 Config file: `~/.config/opencode/config/plugin-updater.json` (preferred) or `~/.config/opencode/plugin-updater.json` (fallback); same under `~/.claude` for Claude Code.
 

package/dist/cli.js

@@ -4,6 +4,7 @@ process.env.PLUGIN_UPDATER_CLI = "1";
 import fs from "fs";
 import path from "path";
 import os from "os";
+import { resolveOpencodeConfigPath, insertPluginIntoJsonc, resolveInitApps } from "./init.js";
 function parseArgs(argv) {
     const parsed = { command: argv[0] ?? "", urls: [] };
     for (let i = 1; i < argv.length; i++) {
@@ -83,18 +84,79 @@ function registerClaudeHook(configDir) {
     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");
+    // Edit the EXISTING opencode config (opencode.json, else opencode.jsonc) rather than
+    // always creating opencode.json — opencode reads either and two files are confusing.
+    const ocPath = resolveOpencodeConfigPath(configDir);
+    const exists = fs.existsSync(ocPath);
+    const raw = exists ? fs.readFileSync(ocPath, "utf8") : "";
+    const parsed = (exists ? readJson(ocPath) : null) ?? null;
+    // opencode plugin entries may be a string OR a [name, options] tuple — guard accordingly
+    const plugins = Array.isArray(parsed?.plugin) ? parsed.plugin : [];
+    const has = plugins.some((p) => p === "plugin-updater"
+        || (typeof p === "string" && p.startsWith("plugin-updater@"))
+        || (Array.isArray(p) && p[0] === "plugin-updater"));
+    if (has) {
+        console.log(`plugin-updater already registered in ${ocPath}`);
+        return;
     }
-    oc.plugin = plugins;
+    // Comment-preserving in-place insert for an existing file; fall back to a fresh JSON
+    // write only when there's no file or the text can't be safely edited.
+    if (exists && raw.trim()) {
+        const edited = insertPluginIntoJsonc(raw, "plugin-updater", Array.isArray(parsed?.plugin));
+        if (edited) {
+            fs.writeFileSync(ocPath, edited, "utf8");
+            console.log(`Registered plugin-updater in ${ocPath}`);
+            return;
+        }
+    }
+    const oc = (parsed ?? {});
+    oc.plugin = ["plugin-updater", ...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}`);
 }
+// which apps are installed on this machine (used when no --app is given)
+function presentApps() {
+    const claude = fs.existsSync(path.join(os.homedir(), ".claude")) || binaryExists("claude");
+    const opencode = fs.existsSync(path.join(os.homedir(), ".opencode"))
+        || fs.existsSync(path.join(os.homedir(), ".config", "opencode"))
+        || binaryExists("opencode");
+    return { claude, opencode };
+}
+// infer the app from the current directory (the prompt's default suggestion)
+function cwdApp() {
+    const cwd = process.cwd().replace(/\\/g, "/");
+    if (/(^|\/)\.claude(\/|$)/.test(cwd))
+        return "claude";
+    if (/(^|\/)\.opencode(\/|$)/.test(cwd) || /(^|\/)\.config\/opencode(\/|$)/.test(cwd))
+        return "opencode";
+    return null;
+}
+// interactive picker shown when both/neither app is detected and no --app was passed
+async function promptInitApps(_present, defaultApp) {
+    const readline = await import("readline/promises");
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const menu = [
+            "Initialize plugins for which app?",
+            `  [1] opencode${defaultApp === "opencode" ? "  (default)" : ""}`,
+            `  [2] claude${defaultApp === "claude" ? "  (default)" : ""}`,
+            "  [3] both",
+        ].join("\n");
+        const ans = (await rl.question(`${menu}\n> [${defaultApp}] `)).trim().toLowerCase();
+        if (ans === "3" || ans === "both")
+            return ["opencode", "claude"];
+        if (ans === "1" || ans === "opencode")
+            return ["opencode"];
+        if (ans === "2" || ans === "claude")
+            return ["claude"];
+        return [defaultApp];
+    }
+    finally {
+        rl.close();
+    }
+}
 function addPluginEntry(configDir, url, branch, sync) {
     const cleanUrl = url.replace(/\.git$/, "");
     const name = cleanUrl.split("/").pop() ?? cleanUrl;
@@ -150,25 +212,41 @@ async function main() {
         console.log("usage: plugin-updater <init|add|remove|run> [git-urls-or-names...] [--app claude|opencode] [--branch name] [--sync]");
         process.exit(parsed.command ? 1 : 0);
     }
+    const updater = await import("./index.js");
+    // `init` may target one or both apps: explicit --app wins; otherwise a single
+    // detected app is used, and an ambiguous (both/neither) interactive run is prompted.
+    if (parsed.command === "init") {
+        const apps = await resolveInitApps(parsed.app, {
+            present: presentApps,
+            isTTY: Boolean(process.stdin.isTTY),
+            cwdApp,
+            prompt: promptInitApps,
+        });
+        for (const app of apps) {
+            process.env.PLUGIN_UPDATER_APP = app;
+            const configDir = getConfigDir(app);
+            if (!fs.existsSync(configDir))
+                fs.mkdirSync(configDir, { recursive: true });
+            console.log(`App: ${app} (${configDir})`);
+            ensurePluginsJson(configDir);
+            if (app === "claude")
+                registerClaudeHook(configDir);
+            else
+                registerOpencodePlugin(configDir);
+            for (const url of parsed.urls) {
+                await setupEntry(updater, configDir, url, parsed.branch, parsed.sync);
+            }
+        }
+        console.log("Init complete.");
+        return;
+    }
     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) {
-            await setupEntry(updater, configDir, url, parsed.branch, parsed.sync);
-        }
-        console.log("Init complete.");
-    }
-    else if (parsed.command === "add") {
+    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) {

package/dist/commands.js

@@ -1,12 +1,16 @@
 // @ts-nocheck
-// Cross-app slash-command for plugin-updater: /plugin-updater-config (the loaders
-// own /plugins). plugin-updater is an npm package (not deployed at plugin/<name>.js),
-// so the command shells into this same bundle's index.js by its absolute path.
+// Cross-app slash-commands for plugin-updater:
+//   /plugin-updater-config — plugin-updater's OWN settings (scoped, like every plugin)
+//   /config                — the UNIFIED entry: global settings + ANY installed plugin
+// plugin-updater is an npm package (not deployed at plugin/<name>.js), so commands shell
+// into this same bundle's index.js by absolute path. The /config dispatcher (config-all)
+// enumerates plugins.json and resolves each plugin's deployed bundle.
 import { fileURLToPath } from "url";
 import { dirname, join } from "path";
-import { runConfigCli, deployCommands } from "../lib/core.js";
+import fs from "fs";
+import { runConfigCli, runAllConfigCli, deployCommands, getAppConfigDir as coreGetAppConfigDir } from "../lib/core.js";
+import { getPlugins } from "./config.js";
 const PLUGIN = "plugin-updater";
-// the deployed entry that carries the maybeRunCli guard (dist/index.js, sibling).
 const SELF = join(dirname(fileURLToPath(import.meta.url)), "index.js");
 export function deployUpdaterCommands() {
     try {
@@ -18,19 +22,37 @@ export function deployUpdaterCommands() {
                 shell: `node "${SELF}" config $ARGUMENTS`,
                 body: "Above is the plugin-updater config result. Report it; if the user changed a setting, confirm the new value.",
             },
+            {
+                name: "config",
+                description: "View/change ANY plugin's settings and the global settings",
+                argumentHint: "[global | <plugin>] [list | get <key> | set <key> <value>]",
+                shell: `node "${SELF}" config-all $ARGUMENTS`,
+                body: "Above is the unified ecosystem config: the global settings block plus one block per installed plugin. Present it clearly. If the user asked to change a setting, run `/config <target> set <key> <value>` (target is `global` or the plugin name) and confirm the new value.",
+            },
         ]);
     }
     catch {
         /* best-effort */
     }
 }
-// If invoked as `node dist/index.js config …`, run the config CLI and return true
-// so the entry exits before the updater/self-activate sequence.
 export async function maybeRunCli() {
     const argv = process.argv.slice(2);
     if (argv[0] === "config") {
         runConfigCli(PLUGIN, argv.slice(1));
         return true;
     }
+    if (argv[0] === "config-all") {
+        // Use core's getAppConfigDir (respects HUB_OPENCODE_DIR / HUB_CLAUDE_DIR env overrides)
+        const configDir = coreGetAppConfigDir();
+        const names = getPlugins(configDir).map((p) => p.name);
+        const resolveBundle = (name) => {
+            if (name === PLUGIN)
+                return SELF;
+            const p = join(configDir, "plugin", `${name}.js`);
+            return fs.existsSync(p) ? p : null;
+        };
+        runAllConfigCli(argv.slice(1), { plugins: [...names, PLUGIN], resolveBundle });
+        return true;
+    }
     return false;
 }

package/dist/init.d.ts

@@ -0,0 +1,13 @@
+export declare function resolveOpencodeConfigPath(configDir: string, exists?: (p: string) => boolean): string;
+export declare function insertPluginIntoJsonc(raw: string, pluginName: string, hasPluginKey: boolean): string | null;
+export interface PresentApps {
+    claude: boolean;
+    opencode: boolean;
+}
+export interface InitAppDeps {
+    present: () => PresentApps;
+    isTTY: boolean;
+    cwdApp: () => string | null;
+    prompt: (present: PresentApps, defaultApp: string) => Promise<string[]>;
+}
+export declare function resolveInitApps(explicit: string | undefined, deps: InitAppDeps): Promise<string[]>;

package/dist/init.js

@@ -0,0 +1,65 @@
+// Init-time helpers split out of cli.ts so the comment-preserving opencode-config
+// edit and the app-resolution logic are unit-testable without running the CLI entry.
+import fs from "fs";
+import path from "path";
+// ── opencode config target ───────────────────────────────────────────────────
+// `init` must NOT create a fresh opencode.json when the user already has an
+// opencode.jsonc — opencode reads either, and a second file is confusing. Prefer an
+// existing opencode.json, else an existing opencode.jsonc, else default to .json.
+export function resolveOpencodeConfigPath(configDir, exists = fs.existsSync) {
+    const jsonPath = path.join(configDir, "opencode.json");
+    const jsoncPath = path.join(configDir, "opencode.jsonc");
+    if (exists(jsonPath))
+        return jsonPath;
+    if (exists(jsoncPath))
+        return jsoncPath;
+    return jsonPath;
+}
+// Insert `pluginName` as the first entry of the root `plugin` array, editing the raw
+// text in place so // comments and formatting elsewhere survive (a JSON.stringify
+// rewrite would strip them). `hasPluginKey` (from the PARSED root, so it can't be
+// fooled by a nested "plugin" key or one inside a string) selects the branch: true →
+// insert into the existing array; false → add a new `plugin` key. Returns the edited
+// text, or null if it can't be safely edited (caller then falls back to a JSON write).
+export function insertPluginIntoJsonc(raw, pluginName, hasPluginKey) {
+    const entry = JSON.stringify(pluginName);
+    if (hasPluginKey) {
+        // Insert right after the root array's `[`. Prefer a line-anchored match so a deeper
+        // `"plugin": [` earlier in the file can't be picked; fall back to the first match.
+        const m = raw.match(/^[ \t]*"plugin"\s*:\s*\[/m) ?? raw.match(/"plugin"\s*:\s*\[/);
+        if (!m || m.index === undefined)
+            return null;
+        const at = m.index + m[0].length;
+        const rest = raw.slice(at);
+        const isEmpty = /^\s*\]/.test(rest);
+        return raw.slice(0, at) + (isEmpty ? entry : `${entry}, `) + rest;
+    }
+    // No `plugin` key — insert one right after the root `{`.
+    const brace = raw.indexOf("{");
+    if (brace === -1)
+        return null;
+    const afterBrace = raw.slice(brace + 1);
+    const isEmptyObject = /^\s*}/.test(afterBrace);
+    if (isEmptyObject) {
+        return raw.slice(0, brace + 1) + `\n  "plugin": [${entry}]\n` + afterBrace;
+    }
+    return raw.slice(0, brace + 1) + `\n  "plugin": [${entry}],` + afterBrace;
+}
+// Decide which app(s) `init` targets. Explicit --app always wins. A single detected
+// app is used directly. When both or neither are detected we PROMPT (if interactive)
+// so the user can pick one or both; non-interactively we keep the hard error rather
+// than guess.
+export async function resolveInitApps(explicit, deps) {
+    if (explicit === "claude" || explicit === "opencode")
+        return [explicit];
+    if (explicit)
+        throw new Error(`Unknown app "${explicit}" - use claude or opencode`);
+    const p = deps.present();
+    if (p.claude !== p.opencode)
+        return [p.claude ? "claude" : "opencode"];
+    if (!deps.isTTY) {
+        throw new Error("Both apps (or neither) found - pass --app claude or --app opencode");
+    }
+    const defaultApp = deps.cwdApp() ?? "opencode";
+    return deps.prompt(p, defaultApp);
+}

package/lib/core.js

@@ -285,7 +285,54 @@ function maybeRunConfigCli(pluginName) {
   }
   return true;
 }
+
+// core/src/configcli-all.ts
+import { execFileSync } from "child_process";
+var GLOBAL_SETTINGS_DEFAULTS = { logConsole: false, logColor: true };
+var GLOBAL_NAME = "settings";
+function defaultRunChild(bundle, args) {
+  return execFileSync(process.execPath, [bundle, "config", ...args], { encoding: "utf8" });
+}
+function msg(e) {
+  return String(e?.message ?? e);
+}
+function runAllConfigCli(argv, opts) {
+  defineConfig(GLOBAL_NAME, GLOBAL_SETTINGS_DEFAULTS);
+  const runChild = opts.runChild ?? defaultRunChild;
+  const [target, ...rest] = argv;
+  if (!target || target === "list") {
+    console.log("# global");
+    runConfigCli(GLOBAL_NAME, ["list"]);
+    for (const name of opts.plugins) {
+      const bundle2 = opts.resolveBundle(name);
+      if (!bundle2) continue;
+      console.log(`
+# ${name}`);
+      try {
+        process.stdout.write(runChild(bundle2, ["list"]));
+      } catch (e) {
+        console.log(`  (could not read ${name}: ${msg(e)})`);
+      }
+    }
+    return;
+  }
+  if (target === "global") {
+    runConfigCli(GLOBAL_NAME, rest.length ? rest : ["list"]);
+    return;
+  }
+  const bundle = opts.resolveBundle(target);
+  if (!bundle) {
+    console.log(`Unknown config target: ${target}`);
+    return;
+  }
+  try {
+    process.stdout.write(runChild(bundle, rest.length ? rest : ["list"]));
+  } catch (e) {
+    console.log(`config ${target} failed: ${msg(e)}`);
+  }
+}
 export {
+  GLOBAL_SETTINGS_DEFAULTS,
   atomicWrite,
   coerce,
   configCommand,
@@ -309,6 +356,7 @@ export {
   makeWriteLog,
   maybeRunConfigCli,
   readJson,
+  runAllConfigCli,
   runConfigCli,
   setConfigValue,
   writeJson

package/package.json

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