@graftland/plugin-remote 0.3.2 → 0.4.0

package/dist/token-CYBNNlhS.js

@@ -1,17 +0,0 @@
-import { t as AuthenticationFailed } from "./Errors-DYhsGZcZ.js";
-import { Effect, Option, Redacted } from "effect";
-// packages/remote/src/internal/auth/token.ts
-const invalid = () => AuthenticationFailed.make({
-	reason: "invalid",
-	challenge: "Bearer error=\"invalid_token\""
-});
-const read = (authorization) => {
-	if (Option.isNone(authorization)) return Effect.fail(AuthenticationFailed.make({
-		reason: "missing",
-		challenge: "Bearer"
-	}));
-	const token = /^Bearer +([^ ]+)$/i.exec(Redacted.value(authorization.value))?.[1];
-	return token === void 0 ? Effect.fail(invalid()) : Effect.succeed(Redacted.make(token));
-};
-const prepare = (token) => Effect.succeed(Redacted.make("Bearer " + Redacted.value(token)));
-export { prepare as n, read as r, invalid as t };

package/dist/tokenCredentials-CbCuk-Rt.js

@@ -1,31 +0,0 @@
-import { a as provide, l as make } from "./Graft-B71CPA2Y.js";
-import { t as ConfigDirectory } from "./ConfigDirectory-BCC6q2R4.js";
-import { n as Credentials } from "./Auth-BElTC9_X.js";
-import { r as CredentialsError } from "./Errors-DYhsGZcZ.js";
-import { n as prepare } from "./token-CYBNNlhS.js";
-import { Cause, Effect, FileSystem, Option, Path, Redacted, Schema } from "effect";
-// packages/remote/src/internal/auth/tokenCredentials.ts
-const Config$1 = Schema.Struct({ token: Schema.Union([Schema.RedactedFromValue(Schema.String), Schema.Struct({ file: Schema.String })]) });
-const plugin = (name) => make({
-	name,
-	config: Config$1,
-	inject: [FileSystem.FileSystem, Path.Path],
-	apply: Effect.fnUntraced(function* (config) {
-		const fs = yield* FileSystem.FileSystem;
-		const path = yield* Path.Path;
-		const directory = yield* ConfigDirectory;
-		const token = config.token;
-		const read = Redacted.isRedacted(token) ? Effect.succeed(token) : fs.readFileString(path.resolve(Option.getOrElse(directory, () => "."), token.file)).pipe(Effect.map(Redacted.make));
-		yield* provide(Credentials, {
-			kind: "Authorization",
-			read: read.pipe(Effect.flatMap(prepare), Effect.mapBoth({
-				onSuccess: (value) => ({
-					_tag: "Authorization",
-					value
-				}),
-				onFailure: (error) => CredentialsError.make({ cause: Cause.fail(error) })
-			}))
-		});
-	})
-});
-export { plugin as n, Config$1 as t };

package/dist/websocketServer-NQhODlEt.js

@@ -1,60 +0,0 @@
-import { u as TransportError } from "./Errors-DYhsGZcZ.js";
-import { a as payloadLimit, s as protocol, t as fromSocket } from "./socketChannel-CJvL2DiB.js";
-import { Array, Cause, Deferred, Effect, Option, Redacted, Scope, String } from "effect";
-import { NodeHttpServer, NodeHttpServerRequest } from "@effect/platform-node";
-import { HttpServerRequest, HttpServerResponse } from "effect/http";
-import { TLSSocket } from "node:tls";
-// packages/remote/src/internal/websocketServer.ts
-const rejection = (error) => error._tag === "AuthenticatorUnavailable" ? unavailable(error) : unauthorized(error);
-const unavailable = (error) => Effect.logError("Remote host authenticator is unavailable", error.cause).pipe(Effect.as(HttpServerResponse.empty({ status: 503 })));
-const unauthorized = (error) => Effect.logWarning("Remote host authentication failed", { reason: error.reason }, ...error.cause === void 0 ? [] : [error.cause]).pipe(Effect.as(HttpServerResponse.empty({
-	status: 401,
-	headers: error.challenge === void 0 ? {} : { "www-authenticate": error.challenge }
-})));
-const handshake = Effect.gen(function* () {
-	const request = yield* HttpServerRequest.HttpServerRequest;
-	const { socket } = NodeHttpServerRequest.toIncomingMessage(request);
-	const peer = socket instanceof TLSSocket && socket.authorized ? Option.some(socket.getPeerCertificate()) : Option.none();
-	return {
-		authorization: Option.map(Option.fromUndefinedOr(request.headers["authorization"]), Redacted.make),
-		certificate: Option.map(peer, (certificate) => ({
-			der: certificate.raw,
-			subjectAltName: Option.fromUndefinedOr(certificate.subjectaltname)
-		}))
-	};
-});
-const open = Effect.fnUntraced(function* (createServer, options) {
-	const resources = yield* Effect.acquireRelease(Scope.make(), Scope.close);
-	const ready = yield* Deferred.make();
-	const server = yield* NodeHttpServer.make(createServer, {
-		...options,
-		disablePreemptiveShutdown: true,
-		websocket: {
-			perMessageDeflate: false,
-			maxPayload: payloadLimit,
-			handleProtocols: (protocols) => protocols.has("graft-remote.v1") ? protocol : false
-		}
-	}).pipe(Scope.provide(resources));
-	return {
-		address: server.address,
-		ready: Deferred.await(ready),
-		run: (accept) => server.serve(Effect.gen(function* () {
-			const request = yield* HttpServerRequest.HttpServerRequest;
-			if (request.url !== "/graft") return HttpServerResponse.empty({ status: 404 });
-			if (String.toLowerCase(request.headers["upgrade"] ?? "") !== "websocket" || !Array.some(String.split(request.headers["sec-websocket-protocol"] ?? "", ","), (value) => String.trim(value) === "graft-remote.v1")) return HttpServerResponse.empty({ status: 400 });
-			const session = yield* Effect.result(accept);
-			if (session._tag === "Failure") return yield* rejection(session.failure);
-			yield* request.upgrade.pipe(Effect.flatMap(session.success), Effect.interruptible, Effect.scoped);
-			return HttpServerResponse.empty();
-		})).pipe(Effect.andThen(Deferred.succeed(ready, void 0)), Effect.andThen(Effect.never))
-	};
-});
-const bind = Effect.fnUntraced(function* (createServer, options) {
-	const server = yield* open(createServer, options);
-	return {
-		address: server.address,
-		ready: server.ready,
-		serve: (accept) => server.run(handshake.pipe(Effect.flatMap(accept), Effect.map((session) => (socket) => fromSocket(socket).pipe(Effect.flatMap(session))))).pipe(Effect.mapError((error) => TransportError.make({ cause: Cause.fail(error) })))
-	};
-});
-export { bind as t };

package/dist/workerChannel-C8hhBJzA.js

@@ -1,27 +0,0 @@
-import { u as TransportError } from "./Errors-DYhsGZcZ.js";
-import { Cause, Effect, FiberSet, Queue, Schema, Sink, Stream } from "effect";
-// packages/remote/src/internal/workerBootstrap.ts
-const Bootstrap = Schema.Struct({
-	contractModule: Schema.String,
-	session: Schema.String
-});
-// packages/remote/src/internal/workerChannel.ts
-const make = Effect.fnUntraced(function* (endpoint) {
-	const input = yield* Queue.unbounded();
-	const callbacks = yield* FiberSet.make();
-	const run = yield* FiberSet.runtime(callbacks)();
-	const receive = (value) => run(value === null ? Queue.end(input) : Queue.offer(input, new Uint8Array(value)));
-	yield* Effect.acquireRelease(Effect.sync(() => endpoint.on("message", receive)), () => Effect.sync(() => endpoint.off("message", receive)).pipe(Effect.andThen(Queue.shutdown(input))));
-	const send = (bytes) => Effect.try({
-		try: () => {
-			const buffer = bytes === null ? null : new Uint8Array(bytes).buffer;
-			endpoint.postMessage(buffer, buffer === null ? [] : [buffer]);
-		},
-		catch: (cause) => TransportError.make({ cause: Cause.die(cause) })
-	});
-	return {
-		input: Stream.fromQueue(input),
-		output: Sink.forEach((bytes) => send(bytes)).pipe(Sink.ensuring(send(null)))
-	};
-});
-export { Bootstrap as n, make as t };

package/src/internal/release.ts

@@ -1,72 +0,0 @@
-import { Array, Cause, Effect, Exit, Result, Schema, Scope } from "effect"
-
-/** Resource release was interrupted, rather than successfully cancelled. */
-export class ReleaseInterrupted extends Schema.TaggedError<
-	ReleaseInterrupted,
-	{ readonly brand: unique symbol }
->()("ReleaseInterrupted", {
-	cause: Schema.Cause(Schema.Never, Schema.Unknown),
-}) {
-	override get message() {
-		return "Resource release was interrupted"
-	}
-}
-
-/** Keep a known release failure distinguishable from cancellation through enclosing scopes. */
-export const close = (
-	scope: Scope.Closeable,
-	exit: Exit.Exit<unknown, unknown>,
-) =>
-	Effect.uninterruptible(
-		Scope.close(scope, exit).pipe(
-			Effect.catchCauseIf(
-				Cause.hasInterruptsOnly,
-				Effect.fnUntraced(function* (cause) {
-					// Re-entering interruptibility observes pending external cancellation without producing a self-interrupt.
-					// Read it after release so cancellation arriving during a finalizer is included too.
-					const pending = yield* Effect.exit(Effect.interruptible(Effect.void))
-					const [cancelled, interrupted] = Array.partition(
-						cause.reasons,
-						(reason) =>
-							Exit.isFailure(pending) &&
-							Array.some(
-								pending.cause.reasons,
-								(external) =>
-									reason._tag === "Interrupt" &&
-									external._tag === "Interrupt" &&
-									reason.fiberId === external.fiberId,
-							)
-								? Result.succeed(reason)
-								: Result.fail(reason),
-					)
-					if (interrupted.length === 0) return yield* Effect.failCause(cause)
-					return yield* Effect.failCause(
-						Cause.combine(
-							Cause.fromReasons(cancelled),
-							Cause.die(
-								ReleaseInterrupted.make({
-									cause: Cause.fromReasons(interrupted),
-								}),
-							),
-						),
-					)
-				}),
-			),
-		),
-	)
-
-export const scoped = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
-	Effect.uninterruptibleMask((restore) =>
-		Effect.gen(function* () {
-			const scope = yield* Scope.make()
-			const body = yield* Effect.exit(restore(Scope.provide(scope)(effect)))
-			const closed = yield* Effect.exit(close(scope, body))
-			if (Exit.isFailure(closed))
-				return yield* Effect.failCause(
-					Exit.isFailure(body)
-						? Cause.combine(body.cause, closed.cause)
-						: closed.cause,
-				)
-			return yield* body
-		}),
-	)

package/src/internal/serve.ts

@@ -1,119 +0,0 @@
-import { findSubtree, isSubtreeActive } from "./forkTree"
-import { Graft, Plugin, type Fork } from "@graftland/graft"
-import {
-	ConfigDirectory,
-	Include,
-	Loader,
-	ModuleResolver,
-} from "@graftland/loader"
-import {
-	Array,
-	Cause,
-	Deferred,
-	Effect,
-	Exit,
-	Logger,
-	Option,
-	Path,
-	Stream,
-} from "effect"
-import * as Importer from "./importer"
-
-import { ServeLifecycle, StartupError, make } from "./ServeLifecycle"
-import { cleanupCause } from "./cleanup"
-export { StartupError } from "./ServeLifecycle"
-
-const check = (
-	trees: ReadonlyArray<Fork.ForkTree>,
-): Effect.Effect<void, StartupError> =>
-	Effect.forEach(
-		trees,
-		(tree) => {
-			if (tree.state._tag === "Failed")
-				return Effect.fail(
-					StartupError.make({
-						detail: `Runner entry ${tree.name} failed`,
-						cause: tree.state.cause,
-					}),
-				)
-			return check(tree.children)
-		},
-		{ discard: true },
-	)
-const ready = Plugin.make({
-	name: "remote-ready",
-	inject: [Loader.Loader],
-	apply: Effect.fnUntraced(function* () {
-		const loader = yield* Loader.Loader
-		// A failed authenticator can leave its listener child Pending while the outer plugin is Applying.
-		yield* loader.ready.pipe(
-			Effect.raceFirst(
-				Graft.forks.pipe(
-					Stream.map((trees) => findSubtree(trees, loader.root.id)),
-					Stream.filter(Option.isSome),
-					Stream.runForEach((tree) => check([tree.value])),
-				),
-			),
-		)
-		// Pending can still be reacting to a provider published during startup.
-		// Observe the loader's subtree, excluding this startup observer itself.
-		yield* Graft.forks.pipe(
-			Stream.map((trees) => findSubtree(trees, loader.root.id)),
-			Stream.filter(Option.isSome),
-			Stream.map((tree) => tree.value),
-			Stream.tap((tree) => check([tree])),
-			Stream.filter(isSubtreeActive),
-			Stream.runHead,
-		)
-	}),
-})
-
-/** Loader logs child cleanup errors; the supervisor's release signal also reaches the command exit. */
-const close = Effect.fnUntraced(function* (
-	entries: Fork.Fork,
-	lifecycle: typeof ServeLifecycle.Service,
-) {
-	const disposed = yield* Effect.exit(entries.dispose)
-	const released = yield* Effect.exit(Deferred.await(lifecycle.released))
-	const cause = Array.reduce(
-		[disposed, released],
-		Cause.empty,
-		(cause: Cause.Cause<unknown>, exit: Exit.Exit<void, unknown>) =>
-			Exit.isFailure(exit) ? Cause.combine(cause, exit.cause) : cause,
-	)
-	if (cause.reasons.length > 0)
-		return yield* Effect.failCause(cleanupCause(cause))
-})
-
-const load = Effect.fnUntraced(function* (config: string, directory: string) {
-	const lifecycle = yield* make
-	yield* Graft.provide(ServeLifecycle, lifecycle)
-	const importer = yield* Importer.make(directory)
-	const resolver = yield* ModuleResolver.make({ base: directory, importer })
-	yield* Graft.provide(ModuleResolver.ModuleResolver, resolver)
-	const entries = yield* Graft.plugin(Include.Include, {
-		path: config,
-		watch: false,
-	})
-	yield* entries.await
-	const startup = yield* Graft.plugin(ready)
-	yield* startup.await
-	return yield* Deferred.await(lifecycle.ended).pipe(
-		Effect.ensuring(close(entries, lifecycle)),
-	)
-})
-export const run = Effect.fnUntraced(function* (config: string) {
-	const path = yield* Path.Path
-	const file = path.resolve(config)
-	const directory = path.dirname(file)
-	return yield* load(file, directory).pipe(
-		Effect.mapError((error) =>
-			StartupError.make({
-				detail: "Starting the runner failed",
-				cause: Cause.fail(error),
-			}),
-		),
-		Effect.provideService(ConfigDirectory, Option.some(directory)),
-		Effect.provideService(Logger.LogToStderr, true),
-	)
-})