@alchemy.run/boat 0.0.0 → 2.0.0-beta.86

package/src/internal/SandboxHandle.ts

@@ -0,0 +1,425 @@
+/**
+ * Builds sandbox handles over Boat's REST API: commands, files, ports and
+ * lifecycle all go through `/api/v1` with the binding's key.
+ */
+import * as boat from "@distilled.cloud/boat-dev/boat";
+import type { RuntimeContext } from "alchemy/RuntimeContext";
+import * as Sandbox from "alchemy/Sandbox";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as FetchHttpClient from "effect/http/FetchHttpClient";
+import * as HttpClient from "effect/http/HttpClient";
+import * as HttpClientRequest from "effect/http/HttpClientRequest";
+import * as Option from "effect/Option";
+import * as Redacted from "effect/Redacted";
+import * as Schedule from "effect/Schedule";
+import * as Stream from "effect/Stream";
+import type { BoatAuth } from "../BoatBindings.ts";
+import { BoatUnexpectedResponse, ExecTimedOut, SnapshotFailed } from "../Errors.ts";
+import type {
+  BoatSandbox,
+  Command,
+  ConnectedSandbox,
+  EntryInfo,
+  ExecOptions,
+  ExecResult,
+  Port,
+  Process,
+  ProcessOutput,
+  SandboxOperations,
+  StartOptions,
+} from "../SandboxClient.ts";
+
+const encoder = new TextEncoder();
+
+const toBase64 = (data: string | Uint8Array) => {
+  const bytes = typeof data === "string" ? encoder.encode(data) : data;
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary);
+};
+
+const fromBase64 = (data: string) => Uint8Array.from(atob(data), (char) => char.charCodeAt(0));
+
+/** POSIX single quotes: the value verbatim. */
+const quote = (value: string) => `'${value.replaceAll("'", `'"'"'`)}'`;
+
+/** Boat's `ttlSeconds` for an auto-stop: `null` never stops. */
+export const ttlOf = (autoStop: Duration.Input | false) =>
+  autoStop === false
+    ? null
+    : Math.max(1, Math.round(Duration.toMillis(Duration.fromInputUnsafe(autoStop)) / 1000));
+
+/** Boat runs commands for at most 10 minutes. */
+const MAX_TIMEOUT_SECONDS = 600;
+
+const timeoutSeconds = (timeout: Duration.Input) =>
+  Math.min(
+    MAX_TIMEOUT_SECONDS,
+    Math.max(1, Math.ceil(Duration.toMillis(Duration.fromInputUnsafe(timeout)) / 1000)),
+  );
+
+/**
+ * One shell line for Boat's `commands` endpoint, which takes only a line
+ * and a working directory: `env` becomes exports, an argument vector is
+ * quoted, and `stdin` is piped in from base64.
+ */
+const scriptOf = (
+  command: Command,
+  options?: {
+    readonly env?: Readonly<Record<string, string>>;
+    readonly stdin?: string | Uint8Array;
+  },
+) => {
+  const line = typeof command === "string" ? command : command.map(quote).join(" ");
+  const exports = Object.entries(options?.env ?? {})
+    .map(([key, value]) => `export ${key}=${quote(value)}; `)
+    .join("");
+  const body = exports === "" ? line : `${exports}${line}`;
+  return options?.stdin === undefined
+    ? body
+    : `printf %s ${quote(toBase64(options.stdin))} | base64 -d | { ${body}\n}`;
+};
+
+const entryOf = (entry: {
+  readonly path: string;
+  readonly isDir: boolean;
+  readonly isSymlink: boolean;
+  readonly size: number;
+  readonly mode: string;
+  readonly modifiedAt: string;
+}): EntryInfo => ({
+  path: entry.path,
+  type: entry.isSymlink ? "symlink" : entry.isDir ? "directory" : "file",
+  size: entry.size,
+  mode: entry.mode,
+  modifiedAt: entry.modifiedAt,
+});
+
+const awaitSnapshot = (name: string) =>
+  boat.getSavedSnapshot({ name }).pipe(
+    Effect.map((got) => got.snapshot),
+    Effect.repeat({
+      schedule: Schedule.spaced("2 seconds"),
+      until: (snapshot) => snapshot.status !== "saving",
+      times: 45,
+    }),
+    Effect.flatMap((snapshot) =>
+      snapshot.status === "ready"
+        ? Effect.succeed(snapshot)
+        : new SnapshotFailed({
+            snapshot: name,
+            message:
+              snapshot.status === "failed"
+                ? `Boat could not save snapshot ${name}: ${snapshot.error ?? "unknown error"}`
+                : `Boat snapshot ${name} was still saving after 90 seconds`,
+          }),
+    ),
+  );
+
+/**
+ * The operations every handle shares. `sandboxIdOf` resolves the id (read
+ * at runtime for a declared sandbox).
+ */
+const makeOperations = (
+  auth: BoatAuth,
+  sandboxIdOf: Effect.Effect<string, never, RuntimeContext>,
+): SandboxOperations => {
+  const onSandbox = <A, E>(
+    call: (sandboxId: string) => Effect.Effect<A, E, boat.BoatOpContext>,
+  ): Effect.Effect<A, E, RuntimeContext> =>
+    Effect.flatMap(sandboxIdOf, (sandboxId) => auth.authorize(call(sandboxId)));
+
+  const status = (processId: number, offsets: { stdout: number; stderr: number }) =>
+    onSandbox((sandboxId) =>
+      boat.getCommandStatus({
+        sandboxId,
+        processId,
+        stdoutOffset: offsets.stdout,
+        stderrOffset: offsets.stderr,
+      }),
+    );
+
+  const makeProcess = (processId: number, from: { stdout: number; stderr: number }): Process => {
+    /** Polls the process's logs from `from`, emitting what's new, until it exits. */
+    const output = Stream.paginate(
+      { offsets: from, idle: false },
+      Effect.fnUntraced(function* (state) {
+        if (state.idle) yield* Effect.sleep("500 millis");
+        const current = yield* status(processId, state.offsets);
+        const chunks: ProcessOutput[] = [];
+        if (current.stdout.length > 0) {
+          chunks.push({ fd: "stdout", data: encoder.encode(current.stdout) });
+        }
+        if (current.stderr.length > 0) {
+          chunks.push({ fd: "stderr", data: encoder.encode(current.stderr) });
+        }
+        const offsets = {
+          stdout: current.stdoutNextOffset ?? state.offsets.stdout,
+          stderr: current.stderrNextOffset ?? state.offsets.stderr,
+        };
+        const finished = !current.running && current.more !== true;
+        return [
+          chunks,
+          finished
+            ? Option.none()
+            : Option.some({ offsets, idle: chunks.length === 0 && current.more !== true }),
+        ] as const;
+      }),
+    );
+    const wait = status(processId, { stdout: 0, stderr: 0 }).pipe(
+      Effect.repeat({
+        schedule: Schedule.spaced("1 second"),
+        until: (current) => !current.running,
+      }),
+      Effect.map((current): ExecResult => ({
+        exitCode: current.exitCode ?? -1,
+        stdout: current.stdout,
+        stderr: current.stderr,
+        commandId: undefined,
+      })),
+    );
+    return {
+      id: String(processId),
+      processId,
+      output,
+      kill: () =>
+        onSandbox((sandboxId) => boat.stopCommand({ sandboxId, processId })).pipe(Effect.asVoid),
+      wait,
+    };
+  };
+
+  const files: SandboxOperations["files"] = {
+    read: (path) =>
+      onSandbox((sandboxId) => boat.readSandboxFile({ sandboxId, path, encoding: "base64" })).pipe(
+        Effect.map((file) => fromBase64(file.content)),
+      ),
+    readText: (path) =>
+      onSandbox((sandboxId) => boat.readSandboxFile({ sandboxId, path, encoding: "utf8" })).pipe(
+        Effect.map((file) => file.content),
+      ),
+    write: (path, data) =>
+      onSandbox((sandboxId) =>
+        typeof data === "string"
+          ? boat.writeSandboxFile({ sandboxId, path, content: data, encoding: "utf8" })
+          : boat.writeSandboxFile({ sandboxId, path, content: toBase64(data), encoding: "base64" }),
+      ).pipe(Effect.asVoid),
+    list: (path) =>
+      onSandbox((sandboxId) => boat.listFiles({ sandboxId, path })).pipe(
+        Effect.map((listed) => listed.files.map(entryOf)),
+      ),
+    stat: (path) =>
+      onSandbox((sandboxId) => boat.getFileInfo({ sandboxId, path })).pipe(Effect.map(entryOf)),
+    remove: (path) =>
+      onSandbox((sandboxId) => boat.deleteFile({ sandboxId, path, recursive: true })).pipe(
+        Effect.asVoid,
+      ),
+    makeDir: (path) =>
+      onSandbox((sandboxId) => boat.createFolder({ sandboxId, path })).pipe(Effect.asVoid),
+    exists: (path) =>
+      onSandbox((sandboxId) => boat.getFileInfo({ sandboxId, path })).pipe(
+        Effect.as(true),
+        Effect.catchTag("FileNotFound", () => Effect.succeed(false)),
+      ),
+    move: (source, destination, options) =>
+      onSandbox((sandboxId) =>
+        boat.moveFile({
+          sandboxId,
+          source,
+          destination,
+          ...(options?.overwrite === undefined ? {} : { overwrite: options.overwrite }),
+        }),
+      ).pipe(Effect.asVoid),
+  };
+
+  return {
+    exec: (command: Command, options?: ExecOptions) =>
+      onSandbox((sandboxId) =>
+        boat.executeSandboxCommand({
+          sandboxId,
+          command: scriptOf(command, options),
+          ...(options?.cwd === undefined ? {} : { cwd: options.cwd }),
+          ...(options?.timeout === undefined
+            ? {}
+            : { timeoutSeconds: timeoutSeconds(options.timeout) }),
+        }),
+      ).pipe(
+        Effect.flatMap(
+          (response): Effect.Effect<ExecResult, BoatUnexpectedResponse | ExecTimedOut> => {
+            if (!("exitCode" in response)) {
+              return Effect.fail(
+                new BoatUnexpectedResponse({
+                  message: "Boat started the command in the background",
+                }),
+              );
+            }
+            if (response.timedOut === true) {
+              return Effect.fail(
+                new ExecTimedOut({
+                  message: "The command ran past its timeout and Boat stopped it",
+                  stdout: response.stdout,
+                  stderr: response.stderr,
+                }),
+              );
+            }
+            return Effect.succeed<ExecResult>({
+              exitCode: response.exitCode ?? -1,
+              stdout: response.stdout,
+              stderr: response.stderr,
+              commandId: response.commandId,
+            });
+          },
+        ),
+      ),
+    start: (command: Command, options?: StartOptions) =>
+      onSandbox((sandboxId) =>
+        boat.executeSandboxCommand({
+          sandboxId,
+          command: scriptOf(command, options),
+          detached: true,
+          ...(options?.cwd === undefined ? {} : { cwd: options.cwd }),
+        }),
+      ).pipe(
+        Effect.flatMap((response) =>
+          "processId" in response && typeof response.processId === "number"
+            ? Effect.succeed(makeProcess(response.processId, { stdout: 0, stderr: 0 }))
+            : Effect.fail(
+                new BoatUnexpectedResponse({ message: "Boat returned no process for the command" }),
+              ),
+        ),
+      ),
+    processes: {
+      attach: (processId) =>
+        status(processId, { stdout: 0, stderr: 0 }).pipe(
+          Effect.map((current) =>
+            makeProcess(processId, {
+              stdout: current.stdoutNextOffset ?? 0,
+              stderr: current.stderrNextOffset ?? 0,
+            }),
+          ),
+        ),
+    },
+    files,
+    getTcpPort: (port, options) =>
+      onSandbox((sandboxId) =>
+        boat.hostPort({
+          sandboxId,
+          port,
+          ...(options?.public === undefined ? {} : { public: options.public }),
+          ...(options?.localhost === undefined ? {} : { localhost: options.localhost }),
+        }),
+      ).pipe(
+        Effect.flatMap((hosted) =>
+          hosted.url === undefined
+            ? Effect.fail(
+                new BoatUnexpectedResponse({ message: `Boat hosted port ${port} without a URL` }),
+              )
+            : Effect.sync(() => {
+                const parsed = new URL(hosted.url!);
+                const raw = parsed.searchParams.get("_token");
+                const token = raw === null ? undefined : Redacted.make(raw);
+                const base = parsed.origin;
+                // A protected port reads its token from the `_port_auth`
+                // cookie. The `_token` query answers with a redirect that
+                // sets it, which would turn a POST into a GET, so the cookie
+                // is sent directly. Boat routes on the host, so only the
+                // request's path and query are kept.
+                const send = (request: HttpClientRequest.HttpClientRequest) =>
+                  Effect.gen(function* () {
+                    const client = yield* HttpClient.HttpClient;
+                    const target = new URL(request.url, base);
+                    const cookie = request.headers.cookie;
+                    return yield* client.execute(
+                      request.pipe(
+                        HttpClientRequest.setUrl(`${base}${target.pathname}${target.search}`),
+                        HttpClientRequest.removeHeader("host"),
+                        token === undefined
+                          ? (req) => req
+                          : HttpClientRequest.setHeader(
+                              "cookie",
+                              [cookie, `_port_auth=${Redacted.value(token)}`]
+                                .filter((part) => part !== undefined && part !== "")
+                                .join("; "),
+                            ),
+                      ),
+                    );
+                  }).pipe(Effect.provide(FetchHttpClient.layer));
+                return { url: base, token, fetch: Sandbox.portFetch(send) } satisfies Port;
+              }),
+        ),
+      ),
+    describe: () =>
+      onSandbox((sandboxId) => boat.getSandbox({ sandboxId })).pipe(
+        Effect.flatMap((got) =>
+          got.sandbox === undefined
+            ? Effect.fail(new BoatUnexpectedResponse({ message: "Boat returned no sandbox" }))
+            : Effect.succeed(got.sandbox),
+        ),
+      ),
+    stop: () =>
+      onSandbox((sandboxId) => boat.stopSandbox({ sandboxId })).pipe(
+        Effect.asVoid,
+        Effect.catchTag("SandboxAlreadyStopped", () => Effect.void),
+      ),
+    resume: (options) =>
+      onSandbox((sandboxId) =>
+        boat.resumeSandbox({
+          sandboxId,
+          ...(options?.autoStop === undefined ? {} : { ttlSeconds: ttlOf(options.autoStop) }),
+        }),
+      ).pipe(Effect.asVoid),
+    setAutoStop: (autoStop) =>
+      onSandbox((sandboxId) => boat.updateSandbox({ sandboxId, ttlSeconds: ttlOf(autoStop) })).pipe(
+        Effect.asVoid,
+      ),
+    snapshot: (name) =>
+      onSandbox((sandboxId) =>
+        boat.saveSavedSnapshot({ sandboxId, name }).pipe(Effect.andThen(awaitSnapshot(name))),
+      ),
+  };
+};
+
+/** A handle to a sandbox created or connected at runtime, from what Boat returned. */
+export const makeSandboxHandle = (
+  auth: BoatAuth,
+  info: boat.Sandbox,
+  ownerLabels: Effect.Effect<Readonly<Record<string, string>>, never, RuntimeContext>,
+): BoatSandbox => ({
+  ...makeOperations(auth, Effect.succeed(info.id)),
+  sandboxId: info.id,
+  info,
+  // Boat never copies labels onto a fork, so it gets the owner's again.
+  fork: (forkOptions = {}) => {
+    const { autoStop, ...options } = forkOptions;
+    return Effect.flatMap(ownerLabels, (owner) =>
+      auth.authorize(
+        boat.forkSandbox({
+          ...options,
+          ...(autoStop === undefined ? {} : { ttlSeconds: ttlOf(autoStop) }),
+          sandboxId: info.id,
+          labels: { ...options.labels, ...owner },
+        }),
+      ),
+    ).pipe(
+      Effect.flatMap((forked) =>
+        forked.sandbox === undefined || forked.sandbox === null
+          ? Effect.fail(new BoatUnexpectedResponse({ message: "Boat returned no fork" }))
+          : Effect.succeed(makeSandboxHandle(auth, forked.sandbox, ownerLabels)),
+      ),
+    );
+  },
+  delete: () =>
+    auth.authorize(boat.deleteSandbox({ sandboxId: info.id, xAsciiConfirmDelete: info.id })).pipe(
+      Effect.asVoid,
+      Effect.catchTag("NotFound", () => Effect.void),
+    ),
+});
+
+/** A handle to a sandbox declared in the stack. */
+export const makeConnectedSandbox = (
+  auth: BoatAuth,
+  sandboxIdOf: Effect.Effect<string, never, RuntimeContext>,
+): ConnectedSandbox => ({
+  ...makeOperations(auth, sandboxIdOf),
+  sandboxId: sandboxIdOf,
+});

package/src/internal/WebhookDelivery.ts

@@ -0,0 +1,179 @@
+/**
+ * INTERNAL — handles one delivery of Boat's webhook on a host: checks the
+ * signature, the timestamp and the payload, then scopes and dispatches it.
+ */
+import * as boat from "@distilled.cloud/boat-dev/boat";
+import { isRedactedMarker, type RuntimeContext } from "alchemy/RuntimeContext";
+import * as Clock from "effect/Clock";
+import * as Effect from "effect/Effect";
+import * as Redacted from "effect/Redacted";
+import type { BoatAuth } from "../BoatBindings.ts";
+import type { SandboxEvent } from "../SandboxEvents.ts";
+import { ALCHEMY_LABEL_PREFIX } from "./Ownership.ts";
+
+/** How old a delivery's timestamp may be before it is refused. */
+export const MAX_AGE_SECONDS = 300;
+
+/** The largest delivery accepted. */
+export const MAX_BODY_BYTES = 1024 * 1024;
+
+export interface Scope {
+  readonly auth: BoatAuth;
+  readonly owner: Effect.Effect<Readonly<Record<string, string>>>;
+}
+
+export const handleDelivery = <Req>(
+  request: Request,
+  secret: Effect.Effect<string | undefined>,
+  types: ReadonlySet<string>,
+  scope: Scope | undefined,
+  process: (event: SandboxEvent) => Effect.Effect<void, never, Req>,
+): Effect.Effect<Response, never, Req | RuntimeContext> =>
+  Effect.gen(function* () {
+    if (request.method !== "POST") return new Response("method not allowed", { status: 405 });
+    // Boat's events are a few hundred bytes; refuse anything large before reading it.
+    if (Number(request.headers.get("content-length") ?? "0") > MAX_BODY_BYTES) {
+      return new Response("payload too large", { status: 413 });
+    }
+    const body = yield* Effect.tryPromise(() => request.arrayBuffer()).pipe(Effect.option);
+    if (body._tag === "None") return new Response("unreadable body", { status: 400 });
+    if (body.value.byteLength > MAX_BODY_BYTES) {
+      return new Response("payload too large", { status: 413 });
+    }
+
+    // The signature covers the delivery id, the timestamp and the raw body
+    // bytes; a stale timestamp is refused, so a captured delivery can't be
+    // replayed later.
+    const delivery = request.headers.get("x-ascii-delivery") ?? "";
+    const timestamp = request.headers.get("x-ascii-timestamp") ?? "";
+    const signature = (request.headers.get("x-ascii-signature") ?? "").replace(/^v1=/, "");
+    const now = yield* Clock.currentTimeMillis;
+    const fresh =
+      /^\d{1,12}$/.test(timestamp) &&
+      Math.abs(Number(now) / 1000 - Number(timestamp)) <= MAX_AGE_SECONDS;
+    const valid =
+      delivery !== "" &&
+      fresh &&
+      (yield* verifySignature(
+        (yield* secret) ?? "",
+        `${delivery}.${timestamp}.`,
+        body.value,
+        signature,
+      ));
+    if (!valid) return new Response("invalid signature", { status: 401 });
+
+    const parsed = yield* Effect.try(
+      () => JSON.parse(new TextDecoder().decode(body.value)) as Omit<SandboxEvent, "attempt">,
+    ).pipe(Effect.orElseSucceed(() => undefined));
+    if (
+      parsed === undefined ||
+      parsed.id !== delivery ||
+      typeof parsed.type !== "string" ||
+      typeof parsed.data?.sandbox?.id !== "string"
+    ) {
+      return new Response("invalid payload", { status: 400 });
+    }
+    // An event this host didn't subscribe to: acknowledged, not handled.
+    if (!types.has(parsed.type)) return new Response(null, { status: 202 });
+    let event: SandboxEvent = {
+      ...parsed,
+      attempt: Number(request.headers.get("x-ascii-attempt") ?? "1") || 1,
+    };
+
+    if (scope !== undefined) {
+      const lookup = yield* labelsOf(scope.auth, parsed.data.sandbox.id);
+      // Boat couldn't be asked: answer 503 so it delivers again, rather than
+      // drop an event that may be ours.
+      if (lookup._tag === "Unavailable") return new Response("try again", { status: 503 });
+      const labels = lookup._tag === "Found" ? lookup.labels : undefined;
+      const owner = yield* scope.owner;
+      const ours =
+        labels !== undefined &&
+        ["stack", "stage"].every(
+          (key) =>
+            owner[`${ALCHEMY_LABEL_PREFIX}${key}`] !== undefined &&
+            labels[`${ALCHEMY_LABEL_PREFIX}${key}`] === owner[`${ALCHEMY_LABEL_PREFIX}${key}`],
+        );
+      // Another stack's sandbox, or one already deleted: acknowledged, not handled.
+      if (!ours) return new Response(null, { status: 202 });
+      event = { ...event, data: { ...event.data, sandbox: { ...event.data.sandbox, labels } } };
+    }
+
+    yield* process(event);
+    return new Response(null, { status: 202 });
+  });
+
+/** The bound secret as a string: a `Redacted`, its serialized form, or a plain string. */
+export const asSecret = (raw: unknown): string | undefined => {
+  if (raw === undefined || raw === null || raw === "") return undefined;
+  if (Redacted.isRedacted(raw)) {
+    const value = Redacted.value(raw);
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+  }
+  if (isRedactedMarker(raw) && typeof raw.value === "string") {
+    return raw.value.length > 0 ? raw.value : undefined;
+  }
+  return typeof raw === "string" ? raw : undefined;
+};
+
+type LabelLookup =
+  | { readonly _tag: "Found"; readonly labels: Record<string, string> }
+  | { readonly _tag: "Gone" }
+  | { readonly _tag: "Unavailable" };
+
+/** A sandbox's labels; `Gone` when Boat no longer has it, `Unavailable` when Boat couldn't be asked. */
+const labelsOf = (
+  auth: BoatAuth,
+  sandboxId: string,
+): Effect.Effect<LabelLookup, never, RuntimeContext> =>
+  auth.authorize(boat.getSandbox({ sandboxId })).pipe(
+    Effect.map((got): LabelLookup => ({
+      _tag: "Found",
+      labels: Object.fromEntries(
+        Object.entries(got.sandbox?.labels ?? {}).filter(
+          (entry): entry is [string, string] => typeof entry[1] === "string",
+        ),
+      ),
+    })),
+    Effect.catchTag("NotFound", () => Effect.succeed<LabelLookup>({ _tag: "Gone" })),
+    Effect.orElseSucceed((): LabelLookup => ({ _tag: "Unavailable" })),
+  );
+
+const fromHex = (hex: string) =>
+  Uint8Array.from(hex.match(/../g) ?? [], (byte) => Number.parseInt(byte, 16));
+
+/**
+ * Boat's signature: hex HMAC-SHA256 of `<delivery>.<timestamp>.` followed
+ * by the raw body bytes. Web Crypto checks it (in constant time), so it runs
+ * on Workers without `nodejs_compat`.
+ */
+const verifySignature = (
+  secret: string,
+  prefix: string,
+  body: ArrayBuffer,
+  signature: string,
+): Effect.Effect<boolean> =>
+  Effect.gen(function* () {
+    if (secret === "" || !/^[a-f0-9]{64}$/i.test(signature)) return false;
+    const head = new TextEncoder().encode(prefix);
+    const signed = new Uint8Array(head.byteLength + body.byteLength);
+    signed.set(head, 0);
+    signed.set(new Uint8Array(body), head.byteLength);
+    const valid = yield* Effect.tryPromise(() =>
+      crypto.subtle.importKey(
+        "raw",
+        new TextEncoder().encode(secret),
+        { name: "HMAC", hash: "SHA-256" },
+        false,
+        ["verify"],
+      ),
+    ).pipe(
+      Effect.flatMap((key) =>
+        Effect.tryPromise(() =>
+          crypto.subtle.verify("HMAC", key, fromHex(signature.toLowerCase()), signed),
+        ),
+      ),
+      Effect.orElseSucceed(() => false),
+    );
+    return valid;
+  });