@yourrealm/sdk 0.0.0-alpha.1378.ce03c8dc

package/dist/chunk-VHTUSZUX.js

@@ -0,0 +1,176 @@
+// src/identifiers.ts
+import { z } from "zod";
+var nameSchema = z.string().regex(
+  /^[a-z][a-z0-9-]*$/,
+  "Must be lowercase alphanumeric with hyphens, starting with a letter"
+);
+var domainSchema = z.string().regex(/^[a-zA-Z0-9.*-]+$/, "Invalid domain name");
+var hostKey = z.string().regex(/^[a-zA-Z0-9.-]+(:[0-9]+)?$/, "Invalid registry host");
+var networkSchema = z.string().brand();
+
+// src/worker-protocol/logs-socket-path.ts
+var REALM_LOGS_DIR = "/opt/realm/worker/logs";
+var REALM_LOGS_SOCKET = `${REALM_LOGS_DIR}/logs.sock`;
+var REALM_LOGS_MOUNT = {
+  hostPath: REALM_LOGS_DIR,
+  containerPath: "/run/realm/logs",
+  readOnly: true
+};
+
+// src/worker-protocol/stats-socket-path.ts
+var REALM_STATS_DIR = "/opt/realm/worker/stats";
+var REALM_STATS_SOCKET = `${REALM_STATS_DIR}/stats.sock`;
+var REALM_STATS_MOUNT = {
+  hostPath: REALM_STATS_DIR,
+  containerPath: "/run/realm/stats",
+  readOnly: true
+};
+
+// src/worker-protocol/spawn-paths.ts
+var REALM_SPAWN_DIR = "/opt/realm/worker/spawn";
+function spawnSocketDir(appId) {
+  return `${REALM_SPAWN_DIR}/sock/${appId}`;
+}
+function spawnSocketPath(appId) {
+  return `${spawnSocketDir(appId)}/spawn.sock`;
+}
+function spawnScratchPath(appId) {
+  return `${REALM_SPAWN_DIR}/data/${appId}/scratch`;
+}
+function spawnArtifactsPath(appId) {
+  return `${REALM_SPAWN_DIR}/data/${appId}/artifacts`;
+}
+function spawnMounts(appId) {
+  return {
+    socket: {
+      hostPath: spawnSocketDir(appId),
+      containerPath: "/run/realm/spawn-sock",
+      readOnly: true
+    },
+    scratch: {
+      hostPath: spawnScratchPath(appId),
+      containerPath: "/run/realm/spawn",
+      readOnly: false
+    },
+    artifacts: {
+      hostPath: spawnArtifactsPath(appId),
+      containerPath: "/run/realm/artifacts",
+      readOnly: false
+    }
+  };
+}
+var UNFILLED = spawnMounts("");
+var blank = (m) => ({ ...m, hostPath: "" });
+var SPAWN_PLACEHOLDER = {
+  socket: blank(UNFILLED.socket),
+  scratch: blank(UNFILLED.scratch),
+  artifacts: blank(UNFILLED.artifacts)
+};
+
+// src/worker-protocol/networks.ts
+var MANAGEMENT_NET = "management-net";
+var UNTRUSTED_NET = "untrusted-net";
+var SILO_NET_PREFIX = "realm_silo_";
+function siloNetwork(siloId) {
+  return `${SILO_NET_PREFIX}${siloId}`;
+}
+function isSiloNetwork(name) {
+  return name.startsWith(SILO_NET_PREFIX);
+}
+
+// src/worker-protocol/home-proxy-paths.ts
+var REALM_HOME_PROXY_DIR = "/opt/realm/worker/home-proxy";
+function homeProxyAppDir(appId) {
+  return `${REALM_HOME_PROXY_DIR}/${appId}`;
+}
+function homeProxySocketPath(appId) {
+  return `${homeProxyAppDir(appId)}/home-proxy.sock`;
+}
+var REALM_HOME_PROXY_CONTAINER_DIR = "/run/realm/home-proxy";
+var REALM_HOME_PROXY_CONTAINER_PATH = `${REALM_HOME_PROXY_CONTAINER_DIR}/home-proxy.sock`;
+function homeProxyMount(appId) {
+  return {
+    hostPath: homeProxyAppDir(appId),
+    containerPath: REALM_HOME_PROXY_CONTAINER_DIR,
+    readOnly: true
+  };
+}
+
+// src/speculative-silo.ts
+var SPECULATIVE_SILO = {
+  id: "speculative",
+  hostPath: "/speculative-silo",
+  containerPath: "/silo",
+  /**
+   * The volume schema requires a positive gid, so this cannot be 0. Home draws
+   * real Silo gids from a counter starting at 1,000,000 (`home_state.next_gid`),
+   * so anything below that floor can never name a group an operator has.
+   */
+  gid: 999999,
+  /**
+   * Shape-faithful on purpose: 64 hex characters, the same as a derived key.
+   * A recognisable sentinel would look safer and behave worse - an app that
+   * validates its Silo key (`z.string().length(64)`, or a bare truthiness
+   * check) would drop out of its own preview, which is the exact failure this
+   * whole module exists to prevent.
+   */
+  apiKey: "0".repeat(64)
+};
+function speculativeSilo(asked) {
+  const resolved = {};
+  if (asked.network !== void 0) {
+    resolved.network = siloNetwork(SPECULATIVE_SILO.id);
+    if (asked.network !== true) {
+      const services = {};
+      for (const [name, port] of Object.entries(asked.network)) {
+        services[name] = { host: name, port };
+      }
+      resolved.services = services;
+    }
+  }
+  if (asked.volume !== void 0) {
+    resolved.volume = {
+      hostPath: SPECULATIVE_SILO.hostPath,
+      containerPath: SPECULATIVE_SILO.containerPath,
+      gid: SPECULATIVE_SILO.gid,
+      // The author declared the mode and the placeholder honours it: the shape
+      // an app sees must not change with the mode of the eval.
+      readOnly: asked.volume === "read",
+      backup: false
+    };
+  }
+  if (asked.apiKey !== void 0) {
+    resolved.apiKey = SPECULATIVE_SILO.apiKey;
+  }
+  return resolved;
+}
+
+export {
+  nameSchema,
+  hostKey,
+  REALM_LOGS_DIR,
+  REALM_LOGS_SOCKET,
+  REALM_LOGS_MOUNT,
+  REALM_STATS_DIR,
+  REALM_STATS_SOCKET,
+  REALM_STATS_MOUNT,
+  REALM_SPAWN_DIR,
+  spawnSocketDir,
+  spawnSocketPath,
+  spawnScratchPath,
+  spawnArtifactsPath,
+  spawnMounts,
+  SPAWN_PLACEHOLDER,
+  MANAGEMENT_NET,
+  UNTRUSTED_NET,
+  SILO_NET_PREFIX,
+  siloNetwork,
+  isSiloNetwork,
+  SPECULATIVE_SILO,
+  speculativeSilo,
+  REALM_HOME_PROXY_DIR,
+  homeProxyAppDir,
+  homeProxySocketPath,
+  REALM_HOME_PROXY_CONTAINER_PATH,
+  homeProxyMount
+};