opencode-docker-panel 0.4.8

package/dist/docker.js

@@ -0,0 +1,114 @@
+import { execFile } from "node:child_process";
+const COMMAND = "docker";
+const ARGS = ["ps", "--all", "--format", "{{json .}}"];
+const TIMEOUT_MS = 4000;
+const MAX_BUFFER = 4 * 1024 * 1024;
+const COMPOSE_PROJECT = "com.docker.compose.project";
+const COMPOSE_SERVICE = "com.docker.compose.service";
+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);
+  if (!firstLine) return "no connection to docker";
+  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. */
+function composeLabels(raw) {
+  let composeProject;
+  let composeService;
+  for (const pair of raw.split(",")) {
+    const eq = pair.indexOf("=");
+    if (eq <= 0) continue;
+    const key = pair.slice(0, eq).trim();
+    if (key === COMPOSE_PROJECT) composeProject = pair.slice(eq + 1).trim();else if (key === COMPOSE_SERVICE) composeService = pair.slice(eq + 1).trim();
+  }
+  return {
+    composeProject,
+    composeService
+  };
+}
+
+/** docker reports CreatedAt either 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;
+  if (/^\d+$/.test(text)) return Number(text) * 1000;
+  const parsed = Date.parse(text.replace(/\s+[A-Za-z]{2,5}$/, ""));
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+function toContainer(raw) {
+  const name = String(raw.Names ?? "").replace(/^\//, "").trim();
+  if (!name) return null;
+  const compose = composeLabels(String(raw.Labels ?? ""));
+  return {
+    name,
+    image: String(raw.Image ?? ""),
+    state: String(raw.State ?? "unknown"),
+    status: String(raw.Status ?? ""),
+    ports: String(raw.Ports ?? "").split(",").map(item => item.trim()).filter(Boolean),
+    createdAt: parseCreatedAt(raw.CreatedAt),
+    ...compose
+  };
+}
+export function parseDockerPs(stdout) {
+  const containers = [];
+  for (const line of stdout.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let raw;
+    try {
+      raw = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (typeof raw !== "object" || raw === null) continue;
+    const container = toContainer(raw);
+    if (container) containers.push(container);
+  }
+  containers.sort((a, b) => {
+    const aRunning = a.state === "running";
+    const bRunning = b.state === "running";
+    if (aRunning !== bRunning) return aRunning ? -1 : 1;
+    if (a.createdAt !== b.createdAt) return b.createdAt - a.createdAt;
+    return a.name.localeCompare(b.name);
+  });
+  return containers;
+}
+export function runDockerPs(timeoutMs = TIMEOUT_MS) {
+  return new Promise(resolve => {
+    execFile(COMMAND, ARGS, {
+      timeout: timeoutMs,
+      windowsHide: true,
+      maxBuffer: MAX_BUFFER
+    }, (error, stdout, stderr) => {
+      if (!error) {
+        const containers = parseDockerPs(String(stdout));
+        resolve({
+          kind: containers.length > 0 ? "ok" : "empty",
+          containers,
+          detail: containers.length > 0 ? "" : "no containers"
+        });
+        return;
+      }
+      const failure = error;
+      if (failure.code === "ETIMEDOUT" || failure.killed === true) {
+        resolve({
+          kind: "stale",
+          containers: [],
+          detail: "docker did not respond"
+        });
+        return;
+      }
+      resolve({
+        kind: "unavailable",
+        containers: [],
+        detail: failure.code === "ENOENT" ? "docker not installed" : shortReason(String(stderr || error.message))
+      });
+    });
+  });
+}

package/dist/logs.js

@@ -0,0 +1,73 @@
+import { execFile } from "node:child_process";
+const COMMAND = "docker";
+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. */
+export function sanitize(raw) {
+  return raw.replace(ANSI, "").split(/\r\n|\r|\n/).map(line => line.trimEnd()).filter(line => line.length > 0);
+}
+function level(text) {
+  const lower = text.toLowerCase();
+  if (/\b(error|fatal|panic|exception|traceback|failed)\b/.test(lower)) return "error";
+  if (/\b(warn|warning|deprecated)\b/.test(lower)) return "warn";
+  return "info";
+}
+
+/** docker prefixes every line with an RFC3339 timestamp when asked, so a log line splits into a time and the rest. */
+export function parseLogLines(raw) {
+  const lines = [];
+  for (const line of sanitize(raw)) {
+    if (TIMESTAMP_ONLY.test(line)) continue;
+    const match = TIMESTAMPED.exec(line);
+    if (!match) {
+      lines.push({
+        time: "",
+        level: level(line),
+        text: line
+      });
+      continue;
+    }
+    const text = match[2] ?? "";
+    if (text.trim().length > 0) lines.push({
+      time: match[1] ?? "",
+      level: level(text),
+      text
+    });
+  }
+  return lines;
+}
+
+/** 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);
+}
+export function runDockerLogs(name, timeoutMs = TIMEOUT_MS) {
+  return new Promise(resolve => {
+    execFile(COMMAND, ["logs", "--timestamps", "--tail", String(TAIL), "--", name], {
+      timeout: timeoutMs,
+      windowsHide: true,
+      maxBuffer: MAX_BUFFER
+    }, (error, stdout, stderr) => {
+      if (!error) {
+        resolve({
+          lines: mergeLogLines([String(stdout), String(stderr)])
+        });
+        return;
+      }
+      const killed = error.killed === true;
+      const reason = sanitize(String(stderr))[0] || (killed ? "docker did not respond" : error.message);
+      resolve({
+        lines: [],
+        error: reason || "docker logs failed"
+      });
+    });
+  });
+}