opencode-plugin-auto-update 0.2.0 → 0.3.1

package/README.md

@@ -16,7 +16,7 @@ Automatically updates OpenCode plugins in the background on startup. No prompts,
 
 - Zero startup delay (async, detached update)
 - Bun-first installs with npm fallback
-- Logs update output to the console sidebar with a toast summary
+- Shows a brief toast summary after updates
 - Skips local/path/git plugins
 
 ## 📦 Installation

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/index.ts
-import { appendFile, readFile as readFile3 } from "fs/promises";
+import { appendFile, readFile as readFile4 } from "fs/promises";
 import { join as join3 } from "path";
 import { homedir as homedir3 } from "os";
 
@@ -126,6 +126,22 @@ async function getHostname() {
 
 // src/update.ts
 var DEFAULT_CONFIG_DIR2 = join2(homedir2(), ".config", "opencode");
+function normalizePluginConfig(config) {
+  const existingPlugin = Array.isArray(config.plugin) ? [...config.plugin] : [];
+  const existingPlugins = Array.isArray(config.plugins) ? [...config.plugins] : [];
+  if (existingPlugins.length === 0) {
+    return { config, changed: false };
+  }
+  const merged = [];
+  for (const entry of [...existingPlugin, ...existingPlugins]) {
+    if (!merged.includes(entry)) {
+      merged.push(entry);
+    }
+  }
+  config.plugin = merged;
+  delete config.plugins;
+  return { config, changed: true };
+}
 async function runAutoUpdate(options = {}) {
   const disabled = options.disabled ?? envFlag("OPENCODE_AUTO_UPDATE_DISABLED");
   if (disabled) {
@@ -133,7 +149,7 @@ async function runAutoUpdate(options = {}) {
   }
   const debug = options.debug ?? envFlag("OPENCODE_AUTO_UPDATE_DEBUG");
   const ignoreThrottle = options.ignoreThrottle ?? envFlag("OPENCODE_AUTO_UPDATE_BYPASS_THROTTLE");
-  const intervalHours = options.intervalHours ?? envNumber("OPENCODE_AUTO_UPDATE_INTERVAL_HOURS", 24);
+  const intervalHours = options.intervalHours ?? envNumber("OPENCODE_AUTO_UPDATE_INTERVAL_HOURS", 0);
   const preservePinned = options.preservePinned ?? envFlag("OPENCODE_AUTO_UPDATE_PINNED");
   const configDir = options.configDir ?? DEFAULT_CONFIG_DIR2;
   const configPath = join2(configDir, "opencode.json");
@@ -159,15 +175,24 @@ async function runAutoUpdate(options = {}) {
   try {
     const state = await readThrottleState({ configDir });
     const now = Date.now();
-    const intervalMs = Math.max(intervalHours, 1) * 60 * 60 * 1e3;
+    const intervalMs = intervalHours * 60 * 60 * 1e3;
     if (!ignoreThrottle && state.lastRun && now - state.lastRun < intervalMs) {
       log("[auto-update] Throttled, skipping update.");
       return;
     }
     await writeThrottleState({ ...state, lastRun: now }, { debug, configDir });
-    const config = await readConfig(configPath);
-    const { plugins, key } = getPluginList(config);
-    if (!plugins || plugins.length === 0 || !key) {
+    const rawConfig = await readConfig(configPath);
+    if (!rawConfig) {
+      log("[auto-update] No config found, skipping.");
+      return;
+    }
+    const normalized = normalizePluginConfig(rawConfig);
+    if (normalized.changed) {
+      await writeConfig(configPath, normalized.config);
+      log("[auto-update] Migrated config.plugins -> config.plugin");
+    }
+    const { plugins } = getPluginList(normalized.config);
+    if (!plugins || plugins.length === 0) {
       log("[auto-update] No plugins found to update.");
       return;
     }
@@ -187,9 +212,28 @@ async function runAutoUpdate(options = {}) {
       error
     });
     if (updateResult.changed) {
-      const updatedConfig = { ...config, [key]: updateResult.plugins };
+      const updatedConfig = {
+        ...normalized.config,
+        plugin: updateResult.plugins
+      };
+      delete updatedConfig.plugins;
       await writeConfig(configPath, updatedConfig);
     }
+    const hasOcx = await commandExists("ocx");
+    if (hasOcx) {
+      log("[auto-update] Found ocx, checking for extension updates...");
+      const ocxResult = await runCommand("ocx", ["update"]);
+      if (ocxResult.code === 0) {
+        const output = ocxResult.stdout.trim();
+        if (output) {
+          log("[auto-update] ocx update result:", output);
+        } else {
+          log("[auto-update] ocx update complete (no output).");
+        }
+      } else {
+        error("[auto-update] ocx update failed:", ocxResult.stderr || ocxResult.stdout);
+      }
+    }
     await writeThrottleState(
       { ...state, lastRun: now, lastSuccess: Date.now() },
       { debug, configDir }
@@ -216,16 +260,10 @@ async function writeConfig(configPath, config) {
 `, "utf-8");
 }
 function getPluginList(config) {
-  if (!config) {
-    return { plugins: null, key: null };
-  }
   if (Array.isArray(config.plugin)) {
-    return { plugins: config.plugin, key: "plugin" };
-  }
-  if (Array.isArray(config.plugins)) {
-    return { plugins: config.plugins, key: "plugins" };
+    return { plugins: config.plugin };
   }
-  return { plugins: null, key: null };
+  return { plugins: null };
 }
 async function updatePlugins(options) {
   const { plugins, configDir, preservePinned, useBun, log, error } = options;
@@ -392,8 +430,47 @@ function formatLogMessage(args) {
   }).join(" ");
 }
 
+// src/utils/circular-log.ts
+import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+var MAX_ENTRIES = 5;
+async function readCircularLog(logPath) {
+  try {
+    const contents = await readFile3(logPath, "utf-8");
+    return JSON.parse(contents);
+  } catch {
+    return { entries: [] };
+  }
+}
+async function appendCircularLog(logPath, entry) {
+  const log = await readCircularLog(logPath);
+  log.entries.push(entry);
+  if (log.entries.length > MAX_ENTRIES) {
+    log.entries = log.entries.slice(-MAX_ENTRIES);
+  }
+  await writeFile3(logPath, JSON.stringify(log, null, 2) + "\n", "utf-8");
+}
+function formatLogEntry(plugins, errors, duration, success) {
+  return {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    pluginsUpdated: plugins,
+    errors: errors.slice(0, 10),
+    duration,
+    success
+  };
+}
+
 // src/index.ts
 var CONFIG_PATH = join3(homedir3(), ".config", "opencode", "opencode-plugin-auto-update.json");
+function extractUpdatedPlugins(logEntries) {
+  const plugins = [];
+  for (const entry of logEntries) {
+    const match = entry.match(/Updated\s+(.+?)\s+from\s+v[\d.]+\s+to\s+v[\d.]+/i);
+    if (match && match[1]) {
+      plugins.push(match[1]);
+    }
+  }
+  return plugins;
+}
 var DEBUG_FILE = "/tmp/opencode-auto-update-debug.log";
 var DEBUG_ENABLED = false;
 async function src_default(ctx) {
@@ -405,6 +482,7 @@ async function src_default(ctx) {
   let lastToastMessage = null;
   const localConfig = await readLocalConfig();
   configIgnoreThrottle = localConfig.ignoreThrottle ?? false;
+  const configDebug = localConfig.debug ?? false;
   const shouldIgnoreThrottle = () => envBypassThrottle || configIgnoreThrottle;
   const notifyUser = async (message) => {
     await writeDebug("notifyUser invoked");
@@ -423,9 +501,8 @@ async function src_default(ctx) {
       });
       await writeDebug("toast shown");
     }
-    console.log(message);
-    await writeDebug("console fallback used");
   };
+  const CIRCULAR_LOG_PATH = join3(ctx.directory, "..", ".auto-update-history.json");
   const startUpdate = () => {
     if (updateStarted) {
       return;
@@ -434,21 +511,32 @@ async function src_default(ctx) {
     void writeDebug(`startUpdate invoked (ignoreThrottle=${shouldIgnoreThrottle()})`);
     const logEntries = [];
     const errorEntries = [];
+    const startTime = Date.now();
     runAutoUpdate({
-      debug: false,
+      debug: configDebug,
       ignoreThrottle: shouldIgnoreThrottle(),
       onLog: (message) => logEntries.push(message),
       onError: (message) => errorEntries.push(message)
     }).then(() => {
+      const duration = Date.now() - startTime;
+      const success = errorEntries.length === 0;
+      const pluginsUpdated = extractUpdatedPlugins(logEntries);
+      void appendCircularLog(
+        CIRCULAR_LOG_PATH,
+        formatLogEntry(pluginsUpdated, errorEntries, duration, success)
+      );
       updateMessage = formatUpdateMessage(logEntries, errorEntries);
       void writeDebug(`update finished (logs=${logEntries.length}, errors=${errorEntries.length})`);
       notifyUser(updateMessage).catch((error) => {
         void writeDebug(`notifyUser error: ${String(error)}`);
-        console.error("[opencode-plugin-auto-update] Failed to notify user:", error);
       });
     }).catch((error) => {
+      const duration = Date.now() - startTime;
+      void appendCircularLog(
+        CIRCULAR_LOG_PATH,
+        formatLogEntry([], [String(error)], duration, false)
+      );
       void writeDebug(`runAutoUpdate error: ${String(error)}`);
-      console.error("[opencode-plugin-auto-update] Update check failed:", error);
     });
   };
   startupTimer = setTimeout(() => {
@@ -494,7 +582,7 @@ async function writeDebug(message) {
 }
 async function readLocalConfig() {
   try {
-    const raw = await readFile3(CONFIG_PATH, "utf-8");
+    const raw = await readFile4(CONFIG_PATH, "utf-8");
     const parsed = JSON.parse(raw);
     return parsed ?? {};
   } catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-plugin-auto-update",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "OpenCode plugin that auto-updates plugins in the background",
   "type": "module",
   "main": "dist/index.js",