opencode-docker-panel 0.5.0 → 0.6.0

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;
@@ -275,12 +276,12 @@ export function DockerPanel(props) {
     });
     await polling.refreshAfterAction();
   };
-  /**
-   * Opens the same actions for a container the sidebar does not show, and carries the one engine
-   * action last.
-   *
-   * The engine entry stays available with no containers at all, because that is exactly when Docker is
-   * down and it is the only way to turn it back on.
+  /**
+   * Opens the same actions for a container the sidebar does not show, and carries the one engine
+   * action last.
+   *
+   * The engine entry stays available with no containers at all, because that is exactly when Docker is
+   * down and it is the only way to turn it back on.
    */
   const pickContainer = async all => {
     const action = engine.state() === "running" ? "engine-stop" : undefined;
@@ -325,11 +326,11 @@ export function DockerPanel(props) {
     await pickContainer(polling.state().containers);
   };
 
-  /**
-   * Both engine actions ask first, and Stop names what it is about to end.
-   *
-   * Start confirms too: it brings up a virtual machine and starts consuming memory, so a misclick is
-   * not free even though nothing is running that it would interrupt.
+  /**
+   * Both engine actions ask first, and Stop names what it is about to end.
+   *
+   * Start confirms too: it brings up a virtual machine and starts consuming memory, so a misclick is
+   * not free even though nothing is running that it would interrupt.
    */
   const runRuntime = async action => {
     if (busy()) return;
@@ -536,8 +537,9 @@ export function DockerPanel(props) {
         return _$memo(() => !!(!stopping() && !hasRows()))() && polling.state().containers.length > 0;
       },
       get children() {
-        var _el$30 = _$createElement("text");
-        _$insertNode(_el$30, _$createTextNode(` click for the list`));
+        var _el$30 = _$createElement("text"),
+          _el$31 = _$createTextNode(` click for the list`);
+        _$insertNode(_el$30, _el$31);
         _$setProp(_el$30, "onMouseUp", event => arm(openBrowse, event));
         _$effect(_$p => _$setProp(_el$30, "fg", theme().text.muted, _$p));
         return _el$30;
@@ -548,27 +550,27 @@ export function DockerPanel(props) {
         return _$memo(() => !!engineDown())() && !busy();
       },
       get children() {
-        var _el$32 = _$createElement("text"),
-          _el$33 = _$createElement("b"),
-          _el$35 = _$createElement("span");
-        _$insertNode(_el$32, _el$33);
-        _$insertNode(_el$32, _el$35);
-        _$setProp(_el$32, "onMouseUp", event => arm(() => void runRuntime("engine-start"), event));
-        _$insertNode(_el$33, _$createTextNode(`Start Docker Desktop`));
-        _$insertNode(_el$35, _$createTextNode(` · click to start`));
+        var _el$33 = _$createElement("text"),
+          _el$34 = _$createElement("b"),
+          _el$36 = _$createElement("span");
+        _$insertNode(_el$33, _el$34);
+        _$insertNode(_el$33, _el$36);
+        _$setProp(_el$33, "onMouseUp", event => arm(() => void runRuntime("engine-start"), event));
+        _$insertNode(_el$34, _$createTextNode(`Start Docker Desktop`));
+        _$insertNode(_el$36, _$createTextNode(` · click to start`));
         _$effect(_p$ => {
           var _v$6 = theme().text.base,
             _v$7 = {
               fg: theme().text.muted
             };
-          _v$6 !== _p$.e && (_p$.e = _$setProp(_el$32, "fg", _v$6, _p$.e));
-          _v$7 !== _p$.t && (_p$.t = _$setProp(_el$35, "style", _v$7, _p$.t));
+          _v$6 !== _p$.e && (_p$.e = _$setProp(_el$33, "fg", _v$6, _p$.e));
+          _v$7 !== _p$.t && (_p$.t = _$setProp(_el$36, "style", _v$7, _p$.t));
           return _p$;
         }, {
           e: undefined,
           t: undefined
         });
-        return _el$32;
+        return _el$33;
       }
     }), null);
     _$insert(_el$18, _$createComponent(Show, {
@@ -576,12 +578,12 @@ export function DockerPanel(props) {
         return _$memo(() => !!(!engineDown() && polling.state().containers.length === 0))() && polling.state().detail.length > 0;
       },
       get children() {
-        var _el$37 = _$createElement("text"),
-          _el$38 = _$createTextNode(` `);
-        _$insertNode(_el$37, _el$38);
-        _$insert(_el$37, () => polling.state().detail, null);
-        _$effect(_$p => _$setProp(_el$37, "fg", theme().text.muted, _$p));
-        return _el$37;
+        var _el$38 = _$createElement("text"),
+          _el$39 = _$createTextNode(` `);
+        _$insertNode(_el$38, _el$39);
+        _$insert(_el$38, () => polling.state().detail, null);
+        _$effect(_$p => _$setProp(_el$38, "fg", theme().text.muted, _$p));
+        return _el$38;
       }
     }), null);
     _$insert(_el$18, _$createComponent(Show, {
@@ -594,86 +596,86 @@ export function DockerPanel(props) {
             return visible();
           },
           children: container => (() => {
-            var _el$47 = _$createElement("box"),
-              _el$48 = _$createElement("text"),
-              _el$50 = _$createElement("text"),
-              _el$51 = _$createTextNode(` `),
-              _el$52 = _$createElement("span");
-            _$insertNode(_el$47, _el$48);
-            _$insertNode(_el$47, _el$50);
-            _$setProp(_el$47, "flexDirection", "row");
-            _$setProp(_el$47, "gap", 1);
-            _$setProp(_el$47, "onMouseUp", event => arm(() => openMenu(container()), event));
-            _$insertNode(_el$48, _$createTextNode(`•`));
-            _$setProp(_el$48, "flexShrink", 0);
-            _$insertNode(_el$50, _el$51);
-            _$insertNode(_el$50, _el$52);
-            _$setProp(_el$50, "wrapMode", "word");
-            _$insert(_el$50, () => container().name, _el$51);
-            _$insert(_el$52, () => detailLabel(container(), props.pinned));
+            var _el$48 = _$createElement("box"),
+              _el$49 = _$createElement("text"),
+              _el$51 = _$createElement("text"),
+              _el$52 = _$createTextNode(` `),
+              _el$53 = _$createElement("span");
+            _$insertNode(_el$48, _el$49);
+            _$insertNode(_el$48, _el$51);
+            _$setProp(_el$48, "flexDirection", "row");
+            _$setProp(_el$48, "gap", 1);
+            _$setProp(_el$48, "onMouseUp", event => arm(() => openMenu(container()), event));
+            _$insertNode(_el$49, _$createTextNode(`•`));
+            _$setProp(_el$49, "flexShrink", 0);
+            _$insertNode(_el$51, _el$52);
+            _$insertNode(_el$51, _el$53);
+            _$setProp(_el$51, "wrapMode", "word");
+            _$insert(_el$51, () => container().name, _el$52);
+            _$insert(_el$53, () => detailLabel(container(), props.pinned));
             _$effect(_p$ => {
               var _v$0 = dotColor(theme(), container().state),
                 _v$1 = theme().text.base,
                 _v$10 = {
                   fg: theme().text.muted
                 };
-              _v$0 !== _p$.e && (_p$.e = _$setProp(_el$48, "fg", _v$0, _p$.e));
-              _v$1 !== _p$.t && (_p$.t = _$setProp(_el$50, "fg", _v$1, _p$.t));
-              _v$10 !== _p$.a && (_p$.a = _$setProp(_el$52, "style", _v$10, _p$.a));
+              _v$0 !== _p$.e && (_p$.e = _$setProp(_el$49, "fg", _v$0, _p$.e));
+              _v$1 !== _p$.t && (_p$.t = _$setProp(_el$51, "fg", _v$1, _p$.t));
+              _v$10 !== _p$.a && (_p$.a = _$setProp(_el$53, "style", _v$10, _p$.a));
               return _p$;
             }, {
               e: undefined,
               t: undefined,
               a: undefined
             });
-            return _el$47;
+            return _el$48;
           })()
         }), _$createComponent(Show, {
           get when() {
             return hasRows();
           },
           get children() {
-            var _el$39 = _$createElement("text"),
-              _el$40 = _$createTextNode(` `);
-            _$insertNode(_el$39, _el$40);
-            _$setProp(_el$39, "onMouseUp", event => arm(openBrowse, event));
-            _$insert(_el$39, browseLabel, null);
-            _$effect(_$p => _$setProp(_el$39, "fg", theme().text.muted, _$p));
-            return _el$39;
+            var _el$40 = _$createElement("text"),
+              _el$41 = _$createTextNode(` `);
+            _$insertNode(_el$40, _el$41);
+            _$setProp(_el$40, "onMouseUp", event => arm(openBrowse, event));
+            _$insert(_el$40, browseLabel, null);
+            _$effect(_$p => _$setProp(_el$40, "fg", theme().text.muted, _$p));
+            return _el$40;
           }
         })];
       }
     }), null);
     _$insert(_el$18, _$createComponent(Show, {
       get when() {
-        return _$memo(() => !!pendingStack())() && !engineDown();
+        return _$memo(() => !!(pendingStack() && !engineDown()))() && !stopping();
       },
       get children() {
-        var _el$41 = _$createElement("text"),
-          _el$42 = _$createElement("b"),
-          _el$44 = _$createElement("span"),
-          _el$45 = _$createTextNode(` · `),
-          _el$46 = _$createTextNode(` is not running here`);
-        _$insertNode(_el$41, _el$42);
-        _$insertNode(_el$41, _el$44);
-        _$setProp(_el$41, "onMouseUp", event => arm(() => void openStack(), event));
-        _$insertNode(_el$42, _$createTextNode(`Up stack`));
-        _$insertNode(_el$44, _el$45);
-        _$insertNode(_el$44, _el$46);
-        _$insert(_el$44, () => pendingStack()?.project, _el$46);
+        var _el$42 = _$createElement("text"),
+          _el$43 = _$createElement("b"),
+          _el$45 = _$createElement("span"),
+          _el$46 = _$createTextNode(` · `),
+          _el$47 = _$createTextNode(` is not running here`);
+        _$insertNode(_el$42, _el$43);
+        _$insertNode(_el$42, _el$45);
+        _$setProp(_el$42, "onMouseUp", event => arm(() => void openStack(), event));
+        _$insertNode(_el$43, _$createTextNode(`Up stack`));
+        _$insertNode(_el$45, _el$46);
+        _$insertNode(_el$45, _el$47);
+        _$insert(_el$45, () => pendingStack()?.project, _el$47);
         _$effect(_p$ => {
           var _v$8 = theme().text.base,
             _v$9 = {
               fg: theme().text.muted
             };
-          _v$8 !== _p$.e && (_p$.e = _$setProp(_el$41, "fg", _v$8, _p$.e));
-          _v$9 !== _p$.t && (_p$.t = _$setProp(_el$44, "style", _v$9, _p$.t));
+          _v$8 !== _p$.e && (_p$.e = _$setProp(_el$42, "fg", _v$8, _p$.e));
+          _v$9 !== _p$.t && (_p$.t = _$setProp(_el$45, "style", _v$9, _p$.t));
           return _p$;
         }, {
           e: undefined,
           t: undefined
         });
-        return _el$41;
+        return _el$42;
       }
     }), null);
     _$effect(_$p => _$setProp(_el$20, "fg", theme().text.base, _$p));

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,10 +11,26 @@ const INITIAL = {
 /** docker reports the old state for a moment after start or stop, so an action is polled twice */
 const SETTLE_MS = 1200;
 
-/**
- * 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,
- * and the deadline is what stops a dead engine from holding `working` forever.
+/**
+ * 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,
+ * and the deadline is what stops a dead engine from holding `working` forever.
  */
 export const ENGINE_TRANSITION_MS = 2000;
 export const ENGINE_DEADLINE_MS = 120000;
@@ -27,11 +44,11 @@ export function keepContainers(previous, next) {
 /** The sidebar belongs to what runs right now, not to every container that exists */
 export const MAX_RUNNING = 5;
 
-/**
- * A pinned container is shown whatever its state and spends the running budget when it happens to
- * run, so pinning everything shows everything.
- *
- * Stopped containers get no row, the dialog is their only door.
+/**
+ * A pinned container is shown whatever its state and spends the running budget when it happens to
+ * run, so pinning everything shows everything.
+ *
+ * Stopped containers get no row, the dialog is their only door.
  */
 export function selectRows(all, pinned) {
   const isPinned = item => pinned.includes(item.name);
@@ -39,20 +56,27 @@ 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))];
 }
-/**
- * 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
- * produces. `docker desktop status` is the only thing that tells those apart.
+/**
+ * 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
+ * produces. `docker desktop status` is the only thing that tells those apart.
  */
 export function createEngineProbe() {
   const [state, setState] = createSignal("unknown");
   let disposed = false;
   let probing = false;
 
-  /**
-   * A stopped engine takes over four seconds to answer, which is longer than the container poll, so a
-   * probe per poll would leave several of them waiting on the same pipe at once. One at a time is the
-   * whole guard: a call that arrives while one is in flight reads the last known state instead.
+  /**
+   * A stopped engine takes over four seconds to answer, which is longer than the container poll, so a
+   * probe per poll would leave several of them waiting on the same pipe at once. One at a time is the
+   * whole guard: a call that arrives while one is in flight reads the last known state instead.
    */
   const refresh = async () => {
     if (probing) return state();
@@ -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;