dockscope 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Manuel Tomé
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,168 @@
+# DockScope
+
+**Visual, interactive Docker infrastructure debugger.**
+
+A browser-based 3D dependency graph of your Docker services with live health status, log streams, metrics, and container actions. Think of it as a mission control dashboard for your Docker Compose stacks.
+
+## Features
+
+- **3D Force Graph** — Containers rendered as interactive nodes with dependency and network links
+- **Live Health Status** — Real-time container state with color-coded nodes (healthy, unhealthy, stopped)
+- **Log Streaming** — Live container logs with ANSI color support, timestamp shortening, and search
+- **Container Actions** — Start, stop, restart containers directly from the UI
+- **Compose Project Management** — Up, down, stop, restart entire compose projects
+- **Environment Inspector** — View env vars (with secret masking), labels, mounts, and config
+- **Metrics & Sparklines** — CPU, memory, and network I/O with 5-minute history charts
+- **Node Importance Heuristic** — Nodes sized by exposed ports, connections, dependency depth, CPU, memory, network I/O, and network count
+- **Project Clustering** — Compose projects grouped with translucent enclosure spheres and labels
+- **Health Propagation** — Pulsing warning rings on containers whose dependencies are broken
+- **Search & Filter** — Search by name/image, filter by status (running/stopped/unhealthy)
+- **Keyboard Shortcuts** — `/` search, `F` zoom-to-fit, `R` reset camera, `Esc` close, `?` help
+- **Resizable Panels** — Drag to resize sidebar and status bar
+- **Event Stream** — Live Docker events with health check toggle
+- **System Info** — Docker version, CPU count, total memory
+
+## Quick Start
+
+```bash
+npx dockscope up
+```
+
+Or install globally:
+
+```bash
+npm install -g dockscope
+dockscope up
+```
+
+Requires Docker to be running. Opens a browser at `http://localhost:4681`.
+
+### Options
+
+```
+dockscope up [options]
+
+  -p, --port <port>   Server port (default: 4681)
+  -f, --file <path>   Docker Compose file path (default: auto-detect)
+  --no-open           Don't open browser automatically
+```
+
+### Scan Mode
+
+Output the container graph as JSON (no UI):
+
+```bash
+dockscope scan
+```
+
+## Development
+
+```bash
+git clone https://github.com/ManuelR-T/dockscope.git
+cd dockscope
+npm install
+npm run dev
+```
+
+This starts the backend on port `4681` and the Vite dev server on port `4680` with hot reload.
+
+### Scripts
+
+| Command | Description |
+|---------|-------------|
+| `npm run dev` | Start dev server (backend + frontend with HMR) |
+| `npm run build` | Production build |
+| `npm run start` | Run production build |
+| `npm run lint` | ESLint check |
+| `npm run lint:fix` | ESLint auto-fix |
+| `npm run format` | Prettier format all files |
+| `npm run format:check` | Prettier check |
+| `npm run typecheck` | TypeScript type check |
+
+## Tech Stack
+
+| Layer | Technology |
+|-------|-----------|
+| **Frontend** | Svelte 5 (runes), Three.js, 3d-force-graph, three-spritetext |
+| **Backend** | Express, WebSocket (ws), dockerode |
+| **Build** | Vite, TypeScript (ESNext) |
+| **CLI** | Commander |
+| **Linting** | ESLint, Prettier, commitlint (conventional commits) |
+| **CI/CD** | GitHub Actions (lint, typecheck, build, auto-release to npm) |
+
+## Architecture
+
+```
+Docker daemon
+  |
+  +--> dockerode (client.ts, metrics.ts, logs.ts, links.ts)
+  |      |
+  |      +--> Express REST API (routes.ts)
+  |      +--> WebSocket broadcasts (server/index.ts)
+  |             |
+  |             +--> Svelte 5 store (docker.svelte.ts)
+  |                    |
+  |                    +--> GraphView.svelte (3d-force-graph + Three.js)
+  |                    +--> Sidebar (Info / Env / Logs tabs)
+  |                    +--> StatusBar (event stream + system info)
+  |
+  +--> Compose parser (compose.ts)
+         |
+         +--> depends_on + network link extraction
+```
+
+### API Endpoints
+
+| Method | Path | Description |
+|--------|------|-------------|
+| GET | `/api/graph` | Full graph data (nodes + links) |
+| GET | `/api/containers/:id/stats` | CPU, memory, network I/O |
+| GET | `/api/containers/:id/logs` | Container logs |
+| GET | `/api/containers/:id/inspect` | Env, labels, mounts, config |
+| GET | `/api/containers/:id/history` | Metric history (sparkline data) |
+| POST | `/api/containers/:id/start\|stop\|restart` | Container actions |
+| GET | `/api/projects` | List compose projects |
+| POST | `/api/projects/:name/up\|down\|stop\|start\|restart` | Project actions |
+| GET | `/api/system` | Docker version, CPUs, memory |
+| WS | `/ws` | Real-time graph, stats, events, log streaming |
+
+### Keyboard Shortcuts
+
+| Key | Action |
+|-----|--------|
+| `/` or `Ctrl+K` | Focus search |
+| `Escape` | Close panel / clear search |
+| `F` | Zoom to fit |
+| `R` | Reset camera |
+| `?` | Toggle shortcut help |
+
+## Contributing
+
+This project uses [Conventional Commits](https://www.conventionalcommits.org/). All commit messages must follow the format:
+
+```
+type(scope): description
+
+feat: add new feature
+fix: fix a bug
+docs: update documentation
+refactor: code restructuring
+chore: maintenance tasks
+```
+
+### Setup
+
+1. Fork the repo on GitHub
+2. Clone your fork: `git clone https://github.com/<your-username>/dockscope.git`
+3. `npm install`
+4. Create a branch: `git checkout -b feat/my-feature`
+5. `npm run dev` to start development
+6. Make your changes
+7. `npm run lint && npm run format:check && npm run build` to verify
+8. Commit with conventional messages: `git commit -m "feat: add my feature"`
+9. Push to your fork: `git push origin feat/my-feature`
+10. Open a PR against `main` on the upstream repo
+
+## License
+
+[MIT](LICENSE)

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { startServer } from './server/index.js';
+import { buildGraph, checkConnection } from './docker/client.js';
+const program = new Command();
+program
+    .name('dockscope')
+    .description('Visual, interactive Docker infrastructure debugger')
+    .version('0.1.0');
+program
+    .command('up')
+    .description('Start the DockScope dashboard')
+    .option('-p, --port <port>', 'Server port', '4681')
+    .option('-f, --file <path>', 'Docker Compose file path', 'docker-compose.yml')
+    .option('--no-open', "Don't open browser automatically")
+    .action(async (opts) => {
+    const port = parseInt(opts.port, 10);
+    console.log(`
+  ____             _    ____
+ |  _ \\  ___   ___| | _/ ___|  ___ ___  _ __   ___
+ | | | |/ _ \\ / __| |/ \\___ \\ / __/ _ \\| '_ \\ / _ \\
+ | |_| | (_) | (__|   < ___) | (_| (_) | |_) |  __/
+ |____/ \\___/ \\___|_|\\_\\____/ \\___\\___/| .__/ \\___|
+                                       |_|  v0.1.0
+`);
+    await startServer({ port, composeFile: opts.file, open: opts.open !== false });
+    const url = `http://localhost:${port}`;
+    console.log(`  Dashboard: ${url}`);
+    console.log(`  API:       ${url}/api/graph`);
+    console.log(`  WebSocket: ws://localhost:${port}/ws\n`);
+    console.log('');
+    console.log('  Press Ctrl+C to stop\n');
+    if (opts.open !== false) {
+        const open = (await import('open')).default;
+        await open(url);
+    }
+});
+program
+    .command('scan')
+    .description('Scan Docker environment and output graph data as JSON')
+    .option('-f, --file <path>', 'Docker Compose file path', 'docker-compose.yml')
+    .action(async (opts) => {
+    const connected = await checkConnection();
+    if (!connected) {
+        console.error('Cannot connect to Docker daemon. Is Docker running?');
+        process.exit(1);
+    }
+    const graph = await buildGraph(opts.file);
+    console.log(JSON.stringify(graph, null, 2));
+});
+program.parse();

package/dist/docker/client.d.ts

@@ -0,0 +1,18 @@
+import type { GraphData, ContainerStats, ContainerInspect, SystemInfo, DockerEvent } from '../types.js';
+export declare function checkConnection(): Promise<boolean>;
+export declare function buildGraph(composeFile?: string): Promise<GraphData>;
+export declare const getContainerStats: (id: string) => Promise<ContainerStats>;
+export declare const getContainerLogs: (id: string, tail?: number) => Promise<string>;
+export declare const streamContainerLogs: (id: string, onData: (t: string) => void, onError?: (e: Error) => void) => () => void;
+/** List all compose projects (live + cached) with their container counts */
+export declare function listComposeProjects(): Promise<{
+    name: string;
+    running: number;
+    stopped: number;
+}[]>;
+/** Run a docker compose action on a specific project */
+export declare function composeAction(project: string, action: 'up' | 'down' | 'stop' | 'start' | 'restart'): Promise<string>;
+export declare function containerAction(containerId: string, action: 'start' | 'stop' | 'restart'): Promise<void>;
+export declare function inspectContainer(containerId: string): Promise<ContainerInspect>;
+export declare function getSystemInfo(): Promise<SystemInfo>;
+export declare function watchEvents(callback: (event: DockerEvent) => void, onError?: (err: Error) => void): () => void;

package/dist/docker/client.js

@@ -0,0 +1,250 @@
+import Dockerode from 'dockerode';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { getContainerStats as _getStats } from './metrics.js';
+import { getContainerLogs as _getLogs, streamContainerLogs as _streamLogs } from './logs.js';
+import { extractDependsOnFromLabels, extractDependsOnFromFile, extractNetworkLinks, } from './links.js';
+const docker = new Dockerode();
+export async function checkConnection() {
+    try {
+        await docker.ping();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function buildGraph(composeFile) {
+    const containers = await docker.listContainers({ all: true });
+    const nodes = [];
+    const networkMap = new Map();
+    const containerProject = new Map();
+    for (const container of containers) {
+        const composeService = container.Labels['com.docker.compose.service'];
+        const project = container.Labels['com.docker.compose.project'] || '';
+        const rawName = composeService || container.Names[0]?.replace(/^\//, '') || container.Id.substring(0, 12);
+        const hasDuplicate = containers.some((c) => c.Id !== container.Id &&
+            (c.Labels['com.docker.compose.service'] || c.Names[0]?.replace(/^\//, '')) === rawName &&
+            (c.Labels['com.docker.compose.project'] || '') !== project);
+        const serviceName = hasDuplicate && project ? `${project}/${rawName}` : rawName;
+        const shortId = container.Id.substring(0, 12);
+        containerProject.set(shortId, project);
+        const healthStatus = container.Status?.toLowerCase() || '';
+        let health = 'none';
+        if (healthStatus.includes('healthy') && !healthStatus.includes('unhealthy'))
+            health = 'healthy';
+        else if (healthStatus.includes('unhealthy'))
+            health = 'unhealthy';
+        else if (healthStatus.includes('starting') || healthStatus.includes('health:'))
+            health = 'starting';
+        nodes.push({
+            id: shortId,
+            name: serviceName,
+            project,
+            containerId: container.Id,
+            image: container.Image,
+            status: container.State,
+            health,
+            ports: [
+                ...new Set(container.Ports.map((p) => `${p.PublicPort ? p.PublicPort + ':' : ''}${p.PrivatePort}/${p.Type}`)),
+            ],
+            networks: Object.keys(container.NetworkSettings?.Networks || {}),
+            cpu: 0,
+            memory: 0,
+            memoryLimit: 0,
+            networkRx: 0,
+            networkTx: 0,
+            networkRxRate: 0,
+            networkTxRate: 0,
+        });
+        for (const net of Object.keys(container.NetworkSettings?.Networks || {})) {
+            if (!networkMap.has(net))
+                networkMap.set(net, []);
+            networkMap.get(net).push(shortId);
+        }
+    }
+    // Build links from all sources
+    const { links: labelLinks, seen } = extractDependsOnFromLabels(containers, nodes, containerProject);
+    const fileLinks = await extractDependsOnFromFile(composeFile, nodes, containerProject, seen);
+    const netLinks = extractNetworkLinks(networkMap);
+    return { nodes, links: [...labelLinks, ...fileLinks, ...netLinks] };
+}
+// --- Delegate to extracted modules ---
+export const getContainerStats = (id) => _getStats(docker, id);
+export const getContainerLogs = (id, tail) => _getLogs(docker, id, tail);
+export const streamContainerLogs = (id, onData, onError) => _streamLogs(docker, id, onData, onError);
+const execAsync = promisify(exec);
+const projectCache = new Map();
+/** Cache project metadata from container labels */
+function cacheProjectMeta(containers) {
+    for (const c of containers) {
+        const project = c.Labels['com.docker.compose.project'];
+        const workDir = c.Labels['com.docker.compose.project.working_dir'];
+        const configFiles = c.Labels['com.docker.compose.project.config_files'];
+        if (project && workDir && configFiles && !projectCache.has(project)) {
+            projectCache.set(project, { workDir, configFiles });
+        }
+    }
+}
+/** List all compose projects (live + cached) with their container counts */
+export async function listComposeProjects() {
+    const containers = await docker.listContainers({ all: true });
+    cacheProjectMeta(containers);
+    const projects = new Map();
+    // Live containers
+    for (const c of containers) {
+        const project = c.Labels['com.docker.compose.project'];
+        if (!project)
+            continue;
+        if (!projects.has(project))
+            projects.set(project, { running: 0, stopped: 0 });
+        const p = projects.get(project);
+        if (c.State === 'running')
+            p.running++;
+        else
+            p.stopped++;
+    }
+    // Cached projects with no live containers (after down)
+    for (const [name] of projectCache) {
+        if (!projects.has(name)) {
+            projects.set(name, { running: 0, stopped: 0 });
+        }
+    }
+    return [...projects.entries()]
+        .map(([name, counts]) => ({ name, ...counts }))
+        .sort((a, b) => a.name.localeCompare(b.name));
+}
+/** Get containers for a compose project */
+async function getProjectContainers(project) {
+    return docker.listContainers({
+        all: true,
+        filters: { label: [`com.docker.compose.project=${project}`] },
+    });
+}
+/** Build the docker compose command from container labels or cache */
+function getComposeCommand(project, containers) {
+    // Try live container labels first
+    let workDir = containers[0]?.Labels['com.docker.compose.project.working_dir'];
+    let configFiles = containers[0]?.Labels['com.docker.compose.project.config_files'];
+    // Fall back to cache (for projects that were downed)
+    if (!workDir || !configFiles) {
+        const cached = projectCache.get(project);
+        if (cached) {
+            workDir = cached.workDir;
+            configFiles = cached.configFiles;
+        }
+    }
+    if (!workDir || !configFiles)
+        return null;
+    const fileFlags = configFiles
+        .split(',')
+        .map((f) => `-f "${f.trim()}"`)
+        .join(' ');
+    return { cmd: `docker compose ${fileFlags}`, cwd: workDir };
+}
+/** Run a docker compose action on a specific project */
+export async function composeAction(project, action) {
+    const containers = await getProjectContainers(project);
+    if (action === 'up' || action === 'down') {
+        const compose = getComposeCommand(project, containers);
+        if (compose) {
+            const subCmd = action === 'up' ? 'up -d' : 'down';
+            const { stdout, stderr } = await execAsync(`${compose.cmd} ${subCmd}`, { cwd: compose.cwd });
+            return stdout || stderr || `${action} completed`;
+        }
+        if (action === 'up') {
+            for (const c of containers) {
+                if (c.State !== 'running')
+                    await docker.getContainer(c.Id).start();
+            }
+            return `Started containers in project ${project}`;
+        }
+        return 'Could not find compose config for down';
+    }
+    // stop / start / restart — act on individual containers
+    for (const c of containers) {
+        const container = docker.getContainer(c.Id);
+        if (action === 'stop' && c.State === 'running')
+            await container.stop();
+        else if (action === 'start' && c.State !== 'running')
+            await container.start();
+        else if (action === 'restart' && c.State === 'running')
+            await container.restart();
+    }
+    return `${action} completed for project ${project}`;
+}
+export async function containerAction(containerId, action) {
+    const container = docker.getContainer(containerId);
+    await container[action]();
+}
+export async function inspectContainer(containerId) {
+    const container = docker.getContainer(containerId);
+    const info = await container.inspect();
+    return {
+        id: info.Id.substring(0, 12),
+        env: info.Config.Env || [],
+        labels: info.Config.Labels || {},
+        mounts: (info.Mounts || []).map((m) => ({
+            type: m.Type || 'bind',
+            source: m.Source || '',
+            destination: m.Destination || '',
+            mode: m.Mode || 'rw',
+        })),
+        restartPolicy: info.HostConfig.RestartPolicy?.Name || 'no',
+        entrypoint: info.Config.Entrypoint || null,
+        cmd: info.Config.Cmd || null,
+        workingDir: info.Config.WorkingDir || '/',
+        created: info.Created,
+    };
+}
+export async function getSystemInfo() {
+    const info = await docker.info();
+    return {
+        dockerVersion: info.ServerVersion || 'unknown',
+        os: `${info.OperatingSystem || 'unknown'} (${info.Architecture || ''})`,
+        totalMemory: info.MemTotal || 0,
+        cpus: info.NCPU || 0,
+        containersRunning: info.ContainersRunning || 0,
+        containersStopped: info.ContainersStopped || 0,
+        images: info.Images || 0,
+    };
+}
+export function watchEvents(callback, onError) {
+    let destroyed = false;
+    let stream = null;
+    docker.getEvents({}, (err, eventStream) => {
+        if (err || !eventStream) {
+            onError?.(err || new Error('Failed to get event stream'));
+            return;
+        }
+        if (destroyed) {
+            eventStream.destroy?.();
+            return;
+        }
+        stream = eventStream;
+        eventStream.on('data', (chunk) => {
+            try {
+                const raw = JSON.parse(chunk.toString());
+                callback({
+                    id: (raw.Actor?.ID || raw.id || '').substring(0, 12),
+                    type: raw.Type || 'unknown',
+                    action: raw.Action || raw.status || 'unknown',
+                    actor: raw.Actor?.Attributes?.name ||
+                        raw.Actor?.Attributes?.['com.docker.compose.service'] ||
+                        raw.Actor?.ID?.substring(0, 12) ||
+                        'unknown',
+                    time: raw.time || Math.floor(Date.now() / 1000),
+                    message: `${raw.Type || ''} ${raw.Action || ''}: ${raw.Actor?.Attributes?.name || raw.Actor?.ID?.substring(0, 12) || ''}`,
+                });
+            }
+            catch {
+                /* ignore */
+            }
+        });
+        eventStream.on('error', (e) => onError?.(e));
+    });
+    return () => {
+        destroyed = true;
+        stream?.destroy?.();
+    };
+}

package/dist/docker/compose.d.ts

@@ -0,0 +1,25 @@
+export interface ComposeService {
+    name: string;
+    image: string;
+    ports: string[];
+    networks: string[];
+    dependsOn: string[];
+    volumes: string[];
+    environment: Record<string, string>;
+    labels: Record<string, string>;
+    healthcheck: {
+        test: string;
+        interval?: string;
+        timeout?: string;
+        retries?: number;
+    } | null;
+    resourceLimits: {
+        cpus?: string;
+        memory?: string;
+    } | null;
+}
+export interface ComposeData {
+    services: ComposeService[];
+    networks: string[];
+}
+export declare function parseComposeFile(filePath: string): Promise<ComposeData>;

package/dist/docker/compose.js

@@ -0,0 +1,111 @@
+import { readFile } from 'fs/promises';
+import { parse } from 'yaml';
+export async function parseComposeFile(filePath) {
+    const content = await readFile(filePath, 'utf-8');
+    const compose = parse(content);
+    if (!compose?.services) {
+        return { services: [], networks: [] };
+    }
+    const services = [];
+    for (const [name, svc] of Object.entries(compose.services)) {
+        const dependsOn = parseDependsOn(svc.depends_on);
+        services.push({
+            name,
+            image: svc.image || `${name}:latest`,
+            ports: Array.isArray(svc.ports) ? svc.ports.map(String) : [],
+            networks: parseNetworks(svc.networks),
+            dependsOn,
+            volumes: Array.isArray(svc.volumes) ? svc.volumes.map(String) : [],
+            environment: parseEnvironment(svc.environment),
+            labels: parseLabels(svc.labels),
+            healthcheck: parseHealthcheck(svc.healthcheck),
+            resourceLimits: parseResourceLimits(svc.deploy),
+        });
+    }
+    const topLevelNetworks = compose.networks ? Object.keys(compose.networks) : [];
+    return { services, networks: topLevelNetworks };
+}
+function parseDependsOn(dep) {
+    if (!dep)
+        return [];
+    // Simple form: depends_on: [db, redis]
+    if (Array.isArray(dep))
+        return dep.map(String);
+    // Extended form: depends_on: { db: { condition: service_healthy } }
+    if (typeof dep === 'object')
+        return Object.keys(dep);
+    return [];
+}
+function parseNetworks(nets) {
+    if (!nets)
+        return [];
+    if (Array.isArray(nets))
+        return nets.map(String);
+    if (typeof nets === 'object')
+        return Object.keys(nets);
+    return [];
+}
+function parseEnvironment(env) {
+    if (!env)
+        return {};
+    if (Array.isArray(env)) {
+        const result = {};
+        for (const item of env) {
+            const s = String(item);
+            const eqIdx = s.indexOf('=');
+            if (eqIdx > 0)
+                result[s.substring(0, eqIdx)] = s.substring(eqIdx + 1);
+            else
+                result[s] = '';
+        }
+        return result;
+    }
+    if (typeof env === 'object') {
+        return Object.fromEntries(Object.entries(env).map(([k, v]) => [k, String(v ?? '')]));
+    }
+    return {};
+}
+function parseLabels(labels) {
+    if (!labels)
+        return {};
+    if (Array.isArray(labels)) {
+        const result = {};
+        for (const item of labels) {
+            const s = String(item);
+            const eqIdx = s.indexOf('=');
+            if (eqIdx > 0)
+                result[s.substring(0, eqIdx)] = s.substring(eqIdx + 1);
+        }
+        return result;
+    }
+    if (typeof labels === 'object') {
+        return Object.fromEntries(Object.entries(labels).map(([k, v]) => [k, String(v ?? '')]));
+    }
+    return {};
+}
+function parseHealthcheck(hc) {
+    if (!hc || typeof hc !== 'object')
+        return null;
+    const h = hc;
+    const test = Array.isArray(h.test) ? h.test.join(' ') : String(h.test || '');
+    if (!test)
+        return null;
+    return {
+        test,
+        interval: h.interval,
+        timeout: h.timeout,
+        retries: h.retries,
+    };
+}
+function parseResourceLimits(deploy) {
+    if (!deploy || typeof deploy !== 'object')
+        return null;
+    const d = deploy;
+    const limits = d.resources?.limits;
+    if (!limits)
+        return null;
+    return {
+        cpus: limits.cpus ? String(limits.cpus) : undefined,
+        memory: limits.memory ? String(limits.memory) : undefined,
+    };
+}

package/dist/docker/links.d.ts

@@ -0,0 +1,10 @@
+import type { ServiceNode, ServiceLink } from '../types.js';
+/** Extract depends_on links from container labels (runtime) */
+export declare function extractDependsOnFromLabels(containers: any[], nodes: ServiceNode[], containerProject: Map<string, string>): {
+    links: ServiceLink[];
+    seen: Set<string>;
+};
+/** Extract depends_on links from compose file */
+export declare function extractDependsOnFromFile(composeFile: string | undefined, nodes: ServiceNode[], containerProject: Map<string, string>, seen: Set<string>): Promise<ServiceLink[]>;
+/** Extract network-based links (containers sharing non-default networks) */
+export declare function extractNetworkLinks(networkMap: Map<string, string[]>): ServiceLink[];