claudeup 4.16.0 → 4.18.0

package/src/__tests__/alias-shell-writer.test.ts

@@ -0,0 +1,661 @@
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { mkdtemp, rm, writeFile, readFile, mkdir } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+import {
+  detectShells,
+  renderArgsAsTokens as renderArgs,
+  renderArgs as renderArgsSegments,
+  renderAlias,
+  spliceManagedBlock,
+  validateConfig,
+  writeAliasToShell,
+  findUnquotableTokens,
+  expandTemplateValue,
+  type ShellTarget,
+  type Segment,
+} from "../services/alias-shell-writer";
+import { defaultAliasConfig } from "../services/alias-store";
+
+describe("renderArgs", () => {
+  it("emits nothing when every flag is at default (off)", () => {
+    expect(renderArgs(defaultAliasConfig())).toEqual([]);
+  });
+
+  it("renders boolean flags as bare tokens", () => {
+    const c = defaultAliasConfig();
+    c.flags["dangerously-skip-permissions"] = {
+      kind: "boolean",
+      enabled: true,
+    };
+    c.flags["ide"] = { kind: "boolean", enabled: true };
+    expect(renderArgs(c)).toEqual(["--dangerously-skip-permissions", "--ide"]);
+  });
+
+  it("renders tri-state on/off and skips unset", () => {
+    const c = defaultAliasConfig();
+    c.flags["chrome"] = { kind: "tri-state", state: "on" };
+    expect(renderArgs(c)).toEqual(["--chrome"]);
+    c.flags["chrome"] = { kind: "tri-state", state: "off" };
+    expect(renderArgs(c)).toEqual(["--no-chrome"]);
+    c.flags["chrome"] = { kind: "tri-state", state: "unset" };
+    expect(renderArgs(c)).toEqual([]);
+  });
+
+  it("renders select with value", () => {
+    const c = defaultAliasConfig();
+    c.flags["effort"] = { kind: "select", enabled: true, value: "high" };
+    expect(renderArgs(c)).toEqual(["--effort", "high"]);
+  });
+
+  it("renders select with empty value as bare flag", () => {
+    const c = defaultAliasConfig();
+    c.flags["worktree"] = { kind: "boolean", enabled: true };
+    c.flags["tmux"] = { kind: "select", enabled: true, value: "" };
+    expect(renderArgs(c)).toEqual(["--worktree", "--tmux"]);
+  });
+
+  it("enforces requires: --tmux is dropped without --worktree", () => {
+    const c = defaultAliasConfig();
+    c.flags["tmux"] = { kind: "select", enabled: true, value: "classic" };
+    expect(renderArgs(c)).toEqual([]);
+  });
+
+  it("admits --tmux once --worktree is enabled", () => {
+    const c = defaultAliasConfig();
+    c.flags["worktree"] = { kind: "boolean", enabled: true };
+    c.flags["tmux"] = { kind: "select", enabled: true, value: "classic" };
+    expect(renderArgs(c)).toEqual(["--worktree", "--tmux", "classic"]);
+  });
+
+  it("enforces xor: --system-prompt wins over --system-prompt-file", () => {
+    const c = defaultAliasConfig();
+    c.flags["system-prompt"] = {
+      kind: "text",
+      enabled: true,
+      value: "hello",
+    };
+    c.flags["system-prompt-file"] = {
+      kind: "text",
+      enabled: true,
+      value: "/tmp/p.txt",
+    };
+    const args = renderArgs(c);
+    expect(args).toEqual(["--system-prompt", "hello"]);
+  });
+
+  it("renders text-list as repeated flag/value pairs", () => {
+    const c = defaultAliasConfig();
+    c.flags["dangerously-load-development-channels"] = {
+      kind: "text-list",
+      enabled: true,
+      values: ["plugin:claudish@magus", "plugin:dev@magus"],
+    };
+    expect(renderArgs(c)).toEqual([
+      "--dangerously-load-development-channels",
+      "plugin:claudish@magus",
+      "--dangerously-load-development-channels",
+      "plugin:dev@magus",
+    ]);
+  });
+
+  it("renders multi-with-custom: picked tokens then custom, deduped, comma-joined", () => {
+    const c = defaultAliasConfig();
+    c.flags["debug"] = {
+      kind: "multi-with-custom",
+      enabled: true,
+      picked: ["api", "hooks"],
+      custom: ["!1p", "!file", "api"], // duplicate "api"
+    };
+    expect(renderArgs(c)).toEqual(["--debug", "api,hooks,!1p,!file"]);
+  });
+
+  it("renders multi-with-custom with no tokens as bare --debug", () => {
+    const c = defaultAliasConfig();
+    c.flags["debug"] = {
+      kind: "multi-with-custom",
+      enabled: true,
+      picked: [],
+      custom: [],
+    };
+    expect(renderArgs(c)).toEqual(["--debug"]);
+  });
+
+  it("renders --remote-control as a boolean toggle", () => {
+    const c = defaultAliasConfig();
+    c.flags["remote-control"] = { kind: "boolean", enabled: true };
+    expect(renderArgs(c)).toEqual(["--remote-control"]);
+    c.flags["remote-control"] = { kind: "boolean", enabled: false };
+    expect(renderArgs(c)).toEqual([]);
+  });
+
+  it("renders --remote-control alongside --remote-control-session-name-prefix", () => {
+    const c = defaultAliasConfig();
+    c.flags["remote-control"] = { kind: "boolean", enabled: true };
+    c.flags["remote-control-session-name-prefix"] = {
+      kind: "text",
+      enabled: true,
+      value: "jack-laptop",
+    };
+    expect(renderArgs(c)).toEqual([
+      "--remote-control",
+      "--remote-control-session-name-prefix",
+      "jack-laptop",
+    ]);
+  });
+});
+
+describe("renderAlias — POSIX (zsh/bash)", () => {
+  it("emits an empty alias when no flags are enabled", () => {
+    const r = renderAlias(defaultAliasConfig(), "zsh");
+    expect(r.block).toContain("alias c='claude'");
+    expect(r.block).toMatch(/^# >>> claudeup managed alias >>>\n/);
+    expect(r.block).toMatch(/# <<< claudeup managed alias <<<\n$/);
+  });
+
+  it("uses the configured alias name", () => {
+    const c = defaultAliasConfig();
+    c.aliasName = "ccc";
+    c.flags["ide"] = { kind: "boolean", enabled: true };
+    const r = renderAlias(c, "zsh");
+    expect(r.block).toContain("alias ccc='claude --ide'");
+    const fish = renderAlias(c, "fish");
+    expect(fish.block).toContain("alias ccc 'claude");
+  });
+
+  it("emits bare flags without quoting", () => {
+    const c = defaultAliasConfig();
+    c.flags["dangerously-skip-permissions"] = {
+      kind: "boolean",
+      enabled: true,
+    };
+    c.flags["ide"] = { kind: "boolean", enabled: true };
+    const r = renderAlias(c, "zsh");
+    expect(r.block).toContain(
+      "alias c='claude --dangerously-skip-permissions --ide'",
+    );
+  });
+
+  it("quotes values with spaces using nested single-quote escapes", () => {
+    const c = defaultAliasConfig();
+    c.flags["append-system-prompt"] = {
+      kind: "text",
+      enabled: true,
+      value: "be terse",
+    };
+    const r = renderAlias(c, "zsh");
+    // The final alias body should contain: --append-system-prompt 'be terse'
+    // Encoded inside the outer single-quoted alias as:
+    //   --append-system-prompt '\''be terse'\''
+    expect(r.block).toContain(
+      "alias c='claude --append-system-prompt '\\''be terse'\\'''",
+    );
+  });
+
+  it("leaves comma- and slash-bearing simple values unquoted", () => {
+    const c = defaultAliasConfig();
+    c.flags["debug"] = {
+      kind: "multi-with-custom",
+      enabled: true,
+      picked: ["api", "hooks"],
+      custom: ["!file"],
+    };
+    c.flags["append-system-prompt-file"] = {
+      kind: "text",
+      enabled: true,
+      value: "/tmp/p.txt",
+    };
+    const r = renderAlias(c, "zsh");
+    expect(r.block).toContain("--debug api,hooks,!file");
+    expect(r.block).toContain("--append-system-prompt-file /tmp/p.txt");
+  });
+});
+
+describe("renderAlias — fish", () => {
+  it("uses fish syntax (no = sign)", () => {
+    const c = defaultAliasConfig();
+    c.flags["ide"] = { kind: "boolean", enabled: true };
+    const r = renderAlias(c, "fish");
+    // Outer fish alias: alias c 'claude '--ide''  (each arg fish-quoted)
+    expect(r.block).toContain("alias c 'claude");
+    expect(r.block).toContain("--ide");
+    expect(r.block).not.toContain("alias c='claude");
+  });
+});
+
+describe("expandTemplateValue", () => {
+  it("returns a single literal when no tokens are present", () => {
+    expect(expandTemplateValue("plain-prefix")).toEqual([
+      { kind: "literal", text: "plain-prefix" },
+    ]);
+  });
+
+  it("splits literal/raw alternations for known tokens", () => {
+    expect(expandTemplateValue("dev-{folder}-{day}")).toEqual([
+      { kind: "literal", text: "dev-" },
+      { kind: "raw", posix: '$(basename "$PWD")', fish: "(basename $PWD)" },
+      { kind: "literal", text: "-" },
+      { kind: "raw", posix: "$(date +%d)", fish: "(date +%d)" },
+    ]);
+  });
+
+  it("ignores unknown {bracketed} sequences (passes through as literal)", () => {
+    expect(expandTemplateValue("dev-{unknown}-{folder}")).toEqual([
+      { kind: "literal", text: "dev-{unknown}-" },
+      { kind: "raw", posix: '$(basename "$PWD")', fish: "(basename $PWD)" },
+    ]);
+  });
+
+  it("handles a value that's just a token", () => {
+    expect(expandTemplateValue("{year}")).toEqual([
+      { kind: "raw", posix: "$(date +%Y)", fish: "(date +%Y)" },
+    ]);
+  });
+});
+
+describe("renderAlias — templated values", () => {
+  it("emits a composite POSIX segment with embedded substitutions", () => {
+    const c = defaultAliasConfig();
+    c.flags["remote-control"] = { kind: "boolean", enabled: true };
+    c.flags["remote-control-session-name-prefix"] = {
+      kind: "text",
+      enabled: true,
+      value: "dev-{folder}-{day}",
+    };
+    const r = renderAlias(c, "zsh");
+    // Expected pattern: alias c='claude --remote-control --remote-control-session-name-prefix dev-'"$(basename "$PWD")"'-'"$(date +%d)"''
+    expect(r.block).toContain("--remote-control-session-name-prefix");
+    expect(r.block).toContain('dev-\'"$(basename "$PWD")"\'-\'"$(date +%d)"\'');
+    // Sanity: no raw `{folder}` literal made it through.
+    expect(r.block).not.toContain("{folder}");
+    expect(r.block).not.toContain("{day}");
+  });
+
+  it("emits a composite fish segment with fish-style substitutions", () => {
+    const c = defaultAliasConfig();
+    c.flags["remote-control-session-name-prefix"] = {
+      kind: "text",
+      enabled: true,
+      value: "{folder}-{year}",
+    };
+    const r = renderAlias(c, "fish");
+    // Fish treats adjacent quoted strings inside an alias body as one arg,
+    // so the literal `-` between the two substitutions stays single-quoted.
+    expect(r.block).toContain('\'"(basename $PWD)"\'\'-\'\'"(date +%Y)"\'');
+  });
+
+  it("falls back to a plain literal when no tokens are present", () => {
+    const c = defaultAliasConfig();
+    c.flags["remote-control-session-name-prefix"] = {
+      kind: "text",
+      enabled: true,
+      value: "static-prefix",
+    };
+    const r = renderAlias(c, "zsh");
+    expect(r.block).toContain("--remote-control-session-name-prefix static-prefix");
+    expect(r.block).not.toContain('"');
+  });
+});
+
+describe("findUnquotableTokens", () => {
+  it("flags any literal segment text containing a single quote", () => {
+    const segs: Segment[] = [
+      { kind: "literal", text: "foo" },
+      { kind: "literal", text: "it's" },
+      { kind: "literal", text: "bar" },
+    ];
+    expect(findUnquotableTokens(segs)).toEqual(["it's"]);
+    expect(
+      findUnquotableTokens([
+        { kind: "literal", text: "foo" },
+        { kind: "literal", text: "bar" },
+      ]),
+    ).toEqual([]);
+  });
+
+  it("walks composite segments and flags unquotable literal parts", () => {
+    const segs: Segment[] = [
+      {
+        kind: "composite",
+        parts: [
+          { kind: "literal", text: "ok-" },
+          { kind: "raw", posix: "$(date +%d)", fish: "(date +%d)" },
+          { kind: "literal", text: "it's" },
+        ],
+      },
+    ];
+    expect(findUnquotableTokens(segs)).toEqual(["it's"]);
+  });
+});
+
+describe("spliceManagedBlock", () => {
+  const block = `# >>> claudeup managed alias >>>\nalias c='claude --ide'\n# <<< claudeup managed alias <<<\n`;
+
+  it("appends the block to an empty file", () => {
+    expect(spliceManagedBlock("", block)).toBe(block);
+  });
+
+  it("appends the block with separator when existing has content", () => {
+    const existing = "export PATH=$PATH:/usr/local/bin\n";
+    const result = spliceManagedBlock(existing, block);
+    expect(result.startsWith(existing)).toBe(true);
+    expect(result.endsWith(block)).toBe(true);
+    expect(result).toContain("\n\n# >>> claudeup managed alias >>>");
+  });
+
+  it("replaces an existing block in place without disturbing surrounding lines", () => {
+    const before = "alias ll='ls -la'\n";
+    const after = "export EDITOR=vim\n";
+    const oldBlock = `# >>> claudeup managed alias >>>\nalias c='claude --debug'\n# <<< claudeup managed alias <<<\n`;
+    const existing = before + oldBlock + after;
+    const result = spliceManagedBlock(existing, block);
+    expect(result).toBe(before + block + after);
+  });
+
+  it("is idempotent: writing the same block twice yields the same file", () => {
+    const once = spliceManagedBlock("", block);
+    const twice = spliceManagedBlock(once, block);
+    expect(twice).toBe(once);
+  });
+
+  it("recovers when the END marker is missing (truncated/edited block)", () => {
+    const truncated = `# >>> claudeup managed alias >>>\nalias c='claude --broken\n`;
+    const result = spliceManagedBlock(truncated, block);
+    expect(result).toBe(block);
+  });
+
+  it("preserves a stray hand-edit outside the block", () => {
+    const existing = `# user comment\nalias g='git'\n${block}# trailing comment\n`;
+    // Re-render with same block — surrounding text is preserved verbatim.
+    const result = spliceManagedBlock(existing, block);
+    expect(result).toBe(existing);
+  });
+});
+
+describe("validateConfig", () => {
+  it("reports nothing for the default config", () => {
+    expect(validateConfig(defaultAliasConfig())).toEqual([]);
+  });
+
+  it("flags --tmux as requiring --worktree", () => {
+    const c = defaultAliasConfig();
+    c.flags["tmux"] = { kind: "select", enabled: true, value: "classic" };
+    const issues = validateConfig(c);
+    expect(issues).toEqual([
+      { flagId: "tmux", reason: expect.stringContaining("--worktree") },
+    ]);
+  });
+
+  it("flags xor losers when both system-prompt fields are set", () => {
+    const c = defaultAliasConfig();
+    c.flags["system-prompt"] = { kind: "text", enabled: true, value: "a" };
+    c.flags["system-prompt-file"] = {
+      kind: "text",
+      enabled: true,
+      value: "/x",
+    };
+    const issues = validateConfig(c);
+    expect(issues).toHaveLength(1);
+    expect(issues[0].flagId).toBe("system-prompt-file");
+  });
+
+  it("reports nothing once the dependency is satisfied", () => {
+    const c = defaultAliasConfig();
+    c.flags["worktree"] = { kind: "boolean", enabled: true };
+    c.flags["tmux"] = { kind: "select", enabled: true, value: "classic" };
+    expect(validateConfig(c)).toEqual([]);
+  });
+});
+
+describe("detectShells", () => {
+  let home: string;
+
+  beforeEach(async () => {
+    home = await mkdtemp(join(tmpdir(), "alias-detect-"));
+  });
+
+  afterEach(async () => {
+    await rm(home, { recursive: true, force: true });
+  });
+
+  it("reports no shell as existing when none of the rc files are present", async () => {
+    const shells = await detectShells(home, "/bin/zsh");
+    expect(shells.map((s) => s.kind)).toEqual(["zsh", "bash", "fish"]);
+    expect(shells.every((s) => !s.exists)).toBe(true);
+    expect(shells.find((s) => s.kind === "zsh")?.isDefault).toBe(true);
+  });
+
+  it("marks rc files that exist", async () => {
+    await writeFile(join(home, ".zshrc"), "# zshrc\n", "utf8");
+    await mkdir(join(home, ".config", "fish"), { recursive: true });
+    await writeFile(
+      join(home, ".config", "fish", "config.fish"),
+      "# fish\n",
+      "utf8",
+    );
+    const shells = await detectShells(home, "/usr/local/bin/fish");
+    const byKind = Object.fromEntries(shells.map((s) => [s.kind, s]));
+    expect(byKind.zsh.exists).toBe(true);
+    expect(byKind.bash.exists).toBe(false);
+    expect(byKind.fish.exists).toBe(true);
+    expect(byKind.fish.isDefault).toBe(true);
+  });
+});
+
+describe("writeAliasToShell — end-to-end", () => {
+  let home: string;
+
+  beforeEach(async () => {
+    home = await mkdtemp(join(tmpdir(), "alias-write-"));
+  });
+
+  afterEach(async () => {
+    await rm(home, { recursive: true, force: true });
+  });
+
+  it("creates the rc file when missing and writes the managed block", async () => {
+    const target: ShellTarget = {
+      kind: "zsh",
+      path: join(home, ".zshrc"),
+      exists: false,
+      isDefault: true,
+    };
+    const c = defaultAliasConfig();
+    c.flags["ide"] = { kind: "boolean", enabled: true };
+    const result = await writeAliasToShell(c, target);
+    expect(result.action).toBe("created");
+    const written = await readFile(target.path, "utf8");
+    expect(written).toContain("alias c='claude --ide'");
+    expect(written).toContain("# >>> claudeup managed alias >>>");
+  });
+
+  it("updates an existing rc file in place without losing surrounding content", async () => {
+    const path = join(home, ".zshrc");
+    await writeFile(
+      path,
+      "export PATH=$PATH:/opt/bin\nalias ll='ls -la'\n",
+      "utf8",
+    );
+    const target: ShellTarget = {
+      kind: "zsh",
+      path,
+      exists: true,
+      isDefault: true,
+    };
+    const c = defaultAliasConfig();
+    c.flags["ide"] = { kind: "boolean", enabled: true };
+    const result = await writeAliasToShell(c, target);
+    expect(result.action).toBe("updated");
+    const written = await readFile(path, "utf8");
+    expect(written).toContain("export PATH=$PATH:/opt/bin");
+    expect(written).toContain("alias ll='ls -la'");
+    expect(written).toContain("alias c='claude --ide'");
+  });
+
+  it("re-writing replaces (not duplicates) the managed block", async () => {
+    const path = join(home, ".zshrc");
+    const target: ShellTarget = {
+      kind: "zsh",
+      path,
+      exists: false,
+      isDefault: true,
+    };
+    const c = defaultAliasConfig();
+    c.flags["ide"] = { kind: "boolean", enabled: true };
+    await writeAliasToShell(c, target);
+    target.exists = true;
+    c.flags["ide"] = { kind: "boolean", enabled: false };
+    c.flags["dangerously-skip-permissions"] = { kind: "boolean", enabled: true };
+    await writeAliasToShell(c, target);
+    const written = await readFile(path, "utf8");
+    expect(written).toContain("--dangerously-skip-permissions");
+    expect(written).not.toContain("--ide");
+    // Block markers appear exactly once
+    const beginMatches = written.match(/# >>> claudeup managed alias >>>/g);
+    expect(beginMatches?.length).toBe(1);
+  });
+
+  it("rejects writes containing tokens with embedded single quotes", async () => {
+    const path = join(home, ".zshrc");
+    const target: ShellTarget = {
+      kind: "zsh",
+      path,
+      exists: false,
+      isDefault: true,
+    };
+    const c = defaultAliasConfig();
+    c.flags["append-system-prompt"] = {
+      kind: "text",
+      enabled: true,
+      value: "it's tricky",
+    };
+    await expect(writeAliasToShell(c, target)).rejects.toThrow(/single quote/);
+  });
+});
+
+/**
+ * Behavioral round-trip: write a managed block, source it through real bash,
+ * and inspect the resulting alias. This guards against quoting bugs that
+ * pure byte-equality tests above would miss.
+ */
+describe("end-to-end via bash subprocess", () => {
+  let home: string;
+
+  beforeEach(async () => {
+    home = await mkdtemp(join(tmpdir(), "alias-bash-"));
+  });
+
+  afterEach(async () => {
+    await rm(home, { recursive: true, force: true });
+  });
+
+  it("bash sources the emitted block and `alias claude` reports the right body", async () => {
+    if (spawnSync("bash", ["-c", "true"]).status !== 0) {
+      // No bash on the runner — skip.
+      return;
+    }
+    const path = join(home, ".bashrc");
+    const target: ShellTarget = {
+      kind: "bash",
+      path,
+      exists: false,
+      isDefault: true,
+    };
+    const c = defaultAliasConfig();
+    c.flags["dangerously-skip-permissions"] = { kind: "boolean", enabled: true };
+    c.flags["debug"] = {
+      kind: "multi-with-custom",
+      enabled: true,
+      picked: ["api", "hooks"],
+      custom: ["!file"],
+    };
+    c.flags["append-system-prompt"] = {
+      kind: "text",
+      enabled: true,
+      value: "be terse",
+    };
+    await writeAliasToShell(c, target);
+
+    const result = spawnSync(
+      "bash",
+      ["--noprofile", "--norc", "-c", `source ${path} && alias c`],
+      { encoding: "utf8" },
+    );
+    expect(result.status).toBe(0);
+    // Bash's `alias c` prints: alias c='<body>'
+    // We just check the rendered body contains the flag tokens correctly
+    // separated and the quoted prompt value preserved.
+    expect(result.stdout).toContain("--dangerously-skip-permissions");
+    expect(result.stdout).toContain("--debug api,hooks,!file");
+    expect(result.stdout).toContain("--append-system-prompt");
+    expect(result.stdout).toContain("be terse");
+  });
+
+  it("templated prefix expands at alias-expansion time, not at write time", async () => {
+    if (spawnSync("bash", ["-c", "true"]).status !== 0) return;
+
+    const path = join(home, ".bashrc");
+    const target: ShellTarget = {
+      kind: "bash",
+      path,
+      exists: false,
+      isDefault: true,
+    };
+    const c = defaultAliasConfig();
+    c.flags["remote-control"] = { kind: "boolean", enabled: true };
+    c.flags["remote-control-session-name-prefix"] = {
+      kind: "text",
+      enabled: true,
+      value: "dev-{folder}-{day}",
+    };
+    await writeAliasToShell(c, target);
+
+    // Replace the underlying `claude` binary with a stub that echoes its argv,
+    // then invoke the alias from inside a directory we control. The captured
+    // stdout shows what argv claude would have been called with — including
+    // the actual expansion of {folder} and {day} from the surrounding shell.
+    const probeDir = await mkdtemp(join(tmpdir(), "alias-probe-"));
+    const stubBin = join(probeDir, "bin");
+    await mkdir(stubBin, { recursive: true });
+    const stubPath = join(stubBin, "claude");
+    await writeFile(
+      stubPath,
+      '#!/usr/bin/env bash\nfor a in "$@"; do echo "ARG:$a"; done\n',
+      "utf8",
+    );
+    spawnSync("chmod", ["+x", stubPath]);
+    const cwdNamed = join(probeDir, "myproject");
+    await mkdir(cwdNamed, { recursive: true });
+
+    const result = spawnSync(
+      "bash",
+      [
+        "--noprofile",
+        "--norc",
+        "-O",
+        "expand_aliases",
+        "-c",
+        // Run with the stub on PATH and cwd inside myproject so {folder}
+        // expands to "myproject". `-O expand_aliases` enables alias expansion
+        // in non-interactive bash; `eval` defers parsing of `c` so the alias
+        // is visible when it's resolved (bash parses the whole -c argument
+        // up-front, so a bare `c` would be unknown at parse time).
+        `export PATH="${stubBin}:$PATH" && cd "${cwdNamed}" && source ${path} && eval c`,
+      ],
+      { encoding: "utf8" },
+    );
+    expect(result.status).toBe(0);
+    // The session-name-prefix arg should have been expanded to the literal
+    // string `dev-myproject-<two-digit-day>`.
+    const argLines = result.stdout.split("\n").filter((l) => l.startsWith("ARG:"));
+    const prefixArg = argLines.find((l) =>
+      argLines.indexOf(l) > 0 && argLines[argLines.indexOf(l) - 1] === "ARG:--remote-control-session-name-prefix",
+    );
+    expect(prefixArg).toBeDefined();
+    // Match `dev-myproject-NN` where NN is a 2-digit day.
+    expect(prefixArg).toMatch(/^ARG:dev-myproject-\d{2}$/);
+
+    await rm(probeDir, { recursive: true, force: true });
+  });
+});