opencode-docker-panel 0.4.8 → 0.5.1

package/dist/commands.js

@@ -10,12 +10,12 @@ export const ACTION_LABEL = {
   down: "Down compose project"
 };
 
-/** The name is passed after `--` because a container name may start with a dash and docker would read it as a flag. */
+/** The name goes after `--` because a container name may start with a dash and docker reads it as a flag */
 export function buildArgs(action, container, target) {
   if (action === "up") {
     if (!target) throw new Error(`container ${container.name} has no resolved compose target`);
-    // Both flags are explicit: the project name in the file can be templated or overridden by the
-    // environment, and this way `up` acts on the very project the panel is already showing.
+    // Both flags are explicit because the project's `name:` can be templated or overridden by the
+    // environment, and this way `up` acts on the project the panel is already showing
     return ["compose", "-f", target.file, "-p", target.project, "up", "-d"];
   }
   if (action === "down") {
@@ -26,7 +26,7 @@ export function buildArgs(action, container, target) {
   return [action, "--", container.name];
 }
 
-/** Only offers what docker accepts for the current state, with the destructive action last. */
+/** Only what docker accepts for the current state, with the destructive action last */
 export function availableActions(container, target) {
   const down = container.composeProject ? ["down"] : [];
   const up = container.composeProject && target ? ["up"] : [];
@@ -48,9 +48,11 @@ function firstLine(text) {
   if (!line) return "";
   return line.length > 80 ? `${line.slice(0, 77)}...` : line;
 }
-/**
- * Runs an already-built argument list. `up` has no container behind it, so the boundary takes the
- * argv rather than a container the caller would have to invent to satisfy the type.
+/**
+ * Runs an already-built argument list.
+ *
+ * `up` has no container behind it, so the boundary takes the argv rather than a container the caller
+ * would have to invent to satisfy the type.
  */
 export function runDockerArgs(args) {
   return new Promise(resolve => {

package/dist/compose.js

@@ -1,19 +1,34 @@
 import { readFileSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 
-/** compose v2's own search order, so the resolver sees the same file the CLI would pick. */
+/** compose v2's own search order, so the resolver sees the file the CLI would pick */
 const CANDIDATES = ["compose.yaml", "compose.yml", "docker-compose.yaml", "docker-compose.yml"];
-/** An unindented `name:` is top-level by construction, which is why a regex beats a YAML parser here. */
+
+/**
+ * Compose derives a project name from the directory by lowercasing it, dropping everything outside
+ * `[a-z0-9_-]` and then dropping whatever is left before the first alphanumeric. Measured against
+ * compose v2: `My.Stack 2` becomes `mystack2`, `A+B` becomes `ab`, `--Lead` becomes `lead`,
+ * `Ünïcode` becomes `ncode`, and a directory named `---` fails with "project name must not be empty".
+ *
+ * The panel passes the name explicitly as `-p`, which replaces that derivation, so the same
+ * normalization has to happen here or compose rejects what it would have accepted on its own.
+ */
+export function normalizeProject(name) {
+  return name.toLowerCase().replace(/[^a-z0-9_-]/g, "").replace(/^[^a-z0-9]+/, "");
+}
+const VALID_PROJECT = /^[a-z0-9][a-z0-9_-]*$/;
+/** An unindented `name:` is top-level by construction, which is why a regex beats a YAML parser here */
 function declaredProject(body) {
-  // A UTF-8 BOM makes `^` miss the first line, which would hand back the directory name as if it
-  // were the project's. PowerShell and several editors write one, so strip it before matching.
+  // A UTF-8 BOM makes `^` miss the first line and hands back the directory name as the project, and
+  // PowerShell writes one
   const match = body.replace(/^\uFEFF/, "").match(/^name:[ \t]*(\S.*?)[ \t]*$/m);
   return match?.[1]?.replace(/^["']|["']$/g, "") ?? "";
 }
 
-/**
- * Finds the agent directory's compose file and reports the project it declares, if any. The file is
- * read on every call because the call comes from opening a menu, not from the poll loop.
+/**
+ * Finds the agent directory's compose file and reports the project it declares, if any.
+ *
+ * Read on every call because the caller opens a menu, not the poll loop.
  */
 export function findComposeFile(agentDir) {
   if (!agentDir) return null;
@@ -25,21 +40,28 @@ export function findComposeFile(agentDir) {
     } catch {
       continue;
     }
-    // The first file that exists wins even when its project differs, because that is the file
-    // compose itself would use. Falling through would act on a stack the CLI ignores.
+    // The first file that exists wins even when its project differs, because that is the one compose
+    // itself would use, and falling through would act on a stack the CLI ignores
+    const declared = declaredProject(body);
+    const project = declared || normalizeProject(basename(dirname(file)));
+    // A declared name compose will reject, or a directory that normalizes to nothing, is a refusal
+    // rather than a button that can only fail
+    if (!VALID_PROJECT.test(project)) return null;
     return {
       dir: agentDir,
       file,
-      project: declaredProject(body) || basename(dirname(file))
+      project
     };
   }
   return null;
 }
 
-/**
- * The compose target for a container that is already part of the project, or null when the agent
- * directory's file belongs to somebody else. `up` runs build and command lines from that file, so
- * an uncertain match has to hide the button rather than point it at the wrong stack.
+/**
+ * The compose target for a container already part of the project, or null when the agent directory's
+ * file belongs to somebody else.
+ *
+ * `up` runs build and command lines from that file, so an uncertain match has to hide the button
+ * rather than point it at the wrong stack.
  */
 export function resolveComposeTarget(agentDir, project) {
   const target = findComposeFile(agentDir);

package/dist/docker.js

@@ -5,11 +5,22 @@ const TIMEOUT_MS = 4000;
 const MAX_BUFFER = 4 * 1024 * 1024;
 const COMPOSE_PROJECT = "com.docker.compose.project";
 const COMPOSE_SERVICE = "com.docker.compose.service";
+
+/**
+ * The Desktop backend owns the named pipe `dockerDesktopLinuxEngine`, and `docker ps` reports it as
+ * missing within about a quarter second, while `docker desktop status` needs four seconds to admit
+ * the same thing. Measured with Desktop stopped: `docker ps` 257 ms, `docker desktop status` 4.4 s.
+ *
+ * The wording is the only evidence here, so it has to name the pipe and its absence together: a bare
+ * `cannot find the file specified` also covers a missing binary and must not be read as a stopped
+ * engine.
+ */
+export function isDesktopPipeMissing(raw) {
+  const text = raw.toLowerCase();
+  return text.includes("dockerdesktoplinuxengine") && (text.includes("cannot find the file specified") || text.includes("no such file"));
+}
 export function shortReason(raw) {
   const text = raw.toLowerCase();
-  if (text.includes("dockerdesktoplinuxengine") || text.includes("cannot find the file specified")) {
-    return "docker desktop not running";
-  }
   if (text.includes("docker_engine") || text.includes("is the server running")) return "no connection to docker";
   if (text.includes("access is denied") || text.includes("permission denied")) return "no permission to talk to docker";
   const firstLine = raw.split(/\r?\n/).map(line => line.trim()).find(line => line.length > 0);
@@ -17,7 +28,7 @@ export function shortReason(raw) {
   return firstLine.length > 60 ? `${firstLine.slice(0, 57)}...` : firstLine;
 }
 
-/** Docker joins labels with commas, and neither a compose project nor a service name may contain one, so a plain split is enough. */
+/** Docker joins labels with commas and neither a compose project nor a service name may contain one, so a plain split is enough */
 function composeLabels(raw) {
   let composeProject;
   let composeService;
@@ -33,7 +44,7 @@ function composeLabels(raw) {
   };
 }
 
-/** docker reports CreatedAt either as a unix timestamp in seconds or as a date with a trailing zone name, which Date.parse rejects. */
+/** docker reports CreatedAt as a unix timestamp in seconds or as a date with a trailing zone name, which Date.parse rejects */
 function parseCreatedAt(raw) {
   const text = String(raw ?? "").trim();
   if (!text) return 0;
@@ -104,10 +115,19 @@ export function runDockerPs(timeoutMs = TIMEOUT_MS) {
         });
         return;
       }
+      const raw = String(stderr || error.message);
+      if (isDesktopPipeMissing(raw)) {
+        resolve({
+          kind: "stopped",
+          containers: [],
+          detail: ""
+        });
+        return;
+      }
       resolve({
         kind: "unavailable",
         containers: [],
-        detail: failure.code === "ENOENT" ? "docker not installed" : shortReason(String(stderr || error.message))
+        detail: failure.code === "ENOENT" ? "docker not installed" : shortReason(raw)
       });
     });
   });

package/dist/logs.js

@@ -4,12 +4,10 @@ const TAIL = 200;
 const TIMEOUT_MS = 4000;
 const MAX_BUFFER = 4 * 1024 * 1024;
 const ANSI = /\u001b\[[0-9;?]*[ -/]*[@-~]|\u001b\][^\u0007\u001b]*(?:\u0007|\u001b\\)/g;
-
-/** One source for both timestamp shapes, so the two patterns cannot drift apart. */
 const STAMP = String.raw`\d{4}-\d{2}-\d{2}T\S+`;
 const TIMESTAMP_ONLY = new RegExp(`^${STAMP}$`);
 const TIMESTAMPED = new RegExp(`^(${STAMP})\\s+(.*)$`);
-/** The terminal would run ANSI sequences from a log as control codes, and a lone CR is a line terminator, not an overwrite. */
+/** The terminal would run ANSI sequences as control codes, and a lone CR is a terminator, not an overwrite */
 export function sanitize(raw) {
   return raw.replace(ANSI, "").split(/\r\n|\r|\n/).map(line => line.trimEnd()).filter(line => line.length > 0);
 }
@@ -20,7 +18,7 @@ function level(text) {
   return "info";
 }
 
-/** docker prefixes every line with an RFC3339 timestamp when asked, so a log line splits into a time and the rest. */
+/** docker prefixes every line with an RFC3339 timestamp when asked, so a line splits into time and rest */
 export function parseLogLines(raw) {
   const lines = [];
   for (const line of sanitize(raw)) {
@@ -44,7 +42,7 @@ export function parseLogLines(raw) {
   return lines;
 }
 
-/** docker interleaves the container's two streams, so the real order only survives in the timestamps. */
+/** docker interleaves the container's two streams, so the real order only survives in the timestamps */
 export function mergeLogLines(parts) {
   const lines = parts.flatMap(part => parseLogLines(part));
   return lines.sort((a, b) => (a.time || "￿").localeCompare(b.time || "￿")).slice(-TAIL);