@boxd-sh/convex 0.1.0

package/src/component/_generated/dataModel.ts

@@ -0,0 +1,60 @@
+/* eslint-disable */
+/**
+ * Generated data model types.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import type {
+  DataModelFromSchemaDefinition,
+  DocumentByName,
+  TableNamesInDataModel,
+  SystemTableNames,
+} from "convex/server";
+import type { GenericId } from "convex/values";
+import schema from "../schema.js";
+
+/**
+ * The names of all of your Convex tables.
+ */
+export type TableNames = TableNamesInDataModel<DataModel>;
+
+/**
+ * The type of a document stored in Convex.
+ *
+ * @typeParam TableName - A string literal type of the table name (like "users").
+ */
+export type Doc<TableName extends TableNames> = DocumentByName<
+  DataModel,
+  TableName
+>;
+
+/**
+ * An identifier for a document in Convex.
+ *
+ * Convex documents are uniquely identified by their `Id`, which is accessible
+ * on the `_id` field. To learn more, see [Document IDs](https://docs.convex.dev/using/document-ids).
+ *
+ * Documents can be loaded using `db.get(tableName, id)` in query and mutation functions.
+ *
+ * IDs are just strings at runtime, but this type can be used to distinguish them from other
+ * strings when type checking.
+ *
+ * @typeParam TableName - A string literal type of the table name (like "users").
+ */
+export type Id<TableName extends TableNames | SystemTableNames> =
+  GenericId<TableName>;
+
+/**
+ * A type describing your Convex data model.
+ *
+ * This type includes information about what tables you have, the type of
+ * documents stored in those tables, and the indexes defined on them.
+ *
+ * This type is used to parameterize methods like `queryGeneric` and
+ * `mutationGeneric` to make them type-safe.
+ */
+export type DataModel = DataModelFromSchemaDefinition<typeof schema>;

package/src/component/_generated/server.ts

@@ -0,0 +1,171 @@
+/* eslint-disable */
+/**
+ * Generated utilities for implementing server-side Convex query and mutation functions.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+import type {
+  ActionBuilder,
+  HttpActionBuilder,
+  MutationBuilder,
+  QueryBuilder,
+  GenericActionCtx,
+  GenericMutationCtx,
+  GenericQueryCtx,
+  GenericDatabaseReader,
+  GenericDatabaseWriter,
+} from "convex/server";
+import {
+  actionGeneric,
+  httpActionGeneric,
+  queryGeneric,
+  mutationGeneric,
+  internalActionGeneric,
+  internalMutationGeneric,
+  internalQueryGeneric,
+} from "convex/server";
+import type { DataModel } from "./dataModel.js";
+
+/**
+ * Typesafe environment variables.
+ *
+ * This includes platform-provided env vars and any variables declared in
+ * `convex.config.ts`.
+ */
+type Env = {
+  readonly CONVEX_CLOUD_URL: string;
+  readonly CONVEX_SITE_URL: string;
+  readonly BOXD_API_KEY: string;
+  readonly BOXD_BASE_URL: string | undefined;
+};
+
+/**
+ * Define a query in this Convex app's public API.
+ *
+ * This function will be allowed to read your Convex database and will be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export const query: QueryBuilder<DataModel, "public"> = queryGeneric;
+
+/**
+ * Define a query that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to read from your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export const internalQuery: QueryBuilder<DataModel, "internal"> =
+  internalQueryGeneric;
+
+/**
+ * Define a mutation in this Convex app's public API.
+ *
+ * This function will be allowed to modify your Convex database and will be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export const mutation: MutationBuilder<DataModel, "public"> = mutationGeneric;
+
+/**
+ * Define a mutation that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to modify your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export const internalMutation: MutationBuilder<DataModel, "internal"> =
+  internalMutationGeneric;
+
+/**
+ * Define an action in this Convex app's public API.
+ *
+ * An action is a function which can execute any JavaScript code, including non-deterministic
+ * code and code with side-effects, like calling third-party services.
+ * They can be run in Convex's JavaScript environment or in Node.js using the "use node" directive.
+ * They can interact with the database indirectly by calling queries and mutations using the {@link ActionCtx}.
+ *
+ * @param func - The action. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped action. Include this as an `export` to name it and make it accessible.
+ */
+export const action: ActionBuilder<DataModel, "public"> = actionGeneric;
+
+/**
+ * Define an action that is only accessible from other Convex functions (but not from the client).
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped function. Include this as an `export` to name it and make it accessible.
+ */
+export const internalAction: ActionBuilder<DataModel, "internal"> =
+  internalActionGeneric;
+
+/**
+ * Define an HTTP action.
+ *
+ * The wrapped function will be used to respond to HTTP requests received
+ * by a Convex deployment if the requests matches the path and method where
+ * this action is routed. Be sure to route your httpAction in `convex/http.js`.
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument
+ * and a Fetch API `Request` object as its second.
+ * @returns The wrapped function. Import this function from `convex/http.js` and route it to hook it up.
+ */
+export const httpAction: HttpActionBuilder = httpActionGeneric;
+export const env: Env = (globalThis as unknown as { process: { env: Env } })
+  .process.env;
+
+/**
+ * A set of services for use within Convex query functions.
+ *
+ * The query context is passed as the first argument to any Convex query
+ * function run on the server.
+ *
+ * If you're using code generation, use the `QueryCtx` type in `convex/_generated/server.d.ts` instead.
+ */
+export type QueryCtx = GenericQueryCtx<DataModel>;
+
+/**
+ * A set of services for use within Convex mutation functions.
+ *
+ * The mutation context is passed as the first argument to any Convex mutation
+ * function run on the server.
+ *
+ * If you're using code generation, use the `MutationCtx` type in `convex/_generated/server.d.ts` instead.
+ */
+export type MutationCtx = GenericMutationCtx<DataModel>;
+
+/**
+ * A set of services for use within Convex action functions.
+ *
+ * The action context is passed as the first argument to any Convex action
+ * function run on the server.
+ */
+export type ActionCtx = GenericActionCtx<DataModel>;
+
+/**
+ * An interface to read from the database within Convex query functions.
+ *
+ * The two entry points are {@link DatabaseReader.get}, which fetches a single
+ * document by its {@link Id}, or {@link DatabaseReader.query}, which starts
+ * building a query.
+ */
+export type DatabaseReader = GenericDatabaseReader<DataModel>;
+
+/**
+ * An interface to read from and write to the database within Convex mutation
+ * functions.
+ *
+ * Convex guarantees that all writes within a single mutation are
+ * executed atomically, so you never have to worry about partial writes leaving
+ * your data in an inconsistent state. See [the Convex Guide](https://docs.convex.dev/understanding/convex-fundamentals/functions#atomicity-and-optimistic-concurrency-control)
+ * for the guarantees Convex provides your functions.
+ */
+export type DatabaseWriter = GenericDatabaseWriter<DataModel>;

package/src/component/boxd.ts

@@ -0,0 +1,188 @@
+/**
+ * Connects component actions to boxd.
+ *
+ * The component runs in Convex's default JavaScript runtime, so it uses the
+ * SDK's `@boxd-sh/sdk/web` entry: grpc-web over `fetch`, no Node built-ins.
+ *
+ * The API key comes from the component's own env (`BOXD_API_KEY`, bound by
+ * the app in `app.use`), so it never travels as a function argument. The SDK
+ * could exchange the key for a session token itself, but it would do so once
+ * per action: an SDK client lives only as long as the action. boxd
+ * rate-limits the exchange per source IP, and Convex deployments share their
+ * egress IPs. So the component exchanges the key once, caches the token in
+ * its `sessions` table, and hands the SDK the token.
+ */
+
+import { Boxd } from "@boxd-sh/sdk/web";
+import { internal } from "./_generated/api.js";
+import { env, type ActionCtx } from "./_generated/server.js";
+import { boxdError, toConvexError } from "./errors.js";
+
+/** boxd production. `BOXD_BASE_URL` points the component anywhere else. */
+export const DEFAULT_BASE_URL = "https://boxd.sh:9443";
+
+const EXCHANGE_PATH = "/api/v1/auth/token";
+
+/** Exchange again this long before the cached token expires. */
+const REFRESH_SKEW_MS = 5 * 60_000;
+
+type Session = { token: string; expiresAt: number };
+
+/**
+ * The console origin that serves the key exchange: `https://app.<zone>` for a
+ * cluster zone, or the endpoint's own origin for a local, IP or `app.` host.
+ * Mirrors `consoleBaseUrl` in `@boxd-sh/sdk`, which the SDK doesn't export.
+ */
+export function exchangeUrl(baseURL: string): string {
+  const trimmed = baseURL.trim().replace(/\/+$/, "");
+  const scheme = /^https?:\/\//.exec(trimmed)?.[0];
+  const local = /^(localhost|127\.)/.test(trimmed.slice(scheme?.length ?? 0));
+  // No scheme: pick the one the SDK would dial, plain HTTP for a local host.
+  const url = new URL(
+    scheme ? trimmed : `${local ? "http" : "https"}://${trimmed}`,
+  );
+  const host = url.hostname;
+  const sameOrigin =
+    host === "localhost" ||
+    host.startsWith("[") ||
+    /^\d{1,3}(\.\d{1,3}){3}$/.test(host) ||
+    host.startsWith("app.");
+  const origin = sameOrigin ? url.origin : `https://app.${host}`;
+  return `${origin}${EXCHANGE_PATH}`;
+}
+
+async function sha256Hex(text: string): Promise<string> {
+  const digest = await crypto.subtle.digest(
+    "SHA-256",
+    new TextEncoder().encode(text),
+  );
+  return Array.from(new Uint8Array(digest), (b) =>
+    b.toString(16).padStart(2, "0"),
+  ).join("");
+}
+
+async function exchange(apiKey: string, baseURL: string): Promise<Session> {
+  const url = exchangeUrl(baseURL);
+  let response: Response;
+  try {
+    response = await fetch(url, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ api_key: apiKey }),
+    });
+  } catch (error) {
+    throw boxdError(
+      "UNAVAILABLE",
+      `could not reach ${url} to exchange BOXD_API_KEY: ${String(error)}`,
+    );
+  }
+  if (response.status === 401) {
+    throw boxdError(
+      "UNAUTHENTICATED",
+      "boxd rejected BOXD_API_KEY: it is invalid, expired or revoked. " +
+        "Create a new key with `boxd auth keys create <name>` and set it with " +
+        "`npx convex env set BOXD_API_KEY <key>`.",
+    );
+  }
+  if (response.status === 429) {
+    throw boxdError(
+      "RATE_LIMITED",
+      "boxd rate-limited the API key exchange. Retry after a minute.",
+    );
+  }
+  if (!response.ok) {
+    const detail = await response.text().catch(() => "");
+    throw boxdError(
+      response.status >= 500 ? "UNAVAILABLE" : "BOXD_ERROR",
+      `boxd API key exchange failed with ${response.status}: ${detail.slice(0, 500)}`,
+    );
+  }
+  const body = (await response.json()) as {
+    token?: unknown;
+    expires_at?: unknown;
+  };
+  if (typeof body.token !== "string" || typeof body.expires_at !== "number") {
+    throw boxdError(
+      "BOXD_ERROR",
+      "boxd API key exchange returned a malformed response",
+    );
+  }
+  return { token: body.token, expiresAt: body.expires_at * 1000 };
+}
+
+function config(): { apiKey: string; baseURL: string } {
+  // Read inside the handler: component env only exists at runtime.
+  const apiKey = env.BOXD_API_KEY?.trim();
+  if (!apiKey) {
+    throw boxdError(
+      "UNAUTHENTICATED",
+      "BOXD_API_KEY is empty. Set it with `npx convex env set BOXD_API_KEY <key>` " +
+        "and bind it in convex.config.ts: " +
+        "`app.use(boxd, { env: { BOXD_API_KEY: app.env.BOXD_API_KEY } })`.",
+    );
+  }
+  const baseURL = env.BOXD_BASE_URL?.trim() || DEFAULT_BASE_URL;
+  return { apiKey, baseURL };
+}
+
+async function session(
+  ctx: ActionCtx,
+  keyHash: string,
+  apiKey: string,
+  baseURL: string,
+): Promise<{ session: Session; cached: boolean }> {
+  const cached = await ctx.runQuery(internal.sessions.get, { keyHash });
+  if (cached && cached.expiresAt - REFRESH_SKEW_MS > Date.now()) {
+    return { session: cached, cached: true };
+  }
+  let fresh: Session;
+  try {
+    fresh = await exchange(apiKey, baseURL);
+  } catch (error) {
+    // Many actions can reach the refresh margin at once, and boxd
+    // rate-limits the exchange. A token that has not expired yet still
+    // works, so fall back to it rather than fail the call.
+    if (cached && cached.expiresAt > Date.now()) {
+      return { session: cached, cached: true };
+    }
+    throw error;
+  }
+  await ctx.runMutation(internal.sessions.put, { keyHash, ...fresh });
+  return { session: fresh, cached: false };
+}
+
+/**
+ * Run `operation` with an authenticated SDK client, and turn whatever it
+ * throws into a coded `ConvexError`.
+ *
+ * A cached token can be revoked before it expires. If boxd rejects a cached
+ * token, the token is dropped, the key is exchanged again, and `operation`
+ * runs once more. That retry is safe for every operation, including create:
+ * boxd refuses an unauthenticated request before it does anything.
+ */
+export async function withBoxd<T>(
+  ctx: ActionCtx,
+  operation: (boxd: Boxd) => Promise<T>,
+): Promise<T> {
+  const { apiKey, baseURL } = config();
+  const keyHash = await sha256Hex(`${baseURL}\n${apiKey}`);
+  const first = await session(ctx, keyHash, apiKey, baseURL);
+  try {
+    return await operation(new Boxd({ token: first.session.token, baseURL }));
+  } catch (error) {
+    const converted = toConvexError(error);
+    if (!first.cached || converted.data.code !== "UNAUTHENTICATED") {
+      throw converted;
+    }
+    await ctx.runMutation(internal.sessions.drop, {
+      keyHash,
+      token: first.session.token,
+    });
+  }
+  const retry = await session(ctx, keyHash, apiKey, baseURL);
+  try {
+    return await operation(new Boxd({ token: retry.session.token, baseURL }));
+  } catch (error) {
+    throw toConvexError(error);
+  }
+}

package/src/component/convex.config.ts

@@ -0,0 +1,9 @@
+import { defineComponent } from "convex/server";
+import { v } from "convex/values";
+
+export default defineComponent("boxd", {
+  env: {
+    BOXD_API_KEY: v.string(),
+    BOXD_BASE_URL: v.optional(v.string()),
+  },
+});

package/src/component/errors.ts

@@ -0,0 +1,105 @@
+import { ConvexError, v, type Infer } from "convex/values";
+import { MAX_STORED_ERROR, truncate } from "./limits.js";
+
+export const errorCode = v.union(
+  v.literal("INVALID_ARGUMENT"),
+  v.literal("UNAUTHENTICATED"),
+  v.literal("PERMISSION_DENIED"),
+  v.literal("NOT_FOUND"),
+  v.literal("CONFLICT"),
+  v.literal("RATE_LIMITED"),
+  v.literal("TIMEOUT"),
+  v.literal("UNAVAILABLE"),
+  v.literal("BOXD_ERROR"),
+);
+
+/** The `data` of every `ConvexError` this component throws. */
+export type BoxdErrorData = {
+  code: Infer<typeof errorCode>;
+  message: string;
+  /**
+   * Set when `create` or `fork` made a machine but it failed to become ready:
+   * the machine exists, and bills, until you destroy it.
+   */
+  machineId?: string;
+};
+
+// gRPC status codes, as carried on `BoxdError.grpcCode`.
+const GRPC_CODES: Record<number, BoxdErrorData["code"]> = {
+  3: "INVALID_ARGUMENT",
+  4: "TIMEOUT",
+  5: "NOT_FOUND",
+  6: "CONFLICT",
+  7: "PERMISSION_DENIED",
+  8: "RATE_LIMITED",
+  9: "CONFLICT",
+  14: "UNAVAILABLE",
+  16: "UNAUTHENTICATED",
+};
+
+// The SDK's own error classes, for errors raised before anything reached the
+// wire (a missing credential, a failed key exchange, a dropped connection).
+// Matched by name and `grpcCode` rather than `instanceof`, so the modules
+// that only store and read rows never load the SDK.
+const SDK_CLASSES: Record<string, BoxdErrorData["code"]> = {
+  AuthenticationError: "UNAUTHENTICATED",
+  PermissionDeniedError: "PERMISSION_DENIED",
+  NotFoundError: "NOT_FOUND",
+  ConflictError: "CONFLICT",
+  RateLimitError: "RATE_LIMITED",
+  APIConnectionError: "UNAVAILABLE",
+};
+
+// The SDK's client-side deadlines: "exec timed out after 5000ms", and
+// "machine x did not reach 'running' within 90000ms".
+const TIMEOUT_MESSAGE = /timed out|within \d+ms/i;
+
+export function boxdError(
+  code: BoxdErrorData["code"],
+  message: string,
+): ConvexError<BoxdErrorData> {
+  return new ConvexError({ code, message });
+}
+
+export function invalidArgument(message: string): ConvexError<BoxdErrorData> {
+  return boxdError("INVALID_ARGUMENT", message);
+}
+
+/** A human-readable message for any thrown value, bounded for storage. */
+export function errorMessage(error: unknown): string {
+  let message: string;
+  if (error instanceof ConvexError) {
+    const data = error.data as Partial<BoxdErrorData> | string;
+    message =
+      typeof data === "string" ? data : (data.message ?? String(error.data));
+  } else if (error instanceof Error) {
+    message = error.message;
+  } else {
+    message = String(error);
+  }
+  return truncate(message, MAX_STORED_ERROR);
+}
+
+/**
+ * Map anything thrown while talking to boxd onto a `ConvexError` with a
+ * stable `code`, so the app can branch on `error.data.code` instead of
+ * parsing messages. A `ConvexError` passes through unchanged.
+ */
+export function toConvexError(error: unknown): ConvexError<BoxdErrorData> {
+  if (error instanceof ConvexError) return error as ConvexError<BoxdErrorData>;
+  const message = errorMessage(error);
+  if (error instanceof Error) {
+    const { grpcCode } = error as { grpcCode?: unknown };
+    const code =
+      (typeof grpcCode === "number" ? GRPC_CODES[grpcCode] : undefined) ??
+      SDK_CLASSES[error.name] ??
+      (TIMEOUT_MESSAGE.test(message) ? "TIMEOUT" : "BOXD_ERROR");
+    return boxdError(code, message);
+  }
+  return boxdError("BOXD_ERROR", message);
+}
+
+/** True when `error` says the target no longer exists on boxd. */
+export function isNotFound(error: unknown): boolean {
+  return toConvexError(error).data.code === "NOT_FOUND";
+}

package/src/component/exec.ts

@@ -0,0 +1,134 @@
+/**
+ * Run a command in a machine. Each run is recorded in `executions`
+ * (running → completed or failed), so the app can render live status and
+ * history from a reactive query.
+ *
+ * The call returns when the command exits. For work that can outlast the 10
+ * minute action ceiling, start it in the background inside the machine
+ * (`nohup ... &`) and poll it with later runs.
+ */
+
+import { v } from "convex/values";
+import { internal } from "./_generated/api.js";
+import type { Id } from "./_generated/dataModel.js";
+import { action } from "./_generated/server.js";
+import { withBoxd } from "./boxd.js";
+import { errorMessage, isNotFound } from "./errors.js";
+import {
+  DEFAULT_EXEC_TIMEOUT_MS,
+  MAX_EXEC_TIMEOUT_MS,
+  MAX_RETURNED_OUTPUT,
+  MAX_STORED_COMMAND,
+  MAX_STORED_OUTPUT,
+  truncate,
+} from "./limits.js";
+import { requireMachine } from "./records.js";
+import {
+  boundedTimeout,
+  requireAbsolutePath,
+  requireNonEmpty,
+} from "./validate.js";
+
+const SAFE_ARG = /^[A-Za-z0-9_\-./=:@%+,]+$/;
+
+/** How the command reads in a shell, for the execution row. */
+function displayCommand(command: string | string[]): string {
+  if (typeof command === "string") return command;
+  return command
+    .map((arg) =>
+      SAFE_ARG.test(arg) ? arg : `'${arg.replace(/'/g, `'"'"'`)}'`,
+    )
+    .join(" ");
+}
+
+export const run = action({
+  args: {
+    machineId: v.string(),
+    ownerId: v.optional(v.string()),
+    /** A shell command line, or an argv array that is quoted for you. */
+    command: v.union(v.string(), v.array(v.string())),
+    /** Absolute working directory. A missing one fails the command. */
+    cwd: v.optional(v.string()),
+    /** Extra environment for this command only. Not stored. */
+    env: v.optional(v.record(v.string(), v.string())),
+    /** Kill the command after this many ms. Default 540s, capped at 570s. */
+    timeoutMs: v.optional(v.number()),
+  },
+  returns: v.object({
+    executionId: v.id("executions"),
+    exitCode: v.number(),
+    success: v.boolean(),
+    stdout: v.string(),
+    stderr: v.string(),
+  }),
+  handler: async (
+    ctx,
+    args,
+  ): Promise<{
+    executionId: Id<"executions">;
+    exitCode: number;
+    success: boolean;
+    stdout: string;
+    stderr: string;
+  }> => {
+    // Validate before anything is recorded or sent.
+    const timeout = boundedTimeout(
+      args.timeoutMs,
+      DEFAULT_EXEC_TIMEOUT_MS,
+      MAX_EXEC_TIMEOUT_MS,
+      "timeoutMs",
+    );
+    if (args.cwd !== undefined) requireAbsolutePath(args.cwd);
+    const line = displayCommand(args.command);
+    requireNonEmpty(line, "command");
+    const machine = await requireMachine(ctx, args.machineId, args.ownerId);
+
+    const executionId: Id<"executions"> = await ctx.runMutation(
+      internal.executions.begin,
+      {
+        machineId: machine.machineId,
+        ownerId: machine.ownerId,
+        command: truncate(line, MAX_STORED_COMMAND),
+        cwd: args.cwd,
+        timeoutMs: timeout,
+      },
+    );
+    try {
+      const result = await withBoxd(ctx, (boxd) =>
+        boxd.machines.exec(machine.machineId, {
+          command: args.command,
+          cwd: args.cwd,
+          env: args.env,
+          timeout,
+        }),
+      );
+      await ctx.runMutation(internal.executions.finish, {
+        executionId,
+        status: "completed",
+        exitCode: result.exitCode,
+        stdout: truncate(result.stdout, MAX_STORED_OUTPUT),
+        stderr: truncate(result.stderr, MAX_STORED_OUTPUT),
+      });
+      return {
+        executionId,
+        exitCode: result.exitCode,
+        success: result.success,
+        stdout: truncate(result.stdout, MAX_RETURNED_OUTPUT),
+        stderr: truncate(result.stderr, MAX_RETURNED_OUTPUT),
+      };
+    } catch (error) {
+      await ctx.runMutation(internal.executions.finish, {
+        executionId,
+        status: "failed",
+        error: errorMessage(error),
+      });
+      if (isNotFound(error)) {
+        // boxd no longer has the machine, e.g. after its auto-destroy timer.
+        await ctx.runMutation(internal.machines.markDestroyed, {
+          machineId: machine.machineId,
+        });
+      }
+      throw error;
+    }
+  },
+});