@yourrealm/sdk 0.0.0-alpha.1414.ca4ff83e → 0.0.0-alpha.1438.ee6bc935

package/dist/chunk-NSZJJPMQ.js

@@ -0,0 +1,641 @@
+import {
+  SPECULATIVE_SILO,
+  hostKey,
+  nameSchema
+} from "./chunk-VHTUSZUX.js";
+
+// src/worker-protocol/worker-state.ts
+import { z as z3 } from "zod";
+
+// src/worker-protocol/backup.ts
+import { z } from "zod";
+var keepSchema = z.object({
+  daily: z.number().int().nonnegative(),
+  weekly: z.number().int().nonnegative(),
+  monthly: z.number().int().nonnegative()
+});
+var hostPathSchema = z.string().regex(/^\.\/apps\/[^/]+\/./, { message: "must be ./apps/<appId>/..." }).refine(
+  (p) => !p.split("/").slice(1).some((seg) => seg === "" || seg === "." || seg === ".."),
+  {
+    message: "must be a normalized path with no empty, . or .. segments"
+  }
+);
+var backupTargetStrategySchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("file-copy"), hostPath: hostPathSchema }),
+  z.object({ kind: z.literal("sqlite"), hostPath: hostPathSchema, file: z.string().min(1) }),
+  // `url` carries the resolved credentials; the Worker passes them to the dump
+  // tool as exec env. `version` is informational: the dump runs with the tool
+  // the database image ships, which always matches its server.
+  z.object({
+    kind: z.literal("pg-dump"),
+    url: z.string().min(1),
+    version: z.number().int().positive()
+  }),
+  z.object({
+    kind: z.literal("mysql-dump"),
+    url: z.string().min(1),
+    version: z.number().int().positive()
+  }),
+  z.object({ kind: z.literal("valkey-save"), url: z.string().min(1) })
+]);
+var backupVolumeSchema = z.string().min(1).refine((v) => !v.includes(","), { message: "must not contain a comma" }).refine((v) => !v.split("/").some((seg) => seg === "" || seg === "." || seg === ".."), {
+  message: "must be a normalized relative path with no empty, . or .. segments"
+});
+var backupTargetSchema = z.object({
+  appId: z.string().min(1),
+  serviceKey: z.string().min(1),
+  volume: backupVolumeSchema,
+  strategy: backupTargetStrategySchema
+}).refine(
+  (t) => !("hostPath" in t.strategy) || t.strategy.hostPath.startsWith(`./apps/${t.appId}/`),
+  {
+    message: "a target's folder must be its own app's",
+    path: ["strategy", "hostPath"]
+  }
+);
+var offsiteSchema = z.object({ enabled: z.literal(true), generation: z.string().min(1) });
+var backupStateSchema = z.object({
+  /** Cron expression. */
+  schedule: z.string().min(1),
+  keep: keepSchema,
+  /** Derived per worker by Home; a worker only ever sees its own. */
+  resticPassword: z.string().min(1),
+  offsite: offsiteSchema.nullable(),
+  /**
+   * Disaster recovery: scheduled and startup runs and offsite copies don't
+   * start, so a rebuilt box writes nothing to the bucket before the operator
+   * has restored from it. Restores and the snapshot listing still run.
+   */
+  hold: z.boolean(),
+  targets: z.array(backupTargetSchema).min(1).refine((ts) => new Set(ts.map((t) => backupTargetKey(t))).size === ts.length, {
+    message: "two targets name the same app, service and volume"
+  })
+}).nullable();
+function backupTargetKey(t) {
+  return `${t.appId}/${t.serviceKey}/${t.volume}`;
+}
+var BACKUP_SAFETY_TAG = "safety";
+var STRATEGY_TAG_PREFIX = "strategy:";
+function backupSnapshotTags(t, kind, safety = false) {
+  return [
+    backupTargetKey(t),
+    `${STRATEGY_TAG_PREFIX}${kind}`,
+    ...safety ? [BACKUP_SAFETY_TAG] : []
+  ];
+}
+function parseBackupSnapshotTags(tags) {
+  let target = null;
+  let kind = null;
+  let safety = false;
+  for (const tag of tags) {
+    if (tag === BACKUP_SAFETY_TAG) {
+      safety = true;
+    } else if (tag.startsWith(STRATEGY_TAG_PREFIX)) {
+      kind = tag.slice(STRATEGY_TAG_PREFIX.length) || null;
+    } else {
+      const m = /^([^/]+)\/([^/]+)\/(.+)$/.exec(tag);
+      if (m !== null) target = { appId: m[1], serviceKey: m[2], volume: m[3] };
+    }
+  }
+  return target === null || kind === null ? null : { ...target, kind, safety };
+}
+var BACKUP_FILE_TYPES = ["config", "data", "index", "keys", "locks", "snapshots"];
+var backupSignRequestSchema = z.object({
+  method: z.enum(["GET", "HEAD", "PUT", "DELETE", "LIST"]),
+  type: z.enum(BACKUP_FILE_TYPES),
+  /** The file's name. Absent for `config` and `LIST`. */
+  name: z.string().min(1).optional(),
+  /** Lowercase hex SHA-256 of a `PUT` body, which the signature covers. */
+  sha256: z.string().min(1).optional(),
+  /** Byte length of a `PUT` body. */
+  length: z.number().int().nonnegative().optional(),
+  /** A `LIST` page's `NextContinuationToken`. */
+  continuation: z.string().min(1).optional(),
+  /**
+   * `offsite.generation` from the state the run started with. Home refuses
+   * (409) one that isn't the bucket's current generation.
+   */
+  generation: z.string().min(1)
+});
+var BACKUP_STALE_GENERATION = "the bucket changed since this run started";
+var BACKUP_FILE_EXISTS = "the file is already in the bucket";
+var backupSignResultSchema = z.object({
+  url: z.string().min(1),
+  headers: z.record(z.string(), z.string())
+});
+var outcomeSchema = z.enum(["ok", "failed", "skipped"]);
+var targetStatusSchema = z.object({
+  appId: z.string(),
+  serviceKey: z.string(),
+  volume: z.string(),
+  kind: z.string(),
+  /** ISO-8601 of the attempt that settled this outcome. */
+  at: z.string(),
+  outcome: outcomeSchema,
+  /** Why it failed or was skipped. Absent on `ok`. */
+  error: z.string().optional(),
+  /** Attempts in that run; above 1 means the startup retry ran. */
+  attempts: z.number()
+});
+var repoStatusBase = {
+  at: z.string(),
+  outcome: outcomeSchema,
+  error: z.string().optional()
+};
+var repoStatusSchema = z.discriminatedUnion("repo", [
+  z.object({ repo: z.literal("local"), ...repoStatusBase }),
+  z.object({
+    repo: z.literal("offsite"),
+    ...repoStatusBase,
+    /** `offsite.generation` the copy ran against; null if it never got one. */
+    generation: z.string().nullable()
+  })
+]);
+var SNAPSHOT_ID_RE = /^[0-9a-f]{64}$/;
+var snapshotSchema = z.object({
+  /**
+   * restic's full id, not `short_id`. A local snapshot and its offsite copy
+   * have different ids; a restore names one of these exact strings.
+   */
+  id: z.string().regex(SNAPSHOT_ID_RE),
+  time: z.string(),
+  /** Taken by a restore just before it touched anything. */
+  safety: z.boolean()
+});
+var snapshotGroupSchema = z.object({
+  appId: z.string(),
+  serviceKey: z.string(),
+  volume: z.string(),
+  /** The strategy, from the `strategy:` tag. */
+  kind: z.string(),
+  local: z.array(snapshotSchema),
+  /** Null when offsite isn't set up, or its listing failed (see `repos`). */
+  offsite: z.array(snapshotSchema).nullable()
+});
+var restoreSourceSchema = z.enum(["local", "offsite"]);
+var restoreItemSchema = z.object({
+  serviceKey: z.string().min(1),
+  volume: backupVolumeSchema,
+  snapshotId: z.string().regex(SNAPSHOT_ID_RE),
+  source: restoreSourceSchema
+});
+var backupRestoreRequestSchema = z.object({
+  restoreId: z.uuid(),
+  appId: z.string().min(1),
+  items: z.array(restoreItemSchema).min(1).refine(
+    (items) => new Set(items.map((i) => `${i.serviceKey}/${i.volume}`)).size === items.length,
+    { message: "a volume is named twice" }
+  )
+});
+var BACKUP_RESTORE_PHASES = [
+  "queued",
+  "safety",
+  "stopping",
+  "restoring",
+  "starting",
+  "done",
+  "failed"
+];
+var BACKUP_RESTORE_INTERRUPTED = "the Worker restarted during the restore";
+var restoreSchema = z.object({
+  restoreId: z.string(),
+  appId: z.string(),
+  startedAt: z.string(),
+  finishedAt: z.string().nullable(),
+  phase: z.enum(BACKUP_RESTORE_PHASES),
+  items: z.array(
+    restoreItemSchema.extend({
+      outcome: z.enum(["pending", "ok", "failed"]),
+      error: z.string().optional()
+    })
+  ),
+  /** It failed, and the safety snapshot was put back. */
+  rolledBack: z.boolean(),
+  /** What happened, when it failed. */
+  error: z.string().nullable()
+});
+var backupStatusSchema = z.object({
+  /** ISO-8601 by the Worker's clock when it sent this, for Home to measure drift. */
+  sentAt: z.iso.datetime(),
+  offsiteConfigured: z.boolean(),
+  schedule: z.string(),
+  retention: keepSchema,
+  /** A run is in progress right now. */
+  running: z.boolean(),
+  /** ISO-8601, null before the first run settles. */
+  lastRunAt: z.string().nullable(),
+  nextRunAt: z.string().nullable(),
+  /** The schedule doesn't parse, so only the startup run happens. */
+  scheduleError: z.string().nullable(),
+  /** The last run stopped before reaching any target (an unreadable config, say). */
+  runError: z.string().nullable(),
+  targets: z.array(targetStatusSchema),
+  repos: z.array(repoStatusSchema),
+  snapshots: z.array(snapshotGroupSchema),
+  /**
+   * ISO-8601 by the Worker's clock of its last successful listing of the
+   * bucket, by a run or a read-only refresh. Null with no bucket, or before
+   * the first listing that worked: `snapshots[].offsite` says nothing until
+   * this is set.
+   */
+  offsiteListedAt: z.string().nullable(),
+  /**
+   * Apps a restore left stopped on data Realm can't vouch for - a rollback
+   * failed, or a dropped database could not be put back. Nothing starts one
+   * until an admin releases it (`backup.release`) or a later restore of it
+   * finishes. An app is otherwise held only while its restore runs, which
+   * `restores` already shows.
+   */
+  held: z.array(z.object({ appId: z.string(), restoreId: z.string(), reason: z.string() })),
+  /** The latest restore of each app that has had one since the Worker started. */
+  restores: z.array(restoreSchema)
+});
+
+// src/worker-protocol/ingress.ts
+import { z as z2 } from "zod";
+var acmeIssuerSchema = z2.object({
+  serverUrl: z2.string(),
+  username: z2.string(),
+  apiKey: z2.string(),
+  ca: z2.string(),
+  caRootPem: z2.string()
+});
+var ingressRouterSchema = z2.object({
+  containerPort: z2.number().int().min(1).max(65535),
+  /** Operator-granted hostnames for the additional ungated public route. */
+  publicDomain: z2.union([z2.string(), z2.array(z2.string())]).optional(),
+  /** With several granted hosts: serve them all, or serve one and 301 the rest. */
+  domainMode: z2.enum(["redirect", "all"]),
+  pathPrefix: z2.string().regex(/^\/[a-zA-Z0-9/_-]*$/, "pathPrefix must start with / and contain only [a-zA-Z0-9/_-]").optional(),
+  compress: z2.boolean(),
+  maxRequestSizeMb: z2.number().nullable(),
+  rateLimit: z2.union([
+    z2.number(),
+    z2.object({
+      requests: z2.number(),
+      window: z2.string().regex(/^\d+(ms|s|m|h)$/, "window must be a duration like 10s, 1m, 1h")
+    })
+  ]).nullable(),
+  /** Response-header overrides; `null` deletes the renderer's default. */
+  headers: z2.record(z2.string(), z2.string().nullable()).optional()
+});
+var ingressRoutedAppSchema = z2.object({
+  appId: z2.string(),
+  services: z2.array(z2.object({ serviceId: z2.string(), router: ingressRouterSchema })),
+  /**
+   * Header-brokering names the app declared via `getTrustedHeaders`. The
+   * renderer injects these on the authenticated route (lifted off the
+   * forward-auth response) and strips them everywhere else, so identity can't
+   * be spoofed.
+   */
+  trustedHeaderKeys: z2.array(z2.string()).optional()
+});
+var ingressInputSchema = z2.object({
+  /** Every routed service on this worker, ordered canonically by `appId`. */
+  routedApps: z2.array(ingressRoutedAppSchema),
+  /**
+   * The Home dashboard's own host, `{homeSlug}.{workerId}.{baseDomain}` - one
+   * label under the worker wildcard, which a renderer has to match ahead of
+   * that wildcard so the not-routed holding page never shadows it.
+   *
+   * Null on a box that does not run Home. The name resolves realm-wide (it
+   * sits under the realm's wildcard), so emitting the route on a worker-only
+   * box would answer a hit there with a page claiming the control plane is
+   * down - and, under BYO public providers, cost a real per-host certificate
+   * on every worker. Home knows which box is which from `home_state
+   * .home_worker_id`.
+   */
+  dashboardHost: z2.string().nullable(),
+  /**
+   * This worker's short slug: the `{workerId}` level of every app subdomain,
+   * and the label it owns under acme-dns.
+   */
+  workerId: z2.string(),
+  /**
+   * The realm's domain base (`{slug}.yourrealm.me`, or the operator's own).
+   * With `workerId` it forms every structured authenticated subdomain. Empty
+   * on the placeholder identity, before an install is configured.
+   */
+  baseDomain: z2.string(),
+  /** DNS-01 inputs for the worker wildcard, or null (dev / e2e / first boot). */
+  acmeDns: acmeIssuerSchema.extend({ baseDomain: z2.string() }).nullable(),
+  /**
+   * BYO public-DNS providers, in issue order. `apiToken` is a plain string:
+   * a `Ref` cannot ride the wire, and by this point Home has resolved it.
+   */
+  publicProviders: z2.array(
+    z2.object({ name: z2.enum(["cloudflare", "hetzner"]), apiToken: z2.string() })
+  ),
+  /**
+   * CDNs in front of this realm, whose edge addresses ingress trusts when
+   * resolving the real client IP. The addresses themselves are not here - the
+   * renderer's runtime fetches and refreshes them.
+   */
+  cdnProviders: z2.array(z2.string()),
+  /**
+   * The signing-certificate fingerprints in the Digital Asset Links statement
+   * the ingress serves on every host - the statement's
+   * `sha256_cert_fingerprints`, which Chrome matches the companion APK's own
+   * signature against before it drops the Trusted Web Activity's toolbar.
+   *
+   * Operator-set rather than a constant, because which certificate signs the
+   * installed APK is a property of how that operator got it: Play App Signing
+   * re-signs with Google's key, direct distribution keeps the release
+   * keystore's, and a locally built debug APK carries a third.
+   *
+   * The shape is pinned here because the renderer inlines these strings into a
+   * JSON body Caddy's `ReplaceKnown` walks: uppercase hex bytes and colons can
+   * never form a `{placeholder}`, so a value that parses cannot reach into the
+   * replacer.
+   */
+  companionFingerprints: z2.array(
+    z2.string().regex(/^[0-9A-F]{2}(:[0-9A-F]{2}){31}$/, "expected 32 colon-separated uppercase hex bytes")
+  )
+});
+var PLATFORM_INGRESS_PORTS = [80, 443];
+
+// src/worker-protocol/worker-state.ts
+var dependsOnEdgeSchema = z3.object({
+  providerAppId: z3.string(),
+  providerServiceName: z3.string(),
+  condition: z3.enum(["started", "healthy"])
+});
+var duration = z3.number().int().nonnegative();
+var containerPort = z3.number().int().min(1).max(65535);
+var healthcheckSchema = z3.object({
+  test: z3.array(z3.string()),
+  interval: duration,
+  timeout: duration,
+  retries: z3.number().int().nonnegative(),
+  startPeriod: duration
+});
+var hostPortSchema = z3.object({
+  containerPort,
+  hostPort: z3.number().int().min(1).max(65535),
+  protocol: z3.enum(["tcp", "udp"]).optional()
+});
+var backupStrategySchema = z3.discriminatedUnion("kind", [
+  z3.object({ kind: z3.literal("file-copy") }),
+  z3.object({ kind: z3.literal("sqlite"), file: z3.string() }),
+  z3.object({ kind: z3.literal("pg-dump"), url: z3.string(), version: z3.number().int().positive() }),
+  z3.object({ kind: z3.literal("valkey-save"), url: z3.string() }),
+  z3.object({
+    kind: z3.literal("mysql-dump"),
+    url: z3.string(),
+    version: z3.number().int().positive()
+  })
+]);
+var volumeSchema = z3.object({
+  // Refused by name: the wire is where "this was fully resolved" stops being a
+  // promise and becomes a check. A speculative eval fabricates a Silo so an app
+  // can be previewed before the operator picks one (`speculative-silo.ts`), and
+  // that placeholder is otherwise an ordinary absolute path - shipping it binds
+  // an empty directory in place of the operator's library, silently. `evalApps`
+  // refuses that combination up front; this is the half that cannot be bypassed.
+  hostPath: z3.string().refine((p) => p !== SPECULATIVE_SILO.hostPath, {
+    message: "the speculative Silo placeholder must never reach the wire"
+  }),
+  containerPath: z3.string(),
+  // The Silo group that owns this directory. The renderer turns it into
+  // `group_add` on every service that mounts the volume, so directory
+  // preparation and group membership are driven by the same field and can
+  // never disagree.
+  gid: z3.number().int().positive().optional(),
+  readOnly: z3.boolean().optional(),
+  backup: z3.union([backupStrategySchema, z3.literal(false)]).optional()
+});
+var wireServiceSchema = z3.object({
+  image: z3.string().min(1),
+  hostPorts: z3.array(hostPortSchema).optional(),
+  env: z3.record(z3.string(), z3.union([z3.string(), z3.number()])).optional(),
+  // containerPath -> 64-char hex digest the renderer resolves to bytes. The two
+  // sources hash different things: artifact refs collapse to their bare content
+  // sha, while inline content is keyed by *identity* — sha256 of
+  // `appId:serviceKey:fileKey` (plaintext rides in `WorkerApp.inlineFiles`). An
+  // inline file therefore keeps the same digest and worker path across content
+  // changes, so `--watch` consumers reload without recreating the container.
+  files: z3.record(z3.string().startsWith("/"), z3.string().regex(/^[a-f0-9]{64}$/)).optional(),
+  command: z3.array(z3.string()).optional(),
+  volumes: z3.array(volumeSchema).optional(),
+  gpu: z3.boolean().optional(),
+  iptables: z3.boolean().optional(),
+  joinNetworks: z3.array(z3.string()).optional(),
+  healthcheck: healthcheckSchema.optional(),
+  memory: z3.string().optional(),
+  cpu: z3.number().positive().max(128).optional(),
+  // Defaulted to 1 upstream, so always present on the wire.
+  replicas: z3.number().int().min(1).max(100),
+  labels: z3.array(z3.string()).optional(),
+  shmSizeMb: z3.number().int().positive().optional()
+});
+var workerAppSchema = z3.object({
+  appId: z3.string(),
+  // Flattened: in the resolve model these live under `.state` (matching
+  // `getDesiredState`'s shape), but on the wire only these two of that
+  // object's fields survive, so they're hoisted onto the app directly.
+  services: z3.record(nameSchema, wireServiceSchema),
+  /** `true` makes the per-app network `internal: true` (no egress). */
+  egress: z3.literal(true).optional(),
+  /** Worker-owned external nets this app's services join (e.g. `management-net`). */
+  externalNetworks: z3.array(z3.string()),
+  /**
+   * Service-name (unprefixed) -> producer edges. The renderer namespaces
+   * `providerServiceName` with `providerAppId` to form the final compose key.
+   */
+  dependsOn: z3.record(z3.string(), z3.array(dependsOnEdgeSchema)),
+  /** Plaintext for inline `files` entries, keyed by their identity digest. */
+  inlineFiles: z3.record(z3.string(), z3.string()),
+  /**
+   * Absolute host paths exempted from the absolute-mount gate and
+   * bound verbatim by the renderer (peer backup volumes, the logs socket).
+   */
+  allowedAbsoluteHostPaths: z3.array(z3.string()),
+  /**
+   * Host path the worker binds this app's `home-proxy.sock` at. Present only
+   * when the app holds a `home.apiAccess` grant.
+   */
+  homeProxySocketPath: z3.string().optional(),
+  /**
+   * Host path the worker binds this app's spawn broker socket at. Present
+   * only when the app holds a `host.spawn` grant.
+   */
+  spawnSocketPath: z3.string().optional(),
+  /**
+   * This app's registry credentials, keyed by registry host. The worker
+   * renders a per-app docker `config.json` from these so private images pull.
+   */
+  registryAuth: z3.record(hostKey, z3.object({ username: z3.string(), password: z3.string() })).optional()
+});
+var workerStateSchema = z3.object({
+  apps: z3.array(workerAppSchema),
+  /** SHAs of every artifact the worker keeps in `files/` after a reconcile. */
+  artifactHashes: z3.array(z3.string()),
+  /** Docker networks the worker container itself joins this reconcile. */
+  workerNetworks: z3.array(z3.string()),
+  /**
+   * Where traffic goes on this box, as `apps` says what runs on it. Runtime-
+   * neutral: the Docker worker renders it with `buildCaddyConfig`
+   * (`runtime/docker/ingress`) exactly as it renders `apps` with
+   * `convertToDockerCompose`.
+   *
+   * Required, not optional. Every producer can state an honest value - an
+   * unconfigured box gets the empty-identity placeholder, which is a real
+   * answer ("no domain yet") rather than a missing one - and a box with no
+   * schedulable app still needs a front door, so absence must never be a legal
+   * way to say "no ingress here".
+   */
+  ingress: ingressInputSchema,
+  /**
+   * What this box backs up, and where to. Null when nothing on it has a backup
+   * strategy - required-nullable like `ingress`, so "no backup here" is a
+   * stated answer. The Docker worker runs it in-process on its cron.
+   */
+  backup: backupStateSchema
+});
+
+// src/worker-protocol/node-version.ts
+import { z as z4 } from "zod";
+var nodeVersionSchema = z4.object({
+  // The pinned ref this container runs: `benjick/realm-worker@sha256:…` for a
+  // pulled image, a bare image ID for a locally-loaded one (see the installer's
+  // pin_image). This is the string an `applied` audit entry matches against.
+  imageRef: z4.string().nullable(),
+  // The commit the image was built from - a full SHA from the publish workflow,
+  // null for anything built outside it.
+  gitHash: z4.string().nullable(),
+  // ISO-8601 build timestamp, read back off the image's OCI `created` label by
+  // the publish workflow so the reported date and the image's own can't drift.
+  buildDate: z4.string().nullable()
+});
+function readEnv(name) {
+  const value = Deno.env.get(name);
+  return value === void 0 || value === "" ? null : value;
+}
+function readNodeVersion() {
+  return {
+    imageRef: readEnv("REALM_IMAGE_REF"),
+    gitHash: readEnv("REALM_GIT_HASH"),
+    buildDate: readEnv("REALM_BUILD_DATE")
+  };
+}
+function shortNodeVersion(version) {
+  if (version.gitHash) return version.gitHash.slice(0, 7);
+  const digest = version.imageRef?.split("sha256:")[1];
+  return digest ? digest.slice(0, 12) : null;
+}
+
+// src/worker-protocol/update-files.ts
+var UPDATE_ERROR_MAX_CHARS = 2048;
+var MAX_ERROR_FILE_BYTES = 16 * 1024;
+async function readUpdateFiles(dir) {
+  const [pending, error] = await Promise.all([
+    isFile(`${dir}/.update`),
+    readError(`${dir}/.update.error`)
+  ]);
+  return { pending, error };
+}
+async function isFile(path) {
+  try {
+    return (await Deno.stat(path)).isFile;
+  } catch {
+    return false;
+  }
+}
+async function readError(path) {
+  let text;
+  try {
+    const stat = await Deno.stat(path);
+    if (!stat.isFile || stat.size > MAX_ERROR_FILE_BYTES) return null;
+    text = await Deno.readTextFile(path);
+  } catch {
+    return null;
+  }
+  const trimmed = text.trim();
+  if (trimmed === "") return null;
+  return trimmed.length > UPDATE_ERROR_MAX_CHARS ? trimmed.slice(-UPDATE_ERROR_MAX_CHARS) : trimmed;
+}
+
+// src/worker-protocol/app-dirs.ts
+var REALM_APP_DIR_GID = 999999;
+function isPreparedAppDir(appId, volume, exemptHostPaths) {
+  if (volume.gid !== void 0) return false;
+  if (exemptHostPaths.has(volume.hostPath)) return false;
+  if (!volume.hostPath.startsWith("./")) return false;
+  return scopeBindSource(volume.hostPath, appId) !== `./apps/${appId}`;
+}
+function scopeBindSource(source, appId) {
+  if (!source.startsWith("./")) return source;
+  const scoped = `./apps/${appId}/${source.slice(2)}`;
+  const segments = scoped.split("/");
+  const resolved = [];
+  for (const seg of segments) {
+    if (seg === "..") resolved.pop();
+    else if (seg !== "." && seg !== "") resolved.push(seg);
+  }
+  const normalized = "./" + resolved.join("/");
+  if (!normalized.startsWith(`./apps/${appId}/`) && normalized !== `./apps/${appId}`) {
+    throw new Error(`bind source escapes app directory: ${source}`);
+  }
+  return normalized;
+}
+
+// src/worker-protocol/silo-paths.ts
+var REALM_SILO_DIR = "/opt/realm/worker/silo";
+function managedSiloPath(id) {
+  return `${REALM_SILO_DIR}/${id}`;
+}
+function isManagedSiloPath(hostPath) {
+  return hostPath.startsWith(`${REALM_SILO_DIR}/`);
+}
+function shellQuote(path) {
+  return `'${path.replaceAll("'", "'\\''")}'`;
+}
+function siloSetupCommand(silo) {
+  const path = shellQuote(silo.hostPath);
+  return `chgrp -R ${silo.gid} ${path}
+chmod g+rwxs ${path}`;
+}
+function siloWidenCommand(silo) {
+  return `find ${shellQuote(silo.hostPath)} -type d -exec chmod g+rwxs {} +`;
+}
+function siloReclaimCommand(orphan) {
+  return `ssh root@${orphan.workerIp}
+rm -rf ${shellQuote(orphan.hostPath)}`;
+}
+
+export {
+  backupVolumeSchema,
+  backupStateSchema,
+  backupTargetKey,
+  BACKUP_SAFETY_TAG,
+  backupSnapshotTags,
+  parseBackupSnapshotTags,
+  BACKUP_FILE_TYPES,
+  backupSignRequestSchema,
+  BACKUP_STALE_GENERATION,
+  BACKUP_FILE_EXISTS,
+  backupSignResultSchema,
+  backupRestoreRequestSchema,
+  BACKUP_RESTORE_PHASES,
+  BACKUP_RESTORE_INTERRUPTED,
+  backupStatusSchema,
+  ingressInputSchema,
+  PLATFORM_INGRESS_PORTS,
+  dependsOnEdgeSchema,
+  wireServiceSchema,
+  workerAppSchema,
+  workerStateSchema,
+  nodeVersionSchema,
+  readNodeVersion,
+  shortNodeVersion,
+  readUpdateFiles,
+  REALM_APP_DIR_GID,
+  isPreparedAppDir,
+  scopeBindSource,
+  REALM_SILO_DIR,
+  managedSiloPath,
+  isManagedSiloPath,
+  siloSetupCommand,
+  siloWidenCommand,
+  siloReclaimCommand
+};