@zgeoff/imp-client 0.7.0 → 0.9.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.7.0";
+const CLIENT_VERSION = "0.9.0";
 async function checkServer(rpc) {
 	const info = await rpc.system.info();
 	return {
@@ -29,6 +29,29 @@ function parseVersion(version) {
 //#region ../api/src/name-schema.ts
 const NameSchema = z.string().regex(/^[a-z][a-z0-9-]{0,30}$/, "must be a lowercase letter followed by up to 30 lowercase letters, digits or hyphens");
 //#endregion
+//#region ../api/src/image-schema.ts
+const ImageSchema = z.object({
+	id: z.string(),
+	name: NameSchema,
+	ref: z.string(),
+	digest: z.string(),
+	createdAt: z.date(),
+	sizeBytes: z.int().nonnegative()
+});
+//#endregion
+//#region ../api/src/image-build-protocol.ts
+const IMAGE_BUILD_PATH = "/images/build";
+const DockerfilePathSchema = z.string().min(1).refine((path) => !path.startsWith("/") && !path.split(/[/\\]/u).includes(".."), { message: "the Dockerfile path must be relative and stay inside the build context" });
+z.object({
+	name: NameSchema,
+	dockerfile: DockerfilePathSchema.optional()
+});
+const ImageBuildResultSchema = ImageSchema.extend({ createdAt: z.coerce.date() });
+const ImageBuildErrorSchema = z.object({
+	code: z.string(),
+	message: z.string()
+});
+//#endregion
 //#region ../api/src/session-schema.ts
 const SessionNameSchema = z.string().regex(/^[a-z0-9][a-z0-9-]{0,31}$/, "must be a lowercase letter or digit followed by up to 31 lowercase letters, digits or hyphens");
 const SessionExitSchema = z.object({
@@ -66,10 +89,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 +131,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 +176,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",
@@ -160,6 +245,44 @@ const CONSOLE_SHELL = [
 	"exec \"$shell\" -l"
 ].join("\n");
 //#endregion
+//#region src/resolve-impd-url.ts
+function resolveImpdUrl(base, path) {
+	const url = new URL(base);
+	url.pathname = `${url.pathname.replace(/\/+$/, "")}${path}`;
+	return url;
+}
+//#endregion
+//#region src/build-image.ts
+async function buildImage(deps, name, context, options = {}) {
+	const url = resolveImpdUrl(deps.baseUrl, IMAGE_BUILD_PATH);
+	url.searchParams.set("name", name);
+	if (options.dockerfile !== void 0) url.searchParams.set("dockerfile", options.dockerfile);
+	const headers = { "content-type": "application/x-tar" };
+	if (deps.token !== null) headers["authorization"] = `Bearer ${deps.token}`;
+	if (options.size !== void 0) headers["content-length"] = String(options.size);
+	const init = {
+		method: "POST",
+		headers,
+		body: context,
+		duplex: "half",
+		...options.signal !== void 0 && { signal: options.signal }
+	};
+	const request = new Request(url.href, init);
+	const response = await (deps.fetch ?? fetch)(request);
+	const body = await response.json().catch(() => null);
+	if (response.ok) return ImageBuildResultSchema.parse(body);
+	const failure = ImageBuildErrorSchema.safeParse(body);
+	if (failure.success) throw new ORPCError$1(failure.data.code, {
+		status: response.status,
+		message: failure.data.message
+	});
+	const code = response.status === 401 ? "UNAUTHORIZED" : "INTERNAL_SERVER_ERROR";
+	throw new ORPCError$1(code, {
+		status: response.status,
+		message: `impd answered ${String(response.status)} to the image build`
+	});
+}
+//#endregion
 //#region src/exec/exec-error.ts
 var ExecError = class extends Error {
 	code;
@@ -182,13 +305,6 @@ function toExecError(outcome) {
 	return new ExecError("LOCAL_ERROR", "an output handler threw", { cause: outcome.error });
 }
 //#endregion
-//#region src/resolve-impd-url.ts
-function resolveImpdUrl(base, path) {
-	const url = new URL(base);
-	url.pathname = `${url.pathname.replace(/\/+$/, "")}${path}`;
-	return url;
-}
-//#endregion
 //#region src/exec/check-impd-access.ts
 const CHECK_TIMEOUT_MS = 5e3;
 async function checkImpdAccess(baseUrl, token, customFetch = fetch) {
@@ -272,7 +388,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",
@@ -407,7 +524,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 = {}) {
@@ -459,7 +577,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) => {
@@ -701,7 +819,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,
@@ -710,8 +829,215 @@ function createImpClient(options) {
 		openConsole: (name, consoleOptions) => openConsole(execDeps, name, consoleOptions),
 		openAttach: (name, session, attachOptions) => openAttach(execDeps, name, session, attachOptions),
 		requireAwake: (name, awakeOptions) => requireAwake(rpc, name, awakeOptions),
-		checkServer: () => checkServer(rpc)
+		checkServer: () => checkServer(rpc),
+		buildImage: (name, context, buildOptions) => buildImage(execDeps, name, context, buildOptions)
+	};
+}
+//#endregion
+//#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, safe };
+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.7.0",
+  "version": "0.9.0",
   "description": "Typed client for impd, the imp host daemon: imps, checkpoints, images and exec",
   "license": "MIT",
   "repository": {