@zgeoff/imp-client 0.6.0 → 0.8.0

package/dist/index.js

@@ -3,7 +3,7 @@ import { RPCLink } from "@orpc/client/fetch";
 import * as z from "zod";
 //#endregion
 //#region src/check-server.ts
-const CLIENT_VERSION = "0.6.0";
+const CLIENT_VERSION = "0.8.0";
 async function checkServer(rpc) {
 	const info = await rpc.system.info();
 	return {
@@ -66,10 +66,14 @@ const ExecStartMessageSchema = z.object({
 	cols: DimensionSchema.optional(),
 	rows: DimensionSchema.optional(),
 	session: SessionNameSchema.optional(),
-	tool: z.enum(["tar"]).optional()
+	tool: z.enum(["tar"]).optional(),
+	killGraceMs: z.int().min(1).max(6e4).optional()
 }).refine((start) => start.session === void 0 || start.tty, {
 	message: "a session needs a tty",
 	path: ["tty"]
+}).refine((start) => start.killGraceMs === void 0 || !start.tty, {
+	message: "a tty exec takes no kill grace",
+	path: ["killGraceMs"]
 }).refine((start) => start.tool === void 0 || !start.tty && start.session === void 0 && start.env === void 0 && start.cwd === void 0, {
 	message: "a tool takes no tty, session, env or cwd",
 	path: ["tool"]
@@ -104,7 +108,8 @@ const ExecServerMessageSchema = z.discriminatedUnion("type", [
 		type: z.literal("started"),
 		pid: z.int().positive(),
 		session: SessionNameSchema.optional(),
-		created: z.boolean().optional()
+		created: z.boolean().optional(),
+		groupKill: z.boolean().optional()
 	}),
 	z.object({
 		type: z.literal("exit"),
@@ -148,6 +153,63 @@ function isExecChannel(value) {
 	return value === EXEC_CHANNELS.stdin || value === EXEC_CHANNELS.stdout || value === EXEC_CHANNELS.stderr;
 }
 //#endregion
+//#region ../api/src/tunnel-protocol.ts
+const TUNNEL_PATH = "/tunnel";
+const TUNNEL_CLOSE_NORMAL = 1e3;
+const TUNNEL_CLOSE_PROTOCOL = 1002;
+const TUNNEL_WINDOW_BYTES = 1048576;
+const TUNNEL_MAX_FRAME_BYTES = 65536;
+const AckSchema = z.object({
+	type: z.literal("ack"),
+	bytes: z.int().positive()
+});
+const TunnelListenSchema = z.object({
+	type: z.literal("listen"),
+	name: NameSchema,
+	network: z.enum(["unix", "tcp"]),
+	path: z.string().startsWith("/").nullable().optional(),
+	port: z.int().min(0).max(65535).optional()
+}).refine((listen) => listen.network === "tcp" ? listen.port !== void 0 && listen.path === void 0 : listen.port === void 0, {
+	message: "tcp takes a port, unix a path or null",
+	path: ["network"]
+});
+z.discriminatedUnion("type", [
+	z.object({
+		type: z.literal("open"),
+		name: NameSchema,
+		port: z.int().min(1).max(65535)
+	}),
+	z.object({ type: z.literal("eof") }),
+	AckSchema,
+	TunnelListenSchema,
+	z.object({
+		type: z.literal("accept"),
+		name: NameSchema,
+		listener: z.string().min(1),
+		connection: z.int().positive()
+	})
+]);
+const TunnelServerMessageSchema = z.discriminatedUnion("type", [
+	z.object({ type: z.literal("opened") }),
+	z.object({ type: z.literal("eof") }),
+	AckSchema,
+	z.object({
+		type: z.literal("listening"),
+		listener: z.string(),
+		path: z.string().nullable(),
+		port: z.int().nullable()
+	}),
+	z.object({
+		type: z.literal("connection"),
+		id: z.int().positive()
+	}),
+	z.object({
+		type: z.literal("error"),
+		message: z.string(),
+		code: z.string().optional()
+	})
+]);
+//#endregion
 //#region ../api/src/login-shell.ts
 const CONSOLE_SHELL = [
 	"uid=$(id -u 2>/dev/null) || uid=0",
@@ -222,7 +284,8 @@ function openExecSession(options) {
 	const state = {
 		opened: false,
 		started: false,
-		finished: false
+		finished: false,
+		refused: false
 	};
 	ws.binaryType = "arraybuffer";
 	const stopSocket = () => {
@@ -271,7 +334,8 @@ function openExecSession(options) {
 			options.onStarted({
 				pid: message.pid,
 				session: message.session ?? null,
-				created: message.created ?? false
+				created: message.created ?? false,
+				groupKill: message.groupKill ?? false
 			});
 		} else if (message.type === "exit") resolveOutcome({
 			kind: "exit",
@@ -311,6 +375,8 @@ function openExecSession(options) {
 		}
 	});
 	const resolveRefusal = async (reason) => {
+		if (state.refused) return;
+		state.refused = true;
 		const access = await checkImpdAccess(options.baseUrl, options.token, options.fetch);
 		if (access === "unauthorized") resolveOutcome({ kind: "unauthorized" });
 		else if (access === "reachable" && options.ticket !== void 0) resolveOutcome({
@@ -326,6 +392,9 @@ function openExecSession(options) {
 			reason
 		});
 	};
+	ws.addEventListener("error", () => {
+		if (!state.opened && !state.finished) resolveRefusal("the connection failed");
+	});
 	ws.addEventListener("close", (event) => {
 		if (state.finished) return;
 		const reason = event.reason === "" ? `code ${String(event.code)}` : event.reason;
@@ -401,7 +470,8 @@ function openExec(deps, name, argv, options = {}) {
 		...options.cwd !== void 0 && { cwd: options.cwd },
 		...options.cols !== void 0 && { cols: options.cols },
 		...options.rows !== void 0 && { rows: options.rows },
-		...options.session !== void 0 && { session: options.session }
+		...options.session !== void 0 && { session: options.session },
+		...options.killGraceMs !== void 0 && { killGraceMs: options.killGraceMs }
 	});
 }
 function openAttach(deps, name, session, options = {}) {
@@ -453,7 +523,7 @@ async function openHandle(deps, options, tty, start) {
 		onOutput: (channel, data) => {
 			(channel === "stderr" ? stderr : stdout).push(data);
 		},
-		connect: (url) => new WebSocket(url),
+		connect: deps.connect ?? ((url) => new WebSocket(url)),
 		...deps.fetch !== void 0 && { fetch: deps.fetch }
 	});
 	const resolveHandle = (result) => {
@@ -461,13 +531,21 @@ async function openHandle(deps, options, tty, start) {
 		state.ended = true;
 		stdout.end();
 		stderr.end();
-		abort?.removeEventListener("abort", stopSession);
+		abort?.removeEventListener("abort", stopForAbort);
 		if ("error" in result) started.resolve({ error: result.error });
 		ended.resolve(result);
 	};
 	const stopSession = () => {
 		stopWith("CLOSED", "the exec session was closed");
 	};
+	const stopForAbort = () => {
+		if (session.isStarted()) {
+			stopSession();
+			return;
+		}
+		session.stop();
+		resolveHandle({ error: readAbortReason(abort) });
+	};
 	const waitForOutcome = async () => {
 		const outcome = await session.outcome;
 		const result = outcome.kind === "exit" ? { value: {
@@ -476,8 +554,8 @@ async function openHandle(deps, options, tty, start) {
 		} } : { error: toExecError(outcome) };
 		resolveHandle(result);
 	};
-	if (abort?.aborted === true) stopSession();
-	else abort?.addEventListener("abort", stopSession, { once: true });
+	if (abort?.aborted === true) stopForAbort();
+	else abort?.addEventListener("abort", stopForAbort, { once: true });
 	waitForOutcome();
 	return buildHandle(session, {
 		started: started.promise,
@@ -488,6 +566,10 @@ async function openHandle(deps, options, tty, start) {
 		streams: [stdout.stream, stderr.stream]
 	});
 }
+function readAbortReason(abort) {
+	const reason = abort?.reason;
+	return reason instanceof Error ? reason : new DOMException("the exec was aborted", "AbortError");
+}
 function openConsole(deps, name, options = {}) {
 	return openExec(deps, name, [
 		"/bin/sh",
@@ -683,7 +765,8 @@ function createImpClient(options) {
 		rpc,
 		baseUrl: options.url,
 		token: token ?? null,
-		...customFetch !== void 0 && { fetch: customFetch }
+		...customFetch !== void 0 && { fetch: customFetch },
+		...options.connect !== void 0 && { connect: options.connect }
 	};
 	return {
 		...namespaces,
@@ -696,4 +779,210 @@ function createImpClient(options) {
 	};
 }
 //#endregion
-export { CLIENT_VERSION, CONSOLE_SHELL, ExecError, ORPCError, createImpClient, isDefinedError, openExecSession, safe };
+//#region src/reverse/open-reverse-forward.ts
+function parseMessage(text) {
+	try {
+		const parsed = TunnelServerMessageSchema.safeParse(JSON.parse(text));
+		return parsed.success ? parsed.data : null;
+	} catch {
+		return null;
+	}
+}
+function buildListenMessage(name, guest) {
+	return guest.network === "tcp" ? {
+		type: "listen",
+		name,
+		network: "tcp",
+		port: guest.port
+	} : {
+		type: "listen",
+		name,
+		network: "unix",
+		path: guest.path
+	};
+}
+function openRelay(target, accept, handlers) {
+	const ws = target.connect(target.url, target.headers);
+	const state = {
+		opened: false,
+		unacked: 0,
+		done: false,
+		peerEof: false,
+		guestEof: false
+	};
+	const waiters = [];
+	const pending = [];
+	ws.binaryType = "arraybuffer";
+	const wakeWaiters = () => {
+		for (const wake of waiters.splice(0)) wake();
+	};
+	const sendText = (message) => {
+		if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify(message));
+	};
+	const sendFrames = (data) => {
+		for (let offset = 0; offset < data.byteLength; offset += TUNNEL_MAX_FRAME_BYTES) ws.send(Uint8Array.from(data.subarray(offset, offset + TUNNEL_MAX_FRAME_BYTES)));
+	};
+	const stopRelay = (lost) => {
+		if (state.done) return;
+		state.done = true;
+		wakeWaiters();
+		handlers.onClose(lost);
+	};
+	const sendAck = async (data) => {
+		await handlers.onData(data);
+		sendText({
+			type: "ack",
+			bytes: data.byteLength
+		});
+	};
+	const handleControl = (message) => {
+		if (message.type === "opened") {
+			state.opened = true;
+			for (const data of pending.splice(0)) sendFrames(data);
+			if (state.peerEof) sendText({ type: "eof" });
+		} else if (message.type === "eof") {
+			state.guestEof = true;
+			handlers.onEof();
+		} else if (message.type === "ack") {
+			state.unacked -= message.bytes;
+			if (state.unacked <= 1048576) wakeWaiters();
+		} else {
+			ws.close(TUNNEL_CLOSE_NORMAL, "relay failed");
+			stopRelay(true);
+		}
+	};
+	ws.addEventListener("open", () => {
+		sendText(accept);
+	});
+	ws.addEventListener("message", (event) => {
+		if (event.data instanceof ArrayBuffer) {
+			sendAck(new Uint8Array(event.data));
+			return;
+		}
+		const message = parseMessage(String(event.data));
+		if (message === null) {
+			ws.close(TUNNEL_CLOSE_PROTOCOL, "bad message");
+			stopRelay(true);
+		} else handleControl(message);
+	});
+	ws.addEventListener("close", (event) => {
+		stopRelay(event.code !== TUNNEL_CLOSE_NORMAL);
+	});
+	ws.addEventListener("error", () => {});
+	return {
+		send: (data) => {
+			if (state.done) return true;
+			if (state.opened) sendFrames(data);
+			else pending.push(Uint8Array.from(data));
+			state.unacked += data.byteLength;
+			return state.unacked <= TUNNEL_WINDOW_BYTES;
+		},
+		waitForRoom: async () => {
+			while (!state.done && state.unacked > 1048576) await new Promise((resolve) => {
+				waiters.push(resolve);
+			});
+		},
+		sendEof: () => {
+			state.peerEof = true;
+			if (state.opened) sendText({ type: "eof" });
+		},
+		close: () => {
+			if (ws.readyState === WebSocket.CONNECTING || ws.readyState === WebSocket.OPEN) ws.close(TUNNEL_CLOSE_NORMAL, "local side closed");
+			stopRelay(false);
+		}
+	};
+}
+function openReverseForward(options) {
+	const url = resolveImpdUrl(options.baseUrl, TUNNEL_PATH);
+	url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+	const headers = options.token === null ? {} : { authorization: `Bearer ${options.token}` };
+	const target = {
+		url: url.href,
+		headers,
+		connect: options.connect
+	};
+	const ws = options.connect(url.href, headers);
+	const listening = Promise.withResolvers();
+	const ended = Promise.withResolvers();
+	const relays = /* @__PURE__ */ new Set();
+	const state = {
+		listener: "",
+		done: false
+	};
+	const waitForListening = async () => {
+		try {
+			await listening.promise;
+		} catch {}
+	};
+	waitForListening();
+	const stopForward = (end) => {
+		if (state.done) return;
+		state.done = true;
+		for (const relay of relays) relay.close();
+		const why = end.kind === "failed" ? end.message : `the forward ${end.kind}`;
+		listening.reject(new Error(why));
+		ended.resolve(end);
+	};
+	const openClientRelay = (id) => {
+		const message = {
+			type: "accept",
+			name: options.name,
+			listener: state.listener,
+			connection: id
+		};
+		options.onConnection((handlers) => {
+			const relay = openRelay(target, message, {
+				...handlers,
+				onClose: (lost) => {
+					relays.delete(relay);
+					handlers.onClose(lost);
+				}
+			});
+			relays.add(relay);
+			return relay;
+		});
+	};
+	const handleControl = (message) => {
+		if (message.type === "listening") {
+			state.listener = message.listener;
+			listening.resolve({
+				path: message.path,
+				port: message.port
+			});
+		} else if (message.type === "connection") openClientRelay(message.id);
+		else if (message.type === "error") stopForward({
+			kind: "failed",
+			code: message.code ?? null,
+			message: message.message
+		});
+		else ws.close(TUNNEL_CLOSE_PROTOCOL, "bad message");
+	};
+	ws.binaryType = "arraybuffer";
+	ws.addEventListener("open", () => {
+		ws.send(JSON.stringify(buildListenMessage(options.name, options.guest)));
+	});
+	ws.addEventListener("message", (event) => {
+		const message = event.data instanceof ArrayBuffer ? null : parseMessage(String(event.data));
+		if (message === null) ws.close(TUNNEL_CLOSE_PROTOCOL, "bad message");
+		else handleControl(message);
+	});
+	ws.addEventListener("close", (event) => {
+		if (event.code === 4e3) stopForward({ kind: "lost" });
+		else stopForward({
+			kind: "closed",
+			code: event.code,
+			reason: event.reason
+		});
+	});
+	ws.addEventListener("error", () => {});
+	return {
+		listening: listening.promise,
+		ended: ended.promise,
+		stop: () => {
+			if (ws.readyState === WebSocket.CONNECTING || ws.readyState === WebSocket.OPEN) ws.close(TUNNEL_CLOSE_NORMAL, "stopped");
+			stopForward({ kind: "stopped" });
+		}
+	};
+}
+//#endregion
+export { CLIENT_VERSION, CONSOLE_SHELL, ExecError, ORPCError, createImpClient, isDefinedError, openExecSession, openReverseForward, safe };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zgeoff/imp-client",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "Typed client for impd, the imp host daemon: imps, checkpoints, images and exec",
   "license": "MIT",
   "repository": {