opencode-plugin-auto-update 0.1.1 → 0.2.0

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
-- Silent by default; debug logging via env
+- Logs update output to the console sidebar with a toast summary
 - Skips local/path/git plugins
 
 ## 📦 Installation
@@ -94,29 +94,34 @@ Configure via environment variables:
 |----------|---------|-------------|
 | `OPENCODE_AUTO_UPDATE_DISABLED` | `false` | Disable all updates when `true` |
 | `OPENCODE_AUTO_UPDATE_INTERVAL_HOURS` | `24` | Throttle interval in hours |
-| `OPENCODE_AUTO_UPDATE_DEBUG` | `false` | Enable debug logs |
 | `OPENCODE_AUTO_UPDATE_PINNED` | `false` | Preserve pinned versions |
 | `OPENCODE_AUTO_UPDATE_BYPASS_THROTTLE` | `false` | Ignore throttle (useful for testing) |
 
-### CLI Flags
+### Local Config File
 
-- `opencode --log-level DEBUG`: enable debug mode for OpenCode and trigger verbose update logs with throttle bypass.
+You can bypass throttling without relying on CLI flags by creating:
+
+`~/.config/opencode/opencode-plugin-auto-update.json`
+
+```json
+{
+  "ignoreThrottle": true
+}
+```
 
 ## ❓ Troubleshooting
 
 1. **Updates not running**: ensure `OPENCODE_AUTO_UPDATE_DISABLED` is not set to `true`.
-2. **No logs**: run `opencode --log-level DEBUG` or set `OPENCODE_AUTO_UPDATE_DEBUG=true` for verbose output.
+2. **No logs**: confirm the plugin is enabled and watch for the "Auto-update logs" output after startup.
 3. **Plugin not loading**: check the `plugin` array in `~/.config/opencode/opencode.json`.
-4. **Testing updates**: run `opencode --log-level DEBUG` to bypass the 24h throttle and see detailed update logs.
+4. **Testing updates**: set `OPENCODE_AUTO_UPDATE_BYPASS_THROTTLE=true` or the local config `ignoreThrottle=true`.
 
 ## 🚀 Release Process
 
-1. Update version in `package.json`
-2. Update `CHANGELOG.md`
-3. `bun run build`
-4. `npm publish`
-5. `git tag vX.Y.Z && git push --tags`
-6. `gh release create vX.Y.Z --notes "..."`
+1. Land changes on `main` using conventional commits.
+2. The Release workflow opens a Release Please PR with version + changelog updates.
+3. Merge the Release Please PR to create the tag + GitHub release.
+4. The Publish workflow (environment: `release`) builds and publishes to npm via OIDC.
 
 ## 📄 License
 

package/dist/index.d.ts

@@ -1,30 +1,22 @@
 interface PluginInput {
     directory: string;
-    serverUrl?: URL | string;
     client: {
-        session: {
-            status(): Promise<{
-                data?: Record<string, {
-                    type: string;
-                }>;
-            }>;
-            subscribe(callback: (event: {
-                type: string;
-                properties?: unknown;
-            }) => void): () => void;
+        tui?: {
+            showToast?: (input: {
+                body: {
+                    title?: string;
+                    message: string;
+                    variant?: 'info' | 'success' | 'warning' | 'error';
+                };
+            }) => Promise<unknown>;
         };
     };
 }
 interface PluginOutput {
     name: string;
-    event?: (input: {
-        event: {
-            type: string;
-            properties?: unknown;
-        };
+    config?: (input: {
+        logLevel?: string;
     }) => Promise<void>;
-    tool?: Record<string, unknown>;
-    config?: unknown;
 }
 declare function export_default(ctx: PluginInput): Promise<PluginOutput>;
 

package/dist/index.js

@@ -1,3 +1,8 @@
+// src/index.ts
+import { appendFile, readFile as readFile3 } from "fs/promises";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+
 // src/update.ts
 import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
 import { dirname, join as join2 } from "path";
@@ -133,14 +138,18 @@ async function runAutoUpdate(options = {}) {
   const configDir = options.configDir ?? DEFAULT_CONFIG_DIR2;
   const configPath = join2(configDir, "opencode.json");
   const log = (...args) => {
+    const message = formatLogMessage(args);
     if (debug) {
-      console.log(...args);
+      console.log(message);
     }
+    options.onLog?.(message);
   };
   const error = (...args) => {
+    const message = formatLogMessage(args);
     if (debug) {
-      console.error(...args);
+      console.error(message);
     }
+    options.onError?.(message);
   };
   const lockAcquired = await acquireLock({ debug, configDir });
   if (!lockAcquired) {
@@ -361,26 +370,142 @@ function envNumber(name, fallback) {
   const parsed = Number(raw);
   return Number.isFinite(parsed) ? parsed : fallback;
 }
+function formatLogMessage(args) {
+  return args.map((arg) => {
+    if (typeof arg === "string") {
+      return arg;
+    }
+    if (arg instanceof Error) {
+      return arg.message || arg.name;
+    }
+    if (arg && typeof arg === "object" && "message" in arg) {
+      const message = arg.message;
+      if (typeof message === "string" && message.trim().length > 0) {
+        return message;
+      }
+    }
+    try {
+      return JSON.stringify(arg);
+    } catch {
+      return String(arg);
+    }
+  }).join(" ");
+}
 
 // src/index.ts
+var CONFIG_PATH = join3(homedir3(), ".config", "opencode", "opencode-plugin-auto-update.json");
+var DEBUG_FILE = "/tmp/opencode-auto-update-debug.log";
+var DEBUG_ENABLED = false;
 async function src_default(ctx) {
-  const args = process.argv ?? [];
-  const debugLevelFlag = args.includes("--log-level") && args.includes("DEBUG");
-  const envDebug = process.env.OPENCODE_AUTO_UPDATE_DEBUG?.toLowerCase() === "true";
   const envBypassThrottle = process.env.OPENCODE_AUTO_UPDATE_BYPASS_THROTTLE?.toLowerCase() === "true";
-  const debug = debugLevelFlag || envDebug;
-  const ignoreThrottle = debugLevelFlag || envBypassThrottle;
-  setTimeout(() => {
-    runAutoUpdate({ debug, ignoreThrottle }).catch((error) => {
-      if (debug) {
-        console.error("[opencode-plugin-auto-update] Update check failed:", error);
-      }
+  let configIgnoreThrottle = false;
+  let updateStarted = false;
+  let startupTimer = null;
+  let updateMessage = null;
+  let lastToastMessage = null;
+  const localConfig = await readLocalConfig();
+  configIgnoreThrottle = localConfig.ignoreThrottle ?? false;
+  const shouldIgnoreThrottle = () => envBypassThrottle || configIgnoreThrottle;
+  const notifyUser = async (message) => {
+    await writeDebug("notifyUser invoked");
+    const toastMessage = summarizeMessage(message);
+    if (toastMessage === lastToastMessage) {
+      return;
+    }
+    lastToastMessage = toastMessage;
+    if (typeof ctx?.client?.tui?.showToast === "function") {
+      await ctx.client.tui.showToast({
+        body: {
+          title: "Auto-update",
+          message: toastMessage,
+          variant: "info"
+        }
+      });
+      await writeDebug("toast shown");
+    }
+    console.log(message);
+    await writeDebug("console fallback used");
+  };
+  const startUpdate = () => {
+    if (updateStarted) {
+      return;
+    }
+    updateStarted = true;
+    void writeDebug(`startUpdate invoked (ignoreThrottle=${shouldIgnoreThrottle()})`);
+    const logEntries = [];
+    const errorEntries = [];
+    runAutoUpdate({
+      debug: false,
+      ignoreThrottle: shouldIgnoreThrottle(),
+      onLog: (message) => logEntries.push(message),
+      onError: (message) => errorEntries.push(message)
+    }).then(() => {
+      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) => {
+      void writeDebug(`runAutoUpdate error: ${String(error)}`);
+      console.error("[opencode-plugin-auto-update] Update check failed:", error);
     });
-  }, 0);
+  };
+  startupTimer = setTimeout(() => {
+    if (!updateStarted) {
+      void writeDebug("startup timer fired");
+      startUpdate();
+    }
+  }, 1500);
   return {
-    name: "opencode-plugin-auto-update"
+    name: "opencode-plugin-auto-update",
+    config: async (config) => {
+      await writeDebug(`config hook invoked (logLevel=${config?.logLevel ?? "unset"})`);
+      if (startupTimer) {
+        clearTimeout(startupTimer);
+        startupTimer = null;
+      }
+      startUpdate();
+    }
   };
 }
+function formatUpdateMessage(logs, errors) {
+  const lines = ["Auto-update logs"];
+  const logLines = logs.length > 0 ? logs : ["No update output recorded."];
+  lines.push("", ...limitLines(logLines, 40));
+  if (errors.length > 0) {
+    lines.push("", "Errors:", ...limitLines(errors, 10));
+  }
+  return lines.join("\n");
+}
+function limitLines(lines, maxLines) {
+  if (lines.length <= maxLines) {
+    return lines;
+  }
+  return [...lines.slice(0, maxLines), `... (${lines.length - maxLines} more lines)`];
+}
+async function writeDebug(message) {
+  if (!DEBUG_ENABLED) {
+    return;
+  }
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  await appendFile(DEBUG_FILE, `[${timestamp}] ${message}
+`);
+}
+async function readLocalConfig() {
+  try {
+    const raw = await readFile3(CONFIG_PATH, "utf-8");
+    const parsed = JSON.parse(raw);
+    return parsed ?? {};
+  } catch {
+    return {};
+  }
+}
+function summarizeMessage(message) {
+  const lines = message.split("\n").filter((line) => line.trim().length > 0);
+  const summary = lines.slice(0, 4).join(" | ");
+  return summary.length > 240 ? `${summary.slice(0, 237)}...` : summary;
+}
 export {
   src_default as default
 };

package/package.json

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