@parel/sandbox-vercel 0.1.1 → 0.2.1

package/dist/index.js

@@ -1,8 +1,193 @@
 // src/index.ts
 import { Buffer } from "buffer";
-import {
-  PAREL_SANDBOX_CAPABILITY
-} from "@parel/capability-sandbox";
+
+// ../../capabilities/sandbox/dist/index.js
+var PAREL_SANDBOX_CAPABILITY = "parel.sandbox";
+var PROCESS_VIEW_STORE_PREFIX = "sandbox_process:";
+var PORT_VIEW_STORE_PREFIX = "sandbox_port:";
+function viewShellQuote(value) {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function viewCreateId(prefix) {
+  return `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+function clampBytes(value, fallback, max) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return fallback;
+  return Math.min(Math.floor(value), max);
+}
+function createSandboxCapabilityViews(capability, store) {
+  const requireFs = () => {
+    if (!capability.fs) {
+      throw new Error(`Sandbox provider ${capability.provider} does not support filesystem access`);
+    }
+    return capability.fs;
+  };
+  const shell = async (command, opts) => {
+    const proc = capability.process;
+    if (!proc) {
+      throw new Error(`Sandbox provider ${capability.provider} does not support process execution`);
+    }
+    if (proc.shell) return proc.shell(command, opts);
+    return proc.exec(["sh", "-lc", command], opts);
+  };
+  const filesystem = {
+    async readFile(path) {
+      return requireFs().readFile(path);
+    },
+    async writeFile(path, content) {
+      await requireFs().writeFile(path, content);
+    },
+    async exists(path) {
+      const fs = requireFs();
+      if (fs.exists) return fs.exists(path);
+      try {
+        await fs.readFile(path);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    async listDir(path) {
+      return (await requireFs().listDir(path)).map((entry) => entry.name);
+    }
+  };
+  const exec = {
+    async run(command) {
+      const result = await shell(command);
+      if (result.exitCode !== 0) {
+        const detail = [result.stdout, result.stderr].filter(Boolean).join("\n");
+        return `Exit code: ${result.exitCode}${detail ? `
+${detail}` : ""}`;
+      }
+      return result.stdout;
+    }
+  };
+  const processKey = (id) => `${PROCESS_VIEW_STORE_PREFIX}${id}`;
+  const process = {
+    async start(command, opts = {}) {
+      if (!command.trim()) throw new Error("command must be a non-empty string");
+      const id = viewCreateId("proc");
+      const dir = `/tmp/parel/processes/${id}`;
+      const stdoutPath = `${dir}/stdout.log`;
+      const stderrPath = `${dir}/stderr.log`;
+      const script = `(${command}) > ${viewShellQuote(stdoutPath)} 2> ${viewShellQuote(stderrPath)}`;
+      const runner = `nohup sh -lc ${viewShellQuote(script)} >/dev/null 2>&1 & echo $!`;
+      const launch = `mkdir -p ${viewShellQuote(dir)} && if command -v setsid >/dev/null 2>&1; then setsid ${runner}; else sh -lmc ${viewShellQuote(runner)}; fi`;
+      const result = await shell(launch, {
+        ...opts.cwd ? { cwd: opts.cwd } : {},
+        ...opts.envs ? { env: opts.envs } : {},
+        ...opts.timeoutMs ? { timeoutMs: opts.timeoutMs } : {}
+      });
+      const pid = Number.parseInt(result.stdout.trim().split("\n").pop() ?? "", 10);
+      if (!Number.isFinite(pid) || pid <= 0) {
+        throw new Error(`Failed to start background process: ${result.stderr || result.stdout}`);
+      }
+      const record = {
+        id,
+        pid,
+        command,
+        ...opts.cwd ? { cwd: opts.cwd } : {},
+        stdoutPath,
+        stderrPath,
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        status: "running"
+      };
+      await store.set(processKey(id), record);
+      return record;
+    },
+    async list() {
+      const keys = await store.list(PROCESS_VIEW_STORE_PREFIX);
+      const records = (await Promise.all(keys.map((key) => store.get(key)))).filter((record) => Boolean(record));
+      if (records.length === 0) return [];
+      const pids = records.map((record) => record.pid).join(" ");
+      const probe = await shell(
+        `for p in ${pids}; do kill -0 "$p" 2>/dev/null && echo "$p"; done; true`
+      );
+      const running = new Set(
+        probe.stdout.split("\n").map((line) => Number.parseInt(line.trim(), 10)).filter((pid) => Number.isFinite(pid))
+      );
+      return records.map((record) => ({
+        ...record,
+        status: record.status === "stopped" ? "stopped" : running.has(record.pid) ? "running" : "unknown"
+      }));
+    },
+    async tail(processId, opts = {}) {
+      const record = await store.get(processKey(processId));
+      if (!record) throw new Error(`unknown process: ${processId}`);
+      const maxBytes = clampBytes(opts.maxBytes, 32 * 1024, 1024 * 1024);
+      const readTail = async (path) => {
+        const result = await shell(
+          `tail -c ${maxBytes} ${viewShellQuote(path)} 2>/dev/null || true`
+        );
+        return result.stdout;
+      };
+      return {
+        stdout: await readTail(record.stdoutPath),
+        stderr: await readTail(record.stderrPath),
+        stdoutPath: record.stdoutPath,
+        stderrPath: record.stderrPath
+      };
+    },
+    async stop(processId) {
+      const record = await store.get(processKey(processId));
+      if (!record) throw new Error(`unknown process: ${processId}`);
+      const result = await shell(
+        `kill -- -${record.pid} 2>/dev/null; kill ${record.pid} 2>/dev/null; sleep 0.2; if kill -0 -- -${record.pid} 2>/dev/null || kill -0 ${record.pid} 2>/dev/null; then echo still-alive; fi`
+      );
+      const stopped = !result.stdout.includes("still-alive");
+      const next = {
+        ...record,
+        status: stopped ? "stopped" : record.status
+      };
+      await store.set(processKey(processId), next);
+      return { stopped, process: next };
+    }
+  };
+  const portKey = (id) => `${PORT_VIEW_STORE_PREFIX}${id}`;
+  const ports = {
+    async expose(port, opts = {}) {
+      if (!capability.ports) {
+        throw new Error(`Sandbox provider ${capability.provider} does not support ports`);
+      }
+      const protocol = opts.protocol ?? "https";
+      const exposed = await capability.ports.expose(port, { protocol });
+      const url = exposed.url.includes("://") ? exposed.url : `${protocol}://${exposed.url}`;
+      const host = url.replace(/^[a-z]+:\/\//, "");
+      const record = {
+        id: String(exposed.port),
+        port: exposed.port,
+        host,
+        url,
+        protocol: exposed.protocol ?? protocol,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await store.set(portKey(record.id), record);
+      return record;
+    },
+    async list() {
+      const keys = await store.list(PORT_VIEW_STORE_PREFIX);
+      return (await Promise.all(keys.map((key) => store.get(key)))).filter(
+        (record) => Boolean(record)
+      );
+    },
+    async revoke(port) {
+      const key = portKey(String(port));
+      const existing = await store.get(key);
+      if (!existing) return false;
+      if (!capability.ports?.unexpose) {
+        throw new Error(
+          `Sandbox provider ${capability.provider} cannot unexpose ports; the exposed URL stays live until the sandbox stops`
+        );
+      }
+      await capability.ports.unexpose(existing.port);
+      await store.delete(key);
+      return true;
+    }
+  };
+  return { filesystem, exec, process, ports };
+}
+
+// src/index.ts
 import { definePlugin, LifecycleEvent } from "@parel/plugin-sdk";
 import { Sandbox as VercelSandboxClient } from "@vercel/sandbox";
 
@@ -12,7 +197,7 @@ var parel_plugin_default = {
   version: "0.0.0",
   description: "Provides the standard parel.sandbox capability backed by Vercel Sandbox.",
   provides: {
-    capabilities: ["parel.sandbox"]
+    capabilities: ["parel.sandbox", "filesystem", "exec", "process", "ports"]
   },
   requires: {
     permissions: {
@@ -316,6 +501,11 @@ var index_default = definePlugin({
       await disposeSandbox();
     });
     ctx.provide(PAREL_SANDBOX_CAPABILITY, capability);
+    const views = createSandboxCapabilityViews(capability, ctx.store);
+    ctx.provide("filesystem", views.filesystem);
+    ctx.provide("exec", views.exec);
+    ctx.provide("process", views.process);
+    ctx.provide("ports", views.ports);
   }
 });
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parel/sandbox-vercel",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "description": "PAREL sandbox capability provider plugin for Vercel Sandbox.",
   "license": "MIT",
   "repository": {
@@ -15,7 +15,6 @@
   "type": "module",
   "exports": {
     ".": {
-      "bun": "./src/index.ts",
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     }
@@ -26,15 +25,10 @@
     "LICENSE",
     "README.md"
   ],
-  "scripts": {
-    "build": "tsup",
-    "test": "vitest run --passWithNoTests",
-    "lint": "biome check src/"
-  },
   "dependencies": {
-    "@parel/capability-sandbox": "workspace:*",
-    "@parel/plugin-sdk": "workspace:*",
-    "@vercel/sandbox": "^2.1.1"
+    "@vercel/sandbox": "^2.1.1",
+    "@parel/capability-sandbox": "0.2.0",
+    "@parel/plugin-sdk": "0.4.1"
   },
   "devDependencies": {
     "@types/node": "^25.9.1",
@@ -43,12 +37,11 @@
     "vitest": "^4.1.8"
   },
   "publishConfig": {
-    "exports": {
-      ".": {
-        "types": "./dist/index.d.ts",
-        "import": "./dist/index.js"
-      }
-    },
     "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run --passWithNoTests",
+    "lint": "biome check src/"
   }
-}
+}

package/parel.plugin.json

@@ -3,7 +3,7 @@
   "version": "0.0.0",
   "description": "Provides the standard parel.sandbox capability backed by Vercel Sandbox.",
   "provides": {
-    "capabilities": ["parel.sandbox"]
+    "capabilities": ["parel.sandbox", "filesystem", "exec", "process", "ports"]
   },
   "requires": {
     "permissions": {