movehat 0.1.8 → 0.2.0

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

@@ -0,0 +1,121 @@
+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 serverStart = vi.fn();
+const serverStop = vi.fn();
+const ForkServerCtor = vi.fn();
+const loadUserConfigMock = vi.fn();
+
+vi.mock("../../../fork/server.js", () => ({
+  ForkServer: class {
+    constructor(forkPath: string, port: number, host: string) {
+      ForkServerCtor(forkPath, port, host);
+    }
+    start = serverStart;
+    stop = serverStop;
+  },
+}));
+
+vi.mock("../../../core/config.js", () => ({
+  loadUserConfig: loadUserConfigMock,
+}));
+
+const { default: forkServeCommand } = await import("../serve.js");
+
+describe("forkServeCommand", () => {
+  let tmpCwd: string;
+  let origCwd: string;
+  let exitSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    serverStart.mockReset().mockResolvedValue(undefined);
+    serverStop.mockReset().mockResolvedValue(undefined);
+    ForkServerCtor.mockReset();
+    loadUserConfigMock.mockReset();
+    origCwd = process.cwd();
+    tmpCwd = mkdtempSync(join(tmpdir(), "movehat-forkserve-"));
+    process.chdir(tmpCwd);
+    exitSpy = vi
+      .spyOn(process, "exit")
+      .mockImplementation(((code?: number) => {
+        throw new Error(`__test_exit_${code ?? 0}__`);
+      }) 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("happy path: starts server with explicit fork path + default port/host", async () => {
+    const forkPath = join(tmpCwd, "myfork");
+    mkdirSync(forkPath, { recursive: true });
+    writeFileSync(join(forkPath, "metadata.json"), "{}");
+
+    await forkServeCommand({ fork: forkPath });
+
+    expect(ForkServerCtor).toHaveBeenCalledWith(forkPath, 8080, "127.0.0.1");
+    expect(serverStart).toHaveBeenCalledTimes(1);
+  });
+
+  it("respects --port and --host overrides", async () => {
+    const forkPath = join(tmpCwd, "myfork");
+    mkdirSync(forkPath, { recursive: true });
+    writeFileSync(join(forkPath, "metadata.json"), "{}");
+
+    await forkServeCommand({ fork: forkPath, port: 9999, host: "0.0.0.0" });
+
+    expect(ForkServerCtor).toHaveBeenCalledWith(forkPath, 9999, "0.0.0.0");
+  });
+
+  it("resolves fork path from defaultNetwork when --fork is omitted", async () => {
+    loadUserConfigMock.mockResolvedValueOnce({
+      defaultNetwork: "testnet",
+      networks: { testnet: { url: "x", chainId: "testnet" } },
+    });
+    const expectedPath = join(tmpCwd, ".movehat", "forks", "testnet-fork");
+    mkdirSync(expectedPath, { recursive: true });
+    writeFileSync(join(expectedPath, "metadata.json"), "{}");
+
+    await forkServeCommand({});
+
+    // macOS /var → /private/var symlink — match by suffix.
+    const passedPath = ForkServerCtor.mock.calls[0]![0] as string;
+    expect(passedPath).toMatch(/\.movehat\/forks\/testnet-fork$/);
+  });
+
+  it("exits 1 when the fork's metadata.json is missing", async () => {
+    const forkPath = join(tmpCwd, "missing-fork");
+
+    await expect(forkServeCommand({ fork: forkPath })).rejects.toThrow(
+      "__test_exit_1__"
+    );
+    expect(serverStart).not.toHaveBeenCalled();
+  });
+
+  it("exits 1 when the configured network is unknown", async () => {
+    loadUserConfigMock.mockResolvedValueOnce({
+      defaultNetwork: "ghost",
+      networks: {},
+    });
+
+    await expect(forkServeCommand({})).rejects.toThrow("__test_exit_1__");
+    expect(serverStart).not.toHaveBeenCalled();
+  });
+
+  it("exits 1 when server.start throws", async () => {
+    const forkPath = join(tmpCwd, "myfork");
+    mkdirSync(forkPath, { recursive: true });
+    writeFileSync(join(forkPath, "metadata.json"), "{}");
+    serverStart.mockRejectedValueOnce(new Error("EADDRINUSE"));
+
+    await expect(forkServeCommand({ fork: forkPath })).rejects.toThrow(
+      "__test_exit_1__"
+    );
+  });
+});

package/src/commands/fork/__tests__/view-resource.test.ts

@@ -0,0 +1,101 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const forkManagerLoad = vi.fn();
+const forkManagerGetResource = vi.fn();
+const ForkManagerCtor = vi.fn();
+
+vi.mock("../../../fork/manager.js", () => ({
+  ForkManager: class {
+    constructor(forkPath: string) {
+      ForkManagerCtor(forkPath);
+    }
+    load = forkManagerLoad;
+    getResource = forkManagerGetResource;
+  },
+}));
+
+const { default: forkViewResourceCommand } = await import("../view-resource.js");
+
+describe("forkViewResourceCommand", () => {
+  let exitSpy: ReturnType<typeof vi.spyOn>;
+  let logSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    forkManagerLoad.mockReset();
+    forkManagerGetResource.mockReset();
+    ForkManagerCtor.mockReset();
+    exitSpy = vi
+      .spyOn(process, "exit")
+      .mockImplementation(((code?: number) => {
+        throw new Error(`__test_exit_${code ?? 0}__`);
+      }) as never);
+    logSpy = vi.spyOn(console, "log").mockImplementation(() => undefined);
+    vi.spyOn(console, "error").mockImplementation(() => undefined);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("exits 1 when --account is missing", async () => {
+    await expect(
+      forkViewResourceCommand({
+        account: "",
+        resource: "0x1::aptos_coin::AptosCoin",
+      } as never)
+    ).rejects.toThrow("__test_exit_1__");
+    expect(forkManagerLoad).not.toHaveBeenCalled();
+  });
+
+  it("exits 1 when --resource is missing", async () => {
+    await expect(
+      forkViewResourceCommand({
+        account: "0xabc",
+        resource: "",
+      } as never)
+    ).rejects.toThrow("__test_exit_1__");
+    expect(forkManagerLoad).not.toHaveBeenCalled();
+  });
+
+  it("happy path: loads the fork, fetches the resource, JSON-pretty-prints it", async () => {
+    forkManagerGetResource.mockResolvedValueOnce({ coin: { value: "1000" } });
+
+    await forkViewResourceCommand({
+      account: "0xabc",
+      resource: "0x1::coin::CoinStore<0x1::aptos_coin::AptosCoin>",
+      fork: "/tmp/fork",
+    } as never);
+
+    expect(forkManagerLoad).toHaveBeenCalledTimes(1);
+    expect(forkManagerGetResource).toHaveBeenCalledWith(
+      "0xabc",
+      "0x1::coin::CoinStore<0x1::aptos_coin::AptosCoin>"
+    );
+    // Pretty-printed JSON appears in stdout.
+    const printed = logSpy.mock.calls.flat().join(" ");
+    expect(printed).toContain("1000");
+  });
+
+  it("defaults forkPath to <cwd>/.movehat/forks/testnet-fork when --fork is omitted", async () => {
+    forkManagerGetResource.mockResolvedValueOnce({});
+
+    await forkViewResourceCommand({
+      account: "0xabc",
+      resource: "0x1::a::B",
+    } as never);
+
+    const passed = ForkManagerCtor.mock.calls[0]![0] as string;
+    expect(passed).toMatch(/\.movehat\/forks\/testnet-fork$/);
+  });
+
+  it("exits 1 when getResource throws (resource not found)", async () => {
+    forkManagerGetResource.mockRejectedValueOnce(new Error("not found"));
+
+    await expect(
+      forkViewResourceCommand({
+        account: "0xabc",
+        resource: "0x1::missing::X",
+      } as never)
+    ).rejects.toThrow("__test_exit_1__");
+  });
+});

package/src/commands/fork/create.ts

@@ -12,7 +12,7 @@ interface ForkCreateOptions {
 }
 
 /**
- * Create a local fork of a Movement/Aptos network
+ * Create a local fork of a Movement network
  *
  * This command:
  * - Connects to the specified network RPC endpoint
@@ -100,9 +100,10 @@ export default async function forkCreateCommand(options: ForkCreateOptions = {})
     logger.item(formatCommand('movehat fork list'), 2);
     logger.newline();
 
-  } catch (error: any) {
+  } catch (error) {
     logger.newline();
-    logger.error(`Error: ${error.message}`);
+    const msg = error instanceof Error ? error.message : String(error);
+    logger.error(`Error: ${msg}`);
     logger.newline();
     process.exit(1);
   }

package/src/commands/fork/fund.ts

@@ -1,5 +1,6 @@
 import { join } from 'path';
 import { ForkManager } from '../../fork/manager.js';
+import { logger } from '../../ui/index.js';
 
 interface ForkFundOptions {
   fork?: string;
@@ -30,11 +31,13 @@ export default async function forkFundCommand(options: ForkFundOptions) {
     const forkPath = options.fork || join(process.cwd(), '.movehat', 'forks', 'testnet-fork');
     const coinType = options.coinType || '0x1::aptos_coin::AptosCoin';
 
-    console.log(`\n💰 Funding account in fork`);
-    console.log(`   Fork: ${forkPath}`);
-    console.log(`   Account: ${options.account}`);
-    console.log(`   Amount: ${amount}`);
-    console.log(`   Coin Type: ${coinType}\n`);
+    logger.newline();
+    logger.step("Funding account in fork");
+    logger.plain(`   Fork: ${forkPath}`);
+    logger.plain(`   Account: ${options.account}`);
+    logger.plain(`   Amount: ${amount}`);
+    logger.plain(`   Coin Type: ${coinType}`);
+    logger.newline();
 
     // Load fork
     const forkManager = new ForkManager(forkPath);
@@ -47,11 +50,15 @@ export default async function forkFundCommand(options: ForkFundOptions) {
     const resourceType = `0x1::coin::CoinStore<${coinType}>`;
     const coinStore = await forkManager.getResource(options.account, resourceType);
 
-    console.log(`\n✅ Account funded successfully!`);
-    console.log(`   New balance: ${coinStore.coin.value}\n`);
+    logger.newline();
+    logger.success("Account funded successfully!");
+    logger.plain(`   New balance: ${coinStore.coin.value}`);
+    logger.newline();
 
-  } catch (error: any) {
-    console.error(`\n❌ Error: ${error.message}\n`);
+  } catch (error) {
+    logger.newline();
+    logger.error(error instanceof Error ? error.message : String(error));
+    logger.newline();
     process.exit(1);
   }
 }

package/src/commands/fork/list.ts

@@ -88,9 +88,10 @@ export default async function forkListCommand() {
     logger.item(formatCommand('movehat fork fund --fork <PATH> --account <ADDR> --amount <AMOUNT>'), 2);
     logger.newline();
 
-  } catch (error: any) {
+  } catch (error) {
     logger.newline();
-    logger.error(`Error: ${error.message}`);
+    const msg = error instanceof Error ? error.message : String(error);
+    logger.error(`Error: ${msg}`);
     logger.newline();
     process.exit(1);
   }

package/src/commands/fork/serve.ts

@@ -6,6 +6,7 @@ import { ForkServer } from '../../fork/server.js';
 interface ForkServeOptions {
   fork?: string;
   port?: number;
+  host?: string;
 }
 
 /**
@@ -43,9 +44,10 @@ export default async function forkServeCommand(options: ForkServeOptions): Promi
 
     // Get port (already validated by Commander's parsePort in cli.ts)
     const port = options.port ?? 8080;
+    const host = options.host ?? '127.0.0.1';
 
     // Create and start server
-    const server = new ForkServer(forkPath, port);
+    const server = new ForkServer(forkPath, port, host);
 
     // Handle graceful shutdown (use 'once' to prevent duplicate shutdowns)
     const shutdown = async () => {
@@ -70,8 +72,9 @@ export default async function forkServeCommand(options: ForkServeOptions): Promi
       process.removeListener('SIGTERM', sigtermHandler);
     }
 
-  } catch (error: any) {
-    console.error(`\nError starting fork server:`, error.message);
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    console.error(`\nError starting fork server:`, msg);
     process.exit(1);
   }
 }

package/src/commands/fork/view-resource.ts

@@ -1,5 +1,6 @@
 import { join } from 'path';
 import { ForkManager } from '../../fork/manager.js';
+import { logger } from '../../ui/index.js';
 
 interface ForkViewResourceOptions {
   fork?: string;
@@ -23,10 +24,12 @@ export default async function forkViewResourceCommand(options: ForkViewResourceO
     // Determine fork path
     const forkPath = options.fork || join(process.cwd(), '.movehat', 'forks', 'testnet-fork');
 
-    console.log(`\n🔍 Viewing resource from fork`);
-    console.log(`   Fork: ${forkPath}`);
-    console.log(`   Account: ${options.account}`);
-    console.log(`   Resource: ${options.resource}\n`);
+    logger.newline();
+    logger.step("Viewing resource from fork");
+    logger.plain(`   Fork: ${forkPath}`);
+    logger.plain(`   Account: ${options.account}`);
+    logger.plain(`   Resource: ${options.resource}`);
+    logger.newline();
 
     // Load fork
     const forkManager = new ForkManager(forkPath);
@@ -39,8 +42,10 @@ export default async function forkViewResourceCommand(options: ForkViewResourceO
     console.log(JSON.stringify(resource, null, 2));
     console.log('');
 
-  } catch (error: any) {
-    console.error(`\n❌ Error: ${error.message}\n`);
+  } catch (error) {
+    logger.newline();
+    logger.error(error instanceof Error ? error.message : String(error));
+    logger.newline();
     process.exit(1);
   }
 }

package/src/commands/run.ts

@@ -1,14 +1,37 @@
-import { spawn } from "child_process";
 import { resolve, extname, dirname, join } from "path";
 import { existsSync } from "fs";
 import { fileURLToPath } from "url";
 import { createRequire } from "module";
+import { runCli } from "../utils/runCli.js";
+import { logger } from "../ui/index.js";
+import type { RunResult } from "../utils/childProcessAdapter.js";
+
+/**
+ * Apply the exit policy for a child whose output was inherited by the
+ * parent. When the child dies via signal, re-raise it on the parent so
+ * shells and wrappers see the standard 128+N exit convention. Otherwise
+ * forward the numeric exit code, clamping any unexpected -1 to 1 (a -1
+ * would mask to 255 on Unix and drop signal-context).
+ *
+ * Exported so the branch is testable in isolation (a unit test against
+ * the full runCommand requires mocking fs + tsx resolution + runCli, all
+ * for 4 lines of policy).
+ *
+ * @internal
+ */
+export function propagateRunResultExit(result: RunResult): void {
+  if (result.signal) {
+    process.kill(process.pid, result.signal);
+    return;
+  }
+  process.exit(result.exitCode >= 0 ? result.exitCode : 1);
+}
 
 export default async function runCommand(scriptPath: string) {
   if (!scriptPath) {
-    console.error("❌ Error: No script path provided");
-    console.error("Usage: movehat run <script-path> [--network <name>]");
-    console.error("Example: movehat run scripts/deploy-counter.ts --network testnet");
+    logger.error("No script path provided");
+    logger.plain("Usage: movehat run <script-path> [--network <name>]");
+    logger.plain("Example: movehat run scripts/deploy-counter.ts --network testnet");
     process.exit(1);
   }
 
@@ -16,24 +39,24 @@ export default async function runCommand(scriptPath: string) {
 
   // Check if file exists
   if (!existsSync(fullPath)) {
-    console.error(`❌ Script not found: ${scriptPath}`);
+    logger.error(`Script not found: ${scriptPath}`);
     process.exit(1);
   }
 
   // Check if it's a TypeScript or JavaScript file
   const ext = extname(fullPath);
   if (![".ts", ".js", ".mjs"].includes(ext)) {
-    console.error(`❌ Unsupported file type: ${ext}`);
-    console.error("Supported extensions: .ts, .js, .mjs");
+    logger.error(`Unsupported file type: ${ext}`);
+    logger.plain("Supported extensions: .ts, .js, .mjs");
     process.exit(1);
   }
 
   const network = process.env.MH_CLI_NETWORK;
-  console.log(`🚀 Running script: ${scriptPath}`);
+  logger.step(`Running script: ${scriptPath}`);
   if (network) {
-    console.log(`   Network: ${network}`);
+    logger.plain(`   Network: ${network}`);
   }
-  console.log();
+  logger.newline();
 
   // Find tsx binary - try multiple locations for compatibility
   // Uses require.resolve for cross-platform compatibility (works on Windows, macOS, Linux)
@@ -72,28 +95,31 @@ export default async function runCommand(scriptPath: string) {
   }
 
   if (!tsxPath) {
-    console.error("❌ Error: tsx binary not found");
-    console.error("   Make sure 'tsx' is installed in your project:");
-    console.error("   npm install --save-dev tsx");
+    logger.error("tsx binary not found");
+    logger.plain("   Make sure 'tsx' is installed in your project:");
+    logger.plain("   npm install --save-dev tsx");
     process.exit(1);
   }
 
   // Execute script with tsx (handles both .ts and .js files)
-  // Using 'node' to execute tsx for cross-platform compatibility
-  const child = spawn("node", [tsxPath, fullPath], {
-    stdio: "inherit",
-    env: {
-      ...process.env,
-      // MH_CLI_NETWORK is already set by the CLI hook
-    },
-  });
-
-  child.on("exit", (code) => {
-    process.exit(code || 0);
-  });
+  // Using 'node' to execute tsx for cross-platform compatibility.
+  try {
+    const result = await runCli(
+      {
+        command: "node",
+        args: [tsxPath, fullPath],
+        env: {
+          ...process.env,
+          // MH_CLI_NETWORK is already set by the CLI hook
+        },
+        inheritStdio: true,
+      },
+      { throwOnNonZeroExit: false }
+    );
 
-  child.on("error", (error) => {
-    console.error(`❌ Failed to execute script: ${error.message}`);
+    propagateRunResultExit(result);
+  } catch (error) {
+    logger.error(`Failed to execute script: ${(error as Error).message}`);
     process.exit(1);
-  });
+  }
 }

package/src/commands/test-move.ts

@@ -16,10 +16,11 @@ export default async function testMoveCommand(options: TestMoveOptions = {}) {
     });
 
     process.exit(0);
-  } catch (err: any) {
+  } catch (err) {
     console.error("\n✗ Move tests failed");
-    if (err.message) {
-      console.error(`   ${err.message}`);
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg) {
+      console.error(`   ${msg}`);
     }
     process.exit(1);
   }

package/src/commands/test.ts

@@ -1,9 +1,9 @@
-import { spawn } from "child_process";
 import { join } from "path";
 import { existsSync } from "fs";
 import prompts from "prompts";
 import { runMoveTests } from "../helpers/move-tests.js";
 import { logger, colors, symbols } from "../ui/index.js";
+import { runCli } from "../utils/runCli.js";
 
 interface TestOptions {
   move?: boolean;
@@ -194,57 +194,69 @@ async function runAllTests(filter?: string): Promise<void> {
 /**
  * Run TypeScript tests using Mocha
  */
-function runTypeScriptTests(watch: boolean = false): Promise<void> {
-  return new Promise((resolve, reject) => {
-    const testDir = join(process.cwd(), "tests");
+async function runTypeScriptTests(watch: boolean = false): Promise<void> {
+  const testDir = join(process.cwd(), "tests");
 
-    if (!existsSync(testDir)) {
-      console.log(`${colors.muted(symbols.info)} No TypeScript tests found ${colors.muted("(tests/ directory not found)")}`);
-      console.log(`   ${colors.muted("Skipping TypeScript tests...")}`);
-      logger.newline();
-      resolve();
-      return;
-    }
+  if (!existsSync(testDir)) {
+    console.log(`${colors.muted(symbols.info)} No TypeScript tests found ${colors.muted("(tests/ directory not found)")}`);
+    console.log(`   ${colors.muted("Skipping TypeScript tests...")}`);
+    logger.newline();
+    return;
+  }
 
-    const mochaPath = join(process.cwd(), "node_modules", ".bin", "mocha");
+  const mochaPath = join(process.cwd(), "node_modules", ".bin", "mocha");
 
-    if (!existsSync(mochaPath)) {
-      logger.error("Mocha not found in project dependencies");
-      console.log(`   ${colors.muted("Install it with:")} ${colors.info("npm install --save-dev mocha")}`);
-      reject(new Error("Mocha not found"));
-      return;
-    }
+  if (!existsSync(mochaPath)) {
+    logger.error("Mocha not found in project dependencies");
+    console.log(`   ${colors.muted("Install it with:")} ${colors.info("npm install --save-dev mocha")}`);
+    throw new Error("Mocha not found");
+  }
 
-    const args = watch ? ["--watch"] : [];
+  const args = watch ? ["--watch"] : [];
 
-    const child = spawn(mochaPath, args, {
-      stdio: "inherit",
-      env: {
-        ...process.env,
+  // Watch mode: Mocha never exits. We fire-and-forget runCli so it owns the
+  // terminal until the user Ctrl+Cs the parent (which kills the child via
+  // inherited stdio). Attach .catch so a spawn-time failure doesn't become
+  // an unhandled rejection.
+  if (watch) {
+    runCli(
+      {
+        command: mochaPath,
+        args,
+        env: { ...process.env },
+        inheritStdio: true,
       },
+      { throwOnNonZeroExit: false }
+    ).catch((error) => {
+      logger.error(`Mocha watch crashed: ${(error as Error).message}`);
+      process.exit(1);
     });
 
-    // In watch mode, Mocha never exits, so resolve immediately
-    if (watch) {
-      console.log(`${colors.info(symbols.info)} Watch mode active. Press Ctrl+C to exit.`);
-      logger.newline();
-      resolve();
-      return;
-    }
+    console.log(`${colors.info(symbols.info)} Watch mode active. Press Ctrl+C to exit.`);
+    logger.newline();
+    return;
+  }
 
-    // Non-watch mode: wait for exit
-    child.on("exit", (code) => {
-      if (code === 0) {
-        resolve();
-      } else {
-        const exitCode = typeof code === "number" ? code : 1;
-        reject(new Error(`TypeScript tests failed with exit code ${exitCode}`));
-      }
-    });
+  // Non-watch mode: await the run, surface the exit code as a thrown error
+  // so the orchestrator above can summarize the failure.
+  let result;
+  try {
+    result = await runCli(
+      {
+        command: mochaPath,
+        args,
+        env: { ...process.env },
+        inheritStdio: true,
+      },
+      { throwOnNonZeroExit: false }
+    );
+  } catch (error) {
+    logger.error(`Failed to run TypeScript tests: ${(error as Error).message}`);
+    throw error;
+  }
 
-    child.on("error", (error) => {
-      logger.error(`Failed to run TypeScript tests: ${error.message}`);
-      reject(error);
-    });
-  });
+  if (result.exitCode === 0) {
+    return;
+  }
+  throw new Error(`TypeScript tests failed with exit code ${result.exitCode}`);
 }