hyperbrane 0.2.0 → 0.2.1

package/dist/dimension/api.d.ts

@@ -1,3 +1,4 @@
+import type { RunCommandOptions, RunCommandResult } from "../sandbox/api.ts";
 export { dimensionLayout } from "./paths.ts";
 export type MemoryLimit = number & {
     readonly __brand: "MemoryLimit";
@@ -59,6 +60,7 @@ export interface DimensionClient {
     createDimension(dimension: Dimension): Promise<Dimension>;
     destroyDimension(dimensionName: string): Promise<void>;
     restartDimension(dimensionName: string): Promise<void>;
+    restoreDimensions(): Promise<string[]>;
     updateDimension(dimensionName: string, limits: DimensionLimits): Promise<Dimension>;
     listDimensions(): Promise<DimensionInfo[]>;
     getDimensionUsage(): Promise<DimensionUsage[]>;
@@ -68,6 +70,7 @@ export interface DimensionClient {
     }): Promise<ReadableStream<Uint8Array>>;
     writeFile(dimensionName: string, path: string, data: Uint8Array | ReadableStream<Uint8Array>): Promise<void>;
     statFile(dimensionName: string, path: string): Promise<DimensionFileInfo>;
+    runCommand(dimensionName: string, cmd: string[], options?: RunCommandOptions): Promise<RunCommandResult>;
 }
 export declare class DimensionInvalidError extends Error {
     name: string;

package/dist/dimension/control.d.ts

@@ -1,5 +1,5 @@
 import { type ControlOptions } from "../lib/control.ts";
-import type { Sandbox } from "../sandbox/api.ts";
+import type { RunCommandOptions, RunCommandResult, Sandbox } from "../sandbox/api.ts";
 import { type Dimension, type DimensionLimits, type DimensionStatus, type DimensionUsage } from "./api.ts";
 export type { ControlOptions };
 export type DimensionRecord = Dimension & {
@@ -19,3 +19,4 @@ export declare function dimensionUsageScript(host: Sandbox, options?: ControlOpt
 export declare function startTransportScript(host: Sandbox, dimensionName: string, options: ControlOptions, { restart, }: {
     restart: boolean;
 }): Promise<void>;
+export declare function runInDimensionScript(host: Sandbox, dimensionName: string, cmd: string[], { cwd, env, stdin }: RunCommandOptions, options?: ControlOptions): Promise<RunCommandResult>;

package/dist/dimension/control.js

@@ -1,3 +1,4 @@
+import { posix } from "node:path";
 import { exitEnv, records, runControl } from "../lib/control.js";
 import { sh } from "../lib/sh.js";
 import { HYPERBRANE_VERSION } from "../lib/version.js";
@@ -96,6 +97,13 @@ export async function startTransportScript(host, dimensionName, options, { resta
     }
     check(result, `starting dimension ${dimensionName}'s transport worker`);
 }
+export async function runInDimensionScript(host, dimensionName, cmd, { cwd, env = {}, stdin }, options = {}) {
+    const envFlags = Object.entries(env).flatMap(([name, value]) => ["-e", `${name}=${value}`]);
+    const result = await runControl(host, PRELUDE, RUN_IN_DIMENSION, { ...exitEnv(EXIT), ...dimensionEnv(dimensionName, options), WORKDIR: posix.resolve(WORKSPACE_PATH, cwd ?? "."), INTERACTIVE: stdin === undefined ? "" : "1" }, {}, { args: [...envFlags, containerName(dimensionName), ...cmd], stdin });
+    if (!result.stdout.startsWith(COMMAND_START))
+        check(result, `running a command in dimension ${dimensionName}`);
+    return { ...result, stdout: result.stdout.slice(COMMAND_START.length) };
+}
 function dataEnv({ dataDirectory }) {
     return { ...(dataDirectory === undefined ? {} : { DATA: dataDirectory }), CONTAINER_PREFIX: containerName(""), RUN_PATH, STATE_PATH };
 }
@@ -121,6 +129,7 @@ function check(result, what) {
     }
 }
 const CONTAINERS_START = "\n\x1d\n";
+const COMMAND_START = "\x1e";
 const PRELUDE = sh `
 # shellcheck disable=SC2034
 dimension_paths() {
@@ -326,3 +335,12 @@ done
 # shellcheck disable=SC2086
 [ -z "$containers" ] || docker stats --no-stream --format '{{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}' $containers
 `;
+const RUN_IN_DIMENSION = sh `
+set -eu
+dimension_paths
+require_dimension
+[ "$RUNNING" = true ] || refuse "$E_CONFLICT" "dimension $DIMENSION isn't running"
+user="$(docker inspect -f '{{.Config.User}}' "$CONTAINER")"
+printf '\036'
+exec docker exec \${INTERACTIVE:+-i} -u "\${user:-0:0}" -w "$WORKDIR" "$@"
+`;

package/dist/dimension/service.js

@@ -1,5 +1,5 @@
 import { DimensionInvalidError, isDimensionName } from "./api.js";
-import { createDimensionScript, destroyDimensionScript, dimensionUsageScript, listDimensionsScript, restartDimensionScript, startTransportScript, updateDimensionScript, } from "./control.js";
+import { createDimensionScript, destroyDimensionScript, dimensionUsageScript, listDimensionsScript, restartDimensionScript, runInDimensionScript, startTransportScript, updateDimensionScript, } from "./control.js";
 import { createDimensionImage } from "./image.js";
 import { RUN_PATH, STATE_PATH, WORKSPACE_PATH, containerName, dimensionLayout } from "./paths.js";
 import { transportFiles } from "./transportClient.js";
@@ -41,6 +41,20 @@ export function createDimensionService(host, { dataDirectory } = {}) {
         await portals.restorePortals({ dimensionName });
         await startTransportScript(host, dimensionName, options, { restart: true });
     }
+    async function restoreDimensions() {
+        const running = (await listDimensionsScript(host, options)).filter(({ status }) => status === "running");
+        const restored = await Promise.all(running.map(async ({ record: { name } }) => {
+            try {
+                await startTransportScript(host, name, options, { restart: false });
+                return name;
+            }
+            catch (error) {
+                console.warn(`starting dimension ${name}'s transport worker failed:`, error.message);
+                return null;
+            }
+        }));
+        return restored.filter((name) => name !== null);
+    }
     async function transportSocket(dimensionName) {
         assertValidName(dimensionName);
         const data = dataDirectory ?? `${await host.homeDirectory()}/.local/share/hyperbrane`;
@@ -53,6 +67,16 @@ export function createDimensionService(host, { dataDirectory } = {}) {
         const { state: _state, ...updated } = await updateDimensionScript(host, dimensionName, limits, options);
         return updated;
     }
+    async function runCommand(dimensionName, cmd, commandOptions = {}) {
+        assertValidName(dimensionName);
+        if (cmd.length === 0)
+            throw new DimensionInvalidError("a command needs at least its program");
+        for (const name of Object.keys(commandOptions.env ?? {})) {
+            if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name))
+                throw new DimensionInvalidError(`not an environment variable name: "${name}"`);
+        }
+        return runInDimensionScript(host, dimensionName, cmd, commandOptions, options);
+    }
     return {
         listDimensions,
         getDimensionUsage: () => dimensionUsageScript(host, options),
@@ -62,7 +86,9 @@ export function createDimensionService(host, { dataDirectory } = {}) {
         createDimension: (dimension) => createDimension(dimension),
         destroyDimension: (dimensionName) => destroyDimension(dimensionName),
         restartDimension: (dimensionName) => restartDimension(dimensionName),
+        restoreDimensions,
         updateDimension: (dimensionName, limits) => updateDimension(dimensionName, limits),
+        runCommand: (dimensionName, cmd, commandOptions) => runCommand(dimensionName, cmd, commandOptions),
     };
 }
 function assertLimits(limits) {