opencode-docker-panel 0.5.1 → 0.6.0

package/CHANGELOG.md

@@ -3,6 +3,25 @@
 All notable changes to this plugin, by version and date. The version is the one in `package.json` at
 that commit.
 
+## 0.6.0 - 2026-10-10
+
+- The panel follows `docker events` instead of asking on a timer, so a container appears or disappears
+  as soon as Docker reports it: 442 ms on a measured `compose stop`, against up to three seconds before
+- Only `start`, `die`, `destroy`, `pause`, `unpause` and `rename` cause a repaint. `kill`, `stop` and
+  `create` would redraw a frame identical to the one already on screen, and `exec_` and `health_` events
+  are the container's own internals
+- Polling stays as a safety net: `docker ps` every 30 seconds, and every 3 seconds while Docker is
+  stopped so that starting Docker Desktop from the tray shows up at once
+- The event stream is reopened when its process exits, which it does loudly: about thirty seconds of
+  silence, then `unexpected EOF` and exit code 1. Reopening waits for `docker ps` to answer, so no
+  process is spawned for as long as Docker stays down
+- `intervalMs` is gone. It controlled how often the panel ran `docker ps`, and events make that
+  meaningless; leaving it in a config is harmless
+- Two container changes in quick succession no longer lose the second one, and simultaneous refreshes
+  can no longer apply out of order
+- `Stop Docker Desktop` hides the `Up stack` line the moment it is pressed rather than after the
+  command finishes
+
 ## 0.5.1 - 2026-10-08
 
 - The repository is formatted with prettier, with a config that matches the existing style: no semicolons,

package/README.md

@@ -35,7 +35,7 @@ whatever is already in it.
 ```jsonc
 {
   "$schema": "https://opencode.ai/v2/cli.json",
-  "plugins": [{ "package": "opencode-docker-panel", "options": { "intervalMs": 3000 } }],
+  "plugins": ["opencode-docker-panel"],
 }
 ```
 
@@ -49,7 +49,7 @@ Two things trip people up here, so they are worth stating plainly:
 Restart the TUI afterwards. The host installs the package on the next start; nothing to copy and
 nothing to build.
 
-Pin a version when you want a known state: `{ "package": "opencode-docker-panel@0.5.0" }`.
+Pin a version when you want a known state: `{ "package": "opencode-docker-panel@0.6.0" }`.
 
 ### Verification
 
@@ -71,9 +71,13 @@ If the header never appears, the plugin did not load: check that the entry is in
 
 ## Options
 
-| Option       | Default | Notes                                 |
-| ------------ | ------- | ------------------------------------- |
-| `intervalMs` | `3000`  | Poll interval, clamped to 1000..60000 |
+There are none. The panel follows Docker's own event stream, so there is nothing to configure and
+nothing to tune. It still polls as a safety net every 30 seconds, and every 3 seconds while Docker is
+stopped so that starting Docker Desktop from the tray shows up right away.
+
+Before `0.6.0` there was an `intervalMs` option. It controlled how often the panel ran `docker ps`,
+and it no longer does anything: events carry the updates and the poll is only a net. Leaving it in
+your config is harmless.
 
 Everything else lives in [docs/features.md](docs/features.md).
 

package/README.ru.md

@@ -33,7 +33,7 @@ https://github.com/victor-ochenin/opencodeDockerPlugin#installation
 ```jsonc
 {
   "$schema": "https://opencode.ai/v2/cli.json",
-  "plugins": [{ "package": "opencode-docker-panel", "options": { "intervalMs": 3000 } }],
+  "plugins": ["opencode-docker-panel"],
 }
 ```
 
@@ -44,7 +44,7 @@ https://github.com/victor-ochenin/opencodeDockerPlugin#installation
 
 После этого перезапусти TUI: хост сам поставит пакет при следующем старте, копировать и собирать ничего не нужно.
 
-Если нужна зафиксированная версия, укажи её явно: `{ "package": "opencode-docker-panel@0.5.0" }`.
+Если нужна зафиксированная версия, укажи её явно: `{ "package": "opencode-docker-panel@0.6.0" }`.
 
 ### Проверка
 
@@ -61,9 +61,13 @@ CLI-проверки у этого плагина нет: он рисуется
 
 ## Опции
 
-| Опция        | По умолчанию | Примечания                                             |
-| ------------ | ------------ | ------------------------------------------------------ |
-| `intervalMs` | `3000`       | Интервал опроса, ограничивается диапазоном 1000..60000 |
+Их нет. Панель следует за потоком событий самого Docker, поэтому настраивать и подкручивать нечего.
+Опрос при этом остался как страховка: раз в 30 секунд и раз в 3 секунды, пока Docker выключен, чтобы
+запуск Docker Desktop из трея был виден сразу.
+
+До `0.6.0` была опция `intervalMs`. Она задавала, как часто панель запускает `docker ps`, и больше
+ничего не делает: обновления приходят по событиям, а опрос только страхует. Если она осталась у тебя
+в конфиге, это безвредно.
 
 Всё остальное — в [docs/features.ru.md](docs/features.ru.md).
 

package/dist/events.js

@@ -0,0 +1,103 @@
+import { spawn } from "node:child_process";
+const COMMAND = "docker";
+const ARGS = ["events", "--filter", "type=container", "--format", "{{json .}}"];
+
+/**
+ * The actions that can change what the panel draws.
+ *
+ * `kill` is left out because it arrives as a pair ahead of `stop` and `die` and changes nothing on its
+ * own. `create` is out because the container stays `created` for the half second before `start` and the
+ * panel draws no row for that state. `stop` is out because `docker ps` already reports `exited` by the
+ * time it arrives. `restart` is out because a measured `docker restart` sends `die` and `start` first,
+ * which bracket the whole visible change, so it would repeat the frame `start` just produced.
+ * Everything with an `exec_` or `health_` prefix is the container's internals and never reaches the panel.
+ */
+export const INTERESTING_ACTIONS = ["start", "die", "destroy", "pause", "unpause", "rename"];
+/** Returns the container name an event is about, or null when the panel has no reason to react */
+export function parseEventLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+  let raw;
+  try {
+    raw = JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+  if (typeof raw !== "object" || raw === null) return null;
+  const event = raw;
+  if (event.Type !== "container") return null;
+  const action = String(event.Action ?? event.status ?? "");
+  if (!INTERESTING_ACTIONS.includes(action)) return null;
+  const name = event.Actor?.Attributes?.name;
+  return typeof name === "string" && name.length > 0 ? name : null;
+}
+/**
+ * A long-lived `docker events` reader.
+ *
+ * The stream ends loudly rather than going quiet: stopping Docker Desktop leaves it silent for about
+ * thirty seconds and then writes `unexpected EOF` and exits with code 1. So the caller is told when the
+ * process is gone and decides on its own when reopening is worth the attempt.
+ */
+export function createEventWatch() {
+  let child;
+  let buffer = "";
+  let closed = false;
+  let consumer;
+  let onDead;
+  const open = () => {
+    if (closed) return;
+    const spawned = spawn(COMMAND, ARGS, {
+      windowsHide: true,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    child = spawned;
+    // A docker that is not on the PATH makes spawn emit an error, and an unheard one throws
+    spawned.on("error", () => {});
+    // A half-written line from the killed process would prepend itself to the new process's first
+    // chunk and take that first event down with it
+    buffer = "";
+    spawned.stdout?.setEncoding("utf8");
+    spawned.stdout?.on("data", chunk => {
+      // The last split piece is a partial line and has to survive to the next chunk
+      const lines = (buffer + chunk).split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!parseEventLine(line)) continue;
+        consumer?.();
+      }
+    });
+    // Only the process still in hand gets to speak for the stream, and killing one is asynchronous, so
+    // after a restart the previous child still reports in. Trusting that report would drop the live
+    // child's reference, orphan the process and fake a dead stream. The same check covers our own stop,
+    // which clears `child` before killing.
+    spawned.on("close", () => {
+      if (child !== spawned) return;
+      child = undefined;
+      onDead?.();
+    });
+  };
+  const stop = () => {
+    const current = child;
+    child = undefined;
+    current?.kill();
+  };
+  open();
+  return {
+    onEvent: onChange => {
+      consumer = onChange;
+    },
+    onDead: handler => {
+      onDead = handler;
+    },
+    restart: () => {
+      stop();
+      open();
+    },
+    close: () => {
+      closed = true;
+      consumer = undefined;
+      onDead = undefined;
+      stop();
+    }
+  };
+}

package/dist/panel.js

@@ -227,9 +227,10 @@ export function DockerPanel(props) {
   const engine = createEngineProbe();
   // The probe only has to be re-read when the poll changes its verdict: an available docker proves the
   // engine answers, and a probe on every poll would stack several four second calls on the same pipe,
-  // while never re-reading it would leave a stale stopped engine once docker starts from the tray
+  // while never re-reading it would leave a stale stopped engine once docker starts from the tray, which
+  // poll.ts covers by keeping the poll fast while the last answer said stopped
   let lastKind = "";
-  const polling = createDockerPolling(props.intervalMs, props.reload, next => {
+  const polling = createDockerPolling(props.reload, next => {
     refreshStack();
     if (next.kind === lastKind) return;
     lastKind = next.kind;
@@ -647,7 +648,7 @@ export function DockerPanel(props) {
     }), null);
     _$insert(_el$18, _$createComponent(Show, {
       get when() {
-        return _$memo(() => !!pendingStack())() && !engineDown();
+        return _$memo(() => !!(pendingStack() && !engineDown()))() && !stopping();
       },
       get children() {
         var _el$42 = _$createElement("text"),

package/dist/poll.js

@@ -1,4 +1,5 @@
 import { createSignal, onCleanup } from "solid-js";
+import { createEventWatch } from "./events.js";
 import { runDockerPs } from "./docker.js";
 import { runDesktopStatus } from "./runtime.js";
 const INITIAL = {
@@ -10,6 +11,22 @@ const INITIAL = {
 /** docker reports the old state for a moment after start or stop, so an action is polled twice */
 const SETTLE_MS = 1200;
 
+/**
+ * Events drive the panel now, so this is only the net for the case where docker says nothing at all:
+ * a container changed outside anything we would hear about, or the stream is gone and the engine has
+ * come back since the last attempt.
+ */
+export const FALLBACK_INTERVAL_MS = 30000;
+
+/**
+ * Nothing can change while the engine is down, so a start from the tray is the one thing worth waiting
+ * on closely, and the engine probe has no timer of its own to notice it.
+ */
+const ENGINE_DOWN_RETRY_MS = 3000;
+export function fallbackDelayMs(kind) {
+  return kind === "stopped" ? ENGINE_DOWN_RETRY_MS : FALLBACK_INTERVAL_MS;
+}
+
 /**
  * A Docker Desktop cold start boots a virtual machine, which takes a minute and answers `unknown` while
  * it goes. Polling faster than the container loop is what makes the panel notice it came up at all,
@@ -39,6 +56,13 @@ export function selectRows(all, pinned) {
   const running = all.filter(item => !isPinned(item) && item.state === "running");
   return [...fixed, ...running.slice(0, Math.max(0, MAX_RUNNING - fixed.length))];
 }
+/**
+ * A stream that has closed is only worth reopening once docker answers again. Reopening while the
+ * engine is down would spawn a process that cannot work, every tick, for as long as the engine is off.
+ */
+export function shouldReconnect(kind, streamAlive) {
+  return !streamAlive && (kind === "ok" || kind === "empty");
+}
 /**
  * The engine has its own probe because `docker ps` cannot report it: on a stopped engine the ps call
  * fails to connect and says only `unavailable`, which is also what a missing CLI or a locked socket
@@ -93,17 +117,26 @@ function signature(containers) {
 
 /** A container in a crash loop changes state on every poll and each remount costs a fresh docker ps */
 const RELOAD_COOLDOWN_MS = 10000;
-export function createDockerPolling(intervalMs, onContentChange, onPoll) {
+export function createDockerPolling(onContentChange, onPoll) {
   const [state, setState] = createSignal(INITIAL);
   let timer;
   let settle;
   let disposed = false;
-  let last = "";
-  let seen = false;
+  let shown = "";
+  let mounted = false;
   let reloadedAt = 0;
-  const refresh = async () => {
-    const next = await runDockerPs();
+
+  /**
+   * `shown` is what the host has been told, not what was last seen. A change that arrives inside the
+   * cooldown has to stay owed rather than be written off, because the signature would match on every
+   * later poll and nothing would ever deliver it.
+   */
+  const apply = next => {
     if (disposed) return;
+    if (shouldReconnect(next.kind, streamAlive)) {
+      streamAlive = true;
+      events.restart();
+    }
     const visible = keepContainers(state().containers, next);
     setState({
       ...next,
@@ -112,26 +145,58 @@ export function createDockerPolling(intervalMs, onContentChange, onPoll) {
     onPoll?.(next);
     if (next.kind === "unavailable" || next.kind === "stale") return;
     const current = signature(visible);
-    if (current === last) return;
-    last = current;
-    if (!seen) {
-      seen = true;
+    if (!mounted) {
+      mounted = true;
+      shown = current;
       return;
     }
+    if (current === shown) return;
     if (Date.now() - reloadedAt < RELOAD_COOLDOWN_MS) return;
+    shown = current;
     reloadedAt = Date.now();
     onContentChange();
   };
+
+  /**
+   * One `docker ps` at a time. Events arrive faster than a ps call returns, and without this the older
+   * result lands last and overwrites the newer one. A call that arrives while one is in flight asks for
+   * one more pass instead of starting a parallel one, the same guard `createEngineProbe` uses.
+   */
+  let reading = false;
+  let reread = false;
+  const refresh = async () => {
+    if (reading) {
+      reread = true;
+      return;
+    }
+    reading = true;
+    try {
+      do {
+        reread = false;
+        apply(await runDockerPs());
+      } while (reread && !disposed);
+    } finally {
+      reading = false;
+    }
+  };
+  const events = createEventWatch();
+  let streamAlive = true;
+  events.onEvent(() => void refresh());
+  events.onDead(() => {
+    streamAlive = false;
+  });
   const tick = async () => {
     await refresh();
     if (disposed) return;
-    timer = setTimeout(tick, intervalMs);
+    timer = setTimeout(tick, fallbackDelayMs(state().kind));
   };
   void tick();
   onCleanup(() => {
     disposed = true;
     if (timer) clearTimeout(timer);
     if (settle) clearTimeout(settle);
+    // A docker events process outlives the panel otherwise and stays in the task list
+    events.close();
   });
   return {
     state,

package/dist/tui.js

@@ -1,12 +1,8 @@
 import { createComponent as _$createComponent } from "@opentui/solid";
 import { DockerPanel } from "./panel.js";
-const MIN_INTERVAL = 1000;
-const MAX_INTERVAL = 60000;
 const plugin = {
   id: "docker.panel.cli",
   setup(context) {
-    const requested = Number(context.options.intervalMs);
-    const intervalMs = Number.isFinite(requested) ? Math.min(Math.max(requested, MIN_INTERVAL), MAX_INTERVAL) : 3000;
     const agentDir = context.location?.directory ?? process.cwd();
     const [pinned, setPinned] = context.storage.store("docker-panel.pinned", {
       initial: {
@@ -33,7 +29,6 @@ const plugin = {
     const claim = {
       append: "sidebar.content",
       render: () => _$createComponent(DockerPanel, {
-        intervalMs: intervalMs,
         agentDir: agentDir,
         get pinned() {
           return pinned.names;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-docker-panel",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "Docker container panel for the OpenCode 2 TUI sidebar",
   "keywords": [
     "opencode",