@robinpath/docker - npm Package Compare versions

Comparing version

0.1.1

0.3.0

+35

dist/docker.d.ts

		/**
		* RobinPath Docker Module (Node port)
		*
		* Thin client for the Docker Engine API. Talks to either:
		* • a local Unix socket (`unix:///var/run/docker.sock`, the default) via
		* Node's `net.Socket` + a tiny HTTP/1.1 request writer, or
		* • a TCP endpoint (`http://host:2375`) via `fetch()`.
		*
		* Mirror of packages/php/docker/src/index.php — shares the same credential
		* contract, metadata shape, and error taxonomy so the visual editor can
		* render both identically.
		*
		* Credential type declared by this module:
		* - docker : { host } → `unix:///var/run/docker.sock` (default),
		* `unix:///path/to/docker.sock`, or
		* `http://host:2375` / `https://host:2376`.
		*
		* If the credential slug is empty, the module falls back to the standard
		* Unix socket location — convenient for local CLI and desktop hosts.
		*
		* Handlers cover containers (ps / run-like create / start / stop / restart /
		* kill / rm / logs / inspect / stats), images (list / pull / tag / inspect /
		* rmi), exec, networks (list / create / remove / inspect), volumes (list /
		* create / remove / inspect), and a `version` / `info` probe.
		*
		* All handlers return the parsed JSON response. Errors are never thrown —
		* they are returned as `{error, code, status?, docker_error?}`.
		*/
		import type { BuiltinHandler, CredentialTypeSchema, FunctionMetadata, ModuleHost, ModuleMetadata } from "@robinpath/core";
		export declare function configureDocker(h: ModuleHost): void;
		export declare const DockerFunctions: Record<string, BuiltinHandler>;
		export declare const DockerCredentialTypes: CredentialTypeSchema[];
		export declare const DockerFunctionMetadata: Record<string, FunctionMetadata>;
		export declare const DockerModuleMetadata: ModuleMetadata;
		//# sourceMappingURL=docker.d.ts.map

+1

dist/docker.d.ts.map

{"version":3,"file":"docker.d.ts","sourceRoot":"","sources":["../src/docker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,KAAK,EACV,cAAc,EACd,oBAAoB,EACpB,gBAAgB,EAChB,UAAU,EACV,cAAc,EAEf,MAAM,iBAAiB,CAAC;AAiBzB,wBAAgB,eAAe,CAAC,CAAC,EAAE,UAAU,GAAG,IAAI,CAEnD;AA6pBD,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CA4B1D,CAAC;AAIF,eAAO,MAAM,qBAAqB,EAAE,oBAAoB,EAiBvD,CAAC;AAsDF,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAmxBnE,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,cAwBlC,CAAC"}

+1585

dist/docker.js

		/**
		* RobinPath Docker Module (Node port)
		*
		* Thin client for the Docker Engine API. Talks to either:
		* • a local Unix socket (`unix:///var/run/docker.sock`, the default) via
		* Node's `net.Socket` + a tiny HTTP/1.1 request writer, or
		* • a TCP endpoint (`http://host:2375`) via `fetch()`.
		*
		* Mirror of packages/php/docker/src/index.php — shares the same credential
		* contract, metadata shape, and error taxonomy so the visual editor can
		* render both identically.
		*
		* Credential type declared by this module:
		* - docker : { host } → `unix:///var/run/docker.sock` (default),
		* `unix:///path/to/docker.sock`, or
		* `http://host:2375` / `https://host:2376`.
		*
		* If the credential slug is empty, the module falls back to the standard
		* Unix socket location — convenient for local CLI and desktop hosts.
		*
		* Handlers cover containers (ps / run-like create / start / stop / restart /
		* kill / rm / logs / inspect / stats), images (list / pull / tag / inspect /
		* rmi), exec, networks (list / create / remove / inspect), volumes (list /
		* create / remove / inspect), and a `version` / `info` probe.
		*
		* All handlers return the parsed JSON response. Errors are never thrown —
		* they are returned as `{error, code, status?, docker_error?}`.
		*/
		import * as net from "node:net";
		import { Buffer } from "node:buffer";
		// ── Module-local state ─────────────────────────────────────────────────
		const state = {};
		function host() {
		if (!state.host) {
		throw new Error("Docker module not initialized. Pass the adapter to rp.registerModule() via loadModule so its configure() hook runs first.");
		}
		return state.host;
		}
		export function configureDocker(h) {
		state.host = h;
		}
		// ── Constants ──────────────────────────────────────────────────────────
		const CREDENTIAL_TYPE = "docker";
		const DEFAULT_HOST = "unix:///var/run/docker.sock";
		const USER_AGENT = "RobinPath-WP/1.0";
		function errorReturn(error, code, extra = {}) {
		return { error, code, ...extra };
		}
		function isErr(x) {
		return typeof x === "object" && x !== null && "error" in x && "code" in x;
		}
		async function resolveHost(credentialSlug) {
		let raw = DEFAULT_HOST;
		if (credentialSlug) {
		let fields;
		try {
		fields = await host().credentials.get(credentialSlug);
		}
		catch (e) {
		return errorReturn(e instanceof Error ? e.message : String(e), "credential_not_found");
		}
		if (!fields) {
		return errorReturn(`Credential '${credentialSlug}' not found.`, "credential_not_found");
		}
		const h = String(fields.host ?? fields.endpoint ?? "").trim();
		if (h !== "")
		raw = h;
		}
		if (raw.startsWith("unix://")) {
		return { kind: "unix", socketPath: raw.slice("unix://".length) };
		}
		if (raw.startsWith("http://") \|\| raw.startsWith("https://")) {
		return { kind: "http", baseUrl: raw.replace(/\/+$/, "") };
		}
		return errorReturn(`Unrecognized docker host '${raw}'. Use unix:///path/to/sock or http(s)://host:port.`, "validation_failed");
		}
		// ── HTTP over Unix socket ──────────────────────────────────────────────
		function httpOverSocket(socketPath, method, path, body) {
		return new Promise((resolve) => {
		const socket = net.createConnection(socketPath);
		let resolved = false;
		const chunks = [];
		let headerEnd = -1;
		let contentLength = null;
		let chunkedEncoding = false;
		let headerStr = "";
		const settle = (value) => {
		if (resolved)
		return;
		resolved = true;
		try {
		socket.destroy();
		}
		catch {
		// ignore
		}
		resolve(value);
		};
		socket.on("error", (err) => {
		settle(errorReturn(err.message, "transport"));
		});
		socket.on("connect", () => {
		const hasBody = typeof body === "string";
		let req = `${method} ${path} HTTP/1.1\r\n` +
		`Host: localhost\r\n` +
		`User-Agent: ${USER_AGENT}\r\n` +
		`Accept: application/json\r\n` +
		`Connection: close\r\n`;
		if (hasBody) {
		req += `Content-Type: application/json\r\n`;
		req += `Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n`;
		}
		req += `\r\n`;
		if (hasBody)
		req += body;
		socket.write(req);
		});
		socket.on("data", (data) => {
		const buf = typeof data === "string" ? Buffer.from(data, "utf8") : data;
		chunks.push(buf);
		if (headerEnd === -1) {
		const combined = Buffer.concat(chunks);
		const idx = combined.indexOf(Buffer.from("\r\n\r\n"));
		if (idx !== -1) {
		headerEnd = idx;
		headerStr = combined.slice(0, idx).toString("utf8");
		const cl = /Content-Length:\s*(\d+)/i.exec(headerStr);
		if (cl)
		contentLength = parseInt(cl[1], 10);
		chunkedEncoding = /Transfer-Encoding:\s*chunked/i.test(headerStr);
		// Replace chunks with the body portion.
		const bodyStart = idx + 4;
		const body = combined.slice(bodyStart);
		chunks.length = 0;
		if (body.length > 0)
		chunks.push(body);
		if (contentLength !== null && combined.length - bodyStart >= contentLength) {
		socket.end();
		}
		}
		}
		else {
		if (contentLength !== null) {
		const total = chunks.reduce((sum, c) => sum + c.length, 0);
		if (total >= contentLength)
		socket.end();
		}
		}
		});
		socket.on("end", () => finish());
		socket.on("close", () => finish());
		const finish = () => {
		if (resolved)
		return;
		const bodyBuf = Buffer.concat(chunks);
		let rawBody = bodyBuf.toString("utf8");
		let status = 0;
		const headers = {};
		if (headerStr) {
		const lines = headerStr.split("\r\n");
		const statusMatch = /^HTTP\/\d\.\d\s+(\d+)/.exec(lines[0] ?? "");
		if (statusMatch)
		status = parseInt(statusMatch[1], 10);
		for (let i = 1; i < lines.length; i++) {
		const colon = lines[i].indexOf(":");
		if (colon > 0) {
		const k = lines[i].slice(0, colon).trim().toLowerCase();
		const v = lines[i].slice(colon + 1).trim();
		headers[k] = v;
		}
		}
		}
		// Decode chunked transfer encoding.
		if (chunkedEncoding) {
		rawBody = decodeChunked(rawBody);
		}
		settle({ status, headers, body: rawBody });
		};
		});
		}
		function decodeChunked(raw) {
		// Minimal chunked decoder: hex size lines separated by \r\n, 0 terminator.
		let i = 0;
		let out = "";
		while (i < raw.length) {
		const crlf = raw.indexOf("\r\n", i);
		if (crlf === -1)
		break;
		const sizeHex = raw.slice(i, crlf).trim();
		const size = parseInt(sizeHex, 16);
		if (!Number.isFinite(size) \|\| size === 0)
		break;
		i = crlf + 2;
		out += raw.slice(i, i + size);
		i += size + 2; // skip trailing \r\n
		}
		return out;
		}
		// ── HTTP dispatcher ────────────────────────────────────────────────────
		async function http(resolved, method, path, body) {
		const hasBody = body !== undefined && body !== null;
		const serialized = hasBody ? JSON.stringify(body) : undefined;
		let status;
		let raw;
		if (resolved.kind === "unix") {
		const res = await httpOverSocket(resolved.socketPath, method, path, serialized);
		if (isErr(res))
		return res;
		status = res.status;
		raw = res.body;
		}
		else {
		const url = `${resolved.baseUrl}${path}`;
		let response;
		try {
		response = await fetch(url, {
		method,
		headers: {
		Accept: "application/json",
		"User-Agent": USER_AGENT,
		...(hasBody ? { "Content-Type": "application/json" } : {}),
		},
		body: serialized,
		});
		}
		catch (e) {
		return errorReturn(e instanceof Error ? e.message : String(e), "transport");
		}
		status = response.status;
		raw = await response.text();
		}
		if (status === 204)
		return { ok: true, status };
		let decoded = null;
		if (raw) {
		try {
		decoded = JSON.parse(raw);
		}
		catch {
		decoded = raw;
		}
		}
		if (status < 200 \|\| status >= 300) {
		let message = `Docker Engine returned HTTP ${status}.`;
		if (decoded && typeof decoded === "object" && "message" in decoded) {
		const m = decoded.message;
		if (typeof m === "string")
		message = m;
		}
		else if (typeof decoded === "string" && decoded !== "") {
		message = decoded.slice(0, 500);
		}
		let code = "docker_error";
		if (status === 404)
		code = "not_found";
		else if (status === 409)
		code = "conflict";
		else if (status === 400)
		code = "validation_failed";
		return errorReturn(message, code, { status, docker_error: decoded });
		}
		return decoded ?? { ok: true, status };
		}
		// ── Query helpers ──────────────────────────────────────────────────────
		function asOpts(v) {
		return v && typeof v === "object" && !Array.isArray(v) ? v : {};
		}
		function asString(v) {
		if (v === undefined \|\| v === null)
		return "";
		return String(v);
		}
		function buildQuery(params) {
		const parts = [];
		for (const [k, v] of Object.entries(params)) {
		if (v === null \|\| v === undefined)
		continue;
		if (typeof v === "boolean") {
		parts.push(`${encodeURIComponent(k)}=${v ? "true" : "false"}`);
		}
		else if (v === "") {
		continue;
		}
		else if (typeof v === "object") {
		parts.push(`${encodeURIComponent(k)}=${encodeURIComponent(JSON.stringify(v))}`);
		}
		else {
		parts.push(`${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`);
		}
		}
		return parts.length === 0 ? "" : `?${parts.join("&")}`;
		}
		// ── Handlers: misc ─────────────────────────────────────────────────────
		const version = async (args) => {
		const cred = String(args[0] ?? "");
		const resolved = await resolveHost(cred);
		if (isErr(resolved))
		return resolved;
		return (await http(resolved, "GET", "/version"));
		};
		const info = async (args) => {
		const cred = String(args[0] ?? "");
		const resolved = await resolveHost(cred);
		if (isErr(resolved))
		return resolved;
		return (await http(resolved, "GET", "/info"));
		};
		// ── Handlers: containers ───────────────────────────────────────────────
		const ps = async (args) => {
		const cred = String(args[0] ?? "");
		const opts = asOpts(args[1]);
		const resolved = await resolveHost(cred);
		if (isErr(resolved))
		return resolved;
		const q = buildQuery({
		all: opts.all,
		limit: opts.limit,
		size: opts.size,
		filters: opts.filters,
		});
		return (await http(resolved, "GET", `/containers/json${q}`));
		};
		const inspect = async (args) => {
		const cred = String(args[0] ?? "");
		const container = asString(args[1]);
		if (!container)
		return errorReturn("`container` is required.", "validation_failed");
		const resolved = await resolveHost(cred);
		if (isErr(resolved))
		return resolved;
		return (await http(resolved, "GET", `/containers/${encodeURIComponent(container)}/json`));
		};
		const create = async (args) => {
		const cred = String(args[0] ?? "");
		const name = asString(args[1]);
		const config = asOpts(args[2]);
		if (!config.Image)
		return errorReturn("`config.Image` is required.", "validation_failed");
		const resolved = await resolveHost(cred);
		if (isErr(resolved))
		return resolved;
		const q = name ? `?name=${encodeURIComponent(name)}` : "";
		return (await http(resolved, "POST", `/containers/create${q}`, config));
		};
		const start = async (args) => {
		const cred = String(args[0] ?? "");
		const container = asString(args[1]);
		if (!container)
		return errorReturn("`container` is required.", "validation_failed");
		const resolved = await resolveHost(cred);
		if (isErr(resolved))
		return resolved;
		return (await http(resolved, "POST", `/containers/${encodeURIComponent(container)}/start`));
		};
		const stop = async (args) => {
		const cred = String(args[0] ?? "");
		const container = asString(args[1]);
		const timeout = args[2];
		if (!container)
		return errorReturn("`container` is required.", "validation_failed");
		const resolved = await resolveHost(cred);
		if (isErr(resolved))
		return resolved;
		const q = typeof timeout === "number" ? `?t=${timeout \| 0}` : "";
		return (await http(resolved, "POST", `/containers/${encodeURIComponent(container)}/stop${q}`));
		};
		const restart = async (args) => {
		const cred = String(args[0] ?? "");
		const container = asString(args[1]);
		const timeout = args[2];
		if (!container)
		return errorReturn("`container` is required.", "validation_failed");
		const resolved = await resolveHost(cred);
		if (isErr(resolved))
		return resolved;
		const q = typeof timeout === "number" ? `?t=${timeout \| 0}` : "";
		return (await http(resolved, "POST", `/containers/${encodeURIComponent(container)}/restart${q}`));
		};
		const kill = async (args) => {
		const cred = String(args[0] ?? "");
		const container = asString(args[1]);
		const signal = asString(args[2]);
		if (!container)
		return errorReturn("`container` is required.", "validation_failed");
		const resolved = await resolveHost(cred);
		if (isErr(resolved))
		return resolved;
		const q = signal ? `?signal=${encodeURIComponent(signal)}` : "";
		return (await http(resolved, "POST", `/containers/${encodeURIComponent(container)}/kill${q}`));
		};
		const rm = async (args) => {
		const cred = String(args[0] ?? "");
		const container = asString(args[1]);
		const opts = asOpts(args[2]);
		if (!container)
		return errorReturn("`container` is required.", "validation_failed");
		const resolved = await resolveHost(cred);
		if (isErr(resolved))
		return resolved;
		const q = buildQuery({ v: opts.volumes, force: opts.force, link: opts.link });
		return (await http(resolved, "DELETE", `/containers/${encodeURIComponent(container)}${q}`));
		};
		const logs = async (args) => {
		const cred = String(args[0] ?? "");
		const container = asString(args[1]);
		const opts = asOpts(args[2]);
		if (!container)
		return errorReturn("`container` is required.", "validation_failed");
		const resolved = await resolveHost(cred);
		if (isErr(resolved))
		return resolved;
		const q = buildQuery({
		stdout: opts.stdout ?? true,
		stderr: opts.stderr ?? true,
		tail: opts.tail,
		since: opts.since,
		until: opts.until,
		timestamps: opts.timestamps,
		});
		// /containers/{id}/logs returns a multiplexed raw stream when the container
		// has no TTY — we return it as a string either way.
		const hasBody = false;
		const serialized = undefined;
		if (resolved.kind === "unix") {
		const res = await httpOverSocket(resolved.socketPath, "GET", `/containers/${encodeURIComponent(container)}/logs${q}`, serialized);
		if (isErr(res))
		return res;
		if (res.status < 200 \|\| res.status >= 300) {
		return errorReturn(`Docker Engine returned HTTP ${res.status}.`, "docker_error", {
		status: res.status,
		});
		}
		return { logs: stripDockerLogFrames(res.body), status: res.status };
		}
		else {
		const url = `${resolved.baseUrl}/containers/${encodeURIComponent(container)}/logs${q}`;
		try {
		const response = await fetch(url, {
		method: "GET",
		headers: {
		Accept: "application/json",
		"User-Agent": USER_AGENT,
		},
		});
		const raw = await response.text();
		if (!response.ok) {
		return errorReturn(`Docker Engine returned HTTP ${response.status}.`, "docker_error", {
		status: response.status,
		});
		}
		return { logs: stripDockerLogFrames(raw), status: response.status };
		}
		catch (e) {
		return errorReturn(e instanceof Error ? e.message : String(e), "transport");
		}
		}
		void hasBody; // appease linter
		};
		// Docker multiplexed log frames: 8-byte header per chunk (stream-id, padding*3, be-len 4).
		function stripDockerLogFrames(raw) {
		if (!raw)
		return raw;
		const buf = Buffer.from(raw, "binary");
		// Detect multiplex: first byte 0/1/2, next 3 bytes zero.
		if (buf.length < 8 \|\| ![0, 1, 2].includes(buf[0]) \|\| buf[1] !== 0 \|\| buf[2] !== 0 \|\| buf[3] !== 0) {
		return raw;
		}
		const out = [];
		let i = 0;
		while (i + 8 <= buf.length) {
		const len = buf.readUInt32BE(i + 4);
		out.push(buf.slice(i + 8, i + 8 + len).toString("utf8"));
		i += 8 + len;
		}
		return out.join("");
		}
		const stats = async (args) => {
		const cred = String(args[0] ?? "");
		const container = asString(args[1]);
		if (!container)
		return errorReturn("`container` is required.", "validation_failed");
		const resolved = await resolveHost(cred);
		if (isErr(resolved))
		return resolved;
		// One-shot snapshot; `stream=false` returns a single JSON object.
		return (await http(resolved, "GET", `/containers/${encodeURIComponent(container)}/stats?stream=false`));
		};
		const execCreate = async (args) => {
		const cred = String(args[0] ?? "");
		const container = asString(args[1]);
		const config = asOpts(args[2]);
		if (!container)
		return errorReturn("`container` is required.", "validation_failed");
		if (!config.Cmd)
		return errorReturn("`config.Cmd` is required.", "validation_failed");
		const resolved = await resolveHost(cred);
		if (isErr(resolved))
		return resolved;
		return (await http(resolved, "POST", `/containers/${encodeURIComponent(container)}/exec`, config));
		};
		const execStart = async (args) => {
		const cred = String(args[0] ?? "");
		const execId = asString(args[1]);
		const opts = asOpts(args[2]);
		if (!execId)
		return errorReturn("`execId` is required.", "validation_failed");
		const resolved = await resolveHost(cred);
		if (isErr(resolved))
		return resolved;
		return (await http(resolved, "POST", `/exec/${encodeURIComponent(execId)}/start`, { Detach: opts.detach ?? false, Tty: opts.tty ?? false }));
		};
		// ── Handlers: images ───────────────────────────────────────────────────
		const images = async (args) => {
		const cred = String(args[0] ?? "");
		const opts = asOpts(args[1]);
		const resolved = await resolveHost(cred);
		if (isErr(resolved))
		return resolved;
		const q = buildQuery({ all: opts.all, filters: opts.filters, "shared-size": opts.sharedSize, digests: opts.digests });
		return (await http(resolved, "GET", `/images/json${q}`));
		};
		const inspectImage = async (args) => {
		const cred = String(args[0] ?? "");
		const image = asString(args[1]);
		if (!image)
		return errorReturn("`image` is required.", "validation_failed");
		const resolved = await resolveHost(cred);
		if (isErr(resolved))
		return resolved;
		return (await http(resolved, "GET", `/images/${encodeURIComponent(image)}/json`));
		};
		const pull = async (args) => {
		const cred = String(args[0] ?? "");
		const image = asString(args[1]);
		if (!image)
		return errorReturn("`image` is required.", "validation_failed");
		const resolved = await resolveHost(cred);
		if (isErr(resolved))
		return resolved;
		// `/images/create?fromImage=…` returns a newline-delimited JSON stream. We
		// just wait for it to finish and expose the raw status tail.
		const q = `?fromImage=${encodeURIComponent(image)}`;
		if (resolved.kind === "unix") {
		const res = await httpOverSocket(resolved.socketPath, "POST", `/images/create${q}`);
		if (isErr(res))
		return res;
		if (res.status < 200 \|\| res.status >= 300) {
		return errorReturn(`Docker Engine returned HTTP ${res.status}.`, "docker_error", {
		status: res.status,
		});
		}
		return { status: res.status, stream: res.body };
		}
		else {
		try {
		const response = await fetch(`${resolved.baseUrl}/images/create${q}`, {
		method: "POST",
		headers: { Accept: "application/json", "User-Agent": USER_AGENT },
		});
		const raw = await response.text();
		if (!response.ok) {
		return errorReturn(`Docker Engine returned HTTP ${response.status}.`, "docker_error", {
		status: response.status,
		});
		}
		return { status: response.status, stream: raw };
		}
		catch (e) {
		return errorReturn(e instanceof Error ? e.message : String(e), "transport");
		}
		}
		};
		const tag = async (args) => {
		const cred = String(args[0] ?? "");
		const image = asString(args[1]);
		const repo = asString(args[2]);
		const newTag = asString(args[3]);
		if (!image)
		return errorReturn("`image` is required.", "validation_failed");
		if (!repo)
		return errorReturn("`repo` is required.", "validation_failed");
		const resolved = await resolveHost(cred);
		if (isErr(resolved))
		return resolved;
		const q = buildQuery({ repo, tag: newTag \|\| undefined });
		return (await http(resolved, "POST", `/images/${encodeURIComponent(image)}/tag${q}`));
		};
		const rmi = async (args) => {
		const cred = String(args[0] ?? "");
		const image = asString(args[1]);
		const opts = asOpts(args[2]);
		if (!image)
		return errorReturn("`image` is required.", "validation_failed");
		const resolved = await resolveHost(cred);
		if (isErr(resolved))
		return resolved;
		const q = buildQuery({ force: opts.force, noprune: opts.noprune });
		return (await http(resolved, "DELETE", `/images/${encodeURIComponent(image)}${q}`));
		};
		// ── Handlers: networks ─────────────────────────────────────────────────
		const networks = async (args) => {
		const cred = String(args[0] ?? "");
		const opts = asOpts(args[1]);
		const resolved = await resolveHost(cred);
		if (isErr(resolved))
		return resolved;
		const q = buildQuery({ filters: opts.filters });
		return (await http(resolved, "GET", `/networks${q}`));
		};
		const createNetwork = async (args) => {
		const cred = String(args[0] ?? "");
		const name = asString(args[1]);
		const opts = asOpts(args[2]);
		if (!name)
		return errorReturn("`name` is required.", "validation_failed");
		const resolved = await resolveHost(cred);
		if (isErr(resolved))
		return resolved;
		return (await http(resolved, "POST", `/networks/create`, { Name: name, ...opts }));
		};
		const removeNetwork = async (args) => {
		const cred = String(args[0] ?? "");
		const name = asString(args[1]);
		if (!name)
		return errorReturn("`name` is required.", "validation_failed");
		const resolved = await resolveHost(cred);
		if (isErr(resolved))
		return resolved;
		return (await http(resolved, "DELETE", `/networks/${encodeURIComponent(name)}`));
		};
		const inspectNetwork = async (args) => {
		const cred = String(args[0] ?? "");
		const name = asString(args[1]);
		if (!name)
		return errorReturn("`name` is required.", "validation_failed");
		const resolved = await resolveHost(cred);
		if (isErr(resolved))
		return resolved;
		return (await http(resolved, "GET", `/networks/${encodeURIComponent(name)}`));
		};
		// ── Handlers: volumes ──────────────────────────────────────────────────
		const volumes = async (args) => {
		const cred = String(args[0] ?? "");
		const opts = asOpts(args[1]);
		const resolved = await resolveHost(cred);
		if (isErr(resolved))
		return resolved;
		const q = buildQuery({ filters: opts.filters });
		return (await http(resolved, "GET", `/volumes${q}`));
		};
		const createVolume = async (args) => {
		const cred = String(args[0] ?? "");
		const name = asString(args[1]);
		const opts = asOpts(args[2]);
		if (!name)
		return errorReturn("`name` is required.", "validation_failed");
		const resolved = await resolveHost(cred);
		if (isErr(resolved))
		return resolved;
		return (await http(resolved, "POST", `/volumes/create`, { Name: name, ...opts }));
		};
		const removeVolume = async (args) => {
		const cred = String(args[0] ?? "");
		const name = asString(args[1]);
		const opts = asOpts(args[2]);
		if (!name)
		return errorReturn("`name` is required.", "validation_failed");
		const resolved = await resolveHost(cred);
		if (isErr(resolved))
		return resolved;
		const q = buildQuery({ force: opts.force });
		return (await http(resolved, "DELETE", `/volumes/${encodeURIComponent(name)}${q}`));
		};
		const inspectVolume = async (args) => {
		const cred = String(args[0] ?? "");
		const name = asString(args[1]);
		if (!name)
		return errorReturn("`name` is required.", "validation_failed");
		const resolved = await resolveHost(cred);
		if (isErr(resolved))
		return resolved;
		return (await http(resolved, "GET", `/volumes/${encodeURIComponent(name)}`));
		};
		// ── Exports: functions map ─────────────────────────────────────────────
		export const DockerFunctions = {
		version,
		info,
		ps,
		inspect,
		create,
		start,
		stop,
		restart,
		kill,
		rm,
		logs,
		stats,
		execCreate,
		execStart,
		images,
		inspectImage,
		pull,
		tag,
		rmi,
		networks,
		createNetwork,
		removeNetwork,
		inspectNetwork,
		volumes,
		createVolume,
		removeVolume,
		inspectVolume,
		};
		// ── Exports: credential types ──────────────────────────────────────────
		export const DockerCredentialTypes = [
		{
		slug: CREDENTIAL_TYPE,
		title: "Docker Engine",
		icon: "box",
		fields: [
		{
		name: "host",
		title: "Host",
		type: "text",
		required: false,
		placeholder: "unix:///var/run/docker.sock",
		description: "Docker Engine endpoint. Use `unix:///path/to/docker.sock` for local sockets (default) or `http://host:2375` / `https://host:2376` for remote TCP.",
		},
		],
		},
		];
		// ── Exports: metadata ──────────────────────────────────────────────────
		const credentialParam = {
		name: "credential",
		title: "Credential",
		description: "Slug of a saved `docker` credential. Pass empty string to use the default Unix socket (`unix:///var/run/docker.sock`).",
		dataType: "string",
		formInputType: "resource",
		required: false,
		allowExpression: true,
		placeholder: "my_docker",
		resource: {
		type: "credential",
		listFn: "credential.list",
		modes: ["list", "expression"],
		searchable: true,
		filter: { type: CREDENTIAL_TYPE },
		},
		};
		const containerParam = {
		name: "container",
		title: "Container",
		description: "Container ID or name.",
		dataType: "string",
		formInputType: "text",
		required: true,
		allowExpression: true,
		placeholder: "nginx-1",
		};
		const imageParam = {
		name: "image",
		title: "Image",
		description: "Image ID, name, or `repo:tag`.",
		dataType: "string",
		formInputType: "text",
		required: true,
		allowExpression: true,
		placeholder: "nginx:alpine",
		};
		const commonErrors = {
		credential_not_found: "No credential with that slug exists in the vault.",
		validation_failed: "A required argument is missing or invalid.",
		transport: "Could not reach the Docker Engine socket or endpoint.",
		not_found: "Docker Engine returned 404.",
		conflict: "Docker Engine returned 409 (name or state conflict).",
		docker_error: "Docker Engine returned an error.",
		};
		export const DockerFunctionMetadata = {
		version: {
		title: "Engine version",
		summary: "Engine / API version info",
		description: "Calls `GET /version`.",
		group: "engine",
		action: "read",
		icon: "info",
		capability: "manage_options",
		sideEffects: ["makes_http_call"],
		idempotent: true,
		since: "1.0.0",
		tags: ["docker", "engine"],
		parameters: [credentialParam],
		returnType: "object",
		errors: commonErrors,
		example: 'docker.version ""',
		},
		info: {
		title: "Engine info",
		summary: "Engine runtime info / counts",
		description: "Calls `GET /info`.",
		group: "engine",
		action: "read",
		icon: "info",
		capability: "manage_options",
		sideEffects: ["makes_http_call"],
		idempotent: true,
		since: "1.0.0",
		tags: ["docker", "engine"],
		parameters: [credentialParam],
		returnType: "object",
		errors: commonErrors,
		example: 'docker.info ""',
		},
		ps: {
		title: "List containers",
		summary: "Running (and optionally stopped) containers",
		description: "Calls `GET /containers/json`. Pass `{all: true}` to include stopped.",
		group: "containers",
		action: "query",
		icon: "list",
		capability: "manage_options",
		sideEffects: ["makes_http_call"],
		idempotent: true,
		since: "1.0.0",
		tags: ["docker", "container"],
		parameters: [
		credentialParam,
		{
		name: "options",
		title: "Options",
		description: "Recognized keys:\n all : bool — include stopped\n limit : int\n size : bool\n filters : object (see Docker Engine docs)",
		dataType: "object",
		formInputType: "json",
		required: false,
		allowExpression: true,
		language: "json",
		rows: 4,
		advanced: true,
		},
		],
		returnType: "array",
		errors: commonErrors,
		example: 'docker.ps "" {all: true}',
		},
		inspect: {
		title: "Inspect container",
		summary: "Full container JSON",
		description: "Calls `GET /containers/{id}/json`.",
		group: "containers",
		action: "read",
		icon: "info",
		capability: "manage_options",
		sideEffects: ["makes_http_call"],
		idempotent: true,
		since: "1.0.0",
		tags: ["docker", "container", "inspect"],
		parameters: [credentialParam, containerParam],
		returnType: "object",
		errors: commonErrors,
		example: 'docker.inspect "" "nginx-1"',
		},
		create: {
		title: "Create container",
		summary: "Create (but don't start) a container",
		description: "Calls `POST /containers/create?name={name}`. The config object is the raw Docker Engine create payload (`Image`, `Cmd`, `Env`, `HostConfig`, `ExposedPorts`, …).",
		group: "containers",
		action: "write",
		icon: "plus",
		capability: "manage_options",
		sideEffects: ["makes_http_call"],
		idempotent: false,
		since: "1.0.0",
		tags: ["docker", "container", "create"],
		parameters: [
		credentialParam,
		{
		name: "name",
		title: "Name",
		dataType: "string",
		description: "Optional container name.",
		formInputType: "text",
		required: false,
		allowExpression: true,
		placeholder: "nginx-1",
		},
		{
		name: "config",
		title: "Config",
		description: "Docker Engine `CreateContainer` body (must include `Image`).",
		dataType: "object",
		formInputType: "json",
		required: true,
		allowExpression: true,
		language: "json",
		rows: 8,
		},
		],
		returnType: "object",
		returnDescription: "{Id, Warnings}",
		errors: commonErrors,
		example: 'docker.create "" "nginx-1" {Image: "nginx:alpine"}',
		},
		start: {
		title: "Start container",
		summary: "Start an existing container",
		description: "Calls `POST /containers/{id}/start`.",
		group: "containers",
		action: "write",
		icon: "play",
		capability: "manage_options",
		sideEffects: ["makes_http_call"],
		idempotent: true,
		since: "1.0.0",
		tags: ["docker", "container", "start"],
		parameters: [credentialParam, containerParam],
		returnType: "object",
		errors: commonErrors,
		example: 'docker.start "" "nginx-1"',
		},
		stop: {
		title: "Stop container",
		summary: "Gracefully stop a container",
		description: "Calls `POST /containers/{id}/stop?t={timeout}`.",
		group: "containers",
		action: "write",
		icon: "square",
		capability: "manage_options",
		sideEffects: ["makes_http_call"],
		idempotent: true,
		since: "1.0.0",
		tags: ["docker", "container", "stop"],
		parameters: [
		credentialParam,
		containerParam,
		{
		name: "timeout",
		title: "Timeout (s)",
		dataType: "number",
		description: "Seconds to wait before SIGKILL. Defaults to Docker's 10s.",
		formInputType: "number",
		required: false,
		allowExpression: true,
		},
		],
		returnType: "object",
		errors: commonErrors,
		example: 'docker.stop "" "nginx-1" 5',
		},
		restart: {
		title: "Restart container",
		summary: "Stop + start in one call",
		description: "Calls `POST /containers/{id}/restart?t={timeout}`.",
		group: "containers",
		action: "write",
		icon: "refresh-cw",
		capability: "manage_options",
		sideEffects: ["makes_http_call"],
		idempotent: true,
		since: "1.0.0",
		tags: ["docker", "container", "restart"],
		parameters: [
		credentialParam,
		containerParam,
		{
		name: "timeout",
		title: "Timeout (s)",
		dataType: "number",
		description: "Seconds to wait before SIGKILL.",
		formInputType: "number",
		required: false,
		allowExpression: true,
		},
		],
		returnType: "object",
		errors: commonErrors,
		example: 'docker.restart "" "nginx-1"',
		},
		kill: {
		title: "Kill container",
		summary: "Send a signal (default SIGKILL)",
		description: "Calls `POST /containers/{id}/kill?signal={signal}`.",
		group: "containers",
		action: "write",
		icon: "zap",
		capability: "manage_options",
		sideEffects: ["makes_http_call"],
		idempotent: true,
		since: "1.0.0",
		tags: ["docker", "container", "kill"],
		parameters: [
		credentialParam,
		containerParam,
		{
		name: "signal",
		title: "Signal",
		dataType: "string",
		description: "Posix signal (e.g. SIGTERM, SIGKILL). Default: SIGKILL.",
		formInputType: "text",
		required: false,
		allowExpression: true,
		placeholder: "SIGKILL",
		},
		],
		returnType: "object",
		errors: commonErrors,
		example: 'docker.kill "" "nginx-1" "SIGTERM"',
		},
		rm: {
		title: "Remove container",
		summary: "Delete a (stopped) container",
		description: "Calls `DELETE /containers/{id}`.",
		group: "containers",
		action: "delete",
		icon: "trash-2",
		capability: "manage_options",
		sideEffects: ["makes_http_call"],
		idempotent: true,
		since: "1.0.0",
		tags: ["docker", "container", "delete"],
		parameters: [
		credentialParam,
		containerParam,
		{
		name: "options",
		title: "Options",
		description: "Recognized keys:\n volumes : bool — remove associated volumes\n force : bool — force-remove running\n link : bool — remove the specified link only",
		dataType: "object",
		formInputType: "json",
		required: false,
		allowExpression: true,
		language: "json",
		rows: 3,
		},
		],
		returnType: "object",
		errors: commonErrors,
		example: 'docker.rm "" "nginx-1" {force: true, volumes: true}',
		},
		logs: {
		title: "Container logs",
		summary: "One-shot container logs as a string",
		description: "Calls `GET /containers/{id}/logs`. Strips Docker's multiplexed framing so the result is clean UTF-8.",
		group: "containers",
		action: "read",
		icon: "file-text",
		capability: "manage_options",
		sideEffects: ["makes_http_call"],
		idempotent: true,
		since: "1.0.0",
		tags: ["docker", "container", "logs"],
		parameters: [
		credentialParam,
		containerParam,
		{
		name: "options",
		title: "Options",
		description: "Recognized keys:\n stdout, stderr : bool (both default true)\n tail : int \| 'all'\n since, until : unix timestamp\n timestamps : bool",
		dataType: "object",
		formInputType: "json",
		required: false,
		allowExpression: true,
		language: "json",
		rows: 4,
		advanced: true,
		},
		],
		returnType: "object",
		returnDescription: "{logs: string, status: int}",
		errors: commonErrors,
		example: 'docker.logs "" "nginx-1" {tail: 200}',
		},
		stats: {
		title: "Container stats",
		summary: "Single CPU/mem snapshot",
		description: "Calls `GET /containers/{id}/stats?stream=false`.",
		group: "containers",
		action: "read",
		icon: "activity",
		capability: "manage_options",
		sideEffects: ["makes_http_call"],
		idempotent: true,
		since: "1.0.0",
		tags: ["docker", "container", "stats"],
		parameters: [credentialParam, containerParam],
		returnType: "object",
		errors: commonErrors,
		example: 'docker.stats "" "nginx-1"',
		},
		execCreate: {
		title: "Exec: create",
		summary: "Create an exec instance inside a container",
		description: "Calls `POST /containers/{id}/exec`. Config must include `Cmd` (array of strings).",
		group: "exec",
		action: "write",
		icon: "terminal",
		capability: "manage_options",
		sideEffects: ["makes_http_call"],
		idempotent: false,
		since: "1.0.0",
		tags: ["docker", "exec"],
		parameters: [
		credentialParam,
		containerParam,
		{
		name: "config",
		title: "Exec config",
		description: "e.g. `{Cmd: ['sh','-c','ls /'], AttachStdout: true, AttachStderr: true}`.",
		dataType: "object",
		formInputType: "json",
		required: true,
		allowExpression: true,
		language: "json",
		rows: 6,
		},
		],
		returnType: "object",
		returnDescription: "{Id: string}",
		errors: commonErrors,
		example: 'docker.execCreate "" "nginx-1" {Cmd: ["ls","/"], AttachStdout: true}',
		},
		execStart: {
		title: "Exec: start",
		summary: "Run a previously created exec instance",
		description: "Calls `POST /exec/{id}/start`. Note: output is the raw multiplexed stream.",
		group: "exec",
		action: "write",
		icon: "play",
		capability: "manage_options",
		sideEffects: ["makes_http_call"],
		idempotent: false,
		since: "1.0.0",
		tags: ["docker", "exec"],
		parameters: [
		credentialParam,
		{
		name: "execId",
		title: "Exec ID",
		dataType: "string",
		description: "ID returned by `execCreate`.",
		formInputType: "text",
		required: true,
		allowExpression: true,
		},
		{
		name: "options",
		title: "Options",
		description: "Recognized keys:\n detach : bool (default false)\n tty : bool (default false)",
		dataType: "object",
		formInputType: "json",
		required: false,
		allowExpression: true,
		language: "json",
		rows: 3,
		},
		],
		returnType: "object",
		errors: commonErrors,
		example: 'docker.execStart "" "abc123" {detach: false}',
		},
		images: {
		title: "List images",
		summary: "Images on the host",
		description: "Calls `GET /images/json`.",
		group: "images",
		action: "query",
		icon: "image",
		capability: "manage_options",
		sideEffects: ["makes_http_call"],
		idempotent: true,
		since: "1.0.0",
		tags: ["docker", "image"],
		parameters: [
		credentialParam,
		{
		name: "options",
		title: "Options",
		description: "Recognized keys:\n all : bool\n filters : object\n sharedSize : bool\n digests : bool",
		dataType: "object",
		formInputType: "json",
		required: false,
		allowExpression: true,
		language: "json",
		rows: 4,
		advanced: true,
		},
		],
		returnType: "array",
		errors: commonErrors,
		example: 'docker.images ""',
		},
		inspectImage: {
		title: "Inspect image",
		summary: "Full image JSON",
		description: "Calls `GET /images/{id}/json`.",
		group: "images",
		action: "read",
		icon: "info",
		capability: "manage_options",
		sideEffects: ["makes_http_call"],
		idempotent: true,
		since: "1.0.0",
		tags: ["docker", "image", "inspect"],
		parameters: [credentialParam, imageParam],
		returnType: "object",
		errors: commonErrors,
		example: 'docker.inspectImage "" "nginx:alpine"',
		},
		pull: {
		title: "Pull image",
		summary: "Pull an image from a registry",
		description: "Calls `POST /images/create?fromImage={image}`. Returns the raw newline-delimited status stream once complete.",
		group: "images",
		action: "write",
		icon: "download",
		capability: "manage_options",
		sideEffects: ["makes_http_call"],
		idempotent: false,
		since: "1.0.0",
		tags: ["docker", "image", "pull"],
		parameters: [credentialParam, imageParam],
		returnType: "object",
		returnDescription: "{status: int, stream: string}",
		errors: commonErrors,
		example: 'docker.pull "" "nginx:alpine"',
		},
		tag: {
		title: "Tag image",
		summary: "Give an image a new repo:tag",
		description: "Calls `POST /images/{source}/tag?repo={repo}&tag={tag}`.",
		group: "images",
		action: "write",
		icon: "tag",
		capability: "manage_options",
		sideEffects: ["makes_http_call"],
		idempotent: true,
		since: "1.0.0",
		tags: ["docker", "image", "tag"],
		parameters: [
		credentialParam,
		imageParam,
		{
		name: "repo",
		title: "Repo",
		dataType: "string",
		description: "New repo name (e.g. `myregistry/nginx`).",
		formInputType: "text",
		required: true,
		allowExpression: true,
		},
		{
		name: "tag",
		title: "Tag",
		dataType: "string",
		description: "New tag (optional).",
		formInputType: "text",
		required: false,
		allowExpression: true,
		},
		],
		returnType: "object",
		errors: commonErrors,
		example: 'docker.tag "" "nginx:alpine" "myregistry/nginx" "v1"',
		},
		rmi: {
		title: "Remove image",
		summary: "Delete an image",
		description: "Calls `DELETE /images/{id}`.",
		group: "images",
		action: "delete",
		icon: "trash-2",
		capability: "manage_options",
		sideEffects: ["makes_http_call"],
		idempotent: true,
		since: "1.0.0",
		tags: ["docker", "image", "delete"],
		parameters: [
		credentialParam,
		imageParam,
		{
		name: "options",
		title: "Options",
		description: "Recognized keys:\n force : bool\n noprune : bool",
		dataType: "object",
		formInputType: "json",
		required: false,
		allowExpression: true,
		language: "json",
		rows: 3,
		},
		],
		returnType: "array",
		errors: commonErrors,
		example: 'docker.rmi "" "nginx:alpine" {force: true}',
		},
		networks: {
		title: "List networks",
		summary: "All Docker networks",
		description: "Calls `GET /networks`.",
		group: "networks",
		action: "query",
		icon: "globe",
		capability: "manage_options",
		sideEffects: ["makes_http_call"],
		idempotent: true,
		since: "1.0.0",
		tags: ["docker", "network"],
		parameters: [
		credentialParam,
		{
		name: "options",
		title: "Options",
		description: "Recognized keys:\n filters : object",
		dataType: "object",
		formInputType: "json",
		required: false,
		allowExpression: true,
		language: "json",
		rows: 3,
		advanced: true,
		},
		],
		returnType: "array",
		errors: commonErrors,
		example: 'docker.networks ""',
		},
		createNetwork: {
		title: "Create network",
		summary: "New Docker network",
		description: "Calls `POST /networks/create`.",
		group: "networks",
		action: "write",
		icon: "plus",
		capability: "manage_options",
		sideEffects: ["makes_http_call"],
		idempotent: false,
		since: "1.0.0",
		tags: ["docker", "network", "create"],
		parameters: [
		credentialParam,
		{
		name: "name",
		title: "Name",
		dataType: "string",
		description: "Network name.",
		formInputType: "text",
		required: true,
		allowExpression: true,
		placeholder: "my-net",
		},
		{
		name: "options",
		title: "Options",
		description: "Extra fields merged into the create body (Driver, IPAM, Labels, Internal, …).",
		dataType: "object",
		formInputType: "json",
		required: false,
		allowExpression: true,
		language: "json",
		rows: 5,
		},
		],
		returnType: "object",
		errors: commonErrors,
		example: 'docker.createNetwork "" "my-net" {Driver: "bridge"}',
		},
		removeNetwork: {
		title: "Remove network",
		summary: "Delete a network",
		description: "Calls `DELETE /networks/{id}`.",
		group: "networks",
		action: "delete",
		icon: "trash-2",
		capability: "manage_options",
		sideEffects: ["makes_http_call"],
		idempotent: true,
		since: "1.0.0",
		tags: ["docker", "network", "delete"],
		parameters: [
		credentialParam,
		{
		name: "name",
		title: "Name",
		dataType: "string",
		description: "Network ID or name.",
		formInputType: "text",
		required: true,
		allowExpression: true,
		},
		],
		returnType: "object",
		errors: commonErrors,
		example: 'docker.removeNetwork "" "my-net"',
		},
		inspectNetwork: {
		title: "Inspect network",
		summary: "Full network JSON",
		description: "Calls `GET /networks/{id}`.",
		group: "networks",
		action: "read",
		icon: "info",
		capability: "manage_options",
		sideEffects: ["makes_http_call"],
		idempotent: true,
		since: "1.0.0",
		tags: ["docker", "network", "inspect"],
		parameters: [
		credentialParam,
		{
		name: "name",
		title: "Name",
		dataType: "string",
		description: "Network ID or name.",
		formInputType: "text",
		required: true,
		allowExpression: true,
		},
		],
		returnType: "object",
		errors: commonErrors,
		example: 'docker.inspectNetwork "" "bridge"',
		},
		volumes: {
		title: "List volumes",
		summary: "All Docker volumes",
		description: "Calls `GET /volumes`.",
		group: "volumes",
		action: "query",
		icon: "database",
		capability: "manage_options",
		sideEffects: ["makes_http_call"],
		idempotent: true,
		since: "1.0.0",
		tags: ["docker", "volume"],
		parameters: [
		credentialParam,
		{
		name: "options",
		title: "Options",
		description: "Recognized keys:\n filters : object",
		dataType: "object",
		formInputType: "json",
		required: false,
		allowExpression: true,
		language: "json",
		rows: 3,
		advanced: true,
		},
		],
		returnType: "object",
		returnDescription: "{Volumes: [...], Warnings: [...]}",
		errors: commonErrors,
		example: 'docker.volumes ""',
		},
		createVolume: {
		title: "Create volume",
		summary: "New named volume",
		description: "Calls `POST /volumes/create`.",
		group: "volumes",
		action: "write",
		icon: "plus",
		capability: "manage_options",
		sideEffects: ["makes_http_call"],
		idempotent: false,
		since: "1.0.0",
		tags: ["docker", "volume", "create"],
		parameters: [
		credentialParam,
		{
		name: "name",
		title: "Name",
		dataType: "string",
		description: "Volume name.",
		formInputType: "text",
		required: true,
		allowExpression: true,
		placeholder: "pgdata",
		},
		{
		name: "options",
		title: "Options",
		description: "Extra fields merged into the create body (Driver, DriverOpts, Labels).",
		dataType: "object",
		formInputType: "json",
		required: false,
		allowExpression: true,
		language: "json",
		rows: 4,
		},
		],
		returnType: "object",
		errors: commonErrors,
		example: 'docker.createVolume "" "pgdata" {Driver: "local"}',
		},
		removeVolume: {
		title: "Remove volume",
		summary: "Delete a volume",
		description: "Calls `DELETE /volumes/{name}`.",
		group: "volumes",
		action: "delete",
		icon: "trash-2",
		capability: "manage_options",
		sideEffects: ["makes_http_call"],
		idempotent: true,
		since: "1.0.0",
		tags: ["docker", "volume", "delete"],
		parameters: [
		credentialParam,
		{
		name: "name",
		title: "Name",
		dataType: "string",
		description: "Volume name.",
		formInputType: "text",
		required: true,
		allowExpression: true,
		},
		{
		name: "options",
		title: "Options",
		description: "Recognized keys:\n force : bool",
		dataType: "object",
		formInputType: "json",
		required: false,
		allowExpression: true,
		language: "json",
		rows: 3,
		},
		],
		returnType: "object",
		errors: commonErrors,
		example: 'docker.removeVolume "" "pgdata" {force: true}',
		},
		inspectVolume: {
		title: "Inspect volume",
		summary: "Full volume JSON",
		description: "Calls `GET /volumes/{name}`.",
		group: "volumes",
		action: "read",
		icon: "info",
		capability: "manage_options",
		sideEffects: ["makes_http_call"],
		idempotent: true,
		since: "1.0.0",
		tags: ["docker", "volume", "inspect"],
		parameters: [
		credentialParam,
		{
		name: "name",
		title: "Name",
		dataType: "string",
		description: "Volume name.",
		formInputType: "text",
		required: true,
		allowExpression: true,
		},
		],
		returnType: "object",
		errors: commonErrors,
		example: 'docker.inspectVolume "" "pgdata"',
		},
		};
		export const DockerModuleMetadata = {
		slug: "docker",
		title: "Docker",
		summary: "Docker Engine API — containers, images, networks, volumes.",
		description: "Talks to the Docker Engine API directly — via the local Unix socket by default, or a TCP endpoint if configured in the credential. Covers the day-to-day surface: containers (ps / create / start / stop / rm / logs / stats), images (pull / tag / rmi), exec, networks, and volumes.\n\nReturns parsed JSON as-is. Errors are structured envelopes — never thrown.",
		category: "devops",
		icon: "icon.svg",
		color: "#2496ED",
		version: "0.2.0",
		docsUrl: "https://docs.robinpath.com/modules/docker",
		status: "stable",
		requires: [],
		minNodeVersion: "18.0.0",
		credentialsType: CREDENTIAL_TYPE,
		operationGroups: {
		engine: { title: "Engine", description: "Version / info probes.", order: 1 },
		containers: { title: "Containers", description: "Container lifecycle.", order: 2 },
		exec: { title: "Exec", description: "Run commands inside containers.", order: 3 },
		images: { title: "Images", description: "Image registry + local.", order: 4 },
		networks: { title: "Networks", description: "Docker networks.", order: 5 },
		volumes: { title: "Volumes", description: "Docker volumes.", order: 6 },
		},
		methods: Object.keys(DockerFunctions),
		};
		//# sourceMappingURL=docker.js.map

+1

dist/docker.js.map

+6

dist/index.d.ts

		import type { ModuleAdapter } from "@robinpath/core";
		declare const DockerModule: ModuleAdapter;
		export default DockerModule;
		export { DockerModule };
		export { DockerFunctions, DockerFunctionMetadata, DockerModuleMetadata, DockerCredentialTypes, configureDocker, } from "./docker.js";
		//# sourceMappingURL=index.d.ts.map

+1

dist/index.d.ts.map

{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AASrD,QAAA,MAAM,YAAY,EAAE,aAQnB,CAAC;AAEF,eAAe,YAAY,CAAC;AAC5B,OAAO,EAAE,YAAY,EAAE,CAAC;AACxB,OAAO,EACL,eAAe,EACf,sBAAsB,EACtB,oBAAoB,EACpB,qBAAqB,EACrB,eAAe,GAChB,MAAM,aAAa,CAAC"}

+14

dist/index.js

		import { DockerFunctions, DockerFunctionMetadata, DockerModuleMetadata, DockerCredentialTypes, configureDocker, } from "./docker.js";
		const DockerModule = {
		name: "docker",
		functions: DockerFunctions,
		functionMetadata: DockerFunctionMetadata,
		moduleMetadata: DockerModuleMetadata,
		credentialTypes: DockerCredentialTypes,
		configure: configureDocker,
		global: false,
		};
		export default DockerModule;
		export { DockerModule };
		export { DockerFunctions, DockerFunctionMetadata, DockerModuleMetadata, DockerCredentialTypes, configureDocker, } from "./docker.js";
		//# sourceMappingURL=index.js.map

+1

dist/index.js.map

{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,eAAe,EACf,sBAAsB,EACtB,oBAAoB,EACpB,qBAAqB,EACrB,eAAe,GAChB,MAAM,aAAa,CAAC;AAErB,MAAM,YAAY,GAAkB;IAClC,IAAI,EAAE,QAAQ;IACd,SAAS,EAAE,eAAe;IAC1B,gBAAgB,EAAE,sBAAsB;IACxC,cAAc,EAAE,oBAAoB;IACpC,eAAe,EAAE,qBAAqB;IACtC,SAAS,EAAE,eAAe;IAC1B,MAAM,EAAE,KAAK;CACd,CAAC;AAEF,eAAe,YAAY,CAAC;AAC5B,OAAO,EAAE,YAAY,EAAE,CAAC;AACxB,OAAO,EACL,eAAe,EACf,sBAAsB,EACtB,oBAAoB,EACpB,qBAAqB,EACrB,eAAe,GAChB,MAAM,aAAa,CAAC"}

+18

-8

package.json

		{
		"name": "@robinpath/docker",
		"version": "0.1.1",
		"version": "0.3.0",
		"publishConfig": {
		@@ -24,13 +24,16 @@ "access": "public"
		"peerDependencies": {
		"@robinpath/core": ">=0.20.0"
		"@robinpath/core": ">=0.40.0"
		},
		"devDependencies": {
		"@robinpath/core": "^0.30.1",
		"@robinpath/core": "^0.40.0",
		"tsx": "^4.19.0",
		"typescript": "^5.6.0"
		},
		"description": "Docker container and image management using the system docker binary",
		"description": "Docker Engine API client — containers, images, networks, volumes, and exec. Talks to a local Unix socket by default (`unix:///var/run/docker.sock`) or a TCP endpoint via the credential vault.",
		"keywords": [
		"docker",
		"devops"
		"devops",
		"containers",
		"engine-api",
		"unix-socket"
		],
		@@ -40,6 +43,13 @@ "license": "MIT",
		"category": "devops",
		"type": "integration",
		"auth": "none",
		"functionCount": 16
		"type": "module",
		"auth": "credential-vault",
		"credentialType": "docker",
		"functionCount": 27,
		"language": "nodejs",
		"platforms": [
		"cloud",
		"cli",
		"desktop"
		]
		}
		}

+1

-1

README.md

		@@ -22,3 +22,3 @@ # @robinpath/docker
		```bash
		npm install @robinpath/docker
		robinpath add @robinpath/docker
		```
		@@ -25,0 +25,0 @@

@robinpath/docker - npm Package Compare versions

New alerts

Fixed alerts

Improved metrics

Worsened metrics