movehat 0.1.9 → 0.2.1

package/src/commands/__tests__/run.test.ts

@@ -0,0 +1,192 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { propagateRunResultExit } from "../run.js";
+import type { RunResult } from "../../utils/childProcessAdapter.js";
+
+// Mock runCli for orchestrator tests so we never spawn a real node/tsx.
+// Use vi.hoisted to make the mock fn visible to the hoisted vi.mock factory.
+const { runCliMock } = vi.hoisted(() => ({ runCliMock: vi.fn() }));
+vi.mock("../../utils/runCli.js", () => ({
+  runCli: runCliMock,
+}));
+
+// Static import after mock declaration — vi hoists vi.mock.
+const { default: runCommand } = await import("../run.js");
+
+/**
+ * Direct coverage for the signal-forwarding branch added to fix the
+ * CodeRabbit finding on PR #100 — `process.kill(process.pid, signal)`
+ * cannot run inside vitest without killing the runner, so the helper is
+ * exported and `process.kill` / `process.exit` are spied.
+ */
+describe("propagateRunResultExit", () => {
+  let killSpy: ReturnType<typeof vi.spyOn>;
+  let exitSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    killSpy = vi.spyOn(process, "kill").mockImplementation(() => true);
+    exitSpy = vi
+      .spyOn(process, "exit")
+      .mockImplementation(((_code?: number) => undefined) as never);
+  });
+
+  afterEach(() => {
+    killSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
+
+  it("re-raises the signal on the parent when result.signal is set", () => {
+    const result: RunResult = {
+      exitCode: -1,
+      stdout: "",
+      stderr: "",
+      signal: "SIGINT",
+    };
+
+    propagateRunResultExit(result);
+
+    expect(killSpy).toHaveBeenCalledTimes(1);
+    expect(killSpy).toHaveBeenCalledWith(process.pid, "SIGINT");
+    expect(exitSpy).not.toHaveBeenCalled();
+  });
+
+  it("forwards a non-negative numeric exit code via process.exit", () => {
+    const result: RunResult = { exitCode: 42, stdout: "", stderr: "" };
+
+    propagateRunResultExit(result);
+
+    expect(exitSpy).toHaveBeenCalledTimes(1);
+    expect(exitSpy).toHaveBeenCalledWith(42);
+    expect(killSpy).not.toHaveBeenCalled();
+  });
+
+  it("clamps a negative exit code with no signal to exit 1 (avoids -1 → 255 mask)", () => {
+    const result: RunResult = { exitCode: -1, stdout: "", stderr: "" };
+
+    propagateRunResultExit(result);
+
+    expect(exitSpy).toHaveBeenCalledWith(1);
+    expect(killSpy).not.toHaveBeenCalled();
+  });
+
+  it("treats exitCode 0 as a normal success exit (not a signal)", () => {
+    const result: RunResult = { exitCode: 0, stdout: "", stderr: "" };
+
+    propagateRunResultExit(result);
+
+    expect(exitSpy).toHaveBeenCalledWith(0);
+    expect(killSpy).not.toHaveBeenCalled();
+  });
+});
+
+describe("runCommand — orchestrator", () => {
+  let tmpCwd: string;
+  let origCwd: string;
+  let exitSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    runCliMock.mockReset();
+    origCwd = process.cwd();
+    tmpCwd = mkdtempSync(join(tmpdir(), "movehat-runcmd-"));
+    process.chdir(tmpCwd);
+    // Throw on exit so the orchestrator's process.exit branches actually
+    // halt the flow (otherwise execution continues past process.exit and
+    // crashes on the next stmt with confusing errors).
+    exitSpy = vi
+      .spyOn(process, "exit")
+      .mockImplementation(((code?: number) => {
+        throw new Error(`__test_exit_${code ?? 0}__`);
+      }) as never);
+    // Suppress the signal-forwarding branch from killing the test runner.
+    vi.spyOn(process, "kill").mockImplementation(() => true);
+    vi.spyOn(console, "log").mockImplementation(() => undefined);
+    vi.spyOn(console, "error").mockImplementation(() => undefined);
+  });
+
+  afterEach(() => {
+    process.chdir(origCwd);
+    if (existsSync(tmpCwd)) rmSync(tmpCwd, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  it("exits 1 when scriptPath is empty", async () => {
+    await expect(runCommand("")).rejects.toThrow("__test_exit_1__");
+    expect(runCliMock).not.toHaveBeenCalled();
+  });
+
+  it("exits 1 when the script file does not exist", async () => {
+    await expect(runCommand("nonexistent.ts")).rejects.toThrow("__test_exit_1__");
+    expect(runCliMock).not.toHaveBeenCalled();
+  });
+
+  it("exits 1 on an unsupported file extension", async () => {
+    const path = join(tmpCwd, "script.txt");
+    writeFileSync(path, "console.log('hi');");
+    await expect(runCommand("script.txt")).rejects.toThrow("__test_exit_1__");
+    expect(runCliMock).not.toHaveBeenCalled();
+  });
+
+  it("invokes runCli when both script and tsx are resolvable (orchestrator happy path)", async () => {
+    // Inside vitest, the __dirname fallback in run.ts resolves tsx via
+    // the workspace's own node_modules. We don't need to plant a fake
+    // tsx — the orchestrator finds it and reaches the runCli call.
+    const scriptPath = join(tmpCwd, "deploy.ts");
+    writeFileSync(scriptPath, "// noop");
+    runCliMock.mockResolvedValueOnce({ exitCode: 0, stdout: "", stderr: "" });
+
+    // propagateRunResultExit's thrown __test_exit_0__ gets caught by the
+    // outer try/catch in runCommand, which then logs and calls
+    // process.exit(1) → throws __test_exit_1__. The interesting bit is
+    // that runCli got called with the right args.
+    await expect(runCommand("deploy.ts")).rejects.toThrow();
+
+    expect(runCliMock).toHaveBeenCalledTimes(1);
+    const callArgs = runCliMock.mock.calls[0]![0];
+    expect(callArgs.command).toBe("node");
+    // macOS resolves /var → /private/var, so compare by basename.
+    expect(callArgs.args[1]).toMatch(/deploy\.ts$/);
+    expect(callArgs.inheritStdio).toBe(true);
+  });
+
+  it("accepts .js and .mjs script extensions", async () => {
+    runCliMock.mockResolvedValueOnce({ exitCode: 0, stdout: "", stderr: "" });
+    const path = join(tmpCwd, "script.mjs");
+    writeFileSync(path, "");
+    await expect(runCommand("script.mjs")).rejects.toThrow();
+    expect(runCliMock).toHaveBeenCalledTimes(1);
+  });
+
+  it("logs the active network when MH_CLI_NETWORK is set", async () => {
+    const origNetwork = process.env.MH_CLI_NETWORK;
+    process.env.MH_CLI_NETWORK = "testnet";
+    try {
+      const path = join(tmpCwd, "script.ts");
+      writeFileSync(path, "");
+      runCliMock.mockResolvedValueOnce({ exitCode: 0, stdout: "", stderr: "" });
+      await expect(runCommand("script.ts")).rejects.toThrow();
+      expect(runCliMock).toHaveBeenCalled();
+    } finally {
+      if (origNetwork === undefined) delete process.env.MH_CLI_NETWORK;
+      else process.env.MH_CLI_NETWORK = origNetwork;
+    }
+  });
+
+  // Note: the "tsx binary not found" exit branch (lines 80-101 in run.ts)
+  // requires `require.resolve` to throw for BOTH the cwd-paths lookup and
+  // the __dirname-paths fallback. In vitest, tsx is always resolvable via
+  // the workspace's own node_modules from __dirname's perspective, so the
+  // fallback never throws. Patching `module.createRequire` to inject a
+  // failing resolver fails with "Cannot redefine property" because the
+  // ESM-imported `node:module` is read-only. The branch is exercised
+  // by the integration suite via the "tsx not found" runtime failure
+  // when tsx is missing from a published consumer.
+
+  it("catches and exits 1 when runCli throws (spawn-time failure)", async () => {
+    runCliMock.mockRejectedValueOnce(new Error("ENOENT: node not found"));
+    const path = join(tmpCwd, "script.ts");
+    writeFileSync(path, "");
+    await expect(runCommand("script.ts")).rejects.toThrow("__test_exit_1__");
+  });
+});

package/src/commands/__tests__/test-move.test.ts

@@ -0,0 +1,81 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+// Mock the helper before importing the command — vi.mock is hoisted.
+const runMoveTestsMock = vi.fn();
+vi.mock("../../helpers/move-tests.js", () => ({
+  runMoveTests: runMoveTestsMock,
+}));
+
+const { default: testMoveCommand } = await import("../test-move.js");
+
+describe("testMoveCommand", () => {
+  let exitSpy: ReturnType<typeof vi.spyOn>;
+  let logSpy: ReturnType<typeof vi.spyOn>;
+  let errSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    runMoveTestsMock.mockReset();
+    // Intercept process.exit so the test process keeps running.
+    exitSpy = vi
+      .spyOn(process, "exit")
+      .mockImplementation(((_code?: number) => undefined) as never);
+    logSpy = vi.spyOn(console, "log").mockImplementation(() => undefined);
+    errSpy = vi.spyOn(console, "error").mockImplementation(() => undefined);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("exits 0 on a successful move-tests run and forwards options", async () => {
+    runMoveTestsMock.mockResolvedValueOnce(undefined);
+
+    await testMoveCommand({ filter: "counter", ignoreWarnings: true });
+
+    expect(runMoveTestsMock).toHaveBeenCalledTimes(1);
+    expect(runMoveTestsMock).toHaveBeenCalledWith({
+      filter: "counter",
+      ignoreWarnings: true,
+      skipIfMissing: false,
+    });
+    expect(exitSpy).toHaveBeenCalledWith(0);
+  });
+
+  it("defaults options to undefined when none are provided", async () => {
+    runMoveTestsMock.mockResolvedValueOnce(undefined);
+
+    await testMoveCommand();
+
+    const callArg = runMoveTestsMock.mock.calls[0]![0];
+    expect(callArg).toEqual({
+      filter: undefined,
+      ignoreWarnings: undefined,
+      skipIfMissing: false,
+    });
+  });
+
+  it("exits 1 and logs the error message when the helper throws", async () => {
+    runMoveTestsMock.mockRejectedValueOnce(new Error("move compile failed"));
+
+    await testMoveCommand({});
+
+    expect(exitSpy).toHaveBeenCalledWith(1);
+    expect(errSpy).toHaveBeenCalledWith(
+      expect.stringContaining("Move tests failed")
+    );
+    expect(errSpy).toHaveBeenCalledWith(
+      expect.stringContaining("move compile failed")
+    );
+  });
+
+  it("handles non-Error throws (string) without crashing", async () => {
+    runMoveTestsMock.mockRejectedValueOnce("just a string");
+
+    await testMoveCommand({});
+
+    expect(exitSpy).toHaveBeenCalledWith(1);
+    expect(errSpy).toHaveBeenCalledWith(
+      expect.stringContaining("just a string")
+    );
+  });
+});

package/src/commands/__tests__/test.test.ts

@@ -0,0 +1,204 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { existsSync, mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const runMoveTestsMock = vi.fn();
+const runCliMock = vi.fn();
+const promptsMock = vi.fn();
+
+vi.mock("../../helpers/move-tests.js", () => ({
+  runMoveTests: runMoveTestsMock,
+}));
+
+vi.mock("../../utils/runCli.js", () => ({
+  runCli: runCliMock,
+}));
+
+vi.mock("prompts", () => ({
+  default: promptsMock,
+}));
+
+const { default: testCommand } = await import("../test.js");
+
+describe("testCommand — flag dispatch", () => {
+  let tmpCwd: string;
+  let origCwd: string;
+  let exitSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    runMoveTestsMock.mockReset();
+    runCliMock.mockReset();
+    promptsMock.mockReset();
+    origCwd = process.cwd();
+    tmpCwd = mkdtempSync(join(tmpdir(), "movehat-testcmd-"));
+    process.chdir(tmpCwd);
+    exitSpy = vi
+      .spyOn(process, "exit")
+      .mockImplementation(((_code?: number) => undefined) as never);
+    vi.spyOn(console, "log").mockImplementation(() => undefined);
+    vi.spyOn(console, "error").mockImplementation(() => undefined);
+  });
+
+  afterEach(() => {
+    process.chdir(origCwd);
+    if (existsSync(tmpCwd)) rmSync(tmpCwd, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  it("--move flag runs only the Move test path", async () => {
+    runMoveTestsMock.mockResolvedValueOnce(undefined);
+
+    await testCommand({ move: true });
+
+    expect(runMoveTestsMock).toHaveBeenCalledTimes(1);
+    expect(runMoveTestsMock).toHaveBeenCalledWith({
+      filter: undefined,
+      skipIfMissing: false,
+    });
+    expect(runCliMock).not.toHaveBeenCalled();
+  });
+
+  it("legacy --moveOnly flag is translated into --move", async () => {
+    runMoveTestsMock.mockResolvedValueOnce(undefined);
+
+    await testCommand({ moveOnly: true });
+
+    expect(runMoveTestsMock).toHaveBeenCalledTimes(1);
+  });
+
+  it("legacy --tsOnly flag is translated into --ts (skips Move; mocha branch missing tests/ → skip)", async () => {
+    // No tests/ directory exists in tmpCwd, so the TS-only path skips
+    // gracefully via the "No TypeScript tests found" branch and never
+    // invokes runCli. The Move path is never entered.
+    await testCommand({ tsOnly: true });
+
+    expect(runMoveTestsMock).not.toHaveBeenCalled();
+    expect(runCliMock).not.toHaveBeenCalled();
+  });
+
+  it("--all flag forces the all-tests path", async () => {
+    runMoveTestsMock.mockResolvedValueOnce(undefined);
+    await testCommand({ all: true });
+    expect(runMoveTestsMock).toHaveBeenCalledTimes(1);
+    // skipIfMissing: true in the all-tests path.
+    expect(runMoveTestsMock.mock.calls[0]![0].skipIfMissing).toBe(true);
+  });
+
+  it("--move + --ts together also resolves to 'all'", async () => {
+    runMoveTestsMock.mockResolvedValueOnce(undefined);
+    await testCommand({ move: true, ts: true });
+    // The 'all' path uses skipIfMissing: true.
+    expect(runMoveTestsMock.mock.calls[0]![0].skipIfMissing).toBe(true);
+  });
+
+  it("Move-only path exits 1 when runMoveTests throws", async () => {
+    runMoveTestsMock.mockRejectedValueOnce(new Error("compile failed"));
+    await testCommand({ move: true });
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+
+  it("forwards --filter to runMoveTests", async () => {
+    runMoveTestsMock.mockResolvedValueOnce(undefined);
+    await testCommand({ move: true, filter: "counter" });
+    expect(runMoveTestsMock.mock.calls[0]![0].filter).toBe("counter");
+  });
+});
+
+describe("testCommand — interactive menu", () => {
+  let tmpCwd: string;
+  let origCwd: string;
+  let exitSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    runMoveTestsMock.mockReset();
+    runCliMock.mockReset();
+    promptsMock.mockReset();
+    origCwd = process.cwd();
+    tmpCwd = mkdtempSync(join(tmpdir(), "movehat-testcmd-"));
+    process.chdir(tmpCwd);
+    exitSpy = vi
+      .spyOn(process, "exit")
+      .mockImplementation(((_code?: number) => undefined) as never);
+    vi.spyOn(console, "log").mockImplementation(() => undefined);
+    vi.spyOn(console, "error").mockImplementation(() => undefined);
+  });
+
+  afterEach(() => {
+    process.chdir(origCwd);
+    if (existsSync(tmpCwd)) rmSync(tmpCwd, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  it("falls back to interactive prompt when no flags are passed; cancellation exits 0", async () => {
+    // Ctrl+C — prompt returns {}.
+    promptsMock.mockResolvedValueOnce({});
+
+    await testCommand();
+
+    expect(promptsMock).toHaveBeenCalledTimes(1);
+    expect(exitSpy).toHaveBeenCalledWith(0);
+  });
+
+  it("prompt returns 'move' → runs the Move path", async () => {
+    promptsMock.mockResolvedValueOnce({ testType: "move" });
+    runMoveTestsMock.mockResolvedValueOnce(undefined);
+
+    await testCommand();
+
+    expect(runMoveTestsMock).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("testCommand — TypeScript path with tests/ + node_modules", () => {
+  let tmpCwd: string;
+  let origCwd: string;
+  let exitSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    runMoveTestsMock.mockReset();
+    runCliMock.mockReset();
+    promptsMock.mockReset();
+    origCwd = process.cwd();
+    tmpCwd = mkdtempSync(join(tmpdir(), "movehat-testcmd-"));
+    process.chdir(tmpCwd);
+
+    // Plant a tests/ directory and a fake mocha binary.
+    mkdirSync(join(tmpCwd, "tests"), { recursive: true });
+    mkdirSync(join(tmpCwd, "node_modules", ".bin"), { recursive: true });
+    writeFileSync(join(tmpCwd, "node_modules", ".bin", "mocha"), "#!/bin/sh\nexit 0\n");
+
+    exitSpy = vi
+      .spyOn(process, "exit")
+      .mockImplementation(((_code?: number) => undefined) as never);
+    vi.spyOn(console, "log").mockImplementation(() => undefined);
+    vi.spyOn(console, "error").mockImplementation(() => undefined);
+  });
+
+  afterEach(() => {
+    process.chdir(origCwd);
+    if (existsSync(tmpCwd)) rmSync(tmpCwd, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  it("--ts invokes mocha via runCli when both tests/ and node_modules/.bin/mocha exist", async () => {
+    runCliMock.mockResolvedValueOnce({ exitCode: 0, stdout: "", stderr: "" });
+
+    await testCommand({ ts: true });
+
+    expect(runCliMock).toHaveBeenCalledTimes(1);
+    expect(runCliMock.mock.calls[0]![0].command).toContain("mocha");
+  });
+
+  it("--ts exits 1 when mocha's exit code is non-zero", async () => {
+    runCliMock.mockResolvedValueOnce({
+      exitCode: 1,
+      stdout: "",
+      stderr: "1 failing",
+    });
+
+    await testCommand({ ts: true });
+
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+});

package/src/commands/__tests__/update.test.ts

@@ -0,0 +1,223 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const fetchLatestVersionMock = vi.fn();
+const promptsMock = vi.fn();
+const runCliMock = vi.fn();
+
+vi.mock("../../helpers/npm-registry.js", () => ({
+  fetchLatestVersion: fetchLatestVersionMock,
+}));
+
+vi.mock("prompts", () => ({
+  default: promptsMock,
+}));
+
+vi.mock("../../utils/runCli.js", () => ({
+  runCli: runCliMock,
+}));
+
+const { default: updateCommand } = await import("../update.js");
+
+describe("updateCommand", () => {
+  let exitSpy: ReturnType<typeof vi.spyOn>;
+  let logSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    fetchLatestVersionMock.mockReset();
+    promptsMock.mockReset();
+    runCliMock.mockReset();
+    exitSpy = vi
+      .spyOn(process, "exit")
+      .mockImplementation(((_code?: number) => undefined) as never);
+    logSpy = vi.spyOn(console, "log").mockImplementation(() => undefined);
+    vi.spyOn(console, "error").mockImplementation(() => undefined);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("does nothing further when already on the latest version", async () => {
+    // Read the actual current version from package.json — same fetch the
+    // command does internally — and report it back as the "latest".
+    const currentVersion = await import("../../../package.json", {
+      with: { type: "json" },
+    }).then((m) => m.default.version);
+    fetchLatestVersionMock.mockResolvedValueOnce(currentVersion);
+
+    await updateCommand();
+
+    expect(fetchLatestVersionMock).toHaveBeenCalledTimes(1);
+    // Prompt never fires because the command short-circuits on the
+    // "already up to date" branch.
+    expect(promptsMock).not.toHaveBeenCalled();
+    expect(runCliMock).not.toHaveBeenCalled();
+    expect(exitSpy).not.toHaveBeenCalled();
+  });
+
+  it("exits 1 with a clear error when fetchLatestVersion returns null", async () => {
+    fetchLatestVersionMock.mockResolvedValueOnce(null);
+
+    await updateCommand();
+
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+
+  it("prompts for confirmation, runs the package manager, and exits 0 on success", async () => {
+    fetchLatestVersionMock.mockResolvedValueOnce("99.0.0");
+    promptsMock.mockResolvedValueOnce({ confirm: true });
+    runCliMock.mockResolvedValueOnce({ exitCode: 0, stdout: "", stderr: "" });
+
+    await updateCommand();
+
+    expect(promptsMock).toHaveBeenCalledTimes(1);
+    expect(runCliMock).toHaveBeenCalledTimes(1);
+    expect(exitSpy).toHaveBeenCalledWith(0);
+  });
+
+  it("returns without running the package manager when the user declines the prompt", async () => {
+    fetchLatestVersionMock.mockResolvedValueOnce("99.0.0");
+    promptsMock.mockResolvedValueOnce({ confirm: false });
+
+    await updateCommand();
+
+    expect(runCliMock).not.toHaveBeenCalled();
+    expect(exitSpy).not.toHaveBeenCalled();
+  });
+
+  it("returns without running the package manager when the user Ctrl+Cs the prompt", async () => {
+    fetchLatestVersionMock.mockResolvedValueOnce("99.0.0");
+    // Prompt with Ctrl+C returns an empty object — `confirm` is undefined.
+    promptsMock.mockResolvedValueOnce({});
+
+    await updateCommand();
+
+    expect(runCliMock).not.toHaveBeenCalled();
+  });
+
+  it("exits 1 when the package-manager run returns a non-zero exit code", async () => {
+    fetchLatestVersionMock.mockResolvedValueOnce("99.0.0");
+    promptsMock.mockResolvedValueOnce({ confirm: true });
+    runCliMock.mockResolvedValueOnce({
+      exitCode: 1,
+      stdout: "",
+      stderr: "permission denied",
+    });
+
+    await updateCommand();
+
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+
+  it("exits 1 when the package-manager run throws", async () => {
+    fetchLatestVersionMock.mockResolvedValueOnce("99.0.0");
+    promptsMock.mockResolvedValueOnce({ confirm: true });
+    runCliMock.mockRejectedValueOnce(new Error("ENOENT: pnpm not found"));
+
+    await updateCommand();
+
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+
+  it("exits 1 with a clear error when fetchLatestVersion throws", async () => {
+    fetchLatestVersionMock.mockRejectedValueOnce(new Error("network down"));
+
+    await updateCommand();
+
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+});
+
+describe("updateCommand — package-manager detection", () => {
+  let tmpCwd: string;
+  let origCwd: string;
+  let origAgent: string | undefined;
+
+  beforeEach(() => {
+    fetchLatestVersionMock.mockReset();
+    promptsMock.mockReset();
+    runCliMock.mockReset();
+    origCwd = process.cwd();
+    tmpCwd = mkdtempSync(join(tmpdir(), "movehat-update-pkgmgr-"));
+    process.chdir(tmpCwd);
+    origAgent = process.env.npm_config_user_agent;
+    delete process.env.npm_config_user_agent;
+    // npm_execpath is also inspected by detectPackageManager — clear it
+    // so the test doesn't pick up the runner's own value.
+    delete process.env.npm_execpath;
+    vi.spyOn(process, "exit").mockImplementation(((_code?: number) => undefined) as never);
+    vi.spyOn(console, "log").mockImplementation(() => undefined);
+    vi.spyOn(console, "error").mockImplementation(() => undefined);
+  });
+
+  afterEach(() => {
+    process.chdir(origCwd);
+    if (origAgent === undefined) delete process.env.npm_config_user_agent;
+    else process.env.npm_config_user_agent = origAgent;
+    rmSync(tmpCwd, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  it("detects pnpm when pnpm-lock.yaml is present and runs `pnpm add -g`", async () => {
+    writeFileSync(join(tmpCwd, "pnpm-lock.yaml"), "");
+    fetchLatestVersionMock.mockResolvedValueOnce("99.0.0");
+    promptsMock.mockResolvedValueOnce({ confirm: true });
+    runCliMock.mockResolvedValueOnce({ exitCode: 0, stdout: "", stderr: "" });
+
+    await updateCommand();
+
+    const call = runCliMock.mock.calls[0]!;
+    expect(call[0].command).toBe("pnpm");
+    expect(call[0].args.slice(0, 2)).toEqual(["add", "-g"]);
+  });
+
+  it("detects yarn when yarn.lock is present and runs `yarn global upgrade`", async () => {
+    writeFileSync(join(tmpCwd, "yarn.lock"), "");
+    fetchLatestVersionMock.mockResolvedValueOnce("99.0.0");
+    promptsMock.mockResolvedValueOnce({ confirm: true });
+    runCliMock.mockResolvedValueOnce({ exitCode: 0, stdout: "", stderr: "" });
+
+    await updateCommand();
+
+    const call = runCliMock.mock.calls[0]!;
+    expect(call[0].command).toBe("yarn");
+    expect(call[0].args.slice(0, 2)).toEqual(["global", "upgrade"]);
+  });
+
+  it("detects npm when package-lock.json is present and runs `npm update -g`", async () => {
+    writeFileSync(join(tmpCwd, "package-lock.json"), "{}");
+    fetchLatestVersionMock.mockResolvedValueOnce("99.0.0");
+    promptsMock.mockResolvedValueOnce({ confirm: true });
+    runCliMock.mockResolvedValueOnce({ exitCode: 0, stdout: "", stderr: "" });
+
+    await updateCommand();
+
+    const call = runCliMock.mock.calls[0]!;
+    expect(call[0].command).toBe("npm");
+    expect(call[0].args.slice(0, 2)).toEqual(["update", "-g"]);
+  });
+
+  it("falls back to user-agent detection when no lockfile is present (pnpm)", async () => {
+    process.env.npm_config_user_agent = "pnpm/8.0.0 node/v20";
+    fetchLatestVersionMock.mockResolvedValueOnce("99.0.0");
+    promptsMock.mockResolvedValueOnce({ confirm: true });
+    runCliMock.mockResolvedValueOnce({ exitCode: 0, stdout: "", stderr: "" });
+
+    await updateCommand();
+
+    expect(runCliMock.mock.calls[0]![0].command).toBe("pnpm");
+  });
+
+  it("defaults to npm when neither lockfile nor user-agent gives a hint", async () => {
+    fetchLatestVersionMock.mockResolvedValueOnce("99.0.0");
+    promptsMock.mockResolvedValueOnce({ confirm: true });
+    runCliMock.mockResolvedValueOnce({ exitCode: 0, stdout: "", stderr: "" });
+
+    await updateCommand();
+
+    expect(runCliMock.mock.calls[0]![0].command).toBe("npm");
+  });
+});