The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
/**
* Structured Services detail dashboards and views for Docker containers, Compose
* projects, images, layers, processes, volumes and networks.
*
* Reuses the property-drawer primitives (`DrawerRow`, `DrawerSectionBanner`,
* `LineProgress`) and binary/SI unit & system-local timezone formatters
* proven in `openidea-kubernetes` (`ResourceDetails.tsx`).
*/
import { writeClipboardText } from "@/platform/clipboard";
import { useCallback, useEffect, useMemo, useState, type ReactNode } from "react";
import clsx from "clsx";
import type {
DockerContainer,
DockerContainerStats,
DockerImage,
DockerImageLayer,
DockerNetwork,
DockerProcessList,
DockerSnapshot,
DockerVolume,
} from "@/platform/ipc";
import { call, commands, isTauri } from "@/platform/ipc";
import { useTx, useTxTemplate } from "@/platform/i18n";
import { Button, EmptyState, Icon, IconButton, Spinner, T } from "@/ui";
import { copySelectionOnKeyDown } from "@/ui/selectableText";
import { notifications } from "@/workbench/contributions";
import {
containersInNetwork,
containersUsingImage,
containersUsingVolume,
findImageForContainer,
imageTagsForId,
isDevContainer,
isRunning,
shortId,
treeKey,
type DockerTarget,
} from "./model";
import { canRemove, canRestart, canStart, canStop, execShell, remove, restart, showDetail, start, stop } from "./ops";
import { openContainerLogInEditor } from "./logEditor";
import { containerOp, endpointOf, errorMessage } from "./store";
import { useServicesTree } from "./tree";
import styles from "./Services.module.css";
// ---------------------------------------------------------------------------
// Unit, timestamp & inspect parsers (adapted from openidea-kubernetes)
const UNIT_MULTIPLIERS: Record<string, number> = {
B: 1,
KiB: 1024,
MiB: 1024 ** 2,
GiB: 1024 ** 3,
TiB: 1024 ** 4,
PiB: 1024 ** 5,
Ki: 1024,
Mi: 1024 ** 2,
Gi: 1024 ** 3,
Ti: 1024 ** 4,
Pi: 1024 ** 5,
kB: 1000,
KB: 1000,
MB: 1000 ** 2,
GB: 1000 ** 3,
TB: 1000 ** 4,
PB: 1000 ** 5,
K: 1000,
k: 1000,
M: 1000 ** 2,
G: 1000 ** 3,
T: 1000 ** 4,
};
export function unitsToBytes(value: string | number | undefined | null): number {
if (value === undefined || value === null) return 0;
if (typeof value === "number") return Number.isFinite(value) && value > 0 ? value : 0;
const raw = String(value).trim();
if (!raw) return 0;
const m = /^([0-9]+(?:\.[0-9]+)?)\s*([A-Za-z]+)?$/.exec(raw);
if (!m) return 0;
const num = Number.parseFloat(m[1]!);
if (Number.isNaN(num)) return 0;
const suffix = m[2] ?? "";
if (!suffix) return num;
const mult = UNIT_MULTIPLIERS[suffix] ?? UNIT_MULTIPLIERS[suffix.replace(/B$/i, "")];
return mult ? num * mult : num;
}
export function bytesToUnits(bytes: number, precision = 1): string {
if (!Number.isFinite(bytes) || bytes <= 0) return "0 B";
const units = ["B", "KiB", "MiB", "GiB", "TiB", "PiB"];
let idx = 0;
let val = bytes;
while (val >= 1024 && idx < units.length - 1) {
val /= 1024;
idx++;
}
if (idx === 0) return `${Math.round(val)} B`;
return `${val.toFixed(precision)} ${units[idx]!}`;
}
export function parsePercent(raw: string | undefined | null): number {
if (!raw) return 0;
const n = Number.parseFloat(raw.replace(/%/g, "").trim());
return Number.isFinite(n) && n >= 0 ? n : 0;
}
export interface UsagePair {
used: string;
limit: string;
usedBytes: number;
limitBytes: number;
percent: number;
}
export function parseUsagePair(raw: string | undefined | null): UsagePair {
const parts = (raw ?? "").split("/").map((s) => s.trim());
const used = parts[0] || "0 B";
const limit = parts[1] || "0 B";
const usedBytes = unitsToBytes(used);
const limitBytes = unitsToBytes(limit);
const percent = limitBytes > 0 ? Math.min(100, (usedBytes / limitBytes) * 100) : 0;
return { used, limit, usedBytes, limitBytes, percent };
}
function parseDockerTimestamp(raw?: string | null): number {
if (!raw) return Number.NaN;
const trimmed = raw.trim();
if (!trimmed || trimmed.startsWith("0001-01-01")) return Number.NaN;
const direct = Date.parse(trimmed);
if (!Number.isNaN(direct)) return direct;
// Docker CLI format: `2026-10-01 09:12:44 +0200 CEST` -> drop trailing timezone name
const cleaned = trimmed.replace(/\s+[A-Z]{2,5}$/, "");
return Date.parse(cleaned);
}
/**
* Formats an ISO or Docker CLI timestamp in the user's system local timezone
* (`YYYY-MM-DD HH:mm:ss <TZ>`) with relative age.
*/
export function formatCreatedDetailed(raw?: string | null, nowMs = Date.now(), timeZone?: string): string {
if (!raw) return "—";
const trimmed = raw.trim();
if (!trimmed || trimmed.startsWith("0001-01-01")) return "—";
const ts = parseDockerTimestamp(trimmed);
if (Number.isNaN(ts)) return trimmed;
const diffSec = Math.max(0, Math.floor((nowMs - ts) / 1000));
const days = Math.floor(diffSec / 86400);
const hours = Math.floor((diffSec % 86400) / 3600);
const mins = Math.floor((diffSec % 3600) / 60);
const parts: string[] = [];
if (days > 0) parts.push(`${days}d`);
if (hours > 0) parts.push(`${hours}h`);
if (mins > 0 || parts.length === 0) parts.push(`${mins}m`);
const d = new Date(ts);
try {
const dtf = new Intl.DateTimeFormat(undefined, {
...(timeZone ? { timeZone } : {}),
year: "numeric",
month: "2-digit",
day: "2-digit",
hour: "2-digit",
minute: "2-digit",
second: "2-digit",
hour12: false,
timeZoneName: "short",
});
const p = Object.fromEntries(dtf.formatToParts(d).map((x) => [x.type, x.value]));
const datePart = `${p.year}-${p.month}-${p.day} ${p.hour}:${p.minute}:${p.second}`;
const formatted = p.timeZoneName ? `${datePart} ${p.timeZoneName}` : datePart;
return `${parts.join(" ")} ago (${formatted})`;
} catch {
return `${parts.join(" ")} ago (${trimmed})`;
}
}
export interface PortMapping {
hostIp: string;
hostPort: string | null;
containerPort: string;
protocol: string;
url: string | null;
label: string;
}
/** Extracts published and exposed ports from `DockerContainer.ports` and `docker inspect` JSON. */
export function parsePortMappings(portsText: string, inspectPorts?: Record<string, unknown> | null): PortMapping[] {
const seen = new Set<string>();
const out: PortMapping[] = [];
const push = (rawHostIp: string, hostPort: string | null, containerPort: string, protocol: string) => {
const hostIp = rawHostIp === "::" ? "[::]" : rawHostIp;
const key = `${hostIp}:${hostPort ?? ""}->${containerPort}/${protocol}`;
if (seen.has(key)) return;
seen.add(key);
const browseHost = !hostIp || hostIp === "0.0.0.0" || hostIp === "[::]" ? "localhost" : hostIp;
const url = hostPort && protocol === "tcp" ? `http://${browseHost}:${hostPort}` : null;
const label = hostPort
? `${hostIp || "0.0.0.0"}:${hostPort} -> ${containerPort}/${protocol}`
: `${containerPort}/${protocol}`;
out.push({ hostIp, hostPort, containerPort, protocol, url, label });
};
if (inspectPorts && typeof inspectPorts === "object") {
for (const [spec, bindings] of Object.entries(inspectPorts)) {
const [cPort = spec, proto = "tcp"] = spec.split("/");
if (Array.isArray(bindings) && bindings.length > 0) {
for (const b of bindings) {
if (b && typeof b === "object") {
const rec = b as Record<string, unknown>;
const ip = typeof rec.HostIp === "string" ? rec.HostIp : "0.0.0.0";
const hp = typeof rec.HostPort === "string" && rec.HostPort ? rec.HostPort : null;
push(ip, hp, cPort, proto);
}
}
} else {
push("", null, cPort, proto);
}
}
}
for (const seg of (portsText ?? "")
.split(",")
.map((s) => s.trim())
.filter(Boolean)) {
const arrow = seg.indexOf("->");
if (arrow > 0) {
const left = seg.slice(0, arrow);
const right = seg.slice(arrow + 2);
const [cPort = right, proto = "tcp"] = right.split("/");
const colon = left.lastIndexOf(":");
const hostIp = colon >= 0 ? left.slice(0, colon) : "0.0.0.0";
const hostPort = colon >= 0 ? left.slice(colon + 1) : left;
push(hostIp, hostPort, cPort, proto);
} else {
const [cPort = seg, proto = "tcp"] = seg.split("/");
push("", null, cPort, proto);
}
}
return out;
}
const DOCKERFILE_INSTRUCTIONS = new Set([
"FROM",
"RUN",
"CMD",
"LABEL",
"MAINTAINER",
"EXPOSE",
"ENV",
"ADD",
"COPY",
"ENTRYPOINT",
"VOLUME",
"USER",
"WORKDIR",
"ARG",
"ONBUILD",
"STOPSIGNAL",
"HEALTHCHECK",
"SHELL",
]);
/** Cleans `docker image history` `CreatedBy` text into `{ instruction, args }`. */
export function splitLayerInstruction(createdBy: string): { instruction: string; args: string } {
let text = (createdBy ?? "").trim();
text = text.replace(/\s*#\s*buildkit\s*$/i, "");
if (text.startsWith("/bin/sh -c #(nop)")) {
text = text.slice("/bin/sh -c #(nop)".length).trim();
} else if (text.startsWith("/bin/sh -c")) {
const body = text.slice("/bin/sh -c".length).trim();
return { instruction: "RUN", args: body || text };
}
const space = text.search(/\s/);
if (space < 0) {
const upper = text.toUpperCase();
return DOCKERFILE_INSTRUCTIONS.has(upper) ? { instruction: upper, args: "" } : { instruction: "LAYER", args: text };
}
const first = text.slice(0, space).toUpperCase();
const rest = text.slice(space + 1).trim();
if (DOCKERFILE_INSTRUCTIONS.has(first)) {
return { instruction: first, args: rest };
}
return { instruction: "RUN", args: text };
}
export interface ContainerMountInfo {
type: string;
name?: string;
source: string;
destination: string;
mode: string;
rw: boolean;
}
export interface ContainerNetworkInfo {
name: string;
ipAddress: string;
gateway: string;
macAddress: string;
}
export interface ParsedContainerInspect {
created: string;
imageId: string;
restartPolicy: string;
networkMode: string;
privileged: boolean;
pid: number | null;
exitCode: number | null;
startedAt: string;
finishedAt: string;
healthStatus: string | null;
user: string;
workingDir: string;
entrypoint: string[];
cmd: string[];
env: Array<[string, string]>;
mounts: ContainerMountInfo[];
networks: ContainerNetworkInfo[];
ports: PortMapping[];
labels: Array<[string, string]>;
}
function asStringArray(v: unknown): string[] {
return Array.isArray(v) ? v.filter((x): x is string => typeof x === "string") : [];
}
function splitEnvList(raw: unknown): Array<[string, string]> {
return asStringArray(raw).map((entry) => {
const eq = entry.indexOf("=");
return eq >= 0 ? [entry.slice(0, eq), entry.slice(eq + 1)] : [entry, ""];
});
}
function recordEntries(raw: unknown): Array<[string, string]> {
if (!raw || typeof raw !== "object") return [];
return Object.entries(raw as Record<string, unknown>)
.filter(([, v]) => typeof v === "string" || typeof v === "number" || typeof v === "boolean")
.map(([k, v]) => [k, String(v)] as [string, string])
.sort((a, b) => a[0].localeCompare(b[0]));
}
export function parseContainerInspect(raw: string | null, fallbackPorts = ""): ParsedContainerInspect | null {
if (!raw) return null;
try {
const parsed = JSON.parse(raw) as unknown;
const obj = (Array.isArray(parsed) ? parsed[0] : parsed) as Record<string, unknown> | undefined;
if (!obj || typeof obj !== "object") return null;
const state = (obj.State as Record<string, unknown> | undefined) ?? {};
const config = (obj.Config as Record<string, unknown> | undefined) ?? {};
const hostConfig = (obj.HostConfig as Record<string, unknown> | undefined) ?? {};
const netSettings = (obj.NetworkSettings as Record<string, unknown> | undefined) ?? {};
const restart = (hostConfig.RestartPolicy as Record<string, unknown> | undefined) ?? {};
const restartName = typeof restart.Name === "string" && restart.Name ? restart.Name : "no";
const maxRetry =
typeof restart.MaximumRetryCount === "number" && restart.MaximumRetryCount > 0
? `:${restart.MaximumRetryCount}`
: "";
const health = (state.Health as Record<string, unknown> | undefined) ?? {};
const mountsRaw = Array.isArray(obj.Mounts) ? obj.Mounts : [];
const mounts: ContainerMountInfo[] = mountsRaw
.filter((m): m is Record<string, unknown> => !!m && typeof m === "object")
.map((m) => ({
type: typeof m.Type === "string" ? m.Type : "volume",
name: typeof m.Name === "string" && m.Name ? m.Name : undefined,
source: typeof m.Source === "string" ? m.Source : "",
destination: typeof m.Destination === "string" ? m.Destination : "",
mode: typeof m.Mode === "string" ? m.Mode : "",
rw: m.RW !== false,
}));
const netsObj = (netSettings.Networks as Record<string, unknown> | undefined) ?? {};
const networks: ContainerNetworkInfo[] = Object.entries(netsObj)
.filter(([, v]) => !!v && typeof v === "object")
.map(([name, v]) => {
const n = v as Record<string, unknown>;
return {
name,
ipAddress: typeof n.IPAddress === "string" ? n.IPAddress : "",
gateway: typeof n.Gateway === "string" ? n.Gateway : "",
macAddress: typeof n.MacAddress === "string" ? n.MacAddress : "",
};
});
const portsObj =
(netSettings.Ports as Record<string, unknown> | undefined) ??
(hostConfig.PortBindings as Record<string, unknown> | undefined) ??
null;
return {
created: typeof obj.Created === "string" ? obj.Created : "",
imageId: typeof obj.Image === "string" ? obj.Image : "",
restartPolicy: `${restartName}${maxRetry}`,
networkMode: typeof hostConfig.NetworkMode === "string" ? hostConfig.NetworkMode : "",
privileged: hostConfig.Privileged === true,
pid: typeof state.Pid === "number" && state.Pid > 0 ? state.Pid : null,
exitCode: typeof state.ExitCode === "number" ? state.ExitCode : null,
startedAt: typeof state.StartedAt === "string" ? state.StartedAt : "",
finishedAt: typeof state.FinishedAt === "string" ? state.FinishedAt : "",
healthStatus: typeof health.Status === "string" ? health.Status : null,
user: typeof config.User === "string" ? config.User : "",
workingDir: typeof config.WorkingDir === "string" ? config.WorkingDir : "",
entrypoint: asStringArray(config.Entrypoint),
cmd: asStringArray(config.Cmd),
env: splitEnvList(config.Env),
mounts,
networks,
ports: parsePortMappings(fallbackPorts, portsObj),
labels: recordEntries(config.Labels),
};
} catch {
return null;
}
}
export interface ParsedImageInspect {
created: string;
size: number;
architecture: string;
os: string;
author: string;
dockerVersion: string;
repoTags: string[];
repoDigests: string[];
user: string;
workingDir: string;
entrypoint: string[];
cmd: string[];
exposedPorts: string[];
volumes: string[];
env: Array<[string, string]>;
labels: Array<[string, string]>;
}
export function parseImageInspect(raw: string | null): ParsedImageInspect | null {
if (!raw) return null;
try {
const parsed = JSON.parse(raw) as unknown;
const obj = (Array.isArray(parsed) ? parsed[0] : parsed) as Record<string, unknown> | undefined;
if (!obj || typeof obj !== "object") return null;
const config = (obj.Config as Record<string, unknown> | undefined) ?? {};
const exposed =
config.ExposedPorts && typeof config.ExposedPorts === "object"
? Object.keys(config.ExposedPorts as Record<string, unknown>).sort()
: [];
const volumes =
config.Volumes && typeof config.Volumes === "object"
? Object.keys(config.Volumes as Record<string, unknown>).sort()
: [];
return {
created: typeof obj.Created === "string" ? obj.Created : "",
size: typeof obj.Size === "number" ? obj.Size : 0,
architecture: typeof obj.Architecture === "string" ? obj.Architecture : "",
os: typeof obj.Os === "string" ? obj.Os : "",
author: typeof obj.Author === "string" ? obj.Author : "",
dockerVersion: typeof obj.DockerVersion === "string" ? obj.DockerVersion : "",
repoTags: asStringArray(obj.RepoTags),
repoDigests: asStringArray(obj.RepoDigests),
user: typeof config.User === "string" ? config.User : "",
workingDir: typeof config.WorkingDir === "string" ? config.WorkingDir : "",
entrypoint: asStringArray(config.Entrypoint),
cmd: asStringArray(config.Cmd),
exposedPorts: exposed,
volumes,
env: splitEnvList(config.Env),
labels: recordEntries(config.Labels),
};
} catch {
return null;
}
}
export interface ParsedNetworkInspect {
created: string;
ipamConfigs: Array<{ subnet: string; gateway: string }>;
containers: Array<{ id: string; name: string; ipv4Address: string; macAddress: string }>;
options: Array<[string, string]>;
labels: Array<[string, string]>;
}
export function parseNetworkInspect(raw: string | null): ParsedNetworkInspect | null {
if (!raw) return null;
try {
const parsed = JSON.parse(raw) as unknown;
const obj = (Array.isArray(parsed) ? parsed[0] : parsed) as Record<string, unknown> | undefined;
if (!obj || typeof obj !== "object") return null;
const ipam = (obj.IPAM as Record<string, unknown> | undefined) ?? {};
const ipamRaw = Array.isArray(ipam.Config) ? ipam.Config : [];
const ipamConfigs = ipamRaw
.filter((c): c is Record<string, unknown> => !!c && typeof c === "object")
.map((c) => ({
subnet: typeof c.Subnet === "string" ? c.Subnet : "",
gateway: typeof c.Gateway === "string" ? c.Gateway : "",
}))
.filter((c) => c.subnet || c.gateway);
const containersObj = (obj.Containers as Record<string, unknown> | undefined) ?? {};
const containers = Object.entries(containersObj)
.filter(([, v]) => !!v && typeof v === "object")
.map(([id, v]) => {
const c = v as Record<string, unknown>;
return {
id,
name: typeof c.Name === "string" ? c.Name : shortId(id),
ipv4Address: typeof c.IPv4Address === "string" ? c.IPv4Address : "",
macAddress: typeof c.MacAddress === "string" ? c.MacAddress : "",
};
})
.sort((a, b) => a.name.localeCompare(b.name));
return {
created: typeof obj.Created === "string" ? obj.Created : "",
ipamConfigs,
containers,
options: recordEntries(obj.Options),
labels: recordEntries(obj.Labels),
};
} catch {
return null;
}
}
// ---------------------------------------------------------------------------
// Shared UI primitives (adapted from openidea-kubernetes ResourceDetails.tsx)
const copyText = (text: string) => void writeClipboardText(text);
async function openExternalUrl(url: string): Promise<void> {
try {
if (isTauri()) {
const opener = await import("@tauri-apps/plugin-opener");
await opener.openUrl(url);
} else {
window.open(url, "_blank", "noopener");
}
} catch (e) {
notifications().notify({ group: "run", level: "error", title: "Cannot open link", body: String(e) });
}
}
export function selectServicesTreeKey(key: string): void {
useServicesTree.setState((s) => {
const expanded = new Set(s.expanded);
// Ensure parent connection and group nodes are expanded so the target row is visible.
const parts = key.split(":");
if (parts.length >= 2) expanded.add(`${parts[0]!}:${parts[1]!}`);
if (parts.length >= 4) {
const kind = parts[2]!;
const group =
kind === "container" || kind === "compose"
? "containers"
: kind === "image"
? "images"
: kind === "volume"
? "volumes"
: kind === "network"
? "networks"
: null;
if (group) expanded.add(`${parts[0]!}:${parts[1]!}:group:${group}`);
}
return { selectedKey: key, selectedKeys: new Set([key]), expanded };
});
}
function SectionBanner({ children, action }: { children: ReactNode; action?: ReactNode }) {
return (
<div className={styles.sectionBanner}>
<span>{children}</span>
{action}
</div>
);
}
function PropRow({ label, children, hidden }: { label: ReactNode; children: ReactNode; hidden?: boolean }) {
if (hidden) return null;
return (
<div className={styles.propRow}>
<div className={styles.propName}>{label}</div>
<div className={styles.propVal}>{children}</div>
</div>
);
}
function LineProgress({ percent }: { percent: number }) {
const clamped = Math.min(100, Math.max(0, percent));
const tone = clamped >= 90 ? styles.progressDanger : clamped >= 75 ? styles.progressWarning : styles.progressNormal;
return (
<div className={styles.lineProgress}>
<div
className={clsx(styles.lineProgressFill, tone)}
style={{ width: `${clamped > 0 ? Math.max(2, clamped) : 0}%` }}
/>
</div>
);
}
function StatusBadge({ state, text }: { state: string; text?: string }) {
const s = state.toLowerCase();
const tone =
s === "running" || s === "healthy"
? styles.badgeOk
: s === "paused" || s === "restarting" || s === "starting"
? styles.badgeWarn
: s === "dead" || s === "unhealthy" || s === "removing"
? styles.badgeDanger
: styles.badgeMuted;
return <span className={clsx(styles.statusBadge, tone)}>{text ?? state}</span>;
}
function KeyValueTable({ rows, emptyText }: { rows: ReadonlyArray<readonly [string, string]>; emptyText?: ReactNode }) {
if (!rows.length) {
return emptyText ? <div className={styles.emptySection}>{emptyText}</div> : null;
}
return (
<div className={styles.kvTable} tabIndex={0} onKeyDown={copySelectionOnKeyDown}>
{rows.map(([k, v]) => (
<div key={k} className={styles.kvRow}>
<span className={styles.kvKey} title={k}>
{k}
</span>
<span className={styles.kvVal} title={v}>
{v || "—"}
</span>
</div>
))}
</div>
);
}
function ContainerLinkChip({ conn, container }: { conn: string; container: DockerContainer }) {
const running = isRunning(container);
const key = treeKey(conn, { kind: "container", key: `container:${container.id}`, container });
const parentKey = container.composeProject
? `docker:${conn}:compose:${container.composeProject}`
: isDevContainer(container)
? `docker:${conn}:group:devContainers`
: `docker:${conn}:group:containers`;
return (
<button
type="button"
className={styles.entityChip}
onClick={() => {
useServicesTree.setState((s) => {
const expanded = new Set(s.expanded);
expanded.add(`docker:${conn}`);
expanded.add(parentKey);
return { selectedKey: key, selectedKeys: new Set([key]), expanded };
});
showDetail("dashboard");
}}
>
<span className={clsx(styles.statusDot, running ? styles.dotOk : styles.dotMuted)} />
<span className={styles.mono}>{container.name}</span>
<span className={styles.chipMeta}>{container.status}</span>
</button>
);
}
// ---------------------------------------------------------------------------
// Container Dashboard & Processes View
export function ContainerDashboard({
conn,
container,
snapshot,
inspectText,
}: {
conn: string;
container: DockerContainer;
snapshot: DockerSnapshot;
inspectText: string | null;
}) {
const running = isRunning(container);
const target: DockerTarget = {
conn,
node: { kind: "container", key: `container:${container.id}`, container },
};
const inspect = useMemo(() => parseContainerInspect(inspectText, container.ports), [inspectText, container.ports]);
const ports = useMemo(() => inspect?.ports ?? parsePortMappings(container.ports), [inspect, container.ports]);
const matchedImage = useMemo(() => findImageForContainer(snapshot, container), [snapshot, container]);
const [stats, setStats] = useState<DockerContainerStats | null>(null);
const [statsLoading, setStatsLoading] = useState(false);
useEffect(() => {
if (!running || !isTauri()) return;
let alive = true;
call(commands.dockerContainerStats(endpointOf(conn), container.id))
.then((s) => alive && setStats(s))
.catch(() => alive && setStats(null));
return () => {
alive = false;
};
}, [conn, container.id, running]);
const reloadStats = useCallback(() => {
if (!running || !isTauri()) return;
setStatsLoading(true);
call(commands.dockerContainerStats(endpointOf(conn), container.id))
.then((s) => setStats(s))
.catch(() => setStats(null))
.finally(() => setStatsLoading(false));
}, [conn, container.id, running]);
const cpuPct = stats ? parsePercent(stats.cpuPerc) : 0;
const memPair = stats ? parseUsagePair(stats.memUsage) : null;
const labels = inspect?.labels.length ? inspect.labels : Object.entries(container.labels ?? {});
return (
<div className={styles.dashboard} tabIndex={0} onKeyDown={copySelectionOnKeyDown}>
<div className={styles.dashboardActions}>
<Button size="small" disabled={!canStart(target)} onClick={() => void start(target)}>
Start
</Button>
<Button size="small" disabled={!canStop(target)} onClick={() => void stop(target)}>
Stop
</Button>
<Button size="small" disabled={!canRestart(target)} onClick={() => void restart(target)}>
Restart
</Button>
{container.state === "paused" ? (
<Button size="small" onClick={() => void containerOp(conn, [container.id], "unpause")}>
Unpause
</Button>
) : (
<Button size="small" disabled={!running} onClick={() => void containerOp(conn, [container.id], "pause")}>
Pause
</Button>
)}
<Button size="small" disabled={!running} onClick={() => execShell(target)}>
Create Terminal
</Button>
<Button size="small" onClick={() => showDetail("log")}>
Show Log
</Button>
<Button size="small" onClick={() => openContainerLogInEditor(conn, container)}>
Open Log in Editor
</Button>
<Button size="small" disabled={!canRemove(target)} onClick={() => void remove(target)}>
Delete…
</Button>
</div>
<SectionBanner>
<T>Container Overview</T>
</SectionBanner>
<div className={styles.propList}>
<PropRow label={<T>Name</T>}>
<span className={styles.mono}>{container.name}</span>
</PropRow>
<PropRow label={<T>Container ID</T>}>
<span className={styles.inlineRow}>
<span className={styles.mono} title={container.id}>
{shortId(container.id)}
</span>
<IconButton icon="copy" size="small" title="Copy Container ID" onClick={() => copyText(container.id)} />
</span>
</PropRow>
<PropRow label={<T>Status</T>}>
<span className={styles.inlineRow}>
<StatusBadge state={container.state} text={container.status || container.state} />
{inspect?.healthStatus && <StatusBadge state={inspect.healthStatus} text={inspect.healthStatus} />}
{inspect?.exitCode !== null && inspect?.exitCode !== undefined && !running && (
<span className={styles.mutedMeta}>Exit code {inspect.exitCode}</span>
)}
{inspect?.pid && <span className={styles.mutedMeta}>PID {inspect.pid}</span>}
</span>
</PropRow>
<PropRow label={<T>Image</T>}>
<span className={styles.inlineRow}>
{matchedImage ? (
<button
type="button"
className={styles.link}
onClick={() => {
selectServicesTreeKey(
treeKey(conn, { kind: "image", key: `image:${matchedImage.id}`, image: matchedImage }),
);
showDetail("dashboard");
}}
>
<span className={styles.mono}>{container.image}</span>
</button>
) : (
<span className={styles.mono}>{container.image}</span>
)}
<IconButton icon="copy" size="small" title="Copy Image Name" onClick={() => copyText(container.image)} />
</span>
</PropRow>
<PropRow label={<T>Created</T>}>{formatCreatedDetailed(inspect?.created || container.createdAt)}</PropRow>
<PropRow label={<T>Started</T>} hidden={!inspect?.startedAt || inspect.startedAt.startsWith("0001-01-01")}>
{formatCreatedDetailed(inspect?.startedAt)}
</PropRow>
<PropRow label={<T>Command</T>} hidden={!container.command && !inspect?.cmd.length}>
<code className={styles.codeInline}>
{inspect && (inspect.entrypoint.length || inspect.cmd.length)
? [...inspect.entrypoint, ...inspect.cmd].join(" ")
: container.command}
</code>
</PropRow>
<PropRow label={<T>Working directory</T>} hidden={!inspect?.workingDir}>
<span className={styles.mono}>{inspect?.workingDir}</span>
</PropRow>
<PropRow label={<T>User</T>} hidden={!inspect?.user}>
<span className={styles.mono}>{inspect?.user}</span>
</PropRow>
<PropRow label={<T>Restart policy</T>} hidden={!inspect?.restartPolicy}>
<span className={styles.mono}>{inspect?.restartPolicy}</span>
</PropRow>
<PropRow label={<T>Compose</T>} hidden={!container.composeProject}>
<span className={styles.inlineRow}>
<button
type="button"
className={styles.link}
onClick={() => {
if (container.composeProject) {
selectServicesTreeKey(
treeKey(conn, {
kind: "compose",
key: `compose:${container.composeProject}`,
project: container.composeProject,
containers: [],
}),
);
}
}}
>
{container.composeProject}
</button>
{container.composeService && <span className={styles.mutedMeta}>· {container.composeService}</span>}
</span>
</PropRow>
</div>
{running && (
<>
<SectionBanner
action={
<IconButton icon="refresh" size="small" title="Refresh" disabled={statsLoading} onClick={reloadStats} />
}
>
<T>Resource Usage</T>
</SectionBanner>
{stats ? (
<div className={styles.propList}>
<PropRow label={<T>CPU</T>}>
<div className={styles.metricBlock}>
<span className={styles.mono}>{stats.cpuPerc}</span>
<LineProgress percent={cpuPct} />
</div>
</PropRow>
<PropRow label={<T>Memory</T>}>
<div className={styles.metricBlock}>
<span className={styles.mono}>
{stats.memUsage} ({stats.memPerc})
</span>
<LineProgress percent={memPair?.percent ?? parsePercent(stats.memPerc)} />
</div>
</PropRow>
<PropRow label={<T>Network I/O</T>} hidden={!stats.netIo}>
<span className={styles.mono}>{stats.netIo}</span>
</PropRow>
<PropRow label={<T>Block I/O</T>} hidden={!stats.blockIo}>
<span className={styles.mono}>{stats.blockIo}</span>
</PropRow>
<PropRow label={<T>PIDs</T>} hidden={!stats.pids}>
<span className={styles.mono}>{stats.pids}</span>
</PropRow>
</div>
) : (
<div className={styles.emptySection}>
{statsLoading ? (
<>
<Spinner size={12} /> <T>Loading…</T>
</>
) : (
<T>Metrics unavailable</T>
)}
</div>
)}
</>
)}
<SectionBanner>
<T>Port Bindings</T>
</SectionBanner>
{ports.length > 0 ? (
<div className={styles.chipGroup}>
{ports.map((p) =>
p.url ? (
<button
key={p.label}
type="button"
className={clsx(styles.entityChip, styles.portChipLink)}
title="Open in Browser"
onClick={() => void openExternalUrl(p.url!)}
>
<span className={styles.mono}>{p.label}</span>
<Icon name="external-link" size={12} />
</button>
) : (
<span key={p.label} className={styles.entityChip}>
<span className={styles.mono}>{p.label}</span>
</span>
),
)}
</div>
) : (
<div className={styles.emptySection}>
<T>No port bindings</T>
</div>
)}
<SectionBanner>
<T>Volume & Bind Mounts</T>
</SectionBanner>
{inspect?.mounts && inspect.mounts.length > 0 ? (
<div className={styles.dataTable}>
<div className={clsx(styles.dataRow, styles.dataHeader)}>
<span>
<T>Type</T>
</span>
<span>
<T>Source</T>
</span>
<span>
<T>Destination</T>
</span>
<span>
<T>Mode</T>
</span>
</div>
{inspect.mounts.map((m, idx) => {
const volumeObj = m.name ? snapshot.volumes.find((v) => v.name === m.name) : undefined;
return (
<div key={`${m.destination}:${idx}`} className={styles.dataRow}>
<span className={styles.badgeMuted}>{m.type}</span>
<span className={styles.mono} title={m.source}>
{volumeObj ? (
<button
type="button"
className={styles.link}
onClick={() => {
selectServicesTreeKey(
treeKey(conn, { kind: "volume", key: `volume:${volumeObj.name}`, volume: volumeObj }),
);
showDetail("dashboard");
}}
>
{volumeObj.name}
</button>
) : (
m.name || m.source || "—"
)}
</span>
<span className={styles.mono} title={m.destination}>
{m.destination}
</span>
<span className={styles.mono}>{m.rw ? m.mode || "rw" : "ro"}</span>
</div>
);
})}
</div>
) : container.mounts && container.mounts.length > 0 ? (
<div className={styles.chipGroup}>
{container.mounts.map((m) => {
const volumeObj = snapshot.volumes.find((v) => v.name === m);
return volumeObj ? (
<button
key={m}
type="button"
className={styles.entityChip}
onClick={() => {
selectServicesTreeKey(
treeKey(conn, { kind: "volume", key: `volume:${volumeObj.name}`, volume: volumeObj }),
);
showDetail("dashboard");
}}
>
<Icon name="docker-volumes" size={14} />
<span className={styles.mono}>{m}</span>
</button>
) : (
<span key={m} className={styles.entityChip}>
<span className={styles.mono}>{m}</span>
</span>
);
})}
</div>
) : (
<div className={styles.emptySection}>
<T>No mounts</T>
</div>
)}
{inspect?.networks.length || container.networks?.length ? (
<>
<SectionBanner>
<T>Networks</T>
</SectionBanner>
<div className={styles.chipGroup}>
{(inspect?.networks.length
? inspect.networks
: (container.networks ?? []).map((name) => ({ name, ipAddress: "", gateway: "", macAddress: "" }))
).map((n) => {
const netObj = snapshot.networks.find((x) => x.name === n.name);
return (
<button
key={n.name}
type="button"
className={styles.entityChip}
disabled={!netObj}
onClick={() => {
if (netObj) {
selectServicesTreeKey(
treeKey(conn, { kind: "network", key: `network:${netObj.id}`, network: netObj }),
);
showDetail("dashboard");
}
}}
>
<Icon name="docker-networks" size={14} />
<span className={styles.mono}>{n.name}</span>
{n.ipAddress && <span className={styles.chipMeta}>{n.ipAddress}</span>}
</button>
);
})}
</div>
</>
) : null}
<SectionBanner>
<T>Environment Variables</T>
</SectionBanner>
<KeyValueTable rows={inspect?.env ?? []} emptyText={<T>No environment variables</T>} />
{labels.length > 0 && (
<>
<SectionBanner>
<T>Labels</T>
</SectionBanner>
<KeyValueTable rows={labels} />
</>
)}
</div>
);
}
export function ContainerProcessesView({ conn, id, running }: { conn: string; id: string; running: boolean }) {
const tx = useTx();
const [data, setData] = useState<DockerProcessList | null>(null);
const [error, setError] = useState<string | null>(null);
const [loading, setLoading] = useState(false);
useEffect(() => {
if (!running || !isTauri()) return;
let alive = true;
call(commands.dockerContainerTop(endpointOf(conn), id))
.then((res) => {
if (!alive) return;
setData(res);
setError(null);
})
.catch((e) => alive && setError(errorMessage(e)));
return () => {
alive = false;
};
}, [conn, id, running]);
const reload = useCallback(() => {
if (!running || !isTauri()) return;
setLoading(true);
setError(null);
call(commands.dockerContainerTop(endpointOf(conn), id))
.then((res) => setData(res))
.catch((e) => setError(errorMessage(e)))
.finally(() => setLoading(false));
}, [conn, id, running]);
if (!running) {
return (
<EmptyState title="Container is not running">
<T>Start the container to view its running processes.</T>
</EmptyState>
);
}
return (
<div className={styles.detailBody}>
<div className={styles.subToolbar}>
<span className={styles.subToolbarTitle}>
<T>Processes</T>
{data ? ` (${data.processes.length})` : ""}
</span>
<IconButton icon="refresh" size="small" title="Refresh" disabled={loading} onClick={reload} />
</div>
{error ? (
<div className={styles.loading}>{error}</div>
) : !data ? (
<div className={styles.loading}>
<Spinner size={14} /> <T>Loading…</T>
</div>
) : data.processes.length === 0 ? (
<EmptyState title={tx("No processes reported")} />
) : (
<div className={styles.tableScroll} tabIndex={0} onKeyDown={copySelectionOnKeyDown}>
<table className={styles.gridTable}>
<thead>
<tr>
{data.titles.map((title, i) => (
<th key={`${title}:${i}`}>{title}</th>
))}
</tr>
</thead>
<tbody>
{data.processes.map((row, rIdx) => (
<tr key={rIdx}>
{data.titles.map((_, cIdx) => (
<td key={cIdx} className={styles.mono}>
{row[cIdx] ?? ""}
</td>
))}
</tr>
))}
</tbody>
</table>
</div>
)}
</div>
);
}
// ---------------------------------------------------------------------------
// Image Dashboard & Layers View
export function ImageDashboard({
conn,
image,
snapshot,
inspectText,
}: {
conn: string;
image: DockerImage;
snapshot: DockerSnapshot;
inspectText: string | null;
}) {
const target: DockerTarget = { conn, node: { kind: "image", key: `image:${image.id}`, image } };
const inspect = useMemo(() => parseImageInspect(inspectText), [inspectText]);
const tags = useMemo(() => {
const fromSnap = imageTagsForId(snapshot, image);
const fromInspect = inspect?.repoTags ?? [];
return [...new Set([...fromSnap, ...fromInspect])];
}, [snapshot, image, inspect]);
const usingContainers = useMemo(() => containersUsingImage(snapshot, image), [snapshot, image]);
return (
<div className={styles.dashboard} tabIndex={0} onKeyDown={copySelectionOnKeyDown}>
<div className={styles.dashboardActions}>
<Button size="small" onClick={() => showDetail("layers")}>
Show Layers
</Button>
<Button size="small" onClick={() => showDetail("inspect")}>
Inspect
</Button>
<Button size="small" disabled={!canRemove(target)} onClick={() => void remove(target)}>
Delete…
</Button>
</div>
<SectionBanner>
<T>Image Overview</T>
</SectionBanner>
<div className={styles.propList}>
<PropRow label={<T>Repository</T>}>
<span className={styles.mono}>{image.repository}</span>
</PropRow>
<PropRow label={<T>Tag</T>}>
<span className={styles.mono}>{image.tag}</span>
</PropRow>
<PropRow label={<T>Image ID</T>}>
<span className={styles.inlineRow}>
<span className={styles.mono} title={image.id}>
{shortId(image.id)}
</span>
<IconButton icon="copy" size="small" title="Copy Image ID" onClick={() => copyText(shortId(image.id))} />
</span>
</PropRow>
<PropRow label={<T>Size</T>}>
<span className={styles.mono}>
{inspect?.size ? `${bytesToUnits(inspect.size)} (${image.size})` : image.size}
</span>
</PropRow>
<PropRow label={<T>Created</T>}>
{inspect?.created ? formatCreatedDetailed(inspect.created) : image.createdSince}
</PropRow>
<PropRow label={<T>Platform</T>} hidden={!inspect?.os && !inspect?.architecture}>
<span className={styles.mono}>{[inspect?.os, inspect?.architecture].filter(Boolean).join("/")}</span>
</PropRow>
<PropRow label={<T>Command</T>} hidden={!inspect?.entrypoint.length && !inspect?.cmd.length}>
<code className={styles.codeInline}>
{[...(inspect?.entrypoint ?? []), ...(inspect?.cmd ?? [])].join(" ")}
</code>
</PropRow>
<PropRow label={<T>Working directory</T>} hidden={!inspect?.workingDir}>
<span className={styles.mono}>{inspect?.workingDir}</span>
</PropRow>
<PropRow label={<T>User</T>} hidden={!inspect?.user}>
<span className={styles.mono}>{inspect?.user}</span>
</PropRow>
<PropRow label={<T>Exposed ports</T>} hidden={!inspect?.exposedPorts.length}>
<div className={styles.chipGroupInline}>
{inspect?.exposedPorts.map((p) => (
<span key={p} className={styles.entityChip}>
<span className={styles.mono}>{p}</span>
</span>
))}
</div>
</PropRow>
</div>
{tags.length > 0 && (
<>
<SectionBanner>
<T>Tags</T>
</SectionBanner>
<div className={styles.chipGroup}>
{tags.map((t) => (
<span key={t} className={styles.entityChip}>
<span className={styles.mono}>{t}</span>
</span>
))}
</div>
</>
)}
<SectionBanner>
<T>Containers Using Image</T>
</SectionBanner>
{usingContainers.length > 0 ? (
<div className={styles.chipGroup}>
{usingContainers.map((c) => (
<ContainerLinkChip key={c.id} conn={conn} container={c} />
))}
</div>
) : (
<div className={styles.emptySection}>
<T>No containers are using this image</T>
</div>
)}
{inspect?.env && inspect.env.length > 0 && (
<>
<SectionBanner>
<T>Environment Variables</T>
</SectionBanner>
<KeyValueTable rows={inspect.env} />
</>
)}
{inspect?.labels && inspect.labels.length > 0 && (
<>
<SectionBanner>
<T>Labels</T>
</SectionBanner>
<KeyValueTable rows={inspect.labels} />
</>
)}
</div>
);
}
export function ImageLayersView({ conn, id }: { conn: string; id: string }) {
const tx = useTx();
const [layers, setLayers] = useState<DockerImageLayer[] | null>(null);
const [error, setError] = useState<string | null>(null);
useEffect(() => {
let alive = true;
call(commands.dockerImageHistory(endpointOf(conn), id))
.then((res) => alive && setLayers(res))
.catch((e) => alive && setError(errorMessage(e)));
return () => {
alive = false;
};
}, [conn, id]);
const maxBytes = useMemo(() => Math.max(1, ...(layers ?? []).map((l) => unitsToBytes(l.size))), [layers]);
if (error) return <div className={styles.loading}>{error}</div>;
if (!layers) {
return (
<div className={styles.loading}>
<Spinner size={14} /> <T>Loading…</T>
</div>
);
}
if (layers.length === 0) return <EmptyState title={tx("No image layers")} />;
return (
<div className={styles.detailBody}>
<div className={styles.tableScroll} tabIndex={0} onKeyDown={copySelectionOnKeyDown}>
<table className={styles.gridTable}>
<thead>
<tr>
<th>#</th>
<th>
<T>Instruction</T>
</th>
<th>
<T>Command</T>
</th>
<th>
<T>Size</T>
</th>
<th>
<T>Created</T>
</th>
</tr>
</thead>
<tbody>
{layers.map((layer, idx) => {
const { instruction, args } = splitLayerInstruction(layer.createdBy);
const bytes = unitsToBytes(layer.size);
const pct = bytes > 0 ? (bytes / maxBytes) * 100 : 0;
return (
<tr key={`${layer.id}:${idx}`}>
<td className={styles.mutedMeta}>{idx + 1}</td>
<td>
<span className={clsx(styles.statusBadge, styles.badgeMuted)}>{instruction}</span>
</td>
<td className={styles.layerCmd} title={layer.createdBy}>
<code>{args || layer.createdBy}</code>
</td>
<td className={styles.layerSizeCell}>
<div className={styles.metricBlock}>
<span className={styles.mono}>{layer.size}</span>
{bytes > 0 && <LineProgress percent={pct} />}
</div>
</td>
<td className={styles.mutedMeta}>{layer.createdSince}</td>
</tr>
);
})}
</tbody>
</table>
</div>
</div>
);
}
// ---------------------------------------------------------------------------
// Volume, Network & Compose Project Dashboards
export function VolumeDashboard({
conn,
volume,
snapshot,
}: {
conn: string;
volume: DockerVolume;
snapshot: DockerSnapshot;
}) {
const target: DockerTarget = { conn, node: { kind: "volume", key: `volume:${volume.name}`, volume } };
const usingContainers = useMemo(() => containersUsingVolume(snapshot, volume), [snapshot, volume]);
const labels = Object.entries(volume.labels ?? {}).sort((a, b) => a[0].localeCompare(b[0]));
return (
<div className={styles.dashboard} tabIndex={0} onKeyDown={copySelectionOnKeyDown}>
<div className={styles.dashboardActions}>
<Button size="small" onClick={() => showDetail("inspect")}>
Inspect
</Button>
<Button size="small" disabled={!canRemove(target)} onClick={() => void remove(target)}>
Delete…
</Button>
</div>
<SectionBanner>
<T>Volume Overview</T>
</SectionBanner>
<div className={styles.propList}>
<PropRow label={<T>Name</T>}>
<span className={styles.mono}>{volume.name}</span>
</PropRow>
<PropRow label={<T>Driver</T>}>
<span className={styles.mono}>{volume.driver}</span>
</PropRow>
<PropRow label={<T>Scope</T>} hidden={!volume.scope}>
<span className={styles.mono}>{volume.scope}</span>
</PropRow>
<PropRow label={<T>Mountpoint</T>} hidden={!volume.mountpoint}>
<span className={styles.inlineRow}>
<span className={styles.mono} title={volume.mountpoint}>
{volume.mountpoint}
</span>
<IconButton icon="copy" size="small" title="Copy Path" onClick={() => copyText(volume.mountpoint)} />
</span>
</PropRow>
<PropRow label={<T>Compose</T>} hidden={!volume.composeProject}>
<span className={styles.mono}>{volume.composeProject}</span>
</PropRow>
</div>
<SectionBanner>
<T>Containers Using Volume</T>
</SectionBanner>
{usingContainers.length > 0 ? (
<div className={styles.chipGroup}>
{usingContainers.map((c) => (
<ContainerLinkChip key={c.id} conn={conn} container={c} />
))}
</div>
) : (
<div className={styles.emptySection}>
<T>No containers are using this volume</T>
</div>
)}
{labels.length > 0 && (
<>
<SectionBanner>
<T>Labels</T>
</SectionBanner>
<KeyValueTable rows={labels} />
</>
)}
</div>
);
}
export function NetworkDashboard({
conn,
network,
snapshot,
inspectText,
}: {
conn: string;
network: DockerNetwork;
snapshot: DockerSnapshot;
inspectText: string | null;
}) {
const target: DockerTarget = { conn, node: { kind: "network", key: `network:${network.id}`, network } };
const inspect = useMemo(() => parseNetworkInspect(inspectText), [inspectText]);
const connected = useMemo(() => containersInNetwork(snapshot, network), [snapshot, network]);
const labels = inspect?.labels.length
? inspect.labels
: Object.entries(network.labels ?? {}).sort((a, b) => a[0].localeCompare(b[0]));
return (
<div className={styles.dashboard} tabIndex={0} onKeyDown={copySelectionOnKeyDown}>
<div className={styles.dashboardActions}>
<Button size="small" onClick={() => showDetail("inspect")}>
Inspect
</Button>
<Button size="small" disabled={!canRemove(target)} onClick={() => void remove(target)}>
Delete…
</Button>
</div>
<SectionBanner>
<T>Network Overview</T>
</SectionBanner>
<div className={styles.propList}>
<PropRow label={<T>Name</T>}>
<span className={styles.mono}>{network.name}</span>
</PropRow>
<PropRow label={<T>Network ID</T>}>
<span className={styles.inlineRow}>
<span className={styles.mono} title={network.id}>
{shortId(network.id)}
</span>
<IconButton icon="copy" size="small" title="Copy" onClick={() => copyText(network.id)} />
</span>
</PropRow>
<PropRow label={<T>Driver</T>}>
<span className={styles.mono}>{network.driver}</span>
</PropRow>
<PropRow label={<T>Scope</T>}>
<span className={styles.mono}>{network.scope}</span>
</PropRow>
<PropRow label={<T>Created</T>} hidden={!inspect?.created && !network.createdAt}>
{formatCreatedDetailed(inspect?.created || network.createdAt)}
</PropRow>
<PropRow label={<T>Subnet / Gateway</T>} hidden={!inspect?.ipamConfigs.length}>
<div className={styles.chipGroupInline}>
{inspect?.ipamConfigs.map((cfg, idx) => (
<span key={idx} className={styles.entityChip}>
<span className={styles.mono}>
{[cfg.subnet, cfg.gateway ? `gw ${cfg.gateway}` : ""].filter(Boolean).join(" · ")}
</span>
</span>
))}
</div>
</PropRow>
<PropRow label={<T>Compose</T>} hidden={!network.composeProject}>
<span className={styles.mono}>{network.composeProject}</span>
</PropRow>
</div>
<SectionBanner>
<T>Connected Containers</T>
</SectionBanner>
{connected.length > 0 ? (
<div className={styles.chipGroup}>
{connected.map((c) => {
const ipInfo = inspect?.containers.find((ic) => ic.id === c.id || ic.name === c.name);
return (
<span key={c.id} className={styles.inlineRow}>
<ContainerLinkChip conn={conn} container={c} />
{ipInfo?.ipv4Address && <span className={styles.mutedMeta}>{ipInfo.ipv4Address}</span>}
</span>
);
})}
</div>
) : (
<div className={styles.emptySection}>
<T>No containers are connected to this network</T>
</div>
)}
{labels.length > 0 && (
<>
<SectionBanner>
<T>Labels</T>
</SectionBanner>
<KeyValueTable rows={labels} />
</>
)}
</div>
);
}
export function ComposeProjectDashboard({
conn,
project,
containers,
}: {
conn: string;
project: string;
containers: DockerContainer[];
}) {
const txTemplate = useTxTemplate();
const target: DockerTarget = {
conn,
node: { kind: "compose", key: `compose:${project}`, project, containers },
};
const first = containers[0];
const runningCount = containers.filter(isRunning).length;
return (
<div className={styles.dashboard} tabIndex={0} onKeyDown={copySelectionOnKeyDown}>
<div className={styles.dashboardActions}>
<Button size="small" disabled={!canStart(target)} onClick={() => void start(target)}>
Start
</Button>
<Button size="small" disabled={!canStop(target)} onClick={() => void stop(target)}>
Stop
</Button>
<Button size="small" disabled={!canRestart(target)} onClick={() => void restart(target)}>
Restart
</Button>
<Button size="small" disabled={!canRemove(target)} onClick={() => void remove(target)}>
Compose Down
</Button>
</div>
<SectionBanner>{txTemplate(`Compose project '${project}'`)}</SectionBanner>
<div className={styles.propList}>
<PropRow label={<T>Project</T>}>
<span className={styles.mono}>{project}</span>
</PropRow>
<PropRow label={<T>Status</T>}>
<span>
{runningCount}/{containers.length} running
</span>
</PropRow>
<PropRow label={<T>Working directory</T>} hidden={!first?.composeWorkingDir}>
<span className={styles.mono}>{first?.composeWorkingDir}</span>
</PropRow>
<PropRow label={<T>Compose files</T>} hidden={!first?.composeFiles.length}>
<span className={styles.mono}>{first?.composeFiles.join(", ")}</span>
</PropRow>
</div>
<SectionBanner>
<T>Services</T>
</SectionBanner>
<div className={styles.chipGroup}>
{containers.map((c) => (
<ContainerLinkChip key={c.id} conn={conn} container={c} />
))}
</div>
</div>
);
}