@botbuddy/cli 1.2.3 → 1.4.1

package/src/profile-bootstrap.test.mjs

@@ -0,0 +1,205 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { bootstrapProfile, defaultProfileAgentName, profileShellRefresh } from "./profile-bootstrap.mjs";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+const bootstrapForTest = (profile, options) => bootstrapProfile(profile, { ensureBackend: () => {}, ...options });
+
+test("BOT-1353: the published CLI identifies this profile-bootstrap release", async () => {
+  const { stdout } = await execFileAsync("node", ["bin/botbuddy.mjs", "--version"], {
+    cwd: new URL("..", import.meta.url),
+  });
+
+  assert.equal(stdout.trim(), "botbuddy v1.4.1");
+});
+
+test("BOT-1382: profile --help succeeds and documents the subcommands", async () => {
+  for (const flag of ["--help", "-h"]) {
+    const { stdout } = await execFileAsync("node", ["bin/botbuddy.mjs", "profile", flag], {
+      cwd: new URL("..", import.meta.url),
+    });
+    assert.match(stdout, /botbuddy profile <setup\|env>/);
+  }
+});
+
+test("BOT-1353: default profile agent names are globally collision-resistant", () => {
+  const first = defaultProfileAgentName("supplyguard-dev");
+  const second = defaultProfileAgentName("supplyguard-dev");
+
+  assert.match(first, /^supplyguard-dev-[a-z0-9-]+-[a-f0-9]{12}$/);
+  assert.notEqual(first, second);
+});
+
+test("BOT-1353: the published CLI tarball contains every profile-bootstrap dependency", async () => {
+  const { stdout } = await execFileAsync("npm", ["pack", "--dry-run", "--json"], {
+    cwd: new URL("..", import.meta.url),
+  });
+  const files = JSON.parse(stdout)[0].files.map(({ path }) => path);
+
+  assert(files.includes("src/profile-bootstrap.mjs"));
+  assert(files.includes("src/agent-credential-store.mjs"));
+  // BOT-1383: the loopback-login runtime files must ship in the tarball too.
+  assert(files.includes("src/auth.mjs"));
+  assert(files.includes("src/oauth-loopback.mjs"));
+});
+
+test("BOT-1353: profile bootstrap binds registration to Supply Guard and stores only the returned agent credential", async () => {
+  const calls = [];
+  const stored = [];
+
+  const result = await bootstrapForTest("supplyguard-dev", {
+    name: "supplyguard-dev-jonos-mbp",
+    call: async (tool, args) => {
+      calls.push({ tool, args });
+      return {
+        ok: true,
+        isError: true,
+        data: {
+          code: "FRESH_CONNECTION_REQUIRED",
+          agent_id: "agent-sg-1",
+          tenant_id: "supply-guard",
+          agent_api_key: "fixture-agent-credential",
+        },
+      };
+    },
+    store: async (entry) => stored.push(entry),
+  });
+
+  assert.deepEqual(calls, [{
+    tool: "register_agent",
+    args: {
+      name: "supplyguard-dev-jonos-mbp",
+      type: "codex",
+      tenant_id: "supply-guard",
+    },
+  }]);
+  assert.deepEqual(stored, [{
+    profile: "supplyguard-dev",
+    tenant: "supply-guard",
+    agentId: "agent-sg-1",
+    name: "supplyguard-dev-jonos-mbp",
+    token: "fixture-agent-credential",
+  }]);
+  assert.deepEqual(result, {
+    schema_version: 1,
+    outcome: "installed",
+    profile: "supplyguard-dev",
+    tenant_id: "supply-guard",
+    agent_id: "agent-sg-1",
+    credential_source: "keychain_profile_slot",
+    shell_refresh: "source <(npx --yes @botbuddy/cli@latest profile env supplyguard-dev)",
+    gui_refresh: "$HOME/.local/bin/botbuddy-mcp-env.sh",
+  });
+  assert(!JSON.stringify(result).includes("fixture-agent-credential"));
+});
+
+test("BOT-1353: profile setup gives the invoking shell a deterministic Keychain refresh", () => {
+  assert.equal(
+    profileShellRefresh("supplyguard-dev"),
+    "if botbuddy_profile_token=\"$(security find-generic-password -a \"$USER\" -s \"BOTBUDDY_SG_AGENT_KEY\" -w)\"; then export BOTBUDDY_SG_AGENT_KEY=\"$botbuddy_profile_token\"; unset botbuddy_profile_token; else unset botbuddy_profile_token; false; fi",
+  );
+  assert.throws(() => profileShellRefresh("unknown"), (error) => error?.code === "profile_required");
+});
+
+test("BOT-1353: bootstrap reconnect is tenant-attested and never installs a wrong-tenant credential", async () => {
+  let stored = false;
+
+  await assert.rejects(
+    bootstrapForTest("supplyguard-dev", {
+      call: async () => ({
+        ok: true,
+        data: {
+          agent_id: "agent-bb-1",
+          tenant_id: "botbuddy",
+          api_key: "fixture-wrong-tenant-credential",
+        },
+      }),
+      store: async () => { stored = true; },
+    }),
+    (err) => err?.code === "profile_credential_wrong_tenant",
+  );
+  assert.equal(stored, false);
+});
+
+test("BOT-1353: profile setup reconnects the stored identity without changing its tenant", async () => {
+  let registration;
+  await bootstrapForTest("supplyguard-dev", {
+    readIdentity: async () => ({ agentId: "agent-sg-1", tenant: "supply-guard", name: "supplyguard-dev-existing", token: "fixture-old-credential" }),
+    call: async (_tool, args) => {
+      registration = args;
+      return { ok: true, data: { agent_id: "agent-sg-1", tenant_id: "supply-guard", api_key: "fixture-reconnected-credential" } };
+    },
+    store: async () => {},
+  });
+  assert.equal(registration.agent_id, "agent-sg-1");
+  assert.equal(registration.name, "supplyguard-dev-existing");
+  assert.equal(registration.tenant_id, "supply-guard");
+});
+
+test("BOT-1353: bootstrap refuses an un-attested registration response without storing its credential", async () => {
+  let stored = false;
+  let retryIdentity;
+
+  await assert.rejects(
+    bootstrapForTest("supplyguard-dev", {
+      call: async () => ({
+        ok: true,
+        data: { agent_id: "agent-sg-1", agent_api_key: "fixture-unattested-credential" },
+      }),
+      store: async () => { stored = true; },
+      recordRetryIdentity: async (entry) => { retryIdentity = entry; },
+    }),
+    (err) => err?.code === "profile_tenant_attestation_missing",
+  );
+  assert.equal(stored, false);
+  assert.deepEqual(retryIdentity, { profile: "supplyguard-dev", agentId: "agent-sg-1", name: retryIdentity.name });
+  assert.match(retryIdentity.name, /^supplyguard-dev-/);
+});
+
+test("BOT-1353: an unattested registration retries the same untrusted agent identity", async () => {
+  let retryIdentity;
+  await assert.rejects(bootstrapForTest("supplyguard-dev", {
+    call: async () => ({ ok: true, data: { agent_id: "agent-sg-pending", api_key: "fixture" } }),
+    recordRetryIdentity: async (entry) => { retryIdentity = entry; },
+  }), (error) => error?.code === "profile_tenant_attestation_missing");
+  let retryArgs;
+  await bootstrapForTest("supplyguard-dev", {
+    readRetryIdentity: async () => ({ agentId: retryIdentity.agentId, name: retryIdentity.name }),
+    call: async (_tool, args) => {
+      retryArgs = args;
+      return { ok: true, data: { agent_id: "agent-sg-pending", tenant_id: "supply-guard", api_key: "fixture" } };
+    },
+    store: async () => {},
+  });
+  assert.equal(retryArgs.agent_id, "agent-sg-pending");
+  assert.equal(retryArgs.name, retryIdentity.name);
+});
+
+test("BOT-1353: an unavailable Keychain backend fails before agent registration", async () => {
+  let called = false;
+  await assert.rejects(
+    bootstrapProfile("supplyguard-dev", {
+      ensureBackend: () => { throw new Error("unavailable"); },
+      call: async () => { called = true; return { ok: true }; },
+    }),
+    (error) => error?.code === "profile_agent_required",
+  );
+  assert.equal(called, false);
+});
+
+test("BOT-1353: wrong-tenant metadata is replaced by a fresh tenant-bound registration", async () => {
+  let registration;
+  await bootstrapForTest("supplyguard-dev", {
+    readIdentity: async () => ({ agentId: "agent-bb-1", tenant: "botbuddy" }),
+    call: async (_tool, args) => {
+      registration = args;
+      return { ok: true, data: { agent_id: "agent-sg-2", tenant_id: "supply-guard", api_key: "fixture-replacement-credential" } };
+    },
+    store: async () => {},
+  });
+  assert.equal(registration.agent_id, undefined);
+  assert.equal(registration.tenant_id, "supply-guard");
+});

package/src/publish-equal.mjs

@@ -0,0 +1,207 @@
+#!/usr/bin/env node
+// BOT-1382: decide whether a locally-packed CLI package is equivalent to the
+// already-published npm tarball of the same (immutable) version.
+//
+// Used by .github/workflows/publish-cli-package.yml when the version already
+// exists on npm: an equivalent package is a safe idempotent skip; any drift
+// means cli/ changed without a version bump and must fail loudly so the change
+// cannot merge green while staying unpublished.
+//
+// The comparison excludes ONLY npm-injected manifest fields (notably gitHead,
+// which npm stamps into the tarball's package.json from the publishing commit).
+// Every other manifest field (bin, files, engines, …) and every shipped file
+// is compared, so a genuine metadata change still counts as drift.
+
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { join, relative } from "node:path";
+
+// npm does NOT inject any field into the packed tarball's package.json —
+// verified against the published @botbuddy/cli tarball, which carries neither
+// `gitHead` nor `_`-prefixed keys (those live in the registry packument, not
+// the tarball). So no field is ignored: every package.json field, gitHead
+// included, is compared. Key ORDER is still canonicalised so incidental
+// ordering never reads as drift.
+const NPM_INJECTED_KEYS = [];
+
+// Deep, key-sorted canonical form so incidental key ordering never reads as a
+// difference.
+function canon(v) {
+  if (Array.isArray(v)) return v.map(canon);
+  if (v && typeof v === "object") {
+    return Object.keys(v)
+      .sort()
+      .reduce((o, k) => {
+        o[k] = canon(v[k]);
+        return o;
+      }, {});
+  }
+  return v;
+}
+
+// Parse a STABLE semver ("x.y.z") into numeric [major, minor, patch]. Throws
+// on anything with a prerelease/build suffix — this gate is stable-only.
+export function parseStable(v) {
+  const m = /^(\d+)\.(\d+)\.(\d+)$/.exec(String(v).trim());
+  if (!m) throw new Error(`not a stable semver: ${v}`);
+  return [Number(m[1]), Number(m[2]), Number(m[3])];
+}
+
+// True when stable `next` is strictly greater than stable `current`, compared
+// numerically per component (so 1.10.0 > 1.9.0). Equal is NOT higher. Used to
+// refuse a stable publish that would move the `latest` dist-tag backward.
+export function isHigherStable(next, current) {
+  const a = parseStable(next);
+  const b = parseStable(current);
+  for (let i = 0; i < 3; i++) {
+    if (a[i] !== b[i]) return a[i] > b[i];
+  }
+  return false;
+}
+
+// Parse any semver, including a prerelease suffix ("2.0.0-rc.1"). Build
+// metadata (after "+") is ignored for precedence, per semver §10.
+export function parseSemver(v) {
+  const m = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(String(v).trim());
+  if (!m) throw new Error(`not a semver: ${v}`);
+  return { main: [Number(m[1]), Number(m[2]), Number(m[3])], pre: m[4] ? m[4].split(".") : [] };
+}
+
+// Compare two prerelease identifier lists per semver §11.
+function comparePre(a, b) {
+  // A version with no prerelease outranks one that has a prerelease.
+  if (a.length === 0 && b.length === 0) return 0;
+  if (a.length === 0) return 1;
+  if (b.length === 0) return -1;
+  const n = Math.min(a.length, b.length);
+  for (let i = 0; i < n; i++) {
+    const ai = a[i], bi = b[i];
+    const an = /^\d+$/.test(ai), bn = /^\d+$/.test(bi);
+    if (an && bn) {
+      const d = Number(ai) - Number(bi);
+      if (d !== 0) return d < 0 ? -1 : 1;
+    } else if (an !== bn) {
+      return an ? -1 : 1; // numeric identifiers have lower precedence than alphanumeric
+    } else if (ai !== bi) {
+      return ai < bi ? -1 : 1;
+    }
+  }
+  if (a.length !== b.length) return a.length < b.length ? -1 : 1; // more fields => higher
+  return 0;
+}
+
+// Full semver comparison: -1 | 0 | 1 for a<b | a==b | a>b.
+export function compareSemver(a, b) {
+  const pa = parseSemver(a), pb = parseSemver(b);
+  for (let i = 0; i < 3; i++) {
+    if (pa.main[i] !== pb.main[i]) return pa.main[i] < pb.main[i] ? -1 : 1;
+  }
+  return comparePre(pa.pre, pb.pre);
+}
+
+// True when `next` is strictly greater than `current` under full semver
+// precedence (prereleases included). Used to refuse a publish that would move
+// EITHER the `latest` (stable) or `next` (prerelease) dist-tag backward.
+export function isHigher(next, current) {
+  return compareSemver(next, current) > 0;
+}
+
+// True iff the version carries a semver prerelease component (the part after
+// `-`, before any `+build` metadata). A raw hyphen check is wrong: build
+// metadata like `1.4.0+build-1` is a STABLE release, not a prerelease.
+export function isPrerelease(v) {
+  return parseSemver(v).pre.length > 0;
+}
+
+export function normalizeManifest(json) {
+  const m = JSON.parse(json);
+  for (const k of NPM_INJECTED_KEYS) delete m[k];
+  return JSON.stringify(canon(m));
+}
+
+function walkRelative(root) {
+  const out = [];
+  const rec = (dir) => {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const p = join(dir, entry.name);
+      if (entry.isDirectory()) rec(p);
+      // Always relative to the original root, so nested paths keep their prefix.
+      else out.push(relative(root, p));
+    }
+  };
+  rec(root);
+  return out.sort();
+}
+
+// Compare two extracted `package/` directories. Returns { equal, reason }.
+export function packagesEquivalent(localDir, pubDir) {
+  const localFiles = walkRelative(localDir);
+  const pubFiles = walkRelative(pubDir);
+  if (localFiles.join("\n") !== pubFiles.join("\n")) {
+    return {
+      equal: false,
+      reason: `shipped file set differs\n  local: ${localFiles.join(", ")}\n  published: ${pubFiles.join(", ")}`,
+    };
+  }
+  for (const rel of localFiles) {
+    const a = readFileSync(join(localDir, rel));
+    const b = readFileSync(join(pubDir, rel));
+    if (rel === "package.json") {
+      if (normalizeManifest(a.toString("utf8")) !== normalizeManifest(b.toString("utf8"))) {
+        return { equal: false, reason: "package.json differs beyond npm-injected fields (e.g. bin/files/engines)" };
+      }
+    } else if (!a.equals(b)) {
+      return { equal: false, reason: `shipped file content differs: ${rel}` };
+    }
+    // npm pack preserves the executable bit, so a mode-only change (e.g. a bin
+    // file going 0644 -> 0755) is a real release even when the bytes match.
+    // Both dirs are extracted under the same umask, so the umask cancels out.
+    const ma = statSync(join(localDir, rel)).mode & 0o777;
+    const mb = statSync(join(pubDir, rel)).mode & 0o777;
+    if (ma !== mb) {
+      return { equal: false, reason: `file mode differs: ${rel} (${ma.toString(8)} vs ${mb.toString(8)})` };
+    }
+  }
+  return { equal: true };
+}
+
+// CLI: `node cli-publish-equal.mjs <localPackageDir> <publishedPackageDir>`.
+// Exit 0 = equivalent (safe skip); exit 3 = drift (must fail the publish job).
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const args = process.argv.slice(2);
+  // `--gt <next> <current>`: exit 0 iff stable `next` > stable `current`.
+  // Used by the publish workflow to refuse moving `latest` backward.
+  if (args[0] === "--gt") {
+    const [, next, current] = args;
+    let higher;
+    try {
+      higher = isHigher(next, current);
+    } catch (err) {
+      console.error(String(err.message ?? err));
+      process.exit(2);
+    }
+    process.exit(higher ? 0 : 1);
+  }
+  // `--is-prerelease <version>`: prints "true"/"false" (structural, not a raw
+  // hyphen check). Used by the workflow to classify the local version.
+  if (args[0] === "--is-prerelease") {
+    try {
+      console.log(isPrerelease(args[1]) ? "true" : "false");
+      process.exit(0);
+    } catch (err) {
+      console.error(String(err.message ?? err));
+      process.exit(2);
+    }
+  }
+  const [localDir, pubDir] = args;
+  if (!localDir || !pubDir) {
+    console.error("usage: publish-equal.mjs <localPackageDir> <publishedPackageDir> | --gt <next> <current>");
+    process.exit(2);
+  }
+  const result = packagesEquivalent(localDir, pubDir);
+  if (result.equal) {
+    console.log("identical");
+    process.exit(0);
+  }
+  console.error("drift: " + result.reason);
+  process.exit(3);
+}

package/src/publish-equal.test.mjs

@@ -0,0 +1,176 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, chmodSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { normalizeManifest, packagesEquivalent, isHigherStable, isHigher, isPrerelease } from "./publish-equal.mjs";
+
+// BOT-1382: the publish workflow skips an already-published version ONLY when
+// the local package is equivalent to the published tarball. These tests
+// exercise that decision behaviourally (Codex review round 2, line 108): a
+// changed manifest field must count as drift, while npm-injected fields
+// (gitHead) must not.
+
+const BASE_MANIFEST = {
+  name: "@botbuddy/cli",
+  version: "1.4.0",
+  bin: { botbuddy: "./bin/botbuddy.mjs" },
+  files: ["bin/", "src/"],
+  engines: { node: ">=18.0.0" },
+};
+
+function makePkg(manifest, files) {
+  const root = mkdtempSync(join(tmpdir(), "cli-eq-"));
+  const pkg = join(root, "package");
+  mkdirSync(join(pkg, "bin"), { recursive: true });
+  mkdirSync(join(pkg, "src"), { recursive: true });
+  writeFileSync(join(pkg, "package.json"), JSON.stringify(manifest, null, 2));
+  for (const [rel, content] of Object.entries(files)) {
+    writeFileSync(join(pkg, rel), content);
+  }
+  return { root, pkg };
+}
+
+const DEFAULT_FILES = { "bin/botbuddy.mjs": "#!/usr/bin/env node\n", "src/version.mjs": "export const V=1;\n" };
+
+test("isHigherStable: a stable release must strictly exceed the current latest (no backward move)", () => {
+  assert.equal(isHigherStable("1.4.0", "1.2.3"), true);
+  assert.equal(isHigherStable("1.4.1", "1.4.0"), true);
+  assert.equal(isHigherStable("2.0.0", "1.9.9"), true);
+  assert.equal(isHigherStable("1.10.0", "1.9.0"), true); // numeric, not lexical
+  assert.equal(isHigherStable("1.4.0", "1.4.0"), false); // equal is not higher
+  assert.equal(isHigherStable("1.3.5", "1.4.0"), false); // downgrade => backward
+  assert.equal(isHigherStable("1.2.0", "1.10.0"), false); // numeric, not lexical
+});
+
+test("isHigher: full semver precedence incl. prereleases (guards the next tag too)", () => {
+  // Stable still behaves like isHigherStable.
+  assert.equal(isHigher("1.4.0", "1.2.3"), true);
+  assert.equal(isHigher("1.10.0", "1.9.0"), true);
+  assert.equal(isHigher("1.4.0", "1.4.0"), false);
+  // Prerelease precedence (semver §11).
+  assert.equal(isHigher("2.0.0-rc.2", "2.0.0-rc.1"), true);
+  assert.equal(isHigher("2.0.0-rc.10", "2.0.0-rc.2"), true); // numeric identifiers compare numerically
+  assert.equal(isHigher("2.0.0-rc.1", "1.9.0-rc.1"), true); // higher core wins
+  assert.equal(isHigher("1.9.0-rc.1", "2.0.0-rc.1"), false); // lower core => backward
+  assert.equal(isHigher("2.0.0-rc.1", "2.0.0-rc.1"), false); // equal is not higher
+  assert.equal(isHigher("2.0.0", "2.0.0-rc.1"), true); // a release outranks its prerelease
+  assert.equal(isHigher("2.0.0-rc.1", "2.0.0"), false);
+});
+
+test("isPrerelease: reads the semver prerelease component, not a raw hyphen (build metadata is stable)", () => {
+  assert.equal(isPrerelease("2.0.0-rc.1"), true);
+  assert.equal(isPrerelease("1.4.0"), false);
+  assert.equal(isPrerelease("1.4.0+build-1"), false); // hyphen in build metadata is NOT a prerelease
+  assert.equal(isPrerelease("2.0.0-rc.1+build-1"), true);
+  assert.equal(isPrerelease("1.4.0+2026-08-27"), false);
+});
+
+test("normalizeManifest only canonicalises key order — it ignores NO manifest fields", () => {
+  // npm does not inject gitHead or _-prefixed fields into the packed tarball
+  // (verified against the published @botbuddy/cli tarball), so every field —
+  // gitHead and _-prefixed included — is compared; a change is drift.
+  for (const change of [
+    { gitHead: "aaaa" },
+    { _id: "@botbuddy/cli@1.4.0" },
+    { _npmUser: "alice" },
+  ]) {
+    const a = JSON.stringify({ ...BASE_MANIFEST });
+    const b = JSON.stringify({ ...BASE_MANIFEST, ...change });
+    assert.notEqual(normalizeManifest(a), normalizeManifest(b));
+  }
+});
+
+test("normalizeManifest treats key-order-only differences as identical", () => {
+  const a = JSON.stringify({ name: "x", version: "1.0.0", bin: { a: "1", b: "2" } });
+  const b = JSON.stringify({ bin: { b: "2", a: "1" }, version: "1.0.0", name: "x" });
+  assert.equal(normalizeManifest(a), normalizeManifest(b));
+});
+
+test("a byte-identical package => equivalent (idempotent skip)", () => {
+  const local = makePkg({ ...BASE_MANIFEST }, DEFAULT_FILES);
+  const pub = makePkg({ ...BASE_MANIFEST }, DEFAULT_FILES);
+  try {
+    assert.equal(packagesEquivalent(local.pkg, pub.pkg).equal, true);
+  } finally {
+    rmSync(local.root, { recursive: true, force: true });
+    rmSync(pub.root, { recursive: true, force: true });
+  }
+});
+
+test("a package differing only in gitHead => drift (npm does not inject it into the tarball)", () => {
+  const local = makePkg({ ...BASE_MANIFEST, gitHead: "local" }, DEFAULT_FILES);
+  const pub = makePkg({ ...BASE_MANIFEST, gitHead: "published" }, DEFAULT_FILES);
+  try {
+    assert.equal(packagesEquivalent(local.pkg, pub.pkg).equal, false);
+  } finally {
+    rmSync(local.root, { recursive: true, force: true });
+    rmSync(pub.root, { recursive: true, force: true });
+  }
+});
+
+test("an authored README manifest field change counts as drift (only npm-injected fields are ignored)", () => {
+  const pubManifest = { ...BASE_MANIFEST, readme: "# One", readmeFilename: "README.md" };
+  const localManifest = { ...BASE_MANIFEST, readme: "# Two — changed", readmeFilename: "README.md" };
+  const local = makePkg(localManifest, DEFAULT_FILES);
+  const pub = makePkg(pubManifest, DEFAULT_FILES);
+  try {
+    assert.equal(packagesEquivalent(local.pkg, pub.pkg).equal, false);
+  } finally {
+    rmSync(local.root, { recursive: true, force: true });
+    rmSync(pub.root, { recursive: true, force: true });
+  }
+});
+
+test("a changed manifest field (bin/files/engines) counts as drift", () => {
+  for (const change of [
+    { bin: { botbuddy: "./bin/other.mjs" } },
+    { files: ["bin/", "src/", "README.md"] },
+    { engines: { node: ">=20.0.0" } },
+  ]) {
+    const local = makePkg({ ...BASE_MANIFEST, ...change }, DEFAULT_FILES);
+    const pub = makePkg({ ...BASE_MANIFEST }, DEFAULT_FILES);
+    try {
+      assert.equal(packagesEquivalent(local.pkg, pub.pkg).equal, false);
+    } finally {
+      rmSync(local.root, { recursive: true, force: true });
+      rmSync(pub.root, { recursive: true, force: true });
+    }
+  }
+});
+
+test("changed shipped source content counts as drift", () => {
+  const local = makePkg({ ...BASE_MANIFEST }, { ...DEFAULT_FILES, "src/version.mjs": "export const V=2;\n" });
+  const pub = makePkg({ ...BASE_MANIFEST }, DEFAULT_FILES);
+  try {
+    assert.equal(packagesEquivalent(local.pkg, pub.pkg).equal, false);
+  } finally {
+    rmSync(local.root, { recursive: true, force: true });
+    rmSync(pub.root, { recursive: true, force: true });
+  }
+});
+
+test("a changed executable bit counts as drift (npm pack preserves file mode)", () => {
+  const local = makePkg({ ...BASE_MANIFEST }, DEFAULT_FILES);
+  const pub = makePkg({ ...BASE_MANIFEST }, DEFAULT_FILES);
+  try {
+    chmodSync(join(local.pkg, "bin/botbuddy.mjs"), 0o755);
+    chmodSync(join(pub.pkg, "bin/botbuddy.mjs"), 0o644);
+    assert.equal(packagesEquivalent(local.pkg, pub.pkg).equal, false);
+  } finally {
+    rmSync(local.root, { recursive: true, force: true });
+    rmSync(pub.root, { recursive: true, force: true });
+  }
+});
+
+test("an added/removed shipped file counts as drift", () => {
+  const local = makePkg({ ...BASE_MANIFEST }, { ...DEFAULT_FILES, "src/extra.mjs": "export const X=1;\n" });
+  const pub = makePkg({ ...BASE_MANIFEST }, DEFAULT_FILES);
+  try {
+    assert.equal(packagesEquivalent(local.pkg, pub.pkg).equal, false);
+  } finally {
+    rmSync(local.root, { recursive: true, force: true });
+    rmSync(pub.root, { recursive: true, force: true });
+  }
+});