@nylorun/runtime 0.6.0-beta → 0.8.0-beta

package/dist/sandbox/policy.js

@@ -0,0 +1,67 @@
+import { parseSandboxDuration, parseSandboxSize, } from "@nylorun/core/define";
+/** Docker Official Image: Debian with bash, coreutils and Python 3; small first pull. */
+export const DEFAULT_SANDBOX_IMAGE = "python:3.13-slim";
+export const DEFAULT_SANDBOX_CPUS = 2;
+export const DEFAULT_SANDBOX_MEMORY_MIB = 1024;
+export const DEFAULT_SANDBOX_IDLE_MS = 15 * 60_000;
+/** Package registries and code hosts. Concrete names so every backend can express them. */
+export const DEV_PRESET_HOSTS = Object.freeze([
+    // npm and yarn
+    "registry.npmjs.org",
+    "registry.yarnpkg.com",
+    // Python
+    "pypi.org",
+    "files.pythonhosted.org",
+    // Rust
+    "crates.io",
+    "index.crates.io",
+    "static.crates.io",
+    // Go
+    "proxy.golang.org",
+    "sum.golang.org",
+    // Debian and Ubuntu package mirrors
+    "deb.debian.org",
+    "security.debian.org",
+    "archive.ubuntu.com",
+    "security.ubuntu.com",
+    "ports.ubuntu.com",
+    // Code hosts
+    "github.com",
+    "api.github.com",
+    "codeload.github.com",
+    "objects.githubusercontent.com",
+    "raw.githubusercontent.com",
+    "gitlab.com",
+]);
+export function resolveNetwork(manifest) {
+    const preset = manifest?.network?.preset ?? "dev";
+    const hosts = new Set(preset === "dev" ? DEV_PRESET_HOSTS : []);
+    const suffixes = new Set();
+    for (const entry of manifest?.network?.allow ?? []) {
+        const host = entry.toLowerCase();
+        if (host.startsWith("*."))
+            suffixes.add(host.slice(1));
+        else
+            hosts.add(host);
+    }
+    return Object.freeze({
+        preset,
+        hosts: Object.freeze([...hosts].sort()),
+        suffixes: Object.freeze([...suffixes].sort()),
+    });
+}
+export function idleMsOf(manifest) {
+    return (manifest?.idle && parseSandboxDuration(manifest.idle)) || DEFAULT_SANDBOX_IDLE_MS;
+}
+export function memoryMiBOf(manifest) {
+    const bytes = manifest?.resources?.memory
+        ? parseSandboxSize(manifest.resources.memory)
+        : undefined;
+    return bytes ? Math.max(128, Math.ceil(bytes / 1024 ** 2)) : DEFAULT_SANDBOX_MEMORY_MIB;
+}
+export function describeNetwork(network) {
+    const extra = network.preset === "dev"
+        ? network.hosts.length - DEV_PRESET_HOSTS.length + network.suffixes.length
+        : network.hosts.length + network.suffixes.length;
+    return extra > 0 ? `${network.preset} +${extra} host(s)` : network.preset;
+}

package/dist/sandbox/select.d.ts

@@ -0,0 +1,35 @@
+import type { SandboxBackend, SandboxBackendName, SandboxIsolation, SandboxProbe } from "./types.js";
+export type SandboxPreference = "auto" | SandboxBackendName;
+export interface SandboxSelection {
+    readonly preference: SandboxPreference;
+    readonly backend?: SandboxBackend;
+    /** Why this backend was chosen, or why none could be. */
+    readonly reason: string;
+    readonly probes: readonly SandboxProbe[];
+}
+/** Serializable view of a selection for the CLI and `GET /v1/host/sandbox`. */
+export interface SandboxSelectionReport {
+    readonly preference: SandboxPreference;
+    readonly backend: SandboxBackendName | null;
+    readonly isolation: SandboxIsolation | null;
+    readonly reason: string;
+    readonly probes: readonly SandboxProbe[];
+}
+/** The default order: strongest isolation first, then the backend that always works. */
+export declare function defaultSandboxBackends(options: {
+    readonly root: string;
+}): SandboxBackend[];
+export declare function parseSandboxPreference(value: string | undefined): SandboxPreference | undefined;
+/**
+ * Probe backends in order and pick one. An explicit preference never falls back, so a
+ * production Runtime cannot silently run with weaker isolation than it was configured for.
+ */
+export declare function selectSandboxBackend(backends: readonly SandboxBackend[], preference: SandboxPreference): Promise<SandboxSelection>;
+export declare function reportSelection(selection: SandboxSelection): SandboxSelectionReport;
+/**
+ * Probe this machine the way a Runtime would at startup. Used by `nylorun doctor sandbox`.
+ * Nothing is created or booted.
+ */
+export declare function probeSandboxBackends(options?: {
+    readonly preference?: string;
+}): Promise<SandboxSelectionReport>;

package/dist/sandbox/select.js

@@ -0,0 +1,76 @@
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { microsandboxBackend } from "../adapters/sandbox/microsandbox.js";
+import { virtualBackend } from "../adapters/sandbox/virtual.js";
+const PREFERENCES = ["auto", "microsandbox", "virtual"];
+/** The default order: strongest isolation first, then the backend that always works. */
+export function defaultSandboxBackends(options) {
+    return [microsandboxBackend(), virtualBackend({ root: options.root })];
+}
+export function parseSandboxPreference(value) {
+    const normalized = (value ?? "auto").trim().toLowerCase() || "auto";
+    return PREFERENCES.includes(normalized)
+        ? normalized
+        : undefined;
+}
+/**
+ * Probe backends in order and pick one. An explicit preference never falls back, so a
+ * production Runtime cannot silently run with weaker isolation than it was configured for.
+ */
+export async function selectSandboxBackend(backends, preference) {
+    const probes = [];
+    for (const backend of backends)
+        probes.push(await backend.probe());
+    const probeOf = (name) => probes.find((probe) => probe.name === name);
+    if (preference !== "auto") {
+        const backend = backends.find((item) => item.name === preference);
+        const probe = probeOf(preference);
+        if (backend && probe?.available)
+            return { preference, backend, reason: `${preference} selected by NYLORUN_SANDBOX`, probes };
+        return {
+            preference,
+            reason: `NYLORUN_SANDBOX=${preference} but ${preference} is unavailable: ${probe?.reason ?? "unknown backend"}. Fix it, or unset NYLORUN_SANDBOX to use the best available backend`,
+            probes,
+        };
+    }
+    const index = backends.findIndex((_, i) => probes[i].available);
+    if (index < 0)
+        return {
+            preference,
+            reason: `no sandbox backend is available (${probes.map((probe) => `${probe.name}: ${probe.reason}`).join("; ")})`,
+            probes,
+        };
+    const skipped = probes.slice(0, index).map((probe) => `${probe.name} unavailable: ${probe.reason}`);
+    return {
+        preference,
+        backend: backends[index],
+        reason: skipped.length ? skipped.join("; ") : probes[index].reason ?? backends[index].name,
+        probes,
+    };
+}
+export function reportSelection(selection) {
+    return {
+        preference: selection.preference,
+        backend: selection.backend?.name ?? null,
+        isolation: selection.backend?.isolation ?? null,
+        reason: selection.reason,
+        probes: selection.probes,
+    };
+}
+/**
+ * Probe this machine the way a Runtime would at startup. Used by `nylorun doctor sandbox`.
+ * Nothing is created or booted.
+ */
+export async function probeSandboxBackends(options = {}) {
+    const preference = parseSandboxPreference(options.preference ?? process.env.NYLORUN_SANDBOX);
+    const backends = defaultSandboxBackends({ root: join(tmpdir(), "nylorun-sandbox-probe") });
+    if (!preference)
+        return {
+            preference: "auto",
+            backend: null,
+            isolation: null,
+            reason: "NYLORUN_SANDBOX must be auto, microsandbox or virtual",
+            probes: await Promise.all(backends.map((backend) => backend.probe())),
+        };
+    return reportSelection(await selectSandboxBackend(backends, preference));
+}

package/dist/sandbox/tools.d.ts

@@ -0,0 +1,25 @@
+import { type SandboxToolName } from "@nylorun/core/define";
+import type { SandboxHandle } from "./types.js";
+export type SandboxToolOutcome = {
+    readonly kind: "completed";
+    readonly output: unknown;
+} | {
+    readonly kind: "failed";
+    readonly code: string;
+    readonly message: string;
+};
+/** What the Runtime reports about a tool call on the session stream. */
+export interface SandboxToolReport {
+    readonly command?: string;
+    readonly path?: string;
+    readonly exitCode?: number;
+    readonly killed?: boolean;
+}
+export declare function quote(value: string): string;
+export declare function resolvePath(path: string): string;
+/** Keep the head and tail of long output so the model sees both the start and the error. */
+export declare function truncateMiddle(value: string, limit?: number): {
+    text: string;
+    truncated: boolean;
+};
+export declare function runSandboxTool(handle: SandboxHandle, name: SandboxToolName, input: Record<string, any>, signal: AbortSignal, report: (value: SandboxToolReport) => void): Promise<SandboxToolOutcome>;

package/dist/sandbox/tools.js

@@ -0,0 +1,165 @@
+/**
+ * The six built-in sandbox tools, implemented once over `SandboxHandle` so every backend behaves
+ * the same. Expected problems are returned as failed outcomes; only infrastructure errors throw.
+ */
+import { posix } from "node:path";
+import { SANDBOX_WORKSPACE } from "@nylorun/core/define";
+const OUTPUT_LIMIT = 30_000;
+const DEFAULT_TIMEOUT_S = 120;
+const DEFAULT_READ_LINES = 2000;
+const LINE_LIMIT = 2000;
+const DEFAULT_GREP_RESULTS = 200;
+const GLOB_LIMIT = 500;
+const GLOB_SCAN_LIMIT = 20_000;
+export function quote(value) {
+    return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+export function resolvePath(path) {
+    return posix.normalize(path.startsWith("/") ? path : posix.join(SANDBOX_WORKSPACE, path));
+}
+/** Keep the head and tail of long output so the model sees both the start and the error. */
+export function truncateMiddle(value, limit = OUTPUT_LIMIT) {
+    if (value.length <= limit)
+        return { text: value, truncated: false };
+    const half = Math.floor(limit / 2);
+    const omitted = value.length - half * 2;
+    return {
+        text: `${value.slice(0, half)}\n… [${omitted} characters omitted] …\n${value.slice(-half)}`,
+        truncated: true,
+    };
+}
+const failed = (code, message) => ({
+    kind: "failed",
+    code,
+    message,
+});
+export async function runSandboxTool(handle, name, input, signal, report) {
+    const exec = (command, timeoutMs = 60_000) => handle.exec({ command, cwd: SANDBOX_WORKSPACE, timeoutMs }, signal);
+    switch (name) {
+        case "bash": {
+            const command = String(input.command);
+            const timeout = (input.timeout ?? DEFAULT_TIMEOUT_S) * 1000;
+            const result = await exec(command, timeout);
+            report({ command, exitCode: result.exitCode, killed: result.killed });
+            const stdout = truncateMiddle(result.stdout);
+            const stderr = truncateMiddle(result.stderr);
+            return {
+                kind: "completed",
+                output: {
+                    exitCode: result.exitCode,
+                    stdout: stdout.text,
+                    stderr: result.timedOut
+                        ? `${stderr.text}${stderr.text && !stderr.text.endsWith("\n") ? "\n" : ""}Command timed out after ${timeout / 1000}s and was killed.`
+                        : stderr.text,
+                    ...(stdout.truncated || stderr.truncated ? { truncated: true } : {}),
+                    ...(result.timedOut ? { timedOut: true } : {}),
+                },
+            };
+        }
+        case "read": {
+            const path = resolvePath(String(input.path));
+            report({ path });
+            const content = await handle.readFile(path);
+            if (content === undefined)
+                return failed("sandbox.not_found", `No file at ${path}`);
+            const lines = content.split("\n");
+            if (lines.at(-1) === "")
+                lines.pop();
+            const start = (input.offset ?? 1) - 1;
+            const limit = input.limit ?? DEFAULT_READ_LINES;
+            const slice = lines.slice(start, start + limit);
+            const width = String(start + slice.length).length;
+            const text = slice
+                .map((line, index) => {
+                const clipped = line.length > LINE_LIMIT ? `${line.slice(0, LINE_LIMIT)}…` : line;
+                return `${String(start + index + 1).padStart(width, " ")}\t${clipped}`;
+            })
+                .join("\n");
+            const remaining = lines.length - (start + slice.length);
+            return {
+                kind: "completed",
+                output: lines.length === 0
+                    ? `${path} is empty.`
+                    : remaining > 0
+                        ? `${text}\n… ${remaining} more line(s); read again with offset ${start + slice.length + 1}.`
+                        : text,
+            };
+        }
+        case "write": {
+            const path = resolvePath(String(input.path));
+            const content = String(input.content);
+            report({ path });
+            const parent = await exec(`mkdir -p ${quote(posix.dirname(path))}`);
+            if (parent.exitCode !== 0)
+                return failed("sandbox.write_failed", parent.stderr.trim() || `Could not create ${posix.dirname(path)}`);
+            await handle.writeFile(path, content);
+            return { kind: "completed", output: { path, bytes: Buffer.byteLength(content) } };
+        }
+        case "edit": {
+            const path = resolvePath(String(input.path));
+            report({ path });
+            const content = await handle.readFile(path);
+            if (content === undefined)
+                return failed("sandbox.not_found", `No file at ${path}`);
+            const oldString = String(input.old_string);
+            const newString = String(input.new_string);
+            if (oldString === newString)
+                return failed("sandbox.edit_noop", "old_string and new_string are identical");
+            const count = content.split(oldString).length - 1;
+            if (count === 0)
+                return failed("sandbox.edit_no_match", `old_string was not found in ${path}. Read the file and copy the text exactly.`);
+            if (count > 1 && input.replace_all !== true)
+                return failed("sandbox.edit_not_unique", `old_string appears ${count} times in ${path}. Add surrounding context to make it unique, or set replace_all.`);
+            await handle.writeFile(path, content.replaceAll(oldString, () => newString));
+            return { kind: "completed", output: { path, replacements: input.replace_all === true ? count : 1 } };
+        }
+        case "grep": {
+            const max = input.max_results ?? DEFAULT_GREP_RESULTS;
+            const target = input.path ? String(input.path) : ".";
+            const flags = ["-rnE", ...(input.ignore_case ? ["-i"] : [])];
+            const include = input.glob ? ` --include=${quote(String(input.glob))}` : "";
+            const command = `grep ${flags.join(" ")}${include} -e ${quote(String(input.pattern))} -- ${quote(target)} | head -n ${max + 1}`;
+            report({ command });
+            const result = await exec(command);
+            // The pipeline's exit code is head's, so a grep error shows up as stderr with no matches.
+            const lines = result.stdout.split("\n").filter(Boolean);
+            if (lines.length === 0)
+                return result.stderr.trim()
+                    ? failed("sandbox.grep_failed", result.stderr.trim())
+                    : { kind: "completed", output: "No matches." };
+            const shown = lines.slice(0, max).map((line) => (line.length > LINE_LIMIT ? `${line.slice(0, LINE_LIMIT)}…` : line));
+            return {
+                kind: "completed",
+                output: lines.length > max ? `${shown.join("\n")}\n… more matches omitted; narrow the search.` : shown.join("\n"),
+            };
+        }
+        case "glob": {
+            const root = resolvePath(input.path ? String(input.path) : ".");
+            const pattern = String(input.pattern);
+            const command = `find ${quote(root)} -type f -not -path '*/.git/*' 2>/dev/null | head -n ${GLOB_SCAN_LIMIT}`;
+            report({ command });
+            const result = await exec(command);
+            const byBasename = !pattern.includes("/");
+            const matches = [];
+            for (const file of result.stdout.split("\n")) {
+                if (!file)
+                    continue;
+                const relative = posix.relative(root, file);
+                if (posix.matchesGlob(byBasename ? posix.basename(relative) : relative, pattern)) {
+                    matches.push(file);
+                    if (matches.length > GLOB_LIMIT)
+                        break;
+                }
+            }
+            if (matches.length === 0)
+                return { kind: "completed", output: "No files matched." };
+            matches.sort();
+            return {
+                kind: "completed",
+                output: matches.length > GLOB_LIMIT
+                    ? `${matches.slice(0, GLOB_LIMIT).join("\n")}\n… more files omitted; narrow the pattern.`
+                    : matches.join("\n"),
+            };
+        }
+    }
+}

package/dist/sandbox/types.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Backend contract for Runtime-owned sandboxes. Only files under `adapters/sandbox/` implement it
+ * and import a substrate SDK; everything else in the Runtime talks to this interface.
+ */
+import type { SandboxNetworkPreset } from "@nylorun/core/define";
+export type SandboxBackendName = "microsandbox" | "virtual";
+export type SandboxIsolation = "vm" | "process";
+export interface SandboxProbe {
+    readonly name: SandboxBackendName;
+    readonly available: boolean;
+    readonly isolation: SandboxIsolation;
+    /** Why the backend is unavailable, or a short description when it is. */
+    readonly reason?: string;
+    readonly version?: string;
+}
+/** Egress policy after presets are expanded. Always-blocked ranges are the backend's job. */
+export interface ResolvedNetwork {
+    readonly preset: SandboxNetworkPreset;
+    /** Exact host names allowed over HTTPS/HTTP. */
+    readonly hosts: readonly string[];
+    /** Domain suffixes such as ".pythonhosted.org", from "*.pythonhosted.org". */
+    readonly suffixes: readonly string[];
+}
+export interface SandboxSpec {
+    /** Stable backend name for this sandbox; unique per Runtime scope and session. */
+    readonly key: string;
+    readonly image: string;
+    readonly cpus: number;
+    readonly memoryMiB: number;
+    readonly network: ResolvedNetwork;
+}
+export interface ExecRequest {
+    readonly command: string;
+    readonly cwd: string;
+    readonly timeoutMs: number;
+}
+export interface ExecResult {
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+    /** The process was actually stopped (timeout or cancellation). */
+    readonly killed: boolean;
+    readonly timedOut: boolean;
+}
+export interface SandboxHandle {
+    exec(request: ExecRequest, signal: AbortSignal): Promise<ExecResult>;
+    /** Returns undefined when the file does not exist. */
+    readFile(path: string): Promise<string | undefined>;
+    /** Parent directories must already exist. */
+    writeFile(path: string, content: string): Promise<void>;
+    /** Release compute; files persist. */
+    stop(): Promise<void>;
+}
+export interface SandboxBackend {
+    readonly name: SandboxBackendName;
+    readonly isolation: SandboxIsolation;
+    probe(): Promise<SandboxProbe>;
+    /** A reason this backend cannot meet the spec, or undefined when it can. */
+    unmet(spec: SandboxSpec): string | undefined;
+    /** Reattach to an existing sandbox (starting it if stopped) or create a new one. */
+    open(spec: SandboxSpec): Promise<SandboxHandle>;
+    /** Delete compute and files. Missing sandboxes are ignored. */
+    remove(key: string): Promise<void>;
+    /** Keys of sandboxes this backend holds whose key starts with the prefix. */
+    list(prefix: string): Promise<readonly string[]>;
+}

package/dist/vault/crypto.d.ts

@@ -0,0 +1,12 @@
+export declare class VaultCryptoError extends Error {
+    constructor();
+}
+export declare function kekId(kek: Buffer): string;
+export declare function parseKek(value: Buffer | string): Buffer;
+export declare function encryptSecret(kek: Buffer, aad: Buffer, plaintext: Buffer): {
+    nonce: Buffer;
+    ciphertext: Buffer;
+    wrappedDek: Buffer;
+    kekId: string;
+};
+export declare function decryptSecret(kek: Buffer, aad: Buffer, nonce: Buffer, ciphertext: Buffer, wrappedDek: Buffer, expectedKekId: string): Buffer;

package/dist/vault/crypto.js

@@ -0,0 +1,80 @@
+import { createCipheriv, createDecipheriv, createHash, randomBytes, } from "node:crypto";
+const IV_BYTES = 12;
+const TAG_BYTES = 16;
+export class VaultCryptoError extends Error {
+    constructor() {
+        super("Vault credential could not be read");
+    }
+}
+export function kekId(kek) {
+    return createHash("sha256").update(kek).digest("hex");
+}
+export function parseKek(value) {
+    const bytes = typeof value === "string" ? Buffer.from(value.trim(), "base64") : value;
+    if (bytes.length !== 32)
+        throw new Error("Vault key-encryption key must be 32 bytes");
+    return Buffer.from(bytes);
+}
+export function encryptSecret(kek, aad, plaintext) {
+    const dek = randomBytes(32);
+    try {
+        const nonce = randomBytes(IV_BYTES);
+        const cipher = createCipheriv("aes-256-gcm", dek, nonce);
+        cipher.setAAD(aad);
+        const body = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+        const tag = cipher.getAuthTag();
+        return {
+            nonce,
+            ciphertext: Buffer.concat([body, tag]),
+            wrappedDek: wrapKey(kek, dek),
+            kekId: kekId(kek),
+        };
+    }
+    finally {
+        dek.fill(0);
+    }
+}
+export function decryptSecret(kek, aad, nonce, ciphertext, wrappedDek, expectedKekId) {
+    if (expectedKekId !== kekId(kek))
+        throw new VaultCryptoError();
+    const dek = unwrapKey(kek, wrappedDek);
+    try {
+        if (ciphertext.length < TAG_BYTES)
+            throw new VaultCryptoError();
+        const tag = ciphertext.subarray(ciphertext.length - TAG_BYTES);
+        const body = ciphertext.subarray(0, ciphertext.length - TAG_BYTES);
+        const decipher = createDecipheriv("aes-256-gcm", dek, nonce);
+        decipher.setAAD(aad);
+        decipher.setAuthTag(tag);
+        return Buffer.concat([decipher.update(body), decipher.final()]);
+    }
+    catch (error) {
+        if (error instanceof VaultCryptoError)
+            throw error;
+        throw new VaultCryptoError();
+    }
+    finally {
+        dek.fill(0);
+    }
+}
+function wrapKey(kek, dek) {
+    const nonce = randomBytes(IV_BYTES);
+    const cipher = createCipheriv("aes-256-gcm", kek, nonce);
+    const body = Buffer.concat([cipher.update(dek), cipher.final()]);
+    return Buffer.concat([nonce, body, cipher.getAuthTag()]);
+}
+function unwrapKey(kek, wrapped) {
+    try {
+        if (wrapped.length < IV_BYTES + TAG_BYTES)
+            throw new VaultCryptoError();
+        const nonce = wrapped.subarray(0, IV_BYTES);
+        const tag = wrapped.subarray(wrapped.length - TAG_BYTES);
+        const body = wrapped.subarray(IV_BYTES, wrapped.length - TAG_BYTES);
+        const decipher = createDecipheriv("aes-256-gcm", kek, nonce);
+        decipher.setAuthTag(tag);
+        return Buffer.concat([decipher.update(body), decipher.final()]);
+    }
+    catch {
+        throw new VaultCryptoError();
+    }
+}

package/dist/vault/error.d.ts

@@ -0,0 +1,4 @@
+export declare class VaultError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}

package/dist/vault/error.js

@@ -0,0 +1,7 @@
+export class VaultError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}

package/dist/vault/kek.d.ts

@@ -0,0 +1,6 @@
+export declare function defaultKekPath(): string;
+export declare function readVaultKek(options: {
+    vaultKek?: Buffer | string | null;
+    vaultKekPath?: string;
+}): Buffer | undefined;
+export declare function createKekFile(path: string): Buffer;

package/dist/vault/kek.js

@@ -0,0 +1,26 @@
+import { randomBytes } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { parseKek } from "./crypto.js";
+export function defaultKekPath() {
+    return join(process.cwd(), ".nylorun", "vault-kek");
+}
+export function readVaultKek(options) {
+    if (options.vaultKek === null)
+        return undefined;
+    if (options.vaultKek !== undefined)
+        return parseKek(options.vaultKek);
+    const fromEnv = process.env.NYLORUN_VAULT_KEK;
+    if (fromEnv)
+        return parseKek(fromEnv);
+    const path = options.vaultKekPath ?? defaultKekPath();
+    if (!existsSync(path))
+        return undefined;
+    return parseKek(readFileSync(path, "utf8"));
+}
+export function createKekFile(path) {
+    const bytes = randomBytes(32);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${bytes.toString("base64")}\n`, { mode: 0o600 });
+    return bytes;
+}