@claxedo/sandbox-manager 0.5.1

package/dist/index.mjs

@@ -0,0 +1,330 @@
+import { createRequire as __createRequire } from 'module';var require = __createRequire(import.meta.url);
+
+// src/constants.ts
+var DEFAULT_WORKSPACE_RUNTIME_PORT = 2593;
+
+// src/index.ts
+function applySandboxLeasePatch(current, patch, updatedAt) {
+  return {
+    ...current,
+    ...patch.status === void 0 ? {} : { status: patch.status },
+    ...patch.sandboxId === void 0 ? {} : { sandboxId: patch.sandboxId },
+    ...patch.url === void 0 ? {} : { url: patch.url },
+    ...patch.hostId === void 0 ? {} : { hostId: patch.hostId },
+    ...patch.driverResourceId === void 0 ? {} : { driverResourceId: patch.driverResourceId },
+    ...patch.retryCount === void 0 ? {} : { retryCount: patch.retryCount },
+    ...patch.lastHeartbeatAt === void 0 ? {} : { lastHeartbeatAt: patch.lastHeartbeatAt },
+    ...patch.lastActivityAt === void 0 ? {} : { lastActivityAt: patch.lastActivityAt },
+    ...patch.labels === void 0 ? {} : { labels: patch.labels },
+    ...patch.nextRetryAt === void 0 ? {} : { nextRetryAt: patch.nextRetryAt ?? void 0 },
+    ...patch.lastError === void 0 ? {} : { lastError: patch.lastError ?? void 0 },
+    updatedAt
+  };
+}
+var DEFAULT_APP_LABEL = "claxedo";
+function sandboxId(driver, workspaceId) {
+  return `${driver}-${workspaceId}`;
+}
+function ensureHostInput(input) {
+  const labels = {
+    app: input.appLabel,
+    workspaceId: input.workspaceId,
+    epoch: String(input.lease.epoch),
+    homeRegion: input.homeRegion,
+    ...input.managerInput?.labels
+  };
+  return {
+    workspaceId: input.workspaceId,
+    hostId: input.managerInput?.hostId ?? input.lease.hostId ?? sandboxId(input.driver.id, input.workspaceId),
+    homeRegion: input.homeRegion,
+    epoch: input.lease.epoch,
+    labels,
+    bootSource: input.managerInput?.bootSource ?? { kind: "default" },
+    workspaceRoot: input.managerInput?.workspaceRoot ?? "/workspace",
+    runtimeCwd: input.managerInput?.runtimeCwd,
+    workspaceRuntimePort: input.managerInput?.workspaceRuntimePort ?? DEFAULT_WORKSPACE_RUNTIME_PORT,
+    env: input.managerInput?.env ?? {},
+    // Brokered secrets ride their own channel — NEVER merged into labels or env.
+    ...input.managerInput?.secrets?.length ? { secrets: input.managerInput.secrets } : {},
+    source: input.managerInput?.source,
+    exposure: input.managerInput?.exposure ?? (input.driver.metadata.targetAccess === "loopback" ? { kind: "loopback" } : { kind: "relay" }),
+    net: input.managerInput?.net,
+    snapshot: input.managerInput?.snapshot
+  };
+}
+function createSandboxManager(options) {
+  const staleAfterMs = options.staleAfterMs ?? 6e4;
+  const retryAfterMs = options.retryAfterMs ?? 2e3;
+  const now = options.now ?? Date.now;
+  const retryDelayMs = options.retryDelayMs ?? ((retryCount) => Math.min(6e4, 1e3 * 2 ** Math.max(0, retryCount - 1)));
+  const maxRetryCount = options.maxRetryCount ?? Number.POSITIVE_INFINITY;
+  const retryCapCooldownMs = options.retryCapCooldownMs ?? 10 * 6e4;
+  async function leaseTarget(lease) {
+    if (lease.status !== "ready" || !lease.sandboxId || !lease.url || !lease.hostId) {
+      return { status: "unavailable", reason: "runtime_lease_not_ready" };
+    }
+    return {
+      status: "ready",
+      sandboxId: lease.sandboxId,
+      url: lease.url,
+      workspaceId: lease.workspaceId,
+      hostId: lease.hostId,
+      driverResourceId: lease.driverResourceId,
+      labels: lease.labels,
+      driver: {
+        id: lease.driver,
+        resourceId: lease.driverResourceId ?? lease.sandboxId
+      },
+      epoch: lease.epoch,
+      homeRegion: lease.homeRegion
+    };
+  }
+  async function provision(workspaceId, lease, homeRegion, managerInput) {
+    try {
+      const ensure = ensureHostInput({
+        driver: options.driver,
+        workspaceId,
+        homeRegion,
+        lease,
+        managerInput,
+        appLabel: options.appLabel ?? DEFAULT_APP_LABEL
+      });
+      if (ensure.secrets?.length && options.driver.metadata.secretBrokering === "none") {
+        return {
+          status: "unavailable",
+          error: "secret_brokering_unsupported",
+          epoch: lease.epoch,
+          homeRegion
+        };
+      }
+      const target = lease.sandboxId && ensure.bootSource?.kind === "default" && options.driver.resumeHost ? await options.driver.resumeHost({ lease, ensure }) : await options.driver.ensureHost(ensure);
+      if ("provisioning" in target) {
+        await options.leaseStore.update(workspaceId, lease.epoch, {
+          status: "acquiring",
+          nextRetryAt: now() + target.retryAfterMs
+        });
+        return {
+          status: "provisioning",
+          retryAfterMs: target.retryAfterMs,
+          epoch: lease.epoch,
+          homeRegion
+        };
+      }
+      const updated = await options.leaseStore.update(workspaceId, lease.epoch, {
+        status: "ready",
+        sandboxId: target.sandboxId,
+        url: target.url,
+        hostId: target.hostId,
+        driverResourceId: target.driverResourceId,
+        retryCount: 0,
+        nextRetryAt: null,
+        lastError: null,
+        labels: target.labels ?? ensure.labels
+      });
+      const resolved = await leaseTarget(updated ?? lease);
+      if (resolved.status === "ready") return resolved;
+      return {
+        status: "unavailable",
+        error: resolved.reason,
+        epoch: lease.epoch,
+        homeRegion
+      };
+    } catch (err) {
+      const error = err instanceof Error ? err.message : String(err);
+      if (lease.status === "ready") {
+        const updated = await options.leaseStore.update(workspaceId, lease.epoch, { lastError: error });
+        const resolved = await leaseTarget(updated ?? lease);
+        if (resolved.status === "ready") return resolved;
+      }
+      const nextRetryCount = lease.retryCount + 1;
+      const retryCapped = nextRetryCount >= maxRetryCount;
+      const failed = await options.leaseStore.recordFailure(
+        workspaceId,
+        lease.epoch,
+        error,
+        now() + (retryCapped ? retryCapCooldownMs : retryDelayMs(nextRetryCount))
+      );
+      return {
+        status: "unavailable",
+        retryAfterMs: failed?.nextRetryAt ? Math.max(0, failed.nextRetryAt - now()) : retryAfterMs,
+        error,
+        epoch: lease.epoch,
+        homeRegion
+      };
+    }
+  }
+  return {
+    async ensure(workspaceId, input) {
+      const existing = await options.leaseStore.get(workspaceId);
+      if (existing?.nextRetryAt && existing.nextRetryAt > now()) {
+        if (existing.status === "acquiring") {
+          return {
+            status: "provisioning",
+            retryAfterMs: existing.nextRetryAt - now(),
+            epoch: existing.epoch,
+            homeRegion: existing.homeRegion
+          };
+        }
+        return {
+          status: "unavailable",
+          retryAfterMs: existing.nextRetryAt - now(),
+          error: existing.lastError,
+          epoch: existing.epoch,
+          homeRegion: existing.homeRegion
+        };
+      }
+      if (existing?.status === "unavailable" && existing.retryCount >= maxRetryCount && existing.nextRetryAt === void 0) {
+        return {
+          status: "unavailable",
+          error: existing.lastError ?? "runtime_retry_cap_exceeded",
+          epoch: existing.epoch,
+          homeRegion: existing.homeRegion
+        };
+      }
+      if (existing?.status === "ready") {
+        return provision(workspaceId, existing, existing.homeRegion, input);
+      }
+      if (existing?.status === "acquiring" && existing.nextRetryAt !== void 0 && now() - existing.updatedAt < staleAfterMs) {
+        return provision(workspaceId, existing, existing.homeRegion, input);
+      }
+      const acquired = await options.leaseStore.acquire(workspaceId, {
+        homeRegion: input.homeRegion,
+        driver: options.driver.id,
+        staleAfterMs,
+        now: now()
+      });
+      if (!acquired.acquired) {
+        return {
+          status: "provisioning",
+          retryAfterMs: acquired.retryAfterMs,
+          epoch: acquired.lease.epoch,
+          homeRegion: acquired.lease.homeRegion
+        };
+      }
+      return provision(workspaceId, acquired.lease, input.homeRegion, input);
+    },
+    async register(workspaceId, input) {
+      return await updateFromRuntimeSnapshot(workspaceId, input);
+    },
+    async heartbeat(workspaceId, input) {
+      return await updateFromRuntimeSnapshot(workspaceId, input);
+    },
+    async target(workspaceId) {
+      const lease = await options.leaseStore.get(workspaceId);
+      if (!lease) return { status: "unavailable", reason: "runtime_lease_missing" };
+      return leaseTarget(lease);
+    },
+    async touch(workspaceId) {
+      const target = await this.target(workspaceId);
+      if (target.status !== "ready") return { touched: false, status: "missing" };
+      await options.driver.touch?.(target);
+      return { touched: true, status: "ready" };
+    },
+    async snapshot(workspaceId) {
+      const target = await this.target(workspaceId);
+      if (target.status !== "ready") return { ok: false, reason: target.reason };
+      if (!options.driver.snapshot) return { ok: false, reason: "snapshot_unsupported" };
+      return { ok: true, ...await options.driver.snapshot(target) };
+    },
+    async stop(workspaceId) {
+      const target = await this.target(workspaceId);
+      if (target.status !== "ready") return { ok: false, reason: target.reason };
+      if (options.driver.metadata.hostStopBehavior !== "not-supported") {
+        await (options.driver.suspend ?? options.driver.stop)?.(target);
+      } else {
+        await options.driver.stop?.(target);
+      }
+      await options.leaseStore.update(workspaceId, target.epoch, { status: "stopped" });
+      return { ok: true, status: "stopped" };
+    },
+    async destroy(workspaceId) {
+      const target = await this.target(workspaceId);
+      if (target.status !== "ready") return { ok: false, reason: target.reason };
+      await options.driver.destroy?.(target);
+      await options.leaseStore.update(workspaceId, target.epoch, { status: "destroyed" });
+      return { ok: true, status: "destroyed" };
+    },
+    async release(workspaceId) {
+      const lease = await options.leaseStore.get(workspaceId);
+      if (!lease) return { released: false };
+      await options.leaseStore.release(workspaceId);
+      return { released: true };
+    },
+    async garbageCollect() {
+      if (!options.driver.list) {
+        return {
+          destroyed: [],
+          kept: [],
+          skipped: [],
+          failed: []
+        };
+      }
+      const leases = new Map((await options.leaseStore.list()).map((lease) => [lease.workspaceId, lease]));
+      const result = {
+        destroyed: [],
+        kept: [],
+        skipped: [],
+        failed: []
+      };
+      const appLabel = options.appLabel ?? DEFAULT_APP_LABEL;
+      for (const target of await options.driver.list()) {
+        if (target.labels?.app !== appLabel) {
+          result.skipped.push({ target, reason: "unmanaged_app_label" });
+          continue;
+        }
+        const workspaceId = target.labels.workspaceId;
+        const epoch = target.labels.epoch;
+        if (!workspaceId || !epoch) {
+          result.skipped.push({ target, reason: "missing_runtime_labels" });
+          continue;
+        }
+        const lease = leases.get(workspaceId);
+        if (lease?.status === "ready" && String(lease.epoch) === epoch && lease.hostId === target.hostId && lease.sandboxId === target.sandboxId) {
+          result.kept.push(target);
+          continue;
+        }
+        if (lease?.status === "acquiring" && String(lease.epoch) === epoch) {
+          result.kept.push(target);
+          continue;
+        }
+        if (!options.driver.destroy) {
+          result.skipped.push({ target, reason: "destroy_unsupported" });
+          continue;
+        }
+        try {
+          await options.driver.destroy(target);
+          result.destroyed.push(target);
+        } catch (err) {
+          result.failed.push({ target, error: err instanceof Error ? err.message : String(err) });
+        }
+      }
+      return result;
+    },
+    list: () => options.leaseStore.list()
+  };
+  async function updateFromRuntimeSnapshot(workspaceId, input) {
+    const current = await options.leaseStore.get(workspaceId);
+    if (!current) return { ok: false, reason: "runtime_lease_missing" };
+    const expectedEpoch = input.epoch ?? current.epoch;
+    if (current.epoch !== expectedEpoch) return { ok: false, reason: "runtime_lease_epoch_mismatch" };
+    const timestamp = input.now ?? now();
+    const status = input.status === "unhealthy" || input.ok === false ? "unavailable" : input.ok ? "ready" : current.status;
+    const updated = await options.leaseStore.update(workspaceId, expectedEpoch, {
+      status,
+      ...input.sandboxId ? { sandboxId: input.sandboxId } : {},
+      ...input.url ? { url: input.url } : {},
+      ...input.hostId ? { hostId: input.hostId } : input.sandboxId ? { hostId: input.sandboxId } : {},
+      ...input.driverResourceId ? { driverResourceId: input.driverResourceId } : input.sandboxId ? { driverResourceId: input.sandboxId } : {},
+      lastHeartbeatAt: timestamp,
+      ...input.active ? { lastActivityAt: timestamp } : {},
+      ...input.ok ? { lastError: null } : {}
+    });
+    if (!updated) return { ok: false, reason: "runtime_lease_epoch_mismatch" };
+    return { ok: true, status: updated.status };
+  }
+}
+export {
+  DEFAULT_WORKSPACE_RUNTIME_PORT,
+  applySandboxLeasePatch,
+  createSandboxManager
+};

package/dist/lease-policy.d.ts

@@ -0,0 +1,49 @@
+import type { SandboxLeaseRow } from "./lease-types";
+import type { SandboxDriverID } from "./driver-catalog";
+export type SandboxDecision = {
+    action: "skip";
+    reason: string;
+} | {
+    action: "wait";
+    until: number;
+    reason: string;
+} | {
+    action: "resume";
+    reason: string;
+} | {
+    action: "restore_snapshot";
+    snapshot_id: string;
+    reason: string;
+} | {
+    action: "start_prepared";
+    image_id: string;
+    reason: string;
+} | {
+    action: "start_fresh";
+    reason: string;
+} | {
+    action: "stop_idle";
+    reason: string;
+} | {
+    action: "mark_failed";
+    reason: string;
+};
+export type SandboxDecisionConfig = {
+    maxRetries: number;
+    idleMs: number;
+    backoffMaxMs: number;
+    healthTimeoutMs: number;
+};
+export type SandboxDriverPlacement = {
+    canPauseAndRestartSameResource: boolean;
+    canCreateFilesystemSnapshot: boolean;
+    canStartFromPreparedImage: boolean;
+    canStopExplicitly: boolean;
+    hasHealthProbe: boolean;
+};
+export declare const DEFAULT_WORKSPACE_HOST_DECISION_CONFIG: SandboxDecisionConfig;
+export declare function sandboxDriverPlacement(driver: SandboxDriverID): SandboxDriverPlacement;
+export declare function decideSandboxStart(lease: SandboxLeaseRow, placement: SandboxDriverPlacement, now: number, config?: SandboxDecisionConfig): SandboxDecision;
+export declare function decideSandboxHealthFailure(lease: SandboxLeaseRow, _placement: SandboxDriverPlacement, now: number, config?: SandboxDecisionConfig): SandboxDecision;
+export declare function decideSandboxIdle(lease: SandboxLeaseRow, activeHoldCount: number, now: number, config?: SandboxDecisionConfig): SandboxDecision;
+export declare function nextSandboxRetryAt(retryCount: number, now: number, config?: SandboxDecisionConfig): number | null;

package/dist/lease-policy.mjs

@@ -0,0 +1,126 @@
+import { createRequire as __createRequire } from 'module';var require = __createRequire(import.meta.url);
+
+// src/lease-policy.ts
+var DEFAULT_WORKSPACE_HOST_DECISION_CONFIG = {
+  maxRetries: 8,
+  idleMs: 10 * 60 * 1e3,
+  backoffMaxMs: 3e4,
+  healthTimeoutMs: 6e4
+};
+var DRIVER_PLACEMENT = {
+  daytona: {
+    canPauseAndRestartSameResource: true,
+    canCreateFilesystemSnapshot: false,
+    canStartFromPreparedImage: true,
+    canStopExplicitly: true,
+    hasHealthProbe: true
+  },
+  modal: {
+    canPauseAndRestartSameResource: false,
+    canCreateFilesystemSnapshot: true,
+    canStartFromPreparedImage: true,
+    canStopExplicitly: true,
+    hasHealthProbe: true
+  },
+  vercel: {
+    canPauseAndRestartSameResource: false,
+    canCreateFilesystemSnapshot: true,
+    canStartFromPreparedImage: false,
+    canStopExplicitly: true,
+    hasHealthProbe: true
+  },
+  cloudflare: {
+    canPauseAndRestartSameResource: false,
+    canCreateFilesystemSnapshot: true,
+    canStartFromPreparedImage: false,
+    canStopExplicitly: false,
+    hasHealthProbe: true
+  },
+  docker: {
+    canPauseAndRestartSameResource: true,
+    canCreateFilesystemSnapshot: false,
+    canStartFromPreparedImage: true,
+    canStopExplicitly: true,
+    hasHealthProbe: true
+  }
+};
+function sandboxDriverPlacement(driver) {
+  return DRIVER_PLACEMENT[driver];
+}
+function decideSandboxStart(lease, placement, now, config = DEFAULT_WORKSPACE_HOST_DECISION_CONFIG) {
+  if (lease.status === "ready") {
+    return { action: "skip", reason: "already ready" };
+  }
+  if (lease.status === "failed") {
+    return { action: "mark_failed", reason: `terminal failure: ${lease.last_error ?? "unknown"}` };
+  }
+  if (lease.status === "backoff") {
+    if (lease.retry_count >= config.maxRetries) {
+      return { action: "mark_failed", reason: `exceeded max retries (${config.maxRetries})` };
+    }
+    if (lease.next_retry_at && now < lease.next_retry_at) {
+      return { action: "wait", until: lease.next_retry_at, reason: "backoff timer not elapsed" };
+    }
+  }
+  if (lease.status === "acquiring" || lease.status === "starting") {
+    return { action: "skip", reason: `already ${lease.status}` };
+  }
+  return decideStartMethod(lease, placement);
+}
+function decideSandboxHealthFailure(lease, _placement, now, config = DEFAULT_WORKSPACE_HOST_DECISION_CONFIG) {
+  if (lease.status !== "ready" && lease.status !== "unhealthy") {
+    return { action: "skip", reason: `status is ${lease.status}, health check not applicable` };
+  }
+  const retryCount = lease.retry_count + 1;
+  if (retryCount > config.maxRetries) {
+    return { action: "mark_failed", reason: `health failures exceeded max retries (${config.maxRetries})` };
+  }
+  const backoff = Math.min(config.backoffMaxMs, 1e3 * 2 ** Math.max(0, retryCount - 1));
+  return { action: "wait", until: now + backoff, reason: `health failure #${retryCount}, backoff ${backoff}ms` };
+}
+function decideSandboxIdle(lease, activeHoldCount, now, config = DEFAULT_WORKSPACE_HOST_DECISION_CONFIG) {
+  if (lease.status !== "ready") {
+    return { action: "skip", reason: `status is ${lease.status}, not ready` };
+  }
+  if (activeHoldCount > 0) {
+    return { action: "skip", reason: `${activeHoldCount} active hold(s)` };
+  }
+  const lastActivity = lease.last_activity_at ?? lease.created_at;
+  const idleFor = now - lastActivity;
+  if (idleFor < config.idleMs) {
+    return { action: "wait", until: lastActivity + config.idleMs, reason: `idle for ${idleFor}ms, need ${config.idleMs}ms` };
+  }
+  return { action: "stop_idle", reason: `idle for ${idleFor}ms (threshold: ${config.idleMs}ms)` };
+}
+function nextSandboxRetryAt(retryCount, now, config = DEFAULT_WORKSPACE_HOST_DECISION_CONFIG) {
+  if (retryCount >= config.maxRetries) return null;
+  return now + Math.min(config.backoffMaxMs, 1e3 * 2 ** Math.max(0, retryCount));
+}
+function decideStartMethod(lease, placement) {
+  if (lease.sandbox_id && placement.canPauseAndRestartSameResource) {
+    return { action: "resume", reason: `resume sandbox ${lease.sandbox_id}` };
+  }
+  if (lease.accel_snapshot_id && placement.canCreateFilesystemSnapshot) {
+    return {
+      action: "restore_snapshot",
+      snapshot_id: lease.accel_snapshot_id,
+      reason: `restore snapshot ${lease.accel_snapshot_id}`
+    };
+  }
+  if (lease.accel_prepared_image_id && placement.canStartFromPreparedImage) {
+    return {
+      action: "start_prepared",
+      image_id: lease.accel_prepared_image_id,
+      reason: `start from prepared image ${lease.accel_prepared_image_id}`
+    };
+  }
+  return { action: "start_fresh", reason: "no acceleration available, cold start" };
+}
+export {
+  DEFAULT_WORKSPACE_HOST_DECISION_CONFIG,
+  decideSandboxHealthFailure,
+  decideSandboxIdle,
+  decideSandboxStart,
+  nextSandboxRetryAt,
+  sandboxDriverPlacement
+};

package/dist/lease-types.d.ts

@@ -0,0 +1,89 @@
+import type { SandboxDriverID } from "./driver-catalog";
+export type SandboxLeaseRowStatus = "pending" | "acquiring" | "starting" | "ready" | "unhealthy" | "backoff" | "stopping" | "stopped" | "failed";
+export type SandboxComputeClass = "small" | "medium" | "large" | "gpu";
+export type SandboxLeaseRow = {
+    workspace_id: string;
+    lease_id: string;
+    home_region?: string;
+    epoch: number;
+    status: SandboxLeaseRowStatus;
+    driver: SandboxDriverID;
+    driver_resource_id: string | null;
+    driver_snapshot_id: string | null;
+    sandbox_id: string | null;
+    url: string | null;
+    retry_count: number;
+    next_retry_at: number | null;
+    last_heartbeat_at: number | null;
+    last_activity_at: number | null;
+    last_health_failure_at: number | null;
+    last_error: string | null;
+    compute_class: SandboxComputeClass | null;
+    accel_base_image_id: string | null;
+    accel_prepared_image_id: string | null;
+    accel_snapshot_id: string | null;
+    created_at: number;
+    updated_at: number;
+};
+export type SandboxHoldRowOwnerType = "session" | "stream" | "pty" | "process" | "system";
+export type SandboxHoldRow = {
+    hold_id: string;
+    workspace_id: string;
+    owner_type: SandboxHoldRowOwnerType;
+    owner_id: string;
+    reason: string;
+    expires_at: number | null;
+    updated_at: number;
+};
+export type SandboxEpochEnvelope = {
+    workspace_id: string;
+    lease_id: string;
+    epoch: number;
+    sandbox_id: string;
+};
+export type SandboxRowAcquireResult = {
+    lease: SandboxLeaseRow;
+    bumped_epoch: boolean;
+};
+export type SandboxRowHeartbeatResult = {
+    accepted: true;
+} | {
+    accepted: false;
+    reason: "stale_epoch" | "unknown_workspace" | "wrong_lease";
+};
+export type SandboxRowReconnectResult = {
+    accepted: true;
+    lease: SandboxLeaseRow;
+} | {
+    accepted: false;
+    reason: "stale_epoch" | "unknown_workspace" | "wrong_lease" | "wrong_sandbox";
+};
+export type SandboxRowEvent = {
+    type: "lease_acquired";
+    lease: SandboxLeaseRow;
+} | {
+    type: "lease_updated";
+    lease: SandboxLeaseRow;
+    changed: (keyof SandboxLeaseRow)[];
+} | {
+    type: "lease_released";
+    workspace_id: string;
+    reason: string;
+} | {
+    type: "hold_acquired";
+    hold: SandboxHoldRow;
+} | {
+    type: "hold_released";
+    hold_id: string;
+    workspace_id: string;
+} | {
+    type: "epoch_bumped";
+    workspace_id: string;
+    old_epoch: number;
+    new_epoch: number;
+} | {
+    type: "heartbeat_rejected";
+    workspace_id: string;
+    envelope: SandboxEpochEnvelope;
+    reason: string;
+};

package/dist/lease-types.mjs

@@ -0,0 +1 @@
+import { createRequire as __createRequire } from 'module';var require = __createRequire(import.meta.url);

package/dist/runtime-env.d.ts

@@ -0,0 +1,24 @@
+import type { SandboxDriverID } from "./driver-catalog";
+export declare function workspaceRuntimeTargetEnv(input: {
+    workspaceId: string;
+    hostId?: string;
+    directory: string;
+    port: number;
+    host?: string;
+}): Record<string, string>;
+export declare function workspaceRuntimeSourceEnv(input: {
+    source?: {
+        kind: "git";
+        repoUrl: string;
+        branch?: string;
+    } | {
+        kind: "empty";
+    };
+}): Record<string, string>;
+export declare function workspaceRuntimeServiceExposureEnv(input: {
+    driver: SandboxDriverID;
+    source: "driver-service-url";
+    access: "private" | "public" | "driver-authenticated" | "unknown";
+    fallbackAccess?: "private" | "public" | "driver-authenticated" | "unknown";
+    note?: string;
+}): Record<string, string>;

package/dist/runtime-env.mjs

@@ -0,0 +1,35 @@
+import { createRequire as __createRequire } from 'module';var require = __createRequire(import.meta.url);
+
+// src/runtime-env.ts
+function workspaceRuntimeTargetEnv(input) {
+  return {
+    WORKSPACE_RUNTIME_WORKSPACE_ID: input.workspaceId,
+    ...input.hostId ? { WORKSPACE_RUNTIME_HOST_ID: input.hostId } : {},
+    WORKSPACE_RUNTIME_DIRECTORY: input.directory,
+    WORKSPACE_RUNTIME_PORT: String(input.port),
+    ...input.host ? { WORKSPACE_RUNTIME_HOST: input.host } : {}
+  };
+}
+function workspaceRuntimeSourceEnv(input) {
+  if (!input.source || input.source.kind === "empty") return { WORKSPACE_RUNTIME_SOURCE_KIND: "empty" };
+  return {
+    WORKSPACE_RUNTIME_SOURCE_KIND: "git",
+    WORKSPACE_RUNTIME_GIT_REPO_URL: input.source.repoUrl,
+    ...input.source.branch ? { WORKSPACE_RUNTIME_GIT_BRANCH: input.source.branch } : {}
+  };
+}
+function workspaceRuntimeServiceExposureEnv(input) {
+  return {
+    ...input.driver === "docker" ? { WORKSPACE_RUNTIME_HOST: "0.0.0.0" } : {},
+    WORKSPACE_RUNTIME_SERVICE_EXPOSURE_SOURCE: input.source,
+    WORKSPACE_RUNTIME_SERVICE_EXPOSURE_ACCESS: input.access,
+    WORKSPACE_RUNTIME_SERVICE_EXPOSURE_DRIVER: input.driver,
+    ...input.fallbackAccess ? { WORKSPACE_RUNTIME_SERVICE_EXPOSURE_FALLBACK_ACCESS: input.fallbackAccess } : {},
+    ...input.note ? { WORKSPACE_RUNTIME_SERVICE_EXPOSURE_NOTE: input.note } : {}
+  };
+}
+export {
+  workspaceRuntimeServiceExposureEnv,
+  workspaceRuntimeSourceEnv,
+  workspaceRuntimeTargetEnv
+};

package/dist/runtime-version.d.ts

@@ -0,0 +1 @@
+export declare function workspaceRuntimeVersion(): string;

package/dist/runtime-version.mjs

@@ -0,0 +1,24 @@
+import { createRequire as __createRequire } from 'module';var require = __createRequire(import.meta.url);
+
+// src/runtime-version.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var versionCache;
+function workspaceRuntimeVersion() {
+  if (versionCache) return versionCache;
+  const envVersion = process.env.WORKSPACE_RUNTIME_VERSION;
+  if (envVersion) {
+    versionCache = envVersion;
+    return versionCache;
+  }
+  try {
+    versionCache = require2("@claxedo/workspace-runtime/package.json").version;
+    return versionCache;
+  } catch {
+  }
+  versionCache = "0.0.0";
+  return versionCache;
+}
+export {
+  workspaceRuntimeVersion
+};