@mastra/docker 0.9.0-alpha.2 → 0.9.1-alpha.0

package/dist/index.js

@@ -141,6 +141,61 @@ case "$err" in
 esac
 `;
 /**
+* Upper bound on how long an early stream 'end' waits for an in-flight kill
+* confirmation before settling without termination metadata. The kill helper's
+* own work is bounded (the KILL_SCRIPT polls for at most ~4s), so this only
+* absorbs daemon round-trips; it exists so a wedged `inspect()` cannot leave
+* wait() pending forever.
+*/
+const TERMINATION_CONFIRMATION_DEADLINE_MS = 1e4;
+/**
+* Resolves when `termination` settles, or after
+* TERMINATION_CONFIRMATION_DEADLINE_MS — whichever comes first. Never rejects.
+*/
+function waitForTermination(termination) {
+	return new Promise((resolve) => {
+		const timer = setTimeout(resolve, TERMINATION_CONFIRMATION_DEADLINE_MS);
+		const done = () => {
+			clearTimeout(timer);
+			resolve();
+		};
+		termination.then(done, done);
+	});
+}
+/**
+* Resolves with `work`'s value, or `fallback` if it has not settled within `ms`.
+* Never rejects. Bounds a single daemon round-trip, so one call that never
+* answers cannot leave wait() pending past its deadline.
+*/
+function withDeadline(work, ms, fallback) {
+	return new Promise((resolve) => {
+		const timer = setTimeout(() => resolve(fallback), Math.max(0, ms));
+		const done = (value) => {
+			clearTimeout(timer);
+			resolve(value);
+		};
+		work.then(done, () => done(fallback));
+	});
+}
+/**
+* Polls `exec.inspect()` until the exec reports it is no longer running, bounded
+* by `deadline` (an absolute `Date.now()` timestamp). A stream can close without
+* 'end' while the process is still alive, and settling from inspect then would
+* publish an exit for a process that never exited — but waiting unbounded could
+* leave wait() pending forever, so each call is bounded too. Returns the last
+* inspect result, which may still report Running: true if the bound was reached,
+* or undefined if no call settled in time.
+*/
+async function waitForExecToStop(exec, deadline) {
+	let info;
+	while (Date.now() < deadline) {
+		info = await withDeadline(exec.inspect(), deadline - Date.now(), void 0);
+		if (!info || !info.Running) return info;
+		await new Promise((resolve) => setTimeout(resolve, 10));
+	}
+	return info;
+}
+/**
 * Wraps a Docker exec instance to conform to Mastra's ProcessHandle.
 * Not exported — internal to this module.
 *
@@ -157,6 +212,12 @@ var DockerProcessHandle = class extends ProcessHandle {
 	_killed = false;
 	/** @internal Set by the timeout path to distinguish timeout kills from explicit kills */
 	_timedOut = false;
+	/**
+	* @internal In-flight kill confirmation, set while kill() is verifying the
+	* process group is gone. An early stream 'end' awaits it (bounded) so
+	* termination metadata is not dropped when the target's stream closes first.
+	*/
+	_terminationPromise = null;
 	_waitPromise = null;
 	_stdinStream = null;
 	_execStream = null;
@@ -199,6 +260,20 @@ var DockerProcessHandle = class extends ProcessHandle {
 	}
 	async kill() {
 		if (this._exitCode !== void 0) return false;
+		if (this._terminationPromise) return this._terminationPromise;
+		const termination = this._runKillHelper();
+		this._terminationPromise = termination;
+		try {
+			return await termination;
+		} finally {
+			if (this._terminationPromise === termination) this._terminationPromise = null;
+		}
+	}
+	/**
+	* Runs the kill helper and verifies the process group is gone before reporting
+	* success, so a `true` result means the targets have actually stopped.
+	*/
+	async _runKillHelper() {
 		try {
 			const killExec = await this._container.exec({
 				Cmd: [
@@ -325,52 +400,68 @@ var DockerProcessManager = class extends SandboxProcessManager {
 				}
 				if (combined.length > 0 && buffer.length === 0) buffer.push(combined);
 			});
-			stream.on("end", async () => {
-				try {
-					const exitCode = (await exec.inspect()).ExitCode ?? 1;
-					handle._setExitCode(exitCode);
-					resolve({
-						success: exitCode === 0,
-						exitCode,
-						stdout: handle.stdout,
-						stderr: handle.stderr,
-						executionTimeMs: Date.now() - startTime
-					});
-				} catch {
-					handle._setExitCode(1);
-					resolve({
-						success: false,
-						exitCode: 1,
-						stdout: handle.stdout,
-						stderr: handle.stderr,
-						executionTimeMs: Date.now() - startTime
-					});
-				}
-			});
-			stream.on("close", () => {
-				if (handle.exitCode !== void 0) return;
-				if (!handle._killed) return;
-				handle._setExitCode(137);
+			let settled = false;
+			const settle = (exitCode, metadata = {}) => {
+				if (settled) return;
+				settled = true;
+				handle._setExitCode(exitCode);
 				resolve({
-					success: false,
-					exitCode: 137,
+					success: exitCode === 0,
+					exitCode,
 					stdout: handle.stdout,
 					stderr: handle.stderr,
 					executionTimeMs: Date.now() - startTime,
+					...metadata
+				});
+			};
+			const settleTerminated = () => {
+				settle(137, {
 					killed: true,
 					timedOut: handle._timedOut
 				});
+			};
+			stream.on("end", async () => {
+				if (handle._terminationPromise) await waitForTermination(handle._terminationPromise);
+				if (settled) return;
+				if (handle._killed) {
+					settleTerminated();
+					return;
+				}
+				try {
+					const info = await exec.inspect();
+					settle(info.ExitCode ?? 1);
+				} catch {
+					settle(1);
+				}
 			});
-			stream.on("error", () => {
-				if (handle.exitCode !== void 0) return;
-				handle._setExitCode(1);
-				resolve({
-					success: false,
-					exitCode: 1,
-					stdout: handle.stdout,
-					stderr: handle.stderr || "Stream error",
-					executionTimeMs: Date.now() - startTime
-				});
+			stream.on("close", async () => {
+				const deadline = Date.now() + TERMINATION_CONFIRMATION_DEADLINE_MS;
+				if (handle._terminationPromise) await waitForTermination(handle._terminationPromise);
+				if (settled) return;
+				if (handle._killed) {
+					settleTerminated();
+					return;
+				}
+				try {
+					const info = await waitForExecToStop(exec, deadline);
+					if (settled) return;
+					if (handle._killed) {
+						settleTerminated();
+						return;
+					}
+					settle(info?.ExitCode ?? 1);
+				} catch {
+					settle(1);
+				}
+			});
+			stream.on("error", async () => {
+				if (handle._terminationPromise) await waitForTermination(handle._terminationPromise);
+				if (settled) return;
+				if (handle._killed) {
+					settleTerminated();
+					return;
+				}
+				settle(1, { stderr: handle.stderr || "Stream error" });
 			});
 		});
 		const resolvedTimeout = options.timeout ?? this._defaultTimeout;