@boxd-sh/convex 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Azin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,264 @@
+![boxd: composable computers on Convex](https://raw.githubusercontent.com/azin-tech/boxd-convex/main/assets/banner.png)
+
+# boxd for Convex
+
+Run [boxd](https://boxd.sh) machines from your Convex backend. Each machine is a
+full Linux microVM with its own disk, memory and HTTPS URL. It cold-boots in
+under 10 ms, forks like a git branch in under 200 ms, and sleeps and wakes with
+its memory intact.
+
+The component keeps a reactive row for every machine and every command it runs,
+so your UI subscribes to machine state and command output with a plain Convex
+query.
+
+- Create, fork, pause, resume, hibernate, wake, stop, start and destroy
+  machines.
+- Run commands and read and write files.
+- Put a port on the public internet: `https://<machine>.boxd.sh`.
+- Scope every machine to a user or tenant of your app.
+- Get stable error codes to branch on (`NOT_FOUND`, `CONFLICT`, ...).
+
+## Install
+
+```sh
+npm install @boxd-sh/convex
+```
+
+Create an API key with the [boxd CLI](https://docs.boxd.sh) and set it on your
+deployment:
+
+```sh
+boxd auth keys create convex
+npx convex env set BOXD_API_KEY bxd_...
+```
+
+A key is fenced to one boxd org. Machines are created in, and billed to, that
+org.
+
+Install the component in `convex/convex.config.ts`, and bind the key into it:
+
+```ts
+import { defineApp } from "convex/server";
+import { v } from "convex/values";
+import boxd from "@boxd-sh/convex/convex.config.js";
+
+const app = defineApp({
+  env: { BOXD_API_KEY: v.string() },
+});
+
+app.use(boxd, { env: { BOXD_API_KEY: app.env.BOXD_API_KEY } });
+
+export default app;
+```
+
+The key goes into the component's own environment, so it never travels as a
+function argument.
+
+## Use it
+
+```ts
+// convex/machines.ts
+import { Boxd } from "@boxd-sh/convex";
+import { v } from "convex/values";
+import { components } from "./_generated/api";
+import {
+  action,
+  query,
+  type ActionCtx,
+  type QueryCtx,
+} from "./_generated/server";
+
+const boxd = new Boxd(components.boxd);
+
+// The component can't see your users, so derive the owner from your auth.
+// Never take it from a client argument.
+async function ownerId(ctx: QueryCtx | ActionCtx) {
+  const identity = await ctx.auth.getUserIdentity();
+  if (!identity) throw new Error("Unauthenticated");
+  return identity.subject;
+}
+
+export const createMachine = action({
+  args: {},
+  handler: async (ctx) => {
+    return await boxd.create(ctx, {
+      ownerId: await ownerId(ctx),
+      vcpu: 1,
+      autoSuspendSeconds: 300,
+    });
+  },
+});
+
+export const run = action({
+  args: { machineId: v.string(), command: v.string() },
+  handler: async (ctx, { machineId, command }) => {
+    return await boxd.exec(ctx, {
+      ownerId: await ownerId(ctx),
+      machineId,
+      command,
+    });
+  },
+});
+
+// Reactive: re-runs whenever a machine changes state.
+export const myMachines = query({
+  args: {},
+  handler: async (ctx) => boxd.list(ctx, { ownerId: await ownerId(ctx) }),
+});
+
+// Reactive: every command's status and output, newest first.
+export const history = query({
+  args: { machineId: v.string() },
+  handler: async (ctx, { machineId }) =>
+    boxd.listExecutions(ctx, { machineId, ownerId: await ownerId(ctx) }),
+});
+```
+
+`example/convex/example.ts` wraps every method this way.
+
+## API
+
+Every method takes the Convex `ctx` first. Reads run in queries. Everything that
+calls boxd runs in actions.
+
+| Method                                    | What it does                                                                       |
+| ----------------------------------------- | ---------------------------------------------------------------------------------- |
+| `create(ctx, args)`                       | Create a machine. Waits until it accepts a command, unless `waitUntilReady: false` |
+| `fork(ctx, { machineId })`                | Copy a machine, disk and memory, into a new one with the same owner                |
+| `exec(ctx, { machineId, command })`       | Run a command, wait for it to exit, record it. `command` is a string or an argv    |
+| `readFile` / `readFileBytes`              | Read a UTF-8 file as text, or any file byte for byte                               |
+| `writeFile(ctx, { path, content })`       | Write text or bytes. The parent directory must exist                               |
+| `listDir(ctx, { path })`                  | List a directory                                                                   |
+| `expose(ctx, { machineId, port, name? })` | Route public HTTPS to a port. Returns the URL                                      |
+| `pause` / `resume`                        | Freeze in RAM, and thaw                                                            |
+| `hibernate` / `wake`                      | Save memory to disk and free the host, and restore                                 |
+| `stop` / `start`                          | Shut down and cold boot. The disk is kept                                          |
+| `refresh(ctx, { machineId })`             | Re-read the machine from boxd into its row                                         |
+| `destroy(ctx, { machineId })`             | Destroy the machine. Its row and history stay, with status `destroyed`             |
+| `get` / `list`                            | Machine rows, reactive                                                             |
+| `listExecutions` / `getExecution`         | Command history, reactive                                                          |
+
+`create` takes `name`, `image`, `env`, `vcpu` or `memory` (size classes 1, 2 or
+4 vCPU with 4, 8 or 16 GiB), `autoSuspendSeconds`, `autoDestroySeconds` and
+`isolated`. The component never stores `env`.
+
+### Owners
+
+Pass `ownerId` on every call. A machine created with an `ownerId` is reachable
+only with that same `ownerId`, and one created without one only without one. For
+any other owner, reads return `null` or `[]`, and actions fail with `NOT_FOUND`,
+the same as for a machine that doesn't exist. A fork gets its source's owner.
+
+### Sleeping machines
+
+A paused or hibernated machine wakes by itself when it gets a command or an
+HTTPS request, so `exec` works without a `resume` first. Every transition is
+idempotent: `resume` on a running machine succeeds.
+
+### Errors
+
+Errors are `ConvexError`s with `data: { code, message }`. Branch on the code
+with `isBoxdError`:
+
+```ts
+import { isBoxdError } from "@boxd-sh/convex";
+
+try {
+  await boxd.refresh(ctx, { machineId, ownerId });
+} catch (error) {
+  if (isBoxdError(error, "NOT_FOUND")) return null;
+  throw error;
+}
+```
+
+| Code                | Meaning                                                               |
+| ------------------- | --------------------------------------------------------------------- |
+| `INVALID_ARGUMENT`  | An argument is wrong. Nothing was sent to boxd                        |
+| `NOT_FOUND`         | No such machine for this owner, or no such file                       |
+| `CONFLICT`          | The machine's state doesn't allow this, e.g. `pause` when stopped     |
+| `UNAUTHENTICATED`   | `BOXD_API_KEY` is missing, invalid, expired or revoked                |
+| `PERMISSION_DENIED` | The key's org may not do this                                         |
+| `RATE_LIMITED`      | A quota or rate limit, e.g. the org's machine quota                   |
+| `TIMEOUT`           | A command ran past its `timeoutMs`, or a machine wasn't ready in time |
+| `UNAVAILABLE`       | boxd could not be reached                                             |
+| `BOXD_ERROR`        | Anything else                                                         |
+
+A failed lifecycle call also stores its message in the machine's `lastError`.
+The next successful call clears it.
+
+When `create` or `fork` makes a machine that then fails to become ready, the
+error's `data.machineId` names it. The machine exists, and bills, until you
+destroy it, so act on that id instead of creating another machine.
+
+## Limits
+
+- **10 minute actions.** Convex stops an action after 10 minutes, so `exec`
+  kills its command after `timeoutMs`: default 9 minutes, at most 9.5. For
+  longer work, start it in the background (`nohup ... &`) and check on it with
+  later commands.
+- **Output.** `exec` returns up to 2 million characters per stream. The
+  execution row keeps the first 64,000.
+- **Files.** `readFile`, `readFileBytes` and `writeFile` move at most 8 MiB.
+  Move bigger files with `exec`, for example with `curl`.
+- **New named routes.** `expose` with a `name` returns at once, but the new URL
+  answers HTTPS only after boxd issues its certificate, typically 15 to 20
+  seconds later. The default URL answers at once.
+
+## How it works
+
+The component calls boxd through the
+[`@boxd-sh/sdk`](https://www.npmjs.com/package/@boxd-sh/sdk) web entry, which
+runs in Convex's default runtime. It exchanges the API key for a session token
+once, keeps the token in its own table, and reuses it until it nears expiry.
+boxd rate-limits that exchange per source IP, and Convex deployments share their
+egress IPs, so each action must not exchange the key again. If boxd revokes the
+token early, the component exchanges the key again and retries the call once.
+
+## Testing your app
+
+Register the component with `convex-test`:
+
+```ts
+import { convexTest } from "convex-test";
+import boxdTest from "@boxd-sh/convex/test";
+import schema from "./schema";
+
+const modules = import.meta.glob("./**/*.ts");
+
+const t = convexTest(schema, modules);
+boxdTest.register(t);
+```
+
+To keep tests off the network, mock `@boxd-sh/sdk/web` with `vi.mock`. The
+component's own tests do this: see `src/component/setup.test.ts`.
+
+## Developing this component
+
+```sh
+npm install
+npm run build:codegen   # codegen and build dist/
+npm run check           # build, typecheck, lint, format check, unit tests
+npm run test:live       # the example app against real boxd machines
+```
+
+`test:live` runs the example app on an anonymous local Convex backend, with no
+Convex account and nothing uploaded, against real boxd machines. It needs
+`BOXD_API_KEY` in the environment or in `.env.e2e.local`, and destroys every
+machine it creates.
+
+`demo/` is the public demo: a small React page (`demo/src`) that boots a
+machine, runs commands and forks it, all through the component, with its own
+Convex backend in `demo/convex`. That backend adds the parts a public page needs
+on top of the component: anonymous sign-in, an optional password
+(`DEMO_PASSWORD`), per-visitor machine caps, rate limits, and a cron that
+destroys each machine after ten minutes. Demo machines are `isolated`, so
+visitor commands can't reach boxd or other machines. Run it with
+`npx convex dev` and `npm run dev:demo`, or build it with `npm run build:demo`.
+
+`example/convex` is a reference app that wraps the whole API with no limits. It
+backs the unit and live tests and is never deployed alongside the demo, since
+its functions are open to any signed-in user.
+
+## License
+
+MIT

package/dist/client/_generated/_ignore.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=_ignore.d.ts.map

package/dist/client/_generated/_ignore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_ignore.d.ts","sourceRoot":"","sources":["../../../src/client/_generated/_ignore.ts"],"names":[],"mappings":""}

package/dist/client/_generated/_ignore.js

@@ -0,0 +1,3 @@
+"use strict";
+// This is only here so convex-test can detect a _generated folder
+//# sourceMappingURL=_ignore.js.map

package/dist/client/_generated/_ignore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_ignore.js","sourceRoot":"","sources":["../../../src/client/_generated/_ignore.ts"],"names":[],"mappings":";AAAA,kEAAkE"}

package/dist/client/index.d.ts

@@ -0,0 +1,327 @@
+/**
+ * App-facing client for the boxd Convex component.
+ *
+ * Create one with `components.boxd` in your `convex/` directory and call it
+ * from your queries and actions. Reads (`get`, `list`, `listExecutions`,
+ * `getExecution`) run in queries and are reactive. Everything that talks to
+ * boxd runs in actions.
+ *
+ * The component can't see your users: `ctx.auth` doesn't reach into a
+ * component. Derive `ownerId` from your own auth and pass it on every call.
+ * Never take it from a client argument. A machine created with an `ownerId`
+ * is reachable only with that same `ownerId`.
+ */
+import { ConvexError, type Infer } from "convex/values";
+import type { FunctionArgs, FunctionReference, FunctionReturnType, GenericActionCtx, GenericDataModel, GenericQueryCtx } from "convex/server";
+import type { ComponentApi } from "../component/_generated/component.js";
+import type { BoxdErrorData, errorCode } from "../component/errors.js";
+type QueryCtx = Pick<GenericQueryCtx<GenericDataModel>, "runQuery">;
+type ActionCtx = Pick<GenericActionCtx<GenericDataModel>, "runQuery" | "runMutation" | "runAction">;
+type Machines = ComponentApi["machines"];
+type Args<F extends FunctionReference<any, "internal">> = FunctionArgs<F>;
+type Returns<F extends FunctionReference<any, "internal">> = FunctionReturnType<F>;
+/** A machine's row: boxd's last observed state plus the component's fields. */
+export type MachineRecord = Returns<Machines["create"]>;
+/** One `exec`, as stored in the component. */
+export type ExecutionRecord = NonNullable<Returns<ComponentApi["executions"]["get"]>>;
+export type ExecResult = Returns<ComponentApi["exec"]["run"]>;
+export type DirListing = Returns<ComponentApi["files"]["listDir"]>;
+export type CreateArgs = Args<Machines["create"]>;
+export type ForkArgs = Args<Machines["fork"]>;
+export type ExecArgs = Args<ComponentApi["exec"]["run"]>;
+export type ExposeArgs = Args<Machines["expose"]>;
+/** Addresses one machine: its boxd id, and the owner it belongs to. */
+export type MachineRef = {
+    machineId: string;
+    ownerId?: string;
+};
+/** Addresses a machine that wakes up: optionally wait until it takes an exec. */
+export type WakeArgs = Args<Machines["start"]>;
+export type FileRef = MachineRef & {
+    path: string;
+};
+export type BoxdErrorCode = Infer<typeof errorCode>;
+export type { BoxdErrorData, ComponentApi };
+/**
+ * True when `error` is a `ConvexError` this component threw, and, with
+ * `code`, carries that code:
+ *
+ * ```ts
+ * if (isBoxdError(error, "NOT_FOUND")) return null;
+ * ```
+ */
+export declare function isBoxdError(error: unknown, code?: BoxdErrorCode): error is ConvexError<BoxdErrorData>;
+export declare class Boxd {
+    readonly component: ComponentApi;
+    constructor(component: ComponentApi);
+    /** The machine's row, or null if it doesn't exist for this owner. */
+    get(ctx: QueryCtx, args: MachineRef): Promise<{
+        _creationTime: number;
+        _id: string;
+        forkedFrom?: string;
+        image?: string;
+        lastError?: string;
+        machineId: string;
+        memoryBytes?: number;
+        name: string;
+        ownerId?: string;
+        status: string;
+        updatedAt: number;
+        url?: string;
+        vcpu?: number;
+    } | null>;
+    /** The owner's machines, newest first, destroyed ones included. */
+    list(ctx: QueryCtx, args?: {
+        ownerId?: string;
+        limit?: number;
+    }): Promise<{
+        _creationTime: number;
+        _id: string;
+        forkedFrom?: string;
+        image?: string;
+        lastError?: string;
+        machineId: string;
+        memoryBytes?: number;
+        name: string;
+        ownerId?: string;
+        status: string;
+        updatedAt: number;
+        url?: string;
+        vcpu?: number;
+    }[]>;
+    /** A machine's executions, newest first. */
+    listExecutions(ctx: QueryCtx, args: MachineRef & {
+        limit?: number;
+    }): Promise<{
+        _creationTime: number;
+        _id: string;
+        command: string;
+        cwd?: string;
+        error?: string;
+        exitCode?: number;
+        finishedAt?: number;
+        machineId: string;
+        ownerId?: string;
+        startedAt: number;
+        status: "running" | "completed" | "failed";
+        stderr?: string;
+        stdout?: string;
+    }[]>;
+    /** One execution by the id `exec` returned, or null. */
+    getExecution(ctx: QueryCtx, args: {
+        executionId: string;
+        ownerId?: string;
+    }): Promise<{
+        _creationTime: number;
+        _id: string;
+        command: string;
+        cwd?: string;
+        error?: string;
+        exitCode?: number;
+        finishedAt?: number;
+        machineId: string;
+        ownerId?: string;
+        startedAt: number;
+        status: "running" | "completed" | "failed";
+        stderr?: string;
+        stdout?: string;
+    } | null>;
+    /** Create a machine and, by default, wait until it accepts an exec. */
+    create(ctx: ActionCtx, args?: CreateArgs): Promise<{
+        _creationTime: number;
+        _id: string;
+        forkedFrom?: string;
+        image?: string;
+        lastError?: string;
+        machineId: string;
+        memoryBytes?: number;
+        name: string;
+        ownerId?: string;
+        status: string;
+        updatedAt: number;
+        url?: string;
+        vcpu?: number;
+    }>;
+    /** Fork a machine, disk and memory, into a new one with the same owner. */
+    fork(ctx: ActionCtx, args: ForkArgs): Promise<{
+        _creationTime: number;
+        _id: string;
+        forkedFrom?: string;
+        image?: string;
+        lastError?: string;
+        machineId: string;
+        memoryBytes?: number;
+        name: string;
+        ownerId?: string;
+        status: string;
+        updatedAt: number;
+        url?: string;
+        vcpu?: number;
+    }>;
+    /** Re-read the machine from boxd into its row. */
+    refresh(ctx: ActionCtx, args: MachineRef): Promise<{
+        _creationTime: number;
+        _id: string;
+        forkedFrom?: string;
+        image?: string;
+        lastError?: string;
+        machineId: string;
+        memoryBytes?: number;
+        name: string;
+        ownerId?: string;
+        status: string;
+        updatedAt: number;
+        url?: string;
+        vcpu?: number;
+    }>;
+    /** Boot a stopped machine. */
+    start(ctx: ActionCtx, args: WakeArgs): Promise<{
+        _creationTime: number;
+        _id: string;
+        forkedFrom?: string;
+        image?: string;
+        lastError?: string;
+        machineId: string;
+        memoryBytes?: number;
+        name: string;
+        ownerId?: string;
+        status: string;
+        updatedAt: number;
+        url?: string;
+        vcpu?: number;
+    }>;
+    /** Shut the machine down. The disk is kept. */
+    stop(ctx: ActionCtx, args: MachineRef): Promise<{
+        _creationTime: number;
+        _id: string;
+        forkedFrom?: string;
+        image?: string;
+        lastError?: string;
+        machineId: string;
+        memoryBytes?: number;
+        name: string;
+        ownerId?: string;
+        status: string;
+        updatedAt: number;
+        url?: string;
+        vcpu?: number;
+    }>;
+    /** Suspend to RAM. An exec or an HTTPS request wakes it again. */
+    pause(ctx: ActionCtx, args: MachineRef): Promise<{
+        _creationTime: number;
+        _id: string;
+        forkedFrom?: string;
+        image?: string;
+        lastError?: string;
+        machineId: string;
+        memoryBytes?: number;
+        name: string;
+        ownerId?: string;
+        status: string;
+        updatedAt: number;
+        url?: string;
+        vcpu?: number;
+    }>;
+    /** Resume a paused machine. */
+    resume(ctx: ActionCtx, args: WakeArgs): Promise<{
+        _creationTime: number;
+        _id: string;
+        forkedFrom?: string;
+        image?: string;
+        lastError?: string;
+        machineId: string;
+        memoryBytes?: number;
+        name: string;
+        ownerId?: string;
+        status: string;
+        updatedAt: number;
+        url?: string;
+        vcpu?: number;
+    }>;
+    /** Suspend to disk, freeing the host's memory. */
+    hibernate(ctx: ActionCtx, args: MachineRef): Promise<{
+        _creationTime: number;
+        _id: string;
+        forkedFrom?: string;
+        image?: string;
+        lastError?: string;
+        machineId: string;
+        memoryBytes?: number;
+        name: string;
+        ownerId?: string;
+        status: string;
+        updatedAt: number;
+        url?: string;
+        vcpu?: number;
+    }>;
+    /** Restore a hibernated machine, memory included. */
+    wake(ctx: ActionCtx, args: WakeArgs): Promise<{
+        _creationTime: number;
+        _id: string;
+        forkedFrom?: string;
+        image?: string;
+        lastError?: string;
+        machineId: string;
+        memoryBytes?: number;
+        name: string;
+        ownerId?: string;
+        status: string;
+        updatedAt: number;
+        url?: string;
+        vcpu?: number;
+    }>;
+    /** Destroy the machine. Its row stays, with status "destroyed". */
+    destroy(ctx: ActionCtx, args: MachineRef): Promise<{
+        _creationTime: number;
+        _id: string;
+        forkedFrom?: string;
+        image?: string;
+        lastError?: string;
+        machineId: string;
+        memoryBytes?: number;
+        name: string;
+        ownerId?: string;
+        status: string;
+        updatedAt: number;
+        url?: string;
+        vcpu?: number;
+    }>;
+    /**
+     * Route public HTTPS to a port. Without `name`: the machine's default URL.
+     * With `name`: an extra `https://<name>.<machine>.<zone>`.
+     */
+    expose(ctx: ActionCtx, args: ExposeArgs): Promise<{
+        port: number;
+        url: string;
+    }>;
+    /** Run a command and wait for it to exit. Recorded in `executions`. */
+    exec(ctx: ActionCtx, args: ExecArgs): Promise<{
+        executionId: string;
+        exitCode: number;
+        stderr: string;
+        stdout: string;
+        success: boolean;
+    }>;
+    /** Read a file as UTF-8 text. */
+    readFile(ctx: ActionCtx, args: FileRef): Promise<string>;
+    /** Read a file byte for byte. */
+    readFileBytes(ctx: ActionCtx, args: FileRef): Promise<ArrayBuffer>;
+    /** Create or replace a file from text or bytes. */
+    writeFile(ctx: ActionCtx, args: FileRef & {
+        content: string | ArrayBuffer;
+    }): Promise<{
+        bytesWritten: number;
+    }>;
+    /** The immediate contents of a directory. */
+    listDir(ctx: ActionCtx, args: FileRef): Promise<{
+        entries: Array<{
+            isDir: boolean;
+            modifiedAt: number;
+            name: string;
+            permissions: string;
+            sizeBytes: number;
+        }>;
+        truncated: boolean;
+    }>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/client/index.ts"],"names":[],"mappings":"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"}