freestyle-sandboxes 0.1.38 → 0.1.40

package/index.cjs

@@ -6009,6 +6009,64 @@ function composeVmSpecs(specs) {
 }
 
 const DEFAULT_CONFIGURE_BASE_IMAGE = "FROM debian:trixie-slim";
+const RUN_COMMANDS_SYSTEMD_SERVICE_PREFIX = "freestyle-run-command";
+const WAIT_FOR_SYSTEMD_SERVICE_PREFIX = "freestyle-wait-for";
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function getGeneratedServiceState(services, prefix) {
+  const generatedPrefixes = [
+    RUN_COMMANDS_SYSTEMD_SERVICE_PREFIX,
+    WAIT_FOR_SYSTEMD_SERVICE_PREFIX
+  ];
+  let maxIndex = 0;
+  let lastGeneratedServiceName;
+  for (const service of services) {
+    if (!service.name) {
+      continue;
+    }
+    for (const generatedPrefix of generatedPrefixes) {
+      const match = service.name.match(
+        new RegExp(`^${escapeRegExp(generatedPrefix)}-(\\d+)$`)
+      );
+      if (!match) {
+        continue;
+      }
+      if (generatedPrefix === prefix) {
+        const index = Number.parseInt(match[1] ?? "0", 10);
+        if (index > maxIndex) {
+          maxIndex = index;
+        }
+      }
+      lastGeneratedServiceName = service.name;
+      break;
+    }
+  }
+  return { maxIndex, lastGeneratedServiceName };
+}
+function appendServiceDependency(dependencies, dependency) {
+  if (!dependency) {
+    return dependencies ?? void 0;
+  }
+  const values = [...dependencies ?? []];
+  if (!values.includes(dependency)) {
+    values.push(dependency);
+  }
+  return values;
+}
+function buildWaitForScript(command, intervalSeconds) {
+  const body = command.trim().split("\n").map((line) => `    ${line}`).join("\n");
+  return [
+    "while true; do",
+    "  if (",
+    body,
+    "  ); then",
+    "    exit 0",
+    "  fi",
+    `  sleep ${intervalSeconds}`,
+    "done"
+  ].join("\n");
+}
 function processSystemdServices(services, existingFiles = {}) {
   const additionalFiles = { ...existingFiles };
   const processedServices = [];
@@ -6043,6 +6101,63 @@ ${bash}`;
   }
   return { services: processedServices, additionalFiles };
 }
+function normalizeSystemdServices(services) {
+  return services.map((service) => ({
+    ...service,
+    after: service.after?.map((s) => s.includes(".") ? s : `${s}.service`),
+    requires: service.requires?.map(
+      (s) => s.includes(".") ? s : `${s}.service`
+    ),
+    wantedBy: service.wantedBy?.map(
+      (s) => s.includes(".") ? s : `${s}.service`
+    )
+  }));
+}
+function normalizePatchedServices(services) {
+  return services.map((service) => ({
+    ...service,
+    after: service.after?.map((s) => s.includes(".") ? s : `${s}.service`),
+    requires: service.requires?.map(
+      (s) => s.includes(".") ? s : `${s}.service`
+    ),
+    wantedBy: service.wantedBy?.map(
+      (s) => s.includes(".") ? s : `${s}.service`
+    )
+  }));
+}
+function normalizeTemplateForRequest(template) {
+  const normalizedTemplate = {
+    ...template ?? {}
+  };
+  if (normalizedTemplate.template) {
+    normalizedTemplate.template = normalizeTemplateForRequest(
+      normalizedTemplate.template
+    );
+  }
+  if (normalizedTemplate.baseImage) {
+    normalizedTemplate.baseImage = normalizeBaseImage(
+      normalizedTemplate.baseImage
+    )?.toRaw();
+  }
+  normalizedTemplate.git = normalizeGitOptions(normalizedTemplate.git);
+  if (normalizedTemplate.systemd?.services) {
+    const normalizedServices = normalizeSystemdServices(
+      normalizedTemplate.systemd.services
+    );
+    const { services: processedServices, additionalFiles: bashFiles } = processSystemdServices(
+      normalizedServices,
+      normalizedTemplate.additionalFiles ?? {}
+    );
+    normalizedTemplate.systemd.services = processedServices;
+    normalizedTemplate.additionalFiles = bashFiles;
+  }
+  if (normalizedTemplate.systemd?.patchedServices) {
+    normalizedTemplate.systemd.patchedServices = normalizePatchedServices(
+      normalizedTemplate.systemd.patchedServices
+    );
+  }
+  return normalizedTemplate;
+}
 function normalizeGitOptions(git) {
   if (!git) return git;
   return {
@@ -6238,10 +6353,12 @@ class Vm {
       params: { vm_id: this.vmId },
       body: options
     });
-    const vmId = response.id;
     return {
-      vmId,
-      vm: new Vm({ vmId, freestyle: this._freestyle })
+      forks: response.forks.map((fork) => ({
+        vmId: fork.id,
+        vm: this._freestyle.vms.ref({ vmId: fork.id })
+        // Create a new Vm instance for the forked VM
+      }))
     };
   }
   /**
@@ -6390,10 +6507,14 @@ class VmSpec {
     return { ...this.withDiscriminators };
   }
   mergeRaw(options) {
+    const existingSnapshot = this.raw.snapshot;
     this.raw = composeCreateVmOptions([
       this.raw,
       options
     ]);
+    if (existingSnapshot !== void 0 && this.raw.snapshot === void 0) {
+      this.raw.snapshot = existingSnapshot;
+    }
     return this;
   }
   clearBuilders() {
@@ -6460,6 +6581,14 @@ class VmSpec {
     const existing = this.raw.aptDeps ?? [];
     return this.mergeRaw({ aptDeps: [...existing, ...deps] });
   }
+  users(users) {
+    const existing = this.raw.users ?? [];
+    return this.mergeRaw({ users: [...existing, ...users] });
+  }
+  groups(groups) {
+    const existing = this.raw.groups ?? [];
+    return this.mergeRaw({ groups: [...existing, ...groups] });
+  }
   additionalFiles(files) {
     const existing = this.raw.additionalFiles ?? {};
     this.raw.additionalFiles = {
@@ -6469,9 +6598,74 @@ class VmSpec {
     return this;
   }
   runCommands(...commands) {
-    const image = normalizeBaseImage(this.raw.baseImage) ?? new VmBaseImage();
-    image.runCommands(...commands);
-    this.raw.baseImage = image;
+    const normalizedCommands = commands.map((command) => command.trim()).filter((command) => command.length > 0);
+    if (normalizedCommands.length === 0) {
+      return this;
+    }
+    const existingSystemd = this.raw.systemd ?? {};
+    const existingServices = [...existingSystemd.services ?? []];
+    let { maxIndex: maxRunCommandIndex, lastGeneratedServiceName } = getGeneratedServiceState(
+      existingServices,
+      RUN_COMMANDS_SYSTEMD_SERVICE_PREFIX
+    );
+    for (const command of normalizedCommands) {
+      const nextIndex = ++maxRunCommandIndex;
+      const serviceName = `${RUN_COMMANDS_SYSTEMD_SERVICE_PREFIX}-${nextIndex}`;
+      existingServices.push({
+        name: serviceName,
+        mode: "oneshot",
+        deleteAfterSuccess: true,
+        bash: command,
+        ...lastGeneratedServiceName ? {
+          after: [lastGeneratedServiceName],
+          requires: [lastGeneratedServiceName]
+        } : {}
+      });
+      lastGeneratedServiceName = serviceName;
+    }
+    this.raw.systemd = {
+      ...existingSystemd,
+      services: existingServices
+    };
+    return this;
+  }
+  waitFor(command, config = {}) {
+    const trimmedCommand = command.trim();
+    if (!trimmedCommand) {
+      throw new Error("VmSpec.waitFor requires a non-empty command");
+    }
+    const intervalSeconds = config.intervalSeconds ?? 2;
+    if (!Number.isFinite(intervalSeconds) || intervalSeconds <= 0) {
+      throw new Error("VmSpec.waitFor intervalSeconds must be greater than 0");
+    }
+    const existingSystemd = this.raw.systemd ?? {};
+    const existingServices = [...existingSystemd.services ?? []];
+    const { maxIndex, lastGeneratedServiceName } = getGeneratedServiceState(
+      existingServices,
+      WAIT_FOR_SYSTEMD_SERVICE_PREFIX
+    );
+    const {
+      intervalSeconds: _intervalSeconds,
+      name,
+      after,
+      requires,
+      timeoutSec,
+      ...rest
+    } = config;
+    existingServices.push({
+      ...rest,
+      name: name ?? `${WAIT_FOR_SYSTEMD_SERVICE_PREFIX}-${maxIndex + 1}`,
+      mode: "oneshot",
+      // deleteAfterSuccess: true,
+      timeoutSec: timeoutSec ?? 0,
+      after: appendServiceDependency(after, lastGeneratedServiceName),
+      requires: appendServiceDependency(requires, lastGeneratedServiceName),
+      bash: buildWaitForScript(trimmedCommand, intervalSeconds)
+    });
+    this.raw.systemd = {
+      ...existingSystemd,
+      services: existingServices
+    };
     return this;
   }
   repo(repo, path) {
@@ -6498,7 +6692,7 @@ class VmSpec {
 function isVmSpecLike$1(value) {
   return !!value && typeof value === "object" && "raw" in value && "with" in value;
 }
-function isVmTemplateLike(value) {
+function isVmTemplateLike$1(value) {
   return !!value && typeof value === "object" && "raw" in value && "with" in value;
 }
 async function convertSpecSnapshotsToTemplates(spec, processBuilders = true) {
@@ -6624,21 +6818,8 @@ class VmsNamespace {
       }
     }
     if (options.systemd?.services) {
-      const normalizedServices = options.systemd.services.map(
-        (service) => {
-          return {
-            ...service,
-            after: service.after?.map(
-              (s) => s.includes(".") ? s : `${s}.service`
-            ),
-            requires: service.requires?.map(
-              (s) => s.includes(".") ? s : `${s}.service`
-            ),
-            wantedBy: service.wantedBy?.map(
-              (s) => s.includes(".") ? s : `${s}.service`
-            )
-          };
-        }
+      const normalizedServices = normalizeSystemdServices(
+        options.systemd.services
       );
       const { services: processedServices, additionalFiles: bashFiles } = processSystemdServices(
         normalizedServices,
@@ -6648,19 +6829,8 @@ class VmsNamespace {
       options.additionalFiles = bashFiles;
     }
     if (options.systemd?.patchedServices) {
-      options.systemd.patchedServices = options.systemd.patchedServices.map(
-        (service) => {
-          service.after = service.after?.map(
-            (s) => s.includes(".") ? s : `${s}.service`
-          );
-          service.requires = service.requires?.map(
-            (s) => s.includes(".") ? s : `${s}.service`
-          );
-          service.wantedBy = service.wantedBy?.map(
-            (s) => s.includes(".") ? s : `${s}.service`
-          );
-          return service;
-        }
+      options.systemd.patchedServices = normalizePatchedServices(
+        options.systemd.patchedServices
       );
     }
     if ("snapshot" in options) {
@@ -6693,7 +6863,7 @@ class VmsNamespace {
     const specBuilders = isVmSpecLike$1(
       options.spec
     ) ? collectSpecBuilders(options.spec) : void 0;
-    const templateBuilders = isVmTemplateLike(options.template) ? options.template.with : void 0;
+    const templateBuilders = isVmTemplateLike$1(options.template) ? options.template.with : void 0;
     const builders = {
       ...templateBuilders || {},
       ...specBuilders || {},
@@ -6701,10 +6871,10 @@ class VmsNamespace {
     };
     const { with: _, spec: _spec, ...baseConfig } = options;
     let config = baseConfig;
-    if (isVmTemplateLike(config.template)) {
+    if (isVmTemplateLike$1(config.template)) {
       config.template = await processTemplateTree(config.template);
     }
-    if (isVmTemplateLike(config.template)) {
+    if (isVmTemplateLike$1(config.template)) {
       config.template = await ensureNestedTemplates(
         config.template,
         this.snapshots
@@ -6718,18 +6888,9 @@ class VmsNamespace {
       }
     }
     if (config.systemd?.services) {
-      const normalizedServices = config.systemd.services.map((service) => ({
-        ...service,
-        after: service.after?.map(
-          (s) => s.includes(".") ? s : `${s}.service`
-        ),
-        requires: service.requires?.map(
-          (s) => s.includes(".") ? s : `${s}.service`
-        ),
-        wantedBy: service.wantedBy?.map(
-          (s) => s.includes(".") ? s : `${s}.service`
-        )
-      }));
+      const normalizedServices = normalizeSystemdServices(
+        config.systemd.services
+      );
       const { services: processedServices, additionalFiles: bashFiles } = processSystemdServices(
         normalizedServices,
         config.additionalFiles ?? {}
@@ -6738,28 +6899,20 @@ class VmsNamespace {
       config.additionalFiles = bashFiles;
     }
     if (config.systemd?.patchedServices) {
-      config.systemd.patchedServices = config.systemd.patchedServices.map(
-        (service) => {
-          service.after = service.after?.map(
-            (s) => s.includes(".") ? s : `${s}.service`
-          );
-          service.requires = service.requires?.map(
-            (s) => s.includes(".") ? s : `${s}.service`
-          );
-          service.wantedBy = service.wantedBy?.map(
-            (s) => s.includes(".") ? s : `${s}.service`
-          );
-          return service;
-        }
+      config.systemd.patchedServices = normalizePatchedServices(
+        config.systemd.patchedServices
       );
     }
     config.git = normalizeGitOptions(config.git);
     const serializedBaseImage = normalizeBaseImage(config.baseImage)?.toRaw();
-    const rawTemplate = isVmTemplateLike(config.template) ? config.template.raw : config.template;
+    const rawTemplate = isVmTemplateLike$1(config.template) ? config.template.raw : config.template;
     const requestTemplate = serializedBaseImage ? {
       ...rawTemplate ?? {},
       baseImage: serializedBaseImage
     } : rawTemplate;
+    const normalizedRequestTemplate = requestTemplate ? normalizeTemplateForRequest(
+      requestTemplate
+    ) : requestTemplate;
     const {
       baseImage: _baseImage,
       template: _template,
@@ -6768,7 +6921,7 @@ class VmsNamespace {
     const response = await this.freestyle._apiClient.post("/v1/vms", {
       body: {
         ...requestConfig,
-        template: requestTemplate,
+        template: normalizedRequestTemplate,
         // Cast systemd since we've processed SystemdServiceInput[] to RawSystemdService[]
         systemd: config.systemd,
         // Normalize git options - default config to {}
@@ -6863,6 +7016,35 @@ function enhanceError(e) {
     if (!e.message.includes("create --snapshot")) {
       e.message = `${e.message}. Hint: use \`npx freestyle-sandboxes@latest vm create --snapshot ${e.body.snapshotId} --ssh --delete\` to debug.`;
     }
+    if (e.body.diagnostics) {
+      const d = e.body.diagnostics;
+      const parts = [];
+      if (d.serviceStates.length > 0) {
+        parts.push("Service states:");
+        for (const g of d.serviceStates) {
+          parts.push(
+            `  ${g.activeState}(${g.subState}): ${g.services.join(", ")}`
+          );
+        }
+      }
+      const allLogs = [
+        ...d.failedServiceLogs ?? [],
+        ...d.additionalFailedServiceLogs ?? []
+      ];
+      if (allLogs.length > 0) {
+        parts.push("Failed service logs:");
+        for (const l of allLogs) {
+          parts.push(`  --- ${l.unitName} ---`);
+          parts.push(`  ${l.log}`);
+        }
+      }
+      if (parts.length > 0) {
+        e.message = `${e.message}
+
+Diagnostics:
+${parts.join("\n")}`;
+      }
+    }
   }
   return e;
 }
@@ -6930,12 +7112,12 @@ class VmSnapshotsNamespace {
       const { spec: _spec, ...rest } = requestOptions;
       requestOptions = rest;
     }
-    if (isVmTemplateLike(requestOptions.template)) {
+    if (isVmTemplateLike$1(requestOptions.template)) {
       const processedTemplate = await processTemplateTree(
         requestOptions.template
       );
       requestOptions.template = processedTemplate;
-      if (isVmTemplateLike(processedTemplate.raw.template)) {
+      if (isVmTemplateLike$1(processedTemplate.raw.template)) {
         requestOptions.template = await ensureNestedTemplates(
           processedTemplate,
           this
@@ -6950,7 +7132,9 @@ class VmSnapshotsNamespace {
     return this.apiClient.post("/v1/vms/snapshots", {
       body: {
         ...requestOptions,
-        template: isVmTemplateLike(requestOptions.template) ? requestOptions.template.raw : requestOptions.template
+        template: normalizeTemplateForRequest(
+          isVmTemplateLike$1(requestOptions.template) ? requestOptions.template.raw : requestOptions.template
+        )
       }
     }).catch((e) => {
       enhanceError(e);
@@ -6970,22 +7154,9 @@ async function processTemplateTree(template) {
     );
   }
   if (template.raw.systemd?.services) {
-    const normalizedServices = template.raw.systemd.services.map((service) => ({
-      ...service,
-      after: service.after?.map((s) => s.includes(".") ? s : `${s}.service`),
-      requires: service.requires?.map(
-        (s) => s.includes(".") ? s : `${s}.service`
-      ),
-      wantedBy: service.wantedBy?.map(
-        (s) => s.includes(".") ? s : `${s}.service`
-      )
-    }));
-    const { services: processedServices, additionalFiles: bashFiles } = processSystemdServices(
-      normalizedServices,
-      template.raw.additionalFiles ?? {}
+    template.raw.systemd.services = normalizeSystemdServices(
+      template.raw.systemd.services
     );
-    template.raw.systemd.services = processedServices;
-    template.raw.additionalFiles = bashFiles;
   }
   for (const key in template.with) {
     const builder = template.with[key];
@@ -7002,7 +7173,7 @@ async function processTemplateTree(template) {
       }
       if (builder.configureNestedTemplate) {
         let nestedTemplate;
-        if (isVmTemplateLike(template.raw.template)) {
+        if (isVmTemplateLike$1(template.raw.template)) {
           nestedTemplate = template.raw.template;
         } else {
           nestedTemplate = new VmTemplate({});
@@ -7025,38 +7196,16 @@ async function processTemplateTree(template) {
     );
   }
   if (template.raw.systemd?.services) {
-    const normalizedServices = template.raw.systemd.services.map((service) => ({
-      ...service,
-      after: service.after?.map((s) => s.includes(".") ? s : `${s}.service`),
-      requires: service.requires?.map(
-        (s) => s.includes(".") ? s : `${s}.service`
-      ),
-      wantedBy: service.wantedBy?.map(
-        (s) => s.includes(".") ? s : `${s}.service`
-      )
-    }));
-    const { services: processedServices, additionalFiles: bashFiles } = processSystemdServices(
-      normalizedServices,
-      template.raw.additionalFiles ?? {}
+    template.raw.systemd.services = normalizeSystemdServices(
+      template.raw.systemd.services
     );
-    template.raw.systemd.services = processedServices;
-    template.raw.additionalFiles = bashFiles;
   }
   if (template.raw.systemd?.patchedServices) {
-    template.raw.systemd.patchedServices = template.raw.systemd.patchedServices.map((service) => ({
-      ...service,
-      after: service.after?.map(
-        (s) => s.includes(".") ? s : `${s}.service`
-      ),
-      requires: service.requires?.map(
-        (s) => s.includes(".") ? s : `${s}.service`
-      ),
-      wantedBy: service.wantedBy?.map(
-        (s) => s.includes(".") ? s : `${s}.service`
-      )
-    }));
+    template.raw.systemd.patchedServices = normalizePatchedServices(
+      template.raw.systemd.patchedServices
+    );
   }
-  if (isVmTemplateLike(template.raw.template)) {
+  if (isVmTemplateLike$1(template.raw.template)) {
     template.raw.template = await processTemplateTree(
       template.raw.template
     );
@@ -7065,7 +7214,7 @@ async function processTemplateTree(template) {
 }
 async function ensureNestedTemplates(template, snapshots) {
   const templates = [template];
-  while (isVmTemplateLike(templates.at(-1)?.raw.template)) {
+  while (isVmTemplateLike$1(templates.at(-1)?.raw.template)) {
     const innerTemplate = templates.at(-1).raw.template;
     templates.at(-1).raw.template = void 0;
     templates.push(innerTemplate);
@@ -7250,7 +7399,7 @@ async function readFiles(directory) {
 }
 
 async function debugCreateRequests(freestyle, optionsOrSpec = {}) {
-  const options = isVmSpecLike(optionsOrSpec) ? { spec: optionsOrSpec } : optionsOrSpec;
+  const options = isVmSpecLike(optionsOrSpec) ? { spec: cloneVmSpec(optionsOrSpec) } : cloneCreateOptions(optionsOrSpec);
   const requests = [];
   let snapshotCounter = 0;
   let vmCounter = 0;
@@ -7297,6 +7446,79 @@ async function debugCreateRequests(freestyle, optionsOrSpec = {}) {
 function isVmSpecLike(value) {
   return !!value && typeof value === "object" && "raw" in value && "with" in value;
 }
+function isVmTemplateLike(value) {
+  return !!value && typeof value === "object" && "raw" in value && "with" in value;
+}
+function cloneCreateOptions(options) {
+  return {
+    ...clonePlainObject(options),
+    with: options.with,
+    template: isVmTemplateLike(options.template) ? cloneVmTemplate(options.template) : cloneValue(options.template),
+    spec: isVmSpecLike(options.spec) ? cloneVmSpec(options.spec) : void 0,
+    snapshot: isVmSpecLike(options.snapshot) ? cloneVmSpec(options.snapshot) : void 0
+  };
+}
+function cloneVmSpec(spec) {
+  const clonedRaw = cloneVmSpecRaw(spec.raw);
+  return new VmSpec({
+    ...clonedRaw,
+    with: { ...spec.builders },
+    __withDiscriminators: typeof spec.getBuilderDiscriminators === "function" ? spec.getBuilderDiscriminators() : void 0
+  });
+}
+function cloneVmTemplate(template) {
+  const clonedRaw = cloneVmTemplateRaw(template.raw);
+  return new VmTemplate({
+    ...clonedRaw,
+    with: { ...template.with }
+  });
+}
+function cloneVmSpecRaw(raw) {
+  const cloned = cloneVmTemplateRaw(raw);
+  if (isVmSpecLike(raw.snapshot)) {
+    cloned.snapshot = cloneVmSpec(raw.snapshot);
+  } else if (raw.snapshot !== void 0) {
+    cloned.snapshot = cloneValue(raw.snapshot);
+  }
+  return cloned;
+}
+function cloneVmTemplateRaw(raw) {
+  const cloned = clonePlainObject(raw);
+  if (isVmTemplateLike(raw.template)) {
+    cloned.template = cloneVmTemplate(raw.template);
+  } else if (raw.template !== void 0) {
+    cloned.template = cloneValue(raw.template);
+  }
+  return cloned;
+}
+function clonePlainObject(value) {
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  const cloned = {};
+  for (const [key, entry] of Object.entries(value)) {
+    cloned[key] = cloneValue(entry);
+  }
+  return cloned;
+}
+function cloneValue(value) {
+  if (value instanceof VmBaseImage) {
+    return new VmBaseImage(value.toRaw());
+  }
+  if (isVmSpecLike(value)) {
+    return cloneVmSpec(value);
+  }
+  if (isVmTemplateLike(value)) {
+    return cloneVmTemplate(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => cloneValue(entry));
+  }
+  if (value && typeof value === "object") {
+    return clonePlainObject(value);
+  }
+  return value;
+}
 
 class Freestyle {
   /**