dsh-plugin-wsl-env 0.7.5 → 0.9.0

package/lib/auto-preset.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Auto-preset: bind an agent to the WSL preset when its workspace directory
+ * lives inside a distro.
+ *
+ * Why an event hook and not configuration: the environment is chosen in
+ * `dsh-api-session-controller`'s `composeAgent(presetId)`, whose signature has no
+ * working directory — the cwd only exists one frame up in
+ * `ensureSession(sessionId, cwd, ...)`. So the path-aware decision has to be made
+ * where the path IS available. `agent/created` carries it:
+ *
+ *     ctx.serial(carrier, "agent/created", { agent, source, signal })
+ *
+ * and `agent.session.header.cwd` is the session's workspace directory.
+ *
+ * Two details are load-bearing, both established by experiment:
+ *
+ *  1. **Respect an explicit choice.** By the time the event fires, the resolved
+ *     preset is already mounted (`composeAgent` mounts request-or-default in
+ *     `setup`). We cannot tell which of the two it was — so we only ever rewrite
+ *     when the mounted preset equals the registry default, which means the client
+ *     omitted it. An operator's pick is never overridden.
+ *
+ *  2. **Switch after creation, not during.** Switching inside the listener
+ *     collides with the previous generation's tools:
+ *         Error: tool "subagent" is already registered in this scope
+ *     Deferring past the creating call fixes it — the session is still blank
+ *     (no turn has started), so `select()` remains legal. A short retry loop
+ *     absorbs the remaining ordering slack instead of relying on one timer.
+ *
+ * This is a TypeScript source built to `lib/auto-preset.js`; edit THIS file and
+ * run `pnpm run build` — the artifact under `lib/` is generated, and `pnpm test`
+ * fails when it drifts.
+ *
+ * @module dsh-plugin-wsl/auto-preset
+ */
+import z from "@deepseek-ai/schemastery";
+import type { Context } from "@deepseek-ai/cordis";
+export declare const name = "auto-preset";
+export declare const inject: string[];
+export declare const Config: z<Schemastery.ObjectS<NoInfer<{
+    /** Preset to bind for a WSL workspace. */
+    preset: z<string, string, "defined">;
+    /** Attempts before giving up; each waits `retryMs`. */
+    attempts: z<number, number, "defined">;
+    /** Gap between attempts, in milliseconds. */
+    retryMs: z<number, number, "defined">;
+}>>, Schemastery.ObjectT<NoInfer<{
+    /** Preset to bind for a WSL workspace. */
+    preset: z<string, string, "defined">;
+    /** Attempts before giving up; each waits `retryMs`. */
+    attempts: z<number, number, "defined">;
+    /** Gap between attempts, in milliseconds. */
+    retryMs: z<number, number, "defined">;
+}>>, "plain">;
+/** The config schema's validated output. */
+export interface AutoPresetConfig {
+    /** Preset to bind for a WSL workspace. */
+    preset?: string;
+    /** Attempts before giving up; each waits `retryMs`. */
+    attempts?: number;
+    /** Gap between attempts, in milliseconds. */
+    retryMs?: number;
+}
+/**
+ * The slice of a created agent this plugin inspects; the harness's agent
+ * object is structural here.
+ */
+export interface CreatedAgentView {
+    /** The agent's id. */
+    id: string;
+    /** The session stub, when mounted. */
+    session?: {
+        header?: {
+            cwd?: string | undefined;
+        };
+    } | undefined;
+    /** The agent's own context. */
+    ctx: Context;
+}
+/**
+ * The cordis context extended with the agent-service slices this plugin
+ * consumes. `agents` and `agentPresets` come from the harness's agent
+ * packages, whose declarations are not visible to this plugin, so they are
+ * spelled structurally on top of the framework's {@link Context}.
+ */
+export type AutoPresetContext = Context & {
+    agents: {
+        list: () => CreatedAgentView[];
+    };
+    agentPresets: {
+        composedPreset: (ctx: Context) => string | undefined;
+        defaultId: string | undefined;
+        select: (agent: CreatedAgentView, presetId: string) => Promise<string>;
+    };
+    on: (event: "agent/created", listener: (payload: {
+        agent?: CreatedAgentView;
+    } | undefined) => void) => () => boolean;
+    sessionController?: {
+        agents?: {
+            ensureSession: (this: unknown, sessionId: string, cwd: string | undefined, checkPersistedIdentity: boolean, presetId: string | undefined) => Promise<unknown>;
+        };
+    };
+};
+/**
+ * Mount the auto-preset plugin.
+ *
+ * @param ctx - the cordis context.
+ * @param config - the schema-validated plugin config.
+ */
+export declare function apply(ctx: AutoPresetContext, config?: AutoPresetConfig): Promise<void>;

package/lib/auto-preset.js

@@ -27,14 +27,16 @@
  *     (no turn has started), so `select()` remains legal. A short retry loop
  *     absorbs the remaining ordering slack instead of relying on one timer.
  *
+ * This is a TypeScript source built to `lib/auto-preset.js`; edit THIS file and
+ * run `pnpm run build` — the artifact under `lib/` is generated, and `pnpm test`
+ * fails when it drifts.
+ *
  * @module dsh-plugin-wsl/auto-preset
  */
-
 import { appendFileSync } from "node:fs";
 import z from "@deepseek-ai/schemastery";
 import { isWslUnc } from "./paths.js";
 import { shouldAdoptWslPreset } from "./preset-choice.js";
-
 /**
  * Set `DSH_WSL_TRACE` to a file path to record every decision this plugin makes.
  *
@@ -43,156 +45,170 @@ import { shouldAdoptWslPreset } from "./preset-choice.js";
  * bug in this plugin stayed invisible once already.
  */
 const TRACE = process.env.DSH_WSL_TRACE;
+/**
+ * Append one decision line to the trace file, when tracing is on.
+ *
+ * @param message - the decision line to append.
+ */
 function trace(message) {
-  if (TRACE === void 0 || TRACE === "") return;
-  try {
-    appendFileSync(TRACE, `${new Date().toISOString()} ${message}\n`);
-  } catch {
-    /* a trace is never worth failing a session over */
-  }
+    if (TRACE === void 0 || TRACE === "")
+        return;
+    try {
+        appendFileSync(TRACE, `${new Date().toISOString()} ${message}\n`);
+    }
+    catch {
+        /* a trace is never worth failing a session over */
+    }
 }
-
 export const name = "auto-preset";
-
 export const inject = ["agents", "agentPresets"];
-
 export const Config = z.object({
-  /** Preset to bind for a WSL workspace. */
-  preset: z.string().default("wsl"),
-  /** Attempts before giving up; each waits `retryMs`. */
-  attempts: z.natural().min(1).default(6),
-  /** Gap between attempts, in milliseconds. */
-  retryMs: z.natural().default(150),
+    /** Preset to bind for a WSL workspace. */
+    preset: z.string().default("wsl"),
+    /** Attempts before giving up; each waits `retryMs`. */
+    attempts: z.natural().min(1).default(6),
+    /** Gap between attempts, in milliseconds. */
+    retryMs: z.natural().default(150),
 });
-
+/**
+ * Mount the auto-preset plugin.
+ *
+ * @param ctx - the cordis context.
+ * @param config - the schema-validated plugin config.
+ */
 export async function apply(ctx, config = {}) {
-  const target = config.preset ?? "wsl";
-  const attempts = config.attempts ?? 6;
-  const retryMs = config.retryMs ?? 150;
-  const warn = (message) => {
-    trace(`WARN ${message}`);
-    // `logger` is not injectable here, so an unavailable or throwing logger must
-    // not turn this into a silent no-op: fall back to stderr.
-    let logged = false;
-    try {
-      ctx.logger?.warn?.(`auto-preset: ${message}`);
-      logged = ctx.logger !== void 0;
-    } catch {
-      logged = false;
-    }
-    if (!logged) {
-      try {
-        process.stderr.write(`auto-preset: ${message}\n`);
-      } catch {
-        /* logging is never worth failing a session over */
-      }
-    }
-  };
-
-  const consider = (agent) => {
-    if (agent === void 0) return;
-
-    let cwd;
-    let current;
-    try {
-      cwd = agent.session?.header?.cwd;
-      current = ctx.agentPresets.composedPreset(agent.ctx);
-    } catch (error) {
-      warn(`cannot inspect the new agent: ${error?.message ?? error}`);
-      return;
-    }
-    trace(`consider agent=${agent.id} cwd=${JSON.stringify(cwd)} current=${String(current)}`);
-
-    // Only a workspace inside a distro, and only when the preset is still the
-    // registry default (i.e. the operator did not ask for one). `undefined` means
-    // the creating caller mounted nothing at all — the headless runner does this
-    // — which is likewise "no explicit choice".
-    let fallback;
-    try {
-      fallback = ctx.agentPresets.defaultId;
-    } catch {
-      fallback = void 0;
-    }
-    if (!shouldAdoptWslPreset({ cwd, current, fallback })) return;
-    trace(`  -> acting: fallback=${String(fallback)} isWsl=${isWslUnc(cwd)}`);
-
-    // Deferred on purpose — see the module comment.
-    void (async () => {
-      for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    const target = config.preset ?? "wsl";
+    const attempts = config.attempts ?? 6;
+    const retryMs = config.retryMs ?? 150;
+    const warn = (message) => {
+        trace(`WARN ${message}`);
+        // `logger` is not injectable here, so an unavailable or throwing logger must
+        // not turn this into a silent no-op: fall back to stderr.
+        let logged = false;
         try {
-          const chosen = await ctx.agentPresets.select(agent, target);
-          ctx.logger?.debug?.(`auto-preset: "${cwd}" -> preset "${chosen}"`);
-          return;
-        } catch (error) {
-          const code = error?.code;
-          // The session already started a turn: its preset is fixed, and that is
-          // a legitimate outcome (the operator drove it before we got here).
-          if (code === "agent-preset/locked") {
-            warn(`"${cwd}" already began its first turn; leaving the preset as "${String(current)}"`);
-            return;
-          }
-          if (code === "agent-preset/not-found") {
-            warn(`preset "${target}" is not composed in this profile; skipping "${cwd}"`);
+            ctx.logger?.warn?.(`auto-preset: ${message}`);
+            logged = ctx.logger !== void 0;
+        }
+        catch {
+            logged = false;
+        }
+        if (!logged) {
+            try {
+                process.stderr.write(`auto-preset: ${message}\n`);
+            }
+            catch {
+                /* logging is never worth failing a session over */
+            }
+        }
+    };
+    const consider = (agent) => {
+        if (agent === void 0)
             return;
-          }
-          if (attempt === attempts) {
-            warn(`could not bind preset "${target}" for "${cwd}": ${code ?? error?.name}: ${error?.message}`);
+        let cwd;
+        let current;
+        try {
+            cwd = agent.session?.header?.cwd;
+            current = ctx.agentPresets.composedPreset(agent.ctx);
+        }
+        catch (error) {
+            warn(`cannot inspect the new agent: ${error?.message ?? error}`);
             return;
-          }
-          await new Promise((resolve) => setTimeout(resolve, retryMs));
         }
-      }
-    })();
-  };
-
-  ctx.on("agent/created", (payload) => consider(payload?.agent));
-
-  // ── Make the INITIAL preset correct, instead of correcting it afterwards ────
-  //
-  // A WSL workspace mounted on the HOST preset puts the Windows ACL sandbox in
-  // front of a `\\wsl.localhost` path, which cannot carry security descriptors:
-  // the shell tool then dies in sandbox preparation (`GetNamedSecurityInfoW
-  // failed (Win32 1)`) and the workspace is unusable — not merely mis-labelled.
-  // Correcting the preset after creation loses whenever the first turn does not
-  // wait, so the choice is made where the cwd still exists: the controller
-  // resolves the preset in `composeAgent(presetId)`, which has no cwd, but it
-  // calls `agents.ensureSession(sessionId, cwd, …, presetId)` — and that frame
-  // holds both. Filling the preset there makes the very first mount already
-  // correct, so the host sandbox never meets the distro path at all.
-  ctx.inject(["sessionController"], (controllerCtx) => {
-    const facade = controllerCtx.sessionController?.agents;
-    if (facade === void 0 || typeof facade.ensureSession !== "function") {
-      warn("sessionController exposes no agents.ensureSession(); the creation-time preset fix is inactive");
-      return;
-    }
-    const original = facade.ensureSession;
-    facade.ensureSession = async function (sessionId, cwd, checkPersistedIdentity, presetId) {
-      // An explicit choice always wins, and only a distro workspace is affected.
-      if (presetId !== void 0 || !isWslUnc(cwd)) {
-        return original.call(this, sessionId, cwd, checkPersistedIdentity, presetId);
-      }
-      try {
-        return await original.call(this, sessionId, cwd, checkPersistedIdentity, target);
-      } catch (error) {
-        // A session already stored under another preset rejects a different one.
-        // Fall back rather than turn adoption into a new failure mode.
-        if (!String(error?.message ?? "").includes("agent preset")) throw error;
-        trace(`creation-time preset "${target}" refused for ${sessionId}; falling back to the recorded one`);
-        return original.call(this, sessionId, cwd, checkPersistedIdentity, presetId);
-      }
+        trace(`consider agent=${agent.id} cwd=${JSON.stringify(cwd)} current=${String(current)}`);
+        // Only a workspace inside a distro, and only when the preset is still the
+        // registry default (i.e. the operator did not ask for one). `undefined` means
+        // the creating caller mounted nothing at all — the headless runner does this
+        // — which is likewise "no explicit choice".
+        let fallback;
+        try {
+            fallback = ctx.agentPresets.defaultId;
+        }
+        catch {
+            fallback = void 0;
+        }
+        if (!shouldAdoptWslPreset({ cwd, current, fallback }))
+            return;
+        trace(`  -> acting: fallback=${String(fallback)} isWsl=${isWslUnc(cwd)}`);
+        // Deferred on purpose — see the module comment.
+        void (async () => {
+            for (let attempt = 1; attempt <= attempts; attempt += 1) {
+                try {
+                    const chosen = await ctx.agentPresets.select(agent, target);
+                    ctx.logger?.debug?.(`auto-preset: "${cwd}" -> preset "${chosen}"`);
+                    return;
+                }
+                catch (error) {
+                    const code = error?.code;
+                    // The session already started a turn: its preset is fixed, and that is
+                    // a legitimate outcome (the operator drove it before we got here).
+                    if (code === "agent-preset/locked") {
+                        warn(`"${cwd}" already began its first turn; leaving the preset as "${String(current)}"`);
+                        return;
+                    }
+                    if (code === "agent-preset/not-found") {
+                        warn(`preset "${target}" is not composed in this profile; skipping "${cwd}"`);
+                        return;
+                    }
+                    if (attempt === attempts) {
+                        warn(`could not bind preset "${target}" for "${cwd}": ${code ?? error?.name}: ${error?.message}`);
+                        return;
+                    }
+                    await new Promise((resolve) => setTimeout(resolve, retryMs));
+                }
+            }
+        })();
     };
-    trace("creation-time preset fix installed");
-    controllerCtx.effect(() => () => {
-      facade.ensureSession = original;
+    ctx.on("agent/created", (payload) => consider(payload?.agent));
+    // ── Make the INITIAL preset correct, instead of correcting it afterwards ────
+    //
+    // A WSL workspace mounted on the HOST preset puts the Windows ACL sandbox in
+    // front of a `\\wsl.localhost` path, which cannot carry security descriptors:
+    // the shell tool then dies in sandbox preparation (`GetNamedSecurityInfoW
+    // failed (Win32 1)`) and the workspace is unusable — not merely mis-labelled.
+    // Correcting the preset after creation loses whenever the first turn does not
+    // wait, so the choice is made where the cwd still exists: the controller
+    // resolves the preset in `composeAgent(presetId)`, which has no cwd, but it
+    // calls `agents.ensureSession(sessionId, cwd, …, presetId)` — and that frame
+    // holds both. Filling the preset there makes the very first mount already
+    // correct, so the host sandbox never meets the distro path at all.
+    ctx.inject(["sessionController"], (controllerCtx) => {
+        const facade = controllerCtx.sessionController?.agents;
+        if (facade === void 0 || typeof facade.ensureSession !== "function") {
+            warn("sessionController exposes no agents.ensureSession(); the creation-time preset fix is inactive");
+            return;
+        }
+        const original = facade.ensureSession;
+        facade.ensureSession = async function (sessionId, cwd, checkPersistedIdentity, presetId) {
+            // An explicit choice always wins, and only a distro workspace is affected.
+            if (presetId !== void 0 || cwd === undefined || !isWslUnc(cwd)) {
+                return original.call(this, sessionId, cwd, checkPersistedIdentity, presetId);
+            }
+            try {
+                return await original.call(this, sessionId, cwd, checkPersistedIdentity, target);
+            }
+            catch (error) {
+                // A session already stored under another preset rejects a different one.
+                // Fall back rather than turn adoption into a new failure mode.
+                if (!String(error?.message ?? "").includes("agent preset"))
+                    throw error;
+                trace(`creation-time preset "${target}" refused for ${sessionId}; falling back to the recorded one`);
+                return original.call(this, sessionId, cwd, checkPersistedIdentity, presetId);
+            }
+        };
+        trace("creation-time preset fix installed");
+        controllerCtx.effect(() => () => {
+            facade.ensureSession = original;
+        });
     });
-  });
-  // Mount order is not a guarantee: a runner that creates its session during
-  // startup can finish before this plugin mounts and miss the event entirely
-  // (dsh-headless does exactly that). Sweep the agents already live so the
-  // decision never depends on who mounted first.
-  try {
-    for (const agent of ctx.agents.list()) consider(agent);
-  } catch (error) {
-    warn(`could not sweep already-live agents: ${error?.message ?? error}`);
-  }
+    // Mount order is not a guarantee: a runner that creates its session during
+    // startup can finish before this plugin mounts and miss the event entirely
+    // (dsh-headless does exactly that). Sweep the agents already live so the
+    // decision never depends on who mounted first.
+    try {
+        for (const agent of ctx.agents.list())
+            consider(agent);
+    }
+    catch (error) {
+        warn(`could not sweep already-live agents: ${error?.message ?? error}`);
+    }
 }

package/lib/bwrap.d.ts

@@ -0,0 +1,90 @@
+/**
+ * The distro-side `bwrap` command line, shared by every confinement site.
+ *
+ * Two callers compose a confined command and they must agree on it exactly:
+ * `lib/sandbox.js` wraps a *single* command (`confine()`, and the usability
+ * probe), and `lib/agent-confined.js` wraps a *resident* whose whole lifetime
+ * runs inside the profile — it hands the prefix to the transport, which inserts
+ * it between `wsl.exe --exec` and the `sh <script>` pair.
+ *
+ * That split is why this module exists. The two sites used to assemble the argv
+ * themselves, and only one of them prepended the program: the confined resident's
+ * prefix began at `--ro-bind`, so `wsl.exe --exec` tried to run a `--ro-bind`
+ * executable, the agent exited 1 during its handshake, and every confined
+ * mutation failed with `FS_IO_ERROR: … agent exited during handshake`. The
+ * verified probe could not see it because it inlined its own copy of the argv.
+ *
+ * This module imports nothing, so a bare checkout can assert the argv both sites
+ * actually produce.
+ *
+ * This is a TypeScript source built to `lib/bwrap.js`; edit THIS file and run
+ * `pnpm run build` — the artifact under `lib/` is generated, and `pnpm test`
+ * fails when it drifts.
+ *
+ * @module dsh-plugin-wsl/bwrap
+ */
+/** Profile options shared by the two confinement sites. */
+export interface BwrapProfileOptions {
+    /** Shadow `/mnt` with an empty tmpfs. */
+    maskWindowsDrive?: boolean;
+    /**
+     * Workspace-write binds the real `/tmp` read-write instead of mounting an
+     * ephemeral tmpfs over it.
+     */
+    realTmp?: boolean;
+}
+/**
+ * Build the bwrap profile arguments for one file-effect policy, exactly as
+ * upstream's `bwrapProfileArgs` does.
+ *
+ * `--ro-bind / /` makes the whole distro read-only, `--dev /dev` supplies the
+ * `/dev/null` sink a shell needs, `--unshare-pid` keeps the sandbox's process
+ * view its own, and `--proc /proc` gives it a matching `/proc`. Under
+ * `workspace-write` the workspace is bound read-write and `/tmp` becomes an
+ * ephemeral tmpfs — the temp area the mode promises, without exposing the
+ * distro's real `/tmp`.
+ *
+ * `options.maskWindowsDrive` mounts an empty tmpfs over `/mnt` AFTER the
+ * read-only root, shadowing the Windows drive: the drive's files disappear
+ * from the command's view, which severs interop as a side effect — a Windows
+ * executable on the drive can no longer be reached to launch, and the drive's
+ * data cannot be read or exfiltrated. It is a narrowing, not a closure: a
+ * command may still WRITE an executable into the workspace and run it
+ * (binfmt interop dispatches on file content, not location), so `enforcement`
+ * stays `partial` — see `lib/sandbox.js`.
+ *
+ * `options.realTmp` changes what workspace-write does at `/tmp`. The default
+ * (`--tmpfs /tmp`) gives the sandbox an ephemeral, empty temp area — the right
+ * shape for a COMMAND: fresh per run, cannot touch the distro's real `/tmp`,
+ * cannot be poisoned by a previous run. `realTmp: true` binds the REAL `/tmp`
+ * read-write instead — the right shape for the FILE-WRITES resident: the
+ * fence grants `/tmp` as a writable root, so a write the fence approved must
+ * land where every reader (the plain agent, the user's own shell) reads — not
+ * inside a private tmpfs that reads cannot see and that dies with the
+ * resident. Read-only mode mounts no `/tmp` at all, so the option is inert
+ * there.
+ *
+ * @param policy - the policy to express as bwrap mounts.
+ * @param options - profile options.
+ * @returns profile arguments, before the `--` separator and the command argv.
+ */
+export declare function bwrapProfileArgs(policy: {
+    mode: string;
+    workspaceRoot: string;
+}, options?: BwrapProfileOptions): string[];
+/**
+ * The argv prefix that runs one command (or one resident) inside the profile.
+ *
+ * The prefix is a complete command from the distro's point of view: it names the
+ * program (`bwrap`), the profile, and the `--` separator that ends bwrap's own
+ * options. `workspaceRoot` must already be spelled as a Linux path inside the
+ * distro; the callers own that translation.
+ *
+ * @param policy - the resolved policy: `mode`, plus the Linux `workspaceRoot`.
+ * @param options - profile options, passed through to {@link bwrapProfileArgs}.
+ * @returns argv to insert before the command, as the transport receives it.
+ */
+export declare function bwrapArgvPrefix(policy: {
+    mode: string;
+    workspaceRoot: string;
+}, options?: BwrapProfileOptions): string[];

package/lib/bwrap.js

@@ -17,9 +17,12 @@
  * This module imports nothing, so a bare checkout can assert the argv both sites
  * actually produce.
  *
+ * This is a TypeScript source built to `lib/bwrap.js`; edit THIS file and run
+ * `pnpm run build` — the artifact under `lib/` is generated, and `pnpm test`
+ * fails when it drifts.
+ *
  * @module dsh-plugin-wsl/bwrap
  */
-
 /**
  * Build the bwrap profile arguments for one file-effect policy, exactly as
  * upstream's `bwrapProfileArgs` does.
@@ -53,27 +56,24 @@
  *
  * @param policy - the policy to express as bwrap mounts.
  * @param options - profile options.
- * @param options.maskWindowsDrive - shadow `/mnt` with an empty tmpfs.
- * @param options.realTmp - workspace-write binds the real `/tmp` read-write
- *   instead of mounting an ephemeral tmpfs over it.
  * @returns profile arguments, before the `--` separator and the command argv.
  */
 export function bwrapProfileArgs(policy, options = {}) {
-  const args = ["--ro-bind", "/", "/", "--dev", "/dev", "--unshare-pid", "--proc", "/proc", "--die-with-parent"];
-  if (policy.mode === "workspace-write") {
-    if (options.realTmp) {
-      args.push("--bind", "/tmp", "/tmp");
-    } else {
-      args.push("--tmpfs", "/tmp");
+    const args = ["--ro-bind", "/", "/", "--dev", "/dev", "--unshare-pid", "--proc", "/proc", "--die-with-parent"];
+    if (policy.mode === "workspace-write") {
+        if (options.realTmp) {
+            args.push("--bind", "/tmp", "/tmp");
+        }
+        else {
+            args.push("--tmpfs", "/tmp");
+        }
+        args.push("--bind", policy.workspaceRoot, policy.workspaceRoot);
+    }
+    if (options.maskWindowsDrive) {
+        args.push("--tmpfs", "/mnt");
     }
-    args.push("--bind", policy.workspaceRoot, policy.workspaceRoot);
-  }
-  if (options.maskWindowsDrive) {
-    args.push("--tmpfs", "/mnt");
-  }
-  return args;
+    return args;
 }
-
 /**
  * The argv prefix that runs one command (or one resident) inside the profile.
  *
@@ -87,5 +87,5 @@ export function bwrapProfileArgs(policy, options = {}) {
  * @returns argv to insert before the command, as the transport receives it.
  */
 export function bwrapArgvPrefix(policy, options = {}) {
-  return ["bwrap", ...bwrapProfileArgs(policy, options), "--"];
+    return ["bwrap", ...bwrapProfileArgs(policy, options), "--"];
 }