{#if loading}

{:else if error}

{error}

{:else if containerData} showLogs = false}>Overview showLogs = true}>Logs showLogs = false}>Layers { showLogs = false; if (processesAutoRefresh) startProcessesCollection(); else fetchProcesses(); }}>Processes showLogs = false}>Network showLogs = false}>Mounts showLogs = false}>Files showLogs = false}>Environment showLogs = false}>Security showLogs = false}>Resources showLogs = false}>Health {#if containerData.State?.Running}

CPU {currentStats?.cpuPercent?.toFixed(1) ?? '—'}%

{#if cpuHistory.length >= 2} {:else}

{/if}

Memory {currentStats?.memoryPercent?.toFixed(1) ?? '—'}%

{#if memoryHistory.length >= 2} {:else}

{/if}

{formatBytes(currentStats?.memoryUsage ?? 0)} / {formatBytes(currentStats?.memoryLimit ?? 0)}

Network I/O

RX: {formatBytes(currentStats?.networkRx ?? 0)}

TX: {formatBytes(currentStats?.networkTx ?? 0)}

Disk I/O

Read: {formatBytes(currentStats?.blockRead ?? 0)}

Write: {formatBytes(currentStats?.blockWrite ?? 0)}

{/if}

Status

State

{containerData.State?.Status || 'unknown'}

Restart Policy

{containerData.HostConfig?.RestartPolicy?.Name || 'no'}

Exit Code

{containerData.State?.ExitCode ?? 'N/A'}

Restart Count

{containerData.RestartCount ?? 0}

Basic information

{containerData.Id?.slice(0, 12)}

Platform

{containerData.Platform || 'N/A'}

Created

{formatDate(containerData.Created)}

Started

{formatDate(containerData.State?.StartedAt)}

Image

{containerData.Config?.Image || 'N/A'}

{#if containerData.Path || containerData.Args}

Command


										{containerData.Path || ''} {containerData.Args?.join(' ') || ''}

{/if} {#if containerData.Config?.Labels && Object.keys(containerData.Config.Labels).length > 0}

Labels ({Object.keys(containerData.Config.Labels).length})

{#each Object.entries(containerData.Config.Labels) as [key, value]}

{key} = {value}

{/each}

{/if} {#if !containerData.State?.Running}

Container is not running

{:else if processesLoading}

{:else if processesError}

{processesError}

{:else if processesData && processesData.Processes?.length > 0}

{#each processesData.Titles as title} {/each} {#each processesData.Processes as process, i} {#each process as cell} {/each} {/each}

#	{title}
{i + 1}	{cell}

{processesData.Processes.length} process(es)

{:else}

No processes found

{/if} showLogs = false} /> {#if containerData?.Image} {:else}

No image information available

{/if}

Network mode

{containerData.HostConfig?.NetworkMode || 'default'}

{#if containerData.HostConfig?.Dns?.length > 0 || containerData.HostConfig?.DnsSearch?.length > 0 || containerData.HostConfig?.DnsOptions?.length > 0}

DNS configuration

{#if containerData.HostConfig?.Dns?.length > 0}

DNS Servers

{#each containerData.HostConfig.Dns as dns} {dns} {/each}

{/if} {#if containerData.HostConfig?.DnsSearch?.length > 0}

DNS Search

{#each containerData.HostConfig.DnsSearch as search} {search} {/each}

{/if} {#if containerData.HostConfig?.DnsOptions?.length > 0}

DNS Options

{#each containerData.HostConfig.DnsOptions as opt} {opt} {/each}

{/if}

{/if} {#if containerData.HostConfig?.ExtraHosts?.length > 0}

Extra hosts

{#each containerData.HostConfig.ExtraHosts as host}

{host}

{/each}

{/if} {#if containerData.NetworkSettings?.Networks && Object.keys(containerData.NetworkSettings.Networks).length > 0}

Connected networks

{#each Object.entries(containerData.NetworkSettings.Networks) as [networkName, networkData]}

{networkName} {networkData.NetworkID?.slice(0, 12)}

{#if networkData.IPAddress}

IPv4

{networkData.IPAddress}

{/if} {#if networkData.GlobalIPv6Address}

IPv6

{networkData.GlobalIPv6Address}

{/if} {#if networkData.MacAddress}

MAC

{networkData.MacAddress}

{/if} {#if networkData.Gateway}

Gateway

{networkData.Gateway}

{/if} {#if networkData.Aliases?.length > 0}

Aliases

{networkData.Aliases.join(', ')}

{/if}

{/each}

{/if} {#if containerData.NetworkSettings?.Ports && Object.keys(containerData.NetworkSettings.Ports).length > 0}

Port mappings

{#each Object.entries(containerData.NetworkSettings.Ports) as [containerPort, hostBindings]} {#if hostBindings && hostBindings.length > 0} {#each hostBindings as binding}

{binding.HostIp || '0.0.0.0'}:{binding.HostPort} → {containerPort}

{/each} {:else}

exposed {containerPort}

{/if} {/each}

{/if} {#if containerData.Mounts && containerData.Mounts.length > 0}

{#each containerData.Mounts as mount}

{mount.Type} {mount.RW ? 'Read/Write' : 'Read-Only'}

Source

{mount.Source || mount.Name || 'N/A'}

Destination

{mount.Destination}

{#if mount.Driver}

Driver

{mount.Driver}

{/if} {#if mount.Propagation}

Propagation

{mount.Propagation}

{/if}

{/each}

{:else}

No mounts configured

{/if} {#if containerData.State?.Running && !containerData.State?.Paused} {:else if containerData.State?.Paused}

Container is paused

{:else}

Container is not running

{/if} {#if containerData.Config?.Env && containerData.Config.Env.length > 0}

{#each containerData.Config.Env as envVar} {@const [key, ...valueParts] = envVar.split('=')} {@const value = valueParts.join('=')}

{key} = {value}

{/each}

{:else}

No environment variables

{/if}

Privileged

{containerData.HostConfig?.Privileged ? 'Yes' : 'No'}

Read-only Root

{containerData.HostConfig?.ReadonlyRootfs ? 'Yes' : 'No'}

User

{containerData.Config?.User || 'root'}

User Namespace

{containerData.HostConfig?.UsernsMode || 'host'}

{#if containerData.HostConfig?.SecurityOpt?.length > 0}

Security options

{#each containerData.HostConfig.SecurityOpt as opt}

{opt}

{/each}

{/if}

{#if containerData.AppArmorProfile !== undefined}

AppArmor Profile

{containerData.AppArmorProfile || 'unconfined'}

{/if} {#if containerData.HostConfig?.SecurityOpt?.some((o: string) => o.startsWith('seccomp'))}

Seccomp


										{containerData.HostConfig.SecurityOpt.find((o: string) => o.startsWith('seccomp'))?.split('=')[1] || 'default'}

{/if}

{#if containerData.HostConfig?.CapAdd?.length > 0}

Added capabilities

{#each containerData.HostConfig.CapAdd as cap} {cap} {/each}

{/if} {#if containerData.HostConfig?.CapDrop?.length > 0}

Dropped capabilities

{#each containerData.HostConfig.CapDrop as cap} {cap} {/each}

{/if}

{#if !containerData.HostConfig?.CapAdd?.length && !containerData.HostConfig?.CapDrop?.length && !containerData.HostConfig?.SecurityOpt?.length}

Default security settings

{/if}

Resource limits

CPU Shares

{containerData.HostConfig?.CpuShares || 'default'}

CPUs

{containerData.HostConfig?.NanoCpus ? (containerData.HostConfig.NanoCpus / 1e9).toFixed(2) : 'unlimited'}

Memory

{formatMemory(containerData.HostConfig?.Memory)}

Memory Swap

{formatMemory(containerData.HostConfig?.MemorySwap)}

Memory Reservation

{formatMemory(containerData.HostConfig?.MemoryReservation)}

PIDs Limit

{containerData.HostConfig?.PidsLimit ?? 'unlimited'}

OOM Kill

{containerData.HostConfig?.OomKillDisable ? 'Disabled' : 'Enabled'}

CPU Period/Quota


										{containerData.HostConfig?.CpuPeriod || 0}/{containerData.HostConfig?.CpuQuota || 0}

{#if containerData.HostConfig?.Ulimits?.length > 0}

Ulimits

{#each containerData.HostConfig.Ulimits as ulimit}

{ulimit.Name} soft={ulimit.Soft} hard={ulimit.Hard}

{/each}

{/if} {#if containerData.HostConfig?.Devices?.length > 0}

Devices

{#each containerData.HostConfig.Devices as device}

{device.PathOnHost} → {device.PathInContainer} {#if device.CgroupPermissions} {device.CgroupPermissions} {/if}

{/each}

{/if}

Cgroup settings

Cgroup

{containerData.HostConfig?.Cgroup || 'default'}

Cgroup Parent

{containerData.HostConfig?.CgroupParent || 'default'}

Cgroupns Mode

{containerData.HostConfig?.CgroupnsMode || 'host'}

{#if containerData.State?.Health}

Status

{containerData.State.Health.Status}

Failing Streak

{containerData.State.Health.FailingStreak || 0}

{#if containerData.State.Health.Log && containerData.State.Health.Log.length > 0}

Health check log

{#each containerData.State.Health.Log.slice(-5) as log}

Exit: {log.ExitCode} {formatDate(log.End)}

{#if log.Output} {log.Output.trim()} {/if}

{/each}

{/if}

{:else}

No health check configured

{/if} {/if}