vmsan 0.1.0-alpha.2 → 0.1.0-alpha.21

package/dist/_chunks/agent.mjs

@@ -1,6 +1,196 @@
 import { createGzip } from "node:zlib";
 import { Readable } from "node:stream";
 import { pack } from "tar-stream";
+/**
+* Lightweight async iterable queue for pushing events and yielding them to consumers.
+*/
+var AsyncQueue = class {
+	_buffer = [];
+	_waiting = [];
+	_closed = false;
+	push(item) {
+		if (this._closed) return;
+		if (this._waiting.length > 0) this._waiting.shift()({
+			value: item,
+			done: false
+		});
+		else this._buffer.push(item);
+	}
+	close() {
+		this._closed = true;
+		for (const resolve of this._waiting) resolve({
+			value: void 0,
+			done: true
+		});
+		this._waiting.length = 0;
+	}
+	async *[Symbol.asyncIterator]() {
+		while (true) if (this._buffer.length > 0) yield this._buffer.shift();
+		else if (this._closed) return;
+		else {
+			const item = await new Promise((resolve) => {
+				this._waiting.push(resolve);
+			});
+			if (item.done) return;
+			yield item.value;
+		}
+	}
+};
+var CommandFinished = class {
+	cmdId;
+	exitCode;
+	stdout;
+	stderr;
+	output;
+	timedOut;
+	startedAt;
+	constructor(opts) {
+		this.cmdId = opts.cmdId;
+		this.exitCode = opts.exitCode;
+		this.stdout = opts.stdout;
+		this.stderr = opts.stderr;
+		this.output = opts.output;
+		this.timedOut = opts.timedOut;
+		this.startedAt = opts.startedAt;
+	}
+	get ok() {
+		return this.exitCode === 0;
+	}
+};
+const MAX_LOG_ENTRIES = 1e5;
+var Command = class {
+	cmdId;
+	_startedAt;
+	_exitCode = null;
+	_timedOut = false;
+	_logEntries = [];
+	_logTruncated = false;
+	_eventQueue = new AsyncQueue();
+	_completion;
+	_stdoutPromise = null;
+	_stderrPromise = null;
+	_outputPromise = null;
+	_agent;
+	constructor(init) {
+		const { agent, cmdId, startedAt, stream, signal, onStdout, onStderr } = init;
+		this._agent = agent;
+		this.cmdId = cmdId;
+		this._startedAt = startedAt;
+		let resolveCompletion;
+		let rejectCompletion;
+		this._completion = new Promise((resolve, reject) => {
+			resolveCompletion = resolve;
+			rejectCompletion = reject;
+		});
+		let onAbort;
+		if (signal) {
+			onAbort = () => {
+				this.kill().catch(() => {});
+			};
+			if (signal.aborted) this.kill().catch(() => {});
+			else signal.addEventListener("abort", onAbort, { once: true });
+		}
+		(async () => {
+			try {
+				for await (const event of stream) {
+					this._eventQueue.push(event);
+					switch (event.type) {
+						case "stdout":
+						case "stderr":
+							if (event.data !== void 0) {
+								if (this._logEntries.length < MAX_LOG_ENTRIES) this._logEntries.push({
+									stream: event.type,
+									data: event.data
+								});
+								else this._logTruncated = true;
+								(event.type === "stdout" ? onStdout : onStderr)?.(event.data);
+							}
+							break;
+						case "exit":
+							this._exitCode = event.exitCode ?? 1;
+							break;
+						case "timeout":
+							this._timedOut = true;
+							this._exitCode = 124;
+							break;
+						case "error":
+							this._exitCode = 1;
+							break;
+					}
+				}
+				this._eventQueue.close();
+				resolveCompletion(new CommandFinished({
+					cmdId,
+					exitCode: this._exitCode ?? 1,
+					stdout: this._logEntries.filter((e) => e.stream === "stdout").map((e) => e.data).join("\n"),
+					stderr: this._logEntries.filter((e) => e.stream === "stderr").map((e) => e.data).join("\n"),
+					output: this._logEntries.map((e) => e.data).join("\n"),
+					timedOut: this._timedOut,
+					startedAt
+				}));
+				this._logEntries.length = 0;
+			} catch (err) {
+				this._eventQueue.close();
+				const error = err instanceof Error ? err : new Error(String(err));
+				rejectCompletion(error);
+			} finally {
+				if (signal && onAbort) signal.removeEventListener("abort", onAbort);
+			}
+		})();
+	}
+	get startedAt() {
+		return this._startedAt;
+	}
+	get exitCode() {
+		return this._exitCode;
+	}
+	async *logs(opts) {
+		const signal = opts?.signal;
+		if (signal?.aborted) return;
+		for await (const event of this._eventQueue) {
+			if (signal?.aborted) return;
+			if (event.type === "stdout" || event.type === "stderr") yield {
+				stream: event.type,
+				data: event.data ?? ""
+			};
+		}
+	}
+	stdout(opts) {
+		if (!this._stdoutPromise) this._stdoutPromise = this._completion.then((r) => r.stdout);
+		return this._withSignal(this._stdoutPromise, opts?.signal);
+	}
+	stderr(opts) {
+		if (!this._stderrPromise) this._stderrPromise = this._completion.then((r) => r.stderr);
+		return this._withSignal(this._stderrPromise, opts?.signal);
+	}
+	output(stream, opts) {
+		if (stream === "stdout") return this.stdout(opts);
+		if (stream === "stderr") return this.stderr(opts);
+		if (!this._outputPromise) this._outputPromise = this._completion.then((r) => r.output);
+		return this._withSignal(this._outputPromise, opts?.signal);
+	}
+	wait(opts) {
+		return this._withSignal(this._completion, opts?.signal);
+	}
+	async kill(signal, opts) {
+		await this._agent.killCommand(this.cmdId, signal, opts?.abortSignal);
+	}
+	_withSignal(promise, signal) {
+		if (!signal) return promise;
+		if (signal.aborted) return Promise.reject(new DOMException("The operation was aborted.", "AbortError"));
+		return new Promise((resolve, reject) => {
+			const onAbort = () => reject(new DOMException("The operation was aborted.", "AbortError"));
+			signal.addEventListener("abort", onAbort, { once: true });
+			promise.then((value) => {
+				signal.removeEventListener("abort", onAbort);
+				resolve(value);
+			}, (err) => {
+				signal.removeEventListener("abort", onAbort);
+				reject(err);
+			});
+		});
+	}
+};
 var AgentClient = class {
 	constructor(baseUrl, token) {
 		this.baseUrl = baseUrl;
@@ -11,14 +201,15 @@ var AgentClient = class {
 		if (!res.ok) throw new Error(`Agent health check failed: ${res.status}`);
 		return res.json();
 	}
-	async *run(params) {
+	async *run(params, signal) {
 		const res = await fetch(`${this.baseUrl}/exec`, {
 			method: "POST",
 			headers: {
 				"Content-Type": "application/json",
 				Authorization: `Bearer ${this.token}`
 			},
-			body: JSON.stringify(params)
+			body: JSON.stringify(params),
+			signal
 		});
 		if (!res.ok) {
 			const text = await res.text();
@@ -41,7 +232,7 @@ var AgentClient = class {
 		}
 		if (buffer.trim()) yield JSON.parse(buffer.trim());
 	}
-	async killCommand(cmdId, signal) {
+	async killCommand(cmdId, signal, abortSignal) {
 		const url = `${this.baseUrl}/exec/${cmdId}/kill`;
 		const res = await fetch(url, {
 			method: "POST",
@@ -49,7 +240,8 @@ var AgentClient = class {
 				"Content-Type": "application/json",
 				Authorization: `Bearer ${this.token}`
 			},
-			body: signal ? JSON.stringify({ signal }) : void 0
+			body: signal ? JSON.stringify({ signal }) : void 0,
+			signal: abortSignal
 		});
 		if (!res.ok) {
 			const text = await res.text();
@@ -94,6 +286,41 @@ var AgentClient = class {
 			throw new Error(`Agent killShellSession failed (${res.status}): ${text}`);
 		}
 	}
+	async exec(params, opts) {
+		const stream = this.run(params, opts?.signal);
+		const first = await stream.next();
+		if (first.done) throw new Error("Stream ended without 'started' event");
+		if (first.value.type !== "started") throw new Error(`Expected 'started' event, got '${first.value.type}'`);
+		const cmdId = first.value.id;
+		if (!cmdId) throw new Error("'started' event missing 'id' field");
+		const startedAt = first.value.ts ? new Date(first.value.ts) : /* @__PURE__ */ new Date();
+		return new Command({
+			agent: this,
+			cmdId,
+			startedAt,
+			stream,
+			signal: opts?.signal,
+			onStdout: opts?.onStdout,
+			onStderr: opts?.onStderr
+		});
+	}
+	async runCommand(cmdOrParams, args, opts) {
+		let params;
+		if (typeof cmdOrParams === "string") params = {
+			cmd: cmdOrParams,
+			args,
+			signal: opts?.signal
+		};
+		else params = cmdOrParams;
+		const { signal, onStdout, onStderr, ...runParams } = params;
+		const command = await this.exec(runParams, {
+			signal,
+			onStdout,
+			onStderr
+		});
+		if (params.detached) return command;
+		return command.wait({ signal });
+	}
 	async readFile(path) {
 		const res = await fetch(`${this.baseUrl}/files/read`, {
 			method: "POST",

package/dist/_chunks/connect.mjs

@@ -1,13 +1,55 @@
-import { l as agentTimeoutError } from "./errors.mjs";
-async function waitForAgent(guestIp, port, timeoutMs = 6e4) {
-	const start = Date.now();
-	const url = `http://${guestIp}:${port}/health`;
-	while (Date.now() - start < timeoutMs) {
+import { n as vmsanPaths } from "./paths.mjs";
+import { t as handleCommandError } from "./errors.mjs";
+import { t as createCommandLogger } from "./logger.mjs";
+import "./vm-state.mjs";
+import { n as waitForAgent, t as resolveVmState } from "./vm-context.mjs";
+import { t as ShellSession } from "./shell.mjs";
+import { consola } from "consola";
+import { defineCommand } from "citty";
+const connectCommand = defineCommand({
+	meta: {
+		name: "connect",
+		description: "Connect to a running VM"
+	},
+	args: {
+		vmId: {
+			type: "positional",
+			description: "VM ID to connect to",
+			required: true
+		},
+		session: {
+			type: "string",
+			alias: "s",
+			description: "Attach to an existing shell session ID",
+			required: false
+		}
+	},
+	async run({ args }) {
+		const cmdLog = createCommandLogger("connect");
+		const paths = vmsanPaths();
 		try {
-			if ((await fetch(url, { signal: AbortSignal.timeout(2e3) })).ok) return;
-		} catch {}
-		await new Promise((r) => setTimeout(r, 500));
+			const { state, guestIp, port } = resolveVmState(args.vmId, paths);
+			consola.debug(`Agent endpoint: ${guestIp}:${port}`);
+			consola.debug("Waiting for agent to become ready...");
+			await waitForAgent(guestIp, port);
+			const shell = new ShellSession({
+				host: guestIp,
+				port,
+				token: state.agentToken,
+				sessionId: args.session
+			});
+			const closeInfo = await shell.connect();
+			cmdLog.set({
+				vmId: args.vmId,
+				method: "pty"
+			});
+			cmdLog.emit();
+			if (!closeInfo.sessionDestroyed && shell.sessionId) process.stderr.write(`\nResume this session with:\n  vmsan connect ${args.vmId} --session ${shell.sessionId}\n`);
+			process.exit(0);
+		} catch (error) {
+			handleCommandError(error, cmdLog);
+			process.exit(1);
+		}
 	}
-	throw agentTimeoutError(guestIp, timeoutMs);
-}
-export { waitForAgent as t };
+});
+export { connectCommand as default };