dsh-pentester 0.0.1 → 1.0.0

package/lib/engagement-container-store-B9D8g0wq.js

@@ -0,0 +1,641 @@
+import { mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { randomUUID } from "node:crypto";
+import { request } from "node:http";
+//#region src/domain/tools.ts
+const DEFAULT_TOOL_OUTPUT_LIMITS = {
+	maxInlineOutputBytes: 8192,
+	maxTotalCapturedBytes: 1048576
+};
+const DEFAULT_TOOL_BROKER_LIMITS = {
+	maxPerEngagement: 4,
+	maxPerAgentRun: 2
+};
+//#endregion
+//#region src/tools/errors.ts
+var ToolBrokerError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "ToolBrokerError";
+		this.code = code;
+	}
+};
+//#endregion
+//#region src/tools/persist.ts
+function toolsRuntimeDir(engagementDir) {
+	return `${engagementDir}/runtime/tools`;
+}
+async function writeJsonAtomic(target, value) {
+	await mkdir(dirname(target), { recursive: true });
+	const tmp = `${target}.tmp-${randomUUID()}`;
+	try {
+		await writeFile(tmp, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+		await rename(tmp, target);
+	} catch (error) {
+		try {
+			await unlink(tmp);
+		} catch {}
+		throw new ToolBrokerError("persist_failed", error instanceof Error ? error.message : `Failed to write ${target}`);
+	}
+}
+async function readJsonFile(path) {
+	try {
+		return JSON.parse(await readFile(path, "utf8"));
+	} catch (error) {
+		if (error.code === "ENOENT") return null;
+		if (error instanceof SyntaxError) return null;
+		throw error;
+	}
+}
+//#endregion
+//#region src/tools/output-capture.ts
+var BoundedCapture = class {
+	truncated = false;
+	captureLimitReached = false;
+	buffered = 0;
+	remaining;
+	stdoutParts = [];
+	stderrParts = [];
+	constructor(maxTotalCapturedBytes) {
+		this.remaining = maxTotalCapturedBytes;
+	}
+	get full() {
+		return this.remaining <= 0;
+	}
+	accept(stream, chunk) {
+		if (chunk.length === 0) return;
+		if (this.remaining <= 0) {
+			this.captureLimitReached = true;
+			this.truncated = true;
+			return;
+		}
+		let take = chunk;
+		if (chunk.length > this.remaining) {
+			take = chunk.subarray(0, this.remaining);
+			this.captureLimitReached = true;
+			this.truncated = true;
+		}
+		this.remaining -= take.length;
+		this.buffered += take.length;
+		if (stream === "stderr") this.stderrParts.push(take);
+		else this.stdoutParts.push(take);
+	}
+	stdout() {
+		return Buffer.concat(this.stdoutParts);
+	}
+	stderr() {
+		return Buffer.concat(this.stderrParts);
+	}
+};
+var DockerMuxCapture = class {
+	inner;
+	leftover = Buffer.alloc(0);
+	constructor(maxTotalCapturedBytes) {
+		this.inner = new BoundedCapture(maxTotalCapturedBytes);
+	}
+	pushMuxed(chunk) {
+		this.leftover = Buffer.concat([this.leftover, chunk]);
+		while (this.leftover.length >= 8) {
+			const type = this.leftover[0];
+			if (type !== 1 && type !== 2 && type !== 0) {
+				this.inner.accept("stdout", this.leftover);
+				this.leftover = Buffer.alloc(0);
+				return;
+			}
+			const size = this.leftover.readUInt32BE(4);
+			if (this.leftover.length < 8 + size) return;
+			const payload = this.leftover.subarray(8, 8 + size);
+			this.leftover = this.leftover.subarray(8 + size);
+			this.inner.accept(type === 2 ? "stderr" : "stdout", payload);
+		}
+	}
+};
+function isBinaryBuffer(buf) {
+	if (buf.includes(0)) return true;
+	const sample = buf.subarray(0, Math.min(buf.length, 4096));
+	try {
+		return new TextDecoder("utf8", { fatal: true }).decode(sample).includes("�");
+	} catch {
+		return true;
+	}
+}
+function applyCaptureLimits(streams, limits) {
+	let truncated = false;
+	let captureLimitReached = false;
+	let remaining = limits.maxTotalCapturedBytes;
+	const take = (buf, name) => {
+		if (remaining <= 0) {
+			captureLimitReached = true;
+			truncated = true;
+			return Buffer.alloc(0);
+		}
+		if (buf.length > remaining) {
+			captureLimitReached = true;
+			truncated = true;
+			const slice = buf.subarray(0, remaining);
+			remaining = 0;
+			return slice;
+		}
+		remaining -= buf.length;
+		return buf;
+	};
+	const stdout = take(streams.stdout, "stdout");
+	const stderr = take(streams.stderr, "stderr");
+	const stdoutBinary = isBinaryBuffer(stdout) && stdout.length > 0;
+	const stderrBinary = isBinaryBuffer(stderr) && stderr.length > 0;
+	const files = {};
+	const binaryFiles = {};
+	const inline = {};
+	const put = (name, buf, binary) => {
+		if (buf.length === 0) return;
+		if (binary) {
+			binaryFiles[`${name}.bin`] = buf;
+			return;
+		}
+		const text = buf.toString("utf8");
+		files[`${name}.txt`] = text;
+		if (buf.length <= limits.maxInlineOutputBytes && !truncated) inline[name] = text;
+	};
+	put("stdout", stdout, stdoutBinary);
+	put("stderr", stderr, stderrBinary);
+	return {
+		files,
+		binaryFiles,
+		inline,
+		truncated,
+		captureLimitReached,
+		binary: stdoutBinary || stderrBinary
+	};
+}
+//#endregion
+//#region src/tools/docker-engine.ts
+/**
+* The only extra capabilities a Toolbox container may receive. nmap's file
+* capabilities (`cap_net_bind_service,cap_net_admin,cap_net_raw=eip`) require
+* these to be present in the container's capability set, or exec fails with
+* `Operation not permitted`. This stays a strict whitelist: arbitrary capAdd
+* (e.g. SYS_ADMIN, DAC_OVERRIDE) remains forbidden.
+*/
+const ALLOWED_CONTAINER_CAP_ADD = [
+	"NET_ADMIN",
+	"NET_RAW",
+	"NET_BIND_SERVICE"
+];
+function assertSafeHostConfig(config) {
+	if (config.privileged === true) throw new Error("privileged containers are not allowed");
+	if (config.networkMode === "host") throw new Error("host network is not allowed");
+	if (config.pidMode === "host") throw new Error("host pid namespace is not allowed");
+	if (config.ipcMode === "host") throw new Error("host ipc namespace is not allowed");
+	for (const cap of config.capAdd ?? []) if (!ALLOWED_CONTAINER_CAP_ADD.includes(cap)) throw new Error(`capability ${cap} is not allowed`);
+	for (const bind of config.binds ?? []) {
+		if (/docker\.sock/i.test(bind) || bind.includes(":/") && bind.startsWith("/:")) throw new Error("forbidden bind");
+		if (bind === "/" || bind.startsWith("/:") || /(^|:)\/:/.test(bind)) throw new Error("forbidden bind");
+	}
+}
+const SAFE_CREATE_HOST_CONFIG = {
+	privileged: false,
+	networkMode: "bridge",
+	pidMode: "",
+	ipcMode: "",
+	capAdd: [...ALLOWED_CONTAINER_CAP_ADD]
+};
+function dockerSocketPath() {
+	return process.env.DOCKER_HOST?.startsWith("unix://") ? process.env.DOCKER_HOST.slice(7) : "/var/run/docker.sock";
+}
+var UnixDockerEngine = class {
+	kind = "unix";
+	firewallObjectsCreated = 0;
+	killExecStarts = 0;
+	lastKillPid;
+	socketPath;
+	api;
+	inflight = /* @__PURE__ */ new Map();
+	constructor(socketPath = dockerSocketPath(), api = "v1.41") {
+		this.socketPath = socketPath;
+		this.api = api;
+	}
+	async inspectImage(ref) {
+		const encoded = encodeURIComponent(ref);
+		const res = await this.json("GET", `/images/${encoded}/json`);
+		if (res.status === 404) return;
+		if (res.status >= 400) throw new Error(`inspect image failed: ${res.status}`);
+		const body = res.body;
+		return {
+			id: body.Id ?? ref,
+			digest: body.RepoDigests?.[0]
+		};
+	}
+	async buildImage(input) {
+		const { packDockerContext } = await import("./docker-tar-_wf8UrSj.js");
+		const tar = await packDockerContext(input.contextDir, input.dockerfile);
+		const res = await this.raw("POST", `/build?t=${encodeURIComponent(input.tag)}&dockerfile=${encodeURIComponent(input.dockerfile)}`, tar, "application/x-tar");
+		if (res.status >= 400) throw new Error(`build failed: ${res.status} ${res.body.toString("utf8").slice(0, 200)}`);
+		const inspect = await this.inspectImage(input.tag);
+		if (inspect === void 0) throw new Error("build completed but image missing");
+		return inspect;
+	}
+	async pullImage(image) {
+		const [name, tag] = image.includes(":") ? image.split(/:(?=[^:]+$)/) : [image, "latest"];
+		const res = await this.raw("POST", `/images/create?fromImage=${encodeURIComponent(name ?? image)}&tag=${encodeURIComponent(tag ?? "latest")}`);
+		if (res.status >= 400) throw new Error(`pull failed: ${res.status}`);
+		const inspect = await this.inspectImage(image);
+		if (inspect === void 0) throw new Error("pull completed but image missing");
+		return inspect;
+	}
+	async createContainer(input) {
+		assertSafeHostConfig(input.hostConfig);
+		const res = await this.json("POST", `/containers/create${input.name !== void 0 ? `?name=${encodeURIComponent(input.name)}` : ""}`, {
+			Image: input.image,
+			Cmd: input.cmd ?? ["sleep", "infinity"],
+			Env: input.env ?? [],
+			Labels: input.labels ?? {},
+			HostConfig: {
+				Privileged: false,
+				NetworkMode: input.hostConfig.networkMode ?? "bridge",
+				PidMode: input.hostConfig.pidMode ?? "",
+				IpcMode: input.hostConfig.ipcMode ?? "",
+				CapAdd: [...input.hostConfig.capAdd ?? []],
+				Binds: input.hostConfig.binds ?? [],
+				SecurityOpt: ["no-new-privileges"]
+			}
+		});
+		if (res.status >= 400) throw new Error(`create container failed: ${res.status} ${JSON.stringify(res.body)}`);
+		return { containerId: res.body.Id };
+	}
+	async inspectContainer(containerId) {
+		const res = await this.json("GET", `/containers/${encodeURIComponent(containerId)}/json`);
+		if (res.status === 404) return;
+		if (res.status >= 400) throw new Error(`inspect container failed: ${res.status}`);
+		const body = res.body;
+		return {
+			id: body.Id,
+			running: body.State?.Running === true,
+			image: body.Config?.Image ?? body.Image ?? ""
+		};
+	}
+	async startContainer(containerId) {
+		const res = await this.raw("POST", `/containers/${encodeURIComponent(containerId)}/start`);
+		if (res.status >= 400 && res.status !== 304) throw new Error(`start container failed: ${res.status}`);
+	}
+	async stopContainer(containerId) {
+		const res = await this.raw("POST", `/containers/${encodeURIComponent(containerId)}/stop`);
+		if (res.status >= 400 && res.status !== 304 && res.status !== 404) throw new Error(`stop container failed: ${res.status}`);
+	}
+	async removeContainer(containerId) {
+		const res = await this.raw("DELETE", `/containers/${encodeURIComponent(containerId)}?force=true`);
+		if (res.status >= 400 && res.status !== 404) throw new Error(`remove container failed: ${res.status}`);
+	}
+	async listContainers(input) {
+		const query = new URLSearchParams();
+		if (input?.all === true) query.set("all", "1");
+		if (input?.label !== void 0) query.set("filters", JSON.stringify({ label: [input.label] }));
+		const suffix = query.toString().length > 0 ? `?${query.toString()}` : "";
+		const res = await this.json("GET", `/containers/json${suffix}`);
+		if (res.status >= 400) throw new Error(`list containers failed: ${res.status}`);
+		return res.body.map((row) => ({
+			id: row.Id ?? "",
+			name: row.Names?.[0]?.replace(/^\//, "") ?? "",
+			image: row.Image ?? "",
+			running: row.State === "running",
+			...row.Labels === void 0 ? {} : { labels: row.Labels }
+		})).filter((item) => item.id.length > 0);
+	}
+	async exec(input) {
+		const created = await this.json("POST", `/containers/${encodeURIComponent(input.containerId)}/exec`, {
+			AttachStdout: true,
+			AttachStderr: true,
+			Cmd: input.argv,
+			WorkingDir: input.cwd,
+			Env: input.env
+		});
+		if (created.status >= 400) throw new Error(`exec create failed: ${created.status}`);
+		const execId = created.body.Id;
+		input.onExecCreated?.(execId);
+		const abort = new AbortController();
+		this.inflight.set(execId, {
+			abort,
+			containerId: input.containerId
+		});
+		if (input.abort !== void 0) input.abort.addEventListener("abort", () => abort.abort());
+		const limit = input.maxTotalCapturedBytes ?? DEFAULT_TOOL_OUTPUT_LIMITS.maxTotalCapturedBytes;
+		try {
+			const started = await this.streamExecStart(execId, abort.signal, limit);
+			if (started.status >= 400) throw new Error(`exec start failed: ${started.status}`);
+			return {
+				execId,
+				exitCode: (await this.json("GET", `/exec/${encodeURIComponent(execId)}/json`)).body.ExitCode ?? 0,
+				stdout: started.stdout,
+				stderr: started.stderr,
+				truncated: started.truncated,
+				captureLimitReached: started.captureLimitReached
+			};
+		} finally {
+			this.inflight.delete(execId);
+		}
+	}
+	async cancelExec(execId) {
+		const current = this.inflight.get(execId);
+		const pid = (await this.json("GET", `/exec/${encodeURIComponent(execId)}/json`)).body.Pid;
+		if (typeof pid === "number" && pid > 0 && current !== void 0) {
+			this.lastKillPid = pid;
+			const kill = await this.json("POST", `/containers/${encodeURIComponent(current.containerId)}/exec`, {
+				AttachStdout: false,
+				AttachStderr: false,
+				Cmd: [
+					"kill",
+					"-TERM",
+					String(pid)
+				]
+			});
+			if (kill.status < 400) {
+				const killId = kill.body.Id;
+				if (typeof killId === "string" && killId.length > 0) {
+					await this.raw("POST", `/exec/${encodeURIComponent(killId)}/start`, Buffer.from(JSON.stringify({
+						Detach: true,
+						Tty: false
+					})), "application/json");
+					this.killExecStarts += 1;
+				}
+			}
+			current.abort.abort();
+			return "requested";
+		}
+		current?.abort.abort();
+		return current !== void 0 ? "requested" : "unknown";
+	}
+	streamExecStart(execId, signal, maxTotalCapturedBytes) {
+		return new Promise((resolve, reject) => {
+			const capture = new DockerMuxCapture(maxTotalCapturedBytes);
+			const body = Buffer.from(JSON.stringify({
+				Detach: false,
+				Tty: false
+			}));
+			const req = request({
+				socketPath: this.socketPath,
+				path: `/${this.api}/exec/${encodeURIComponent(execId)}/start`,
+				method: "POST",
+				headers: {
+					Host: "localhost",
+					"Content-Type": "application/json",
+					"Content-Length": body.length
+				}
+			}, (res) => {
+				res.on("data", (chunk) => {
+					capture.pushMuxed(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+				});
+				res.on("end", () => {
+					resolve({
+						status: res.statusCode ?? 0,
+						stdout: capture.inner.stdout(),
+						stderr: capture.inner.stderr(),
+						truncated: capture.inner.truncated,
+						captureLimitReached: capture.inner.captureLimitReached
+					});
+				});
+			});
+			req.on("error", reject);
+			signal.addEventListener("abort", () => {
+				req.destroy(/* @__PURE__ */ new Error("aborted"));
+			});
+			req.write(body);
+			req.end();
+		});
+	}
+	json(method, path, body) {
+		const payload = body === void 0 ? void 0 : Buffer.from(JSON.stringify(body));
+		return this.raw(method, path, payload, "application/json").then((res) => ({
+			status: res.status,
+			body: res.body.length === 0 ? {} : JSON.parse(res.body.toString("utf8"))
+		}));
+	}
+	raw(method, path, body, contentType, signal) {
+		return new Promise((resolve, reject) => {
+			const req = request({
+				socketPath: this.socketPath,
+				path: `/${this.api}${path}`,
+				method,
+				headers: {
+					Host: "localhost",
+					...contentType !== void 0 ? { "Content-Type": contentType } : {},
+					...body !== void 0 ? { "Content-Length": body.length } : {}
+				}
+			}, (res) => {
+				const chunks = [];
+				res.on("data", (chunk) => {
+					chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+				});
+				res.on("end", () => {
+					resolve({
+						status: res.statusCode ?? 0,
+						body: Buffer.concat(chunks)
+					});
+				});
+			});
+			req.on("error", reject);
+			signal?.addEventListener("abort", () => {
+				req.destroy(/* @__PURE__ */ new Error("aborted"));
+			});
+			if (body !== void 0) req.write(body);
+			req.end();
+		});
+	}
+};
+//#endregion
+//#region src/tools/engagement-container-store.ts
+/**
+* P0-B: ONE persistent execution container per Engagement × runtime-profile.
+*
+* Container ownership changed: `agentRunId`/`taskId` NEVER participate in the
+* container identity. The key is `engagementId + runtimeProfile` (the factory
+* Kali image is the single runtime profile in the MVP), so every Worker /
+* Task / Stage of an Engagement reuses the SAME container. Provenance
+* (taskId / agentRunId / toolCallId) stays in the audit log only.
+*
+* Lifecycle:
+*   - lazy create on first execution (ensure)
+*   - Task completed / AgentRun completed / Session ended → KEEP
+*   - Engagement CLOSED → stop + remove
+*   - explicit reset → stop + remove + recreate
+*   - plugin restart → recover/reuse (DockerBindingStore read + engine inspect)
+*   - orphan/stale managed containers (no live Engagement) → GC removes
+*
+* Concurrency: `ensure` is singleflighted per key — N concurrent first-time
+* callers create exactly ONE container and all receive the same id.
+*/
+const PENTESTER_MANAGED_LABEL = "dsh.pentester.managed";
+const PENTESTER_ENGAGEMENT_LABEL = "dsh.pentester.engagement";
+const PENTESTER_RUNTIME_PROFILE_LABEL = "dsh.pentester.runtime-profile";
+const PENTESTER_WORKSPACE_LABEL = "dsh.pentester.workspace";
+const PENTESTER_MANAGED_TRUE = "true";
+/** MVP runtime profile: the single factory Kali image. */
+const RUNTIME_PROFILE_KALI_DEFAULT = "kali-default";
+var EngagementContainerStore = class EngagementContainerStore {
+	path;
+	bindings;
+	/** singleflight: key → in-flight ensure promise. */
+	inflight = /* @__PURE__ */ new Map();
+	constructor(path, bindings) {
+		this.path = path;
+		this.bindings = bindings;
+	}
+	static keyOf(engagementId, profile) {
+		return `${engagementId}::${profile}`;
+	}
+	static async open(engagementDir) {
+		const path = `${engagementDir}/runtime/engagement-containers.json`;
+		const raw = await readJsonFile(path);
+		const bindings = raw !== null && typeof raw === "object" && !Array.isArray(raw) && "bindings" in raw ? raw.bindings ?? {} : {};
+		return new EngagementContainerStore(path, bindings);
+	}
+	list() {
+		return Object.values(this.bindings);
+	}
+	get(key) {
+		return this.bindings[key];
+	}
+	/** Remove a binding record (after the container itself is removed). */
+	async remove(key) {
+		if (this.bindings[key] === void 0) return;
+		const next = { ...this.bindings };
+		delete next[key];
+		this.bindings = next;
+		await writeJsonAtomic(this.path, { bindings: this.bindings });
+	}
+	async put(binding) {
+		const key = EngagementContainerStore.keyOf(binding.engagementId, binding.profile);
+		this.bindings = {
+			...this.bindings,
+			[key]: binding
+		};
+		await writeJsonAtomic(this.path, { bindings: this.bindings });
+	}
+	/**
+	* Ensure exactly ONE running container exists for the profile. Concurrency
+	* safe: concurrent first-time callers singleflight to a single create.
+	* Returns the container id.
+	*/
+	ensure(input) {
+		const key = EngagementContainerStore.keyOf(input.profile.engagementId, input.profile.profile);
+		const inflight = this.inflight.get(key);
+		if (inflight !== void 0) return inflight;
+		const run = this.ensureInner(key, input);
+		this.inflight.set(key, run);
+		run.finally(() => {
+			this.inflight.delete(key);
+		});
+		return run;
+	}
+	async ensureInner(key, input) {
+		const existing = this.bindings[key];
+		if (existing !== void 0) {
+			const inspect = await input.engine.inspectContainer(existing.containerId);
+			if (inspect === void 0) return this.createAndRecord(key, input);
+			if (!inspect.running) await input.engine.startContainer(existing.containerId);
+			return existing.containerId;
+		}
+		return this.createAndRecord(key, input);
+	}
+	async createAndRecord(key, input) {
+		const profile = input.profile;
+		const binds = [];
+		if (profile.workspacePath !== void 0 && profile.workspacePath.length > 0) {
+			const { mkdir } = await import("node:fs/promises");
+			await mkdir(profile.workspacePath, { recursive: true });
+			binds.push(`${profile.workspacePath}:/workspace`);
+			if (profile.artifactsPath !== void 0 && profile.artifactsPath.length > 0) {
+				await mkdir(profile.artifactsPath, { recursive: true });
+				binds.push(`${profile.artifactsPath}:/artifacts`);
+			}
+		} else if (profile.artifactsPath !== void 0 && profile.artifactsPath.length > 0) {
+			const { mkdir } = await import("node:fs/promises");
+			await mkdir(profile.artifactsPath, { recursive: true });
+			binds.push(`${profile.artifactsPath}:/workspace`);
+		}
+		const created = await input.engine.createContainer({
+			image: profile.image,
+			name: engagementContainerName(profile.engagementId, profile.profile, profile.nameSlug),
+			cmd: ["sleep", "infinity"],
+			env: [],
+			labels: {
+				[PENTESTER_MANAGED_LABEL]: PENTESTER_MANAGED_TRUE,
+				[PENTESTER_ENGAGEMENT_LABEL]: profile.engagementId,
+				[PENTESTER_RUNTIME_PROFILE_LABEL]: profile.profile,
+				...profile.workspaceLabel === void 0 ? {} : { [PENTESTER_WORKSPACE_LABEL]: profile.workspaceLabel }
+			},
+			hostConfig: {
+				...SAFE_CREATE_HOST_CONFIG,
+				binds
+			}
+		});
+		await input.engine.startContainer(created.containerId);
+		const binding = {
+			engagementId: profile.engagementId,
+			profile: profile.profile,
+			image: profile.image,
+			containerId: created.containerId,
+			imageId: input.resolvedImage.id,
+			...input.resolvedImage.digest === void 0 ? {} : { imageSource: input.imageSource },
+			createdAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		const raced = this.bindings[key];
+		if (raced !== void 0 && raced.containerId !== created.containerId) {
+			if (await input.engine.inspectContainer(raced.containerId) !== void 0) {
+				try {
+					await input.engine.removeContainer(created.containerId);
+				} catch {}
+				return raced.containerId;
+			}
+		}
+		await this.put(binding);
+		return created.containerId;
+	}
+	/** Remove + recreate the container for a profile (explicit reset). */
+	async reset(key, input) {
+		const existing = this.bindings[key];
+		if (existing !== void 0) {
+			try {
+				await input.engine.stopContainer(existing.containerId);
+			} catch {}
+			try {
+				await input.engine.removeContainer(existing.containerId);
+			} catch {}
+			await this.remove(key);
+		}
+		return this.ensure(input);
+	}
+	/**
+	* Engagement CLOSED: stop + remove the managed container and forget the
+	* binding. Returns the removed container id, if any.
+	*/
+	async closeEngagement(engagementId, engine) {
+		const keys = Object.keys(this.bindings).filter((key) => key.startsWith(`${engagementId}::`));
+		let removed;
+		for (const key of keys) {
+			const binding = this.bindings[key];
+			if (binding === void 0) continue;
+			try {
+				await engine.stopContainer(binding.containerId);
+			} catch {}
+			try {
+				await engine.removeContainer(binding.containerId);
+			} catch {}
+			removed = binding.containerId;
+			await this.remove(key);
+		}
+		return removed;
+	}
+};
+/** Deterministic container name: readable slug + profile (never agentRun/taskId,
+*  never a UUID). E.g. `pentest-192-168-107-5-kali`. Falls back to a short
+*  engagement hash only when no readable slug is available. */
+function engagementContainerName(engagementId, profile, slug) {
+	return `pentest-${slug !== void 0 && slug.length > 0 ? safeName(slug) : `eng-${safeName(engagementId).slice(0, 12)}`}-${profile === "kali-default" ? "kali" : safeName(profile)}`;
+}
+function safeName(value) {
+	return value.replace(/[^a-zA-Z0-9_.-]/g, "").slice(0, 40) || "x";
+}
+//#endregion
+export { PENTESTER_RUNTIME_PROFILE_LABEL as a, applyCaptureLimits as c, writeJsonAtomic as d, ToolBrokerError as f, PENTESTER_MANAGED_TRUE as i, readJsonFile as l, DEFAULT_TOOL_OUTPUT_LIMITS as m, PENTESTER_ENGAGEMENT_LABEL as n, RUNTIME_PROFILE_KALI_DEFAULT as o, DEFAULT_TOOL_BROKER_LIMITS as p, PENTESTER_MANAGED_LABEL as r, UnixDockerEngine as s, EngagementContainerStore as t, toolsRuntimeDir as u };
+
+//# sourceMappingURL=engagement-container-store-B9D8g0wq.js.map