@graftland/plugin-remote 0.3.1 → 0.3.2

package/src/internal/runner/Execution.ts

@@ -45,192 +45,191 @@ export class Channels extends Context.Service<
 	}
 >()("@graftland/plugin-remote/internal/runner/Execution/Channels") {}
 
-export const make = (root: string) =>
-	Effect.gen(function* () {
-		const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
-		const fs = yield* FileSystem.FileSystem
-		const path = yield* Path.Path
-		const platform = Context.make(
-			ChildProcessSpawner.ChildProcessSpawner,
-			spawner,
-		).pipe(Context.add(FileSystem.FileSystem, fs), Context.add(Path.Path, path))
+export const make = Effect.fnUntraced(function* (root: string) {
+	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
+	const fs = yield* FileSystem.FileSystem
+	const path = yield* Path.Path
+	const platform = Context.make(
+		ChildProcessSpawner.ChildProcessSpawner,
+		spawner,
+	).pipe(Context.add(FileSystem.FileSystem, fs), Context.add(Path.Path, path))
 
-		const peers = yield* Ref.make(HashMap.empty<string, Multiplex.Peer>())
-		const claimed = yield* Ref.make(HashSet.empty<string>())
-		const driver = Execution.of({
-			recover: (child) =>
-				Processes.recover(child).pipe(Effect.provideContext(platform)),
-			spawn: (handle, request, limits) =>
-				Effect.gen(function* () {
-					const resolved = yield* Packages.resolve(
-						root,
-						request.specifier,
-						request.digest,
-					)
-					const argv = yield* command()
-					const child = yield* spawner.spawn(
-						ChildProcess.make(
-							argv[0],
-							[
-								...Array.drop(argv, 1),
-								"child",
-								resolved.entry,
-								handle.token,
-								yield* Schema.encodeEffect(Schema.fromJsonString(Bootstrap))({
-									identity: {
-										id: handle.key.instance,
-										generation: handle.generation,
-									},
-									limits,
-								}),
-							],
-							{
-								stdin: "pipe",
-								stdout: "pipe",
-								stderr: "pipe",
-								additionalFds: {
-									fd3: { type: "output" },
-									fd4: { type: "input" },
+	const peers = yield* Ref.make(HashMap.empty<string, Multiplex.Peer>())
+	const claimed = yield* Ref.make(HashSet.empty<string>())
+	const driver = Execution.of({
+		recover: (child) =>
+			Processes.recover(child).pipe(Effect.provideContext(platform)),
+		spawn: Effect.fnUntraced(
+			function* (handle, request, limits) {
+				const resolved = yield* Packages.resolve(
+					root,
+					request.specifier,
+					request.digest,
+				)
+				const argv = yield* command()
+				const child = yield* spawner.spawn(
+					ChildProcess.make(
+						argv[0],
+						[
+							...Array.drop(argv, 1),
+							"child",
+							resolved.entry,
+							handle.token,
+							yield* Schema.encodeEffect(Schema.fromJsonString(Bootstrap))({
+								identity: {
+									id: handle.key.instance,
+									generation: handle.generation,
 								},
-								forceKillAfter: "1 second",
+								limits,
+							}),
+						],
+						{
+							stdin: "pipe",
+							stdout: "pipe",
+							stderr: "pipe",
+							additionalFds: {
+								fd3: { type: "output" },
+								fd4: { type: "input" },
 							},
-						),
-					)
-					const observation = yield* ProcessObservation.observe(child)
-					const exited = observation.exited.pipe(
+							forceKillAfter: "1 second",
+						},
+					),
+				)
+				const observation = yield* ProcessObservation.observe(child)
+				const exited = observation.exited.pipe(
+					Effect.mapError((error) =>
+						ExecutionError.make({
+							detail: "Observing child exit failed",
+							cause: Cause.fail(error),
+						}),
+					),
+				)
+				const failures = yield* FailureGroup.make<ExecutionError>()
+				yield* failures.run(
+					observation.failure.pipe(
 						Effect.mapError((error) =>
 							ExecutionError.make({
-								detail: "Observing child exit failed",
+								detail: "Reading child output failed",
 								cause: Cause.fail(error),
 							}),
 						),
-					)
-					const failures = yield* FailureGroup.make<ExecutionError>()
-					yield* failures.run(
-						observation.failure.pipe(
-							Effect.mapError((error) =>
-								ExecutionError.make({
-									detail: "Reading child output failed",
-									cause: Cause.fail(error),
-								}),
-							),
-						),
-					)
-					const controls = yield* Queue.bounded<string>(4)
+					),
+				)
+				const controls = yield* Queue.bounded<string>(4)
 
-					yield* failures.run(
-						Stream.fromQueue(controls).pipe(
-							Stream.map((line) => new TextEncoder().encode(line + "\n")),
-							Stream.run(child.getInputFd(4)),
+				yield* failures.run(
+					Stream.fromQueue(controls).pipe(
+						Stream.map((line) => new TextEncoder().encode(line + "\n")),
+						Stream.run(child.getInputFd(4)),
+						Effect.mapError((error) =>
+							ExecutionError.make({
+								detail: "Child supervision channel failed",
+								cause: Cause.fail(error),
+							}),
+						),
+					),
+				)
+				const send = (value: typeof Command.Type) =>
+					Effect.raceFirst(
+						Schema.encodeEffect(CommandJson)(value).pipe(
+							Effect.flatMap((line) => Queue.offer(controls, line)),
+							Effect.asVoid,
 							Effect.mapError((error) =>
 								ExecutionError.make({
-									detail: "Child supervision channel failed",
+									detail: "Encoding watchdog command failed",
 									cause: Cause.fail(error),
 								}),
 							),
 						),
+						failures.await,
 					)
-					const send = (value: typeof Command.Type) =>
-						Effect.raceFirst(
-							Schema.encodeEffect(CommandJson)(value).pipe(
-								Effect.flatMap((line) => Queue.offer(controls, line)),
-								Effect.asVoid,
-								Effect.mapError((error) =>
-									ExecutionError.make({
-										detail: "Encoding watchdog command failed",
-										cause: Cause.fail(error),
-									}),
-								),
-							),
-							failures.await,
-						)
-					const peer = yield* Multiplex.make({
-						input: child
-							.getOutputFd(3)
-							.pipe(
-								Stream.mapError((error) =>
-									TransportError.make({ cause: Cause.fail(error) }),
-								),
-							),
-						output: child.stdin.pipe(
-							Sink.mapError((error) =>
+				const peer = yield* Multiplex.make({
+					input: child
+						.getOutputFd(3)
+						.pipe(
+							Stream.mapError((error) =>
 								TransportError.make({ cause: Cause.fail(error) }),
 							),
 						),
-					})
-					const identity = yield* Processes.identity(child.pid)
-					yield* Ref.update(peers, HashMap.set(handle.token, peer))
-					yield* Effect.addFinalizer(() =>
-						Ref.update(peers, HashMap.remove(handle.token)),
-					)
-					return {
-						code: resolved.identity,
-						start: send({ kind: "start" }),
-						identity,
-						exited,
-						interrupt: send({ kind: "stop" }),
-						kill: child.kill({ killSignal: "SIGKILL" }).pipe(
-							Effect.mapError((error) =>
-								ExecutionError.make({
-									detail: "Killing the child failed",
-									cause: Cause.fail(error),
-								}),
-							),
+					output: child.stdin.pipe(
+						Sink.mapError((error) =>
+							TransportError.make({ cause: Cause.fail(error) }),
 						),
-						renew: (millis: number) => send({ kind: "renew", millis }),
-					}
-				}).pipe(
-					Effect.provideContext(platform),
-					Effect.catchTags({
-						PlatformError: (error) =>
-							Effect.fail(
-								ExecutionError.make({
-									detail: "Starting the child failed",
-									cause: Cause.fail(error),
-								}),
-							),
-						SchemaError: (error) =>
-							Effect.fail(
-								ExecutionError.make({
-									detail: "Encoding child bootstrap failed",
-									cause: Cause.fail(error),
-								}),
-							),
-					}),
-				),
-		})
-		return {
-			driver,
-			peer: (token: string) =>
-				Effect.acquireRelease(
-					Effect.gen(function* () {
-						const peer = yield* Ref.get(peers).pipe(
-							Effect.flatMap((all) => {
-								const peer = HashMap.get(all, token)
-								return peer._tag === "Some"
-									? Effect.succeed(peer.value)
-									: Effect.fail(
-											SessionStopped.make({
-												detail: "The execution channel is no longer available",
-											}),
-										)
+					),
+				})
+				const identity = yield* Processes.identity(child.pid)
+				yield* Ref.update(peers, HashMap.set(handle.token, peer))
+				yield* Effect.addFinalizer(() =>
+					Ref.update(peers, HashMap.remove(handle.token)),
+				)
+				return {
+					code: resolved.identity,
+					start: send({ kind: "start" }),
+					identity,
+					exited,
+					interrupt: send({ kind: "stop" }),
+					kill: child.kill({ killSignal: "SIGKILL" }).pipe(
+						Effect.mapError((error) =>
+							ExecutionError.make({
+								detail: "Killing the child failed",
+								cause: Cause.fail(error),
 							}),
-						)
-						const occupied = yield* Ref.modify(
-							claimed,
-							(all) =>
-								[HashSet.has(all, token), HashSet.add(all, token)] as const,
-						)
-						if (occupied)
-							return yield* SessionConflict.make({
-								detail: "The instance channel is already attached",
-							})
-						return peer
-					}),
-					() => Ref.update(claimed, HashSet.remove(token)),
-				),
-		}
+						),
+					),
+					renew: (millis: number) => send({ kind: "renew", millis }),
+				}
+			},
+			Effect.provideContext(platform),
+			Effect.catchTags({
+				PlatformError: (error) =>
+					Effect.fail(
+						ExecutionError.make({
+							detail: "Starting the child failed",
+							cause: Cause.fail(error),
+						}),
+					),
+				SchemaError: (error) =>
+					Effect.fail(
+						ExecutionError.make({
+							detail: "Encoding child bootstrap failed",
+							cause: Cause.fail(error),
+						}),
+					),
+			}),
+		),
 	})
+	return {
+		driver,
+		peer: (token: string) =>
+			Effect.acquireRelease(
+				Effect.gen(function* () {
+					const peer = yield* Ref.get(peers).pipe(
+						Effect.flatMap((all) => {
+							const peer = HashMap.get(all, token)
+							return peer._tag === "Some"
+								? Effect.succeed(peer.value)
+								: Effect.fail(
+										SessionStopped.make({
+											detail: "The execution channel is no longer available",
+										}),
+									)
+						}),
+					)
+					const occupied = yield* Ref.modify(
+						claimed,
+						(all) =>
+							[HashSet.has(all, token), HashSet.add(all, token)] as const,
+					)
+					if (occupied)
+						return yield* SessionConflict.make({
+							detail: "The instance channel is already attached",
+						})
+					return peer
+				}),
+				() => Ref.update(claimed, HashSet.remove(token)),
+			),
+	}
+})
 
 export const layer = (root: string) =>
 	Layer.effectContext(

package/src/internal/runner/Framing.ts

@@ -27,16 +27,15 @@ export const maxPayload = 1024 * 1024
 const invalid = (detail: string) => FrameError.make({ detail })
 
 /** Version 2 carries only channel and length; request admission belongs to port. */
-export const encode = (frame: Frame) =>
-	Effect.gen(function* () {
-		if (frame.payload.byteLength > maxPayload)
-			return yield* invalid("Runner frame exceeds the payload limit")
-		const bytes = new Uint8Array(headerSize + frame.payload.byteLength)
-		bytes.set([2, frame.channel, 0, 0])
-		new DataView(bytes.buffer).setUint32(4, frame.payload.byteLength)
-		bytes.set(frame.payload, headerSize)
-		return bytes
-	})
+export const encode = Effect.fnUntraced(function* (frame: Frame) {
+	if (frame.payload.byteLength > maxPayload)
+		return yield* invalid("Runner frame exceeds the payload limit")
+	const bytes = new Uint8Array(headerSize + frame.payload.byteLength)
+	bytes.set([2, frame.channel, 0, 0])
+	new DataView(bytes.buffer).setUint32(4, frame.payload.byteLength)
+	bytes.set(frame.payload, headerSize)
+	return bytes
+})
 
 /** Check a message boundary; the decoder still validates the frame's contents. */
 export const isCompleteFrame = (bytes: Uint8Array): boolean =>

package/src/internal/runner/Local.ts

@@ -41,33 +41,32 @@ export const connect = Effect.fnUntraced(function* (
 		resources: yield* Effect.scope,
 		transport: { ...peer, failure: failures.await, report },
 		diagnostics: Fiber.await(exited).pipe(Effect.andThen(failures.cause)),
-		terminate: (graceful: boolean) =>
-			Effect.gen(function* () {
-				// Stop observation before intentionally ending stdin or killing the process.
-				yield* failures.close
-				if (!graceful) return
-				// If this fails, the execution scope forces termination and waits for exit.
-				const status = yield* peer.end.pipe(
-					// Peer EOF can interrupt the writer as its output ends. Still confirm the unit's exit.
-					Effect.catchCauseIf(Cause.hasInterruptsOnly, () => Effect.void),
-					Effect.andThen(Fiber.join(exited)),
-					Effect.interruptible,
-					Effect.timeoutOrElse({
-						duration: stdinExitTimeout,
-						orElse: () =>
-							LocalTerminationTimeout.make({
-								...Option.match(execution.pid, {
-									onNone: () => ({}),
-									onSome: (pid) => ({ pid }),
-								}),
-								...(execution.threadId === undefined
-									? {}
-									: { threadId: execution.threadId }),
+		terminate: Effect.fnUntraced(function* (graceful: boolean) {
+			// Stop observation before intentionally ending stdin or killing the process.
+			yield* failures.close
+			if (!graceful) return
+			// If this fails, the execution scope forces termination and waits for exit.
+			const status = yield* peer.end.pipe(
+				// Peer EOF can interrupt the writer as its output ends. Still confirm the unit's exit.
+				Effect.catchCauseIf(Cause.hasInterruptsOnly, () => Effect.void),
+				Effect.andThen(Fiber.join(exited)),
+				Effect.interruptible,
+				Effect.timeoutOrElse({
+					duration: stdinExitTimeout,
+					orElse: () =>
+						LocalTerminationTimeout.make({
+							...Option.match(execution.pid, {
+								onNone: () => ({}),
+								onSome: (pid) => ({ pid }),
 							}),
-					}),
-				)
-				if (status.exitCode !== 0 || status.statusCause.reasons.length > 0)
-					return yield* status
-			}),
+							...(execution.threadId === undefined
+								? {}
+								: { threadId: execution.threadId }),
+						}),
+				}),
+			)
+			if (status.exitCode !== 0 || status.statusCause.reasons.length > 0)
+				return yield* status
+		}),
 	}
 })

package/src/internal/runner/Lock.ts

@@ -2,28 +2,26 @@ import { Cause, Effect, FileSystem, Path } from "effect"
 import { StateDirectoryLocked } from "./model"
 
 /** SQLite owns the local directory lock for the enclosing scope, including failed startup. */
-export const acquire = (directory: string) =>
-	Effect.gen(function* () {
-		const fs = yield* FileSystem.FileSystem
-		const path = yield* Path.Path
-		yield* fs
-			.makeDirectory(directory, { recursive: true })
-			.pipe(Effect.uninterruptible)
-		const { DatabaseSync } = yield* Effect.promise(
-			() => import("node:sqlite"),
-		).pipe(Effect.uninterruptible)
-		const locked = (cause: unknown) =>
-			StateDirectoryLocked.make({
-				detail:
-					"The runner state directory is already owned or cannot be locked",
-				cause: Cause.die(cause),
-			})
-		const db = yield* Effect.acquireRelease(
-			Effect.try({
-				try: () => new DatabaseSync(path.join(directory, "owner.sqlite")),
-				catch: locked,
-			}),
-			(db) => Effect.sync(() => db.close()),
-		)
-		yield* Effect.try({ try: () => db.exec("BEGIN EXCLUSIVE"), catch: locked })
-	})
+export const acquire = Effect.fnUntraced(function* (directory: string) {
+	const fs = yield* FileSystem.FileSystem
+	const path = yield* Path.Path
+	yield* fs
+		.makeDirectory(directory, { recursive: true })
+		.pipe(Effect.uninterruptible)
+	const { DatabaseSync } = yield* Effect.promise(
+		() => import("node:sqlite"),
+	).pipe(Effect.uninterruptible)
+	const locked = (cause: unknown) =>
+		StateDirectoryLocked.make({
+			detail: "The runner state directory is already owned or cannot be locked",
+			cause: Cause.die(cause),
+		})
+	const db = yield* Effect.acquireRelease(
+		Effect.try({
+			try: () => new DatabaseSync(path.join(directory, "owner.sqlite")),
+			catch: locked,
+		}),
+		(db) => Effect.sync(() => db.close()),
+	)
+	yield* Effect.try({ try: () => db.exec("BEGIN EXCLUSIVE"), catch: locked })
+})

package/src/internal/runner/Packages.ts

@@ -44,39 +44,38 @@ export const digest = Effect.fnUntraced(function* (directory: string) {
 	const hash = yield* Effect.sync(() =>
 		createHash("sha256").update("graft-package-sha256-v1\0"),
 	)
-	const visit = (
+	const visit = Effect.fnUntraced(function* (
 		relative: string,
-	): Effect.Effect<void, PackageError | PlatformError.PlatformError> =>
-		Effect.gen(function* () {
-			const filename = path.join(directory, relative)
-			const info = yield* fs.stat(filename)
-			if (info.type !== "File" && info.type !== "Directory")
-				return yield* PackageError.make({
-					detail: `Unsupported package entry: ${relative}`,
-				})
-			const name = new TextEncoder().encode(relative)
-			yield* Effect.sync(() => {
-				hash.update(
-					`${info.type}:${name.byteLength}:${info.type === "File" ? info.size : 0}:`,
-				)
-				hash.update(name)
+	): Effect.fn.Return<void, PackageError | PlatformError.PlatformError> {
+		const filename = path.join(directory, relative)
+		const info = yield* fs.stat(filename)
+		if (info.type !== "File" && info.type !== "Directory")
+			return yield* PackageError.make({
+				detail: `Unsupported package entry: ${relative}`,
 			})
-			if (info.type === "File") {
-				yield* fs.stream(filename).pipe(
-					Stream.runForEach((bytes) =>
-						Effect.sync(() => {
-							hash.update(bytes)
-						}),
-					),
-				)
-			} else {
-				const entries = yield* fs.readDirectory(filename)
-				for (const entry of Array.sort(entries, Order.String)) {
-					if (entry === "node_modules") continue
-					yield* visit(relative === "" ? entry : `${relative}/${entry}`)
-				}
-			}
+		const name = new TextEncoder().encode(relative)
+		yield* Effect.sync(() => {
+			hash.update(
+				`${info.type}:${name.byteLength}:${info.type === "File" ? info.size : 0}:`,
+			)
+			hash.update(name)
 		})
+		if (info.type === "File") {
+			yield* fs.stream(filename).pipe(
+				Stream.runForEach((bytes) =>
+					Effect.sync(() => {
+						hash.update(bytes)
+					}),
+				),
+			)
+		} else {
+			const entries = yield* fs.readDirectory(filename)
+			for (const entry of Array.sort(entries, Order.String)) {
+				if (entry === "node_modules") continue
+				yield* visit(relative === "" ? entry : `${relative}/${entry}`)
+			}
+		}
+	})
 	yield* visit("")
 	return yield* Effect.sync(() => hash.digest("hex"))
 })
@@ -136,43 +135,41 @@ export const resolve = Effect.fnUntraced(
 	}),
 )
 
-export const resolveEntry = (installation: string, specifier: string) =>
-	Effect.gen(function* () {
-		const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
-		return yield* Effect.scoped(
-			Effect.gen(function* () {
-				const child = yield* spawner.spawn(
-					ChildProcess.make(
-						process.execPath,
-						[
-							"--input-type=module",
-							"--eval",
-							"process.stdout.write(import.meta.resolve(process.argv[1]))",
-							"--",
-							specifier,
-						],
-						{
-							cwd: installation,
-							env: {},
-							stdin: "ignore",
-							stdout: "pipe",
-							stderr: "pipe",
-						},
-					),
-				)
-				const [code, stdout, stderr] = yield* Effect.all(
-					[
-						child.exitCode,
-						child.stdout.pipe(Stream.decodeText(), Stream.mkString),
-						child.stderr.pipe(Stream.decodeText(), Stream.mkString),
-					],
-					{ concurrency: "unbounded" },
-				)
-				if (code !== 0)
-					return yield* PackageError.make({
-						detail: `Package resolution failed: ${stderr}`,
-					})
-				return stdout
-			}),
-		)
-	})
+export const resolveEntry = Effect.fnUntraced(function* (
+	installation: string,
+	specifier: string,
+) {
+	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner
+	const child = yield* spawner.spawn(
+		ChildProcess.make(
+			process.execPath,
+			[
+				"--input-type=module",
+				"--eval",
+				"process.stdout.write(import.meta.resolve(process.argv[1]))",
+				"--",
+				specifier,
+			],
+			{
+				cwd: installation,
+				env: {},
+				stdin: "ignore",
+				stdout: "pipe",
+				stderr: "pipe",
+			},
+		),
+	)
+	const [code, stdout, stderr] = yield* Effect.all(
+		[
+			child.exitCode,
+			child.stdout.pipe(Stream.decodeText(), Stream.mkString),
+			child.stderr.pipe(Stream.decodeText(), Stream.mkString),
+		],
+		{ concurrency: "unbounded" },
+	)
+	if (code !== 0)
+		return yield* PackageError.make({
+			detail: `Package resolution failed: ${stderr}`,
+		})
+	return stdout
+}, Effect.scoped)