@computesdk/archil 0.4.12 → 0.4.14

package/README.md

@@ -2,10 +2,21 @@
 
 [Archil](https://archil.com) provider for [ComputeSDK](https://www.computesdk.com).
 
-`create` resolves a handle to an existing Archil disk id, and `runCommand`
-executes shell commands in a managed container with that disk attached via the
-control-plane `exec` endpoint. `destroy` is a no-op because disk lifecycle is
-managed by Archil. `getById` requires a disk id.
+The provider supports Archil's two compute surfaces, selected by the
+`execution` config option:
+
+- **`exec`** (default): `create` resolves a handle to an existing Archil disk
+  id, and `runCommand` executes shell commands in a managed ephemeral
+  container with that disk attached via the control-plane `exec` endpoint.
+  `destroy` is a no-op because disk lifecycle is managed by Archil.
+  `getById` requires a disk id.
+- **`persistent`**: `create` provisions a persistent Archil sandbox — a
+  long-running Linux VM with a dedicated disk — and waits until it is
+  `running`. `runCommand` uses the sandbox's interactive process API over a
+  short-lived WebSocket connection (a fresh connection URL is fetched per
+  command, so expiry is handled automatically). `destroy` deletes the
+  sandbox, `getById` fetches the sandbox and resumes it if paused, and
+  `getUrl` resolves the sandbox's published endpoints.
 
 ## Installation
 
@@ -15,11 +26,12 @@ npm install @computesdk/archil
 
 ## Configuration
 
-| Option    | Env var            | Required | Description                                |
-| --------- | ------------------ | -------- | ------------------------------------------ |
-| `apiKey`  | `ARCHIL_API_KEY`   | yes      | Archil control-plane API key               |
-| `region`  | `ARCHIL_REGION`    | yes      | Archil region (e.g. `aws-us-east-1`)       |
-| `baseUrl` | —                  | no       | Override control-plane URL (for testing)   |
+| Option      | Env var            | Required | Description                                    |
+| ----------- | ------------------ | -------- | ----------------------------------------------- |
+| `apiKey`    | `ARCHIL_API_KEY`   | yes      | Archil control-plane API key                    |
+| `region`    | `ARCHIL_REGION`    | yes      | Archil region (e.g. `aws-us-east-1`)            |
+| `baseUrl`   | —                  | no       | Override control-plane URL (for testing)        |
+| `execution` | —                  | no       | `"exec"` (default) or `"persistent"`                |
 
 ## Usage
 
@@ -44,28 +56,78 @@ await provider.sandbox.destroy(sandbox.sandboxId);
 
 `create()` requires top-level `diskId` as the target disk id.
 
+### Persistent mode
+
+```ts
+const provider = archil({ execution: 'persistent' });
+
+const sandbox = await provider.sandbox.create({
+  name: 'ci-job',
+  baseImage: 'node:24-bookworm', // OCI image; `templateId` works too
+  vcpus: 4,                      // or `cpu` / `cpus`
+  memoryMiB: 8192,               // or `memory`
+  env: { CI: '1' },
+  maxTtlSeconds: 3600,           // per powered-on session
+  sandbox: { /* extra Archil fields, e.g. network policy */ },
+});
+
+// cwd/env/installs and background processes persist between calls.
+await sandbox.runCommand('npm ci', { cwd: '/repo' });
+await sandbox.runCommand('npm test', { cwd: '/repo' });
+
+// Paused sandboxes are resumed automatically on getById/runCommand.
+const resumed = await provider.sandbox.getById(sandbox.sandboxId);
+
+await provider.sandbox.destroy(sandbox.sandboxId); // deletes the sandbox
+```
+
+Sandbox `create` accepts generic `CreateSandboxOptions` fields (`vcpus`/`cpu`/`cpus`,
+`memory`/`memoryMiB`, `image`/`templateId`, `envs`, `timeout` (ms → `maxTtlSeconds`))
+plus the Archil-specific keys shown above.
+
+The shared `ephemeral` create option overrides the configured mode per sandbox:
+`ephemeral: true` resolves an exec-mode disk handle (requires `diskId`),
+`ephemeral: false` provisions a persistent sandbox — matching the same flag on
+other dual-mode providers like Upstash. `getById`/`list`/`destroy` follow the
+configured `execution` mode.
+
+### Choosing a mode
+
+|                       | `exec`                          | `persistent`                                |
+| --------------------- | ------------------------------- | ------------------------------------------- |
+| Compute               | Ephemeral container per command | Persistent VM                               |
+| `cwd`/`env`/installs  | Lost between commands           | Persist while running                       |
+| Filesystem writes     | Only under `/mnt/archil`        | Anywhere on the VM                          |
+| Background processes  | Die with the container          | Keep running                                |
+| `create` input        | Existing `diskId`               | Sandbox spec (image, vcpus, memory, …)      |
+| Billing               | Per `executeMs`                 | Per running wall-clock time                 |
+| `getUrl`              | ❌                              | ✅ (published endpoints)                    |
+
 ## Supported operations
 
-| Method        | Supported | Notes                                                       |
-| ------------- | --------- | ----------------------------------------------------------- |
-| `create`      | ✅        | Resolves an existing disk from top-level `diskId`.          |
-| `getById`     | ✅        | Requires the disk id.                                        |
-| `list`        | ✅        | Lists all disks visible to the API key.                     |
-| `destroy`     | no-op     | Disk lifecycle is managed by Archil.                        |
-| `runCommand`  | ✅        | Executes shell commands through Archil's HTTP `exec` endpoint. |
-| `getInfo`     | ✅        |                                                             |
-| `getUrl`      | ❌        | Each exec runs in a fresh ephemeral container — no port to expose. |
-| `filesystem`  | ✅        | Maps paths into `/mnt/archil` and manages shared-mode checkout/checkin automatically. |
+| Method        | exec mode | persistent mode |
+| ------------- | --------- | ------------ |
+| `create`      | ✅ Resolves an existing disk from top-level `diskId`. | ✅ Provisions a sandbox, waits for `running`. |
+| `getById`     | ✅ Requires the disk id. | ✅ Fetches the sandbox; resumes if paused/stopped. |
+| `list`        | ✅ Lists all disks visible to the API key. | ✅ Lists sandboxes. |
+| `destroy`     | no-op — disk lifecycle is managed by Archil. | ✅ Deletes the sandbox and its backing disk. |
+| `runCommand`  | ✅ Executes via the HTTP `exec` endpoint. | ✅ Executes via the process API (fresh connection URL per command). |
+| `getInfo`     | ✅ | ✅ |
+| `getUrl`      | ❌ Ephemeral containers have no port to expose. | ✅ Resolves the sandbox's endpoint for the port. |
+| `filesystem`  | ✅ Maps paths into `/mnt/archil`; manages shared-mode checkout/checkin. | ✅ Uses the sandbox file transfer API; paths are the VM's real paths. |
 
 ## Limitations
 
-- Each `exec` call provisions a fresh container — there is no persistent
-  state between calls beyond what is written to the disk.
-- Responses are truncated to ~5 MB by the Archil control plane.
-- `getUrl` is not supported — each exec runs in a fresh ephemeral container,
-  so there is no long-lived process to expose a port on.
-- Filesystem operations accept normal absolute paths and map them into the
-  `/mnt/archil` disk mount internally. Each mutating operation checks out and
-  checks in the disk automatically.
-- Raw `runCommand` strings are not rewritten. Commands that access the disk
-  directly must use `/mnt/archil` themselves.
+- **exec mode**: each `exec` call provisions a fresh container — there is no
+  persistent state between calls beyond what is written to the disk.
+- **exec mode**: responses are truncated to ~5 MB by the Archil control plane.
+- **exec mode**: `getUrl` is not supported — each exec runs in a fresh
+  ephemeral container, so there is no long-lived process to expose a port on.
+- **exec mode**: filesystem operations accept normal absolute paths and map
+  them into the `/mnt/archil` disk mount internally. Each mutating operation
+  checks out and checks in the disk automatically. Raw `runCommand` strings
+  are not rewritten — commands that access the disk must use `/mnt/archil`
+  themselves.
+- **persistent mode**: `pause`/`resume`/`fork` are available on the underlying
+  `disk`-SDK sandbox via `getInstance()` — the generic provider interface has
+  no `pause`/`resume` methods, so only `getById`/`runCommand` auto-resume.

package/dist/index.d.mts

@@ -1,6 +1,12 @@
 import * as _computesdk_provider from '@computesdk/provider';
-import { Archil } from 'disk';
+import { Archil, Sandbox } from 'disk';
 
+/**
+ * Archil execution mode:
+ * - "exec": serverless per-command containers on a disk (default).
+ * - "persistent": a persistent sandbox VM run through the process API.
+ */
+type ArchilExecutionMode = 'exec' | 'persistent';
 interface ArchilConfig {
     /** Archil API key. Falls back to ARCHIL_API_KEY env var. */
     apiKey?: string;
@@ -8,6 +14,13 @@ interface ArchilConfig {
     region?: string;
     /** Override the control-plane base URL (useful for testing). */
     baseUrl?: string;
+    /**
+     * Which Archil compute surface to use. Defaults to "exec". In
+     * "persistent" mode create() provisions a persistent sandbox VM instead of
+     * resolving a disk handle. Per-sandbox override: `ephemeral` on
+     * create() options (true -> exec handle, false -> persistent VM).
+     */
+    execution?: ArchilExecutionMode;
 }
 interface DiskResponse {
     id: string;
@@ -22,13 +35,16 @@ type DiskHandle = Pick<DiskResponse, 'id'>;
 interface ResolvedConfig {
     apiKey: string;
     baseUrl: string;
+    execution: ArchilExecutionMode;
 }
 interface ArchilSandbox {
     client: Archil;
     disk: DiskHandle | DiskResponse;
+    /** Set only in "persistent" execution mode. */
+    vm?: Sandbox;
     resolved: ResolvedConfig;
     createdAt: Date;
 }
 declare const archil: (config?: ArchilConfig) => _computesdk_provider.Provider<ArchilSandbox, any, any>;
 
-export { type ArchilConfig, type ArchilSandbox, archil };
+export { type ArchilConfig, type ArchilExecutionMode, type ArchilSandbox, archil };

package/dist/index.d.ts

@@ -1,6 +1,12 @@
 import * as _computesdk_provider from '@computesdk/provider';
-import { Archil } from 'disk';
+import { Archil, Sandbox } from 'disk';
 
+/**
+ * Archil execution mode:
+ * - "exec": serverless per-command containers on a disk (default).
+ * - "persistent": a persistent sandbox VM run through the process API.
+ */
+type ArchilExecutionMode = 'exec' | 'persistent';
 interface ArchilConfig {
     /** Archil API key. Falls back to ARCHIL_API_KEY env var. */
     apiKey?: string;
@@ -8,6 +14,13 @@ interface ArchilConfig {
     region?: string;
     /** Override the control-plane base URL (useful for testing). */
     baseUrl?: string;
+    /**
+     * Which Archil compute surface to use. Defaults to "exec". In
+     * "persistent" mode create() provisions a persistent sandbox VM instead of
+     * resolving a disk handle. Per-sandbox override: `ephemeral` on
+     * create() options (true -> exec handle, false -> persistent VM).
+     */
+    execution?: ArchilExecutionMode;
 }
 interface DiskResponse {
     id: string;
@@ -22,13 +35,16 @@ type DiskHandle = Pick<DiskResponse, 'id'>;
 interface ResolvedConfig {
     apiKey: string;
     baseUrl: string;
+    execution: ArchilExecutionMode;
 }
 interface ArchilSandbox {
     client: Archil;
     disk: DiskHandle | DiskResponse;
+    /** Set only in "persistent" execution mode. */
+    vm?: Sandbox;
     resolved: ResolvedConfig;
     createdAt: Date;
 }
 declare const archil: (config?: ArchilConfig) => _computesdk_provider.Provider<ArchilSandbox, any, any>;
 
-export { type ArchilConfig, type ArchilSandbox, archil };
+export { type ArchilConfig, type ArchilExecutionMode, type ArchilSandbox, archil };

package/dist/index.js

@@ -62,7 +62,7 @@ function resolveConfig(config) {
     }
     baseUrl = regionToBaseUrl(region);
   }
-  return { apiKey, baseUrl };
+  return { apiKey, baseUrl, execution: config.execution ?? "exec" };
 }
 function createClient(config, resolved) {
   const region = config.region ?? process.env.ARCHIL_REGION ?? "aws-us-east-1";
@@ -80,8 +80,11 @@ function resolveCreateDiskId(options) {
 function shellEscape(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
-function mapFilesystemPath(path) {
+function mapFilesystemPath(sandbox, path) {
   const normalized = import_node_path.posix.normalize(path.startsWith("/") ? path : `/${path}`);
+  if (sandbox.vm) {
+    return normalized;
+  }
   if (normalized === "/") {
     return ARCHIL_MOUNT_ROOT;
   }
@@ -90,13 +93,17 @@ function mapFilesystemPath(path) {
   }
   return `${ARCHIL_MOUNT_ROOT}${normalized}`;
 }
-function withDiskWriteLock(command) {
+function withDiskWriteLockCommand(command) {
   const mountRoot = shellEscape(ARCHIL_MOUNT_ROOT);
   return [
     `archil checkout --force --yes ${mountRoot}`,
     `{ ${command}; status=$?; archil checkin ${mountRoot}; checkin_status=$?; if [ $status -ne 0 ]; then exit $status; fi; exit $checkin_status; }`
   ].join(" && ");
 }
+function withDiskWriteLock(sandbox, command) {
+  if (sandbox.vm) return command;
+  return withDiskWriteLockCommand(command);
+}
 function execCommandBytes(command) {
   return Buffer.byteLength(wrapCommand(command), "utf8");
 }
@@ -123,7 +130,7 @@ function maxWriteChunkSize(parent, tempPath, diskPath) {
   let high = ARCHIL_MAX_EXEC_COMMAND_BYTES;
   while (low < high) {
     const candidate = Math.ceil((low + high) / 2);
-    const command = withDiskWriteLock(
+    const command = withDiskWriteLockCommand(
       buildWriteChunkCommand(
         parent,
         tempPath,
@@ -166,6 +173,42 @@ function wrapCommand(command, options) {
 async function execOnDisk(sandbox, command) {
   return sandbox.client.disks.exec(sandbox.disk.id, command);
 }
+function wrapSandboxCommand(command, options) {
+  let wrapped = command;
+  if (options?.cwd) {
+    wrapped = `cd ${shellEscape(options.cwd)} && ${wrapped}`;
+  }
+  if (options?.background) {
+    wrapped = `nohup sh -c ${shellEscape(wrapped)} > /dev/null 2>&1 &`;
+  }
+  return wrapped;
+}
+async function ensureVmRunning(vm) {
+  await vm.refresh();
+  if (vm.status === "running") return;
+  if (vm.status === "paused") {
+    await vm.resume();
+  } else if (vm.status === "stopped" || vm.status === "exited") {
+    await vm.start();
+  }
+}
+function toSandboxRequest(options) {
+  const request = {
+    ...options?.sandbox,
+    name: options?.name,
+    baseImage: options?.baseImage ?? options?.image ?? options?.templateId,
+    env: options?.env ?? options?.envs,
+    vcpuCount: options?.vcpus ?? options?.cpu ?? options?.cpus,
+    memSizeMiB: options?.memoryMiB ?? options?.memory
+  };
+  if (options?.maxTtlSeconds !== void 0) {
+    request.maxTtlSeconds = options.maxTtlSeconds;
+  } else if (options?.timeout !== void 0) {
+    request.maxTtlSeconds = Math.ceil(options.timeout / 1e3);
+  }
+  return request;
+}
+var sandboxModes = /* @__PURE__ */ new Map();
 var _provider = (0, import_provider.defineProvider)({
   name: "archil",
   methods: {
@@ -173,7 +216,25 @@ var _provider = (0, import_provider.defineProvider)({
       create: async (config, options) => {
         const resolved = resolveConfig(config);
         const client = createClient(config, resolved);
+        const execution = options?.ephemeral !== void 0 ? options.ephemeral ? "exec" : "persistent" : resolved.execution;
+        if (execution === "persistent") {
+          const vm = await client.sandboxes.create(toSandboxRequest(options), {
+            wait: true
+          });
+          sandboxModes.set(vm.id, "persistent");
+          return {
+            sandbox: {
+              client,
+              disk: { id: vm.id },
+              vm,
+              resolved,
+              createdAt: /* @__PURE__ */ new Date()
+            },
+            sandboxId: vm.id
+          };
+        }
         const diskId = resolveCreateDiskId(options);
+        sandboxModes.set(diskId, "exec");
         return {
           sandbox: {
             client,
@@ -188,6 +249,20 @@ var _provider = (0, import_provider.defineProvider)({
         const resolved = resolveConfig(config);
         const client = createClient(config, resolved);
         try {
+          if (resolved.execution === "persistent") {
+            const vm = await client.sandboxes.get(sandboxId);
+            await ensureVmRunning(vm);
+            return {
+              sandbox: {
+                client,
+                disk: { id: vm.id },
+                vm,
+                resolved,
+                createdAt: /* @__PURE__ */ new Date()
+              },
+              sandboxId: vm.id
+            };
+          }
           const disk = await client.disks.get(sandboxId);
           return {
             sandbox: { client, disk, resolved, createdAt: /* @__PURE__ */ new Date() },
@@ -200,17 +275,64 @@ var _provider = (0, import_provider.defineProvider)({
       list: async (config) => {
         const resolved = resolveConfig(config);
         const client = createClient(config, resolved);
+        if (resolved.execution === "persistent") {
+          const vms = await client.sandboxes.list();
+          return vms.map((vm) => ({
+            sandbox: {
+              client,
+              disk: { id: vm.id },
+              vm,
+              resolved,
+              createdAt: /* @__PURE__ */ new Date()
+            },
+            sandboxId: vm.id
+          }));
+        }
         const disks = await client.disks.list();
         return disks.map((disk) => ({
           sandbox: { client, disk, resolved, createdAt: /* @__PURE__ */ new Date() },
           sandboxId: disk.id
         }));
       },
-      destroy: async (_config, _sandboxId) => {
+      destroy: async (config, sandboxId) => {
+        const resolved = resolveConfig(config);
+        const mode = sandboxModes.get(sandboxId) ?? resolved.execution;
+        if (mode === "persistent") {
+          const client = createClient(config, resolved);
+          const vm = await client.sandboxes.get(sandboxId);
+          await vm.delete();
+        }
+        sandboxModes.delete(sandboxId);
       },
       runCommand: async (sandbox, command, options) => {
         const startTime = Date.now();
         try {
+          if (sandbox.vm) {
+            await ensureVmRunning(sandbox.vm);
+            const wrapped = wrapSandboxCommand(command, options);
+            if (options?.background) {
+              const proc = await sandbox.vm.processes.start(wrapped, {
+                env: options?.env
+              });
+              await proc.disconnect();
+              return {
+                stdout: "",
+                stderr: "",
+                exitCode: 0,
+                durationMs: Date.now() - startTime
+              };
+            }
+            const result2 = await sandbox.vm.exec(wrapped, {
+              env: options?.env,
+              timeoutSeconds: options?.timeout !== void 0 ? Math.ceil(options.timeout / 1e3) : void 0
+            });
+            return {
+              stdout: result2.stdout,
+              stderr: result2.stderr,
+              exitCode: result2.exitCode ?? (result2.status === "completed" ? 0 : 1),
+              durationMs: Date.now() - startTime
+            };
+          }
           const result = await execOnDisk(sandbox, wrapCommand(command, options));
           return {
             stdout: result.stdout ?? "",
@@ -228,6 +350,24 @@ var _provider = (0, import_provider.defineProvider)({
         }
       },
       getInfo: async (sandbox) => {
+        if (sandbox.vm) {
+          const vm = sandbox.vm;
+          return {
+            id: vm.id,
+            provider: "archil",
+            status: vm.status === "running" ? "running" : vm.status === "failed" ? "error" : "stopped",
+            createdAt: vm.createdAt,
+            timeout: vm.maxTtlSeconds * 1e3,
+            metadata: {
+              name: vm.name,
+              archilStatus: vm.status,
+              vcpuCount: vm.vcpuCount,
+              memSizeMiB: vm.memSizeMiB,
+              baseImage: vm.baseImage,
+              platform: vm.platform
+            }
+          };
+        }
         const diskInfo = "status" in sandbox.disk ? sandbox.disk : void 0;
         return {
           id: sandbox.disk.id,
@@ -243,14 +383,39 @@ var _provider = (0, import_provider.defineProvider)({
           } : {}
         };
       },
-      getUrl: async (_sandbox, options) => {
+      getUrl: async (sandbox, options) => {
+        if (sandbox.vm) {
+          await sandbox.vm.refresh();
+          const endpoint = sandbox.vm.endpoints?.find(
+            (e) => e.port === options.port
+          );
+          if (!endpoint) {
+            throw new Error(
+              `No endpoint exposed on port ${options.port} for Archil sandbox ${sandbox.vm.id}.`
+            );
+          }
+          return `${options.protocol ?? "https"}://${endpoint.hostname}`;
+        }
         throw new Error(
           `Archil exec runs each command in a fresh ephemeral container that exits when the command returns, so there is no long-lived process to expose port ${options.port} on. getUrl is not supported.`
         );
       },
       filesystem: {
         readFile: async (sandbox, path, runCommand) => {
-          const diskPath = mapFilesystemPath(path);
+          if (sandbox.vm) {
+            const chunks2 = [];
+            try {
+              await sandbox.vm.files.downloadFile(path, (chunk) => {
+                chunks2.push(Buffer.from(chunk));
+              });
+            } catch (error) {
+              throw new Error(
+                `Failed to read ${path}: ${error instanceof Error ? error.message : String(error)}`
+              );
+            }
+            return Buffer.concat(chunks2).toString("utf8");
+          }
+          const diskPath = mapFilesystemPath(sandbox, path);
           const sizeResult = await runCommand(
             sandbox,
             `wc -c < ${shellEscape(diskPath)}`
@@ -301,7 +466,20 @@ var _provider = (0, import_provider.defineProvider)({
           return Buffer.concat(chunks).toString("utf8");
         },
         writeFile: async (sandbox, path, content, runCommand) => {
-          const diskPath = mapFilesystemPath(path);
+          if (sandbox.vm) {
+            try {
+              await sandbox.vm.files.uploadFile(
+                Buffer.from(content, "utf8"),
+                path
+              );
+            } catch (error) {
+              throw new Error(
+                `Failed to write ${path}: ${error instanceof Error ? error.message : String(error)}`
+              );
+            }
+            return;
+          }
+          const diskPath = mapFilesystemPath(sandbox, path);
           const parent = import_node_path.posix.dirname(diskPath);
           const encoded = Buffer.from(content, "utf8").toString("base64");
           const tempPath = `${diskPath}.computesdk-write-${(0, import_node_crypto.randomUUID)()}`;
@@ -312,6 +490,7 @@ var _provider = (0, import_provider.defineProvider)({
               const result = await runCommand(
                 sandbox,
                 withDiskWriteLock(
+                  sandbox,
                   [
                     `mkdir -p ${shellEscape(parent)}`,
                     `: > ${shellEscape(tempPath)}`,
@@ -332,6 +511,7 @@ var _provider = (0, import_provider.defineProvider)({
               const result = await runCommand(
                 sandbox,
                 withDiskWriteLock(
+                  sandbox,
                   buildWriteChunkCommand(
                     parent,
                     tempPath,
@@ -351,7 +531,7 @@ var _provider = (0, import_provider.defineProvider)({
               try {
                 await runCommand(
                   sandbox,
-                  withDiskWriteLock(`rm -f ${shellEscape(tempPath)}`)
+                  withDiskWriteLock(sandbox, `rm -f ${shellEscape(tempPath)}`)
                 );
               } catch {
               }
@@ -362,20 +542,21 @@ var _provider = (0, import_provider.defineProvider)({
           }
         },
         mkdir: async (sandbox, path, runCommand) => {
-          const diskPath = mapFilesystemPath(path);
+          const diskPath = mapFilesystemPath(sandbox, path);
           const result = await runCommand(
             sandbox,
-            withDiskWriteLock(`mkdir -p ${shellEscape(diskPath)}`)
+            withDiskWriteLock(sandbox, `mkdir -p ${shellEscape(diskPath)}`)
           );
           if (result.exitCode !== 0) {
             throw new Error(`Failed to create directory ${path}: ${result.stderr}`);
           }
         },
         readdir: async (sandbox, path, runCommand) => {
-          const diskPath = mapFilesystemPath(path);
+          const diskPath = mapFilesystemPath(sandbox, path);
           const result = await runCommand(
             sandbox,
-            `find ${shellEscape(diskPath)} -mindepth 1 -maxdepth 1 -printf '%y\\t%s\\t%T@\\t%f\\n'`
+            `find ${shellEscape(diskPath)} -mindepth 1 -maxdepth 1 -printf '%y	%s	%T@	%f
+'`
           );
           if (result.exitCode !== 0) {
             throw new Error(`Failed to list directory ${path}: ${result.stderr}`);
@@ -395,18 +576,18 @@ var _provider = (0, import_provider.defineProvider)({
           return entries;
         },
         exists: async (sandbox, path, runCommand) => {
-          const diskPath = mapFilesystemPath(path);
+          const diskPath = mapFilesystemPath(sandbox, path);
           const result = await runCommand(sandbox, `test -e ${shellEscape(diskPath)}`);
           return result.exitCode === 0;
         },
         remove: async (sandbox, path, runCommand) => {
-          const diskPath = mapFilesystemPath(path);
-          if (diskPath === ARCHIL_MOUNT_ROOT) {
+          const diskPath = mapFilesystemPath(sandbox, path);
+          if (!sandbox.vm && diskPath === ARCHIL_MOUNT_ROOT) {
             throw new Error("Refusing to remove the Archil disk mount root.");
           }
           const result = await runCommand(
             sandbox,
-            withDiskWriteLock(`rm -rf ${shellEscape(diskPath)}`)
+            withDiskWriteLock(sandbox, `rm -rf ${shellEscape(diskPath)}`)
           );
           if (result.exitCode !== 0) {
             throw new Error(`Failed to remove ${path}: ${result.stderr}`);