@claxedo/sandbox-manager 0.9.0 → 0.10.1

package/dist/hosted-network-policy.mjs

@@ -1,3 +1,220 @@
+// ../sandbox-contract/dist/index.mjs
+function ipv4Number(part) {
+  let value;
+  if (/^0[xX][0-9a-fA-F]+$/.test(part))
+    value = Number.parseInt(part.slice(2), 16);
+  else if (/^0[0-7]+$/.test(part))
+    value = Number.parseInt(part.slice(1), 8);
+  else if (/^\d+$/.test(part))
+    value = Number.parseInt(part, 10);
+  else
+    return;
+  return Number.isSafeInteger(value) ? value : void 0;
+}
+function parseIpv4(input) {
+  const parts = input.split(".");
+  if (parts.length > 1 && parts[parts.length - 1] === "")
+    parts.pop();
+  if (parts.length < 1 || parts.length > 4)
+    return;
+  const numbers = [];
+  for (const part of parts) {
+    const value = ipv4Number(part);
+    if (value === void 0)
+      return;
+    numbers.push(value);
+  }
+  const last = numbers[numbers.length - 1];
+  if (last >= 256 ** (5 - numbers.length))
+    return;
+  for (const value of numbers.slice(0, -1))
+    if (value > 255)
+      return;
+  let address = last;
+  for (let i = 0; i < numbers.length - 1; i++)
+    address += numbers[i] * 256 ** (3 - i);
+  return address >>> 0;
+}
+function hextet(part) {
+  return /^[0-9a-fA-F]{1,4}$/.test(part) ? Number.parseInt(part, 16) : void 0;
+}
+function embeddedQuad(input) {
+  const parts = input.split(".");
+  if (parts.length !== 4)
+    return;
+  const octets = [];
+  for (const part of parts) {
+    if (!/^\d{1,3}$/.test(part))
+      return;
+    const value = Number.parseInt(part, 10);
+    if (value > 255)
+      return;
+    octets.push(value);
+  }
+  return octets;
+}
+function parseIpv6(input) {
+  let body = input;
+  let tail;
+  const lastColon = body.lastIndexOf(":");
+  if (lastColon >= 0 && body.includes(".")) {
+    tail = embeddedQuad(body.slice(lastColon + 1));
+    if (!tail)
+      return;
+    body = body.slice(0, lastColon + 1) + "0:0";
+  }
+  if ((body.match(/::/g) ?? []).length > 1)
+    return;
+  let halves;
+  if (body.includes("::")) {
+    const [left = "", right = ""] = body.split("::");
+    const leftParts = left === "" ? [] : left.split(":");
+    const rightParts = right === "" ? [] : right.split(":");
+    const missing = 8 - leftParts.length - rightParts.length;
+    if (missing < 1)
+      return;
+    halves = [...leftParts, ...Array.from({ length: missing }, () => "0"), ...rightParts];
+  } else {
+    halves = body.split(":");
+    if (halves.length !== 8)
+      return;
+  }
+  if (halves.length !== 8)
+    return;
+  const segments = [];
+  for (const part of halves) {
+    const value = hextet(part);
+    if (value === void 0)
+      return;
+    segments.push(value);
+  }
+  if (tail) {
+    segments[6] = tail[0] * 256 + tail[1];
+    segments[7] = tail[2] * 256 + tail[3];
+  }
+  return segments;
+}
+function parseIpAddress(input) {
+  if (!input)
+    return;
+  let host = input.trim().toLowerCase();
+  if (host.startsWith("[") && host.endsWith("]") && host.includes(":"))
+    host = host.slice(1, -1);
+  if (host.includes(":")) {
+    const segments = parseIpv6(host);
+    return segments ? { kind: "v6", segments } : void 0;
+  }
+  const value = parseIpv4(host);
+  return value === void 0 ? void 0 : { kind: "v4", value };
+}
+var V4_PRIVATE = [
+  [0, 8],
+  [167772160, 8],
+  [1681915904, 10],
+  [2130706432, 8],
+  [2851995648, 16],
+  [2886729728, 12],
+  [3221225472, 24],
+  [3221225984, 24],
+  [3223307264, 24],
+  [3224682752, 24],
+  [3227017984, 24],
+  [3232235520, 16],
+  [3232706560, 24],
+  [3323068416, 15],
+  [3325256704, 24],
+  [3405803776, 24],
+  [3758096384, 4],
+  [4026531840, 4]
+];
+function inCidr(value, base, bits) {
+  return (value ^ base) >>> 32 - bits === 0;
+}
+function isPrivateIpv4(value) {
+  return V4_PRIVATE.some(([base, bits]) => inCidr(value, base, bits));
+}
+function embeddedIpv4(segments) {
+  const [a, b, c, d, e, f, g, h] = segments;
+  if (a === 0 && b === 0 && c === 0 && d === 0 && e === 0) {
+    if (f === 65535 || f === 0)
+      return g * 65536 + h >>> 0;
+  }
+  if (a === 100 && b === 65435 && c === 0 && d === 0 && e === 0 && f === 0)
+    return g * 65536 + h >>> 0;
+  if (a === 8194)
+    return b * 65536 + c >>> 0;
+  if (a === 8193 && b === 0)
+    return (g ^ 65535) * 65536 + (h ^ 65535) >>> 0;
+  return;
+}
+function isUnspecified(segments) {
+  return segments.every((segment) => segment === 0);
+}
+function isIpv6Loopback(segments) {
+  return segments.slice(0, 7).every((segment) => segment === 0) && segments[7] === 1;
+}
+function isPrivateIpAddress(ip) {
+  if (ip.kind === "v4")
+    return isPrivateIpv4(ip.value);
+  const segments = ip.segments;
+  if (isUnspecified(segments) || isIpv6Loopback(segments))
+    return true;
+  const first = segments[0];
+  if ((first & 65280) === 65280)
+    return true;
+  if ((first & 65024) === 64512)
+    return true;
+  if ((first & 65472) === 65152)
+    return true;
+  if ((first & 65472) === 65216)
+    return true;
+  if (first === 256 && segments[1] === 0 && segments[2] === 0 && segments[3] === 0)
+    return true;
+  if (first === 8193 && segments[1] === 3512)
+    return true;
+  const embedded = embeddedIpv4(segments);
+  if (embedded !== void 0)
+    return isPrivateIpv4(embedded);
+  return false;
+}
+function safeRepoUrl(input) {
+  try {
+    const url = new URL(input);
+    return url.protocol === "https:" || url.protocol === "http:" || url.protocol === "ssh:" ? input : void 0;
+  } catch {
+    return /^[\w.-]+@[\w.-]+:[\w./-]+$/.test(input) ? input : void 0;
+  }
+}
+function repoUrlHost(input) {
+  if (!safeRepoUrl(input))
+    return;
+  try {
+    const host = new URL(input).hostname;
+    return host || void 0;
+  } catch {
+    return /^[\w.-]+@([\w.-]+):[\w./-]+$/.exec(input)?.[1]?.toLowerCase();
+  }
+}
+function bareRepoHost(host) {
+  const bare = host.trim().toLowerCase();
+  return bare.startsWith("[") && bare.endsWith("]") && bare.includes(":") ? bare.slice(1, -1) : bare;
+}
+function loopbackRepoName(bare) {
+  return bare === "localhost" || bare.endsWith(".localhost");
+}
+function publicRepoHost(repoUrl) {
+  const host = repoUrlHost(repoUrl);
+  if (!host)
+    return;
+  const bare = bareRepoHost(host);
+  if (loopbackRepoName(bare))
+    return;
+  const ip = parseIpAddress(bare);
+  if (ip && isPrivateIpAddress(ip))
+    return;
+  return host;
+}
+
 // src/hosted-network-policy.ts
 var SANDBOX_MODEL_PROVIDER_HOSTS = [
   "api.anthropic.com",
@@ -35,7 +252,7 @@ function hostOf(value) {
 }
 function sandboxSourceHost(source) {
   if (!source || source.kind !== "git") return void 0;
-  return hostOf(source.repoUrl);
+  return publicRepoHost(source.repoUrl);
 }
 function hostedSandboxNetworkPolicy(input) {
   const hosts = /* @__PURE__ */ new Set();

package/dist/image-name.d.ts

@@ -2,6 +2,16 @@ export declare const SNAPSHOT_SCHEMA_VERSION = 8;
 export declare const DEFAULT_SANDBOX_IMAGE_REPOSITORY = "ghcr.io/kyashrathore/claxedo-sandbox";
 export type SandboxImageEnv = Record<string, string | undefined>;
 export declare function snapshotVersion(value: string): string;
+/**
+ * A caller-supplied image string lands verbatim inside provider argv or
+ * commands (`docker create` argv, `docker run` inside a Boat VM). A value that
+ * parses as an option — a leading `-` — or that splits into multiple words
+ * would be consumed as provider flags, not as an image reference.
+ */
+export declare function assertSandboxImageReference(image: string): string;
 export declare function sandboxImageRepository(env?: SandboxImageEnv): string;
-export declare function defaultSandboxImage(version?: string, buildId?: string, env?: SandboxImageEnv): string;
-export declare function defaultSnapshotName(version?: string, buildId?: string, env?: SandboxImageEnv): string;
+export declare function defaultSandboxImage(version?: string, buildId?: string, env?: SandboxImageEnv, options?: {
+    agentPlugins?: boolean;
+}): string;
+/** Whether an image's tag names a build that carries the Agent Plugins runtime entry. */
+export declare function sandboxImageCarriesAgentPlugins(image: string): boolean;

package/dist/image-name.mjs

@@ -10,6 +10,12 @@ var DEFAULT_SANDBOX_IMAGE_REPOSITORY = "ghcr.io/kyashrathore/claxedo-sandbox";
 function snapshotVersion(value) {
   return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
+function assertSandboxImageReference(image) {
+  if (!image || image !== image.trim() || image.startsWith("-") || /\s/.test(image)) {
+    throw new Error(`sandbox image reference is not a legal image identifier: ${JSON.stringify(image)}`);
+  }
+  return image;
+}
 function sandboxImageRepository(env = process.env) {
   const repository = env.CLAXEDO_SANDBOX_IMAGE_REPOSITORY?.trim();
   return repository ? repository : DEFAULT_SANDBOX_IMAGE_REPOSITORY;
@@ -18,17 +24,20 @@ function buildIdSuffix(buildId, env) {
   const id = (buildId ?? env.CLAXEDO_SANDBOX_BUILD_ID)?.trim();
   return id ? `-${snapshotVersion(id)}` : "";
 }
-function defaultSandboxImage(version = workspaceRuntimeVersion(), buildId, env = process.env) {
-  return `${sandboxImageRepository(env)}:workspace-runtime-${snapshotVersion(version)}${buildIdSuffix(buildId, env)}-v${SNAPSHOT_SCHEMA_VERSION}`;
+var AGENT_PLUGINS_TAG = "-agent-plugins";
+function defaultSandboxImage(version = workspaceRuntimeVersion(), buildId, env = process.env, options = {}) {
+  const feature = options.agentPlugins ? AGENT_PLUGINS_TAG : "";
+  return `${sandboxImageRepository(env)}:workspace-runtime-${snapshotVersion(version)}${buildIdSuffix(buildId, env)}${feature}-v${SNAPSHOT_SCHEMA_VERSION}`;
 }
-function defaultSnapshotName(version = workspaceRuntimeVersion(), buildId, env = process.env) {
-  return `claxedo-workspace-runtime-${snapshotVersion(version)}${buildIdSuffix(buildId, env)}-v${SNAPSHOT_SCHEMA_VERSION}`;
+function sandboxImageCarriesAgentPlugins(image) {
+  return new RegExp(`${AGENT_PLUGINS_TAG}-v\\d+$`).test(image);
 }
 export {
   DEFAULT_SANDBOX_IMAGE_REPOSITORY,
   SNAPSHOT_SCHEMA_VERSION,
+  assertSandboxImageReference,
   defaultSandboxImage,
-  defaultSnapshotName,
+  sandboxImageCarriesAgentPlugins,
   sandboxImageRepository,
   snapshotVersion
 };

package/dist/image.d.ts

@@ -1,23 +1,4 @@
-import type { Daytona, Image } from "@daytona/sdk";
 export { RUNTIME_DIR, WORKSPACE_RUNTIME_PORT, WORKSPACE_DIR } from "./defaults";
-export { SNAPSHOT_SCHEMA_VERSION, snapshotVersion, defaultSandboxImage, defaultSnapshotName, } from "./image-name";
-/**
- * Sink for snapshot-build progress. Every message here reports a long
- * operation an operator is actively waiting on — a snapshot build takes
- * minutes, and the Daytona builder's `onLogs` stream is the only view into
- * whether it is progressing or wedged.
- *
- * Defaults to `console.info`, deliberately unconditional: the same reasoning as
- * `onEgressUnenforced` in index.ts — someone who never wires a sink still sees
- * the build. Pass your own to route it into a logger; pass `() => {}` only if
- * you have another way to observe the build.
- */
-export type SandboxImageLogSink = (message: string, context?: Record<string, unknown>) => void;
-export type SandboxImageOptions = {
-    log?: SandboxImageLogSink;
-};
+export { SNAPSHOT_SCHEMA_VERSION, snapshotVersion, assertSandboxImageReference, defaultSandboxImage, } from "./image-name";
 export declare const SANDBOX_IMAGE_REPOSITORY: string;
 export declare const SANDBOX_IMAGE: string;
-export declare const SNAPSHOT_NAME: string;
-export declare function buildSandboxImage(): Promise<Image>;
-export declare function ensureSnapshot(daytona: Daytona, options?: SandboxImageOptions): Promise<string>;

package/dist/image.mjs

@@ -18,6 +18,12 @@ var DEFAULT_SANDBOX_IMAGE_REPOSITORY = "ghcr.io/kyashrathore/claxedo-sandbox";
 function snapshotVersion(value) {
   return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
+function assertSandboxImageReference(image) {
+  if (!image || image !== image.trim() || image.startsWith("-") || /\s/.test(image)) {
+    throw new Error(`sandbox image reference is not a legal image identifier: ${JSON.stringify(image)}`);
+  }
+  return image;
+}
 function sandboxImageRepository(env = process.env) {
   const repository = env.CLAXEDO_SANDBOX_IMAGE_REPOSITORY?.trim();
   return repository ? repository : DEFAULT_SANDBOX_IMAGE_REPOSITORY;
@@ -26,106 +32,23 @@ function buildIdSuffix(buildId, env) {
   const id = (buildId ?? env.CLAXEDO_SANDBOX_BUILD_ID)?.trim();
   return id ? `-${snapshotVersion(id)}` : "";
 }
-function defaultSandboxImage(version = workspaceRuntimeVersion(), buildId, env = process.env) {
-  return `${sandboxImageRepository(env)}:workspace-runtime-${snapshotVersion(version)}${buildIdSuffix(buildId, env)}-v${SNAPSHOT_SCHEMA_VERSION}`;
-}
-function defaultSnapshotName(version = workspaceRuntimeVersion(), buildId, env = process.env) {
-  return `claxedo-workspace-runtime-${snapshotVersion(version)}${buildIdSuffix(buildId, env)}-v${SNAPSHOT_SCHEMA_VERSION}`;
-}
-
-// ../claxedo-helpers/dist/guards.mjs
-function isRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function asRecord(value) {
-  return isRecord(value) ? value : void 0;
-}
-
-// src/json.ts
-function text(input) {
-  return typeof input === "string" && input.length > 0 ? input : void 0;
+var AGENT_PLUGINS_TAG = "-agent-plugins";
+function defaultSandboxImage(version = workspaceRuntimeVersion(), buildId, env = process.env, options = {}) {
+  const feature = options.agentPlugins ? AGENT_PLUGINS_TAG : "";
+  return `${sandboxImageRepository(env)}:workspace-runtime-${snapshotVersion(version)}${buildIdSuffix(buildId, env)}${feature}-v${SNAPSHOT_SCHEMA_VERSION}`;
 }
 
 // src/image.ts
-function defaultImageLogSink(message, context) {
-  if (context) console.info(message, context);
-  else console.info(message);
-}
 var SANDBOX_IMAGE_REPOSITORY = sandboxImageRepository();
 var SANDBOX_IMAGE = process.env.CLAXEDO_SANDBOX_IMAGE || defaultSandboxImage();
-var SNAPSHOT_NAME = process.env.CLAXEDO_SNAPSHOT_NAME || defaultSnapshotName();
-async function buildSandboxImage() {
-  const { Image } = await import("@daytona/sdk");
-  return Image.base(SANDBOX_IMAGE);
-}
-function snapshotUsable(state) {
-  return state === "ready" || state === "active";
-}
-function snapshotView(input) {
-  const row = asRecord(input) ?? {};
-  return { id: text(row.id), state: text(row.state), errorReason: text(row.errorReason) };
-}
-async function activateSnapshot(snapshots, id) {
-  const activate = asRecord(snapshots)?.activate;
-  if (typeof activate !== "function") throw new Error("Daytona SDK does not support snapshot activation");
-  await activate.call(snapshots, { id });
-}
-async function createSnapshot(daytona, log) {
-  log("Creating sandbox snapshot (this may take a few minutes)...", { name: SNAPSHOT_NAME });
-  await daytona.snapshot.create(
-    { name: SNAPSHOT_NAME, image: await buildSandboxImage() },
-    {
-      timeout: 120,
-      onLogs: (chunk) => log("[snapshot]", { text: chunk })
-    }
-  );
-  return SNAPSHOT_NAME;
-}
-async function ensureSnapshot(daytona, options = {}) {
-  const log = options.log ?? defaultImageLogSink;
-  try {
-    const existing = snapshotView(await daytona.snapshot.get(SNAPSHOT_NAME));
-    if (existing.state === "inactive") {
-      log("Snapshot is inactive, reactivating...", { name: SNAPSHOT_NAME, id: existing.id });
-      if (!existing.id) throw new Error("Daytona snapshot is inactive but reports no id to activate");
-      await activateSnapshot(daytona.snapshot, existing.id);
-      for (let i = 0; i < 120; i++) {
-        const snap = snapshotView(await daytona.snapshot.get(SNAPSHOT_NAME));
-        if (snapshotUsable(snap.state)) return SNAPSHOT_NAME;
-        if (snap.state === "error") throw new Error(`Snapshot activation failed: ${snap.errorReason ?? "unknown"}`);
-        await new Promise((resolve) => setTimeout(resolve, 2e3));
-      }
-      throw new Error("Snapshot activation timed out");
-    }
-    if (existing.state === "building") {
-      log("Snapshot is building, waiting (up to 10 min)...", { name: SNAPSHOT_NAME });
-      for (let i = 0; i < 300; i++) {
-        const snap = snapshotView(await daytona.snapshot.get(SNAPSHOT_NAME));
-        if (snapshotUsable(snap.state)) return SNAPSHOT_NAME;
-        if (snap.state === "error") throw new Error(`Snapshot build failed: ${snap.errorReason ?? "unknown"}`);
-        if (i % 15 === 0) log("Still waiting for snapshot...", { state: snap.state, elapsed: `${i * 2}s` });
-        await new Promise((resolve) => setTimeout(resolve, 2e3));
-      }
-      throw new Error("Snapshot build timed out after 10 minutes");
-    }
-    return SNAPSHOT_NAME;
-  } catch (err) {
-    const { DaytonaNotFoundError } = await import("@daytona/sdk");
-    if (!(err instanceof DaytonaNotFoundError)) throw err;
-  }
-  return createSnapshot(daytona, log);
-}
 export {
   RUNTIME_DIR,
   SANDBOX_IMAGE,
   SANDBOX_IMAGE_REPOSITORY,
-  SNAPSHOT_NAME,
   SNAPSHOT_SCHEMA_VERSION,
   WORKSPACE_DIR,
   WORKSPACE_RUNTIME_PORT,
-  buildSandboxImage,
+  assertSandboxImageReference,
   defaultSandboxImage,
-  defaultSnapshotName,
-  ensureSnapshot,
   snapshotVersion
 };