plugin-updater 1.4.0 → 1.4.2

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, cwdApp } from "./init.js";
 function parseArgs(argv) {
     const parsed = { command: argv[0] ?? "", urls: [] };
     for (let i = 1; i < argv.length; i++) {
@@ -83,18 +84,76 @@ 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 };
+}
+// interactive picker shown when both/neither app is detected and no --app was passed.
+// defaultApp (cwd-inferred) may be null — then there is no default and an empty answer
+// re-asks rather than guessing.
+async function promptInitApps(_present, defaultApp) {
+    const readline = await import("readline/promises");
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        console.log([
+            "Initialize plugins for which app?",
+            `  [1] opencode${defaultApp === "opencode" ? "  (default)" : ""}`,
+            `  [2] claude${defaultApp === "claude" ? "  (default)" : ""}`,
+            "  [3] both",
+        ].join("\n"));
+        for (;;) {
+            const ans = (await rl.question(`> ${defaultApp ? `[${defaultApp}] ` : "1/2/3 "}`)).trim().toLowerCase();
+            if (ans === "1" || ans === "opencode")
+                return ["opencode"];
+            if (ans === "2" || ans === "claude")
+                return ["claude"];
+            if (ans === "3" || ans === "both")
+                return ["opencode", "claude"];
+            if (ans === "" && defaultApp)
+                return [defaultApp];
+            // empty with no default, or unrecognized → re-ask
+        }
+    }
+    finally {
+        rl.close();
+    }
+}
 function addPluginEntry(configDir, url, branch, sync) {
     const cleanUrl = url.replace(/\.git$/, "");
     const name = cleanUrl.split("/").pop() ?? cleanUrl;
@@ -150,25 +209,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/init.d.ts

@@ -0,0 +1,14 @@
+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 declare function cwdApp(cwd?: string): string | null;
+export interface InitAppDeps {
+    present: () => PresentApps;
+    isTTY: boolean;
+    cwdApp: () => string | null;
+    prompt: (present: PresentApps, defaultApp: string | null) => Promise<string[]>;
+}
+export declare function resolveInitApps(explicit: string | undefined, deps: InitAppDeps): Promise<string[]>;

package/dist/init.js

@@ -0,0 +1,76 @@
+// 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;
+}
+// Infer the app ONLY from the current directory actually being an app's config dir
+// (~/.claude or ~/.config/opencode|~/.opencode). Returns null otherwise — e.g. /workspace
+// — so the prompt offers no default rather than silently assuming opencode.
+export function cwdApp(cwd = process.cwd()) {
+    const c = cwd.replace(/\\/g, "/");
+    if (/(^|\/)\.claude(\/|$)/.test(c))
+        return "claude";
+    if (/(^|\/)\.opencode(\/|$)/.test(c) || /(^|\/)\.config\/opencode(\/|$)/.test(c))
+        return "opencode";
+    return null;
+}
+// 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. The prompt default is the cwd-inferred app, or null (no default) when
+// the cwd gives no signal.
+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");
+    }
+    return deps.prompt(p, deps.cwdApp());
+}

package/package.json

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