@openparachute/agent 0.2.3-rc.2 → 0.2.3-rc.4

package/src/sandbox/sandbox.test.ts

@@ -1,168 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import { Sandbox, configForSpec, type SandboxEngine } from "./index.ts";
-import type { SandboxRuntimeConfig } from "@anthropic-ai/sandbox-runtime";
-import type { AgentSpec, BaseBinds } from "./types.ts";
-import type { EgressBaseInput } from "./egress.ts";
-
-const BASE_BINDS: BaseBinds = { workspace: "/state/sessions/arm", runtimeReadOnly: ["/cfg"] };
-const EGRESS_BASE: EgressBaseInput = { hubOrigin: "https://hub.example.com" };
-
-/** A fake engine that records what it was initialized with + what it wrapped. */
-function fakeEngine(): SandboxEngine & {
-  initializedWith: SandboxRuntimeConfig | null;
-  wrappedCommands: string[];
-  resets: number;
-  calls: string[];
-} {
-  const rec = {
-    initializedWith: null as SandboxRuntimeConfig | null,
-    wrappedCommands: [] as string[],
-    resets: 0,
-    calls: [] as string[],
-    isSupportedPlatform: () => true,
-    isSandboxingEnabled: () => true,
-    async initialize(cfg: SandboxRuntimeConfig) {
-      rec.initializedWith = cfg;
-      rec.calls.push("initialize");
-    },
-    async wrapWithSandboxArgv(command: string) {
-      rec.wrappedCommands.push(command);
-      rec.calls.push("wrap");
-      return {
-        argv: ["/bin/bash", "-c", `SANDBOXED ${command}`],
-        env: { SANDBOX_RUNTIME: "1", HTTP_PROXY: "http://localhost:9999" },
-      };
-    },
-    async reset() {
-      rec.resets += 1;
-      rec.calls.push("reset");
-    },
-  };
-  return rec;
-}
-
-// network "restricted" so the allowedDomains-floor assertion applies; the /Users
-// read-deny applies via the DEFAULT filesystem "workspace" (scoped reads). The
-// open-network default is covered in config.test.ts.
-const SPEC: AgentSpec = {
-  name: "arm",
-  channels: ["ch"],
-  network: "restricted",
-  egress: ["registry.npmjs.org"],
-  mounts: [{ hostPath: "/proj", mountPath: "/work", mode: "rw" }],
-};
-
-describe("Sandbox adapter", () => {
-  test("initializes the engine with the spec-derived config, then wraps the command", async () => {
-    const engine = fakeEngine();
-    const sandbox = new Sandbox(engine);
-    const wrapped = await sandbox.wrap({
-      spec: SPEC,
-      baseBinds: BASE_BINDS,
-      egressBase: EGRESS_BASE,
-      command: "claude --strict-mcp-config",
-      platform: "darwin",
-    });
-
-    // It initialized with the right config (egress floor + scoped reads).
-    expect(engine.initializedWith).not.toBeNull();
-    expect(engine.initializedWith!.network.allowedDomains).toContain("api.anthropic.com");
-    expect(engine.initializedWith!.network.allowedDomains).toContain("registry.npmjs.org");
-    expect(engine.initializedWith!.filesystem.denyRead).toContain("/Users");
-    expect(engine.initializedWith!.filesystem.allowWrite).toContain("/proj");
-
-    // It wrapped exactly the command we passed.
-    expect(engine.wrappedCommands).toEqual(["claude --strict-mcp-config"]);
-
-    // It returns argv + env + the config used.
-    expect(wrapped.argv[0]).toBe("/bin/bash");
-    expect(wrapped.argv[2]).toContain("SANDBOXED claude");
-    expect(wrapped.env.SANDBOX_RUNTIME).toBe("1");
-    expect(wrapped.config).toBe(engine.initializedWith!);
-  });
-
-  test("wrap() RESETS the singleton before initializing (no stale proxy/config leak across spawns)", async () => {
-    const engine = fakeEngine();
-    const sandbox = new Sandbox(engine);
-    await sandbox.wrap({
-      spec: SPEC,
-      baseBinds: BASE_BINDS,
-      egressBase: EGRESS_BASE,
-      command: "claude",
-    });
-    // The order matters: reset → initialize → wrap. Without the leading reset, a
-    // prior spawn's network config (e.g. HTTP_PROXY from a restricted session)
-    // leaks into this wrap and an open session routes to a dead proxy → dies.
-    expect(engine.calls).toEqual(["reset", "initialize", "wrap"]);
-  });
-
-  test("a RESTRICTED-network spawn's proxy env does NOT leak into a later OPEN spawn (the real-bug scenario)", async () => {
-    // A leak-MODELING engine, mirroring the real singleton: `initialize` turns the
-    // proxy on iff the config has an allowlist (restricted network); `wrap` emits
-    // HTTP_PROXY iff the proxy is on; `reset` turns it off. Without the
-    // reset-before-init in Sandbox.wrap, the proxy would still be on from the
-    // restricted spawn and leak into the open spawn's env — exactly the live failure.
-    let proxyOn = false;
-    const engine: SandboxEngine = {
-      isSupportedPlatform: () => true,
-      isSandboxingEnabled: () => true,
-      async initialize(cfg: SandboxRuntimeConfig) {
-        if ((cfg.network as { allowedDomains?: string[] }).allowedDomains) proxyOn = true;
-      },
-      async wrapWithSandboxArgv(command: string) {
-        return { argv: ["/bin/bash", "-c", command], env: proxyOn ? { HTTP_PROXY: "http://localhost:1" } : {} };
-      },
-      async reset() {
-        proxyOn = false;
-      },
-    };
-    const sandbox = new Sandbox(engine);
-    // 1) restricted-network spawn → allowlist present → proxy on, HTTP_PROXY present.
-    const restricted = await sandbox.wrap({ spec: { name: "r", channels: ["c"], network: "restricted" }, baseBinds: BASE_BINDS, egressBase: EGRESS_BASE, command: "claude" });
-    expect(restricted.env.HTTP_PROXY).toBeDefined();
-    // 2) open-network spawn right after (the default) → the per-wrap reset clears the
-    //    proxy, so NO stale HTTP_PROXY leaks in (the bug: claude would route to the
-    //    dead proxy + die).
-    const open = await sandbox.wrap({ spec: { name: "o", channels: ["c"] }, baseBinds: BASE_BINDS, egressBase: EGRESS_BASE, command: "claude" });
-    expect(open.env.HTTP_PROXY).toBeUndefined();
-  });
-
-  test("reset() tears the engine down", async () => {
-    const engine = fakeEngine();
-    const sandbox = new Sandbox(engine);
-    await sandbox.reset();
-    expect(engine.resets).toBe(1);
-  });
-
-  test("isSupportedPlatform delegates to the engine", () => {
-    const engine = fakeEngine();
-    expect(new Sandbox(engine).isSupportedPlatform()).toBe(true);
-  });
-
-  test("SECURITY: a restricted-network spec omitting egress still gets the base floor in the engine config", async () => {
-    const engine = fakeEngine();
-    const sandbox = new Sandbox(engine);
-    await sandbox.wrap({
-      spec: { name: "x", channels: ["c"], network: "restricted" }, // restricted, no egress declared
-      baseBinds: BASE_BINDS,
-      egressBase: EGRESS_BASE,
-      command: "claude",
-      platform: "darwin",
-    });
-    expect(engine.initializedWith!.network.allowedDomains).toContain("api.anthropic.com");
-    expect(engine.initializedWith!.network.allowedDomains).toContain("hub.example.com");
-  });
-});
-
-describe("configForSpec helper", () => {
-  test("builds the config without touching an engine", () => {
-    const cfg = configForSpec({
-      spec: SPEC,
-      baseBinds: BASE_BINDS,
-      egressBase: EGRESS_BASE,
-      platform: "darwin",
-    });
-    expect(cfg.network.allowedDomains).toContain("registry.npmjs.org");
-    expect(cfg.filesystem.allowWrite).toContain("/proj");
-  });
-});

package/src/services-manifest.test.ts

@@ -1,106 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import { mkdtempSync, readFileSync, writeFileSync, existsSync } from "fs";
-import { tmpdir } from "os";
-import { join } from "path";
-import { resolveManifestPath, upsertService, listVaultNames, type ServiceEntry } from "./services-manifest.ts";
-
-function tmp(): string {
-  return join(mkdtempSync(join(tmpdir(), "pc-manifest-")), "services.json");
-}
-
-const AGENT: ServiceEntry = {
-  name: "parachute-agent",
-  port: 1941,
-  paths: ["/agent"],
-  health: "/health",
-  version: "0.1.0",
-  displayName: "Agent",
-  stripPrefix: true,
-};
-
-describe("resolveManifestPath", () => {
-  test("honors PARACHUTE_HOME (sandbox for tests/e2e)", () => {
-    expect(resolveManifestPath({ PARACHUTE_HOME: "/tmp/sandbox" })).toBe("/tmp/sandbox/services.json");
-  });
-  test("falls back to HOME/.parachute", () => {
-    expect(resolveManifestPath({ HOME: "/home/x" })).toBe("/home/x/.parachute/services.json");
-  });
-});
-
-describe("upsertService", () => {
-  test("creates the manifest with the entry on first write", () => {
-    const path = tmp();
-    upsertService(AGENT, path);
-    const m = JSON.parse(readFileSync(path, "utf8"));
-    expect(m.services).toHaveLength(1);
-    expect(m.services[0].name).toBe("parachute-agent");
-    expect(m.services[0].paths).toEqual(["/agent"]);
-    expect(m.services[0].stripPrefix).toBe(true);
-  });
-
-  test("carries startCmd so the hub supervisor can start/restart/adopt the module (agent#34)", () => {
-    const path = tmp();
-    upsertService({ ...AGENT, startCmd: ["parachute-agent"] }, path);
-    const m = JSON.parse(readFileSync(path, "utf8"));
-    expect(m.services[0].startCmd).toEqual(["parachute-agent"]);
-  });
-
-  test("is idempotent — re-registering the same name does not duplicate", () => {
-    const path = tmp();
-    upsertService(AGENT, path);
-    upsertService({ ...AGENT, version: "0.1.1" }, path);
-    const m = JSON.parse(readFileSync(path, "utf8"));
-    expect(m.services).toHaveLength(1);
-    expect(m.services[0].version).toBe("0.1.1"); // module wins for fields it owns
-  });
-
-  test("merges — preserves hub-stamped fields the module doesn't author", () => {
-    const path = tmp();
-    // hub stamped installDir onto the row; module re-registers without it.
-    writeFileSync(path, JSON.stringify({ services: [{ ...AGENT, installDir: "/hub/stamped" }] }));
-    upsertService(AGENT, path);
-    const m = JSON.parse(readFileSync(path, "utf8"));
-    expect(m.services[0].installDir).toBe("/hub/stamped");
-  });
-
-  test("preserves other modules' entries", () => {
-    const path = tmp();
-    writeFileSync(path, JSON.stringify({ services: [{ name: "parachute-vault", port: 1940, paths: ["/vault/default"], health: "/vault/default/health", version: "0.5.2" }] }));
-    upsertService(AGENT, path);
-    const m = JSON.parse(readFileSync(path, "utf8"));
-    expect(m.services).toHaveLength(2);
-    expect(m.services.map((s: ServiceEntry) => s.name).sort()).toEqual(["parachute-agent", "parachute-vault"]);
-  });
-
-  test("throws on a malformed manifest rather than clobbering it", () => {
-    const path = tmp();
-    writeFileSync(path, JSON.stringify({ not_services: true }));
-    expect(() => upsertService(AGENT, path)).toThrow(/malformed/);
-    expect(existsSync(path)).toBe(true); // original left intact
-    expect(JSON.parse(readFileSync(path, "utf8"))).toEqual({ not_services: true }); // content untouched
-  });
-});
-
-describe("listVaultNames", () => {
-  test("extracts vault names from the vault module's /vault/<name> paths, default first", () => {
-    const path = tmp();
-    writeFileSync(path, JSON.stringify({ services: [
-      { name: "parachute-vault", port: 1940, paths: ["/vault/boulder", "/vault/default", "/vault/techne"], health: "x", version: "1" },
-      { name: "parachute-agent", port: 1941, paths: ["/agent"], health: "x", version: "1" },
-    ] }));
-    expect(listVaultNames(path)).toEqual(["default", "boulder", "techne"]);
-  });
-
-  test("dedupes across services and ignores non-vault paths", () => {
-    const path = tmp();
-    writeFileSync(path, JSON.stringify({ services: [
-      { name: "a", port: 1, paths: ["/vault/x", "/other"], health: "x", version: "1" },
-      { name: "b", port: 2, paths: ["/vault/x", "/vault/y"], health: "x", version: "1" },
-    ] }));
-    expect(listVaultNames(path).sort()).toEqual(["x", "y"]);
-  });
-
-  test("returns [] when the manifest is absent or unreadable", () => {
-    expect(listVaultNames(join(tmpdir(), "does-not-exist-" + Math.floor(performance.now()), "services.json"))).toEqual([]);
-  });
-});

package/src/spa-serve.test.ts

@@ -1,116 +0,0 @@
-/**
- * Tests for the v2 agent SPA bundle serving (`src/spa-serve.ts`) — the daemon's
- * `/app` mount. Proves: a missing dist 503s with a build hint; the SPA shell is
- * served for the mount root + client-routed paths; real assets serve with the
- * right content-type; path traversal is blocked; the mount-path predicate is
- * exact.
- */
-import { describe, test, expect, beforeAll, afterAll } from "bun:test";
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "fs";
-import { join } from "path";
-import { tmpdir } from "os";
-import {
-  SPA_MOUNT,
-  isSpaPath,
-  serveSpa,
-  spaContentType,
-  spaDistDir,
-} from "./spa-serve.ts";
-
-describe("isSpaPath", () => {
-  test("matches the mount root + sub-paths only", () => {
-    expect(isSpaPath("/app")).toBe(true);
-    expect(isSpaPath("/app/")).toBe(true);
-    expect(isSpaPath("/app/agents")).toBe(true);
-    expect(isSpaPath("/app/assets/index-abc.js")).toBe(true);
-    // NOT the daemon-rendered HTML pages or other routes.
-    expect(isSpaPath("/agents")).toBe(false);
-    expect(isSpaPath("/apple")).toBe(false);
-    expect(isSpaPath("/api/agents")).toBe(false);
-    expect(isSpaPath("/")).toBe(false);
-  });
-});
-
-describe("spaContentType", () => {
-  test("maps the realistic Vite output extensions", () => {
-    expect(spaContentType("/x/index.html")).toContain("text/html");
-    expect(spaContentType("/x/index-abc.js")).toContain("javascript");
-    expect(spaContentType("/x/index-abc.css")).toContain("css");
-    expect(spaContentType("/x/logo.svg")).toBe("image/svg+xml");
-    expect(spaContentType("/x/unknown.bin")).toBe("application/octet-stream");
-  });
-});
-
-describe("spaDistDir", () => {
-  test("anchors to <installDir>/web/ui/dist", () => {
-    expect(spaDistDir("/opt/agent")).toBe("/opt/agent/web/ui/dist");
-  });
-});
-
-describe("serveSpa — missing bundle", () => {
-  test("503s with a build hint when dist/ is absent", async () => {
-    const res = serveSpa("/nonexistent/dist", "/app/");
-    expect(res.status).toBe(503);
-    expect(await res.text()).toContain("run `bun run build`");
-  });
-});
-
-describe("serveSpa — with a fixture bundle", () => {
-  let dist: string;
-
-  beforeAll(() => {
-    dist = mkdtempSync(join(tmpdir(), "agent-spa-test-"));
-    mkdirSync(join(dist, "assets"), { recursive: true });
-    writeFileSync(join(dist, "index.html"), "<!doctype html><div id=root></div>");
-    writeFileSync(join(dist, "assets", "index-abc.js"), "console.log('spa')");
-    writeFileSync(join(dist, "assets", "index-abc.css"), ".x{color:red}");
-  });
-
-  afterAll(() => {
-    rmSync(dist, { recursive: true, force: true });
-  });
-
-  test("serves the SPA shell at the mount root", async () => {
-    const res = serveSpa(dist, SPA_MOUNT);
-    expect(res.status).toBe(200);
-    expect(res.headers.get("content-type")).toContain("text/html");
-    expect(await res.text()).toContain("id=root");
-  });
-
-  test("serves the SPA shell for a client-routed path (no extension)", async () => {
-    const res = serveSpa(dist, "/app/agents");
-    expect(res.status).toBe(200);
-    expect(res.headers.get("content-type")).toContain("text/html");
-    expect(await res.text()).toContain("id=root");
-  });
-
-  test("serves a real JS asset with the right content-type", async () => {
-    const res = serveSpa(dist, "/app/assets/index-abc.js");
-    expect(res.status).toBe(200);
-    expect(res.headers.get("content-type")).toContain("javascript");
-    expect(await res.text()).toContain("spa");
-  });
-
-  test("serves a real CSS asset", async () => {
-    const res = serveSpa(dist, "/app/assets/index-abc.css");
-    expect(res.status).toBe(200);
-    expect(res.headers.get("content-type")).toContain("css");
-  });
-
-  test("an asset-shaped path that doesn't exist falls back to the SPA shell", async () => {
-    const res = serveSpa(dist, "/app/assets/missing.js");
-    expect(res.status).toBe(200);
-    expect(res.headers.get("content-type")).toContain("text/html");
-  });
-
-  test("blocks path traversal out of dist/", async () => {
-    // A `..`-containing path never enters the asset branch → SPA shell (not the
-    // escaped file). The 404 belt-and-braces guards the loosened case.
-    const res = serveSpa(dist, "/app/../../etc/passwd");
-    // Either the shell (traversal filtered) or a 404 — never the escaped file.
-    expect([200, 404]).toContain(res.status);
-    if (res.status === 200) {
-      expect(res.headers.get("content-type")).toContain("text/html");
-    }
-  });
-});

package/src/spawn-agent-cli.test.ts

@@ -1,172 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import { parseArgs, ArgError } from "../scripts/spawn-agent.ts";
-import type { AgentChannelSpec } from "./sandbox/types.ts";
-
-// These tests exercise ONLY the pure arg-parser (`parseArgs`) — no fs/tmux/mint
-// side effect. The real-dep wiring (operator token, hub mint, sandbox, tmux) is
-// covered by spawn-agent.test.ts against stubs; here we assert flags → the right
-// AgentSpec, the --help short-circuit, and that bad args reject.
-
-describe("parseArgs — name + channels + vault + egress + mounts → the right AgentSpec", () => {
-  test("a full invocation builds the complete spec", () => {
-    const { help, spec } = parseArgs([
-      "aaron-dev",
-      "--channel",
-      "aaron-dev",
-      "--channel",
-      "ops:read",
-      "--vault",
-      "default:read:agent/message,#decision",
-      "--egress",
-      "registry.npmjs.org,github.com",
-      "--mount",
-      "/host/code:/work/code:ro",
-      "--mount",
-      "/host/cache:/work/cache:rw:shared-cache",
-    ]);
-    expect(help).toBe(false);
-    expect(spec).toBeDefined();
-    expect(spec!.name).toBe("aaron-dev");
-
-    // Channels: first is the wake channel (write by default); second scoped read.
-    expect(spec!.channels).toEqual([
-      { name: "aaron-dev" },
-      { name: "ops", access: "read" },
-    ] as AgentChannelSpec[]);
-
-    // Vault: name + access + tag-scope.
-    expect(spec!.vault).toEqual({
-      name: "default",
-      access: "read",
-      tags: ["agent/message", "#decision"],
-    });
-
-    // Egress: additive host list, comma-split.
-    expect(spec!.egress).toEqual(["registry.npmjs.org", "github.com"]);
-
-    // Mounts: ro + rw-with-shared.
-    expect(spec!.mounts).toEqual([
-      { hostPath: "/host/code", mountPath: "/work/code", mode: "ro" },
-      { hostPath: "/host/cache", mountPath: "/work/cache", mode: "rw", shared: "shared-cache" },
-    ]);
-  });
-
-  test("a bare --channel defaults to write (back-compat single-threaded session)", () => {
-    const { spec } = parseArgs(["a", "--channel", "c"]);
-    expect(spec!.channels).toEqual([{ name: "c" }]);
-  });
-
-  test("--channel <name>:write is explicit write", () => {
-    const { spec } = parseArgs(["a", "--channel", "c:write"]);
-    expect(spec!.channels).toEqual([{ name: "c", access: "write" }]);
-  });
-
-  test("a minimal invocation (name + one channel) omits optional fields", () => {
-    const { spec } = parseArgs(["solo", "--channel", "solo"]);
-    expect(spec).toEqual({ name: "solo", channels: [{ name: "solo" }] });
-    expect(spec!.vault).toBeUndefined();
-    expect(spec!.egress).toBeUndefined();
-    expect(spec!.mounts).toBeUndefined();
-  });
-
-  test("--vault without a tag list omits tags", () => {
-    const { spec } = parseArgs(["a", "--channel", "c", "--vault", "default:write"]);
-    expect(spec!.vault).toEqual({ name: "default", access: "write" });
-  });
-
-  test("the FIRST channel is the wake channel (order preserved)", () => {
-    const { spec } = parseArgs(["a", "--channel", "first", "--channel", "second"]);
-    expect(spec!.channels[0]).toEqual({ name: "first" });
-    expect(spec!.channels[1]).toEqual({ name: "second" });
-  });
-
-  test("defaults omit filesystem/network; --full-read + --restricted set them + keep --egress", () => {
-    const def = parseArgs(["a", "--channel", "c"]).spec!;
-    expect(def.filesystem).toBeUndefined(); // default = workspace (scoped reads)
-    expect(def.network).toBeUndefined(); // default = open
-    const { spec } = parseArgs(["a", "--channel", "c", "--egress", "x.com", "--full-read", "--restricted"]);
-    expect(spec!.filesystem).toBe("full");
-    expect(spec!.network).toBe("restricted");
-    expect(spec!.egress).toEqual(["x.com"]); // additive hosts kept (used under restricted)
-  });
-});
-
-describe("parseArgs — --help short-circuits", () => {
-  test("--help returns help:true and builds no spec", () => {
-    const r = parseArgs(["--help"]);
-    expect(r.help).toBe(true);
-    expect(r.spec).toBeUndefined();
-  });
-
-  test("-h is the short alias", () => {
-    expect(parseArgs(["-h"]).help).toBe(true);
-  });
-
-  test("--help wins even with other args present", () => {
-    const r = parseArgs(["name", "--channel", "c", "--help"]);
-    expect(r.help).toBe(true);
-    expect(r.spec).toBeUndefined();
-  });
-});
-
-describe("parseArgs — bad args reject", () => {
-  test("missing name", () => {
-    expect(() => parseArgs(["--channel", "c"])).toThrow(ArgError);
-    expect(() => parseArgs(["--channel", "c"])).toThrow(/missing required <name>/);
-  });
-
-  test("no channels", () => {
-    expect(() => parseArgs(["just-a-name"])).toThrow(/at least one --channel/);
-  });
-
-  test("a second positional is rejected", () => {
-    expect(() => parseArgs(["a", "b", "--channel", "c"])).toThrow(/only one <name>/);
-  });
-
-  test("an unknown flag is rejected", () => {
-    expect(() => parseArgs(["a", "--channel", "c", "--bogus"])).toThrow(/unknown flag "--bogus"/);
-  });
-
-  test("a flag with a missing value is rejected", () => {
-    expect(() => parseArgs(["a", "--channel"])).toThrow(/--channel: expected a value/);
-    // A following flag is NOT consumed as the value.
-    expect(() => parseArgs(["a", "--channel", "--vault"])).toThrow(/--channel: expected a value/);
-  });
-
-  test("a bad channel access verb is rejected", () => {
-    expect(() => parseArgs(["a", "--channel", "c:admin"])).toThrow(/access must be "read" or "write"/);
-  });
-
-  test("an over-segmented channel is rejected", () => {
-    expect(() => parseArgs(["a", "--channel", "c:read:extra"])).toThrow(/extra ":"/);
-  });
-
-  test("a bad vault shape is rejected", () => {
-    expect(() => parseArgs(["a", "--channel", "c", "--vault", "default"])).toThrow(
-      /expected <name>:<read\|write>/,
-    );
-    expect(() => parseArgs(["a", "--channel", "c", "--vault", "default:admin"])).toThrow(
-      /access must be "read" or "write"/,
-    );
-  });
-
-  test("--vault given twice is rejected", () => {
-    expect(() =>
-      parseArgs(["a", "--channel", "c", "--vault", "default:read", "--vault", "other:write"]),
-    ).toThrow(/--vault may only be given once/);
-  });
-
-  test("a bad mount shape is rejected", () => {
-    expect(() => parseArgs(["a", "--channel", "c", "--mount", "/h:/m"])).toThrow(
-      /expected <hostPath:mountPath:ro\|rw/,
-    );
-    expect(() => parseArgs(["a", "--channel", "c", "--mount", "/h:/m:rx"])).toThrow(
-      /mode must be "ro" or "rw"/,
-    );
-  });
-
-  test("an empty egress list parses to no egress (not an error)", () => {
-    const { spec } = parseArgs(["a", "--channel", "c", "--egress", ""]);
-    expect(spec!.egress).toBeUndefined();
-  });
-});