@decocms/sandbox-controller 0.8.1 → 0.8.3

package/dist/index.d.ts

@@ -3717,6 +3717,13 @@ interface FreestyleSandboxProviderOptions {
     orgFsSidecarImage?: string;
     /** Pause a VM after this long without network activity. Default 5 min. */
     idleTimeoutSeconds?: number;
+    /**
+     * Also pause a running VM once its daemon has gone this long unused. The
+     * idle timeout counts any traffic, so a dev server holding an outbound
+     * connection open keeps the VM awake without it. Checked every minute;
+     * 0 turns it off. Default 10 min.
+     */
+    idlePauseMs?: number;
     /**
      * Delete a VM after this long without running. Default 1 day. A plan
      * that caps it lower gets its cap.
@@ -3736,6 +3743,7 @@ declare class FreestyleSandboxProvider implements SandboxProvider {
     private readonly image;
     private readonly sidecarImage;
     private readonly idleTimeoutSeconds;
+    private readonly idlePauseMs;
     private readonly autoDeleteSeconds;
     private readonly domainSuffix;
     private readonly timeDaemonRequest;
@@ -3745,6 +3753,8 @@ declare class FreestyleSandboxProvider implements SandboxProvider {
     private readonly knownSnapshots;
     private readonly lookups;
     private readonly releaseTimers;
+    private readonly idleSweep;
+    private sweeping;
     constructor(opts: FreestyleSandboxProviderOptions);
     /** Whether this handle is a Freestyle sandbox. Cached; see `MISS_TTL_MS`. */
     owns(handle: string): Promise<boolean>;
@@ -3807,8 +3817,21 @@ declare class FreestyleSandboxProvider implements SandboxProvider {
      * VM anyway, only later.
      */
     releaseAfter(handle: string, graceMs: number): Promise<void>;
+    /**
+     * `renewTtl` cancels only this process's timer, so a turn that started
+     * through another replica still has to be seen: the daemon's clock counts
+     * its requests and streaming runs. A daemon that won't say is left to the
+     * VM's idle timeout.
+     */
+    private pauseIfIdle;
     /** The VM's idle timeout already counts every request as activity. */
     renewTtl(handle: string): Promise<void>;
+    /**
+     * Pause every running VM of ours whose daemon reports `idlePauseMs` without
+     * use. The daemon's clock counts requests and streaming runs, not the dev
+     * server's own traffic. Returns the handles paused; never throws.
+     */
+    pauseIdle(): Promise<string[]>;
     private cancelRelease;
     close(): void;
 }

package/dist/index.js

@@ -6759,7 +6759,7 @@ var Freestyle = class {
 // ../sandbox/package.json
 var package_default = {
   name: "@decocms/sandbox",
-  version: "1.85.1",
+  version: "1.89.2",
   private: true,
   type: "module",
   description: "Sandbox runtime for isolated Studio tool execution",
@@ -6861,6 +6861,8 @@ var MISS_TTL_MS = 1e4;
 var LOOKUP_MAX = 5e3;
 var WATCH_TIMEOUT_MS = 5 * 6e4;
 var LOOKUP_TIMEOUT_MS = 3e3;
+var IDLE_SWEEP_MS = 6e4;
+var IDLE_SWEEP_PAGE = 100;
 var FreestyleSandboxProvider = class {
   apiKey;
   freestyle;
@@ -6868,6 +6870,7 @@ var FreestyleSandboxProvider = class {
   image;
   sidecarImage;
   idleTimeoutSeconds;
+  idlePauseMs;
   autoDeleteSeconds;
   domainSuffix;
   timeDaemonRequest;
@@ -6877,6 +6880,8 @@ var FreestyleSandboxProvider = class {
   knownSnapshots = /* @__PURE__ */ new Set();
   lookups = /* @__PURE__ */ new Map();
   releaseTimers = /* @__PURE__ */ new Map();
+  idleSweep = null;
+  sweeping = false;
   constructor(opts) {
     this.apiKey = opts.apiKey;
     this.freestyle = opts.client ?? new Freestyle({ apiKey: opts.apiKey });
@@ -6896,9 +6901,14 @@ var FreestyleSandboxProvider = class {
     this.image = opts.image ?? `ghcr.io/decocms/studio/studio-sandbox-go:${package_default.version}`;
     this.sidecarImage = opts.orgFsSidecarImage ?? DEFAULT_SIDECAR_IMAGE;
     this.idleTimeoutSeconds = opts.idleTimeoutSeconds ?? 5 * 60;
+    this.idlePauseMs = opts.idlePauseMs ?? 10 * 6e4;
     this.autoDeleteSeconds = opts.autoDeleteSeconds ?? 24 * 60 * 60;
     this.domainSuffix = opts.domainSuffix ?? "style.dev";
     this.timeDaemonRequest = daemonProxyTimer(opts.meter);
+    if (this.idlePauseMs > 0) {
+      this.idleSweep = setInterval(() => void this.pauseIdle(), IDLE_SWEEP_MS);
+      this.idleSweep.unref?.();
+    }
   }
   /** Whether this handle is a Freestyle sandbox. Cached; see `MISS_TTL_MS`. */
   async owns(handle) {
@@ -7318,23 +7328,88 @@ running`).digest("hex").slice(0, 16)}`;
     this.cancelRelease(handle);
     const timer = setTimeout(() => {
       this.releaseTimers.delete(handle);
-      void this.find(handle).then((f) => f?.vm.pause()).catch(
+      void this.pauseIfIdle(handle, graceMs).catch(
         (err) => console.warn(`[${LOG_LABEL2}] pause ${handle} failed: ${errMsg2(err)}`)
       );
     }, graceMs);
     timer.unref?.();
     this.releaseTimers.set(handle, timer);
   }
+  /**
+   * `renewTtl` cancels only this process's timer, so a turn that started
+   * through another replica still has to be seen: the daemon's clock counts
+   * its requests and streaming runs. A daemon that won't say is left to the
+   * VM's idle timeout.
+   */
+  async pauseIfIdle(handle, graceMs) {
+    const found = await this.find(handle);
+    if (!found) return;
+    const idleMs = await daemonIdleMs(found.daemon.url);
+    if (idleMs === null || idleMs < graceMs) return;
+    await found.vm.pause();
+  }
   /** The VM's idle timeout already counts every request as activity. */
   async renewTtl(handle) {
     this.cancelRelease(handle);
   }
+  /**
+   * Pause every running VM of ours whose daemon reports `idlePauseMs` without
+   * use. The daemon's clock counts requests and streaming runs, not the dev
+   * server's own traffic. Returns the handles paused; never throws.
+   */
+  async pauseIdle() {
+    if (this.sweeping) return [];
+    this.sweeping = true;
+    try {
+      const running = [];
+      for (let offset = 0; ; offset += IDLE_SWEEP_PAGE) {
+        const { vms } = await this.freestyle.vms.list({
+          state: "running",
+          limit: IDLE_SWEEP_PAGE,
+          offset
+        });
+        running.push(...vms);
+        if (vms.length < IDLE_SWEEP_PAGE) break;
+      }
+      const paused = await Promise.all(
+        running.map(async (data) => {
+          const handle = data.slug;
+          if (!handle || !data.metadata[TOKEN_KEY]) return null;
+          if (Date.now() - Date.parse(data.createdAt) < this.idlePauseMs) {
+            return null;
+          }
+          const idleMs = await daemonIdleMs(this.daemonUrl(handle));
+          if (idleMs === null || idleMs < this.idlePauseMs) return null;
+          try {
+            await this.freestyle.vms.ref(data.id).pause();
+          } catch (err) {
+            console.warn(
+              `[${LOG_LABEL2}] pause ${handle} failed: ${errMsg2(err)}`
+            );
+            return null;
+          }
+          this.cancelRelease(handle);
+          console.log(
+            `[${LOG_LABEL2}] paused ${handle}, daemon idle ${Math.round(idleMs / 6e4)}m`
+          );
+          return handle;
+        })
+      );
+      return paused.filter((h) => h !== null);
+    } catch (err) {
+      console.warn(`[${LOG_LABEL2}] idle sweep failed: ${errMsg2(err)}`);
+      return [];
+    } finally {
+      this.sweeping = false;
+    }
+  }
   cancelRelease(handle) {
     const timer = this.releaseTimers.get(handle);
     if (timer) clearTimeout(timer);
     this.releaseTimers.delete(handle);
   }
   close() {
+    if (this.idleSweep) clearInterval(this.idleSweep);
     for (const timer of this.releaseTimers.values()) clearTimeout(timer);
     this.releaseTimers.clear();
     this.lookups.clear();
@@ -7351,6 +7426,21 @@ async function daemonAnswers(url) {
     return false;
   }
 }
+async function daemonIdleMs(url) {
+  try {
+    const res = await fetch(`${url}/_sandbox/idle`, {
+      signal: AbortSignal.timeout(HEALTH_PROBE_TIMEOUT_MS2)
+    });
+    if (!res.ok) {
+      await res.body?.cancel();
+      return null;
+    }
+    const body = await res.json();
+    return typeof body === "object" && body !== null && "idleMs" in body && typeof body.idleMs === "number" ? body.idleMs : null;
+  } catch {
+    return null;
+  }
+}
 function shellQuote(s) {
   return `'${s.replaceAll("'", `'\\''`)}'`;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decocms/sandbox-controller",
-  "version": "0.8.1",
+  "version": "0.8.3",
   "description": "Runs Studio agent sandboxes on Kubernetes, and serves them to a remote Studio.",
   "repository": {
     "type": "git",