@parel/sandbox-vercel 0.2.9 → 0.3.1

package/dist/index.js

@@ -31,8 +31,8 @@ function createSandboxCapabilityViews(capability, store) {
     return proc.exec(["sh", "-lc", command], opts);
   };
   const filesystem = {
-    async readFile(path) {
-      return requireFs().readFile(path);
+    async readFile(path, opts) {
+      return requireFs().readFile(path, opts);
     },
     async writeFile(path, content) {
       await requireFs().writeFile(path, content);
@@ -237,6 +237,8 @@ var parel_plugin_default = {
 
 // src/index.ts
 var STORE_KEY = "vercel_sandbox_name";
+var PROCESS_VIEW_STORE_PREFIX2 = "sandbox_process:";
+var PORT_VIEW_STORE_PREFIX2 = "sandbox_port:";
 function stringConfig(value) {
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
@@ -317,7 +319,26 @@ var index_default = definePlugin({
     const teamId = stringConfig(ctx.config.teamId);
     const projectId = stringConfig(ctx.config.projectId);
     const destroyOnSessionEnd = ctx.config.destroyOnSessionEnd !== false;
+    const externalName = stringConfig(ctx.config.name);
+    const istore = ctx.instanceStore;
+    const state = istore ? {
+      async get(key) {
+        return (await istore.get(key))?.value ?? null;
+      },
+      set(key, value) {
+        return istore.set(key, value);
+      },
+      delete(key) {
+        return istore.delete(key);
+      },
+      list(prefix) {
+        return istore.list(prefix);
+      }
+    } : ctx.store;
+    const managed = Boolean(istore) && !externalName;
     let sandbox = null;
+    let sandboxRecovery = null;
+    let sandboxEpoch = 0;
     function credentials() {
       if (!token || !teamId || !projectId) {
         ctx.log.warn("Vercel Sandbox token, teamId, and projectId are required");
@@ -325,50 +346,238 @@ var index_default = definePlugin({
       }
       return { token, teamId, projectId };
     }
-    function requireSandbox() {
-      if (!sandbox) throw new Error("Vercel sandbox not available");
-      return sandbox;
+    async function createRawSandbox() {
+      const creds = credentials();
+      if (!creds) return null;
+      const params = { ...buildCreateParams(ctx.config), ...creds };
+      const created = await VercelSandboxClient.create(params);
+      ctx.log.info(`Vercel sandbox created: ${created.name}`);
+      return created;
     }
-    async function ensureSandbox() {
+    async function reconnectSandbox(name) {
+      const creds = credentials();
+      if (!creds) return null;
+      try {
+        const s = await VercelSandboxClient.get({ name, ...creds });
+        ctx.log.info(`Vercel sandbox connected: ${name}`);
+        return s;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        ctx.log.warn(`Failed to connect Vercel sandbox ${name}: ${message}`);
+        return null;
+      }
+    }
+    async function killSandboxById(name) {
+      const creds = credentials();
+      if (!creds) return false;
+      try {
+        const s = await VercelSandboxClient.get({ name, ...creds });
+        await s.delete();
+        return true;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        ctx.log.warn(`Failed to kill Vercel sandbox ${name}: ${message}`);
+        return false;
+      }
+    }
+    async function moveLegacyRecords(promote) {
+      for (const prefix of [PROCESS_VIEW_STORE_PREFIX2, PORT_VIEW_STORE_PREFIX2]) {
+        for (const key of await ctx.store.list(prefix)) {
+          if (promote) {
+            const record = await ctx.store.get(key);
+            if (record !== null) await state.set(key, record);
+          }
+          await ctx.store.delete(key);
+        }
+      }
+    }
+    async function clearViewRecords() {
+      for (const prefix of [PROCESS_VIEW_STORE_PREFIX2, PORT_VIEW_STORE_PREFIX2]) {
+        for (const key of await state.list(prefix)) {
+          await state.delete(key);
+        }
+      }
+    }
+    async function migrateLegacyHandle() {
+      if (!istore) return;
+      const legacy = await ctx.store.get(STORE_KEY);
+      if (!legacy) return;
+      const authoritative = await istore.get(STORE_KEY);
+      if (!authoritative) {
+        const reconnected = await reconnectSandbox(legacy);
+        if (!reconnected) {
+          await ctx.store.delete(STORE_KEY);
+          await moveLegacyRecords(false);
+          return;
+        }
+        if (await istore.cas(STORE_KEY, null, legacy)) {
+          await ctx.store.delete(STORE_KEY);
+          await moveLegacyRecords(true);
+          ctx.log.info(`Vercel sandbox ${legacy} migrated to the instance store`);
+          return;
+        }
+      }
+      if ((await istore.get(STORE_KEY))?.value !== legacy) {
+        await killSandboxById(legacy);
+        ctx.log.info(`Vercel legacy sandbox ${legacy} reaped (instance already has a sandbox)`);
+      }
+      await ctx.store.delete(STORE_KEY);
+      await moveLegacyRecords(false);
+    }
+    async function acquireSharedSandbox() {
+      if (!istore) throw new Error("acquireSharedSandbox requires an instance store");
+      await migrateLegacyHandle();
+      for (let attempt = 0; attempt < 3; attempt++) {
+        const entry = await istore.get(STORE_KEY);
+        if (entry) {
+          const reconnected = await reconnectSandbox(entry.value);
+          if (reconnected) {
+            const current = await istore.get(STORE_KEY);
+            if (current?.value === entry.value) return reconnected;
+            continue;
+          }
+          const fresh2 = await createRawSandbox();
+          if (!fresh2) return null;
+          if (await istore.cas(STORE_KEY, entry.version, fresh2.name)) {
+            ctx.log.warn(
+              `Vercel filesystem reset: sandbox ${entry.value} was unreachable, swapped in ${fresh2.name} (files in the previous sandbox are lost)`
+            );
+            await killSandboxById(entry.value);
+            await clearViewRecords();
+            return fresh2;
+          }
+          await killSandboxById(fresh2.name);
+          continue;
+        }
+        const fresh = await createRawSandbox();
+        if (!fresh) return null;
+        if (await istore.cas(STORE_KEY, null, fresh.name)) return fresh;
+        await killSandboxById(fresh.name);
+      }
+      throw new Error("Vercel sandbox acquisition kept losing instance-store races; giving up");
+    }
+    async function acquirePerSession() {
       const creds = credentials();
       if (!creds) return null;
       const savedName = await ctx.store.get(STORE_KEY);
       const name = stringConfig(ctx.config.name) ?? savedName;
       const params = { ...buildCreateParams(ctx.config), ...creds };
+      let next;
       if (name) {
-        sandbox = await VercelSandboxClient.getOrCreate({
+        next = await VercelSandboxClient.getOrCreate({
           ...params,
           name
         });
       } else {
-        sandbox = await VercelSandboxClient.create(params);
+        next = await VercelSandboxClient.create(params);
       }
-      await ctx.store.set(STORE_KEY, sandbox.name);
-      ctx.log.info(`Vercel sandbox ready: ${sandbox.name}`);
-      return sandbox;
+      await ctx.store.set(STORE_KEY, next.name);
+      ctx.log.info(`Vercel sandbox ready: ${next.name}`);
+      return next;
     }
-    async function disposeSandbox() {
-      if (!sandbox) return;
-      try {
-        if (destroyOnSessionEnd) {
-          await sandbox.delete();
-          await ctx.store.delete(STORE_KEY);
-        } else {
-          await sandbox.stop();
-        }
-      } finally {
+    function acquire() {
+      return managed ? acquireSharedSandbox() : acquirePerSession();
+    }
+    async function ensureSandbox() {
+      const cached = sandbox;
+      if (cached) {
+        if (!managed) return cached;
+        const authoritative = await istore?.get(STORE_KEY);
+        if (authoritative?.value === cached.name) return cached;
+        if (sandbox === cached) sandbox = null;
+      }
+      if (!sandboxRecovery) {
+        const epoch = sandboxEpoch;
+        sandboxRecovery = acquire().then(async (s) => {
+          if (epoch !== sandboxEpoch) {
+            if (managed) {
+              throw new Error("Vercel sandbox recovery discarded: session torn down");
+            }
+            if (s && destroyOnSessionEnd) {
+              await killSandboxById(s.name);
+              await ctx.store.delete(STORE_KEY);
+            }
+            throw new Error("Vercel sandbox was torn down during recovery");
+          }
+          sandbox = s;
+          return s;
+        }).finally(() => {
+          sandboxRecovery = null;
+        });
+      }
+      return sandboxRecovery;
+    }
+    async function requireSandbox() {
+      const s = await ensureSandbox();
+      if (!s) throw new Error("Vercel sandbox not available");
+      return s;
+    }
+    async function releaseSandbox() {
+      sandboxEpoch++;
+      if (sandboxRecovery) {
+        await sandboxRecovery.catch(() => {
+        });
+      }
+      sandbox = null;
+    }
+    async function destroySandbox() {
+      sandboxEpoch++;
+      if (sandboxRecovery) {
+        await sandboxRecovery.catch(() => {
+        });
+      }
+      if (istore) {
         sandbox = null;
+        const entry = await istore.get(STORE_KEY);
+        if (entry) {
+          const retired = await istore.casDelete?.(STORE_KEY, entry.version) ?? false;
+          if (!retired && istore.casDelete) {
+            ctx.log.warn("Vercel stop skipped: the instance sandbox changed mid-stop");
+            await ctx.store.delete(STORE_KEY);
+            return;
+          }
+          if (!istore.casDelete) await istore.delete(STORE_KEY);
+          if (await killSandboxById(entry.value)) {
+            ctx.log.info(`Vercel sandbox destroyed: ${entry.value}`);
+          }
+          await clearViewRecords();
+        }
+        await ctx.store.delete(STORE_KEY);
+        return;
+      }
+      const target = sandbox?.name ?? await ctx.store.get(STORE_KEY);
+      sandbox = null;
+      if (target && await killSandboxById(target)) {
+        ctx.log.info(`Vercel sandbox destroyed: ${target}`);
+      }
+      await clearViewRecords();
+      await ctx.store.delete(STORE_KEY);
+    }
+    async function disposeSandbox() {
+      sandboxEpoch++;
+      if (sandboxRecovery) {
+        await sandboxRecovery.catch(() => {
+        });
+      }
+      const current = sandbox;
+      sandbox = null;
+      if (!current) return;
+      if (destroyOnSessionEnd) {
+        await current.delete();
+        await ctx.store.delete(STORE_KEY);
+      } else {
+        await current.stop();
       }
     }
     async function execCommand(command, opts) {
-      const finished = await requireSandbox().runCommand(
-        runParams(command, opts)
-      );
+      const s = await requireSandbox();
+      const finished = await s.runCommand(runParams(command, opts));
       return commandResult(finished, opts);
     }
     async function shellCommand(command, opts) {
       const shell = opts?.shell ?? "sh";
-      const finished = await requireSandbox().runCommand({
+      const s = await requireSandbox();
+      const finished = await s.runCommand({
         cmd: shell,
         args: ["-lc", command],
         cwd: opts?.cwd,
@@ -415,30 +624,32 @@ var index_default = definePlugin({
       },
       fs: {
         async readFile(path, opts) {
-          const content = await requireSandbox().fs.readFile(path, {
+          const s = await requireSandbox();
+          const content = await s.fs.readFile(path, {
             encoding: opts?.encoding === "base64" ? null : "utf8"
           });
           const text = Buffer.isBuffer(content) ? content.toString("base64") : content;
           return opts?.maxChars ? limitOutput(text, opts.maxChars) : text;
         },
         async writeFile(path, content, opts) {
+          const s = await requireSandbox();
           const data = opts?.encoding === "base64" ? Buffer.from(content, "base64") : content;
-          if (opts?.append && requireSandbox().fs.appendFile) {
-            await requireSandbox().fs.appendFile?.(path, data);
+          if (opts?.append && s.fs.appendFile) {
+            await s.fs.appendFile(path, data);
           } else {
-            await requireSandbox().fs.writeFile(path, data);
+            await s.fs.writeFile(path, data);
           }
         },
         async listDir(path) {
-          return (await requireSandbox().fs.readdir(path, { withFileTypes: true })).map(
-            (entry) => ({
-              name: entry.name,
-              type: mapDirentType(entry)
-            })
-          );
+          const s = await requireSandbox();
+          return (await s.fs.readdir(path, { withFileTypes: true })).map((entry) => ({
+            name: entry.name,
+            type: mapDirentType(entry)
+          }));
         },
         async stat(path) {
-          const stats = await requireSandbox().fs.stat(path);
+          const s = await requireSandbox();
+          const stats = await s.fs.stat(path);
           return {
             path,
             type: mapStatsType(stats),
@@ -448,23 +659,28 @@ var index_default = definePlugin({
           };
         },
         async exists(path) {
-          return requireSandbox().fs.exists(path);
+          const s = await requireSandbox();
+          return s.fs.exists(path);
         },
         async mkdir(path, opts) {
-          await requireSandbox().fs.mkdir(path, { recursive: opts?.recursive });
+          const s = await requireSandbox();
+          await s.fs.mkdir(path, { recursive: opts?.recursive });
         },
         async remove(path, opts) {
-          await requireSandbox().fs.rm(path, { recursive: opts?.recursive, force: true });
+          const s = await requireSandbox();
+          await s.fs.rm(path, { recursive: opts?.recursive, force: true });
         },
         async rename(from, to) {
-          await requireSandbox().fs.rename(from, to);
+          const s = await requireSandbox();
+          await s.fs.rename(from, to);
         }
       },
       process: {
         exec: execCommand,
         shell: shellCommand,
         async spawn(command, opts) {
-          const handle = await requireSandbox().runCommand({
+          const s = await requireSandbox();
+          const handle = await s.runCommand({
             ...runParams(command, opts),
             detached: true
           });
@@ -473,35 +689,52 @@ var index_default = definePlugin({
       },
       ports: {
         async expose(port) {
-          return { port, url: requireSandbox().domain(port), protocol: "https" };
+          const s = await requireSandbox();
+          return { port, url: s.domain(port), protocol: "https" };
         }
       },
       lifecycle: {
         async isRunning() {
-          return String(sandbox?.status ?? "running") === "running";
+          if (!sandbox) return false;
+          return String(sandbox.status ?? "running") === "running";
         },
         async stop() {
-          await requireSandbox().stop();
+          if (istore) {
+            await destroySandbox();
+            return;
+          }
+          if (!sandbox) throw new Error("Vercel sandbox not available");
+          await sandbox.stop();
         },
         async extendTimeout(timeoutMs) {
-          await requireSandbox().extendTimeout?.(timeoutMs);
+          const s = await requireSandbox();
+          await s.extendTimeout?.(timeoutMs);
         }
       }
     };
     ctx.hook(LifecycleEvent.SessionStart, async () => {
-      await ensureSandbox();
+      sandbox = await acquire();
     });
     ctx.hook(LifecycleEvent.SessionResume, async () => {
-      await ensureSandbox();
+      sandbox = null;
+      sandbox = await acquire();
     });
     ctx.hook(LifecycleEvent.SessionSuspend, async () => {
-      if (sandbox) await ctx.store.set(STORE_KEY, sandbox.name);
+      if (!istore && sandbox) await ctx.store.set(STORE_KEY, sandbox.name);
     });
     ctx.hook(LifecycleEvent.SessionEnd, async () => {
-      await disposeSandbox();
+      if (!istore) {
+        await disposeSandbox();
+        return;
+      }
+      if (ctx.instance?.ephemeral) {
+        await destroySandbox();
+        return;
+      }
+      await releaseSandbox();
     });
     ctx.provide(PAREL_SANDBOX_CAPABILITY, capability);
-    const views = createSandboxCapabilityViews(capability, ctx.store);
+    const views = createSandboxCapabilityViews(capability, state);
     ctx.provide("filesystem", views.filesystem);
     ctx.provide("exec", views.exec);
     ctx.provide("process", views.process);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parel/sandbox-vercel",
-  "version": "0.2.9",
+  "version": "0.3.1",
   "description": "PAREL sandbox capability provider plugin for Vercel Sandbox.",
   "license": "MIT",
   "repository": {
@@ -27,8 +27,8 @@
   ],
   "dependencies": {
     "@vercel/sandbox": "^2.1.1",
-    "@parel/capability-sandbox": "0.2.0",
-    "@parel/plugin-sdk": "0.10.1"
+    "@parel/capability-sandbox": "0.3.0",
+    "@parel/plugin-sdk": "0.11.0"
   },
   "devDependencies": {
     "@types/node": "^25.9.1",