#!/usr/bin/env node

// Offline shell proofs. Every destination and download is a disposable fixture;
// curl, uname, and sudo are intercepted so no real installation or network runs.
const assert = require("node:assert/strict");
const { spawnSync } = require("node:child_process");
const crypto = require("node:crypto");
const fs = require("node:fs");
const os = require("node:os");
const path = require("node:path");
const test = require("node:test");

const repo = path.resolve(__dirname, "../..");
const bytes = '#!/bin/sh\necho "executed $*" >> "$INSTALL_TEST_EXECUTED"\ncase "$1" in --help) printf \'%s\\n\' "${INSTALL_TEST_HELP:-}" ;; *) echo "codewhale 0.9.11" ;; esac\n';

function executable(file, body) {
  fs.writeFileSync(file, body, { mode: 0o755 });
}

function fixture(t, kind) {
  const root = fs.mkdtempSync(path.join(os.tmpdir(), "cw-install-safety-"));
  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
  const home = path.join(root, "home");
  const bin = path.join(root, "tools");
  const archive = path.join(root, "archive");
  const assets = path.join(root, "assets");
  for (const dir of [home, bin, archive, assets]) fs.mkdirSync(dir);
  fs.copyFileSync(path.join(repo, "scripts/release/install.sh"), path.join(archive, "install.sh"));
  for (const name of ["codewhale", "codew"]) {
    executable(path.join(archive, name), bytes);
    executable(path.join(assets, `${name}-macos-arm64`), bytes);
  }
  const hash = crypto.createHash("sha256").update(bytes).digest("hex");
  fs.writeFileSync(path.join(assets, "codewhale-artifacts-sha256.txt"),
    `${hash}  codewhale-macos-arm64\n${hash}  codew-macos-arm64\n`);
  executable(path.join(bin, "uname"), '#!/bin/sh\ncase "$1" in -s) echo Darwin ;; -m) echo arm64 ;; esac\n');
  executable(path.join(bin, "sudo"), '#!/bin/sh\necho sudo >> "$INSTALL_TEST_EXECUTED"\nexit 97\n');
  executable(path.join(bin, "codewhale"), '#!/bin/sh\necho shadow >> "$INSTALL_TEST_EXECUTED"\nexit 98\n');
  executable(path.join(bin, "curl"), `#!/bin/sh
url=""; output=""
while [ "$#" -gt 0 ]; do
  case "$1" in
    -o) shift; output="$1" ;;
    http*) url="$1" ;;
  esac
  shift
done
printf '%s\n' "$url" >> "$INSTALL_TEST_DOWNLOADS"
asset="$(basename "$url")"
cp "$INSTALL_TEST_ASSETS/$asset" "$output"
`);
  const destination = path.join(home, ".local", "bin");
  fs.mkdirSync(destination, { recursive: true });
  fs.chmodSync(destination, 0o755);
  const env = { ...process.env, HOME: home, PATH: `${bin}:${process.env.PATH}`, CI: "1",
    CODEWHALE_VERSION: "v0.9.11", CODEWHALE_INSTALL_DIR: destination,
    PREFIX: path.dirname(destination), INSTALL_TEST_ASSETS: assets,
    INSTALL_TEST_EXECUTED: path.join(root, "executed"),
    INSTALL_TEST_DOWNLOADS: path.join(root, "downloads") };
  for (const key of ["CODEWHALE_RELEASE_BASE_URL", "DEEPSEEK_TUI_RELEASE_BASE_URL", "CODEWHALE_SKIP_GLIBC_CHECK", "DEEPSEEK_TUI_SKIP_GLIBC_CHECK", "DEEPSEEK_SKIP_GLIBC_CHECK", "TERMUX_VERSION", "CODEWHALE_HOME", "CODEWHALE_FORCE_REINSTALL", "CODEWHALE_INSTALL_COMPILED_HOST", "SHELL", "ZDOTDIR"]) delete env[key];
  function run(args = []) {
    const script = kind === "website" ? path.join(repo, "web/public/install.sh") : path.join(archive, "install.sh");
    return spawnSync(kind === "website" ? "sh" : "bash", [script, ...args], { env, encoding: "utf8", timeout: 10000 });
  }
  function prepare() { fs.mkdirSync(env.CODEWHALE_INSTALL_DIR, { recursive: true }); }
  function untouched() {
    const runs = fs.existsSync(env.INSTALL_TEST_EXECUTED) ? fs.readFileSync(env.INSTALL_TEST_EXECUTED, "utf8").trim().split("\n") : [];
    assert.ok(runs.every(line => line === "executed doctor --installs --brief" || line === "executed --help"), `installers must not execute existing files or sudo: ${runs.join(", ")}`);
  }
  return { root, home, bin, archive, assets, destination, env, run, prepare, untouched };
}

for (const kind of ["website", "archive"]) {
  test(`${kind}: fresh installation verifies bytes, executable modes, and PATH shadowing`, t => {
    const f = fixture(t, kind);
    const result = f.run();
    assert.equal(result.status, 0, result.stderr);
    for (const name of ["codewhale", "codew"]) {
      const installed = path.join(f.destination, name);
      assert.equal(fs.readFileSync(installed, "utf8"), bytes);
      assert.ok(fs.statSync(installed).mode & 0o111);
    }
    const receipt = fs.readFileSync(path.join(f.destination, ".codewhale-install.sha256"), "utf8");
    const hash = crypto.createHash("sha256").update(bytes).digest("hex");
    assert.equal(receipt, `${hash}  codewhale
${hash}  codew
`);
    assert.match(result.stdout, /PATH selects/);
    assert.ok(result.stdout.includes(`"${fs.realpathSync(f.destination)}/codewhale" update`), result.stdout);
    if (kind === "website") {
      const downloads = fs.readFileSync(f.env.INSTALL_TEST_DOWNLOADS, "utf8").trim().split("\n");
      assert.equal(downloads.length, 2);
      assert.ok(downloads.some(url => url.endsWith("/codewhale-macos-arm64")));
      assert.ok(!downloads.some(url => url.endsWith("/codew-macos-arm64")));
      assert.ok(downloads.every(url => url.startsWith("https://github.com/codewhale-hq/CodeWhale/releases/download/v0.9.11/")));
    }
    f.untouched();
  });

  test(`${kind}: the output ends with the PATH command and the verify command`, t => {
    const f = fixture(t, kind);
    const result = f.run();
    assert.equal(result.status, 0, result.stderr);
    const lines = result.stdout.split("\n").map(line => line.trim()).filter(Boolean);
    assert.equal(lines.at(-1), "codewhale --version", result.stdout);
    assert.equal(lines.at(-2), "Then check it:", result.stdout);
    assert.ok(lines.at(-3).startsWith("export PATH="), result.stdout);
    assert.ok(lines.at(-3).endsWith("hash -r"), result.stdout);
    f.untouched();
  });

  test(`${kind}: on macOS without Node the Computer Use notice precedes the PATH block`, t => {
    const noNode = ["/usr/bin", "/bin"].every(dir => !fs.existsSync(path.join(dir, "node")));
    if (!noNode) return t.skip("node is installed in a system directory");
    const f = fixture(t, kind);
    f.env.PATH = `${f.bin}:/usr/bin:/bin`;
    const result = f.run();
    assert.equal(result.status, 0, result.stderr);
    const out = result.stdout;
    const notice = out.indexOf("Computer Use is included and needs Node.js 20");
    assert.ok(notice >= 0, out);
    assert.ok(notice < out.indexOf("PATH selects"), out);
    assert.ok(notice < out.indexOf("Run this now, in this shell:"), out);
    assert.equal(out.trim().split("\n").at(-1).trim(), "codewhale --version", out);
    f.untouched();
  });

  test(`${kind}: rerunning an identical installation preserves its files`, t => {
    const f = fixture(t, kind);
    assert.equal(f.run().status, 0);
    const file = path.join(f.destination, "codewhale");
    const before = fs.statSync(file);
    const result = f.run();
    assert.equal(result.status, 0, result.stderr);
    assert.equal(fs.statSync(file).ino, before.ino);
    assert.equal(fs.readFileSync(file, "utf8"), bytes);
    f.untouched();
  });

  test(`${kind}: refuses a non-Codewhale file at the destination without executing it`, t => {
    const f = fixture(t, kind); f.prepare();
    const primary = path.join(f.destination, "codewhale");
    const newer = bytes.replace("0.9.11", "0.9.12");
    executable(primary, newer);
    const result = f.run();
    assert.notEqual(result.status, 0);
    assert.ok(result.stderr.includes(primary), result.stderr);
    assert.match(result.stderr, /fresh (directory|prefix)/);
    assert.equal(fs.readFileSync(primary, "utf8"), newer);
    assert.equal(fs.existsSync(path.join(f.destination, "codew")), false);
    f.untouched();
  });

  for (const name of ["codew", "codewhale-tui"]) {
    test(`${kind}: existing ${name} follows current command ownership`, t => {
      const f = fixture(t, kind); f.prepare();
      const file = path.join(f.destination, name);
      executable(file, "unrelated bytes");
      const result = f.run();
      assert.equal(fs.readFileSync(file, "utf8"), "unrelated bytes");
      if (name === "codewhale-tui") {
        assert.equal(result.status, 0, result.stderr);
        assert.equal(fs.readFileSync(path.join(f.destination, "codewhale"), "utf8"), bytes);
      } else {
        assert.notEqual(result.status, 0);
        assert.ok(result.stderr.includes(file), result.stderr);
        assert.equal(fs.existsSync(path.join(f.destination, "codewhale")), false);
      }
      f.untouched();
    });
  }

  test(`${kind}: refuses a symlink destination and preserves its target`, t => {
    const f = fixture(t, kind); f.prepare();
    const target = path.join(f.root, "foreign");
    executable(target, "unrelated bytes");
    const alias = path.join(f.destination, "codew");
    fs.symlinkSync(target, alias);
    assert.notEqual(f.run().status, 0);
    assert.ok(fs.lstatSync(alias).isSymbolicLink());
    assert.equal(fs.readFileSync(target, "utf8"), "unrelated bytes");
    assert.equal(fs.existsSync(path.join(f.destination, "codewhale")), false);
    f.untouched();
  });

  test(`${kind}: managed directories are refused without invoking sudo`, t => {
    const f = fixture(t, kind);
    f.env.PREFIX = path.join(f.home, ".cargo");
    f.env.CODEWHALE_INSTALL_DIR = path.join(f.env.PREFIX, "bin");
    const result = f.run();
    assert.notEqual(result.status, 0);
    assert.match(result.stderr, /managed\/system/);
    assert.equal(fs.existsSync(path.join(f.env.CODEWHALE_INSTALL_DIR, "codewhale")), false);
    f.untouched();
  });

  test(`${kind}: a destination created during publication is never overwritten`, t => {
    const f = fixture(t, kind);
    executable(path.join(f.bin, "ln"), `#!/bin/sh
destination="$2$(basename "$1")"
printf 'another writer' > "$destination"
exec /bin/ln "$@"
`);
    assert.notEqual(f.run().status, 0);
    assert.equal(fs.readFileSync(path.join(f.destination, "codewhale"), "utf8"), "another writer");
    assert.equal(fs.existsSync(path.join(f.destination, "codew")), false);
    assert.equal(fs.readdirSync(f.destination).some(name => name.startsWith(".codewhale-install.")), false);
    f.untouched();
  });

  test(`${kind}: a failed second publication removes the command this run published`, t => {
    const f = fixture(t, kind);
    // Another writer claims codew between preflight and its publication.
    executable(path.join(f.bin, "ln"), `#!/bin/sh
case "$(basename "$1")" in codew) printf 'another writer' > "$2codew" ;; esac
exec /bin/ln "$@"
`);
    const result = f.run();
    assert.notEqual(result.status, 0, result.stdout);
    assert.equal(fs.existsSync(path.join(f.destination, "codewhale")), false, "no half-installed pair is left behind");
    assert.equal(fs.readFileSync(path.join(f.destination, "codew"), "utf8"), "another writer");
    assert.match(result.stderr, /did not complete/);
    assert.equal(fs.readdirSync(f.destination).some(name => name.startsWith(".codewhale-install.")), false);
    f.untouched();
  });

  test(`${kind}: rollback never removes a command that was already installed`, t => {
    const f = fixture(t, kind);
    assert.equal(f.run().status, 0);
    fs.unlinkSync(path.join(f.destination, "codew"));
    const kept = fs.statSync(path.join(f.destination, "codewhale")).ino;
    executable(path.join(f.bin, "ln"), `#!/bin/sh
case "$(basename "$1")" in codew) printf 'another writer' > "$2codew" ;; esac
exec /bin/ln "$@"
`);
    assert.notEqual(f.run().status, 0);
    assert.equal(fs.statSync(path.join(f.destination, "codewhale")).ino, kept);
    f.untouched();
  });

  for (const collision of ["directory", "directory symlink"]) {
    test(`${kind}: a raced ${collision} cannot redirect publication`, t => {
      const f = fixture(t, kind);
      const foreign = path.join(f.root, "foreign-directory");
      fs.mkdirSync(foreign);
      f.env.INSTALL_TEST_FOREIGN = foreign;
      const create = collision === "directory"
        ? 'mkdir "$destination"'
        : '/bin/ln -s "$INSTALL_TEST_FOREIGN" "$destination"';
      executable(path.join(f.bin, "ln"), `#!/bin/sh
 destination="$2$(basename "$1")"
 ${create}
 exec /bin/ln "$@"
 `);
      const result = f.run();
      assert.notEqual(result.status, 0, result.stdout);
      assert.doesNotMatch(result.stdout, /Installed checksummed|Done\. Commands/);
      const target = path.join(f.destination, "codewhale");
      assert.equal(fs.lstatSync(target).isSymbolicLink(), collision === "directory symlink");
      assert.deepEqual(fs.readdirSync(target), []);
      assert.deepEqual(fs.readdirSync(foreign), []);
      assert.equal(fs.existsSync(path.join(f.destination, "codew")), false);
      assert.equal(fs.readdirSync(f.destination).some(name => name.startsWith(".codewhale-install.")), false);
      f.untouched();
    });
  }
}

const blockOf = dir => `# >>> codewhale PATH >>>\nexport PATH="${dir}:$PATH"\n# <<< codewhale PATH <<<\n`;
const shownDir = f => (fs.realpathSync(f.destination) === fs.realpathSync(path.join(f.home, ".local", "bin")) ? "$HOME/.local/bin" : fs.realpathSync(f.destination));
for (const kind of ["website", "archive"]) {
  for (const [shell, profile] of [["/bin/zsh", ".zshrc"], ["/bin/bash", ".bash_profile"], ["/bin/sh", ".profile"]]) {
    test(`${kind}: ${shell} gets the marked PATH block in ~/${profile} by default and the output says so`, t => {
      const f = fixture(t, kind);
      f.env.SHELL = shell;
      fs.writeFileSync(path.join(f.home, profile), "# mine\nalias a=b");
      const result = f.run();
      assert.equal(result.status, 0, result.stderr);
      assert.equal(fs.readFileSync(path.join(f.home, profile), "utf8"), `# mine\nalias a=b\n${blockOf(shownDir(f))}`);
      assert.ok(result.stdout.includes(`Added to ~/${profile}`), result.stdout);
      assert.ok(result.stdout.includes("--no-modify-path"), result.stdout);
      const lines = result.stdout.split("\n").map(line => line.trim()).filter(Boolean);
      assert.equal(lines.at(-1), "codewhale --version", result.stdout);
      assert.ok(lines.at(-3).startsWith("export PATH=") && lines.at(-3).endsWith("hash -r"), result.stdout);
      f.untouched();
    });
  }

  test(`${kind}: a fresh profile is created with only the block`, t => {
    const f = fixture(t, kind);
    f.env.SHELL = "/bin/zsh";
    assert.equal(f.run().status, 0);
    assert.equal(fs.readFileSync(path.join(f.home, ".zshrc"), "utf8"), blockOf(shownDir(f)));
  });

  test(`${kind}: the printed undo command removes exactly the block`, t => {
    const f = fixture(t, kind);
    f.env.SHELL = "/bin/zsh";
    const before = "# top\nexport A=1\n";
    const after = "export B=2\n";
    fs.writeFileSync(path.join(f.home, ".zshrc"), before + after);
    const result = f.run();
    assert.equal(result.status, 0, result.stderr);
    const undo = result.stdout.split("\n").map(line => line.trim()).find(line => line.startsWith("cw_tmp="));
    assert.ok(undo, result.stdout);
    const profile = path.join(f.home, ".zshrc");
    fs.writeFileSync(profile, before + blockOf(shownDir(f)) + after);
    const ran = spawnSync("sh", ["-c", undo], { env: { ...f.env }, encoding: "utf8" });
    assert.equal(ran.status, 0, ran.stderr);
    assert.equal(fs.readFileSync(profile, "utf8"), before + after);
  });

  for (const tail of ["a\n# >>> codewhale PATH >>>\nlast\n", "a\n# >>> codewhale PATH >>>\n", "a\n# >>> codewhale PATH >>>"]) {
    test(`${kind}: the printed undo command leaves a lone start marker near end of file untouched (${JSON.stringify(tail)})`, t => {
      const f = fixture(t, kind);
      f.env.SHELL = "/bin/zsh";
      const result = f.run();
      assert.equal(result.status, 0, result.stderr);
      const undo = result.stdout.split("\n").map(line => line.trim()).find(line => line.startsWith("cw_tmp="));
      const profile = path.join(f.home, ".zshrc");
      fs.writeFileSync(profile, tail);
      const ran = spawnSync("sh", ["-c", undo], { env: { ...f.env }, encoding: "utf8" });
      assert.equal(ran.status, 0, ran.stderr);
      assert.equal(fs.readFileSync(profile, "utf8"), tail);
    });
  }

  test(`${kind}: --no-modify-path and CODEWHALE_NO_MODIFY_PATH leave every profile alone and print the command`, t => {
    for (const mode of ["flag", "env"]) {
      const f = fixture(t, kind);
      f.env.SHELL = "/bin/zsh";
      if (mode === "env") f.env.CODEWHALE_NO_MODIFY_PATH = "1";
      const result = f.run(mode === "flag" ? ["--no-modify-path"] : []);
      assert.equal(result.status, 0, result.stderr);
      assert.equal(fs.existsSync(path.join(f.home, ".zshrc")), false);
      assert.ok(result.stdout.includes("Not editing your shell profile"), result.stdout);
      assert.ok(result.stdout.includes(">> ~/.zshrc"), result.stdout);
      assert.equal(result.stdout.trim().split("\n").at(-1).trim(), "codewhale --version");
    }
  });

  test(`${kind}: an unknown option fails before installing`, t => {
    const f = fixture(t, kind);
    const result = f.run(["--no-modify-pth"]);
    assert.equal(result.status, 2);
    assert.equal(fs.existsSync(path.join(f.destination, "codewhale")), false);
  });

  test(`${kind}: no edit when the install directory is already on PATH`, t => {
    const f = fixture(t, kind);
    f.env.SHELL = "/bin/zsh";
    const dir = fs.realpathSync(f.destination);
    f.env.PATH = `${dir}:${f.env.PATH}`;
    const result = f.run();
    assert.equal(result.status, 0, result.stderr);
    assert.equal(fs.existsSync(path.join(f.home, ".zshrc")), false);
    assert.ok(!result.stdout.includes("Added to"), result.stdout);
  });

  test(`${kind}: reinstalling never duplicates the block`, t => {
    const f = fixture(t, kind);
    f.env.SHELL = "/bin/zsh";
    assert.equal(f.run().status, 0);
    const first = fs.readFileSync(path.join(f.home, ".zshrc"), "utf8");
    const again = f.run();
    assert.equal(again.status, 0, again.stderr);
    assert.equal(fs.readFileSync(path.join(f.home, ".zshrc"), "utf8"), first);
    assert.ok(again.stdout.includes("already has the codewhale PATH block"), again.stdout);
  });

  test(`${kind}: a symlinked profile is refused, left alone, and the command is printed`, t => {
    const f = fixture(t, kind);
    f.env.SHELL = "/bin/zsh";
    const target = path.join(f.root, "dotfiles-zshrc");
    fs.writeFileSync(target, "# managed\n");
    fs.symlinkSync(target, path.join(f.home, ".zshrc"));
    const result = f.run();
    assert.equal(result.status, 0, result.stderr);
    assert.equal(fs.readFileSync(target, "utf8"), "# managed\n");
    assert.ok(result.stdout.includes("is a symlink"), result.stdout);
    assert.ok(result.stdout.includes(">> ~/.zshrc"), result.stdout);
    assert.equal(result.stdout.trim().split("\n").at(-1).trim(), "codewhale --version");
  });

  test(`${kind}: an unwritable profile is refused and left alone`, t => {
    if (process.getuid && process.getuid() === 0) return t.skip("root can write read-only files");
    const f = fixture(t, kind);
    f.env.SHELL = "/bin/zsh";
    const profile = path.join(f.home, ".zshrc");
    fs.writeFileSync(profile, "# ro\n", { mode: 0o444 });
    const result = f.run();
    assert.equal(result.status, 0, result.stderr);
    assert.equal(fs.readFileSync(profile, "utf8"), "# ro\n");
    assert.ok(result.stdout.includes("not a writable regular file"), result.stdout);
  });

  test(`${kind}: no profile is chosen or edited when the shell cannot be determined`, t => {
    for (const shell of ["", "/usr/bin/fish", "/bin/tcsh"]) {
      const f = fixture(t, kind);
      f.env.SHELL = shell;
      const result = f.run();
      assert.equal(result.status, 0, result.stderr);
      assert.deepEqual(fs.readdirSync(f.home).filter(name => name !== ".local"), [], `${shell}: ${result.stdout}`);
      assert.ok(!result.stdout.includes("Added to"), result.stdout);
    }
  });
}

const helpWithout = "Usage: codewhale [OPTIONS] [PROMPT]...\n\nCommands:\n  update   Update\n  doctor   Diagnose";
const helpWith = `${helpWithout}\n  uninstall   Remove this receipt-owned release install`;
for (const kind of ["website", "archive"]) {
  for (const [label, help, supported] of [["without", helpWithout, false], ["with", helpWith, true]]) {
    test(`${kind}: a binary ${label} an uninstall command ${supported ? "gets" : "never gets"} the uninstall and update-mode lines`, t => {
      const f = fixture(t, kind);
      f.env.INSTALL_TEST_HELP = help;
      f.env.SHELL = "/bin/bash";
      const result = f.run();
      assert.equal(result.status, 0, result.stderr);
      assert.equal(result.stdout.includes("uninstall --yes"), supported, result.stdout);
      assert.equal(result.stdout.includes("update.mode"), supported, result.stdout);
      assert.equal(/codewhale uninstall/.test(result.stdout), supported, result.stdout);
      assert.equal(result.stdout.includes("this release has no uninstall command"), !supported, result.stdout);
      if (!supported) {
        assert.ok(result.stdout.includes(`rm "${fs.realpathSync(f.destination)}/codewhale" "${fs.realpathSync(f.destination)}/codew" "${fs.realpathSync(f.destination)}/.codewhale-install.sha256"`), result.stdout);
      }
      f.untouched();
    });
  }
}

test("archive: install.bat forwards its arguments so -NoModifyPath reaches install.ps1", () => {
  const bat = fs.readFileSync(path.join(repo, "scripts/release/install.bat"), "utf8");
  const ps1 = fs.readFileSync(path.join(repo, "scripts/release/install.ps1"), "utf8");
  assert.match(ps1, /param\(\[switch\]\$NoModifyPath\)/);
  const call = bat.split(/\r?\n/).find(line => /powershell\.exe/i.test(line));
  assert.match(call, /-File "%~dp0install\.ps1" %\*\s*$/);
});

test("website: a checksum mismatch stops before any installation", t => {
  const f = fixture(t, "website");
  fs.writeFileSync(path.join(f.assets, "codewhale-macos-arm64"), "tampered");
  const result = f.run();
  assert.notEqual(result.status, 0);
  assert.match(result.stderr, /checksum mismatch/);
  assert.equal(fs.existsSync(path.join(f.destination, "codewhale")), false);
  f.untouched();
});

test("archive: a missing second binary stops before the first installation", t => {
  const f = fixture(t, "archive");
  fs.unlinkSync(path.join(f.archive, "codew"));
  const result = f.run();
  assert.notEqual(result.status, 0);
  assert.match(result.stderr, /not found in archive/);
  assert.equal(fs.existsSync(path.join(f.destination, "codewhale")), false);
  f.untouched();
});

test("website: Termux never downloads a Linux binary", t => {
  const f = fixture(t, "website");
  f.env.TERMUX_VERSION = "fixture";
  const result = f.run();
  assert.notEqual(result.status, 0);
  assert.match(result.stderr, /Android\/Termux needs the Android/);
  assert.equal(fs.existsSync(f.env.INSTALL_TEST_DOWNLOADS), false);
  assert.equal(fs.existsSync(path.join(f.destination, "codewhale")), false);
  f.untouched();
});

function addHostPayload(f) {
  const payloads = {
    'codewhale-extension-host': '#!/bin/sh\nexit 0\n',
    'codewhale-extension-host.LICENSES.txt': 'offline runtime notice fixture\n',
    'codewhale-extension-host.relink-source.tar.gz': 'offline relink fixture\n',
    'codewhale-extension-host.release.json': '{"fixture":"already qualified by release producer"}\n',
  };
  let manifest = fs.readFileSync(path.join(f.assets, 'codewhale-artifacts-sha256.txt'), 'utf8');
  for (const [name, content] of Object.entries(payloads)) {
    fs.writeFileSync(path.join(f.archive, name), content, { mode: name === 'codewhale-extension-host' ? 0o755 : 0o644 });
    const asset = name === 'codewhale-extension-host.release.json' ? 'codewhale-extension-hosts.json' : name.replace('codewhale-extension-host', 'codewhale-extension-host-macos-arm64').replace('.LICENSES.txt', '-LICENSES.txt').replace('.relink-source.tar.gz', '-relink-source.tar.gz');
    fs.writeFileSync(path.join(f.assets, asset), content);
    manifest += `${crypto.createHash('sha256').update(content).digest('hex')}  ${asset}\n`;
  }
  fs.writeFileSync(path.join(f.assets, 'codewhale-artifacts-sha256.txt'), manifest);
  return payloads;
}
for (const kind of ['website', 'archive']) {
  test(`${kind}: qualified companion presence stays inert until explicit installer choice`, t => {
    const f = fixture(t, kind), payloads = addHostPayload(f);
    f.env.CODEWHALE_INSTALL_COMPILED_HOST = '0';
    assert.equal(f.run().status, 0);
    assert.equal(fs.existsSync(path.join(f.destination, 'codewhale-extension-host')), false);
    f.env.CODEWHALE_INSTALL_COMPILED_HOST = '1';
    const result = f.run(); assert.equal(result.status, 0, result.stderr);
    for (const [name, content] of Object.entries(payloads)) {
      const file = path.join(f.destination, name);
      assert.equal(fs.readFileSync(file, 'utf8'), content);
      assert.equal(fs.statSync(file).mode & 0o777, name === 'codewhale-extension-host' ? 0o755 : 0o644);
    }
    f.untouched();
  });
  test(`${kind}: a conflicting companion prevents the first command publication`, t => {
    const f = fixture(t, kind); addHostPayload(f); f.prepare(); f.env.CODEWHALE_INSTALL_COMPILED_HOST = '1';
    const foreign = path.join(f.destination, 'codewhale-extension-host.LICENSES.txt'); fs.writeFileSync(foreign, 'foreign');
    const result = f.run(); assert.notEqual(result.status, 0); assert.ok(result.stderr.includes(foreign), result.stderr);
    assert.equal(fs.readFileSync(foreign, 'utf8'), 'foreign'); assert.equal(fs.existsSync(path.join(f.destination, 'codewhale')), false);
    f.untouched();
  });
  test(`${kind}: late companion collision rolls back every new command and image`, t => {
    const f = fixture(t, kind); addHostPayload(f); f.env.CODEWHALE_INSTALL_COMPILED_HOST = '1';
    executable(path.join(f.bin, 'ln'), `#!/bin/sh\ncase "$(basename "$1")" in codewhale-extension-host.LICENSES.txt) printf 'another writer' > "$2codewhale-extension-host.LICENSES.txt" ;; esac\nexec /bin/ln "$@"\n`);
    const result = f.run(); assert.notEqual(result.status, 0, result.stdout);
    for (const name of ['codewhale', 'codew', 'codewhale-extension-host', 'codewhale-extension-host.release.json']) assert.equal(fs.existsSync(path.join(f.destination, name)), false, name);
    assert.equal(fs.readFileSync(path.join(f.destination, 'codewhale-extension-host.LICENSES.txt'), 'utf8'), 'another writer');
    f.untouched();
  });
}