@gjermundgaraba/clankerbox-rivet-sandbox-agent 0.16.0 → 0.18.0

package/dist/index.mjs

@@ -1,8 +1,8 @@
 import * as NodeServices from "@effect/platform-node/NodeServices";
 import * as NodeClient from "@gjermundgaraba/clankerbox-sdk/node";
 import { Data, Duration, Effect, Exit, FileSystem, Layer, ManagedRuntime, Option, Predicate, Schedule, Schema, Scope, Semaphore } from "effect";
-import { randomBytes } from "node:crypto";
-import { Client, Internal, Prebuild, Precondition, actionsByName, loadProfile, pinnedSsh, specRequest, sshTarget } from "@gjermundgaraba/clankerbox-sdk";
+import { ActionName, Client, Conflict, Internal, Prebuild, loadProfile, pinnedSsh, specRequest, sshTarget } from "@gjermundgaraba/clankerbox-sdk";
+import { Hex } from "effect/encoding";
 import { SandboxDestroyedError } from "sandbox-agent";
 import { spawn } from "node:child_process";
 import { closeSync, openSync } from "node:fs";
@@ -15,19 +15,11 @@ const agentPort = 2468;
 const healthPath = "/v1/health";
 //#endregion
 //#region src/tunnel.ts
-/**
-* The tunnel's ssh runs `cat` on a pipe this process holds, so it ends however this process ends.
-* Neither keeps the event loop alive; that takes `node:child_process`, as Effect's process handle
-* can't unref the pipe.
-*/
 const loopback = "127.0.0.1";
 /** A failure on this machine's side, such as a taken port, which no start of the guest changes. */
 var LocalTunnelError = class extends Data.TaggedError("LocalTunnelError") {};
-/** ssh's default ConnectTimeout is the system's TCP timeout, minutes; the SDK waits on this. */
 const openWait = Duration.seconds(30);
-/** A login takes about a second. */
 const openPause = Duration.millis(100);
-/** ssh ends in milliseconds once told to. */
 const closeWait = Duration.seconds(5);
 const freePort = Effect.callback((resume) => {
 	const server = createServer();
@@ -72,9 +64,7 @@ const forwarding = (port, extra) => [
 	`${loopback}:${port}:${loopback}:${agentPort}`,
 	"cat"
 ];
-/** Node sets an exit code for a child that failed to start too. */
 const over = (child) => child.exitCode !== null || child.signalCode !== null;
-/** A program that couldn't be run emits `error`, with no `exit`. */
 const exited = (child) => Effect.callback((resume) => {
 	if (over(child)) return resume(Effect.void);
 	const done = () => resume(Effect.void);
@@ -87,7 +77,9 @@ const exited = (child) => Effect.callback((resume) => {
 });
 /**
 * A port another program holds is refused first: the wait for the port to listen can't tell whose
-* listener it finds. Closing the scope waits for ssh's exit, so the port is free again.
+* listener it finds. Closing the scope waits for ssh's exit, so the port is free again. The ssh
+* runs `cat` on a pipe this process holds, so it ends however this process ends, and neither keeps
+* the event loop alive.
 */
 const open = (start) => Effect.gen(function* () {
 	if (yield* listening(start.port)) return yield* new LocalTunnelError({ message: `the tunnel to ${start.machine} can't use port ${start.port}: another program listens on it` });
@@ -132,14 +124,18 @@ const open = (start) => Effect.gen(function* () {
 });
 //#endregion
 //#region src/sandboxes.ts
-/** The calls that make a machine, whose failure may leave it on its host. */
-const makers = [
-	actionsByName.createMachine,
-	actionsByName.forkMachine,
-	actionsByName.restoreMachine
-];
+const makesMachine = {
+	createMachine: true,
+	forkMachine: true,
+	restoreMachine: true,
+	startMachine: false,
+	stopMachine: false,
+	deleteMachine: false,
+	captureCheckpoint: false,
+	deleteCheckpoint: false
+};
+const isActionName = Schema.is(ActionName);
 const name = "clankerbox";
-/** The agent answers on loopback in milliseconds, so a slower one counts as not answering. */
 const healthWait = Duration.seconds(3);
 const Health = Schema.Struct({ status: Schema.Literal("ok") });
 const isHealth = Schema.is(Health);
@@ -154,7 +150,6 @@ const make = (options, ssh = "ssh") => {
 		sandboxes.set(id, known);
 		return known;
 	};
-	/** A sandbox's operations never overlap: the host would refuse a second start or stop as busy. */
 	const locked = (id, use) => Effect.suspend(() => {
 		const known = sandbox(id);
 		return Semaphore.withPermit(known.lock, Effect.suspend(() => use(known)));
@@ -172,13 +167,11 @@ const make = (options, ssh = "ssh") => {
 		known.held = void 0;
 		return was === void 0 ? Effect.void : Scope.close(was.scope, Exit.void);
 	});
-	/** The machine is read for each tunnel, as its endpoint changes: on boat at every start. */
 	const opened = (id, known) => Effect.gen(function* () {
 		if (known.held?.tunnel.running() === true) return yield* portOf(known);
 		yield* closed(known);
 		const client = yield* Client.Client;
-		const target = sshTarget(yield* client.machine(id));
-		if ("lacks" in target) return yield* new Precondition({ message: `${id} has no ${target.lacks}, which its tunnel needs: see clankerbox get ${id}` });
+		const target = yield* sshTarget(yield* client.getMachine({ id }));
 		const port = yield* portOf(known);
 		const scope = yield* Scope.make();
 		known.held = {
@@ -201,16 +194,21 @@ const make = (options, ssh = "ssh") => {
 		duration: healthWait,
 		orElse: () => Effect.succeed(false)
 	}), Effect.catch(() => Effect.succeed(false)));
-	/** A start reruns a running machine's start hook and may move its endpoint: the tunnel ends. */
 	const started = (id, known) => Effect.gen(function* () {
-		yield* (yield* Client.Client).start(id);
+		yield* (yield* Client.Client).startMachine({ id });
 		yield* closed(known);
 	}).pipe(Effect.catchTag("NotFound", (cause) => Effect.fail(new SandboxDestroyedError(id, name, { cause }))));
 	const made = (named) => Effect.gen(function* () {
 		const client = yield* Client.Client;
 		const { from } = options;
-		if ("checkpoint" in from) return yield* client.restore(from.checkpoint, named);
-		if ("machine" in from) return yield* client.fork(from.machine, named);
+		if ("checkpoint" in from) return yield* client.restoreMachine({
+			checkpoint: from.checkpoint,
+			name: named
+		});
+		if ("machine" in from) return yield* client.forkMachine({
+			machine: from.machine,
+			name: named
+		});
 		const { spec, host } = yield* specRequest("create", yield* loadProfile(from.profile), {});
 		const { machine } = yield* Prebuild.create(client, named, spec, {
 			host,
@@ -218,41 +216,28 @@ const make = (options, ssh = "ssh") => {
 		});
 		return machine;
 	});
-	/**
-	* Only a failed create, fork or restore leaves its machine on the host, and then its error names
-	* it. A placement or prebuild read failure left nothing. A failed delete leaves it to the user.
-	*/
 	const discard = (error) => Effect.gen(function* () {
 		const client = yield* Client.Client;
-		if (error.id !== void 0 && makers.some(({ name }) => name === error.action)) yield* Effect.ignore(client.delete(error.id));
+		if (error.made !== void 0 && isActionName(error.action) && makesMachine[error.action]) yield* Effect.ignore(client.deleteMachine({ id: error.made }));
 		return yield* error;
 	});
 	return {
 		create: Effect.suspend(() => {
-			const named = `${options.namePrefix ?? "sandbox"}-${randomBytes(4).toString("hex")}`;
-			return made(named).pipe(Effect.map((machine) => machine.id), Effect.catchTags({
-				Precondition: discard,
-				Internal: discard,
-				Unavailable: discard
-			}));
+			const named = `${options.namePrefix ?? "sandbox"}-${Hex.encode(globalThis.crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(4)))}`;
+			return made(named).pipe(Effect.map((machine) => machine.id), Effect.catch((error) => error instanceof Conflict ? Effect.fail(error) : discard(error)));
 		}),
 		destroy: (id) => locked(id, (known) => Effect.gen(function* () {
 			const client = yield* Client.Client;
 			yield* closed(known);
-			yield* Effect.catchTag(client.delete(id), "NotFound", () => Effect.void);
+			yield* client.deleteMachine({ id });
 			known.port = void 0;
 		})),
 		pause: (id) => locked(id, (known) => Effect.gen(function* () {
 			const client = yield* Client.Client;
 			yield* closed(known);
-			yield* client.stop(id);
+			yield* client.stopMachine({ id });
 		})),
-		/** The SDK's `ensureServer`, which follows, opens the tunnel. */
 		reconnect: (id) => locked(id, (known) => started(id, known)),
-		/**
-		* A local tunnel failure fails at once, since no start changes it. The SDK calls this only
-		* while it starts: a tunnel that ends later stays down until a caller calls it again.
-		*/
 		ensureServer: (id) => locked(id, (known) => Effect.gen(function* () {
 			const port = yield* opened(id, known).pipe(Effect.asSome, Effect.catchIf((error) => !(error instanceof LocalTunnelError), () => Effect.succeedNone));
 			if (Option.isSome(port) && (yield* healthy(port.value))) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gjermundgaraba/clankerbox-rivet-sandbox-agent",
-  "version": "0.16.0",
+  "version": "0.18.0",
   "description": "clankerbox machines as sandboxes for Rivet's Sandbox Agent",
   "license": "MIT",
   "repository": {
@@ -25,7 +25,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@gjermundgaraba/clankerbox-sdk": "0.16.0"
+    "@gjermundgaraba/clankerbox-sdk": "0.18.0"
   },
   "devDependencies": {
     "@effect/platform-node": "4.0.4",
@@ -33,8 +33,8 @@
     "effect": "4.0.4",
     "sandbox-agent": "0.5.2",
     "typescript": "7.0.2",
-    "vite": "npm:@voidzero-dev/vite-plus-core@1.1.0",
-    "vite-plus": "1.1.0"
+    "vite": "npm:@voidzero-dev/vite-plus-core@1.2.0",
+    "vite-plus": "1.2.0"
   },
   "peerDependencies": {
     "@effect/platform-node": "~4.0.4",