dockza.app 0.2.0

package/dist/docker/networks.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countContainersByNetwork = countContainersByNetwork;
+exports.toNetworkInfo = toNetworkInfo;
+exports.listNetworks = listNetworks;
+exports.removeNetwork = removeNetwork;
+const client_1 = require("./client");
+// Docker's predefined networks can never be removed.
+const BUILTIN_NETWORKS = new Set(['bridge', 'host', 'none']);
+/**
+ * Tally how many containers are attached to each network, keyed by network NAME.
+ *
+ * We key by name (the `NetworkSettings.Networks` map key), not the endpoint's
+ * `NetworkID`: a stopped container can carry a *stale* NetworkID — the default
+ * `bridge` network is recreated with a fresh ID on daemon restart, so an exited
+ * container keeps pointing at the old ID and would never match the live network.
+ * Docker forbids two networks sharing a name on one daemon, so the name is a
+ * stable, unique key; it is also what the Containers view stores/shows
+ * (`toContainerInfo`), keeping the two views consistent. Counts every attached
+ * container regardless of state, like images/volumes derive their in-use flag
+ * from `listContainers({ all: true })`.
+ */
+function countContainersByNetwork(rawContainers) {
+    const counts = new Map();
+    for (const c of rawContainers) {
+        for (const name of Object.keys(c.NetworkSettings?.Networks ?? {})) {
+            counts.set(name, (counts.get(name) ?? 0) + 1);
+        }
+    }
+    return counts;
+}
+function toNetworkInfo(raw, containerCount) {
+    return {
+        id: raw.Id,
+        name: raw.Name,
+        driver: raw.Driver ?? '',
+        scope: raw.Scope ?? '',
+        created: raw.Created ? new Date(raw.Created) : new Date(0),
+        containerCount,
+        inUse: containerCount > 0,
+        builtin: BUILTIN_NETWORKS.has(raw.Name),
+    };
+}
+async function listNetworks() {
+    try {
+        const [rawNetworks, rawContainers] = await Promise.all([
+            client_1.dockerode.listNetworks(),
+            client_1.dockerode.listContainers({ all: true }),
+        ]);
+        const counts = countContainersByNetwork(rawContainers);
+        return rawNetworks
+            .sort((a, b) => (a.Name ?? '').localeCompare(b.Name ?? ''))
+            .map((net) => toNetworkInfo(net, counts.get(net.Name) ?? 0));
+    }
+    catch (err) {
+        throw new Error(`Failed to list networks: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+async function removeNetwork(id) {
+    try {
+        await client_1.dockerode.getNetwork(id).remove();
+    }
+    catch (err) {
+        throw new Error(`Failed to remove network ${id}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}

package/dist/docker/volumes.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listVolumes = listVolumes;
+exports.removeVolume = removeVolume;
+const client_1 = require("./client");
+async function listVolumes() {
+    try {
+        const [volumesResponse, rawContainers, dfData] = await Promise.all([
+            client_1.dockerode.listVolumes(),
+            client_1.dockerode.listContainers({ all: true }),
+            client_1.dockerode.df().catch(() => ({ Volumes: [] })),
+        ]);
+        const usedVolumeNames = new Set(rawContainers.flatMap((c) => c.Mounts.map((m) => m.Name ?? '').filter(Boolean)));
+        const df = dfData;
+        const dfSizes = new Map((df.Volumes ?? [])
+            .filter((v) => typeof v.Name === 'string')
+            .map((v) => [v.Name, v.UsageData?.Size ?? -1]));
+        return (volumesResponse.Volumes ?? [])
+            .sort((a, b) => a.Name.localeCompare(b.Name))
+            .map((vol) => {
+            const sizeBytes = dfSizes.get(vol.Name) ?? -1;
+            const createdAt = vol.CreatedAt;
+            return {
+                name: vol.Name,
+                driver: vol.Driver,
+                mountpoint: vol.Mountpoint,
+                created: createdAt ? new Date(createdAt) : new Date(0),
+                sizeMB: sizeBytes > 0 ? sizeBytes / 1024 / 1024 : 0,
+                inUse: usedVolumeNames.has(vol.Name),
+            };
+        });
+    }
+    catch (err) {
+        throw new Error(`Failed to list volumes: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+async function removeVolume(name) {
+    try {
+        await client_1.dockerode.getVolume(name).remove();
+    }
+    catch (err) {
+        throw new Error(`Failed to remove volume ${name}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}

package/dist/models/docker.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/theme.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.t = exports.C = void 0;
+exports.C = {
+    // backgrounds
+    bg: '#0a0908',
+    bgSoft: '#0f0d0c',
+    bgAlt: '#0f0d0c', // alias of bgSoft
+    panel: '#13110f',
+    bgSel: '#1a1840',
+    selection: '#1a1840', // alias of bgSel
+    bgSelEdge: '#6366f1',
+    // text
+    fg: '#e8e4d8',
+    dim: '#8a8782',
+    comment: '#8a8782', // alias of dim
+    faint: '#5a5853',
+    // rules / dividers
+    rule: '#231f1c',
+    rule2: '#2e2925',
+    // accents
+    accent: '#a5a0ff',
+    purple: '#6366f1',
+    green: '#5ed68a',
+    aqua: '#5eead4',
+    cyan: '#5eead4', // alias of aqua
+    yellow: '#f4c64a',
+    orange: '#fb923c',
+    red: '#f87171',
+    pink: '#f472b6',
+};
+const tag = (hex, text) => `{${hex}-fg}${text}{/}`;
+exports.t = {
+    bg: (s) => tag(exports.C.bg, s),
+    bgSoft: (s) => tag(exports.C.bgSoft, s),
+    bgAlt: (s) => tag(exports.C.bgAlt, s),
+    panel: (s) => tag(exports.C.panel, s),
+    bgSel: (s) => tag(exports.C.bgSel, s),
+    selection: (s) => tag(exports.C.selection, s),
+    fg: (s) => tag(exports.C.fg, s),
+    dim: (s) => tag(exports.C.dim, s),
+    comment: (s) => tag(exports.C.comment, s),
+    faint: (s) => tag(exports.C.faint, s),
+    rule: (s) => tag(exports.C.rule, s),
+    rule2: (s) => tag(exports.C.rule2, s),
+    accent: (s) => tag(exports.C.accent, s),
+    purple: (s) => tag(exports.C.purple, s),
+    green: (s) => tag(exports.C.green, s),
+    aqua: (s) => tag(exports.C.aqua, s),
+    cyan: (s) => tag(exports.C.cyan, s),
+    yellow: (s) => tag(exports.C.yellow, s),
+    orange: (s) => tag(exports.C.orange, s),
+    red: (s) => tag(exports.C.red, s),
+    pink: (s) => tag(exports.C.pink, s),
+};

package/dist/ui/app.js

@@ -0,0 +1,517 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.App = void 0;
+const neo_blessed_1 = __importDefault(require("neo-blessed"));
+const client_1 = require("../docker/client");
+const containers_1 = require("../docker/containers");
+const images_1 = require("../docker/images");
+const volumes_1 = require("../docker/volumes");
+const networks_1 = require("../docker/networks");
+const stacks_1 = require("../utils/stacks");
+const status_1 = require("../utils/status");
+const top_bar_1 = require("./top-bar");
+const footer_1 = require("./footer");
+const side_rail_1 = require("./side-rail");
+const help_overlay_1 = require("./help-overlay");
+const stacks_tab_1 = require("./stacks/stacks-tab");
+const containers_tab_1 = require("./containers/containers-tab");
+const images_tab_1 = require("./images/images-tab");
+const volumes_tab_1 = require("./volumes/volumes-tab");
+const networks_tab_1 = require("./networks/networks-tab");
+const VIEW_ORDER = ['stacks', 'containers', 'images', 'volumes', 'networks'];
+const msgOf = (err) => (err instanceof Error ? err.message : String(err));
+class App {
+    screen;
+    topBar;
+    footer;
+    rail;
+    helpOverlay;
+    stacksTab;
+    containersTab;
+    imagesTab;
+    volumesTab;
+    networksTab;
+    activeView = 'stacks';
+    overlayOpen = false;
+    containers = [];
+    stacks = [];
+    imageCount = 0;
+    volumeCount = 0;
+    networkCount = 0;
+    aggregateStats = null;
+    pollTimers = [];
+    footerMsgTimer = null;
+    exitResolve = null;
+    pollingContainers = false;
+    pollingResources = false;
+    pollingStats = false;
+    constructor() {
+        this.screen = neo_blessed_1.default.screen({
+            smartCSR: true,
+            mouse: true,
+            fullUnicode: true,
+            title: 'dockza',
+            terminal: 'xterm-256color',
+        });
+        const tabDims = {
+            top: 1,
+            left: side_rail_1.RAIL_WIDTH,
+            width: `100%-${side_rail_1.RAIL_WIDTH}`,
+            height: '100%-2',
+        };
+        this.topBar = new top_bar_1.TopBar(this.screen);
+        this.footer = new footer_1.Footer(this.screen);
+        this.rail = new side_rail_1.SideRail(this.screen);
+        this.helpOverlay = new help_overlay_1.HelpOverlay(this.screen);
+        this.stacksTab = new stacks_tab_1.StacksTab(this.screen, tabDims);
+        this.containersTab = new containers_tab_1.ContainersTab(this.screen, tabDims);
+        this.imagesTab = new images_tab_1.ImagesTab(this.screen, tabDims);
+        this.volumesTab = new volumes_tab_1.VolumesTab(this.screen, tabDims);
+        this.networksTab = new networks_tab_1.NetworksTab(this.screen, tabDims);
+        this.wireEvents();
+        this.setupKeys();
+        this.screen.on('destroy', () => this.stopPolling());
+        this.screen.on('resize', () => this.handleResize());
+        const externalShutdown = () => this.shutdown();
+        process.once('SIGTERM', externalShutdown);
+        process.once('SIGHUP', externalShutdown);
+    }
+    wireEvents() {
+        this.helpOverlay.on('hide', () => {
+            this.overlayOpen = false;
+            this.render();
+        });
+        this.rail.on('view-change', (id) => {
+            if (!this.canSwitchView())
+                return;
+            this.showView(id);
+        });
+        this.rail.on('stack-jump', (stackId) => {
+            if (!this.canSwitchView())
+                return;
+            this.showView('stacks');
+            this.stacksTab.jumpToStack(stackId);
+            this.render();
+        });
+        this.stacksTab.on('error', (msg) => this.setFooterMessage(msg, 'red'));
+        this.stacksTab.on('stack-update', (stacks) => {
+            this.stacks = stacks;
+            this.rail.setStacks(stacks);
+            this.refreshTopBarCounters();
+        });
+        this.stacksTab.on('navigate', (sel) => {
+            if (this.activeView !== 'stacks')
+                return;
+            this.footer.setContext(this.contextForStacks(sel));
+            this.render();
+        });
+        this.stacksTab.on('detail-open', () => {
+            if (this.activeView === 'stacks') {
+                this.footer.setContext('detail');
+                this.render();
+            }
+        });
+        this.stacksTab.on('log-open', () => {
+            if (this.activeView === 'stacks') {
+                this.footer.setContext('log');
+                this.render();
+            }
+        });
+        this.stacksTab.on('log-follow-change', () => {
+            if (this.activeView === 'stacks') {
+                this.footer.setContext('log');
+                this.render();
+            }
+        });
+        this.containersTab.on('error', (msg) => this.setFooterMessage(msg, 'red'));
+        this.containersTab.on('select', (c) => {
+            if (this.activeView !== 'containers')
+                return;
+            this.footer.setContext(this.contextForContainer(c));
+            this.render();
+        });
+        this.containersTab.on('detail-open', () => {
+            if (this.activeView === 'containers') {
+                this.footer.setContext('detail');
+                this.render();
+            }
+        });
+        this.containersTab.on('log-open', () => {
+            if (this.activeView === 'containers') {
+                this.footer.setContext('log');
+                this.render();
+            }
+        });
+        this.containersTab.on('log-follow-change', () => {
+            if (this.activeView === 'containers') {
+                this.footer.setContext('log');
+                this.render();
+            }
+        });
+        this.imagesTab.on('error', (msg) => this.setFooterMessage(msg, 'red'));
+        this.imagesTab.on('navigate', () => {
+            if (this.activeView === 'images') {
+                this.footer.setContext('images');
+                this.render();
+            }
+        });
+        this.volumesTab.on('error', (msg) => this.setFooterMessage(msg, 'red'));
+        this.volumesTab.on('navigate', () => {
+            if (this.activeView === 'volumes') {
+                this.footer.setContext('volumes');
+                this.render();
+            }
+        });
+        this.networksTab.on('error', (msg) => this.setFooterMessage(msg, 'red'));
+        this.networksTab.on('navigate', () => {
+            if (this.activeView === 'networks') {
+                this.footer.setContext('networks');
+                this.render();
+            }
+        });
+    }
+    contextForStacks(sel) {
+        if (!sel)
+            return 'global';
+        if (sel.kind === 'stack')
+            return 'stacks-tree-stack';
+        return (0, status_1.isActive)(sel.container.status) ? 'stacks-tree-running' : 'stacks-tree-stopped';
+    }
+    contextForContainer(c) {
+        if (!c)
+            return 'containers-empty';
+        return (0, status_1.isActive)(c.status) ? 'containers-running' : 'containers-stopped';
+    }
+    toggleHelp = () => {
+        if (this.overlayOpen) {
+            this.helpOverlay.hide();
+            return;
+        }
+        if (this.isHelpBlocked())
+            return;
+        this.overlayOpen = true;
+        this.helpOverlay.show();
+    };
+    setupKeys() {
+        this.screen.key('tab', () => {
+            if (!this.canSwitchView())
+                return;
+            const idx = (VIEW_ORDER.indexOf(this.activeView) + 1) % VIEW_ORDER.length;
+            this.showView(VIEW_ORDER[idx]);
+        });
+        this.screen.key('S-tab', () => {
+            if (!this.canSwitchView())
+                return;
+            const idx = (VIEW_ORDER.indexOf(this.activeView) + VIEW_ORDER.length - 1) % VIEW_ORDER.length;
+            this.showView(VIEW_ORDER[idx]);
+        });
+        for (let i = 0; i < VIEW_ORDER.length; i++) {
+            const view = VIEW_ORDER[i];
+            this.screen.key(String(i + 1), () => {
+                if (!this.canSwitchView())
+                    return;
+                this.showView(view);
+            });
+        }
+        this.screen.key(['h'], this.toggleHelp);
+        this.screen.key(['q', 'C-c'], () => {
+            if (this.overlayOpen || this.isModalOpen())
+                return;
+            this.shutdown();
+        });
+    }
+    canSwitchView() {
+        return !this.overlayOpen && !this.isModalOpen();
+    }
+    isModalOpen() {
+        return (this.stacksTab.isOverlayOpen() ||
+            this.containersTab.isOverlayOpen() ||
+            this.imagesTab.isConfirmOpen() ||
+            this.volumesTab.isConfirmOpen() ||
+            this.networksTab.isConfirmOpen() ||
+            this.isFilterOpen());
+    }
+    isFilterOpen() {
+        return this.stacksTab.isFilterOpen();
+    }
+    isHelpBlocked() {
+        return (this.stacksTab.isConfirmOpen() ||
+            this.containersTab.isConfirmOpen() ||
+            this.imagesTab.isConfirmOpen() ||
+            this.volumesTab.isConfirmOpen() ||
+            this.networksTab.isConfirmOpen() ||
+            this.isFilterOpen());
+    }
+    showView(id) {
+        if (this.activeView === id)
+            return;
+        this.hideTab(this.activeView);
+        this.activeView = id;
+        this.showTab(id);
+        this.rail.setActiveView(id);
+        this.footer.setContext(this.defaultContextFor(id));
+        this.render();
+    }
+    hideTab(id) {
+        switch (id) {
+            case 'stacks':
+                this.stacksTab.hide();
+                break;
+            case 'containers':
+                this.containersTab.hide();
+                break;
+            case 'images':
+                this.imagesTab.hide();
+                break;
+            case 'volumes':
+                this.volumesTab.hide();
+                break;
+            case 'networks':
+                this.networksTab.hide();
+                break;
+        }
+    }
+    showTab(id) {
+        switch (id) {
+            case 'stacks':
+                this.stacksTab.show();
+                break;
+            case 'containers':
+                this.containersTab.show();
+                break;
+            case 'images':
+                this.imagesTab.show();
+                break;
+            case 'volumes':
+                this.volumesTab.show();
+                break;
+            case 'networks':
+                this.networksTab.show();
+                break;
+        }
+    }
+    defaultContextFor(id) {
+        switch (id) {
+            case 'stacks':
+                return this.contextForStacks(this.stacksTab.getSelected());
+            case 'containers':
+                return this.contextForContainer(this.containersTab.getSelected());
+            case 'images':
+                return 'images';
+            case 'volumes':
+                return 'volumes';
+            case 'networks':
+                return 'networks';
+        }
+    }
+    render() {
+        this.screen.render();
+    }
+    setFooterMessage(text, color, duration = 3000) {
+        if (this.footerMsgTimer)
+            clearTimeout(this.footerMsgTimer);
+        this.footer.setMessage({ text, color });
+        this.render();
+        this.footerMsgTimer = setTimeout(() => {
+            this.footerMsgTimer = null;
+            this.footer.setMessage(null);
+            this.render();
+        }, duration);
+    }
+    async start() {
+        const dockerVersion = await (0, client_1.getDockerVersion)();
+        this.topBar.setSocketPath((0, client_1.getDockerSocketLabel)());
+        this.topBar.setDockerVersion(dockerVersion);
+        this.topBar.setCounters({ running: 0, errored: 0, stopped: 0 });
+        this.topBar.render();
+        this.rail.setActiveView('stacks');
+        this.rail.setCounts({ stacks: 0, containers: 0, images: 0, volumes: 0, networks: 0 });
+        this.footer.setContext('global');
+        this.footer.startTicker(() => this.render());
+        this.stacksTab.showLoading();
+        this.containersTab.showLoading();
+        this.imagesTab.showLoading();
+        this.volumesTab.showLoading();
+        this.networksTab.showLoading();
+        this.showTab('stacks');
+        this.render();
+        await this.pollContainers();
+        await this.pollResources();
+        this.pollTimers.push(setInterval(() => {
+            void this.pollContainers();
+        }, 5000), setInterval(() => {
+            void this.pollResources();
+        }, 10000), setInterval(() => {
+            void this.pollStats();
+        }, 2000));
+        return new Promise((resolve) => {
+            this.exitResolve = resolve;
+        });
+    }
+    async pollContainers() {
+        if (this.pollingContainers)
+            return;
+        this.pollingContainers = true;
+        try {
+            const containers = await (0, containers_1.listContainers)();
+            this.containers = containers;
+            this.stacks = (0, stacks_1.groupIntoStacks)(containers);
+            this.stacksTab.setData(containers, this.stacks);
+            this.containersTab.setData(containers);
+            this.rail.setStacks(this.stacks);
+            this.refreshTopBarCounters();
+            this.refreshRailCounts();
+            this.footer.noteRefresh();
+            this.render();
+        }
+        catch (err) {
+            this.setFooterMessage(err instanceof Error ? err.message : String(err), 'red');
+        }
+        finally {
+            this.pollingContainers = false;
+        }
+    }
+    async pollResources() {
+        if (this.pollingResources)
+            return;
+        this.pollingResources = true;
+        try {
+            // Settle each resource independently so one listing's failure doesn't blank the others.
+            const [imagesR, volumesR, networksR] = await Promise.allSettled([
+                (0, images_1.listImages)(),
+                (0, volumes_1.listVolumes)(),
+                (0, networks_1.listNetworks)(),
+            ]);
+            const errors = [];
+            if (imagesR.status === 'fulfilled') {
+                this.imageCount = imagesR.value.length;
+                this.imagesTab.setData(imagesR.value);
+            }
+            else {
+                errors.push(msgOf(imagesR.reason));
+            }
+            if (volumesR.status === 'fulfilled') {
+                this.volumeCount = volumesR.value.length;
+                this.volumesTab.setData(volumesR.value);
+            }
+            else {
+                errors.push(msgOf(volumesR.reason));
+            }
+            if (networksR.status === 'fulfilled') {
+                this.networkCount = networksR.value.length;
+                this.networksTab.setData(networksR.value);
+            }
+            else {
+                errors.push(msgOf(networksR.reason));
+            }
+            this.refreshRailCounts();
+            if (errors.length > 0) {
+                this.setFooterMessage(errors[0], 'red');
+            }
+            else {
+                this.footer.noteRefresh();
+            }
+            this.render();
+        }
+        catch (err) {
+            this.setFooterMessage(msgOf(err), 'red');
+        }
+        finally {
+            this.pollingResources = false;
+        }
+    }
+    async pollStats() {
+        if (this.pollingStats)
+            return;
+        this.pollingStats = true;
+        try {
+            await this.doPollStats();
+        }
+        finally {
+            this.pollingStats = false;
+        }
+    }
+    async doPollStats() {
+        const running = this.containers.filter((c) => (0, status_1.isActive)(c.status));
+        await Promise.allSettled(running.map(async (c) => {
+            try {
+                const stats = await (0, containers_1.fetchStats)(c.id);
+                this.stacksTab.updateStats(c.id, stats);
+                this.containersTab.updateStats(c.id, stats);
+            }
+            catch {
+                // ignore per-container stats errors
+            }
+        }));
+        if (running.length > 0) {
+            this.aggregateStats = this.stacksTab.getAggregateStats();
+            this.stacksTab.refreshStats();
+            this.containersTab.refreshListStats();
+            this.topBar.setStats(this.aggregateStats);
+            this.footer.noteRefresh();
+        }
+        else {
+            this.aggregateStats = null;
+            this.topBar.setStats(null);
+        }
+        this.render();
+    }
+    refreshTopBarCounters() {
+        let running = 0;
+        let errored = 0;
+        let stopped = 0;
+        for (const c of this.containers) {
+            if (c.status === 'running' || c.status === 'paused' || c.status === 'restarting')
+                running++;
+            else if ((c.status === 'exited' || c.status === 'dead') && c.exitCode !== 0)
+                errored++;
+            else
+                stopped++;
+        }
+        this.topBar.setCounters({ running, errored, stopped });
+    }
+    refreshRailCounts() {
+        this.rail.setCounts({
+            stacks: this.stacks.length,
+            containers: this.containers.length,
+            images: this.imageCount,
+            volumes: this.volumeCount,
+            networks: this.networkCount,
+        });
+    }
+    handleResize() {
+        this.stacksTab.redraw();
+        this.containersTab.setData(this.containers);
+        this.imagesTab.redraw();
+        this.volumesTab.redraw();
+        this.networksTab.redraw();
+        this.topBar.render();
+        this.footer.render();
+        this.render();
+    }
+    stopPolling() {
+        for (const timer of this.pollTimers)
+            clearInterval(timer);
+        this.pollTimers = [];
+        this.footer.stopTicker();
+    }
+    shutdown() {
+        this.stopPolling();
+        if (this.footerMsgTimer) {
+            clearTimeout(this.footerMsgTimer);
+            this.footerMsgTimer = null;
+        }
+        this.stacksTab.cleanup();
+        this.containersTab.cleanup();
+        this.screen.destroy();
+        if (this.exitResolve) {
+            const resolve = this.exitResolve;
+            this.exitResolve = null;
+            resolve();
+        }
+    }
+}
+exports.App = App;