opencode-docker-panel 0.4.8 → 0.5.1

package/dist/panel.js

@@ -6,15 +6,16 @@ import { createTextNode as _$createTextNode } from "@opentui/solid";
 import { insertNode as _$insertNode } from "@opentui/solid";
 import { setProp as _$setProp } from "@opentui/solid";
 import { createElement as _$createElement } from "@opentui/solid";
-import { Index, Show, createSignal, onCleanup } from "solid-js";
+import { Index, Show, createEffect, createSignal, onCleanup } from "solid-js";
 import { ACTION_LABEL, availableActions, buildArgs, runDockerArgs } from "./commands.js";
 import { findComposeFile } from "./compose.js";
 import { runDockerLogs } from "./logs.js";
-import { createDockerPolling, selectRows } from "./poll.js";
+import { createDockerPolling, createEngineProbe, selectRows } from "./poll.js";
+import { ENGINE_ACTION_LABEL, buildRuntimeArgs } from "./runtime.js";
 const LOG_VIEW_LINES = 15;
 const LOG_REFRESH_MS = 2000;
 
-/** The argv a stack needs, in one place so the menu footer and the run cannot drift apart. */
+/** One source for the argv, so the menu footer and the run cannot drift apart */
 function stackArgs(target) {
   return ["compose", "-f", target.file, "-p", target.project, "up", "-d"];
 }
@@ -37,7 +38,7 @@ function hasStaleRows(state) {
   return (state.kind === "unavailable" || state.kind === "stale") && state.containers.length > 0;
 }
 
-/** A fixed viewport is the only way to keep the height predictable: opentui has no scrollable container. */
+/** Fixed viewport: opentui has no scrollable container, so the height has to be predictable */
 function LogsView(props) {
   const lines = () => props.result?.lines ?? [];
   const end = () => Math.max(0, lines().length - props.offset);
@@ -161,6 +162,7 @@ function LogsView(props) {
 export function DockerPanel(props) {
   const [open, setOpen] = createSignal(true);
   const [busy, setBusy] = createSignal(false);
+  const [stopping, setStopping] = createSignal(false);
   const [logs, setLogs] = createSignal(null);
   const [offset, setOffset] = createSignal(0);
   const theme = () => props.theme;
@@ -222,22 +224,45 @@ export function DockerPanel(props) {
     if (logTimer) clearInterval(logTimer);
     if (logs()) props.ui.dialog.clear();
   });
+  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
+  let lastKind = "";
+  const polling = createDockerPolling(props.intervalMs, props.reload, next => {
+    refreshStack();
+    if (next.kind === lastKind) return;
+    lastKind = next.kind;
+    void engine.refresh();
+  });
+
+  // A stop the container poll could see beats a probe that has not answered yet: the poll knows the
+  // Desktop pipe is missing in a quarter second, the probe needs four seconds to admit the same
+  const engineDown = () => polling.state().kind === "stopped" || engine.state() === "stopped";
 
-  // Read the compose file when the panel mounts and again on every poll, never while the host is
-  // assembling the render tree.
+  // Read on mount and on every poll, never while the host assembles the render tree
   const [stackSignal, setStackSignal] = createSignal(null);
   const [pendingStack, setPendingStack] = createSignal(null);
   const derivePendingStack = stack => {
-    setPendingStack(stack && !polling.state().containers.some(item => item.composeProject === stack.project) ? stack : null);
+    setPendingStack(stack && !engineDown() && !polling.state().containers.some(item => item.composeProject === stack.project) ? stack : null);
   };
   const refreshStack = () => {
     const stack = findComposeFile(props.agentDir);
     setStackSignal(stack);
     derivePendingStack(stack);
   };
-  const polling = createDockerPolling(props.intervalMs, props.reload, refreshStack);
 
-  /** One entry point for every action, so the busy guard and the refresh cannot be forgotten. */
+  // A stopped engine makes every `docker logs` call fail, so the window keeps its last lines and the
+  // polling stops rather than spawning a doomed process every two seconds
+  createEffect(() => {
+    const state = engine.state();
+    if (state === "stopped" || state === "absent") {
+      if (logTimer) clearInterval(logTimer);
+      logTimer = undefined;
+    }
+  });
+
+  /** Single entry point, so the busy guard and the refresh cannot be skipped */
   const run = async (action, title, args) => {
     if (busy()) return;
     setBusy(true);
@@ -250,53 +275,111 @@ export function DockerPanel(props) {
     });
     await polling.refreshAfterAction();
   };
-
-  /**
-   * The stack the agent directory declares, but only while none of its containers is on the machine.
-   * Computed once per poll instead of inside the markup: a `Show` and its own label both read this,
-   * and re-deriving it during render is what the crash traced back to.
+  /**
+   * 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.
    */
-
-  /** The list of every container, from which picking one opens the same actions as its row does. */
   const pickContainer = async all => {
-    const choice = await props.ui.dialog.select({
+    const action = engine.state() === "running" ? "engine-stop" : undefined;
+    const pending = props.ui.dialog.select({
       title: `All containers (${all.length})`,
       placeholder: "Container",
-      options: all.map(container => ({
+      options: [...all.map(container => ({
         title: container.name,
-        value: container,
+        value: {
+          kind: "container",
+          container
+        },
         description: detailLabel(container, props.pinned),
         footer: container.state
-      }))
+      })), ...(action ? [{
+        title: ENGINE_ACTION_LABEL[action],
+        value: {
+          kind: "action",
+          action
+        },
+        description: "stops every container of every project",
+        footer: `docker ${buildRuntimeArgs(action).join(" ")}`
+      }] : [])]
     });
+    props.ui.dialog.set({
+      size: "large"
+    });
+    const choice = await pending;
     if (!choice) return;
-    // The list is a snapshot: a container can stop while it is open, so re-read it before offering actions.
-    const fresh = polling.state().containers.find(item => item.name === choice.name);
+    if (choice.kind === "action") {
+      await runRuntime(choice.action);
+      return;
+    }
+    // The list is a snapshot, a container can stop while it is open, so re-read before acting
+    const fresh = polling.state().containers.find(item => item.name === choice.container.name);
     if (fresh) await openMenu(fresh);
   };
 
-  /**
-   * The single door to the containers the sidebar does not show. Clicking the header lands on the
-   * list itself, so there is no menu to pick through first.
-   */
+  /** Single door to the containers the sidebar does not show, so the header opens the list itself */
   const openBrowse = async () => {
     if (busy()) return;
-    const all = polling.state().containers;
-    if (all.length === 0) {
+    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.
+   */
+  const runRuntime = async action => {
+    if (busy()) return;
+    const args = buildRuntimeArgs(action);
+    const title = ENGINE_ACTION_LABEL[action];
+    if (action === "engine-stop") {
+      const running = polling.state().containers.filter(item => item.state === "running");
+      const names = running.length > 0 ? running.map(item => item.name).join(", ") : "nothing the panel knows about";
+      const confirmed = await props.ui.dialog.confirm({
+        title: "Stop Docker Desktop?",
+        message: `Stops the engine, so every container stops with it. Visible to the panel: ${names}.\n\nNot reversible from the panel.`,
+        label: {
+          confirm: "Stop",
+          cancel: "Cancel"
+        }
+      });
+      if (!confirmed) return;
+    } else {
+      const confirmed = await props.ui.dialog.confirm({
+        title: "Start Docker Desktop?",
+        message: `Brings up the engine and its virtual machine.\n\ndocker ${args.join(" ")}`,
+        label: {
+          confirm: "Start",
+          cancel: "Cancel"
+        }
+      });
+      if (!confirmed) return;
+    }
+    // The containers are about to go, so the rows go with them instead of staying on screen for a
+    // poll or two while the engine finishes shutting down
+    if (action === "engine-stop") setStopping(true);
+    setBusy(true);
+    try {
+      const result = await runDockerArgs(args);
       props.ui.toast.show({
-        title: "Docker",
-        message: "no containers",
-        variant: "info"
+        title,
+        message: result.ok ? `${title}: ${result.message}` : result.message,
+        variant: result.ok ? "success" : "error"
       });
-      return;
+      // busy stays on for the whole transition, otherwise working disappears while the VM boots
+      // A command that failed will never bring the engine up, and waiting for one costs two minutes
+      if (action === "engine-start" && result.ok) await engine.waitForRunning();
+      await polling.refreshAfterAction();
+    } finally {
+      setStopping(false);
+      setBusy(false);
     }
-    await pickContainer(all);
   };
 
-  /**
-   * A stack has no container to be the subject of the action, and its file carries build, command and
-   * entrypoint, so it asks once and shows the exact argv in the prompt.
-   */
+  /** A stack has no container to act on and its file carries build and command lines, so confirm with the exact argv */
   const openStack = async () => {
     if (busy()) return;
     const stack = pendingStack();
@@ -315,7 +398,7 @@ export function DockerPanel(props) {
   const openMenu = async container => {
     if (busy()) return;
     const isPinned = props.pinned.includes(container.name);
-    // Read once per menu: compose can build images, so the action must not wait on a second read.
+    // Read once per menu, compose can build images and the action must not wait on a second read
     const stack = stackSignal()?.project === container.composeProject ? stackSignal() : null;
     const options = [...availableActions(container, stack).map(item => ({
       title: ACTION_LABEL[item],
@@ -334,11 +417,15 @@ export function DockerPanel(props) {
       footer: "stored by the host, survives a restart"
     }];
     try {
-      const choice = await props.ui.dialog.select({
+      const pending = props.ui.dialog.select({
         title: container.name,
         placeholder: "Action",
         options
       });
+      props.ui.dialog.set({
+        size: "large"
+      });
+      const choice = await pending;
       if (!choice) return;
       if (choice === "logs") {
         openLogs(container);
@@ -375,14 +462,17 @@ export function DockerPanel(props) {
   };
 
   // A click in opentui is a mousedown plus a mouseup, and the host dismisses an overlay from the
-  // next mouse event it sees. Every dialog is therefore armed on the release, and only mounted after
-  // that release has finished propagating, so the release cannot land on its own backdrop.
+  // next mouse event it sees, so every dialog is armed on the release and mounted after it propagates
   const arm = (open, event) => {
     event.stopPropagation();
     setTimeout(() => void open(), 0);
   };
-  const visible = () => selectRows(polling.state().containers, props.pinned);
+  const visible = () => stopping() ? [] : selectRows(polling.state().containers, props.pinned);
   const hasRows = () => visible().length > 0;
+  const hidden = () => Math.max(0, polling.state().containers.length - visible().length);
+  // The line stays when nothing is hidden because it is also the only way into the list, which is where
+  // stopping the engine lives
+  const browseLabel = () => hidden() > 0 ? `${hidden()} more, click for all` : `${polling.state().containers.length} container${polling.state().containers.length === 1 ? "" : "s"}, click for all`;
   const pressHeader = () => {
     if (hasRows()) {
       setOpen(value => !value);
@@ -404,7 +494,7 @@ export function DockerPanel(props) {
     _$insertNode(_el$21, _$createTextNode(`Docker`));
     _$insert(_el$20, _$createComponent(Show, {
       get when() {
-        return polling.state().containers.length > 0;
+        return _$memo(() => !!!stopping())() && polling.state().containers.length > 0;
       },
       get children() {
         var _el$23 = _$createElement("span"),
@@ -419,52 +509,80 @@ export function DockerPanel(props) {
         return _el$23;
       }
     }), null);
-    _$insert(_el$20, _$createComponent(Show, {
+    _$insert(_el$19, _$createComponent(Show, {
       get when() {
-        return _$memo(() => !!!hasRows())() && polling.state().containers.length > 0;
+        return hasStaleRows(polling.state());
       },
       get children() {
-        var _el$26 = _$createElement("span");
-        _$insertNode(_el$26, _$createTextNode(` click for the list`));
-        _$effect(_$p => _$setProp(_el$26, "style", {
-          fg: theme().text.muted
-        }, _$p));
+        var _el$26 = _$createElement("text");
+        _$insertNode(_el$26, _$createTextNode(` stale`));
+        _$effect(_$p => _$setProp(_el$26, "fg", theme().text.feedback.warning.base, _$p));
         return _el$26;
       }
     }), null);
     _$insert(_el$19, _$createComponent(Show, {
       get when() {
-        return hasStaleRows(polling.state());
+        return busy();
       },
       get children() {
         var _el$28 = _$createElement("text");
-        _$insertNode(_el$28, _$createTextNode(` stale`));
-        _$effect(_$p => _$setProp(_el$28, "fg", theme().text.feedback.warning.base, _$p));
+        _$insertNode(_el$28, _$createTextNode(` working`));
+        _$effect(_$p => _$setProp(_el$28, "fg", theme().text.muted, _$p));
         return _el$28;
       }
     }), null);
-    _$insert(_el$19, _$createComponent(Show, {
+    _$insert(_el$18, _$createComponent(Show, {
       get when() {
-        return busy();
+        return _$memo(() => !!(!stopping() && !hasRows()))() && polling.state().containers.length > 0;
       },
       get children() {
-        var _el$30 = _$createElement("text");
-        _$insertNode(_el$30, _$createTextNode(` working`));
+        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;
       }
     }), null);
     _$insert(_el$18, _$createComponent(Show, {
       get when() {
-        return _$memo(() => polling.state().containers.length === 0)() && polling.state().detail.length > 0;
+        return _$memo(() => !!engineDown())() && !busy();
+      },
+      get children() {
+        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$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$33;
+      }
+    }), null);
+    _$insert(_el$18, _$createComponent(Show, {
+      get when() {
+        return _$memo(() => !!(!engineDown() && polling.state().containers.length === 0))() && polling.state().detail.length > 0;
       },
       get children() {
-        var _el$32 = _$createElement("text"),
-          _el$33 = _$createTextNode(` `);
-        _$insertNode(_el$32, _el$33);
-        _$insert(_el$32, () => polling.state().detail, null);
-        _$effect(_$p => _$setProp(_el$32, "fg", theme().text.muted, _$p));
-        return _el$32;
+        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, {
@@ -477,88 +595,86 @@ export function DockerPanel(props) {
             return visible();
           },
           children: container => (() => {
-            var _el$43 = _$createElement("box"),
-              _el$44 = _$createElement("text"),
-              _el$46 = _$createElement("text"),
-              _el$47 = _$createTextNode(` `),
-              _el$48 = _$createElement("span");
-            _$insertNode(_el$43, _el$44);
-            _$insertNode(_el$43, _el$46);
-            _$setProp(_el$43, "flexDirection", "row");
-            _$setProp(_el$43, "gap", 1);
-            _$setProp(_el$43, "onMouseUp", event => arm(() => openMenu(container()), event));
-            _$insertNode(_el$44, _$createTextNode(`•`));
-            _$setProp(_el$44, "flexShrink", 0);
-            _$insertNode(_el$46, _el$47);
-            _$insertNode(_el$46, _el$48);
-            _$setProp(_el$46, "wrapMode", "word");
-            _$insert(_el$46, () => container().name, _el$47);
-            _$insert(_el$48, () => 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$8 = dotColor(theme(), container().state),
-                _v$9 = theme().text.base,
-                _v$0 = {
+              var _v$0 = dotColor(theme(), container().state),
+                _v$1 = theme().text.base,
+                _v$10 = {
                   fg: theme().text.muted
                 };
-              _v$8 !== _p$.e && (_p$.e = _$setProp(_el$44, "fg", _v$8, _p$.e));
-              _v$9 !== _p$.t && (_p$.t = _$setProp(_el$46, "fg", _v$9, _p$.t));
-              _v$0 !== _p$.a && (_p$.a = _$setProp(_el$48, "style", _v$0, _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$43;
+            return _el$48;
           })()
         }), _$createComponent(Show, {
           get when() {
-            return _$memo(() => !!hasRows())() && polling.state().containers.length > visible().length;
+            return hasRows();
           },
           get children() {
-            var _el$34 = _$createElement("text"),
-              _el$35 = _$createTextNode(` `),
-              _el$36 = _$createTextNode(` more, click for all`);
-            _$insertNode(_el$34, _el$35);
-            _$insertNode(_el$34, _el$36);
-            _$setProp(_el$34, "onMouseUp", event => arm(openBrowse, event));
-            _$insert(_el$34, () => polling.state().containers.length - visible().length, _el$36);
-            _$effect(_$p => _$setProp(_el$34, "fg", theme().text.muted, _$p));
-            return _el$34;
+            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 pendingStack();
+        return _$memo(() => !!pendingStack())() && !engineDown();
       },
       get children() {
-        var _el$37 = _$createElement("text"),
-          _el$38 = _$createElement("b"),
-          _el$40 = _$createElement("span"),
-          _el$41 = _$createTextNode(` · `),
-          _el$42 = _$createTextNode(` is not running here`);
-        _$insertNode(_el$37, _el$38);
-        _$insertNode(_el$37, _el$40);
-        _$setProp(_el$37, "onMouseUp", event => arm(() => void openStack(), event));
-        _$insertNode(_el$38, _$createTextNode(`Up stack`));
-        _$insertNode(_el$40, _el$41);
-        _$insertNode(_el$40, _el$42);
-        _$insert(_el$40, () => pendingStack()?.project, _el$42);
+        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$6 = theme().text.base,
-            _v$7 = {
+          var _v$8 = theme().text.base,
+            _v$9 = {
               fg: theme().text.muted
             };
-          _v$6 !== _p$.e && (_p$.e = _$setProp(_el$37, "fg", _v$6, _p$.e));
-          _v$7 !== _p$.t && (_p$.t = _$setProp(_el$40, "style", _v$7, _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$37;
+        return _el$42;
       }
     }), null);
     _$effect(_$p => _$setProp(_el$20, "fg", theme().text.base, _$p));

package/dist/poll.js

@@ -1,24 +1,37 @@
 import { createSignal, onCleanup } from "solid-js";
 import { runDockerPs } from "./docker.js";
+import { runDesktopStatus } from "./runtime.js";
 const INITIAL = {
   kind: "empty",
   containers: [],
   detail: "loading"
 };
 
-/** docker reports the old state for a moment after start or stop, so an action is polled twice. */
+/** 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.
+ */
+export const ENGINE_TRANSITION_MS = 2000;
+export const ENGINE_DEADLINE_MS = 120000;
 export function keepContainers(previous, next) {
+  // A stopped engine is not a blip, it means every container really is down, so the rows go rather than
+  // linger as a lie. Only a poll that could not reach docker keeps what was known
   if (next.kind === "unavailable" || next.kind === "stale") return previous;
   return next.containers;
 }
 
-/** The sidebar belongs to what runs right now, so it shows five running containers and nothing else. */
+/** 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);
@@ -26,12 +39,59 @@ 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 host does not repaint this slot when only a signal changes, so the panel is remounted on a real change. */
+/**
+ * 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.
+   */
+  const refresh = async () => {
+    if (probing) return state();
+    probing = true;
+    try {
+      const next = await runDesktopStatus();
+      if (!disposed) setState(next);
+      return next;
+    } finally {
+      probing = false;
+    }
+  };
+  onCleanup(() => {
+    disposed = true;
+  });
+
+  /** Polls on a deadline rather than on a timer, so disposal has nothing to cancel */
+  const waitForRunning = async (deadlineMs = ENGINE_DEADLINE_MS) => {
+    const until = Date.now() + deadlineMs;
+    for (;;) {
+      if ((await refresh()) === "running") return true;
+      if (disposed || Date.now() >= until) return false;
+      await new Promise(resolve => setTimeout(resolve, ENGINE_TRANSITION_MS));
+    }
+  };
+  void refresh();
+  return {
+    state,
+    refresh,
+    waitForRunning
+  };
+}
+
+/** The host does not repaint this slot when only a signal changes, so a real change remounts the panel */
 function signature(containers) {
   return containers.map(item => `${item.name}:${item.state}`).join("|");
 }
 
-/** A container in a crash loop changes state on every poll, and each remount costs a fresh docker ps. */
+/** 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) {
   const [state, setState] = createSignal(INITIAL);
@@ -49,7 +109,7 @@ export function createDockerPolling(intervalMs, onContentChange, onPoll) {
       ...next,
       containers: visible
     });
-    onPoll?.();
+    onPoll?.(next);
     if (next.kind === "unavailable" || next.kind === "stale") return;
     const current = signature(visible);
     if (current === last) return;