movehat 0.2.4 → 0.2.6

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

@@ -1,139 +0,0 @@
-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 storageExists = vi.fn();
-const storageLoadMetadata = vi.fn();
-const storageListAccounts = vi.fn();
-
-vi.mock("../../../fork/storage.js", () => ({
-  ForkStorage: class {
-    exists = storageExists;
-    loadMetadata = storageLoadMetadata;
-    listAccounts = storageListAccounts;
-  },
-}));
-
-const { default: forkListCommand } = await import("../list.js");
-
-describe("forkListCommand", () => {
-  let tmpCwd: string;
-  let origCwd: string;
-  let exitSpy: ReturnType<typeof vi.spyOn>;
-  let logSpy: ReturnType<typeof vi.spyOn>;
-
-  beforeEach(() => {
-    storageExists.mockReset();
-    storageLoadMetadata.mockReset();
-    storageListAccounts.mockReset();
-    origCwd = process.cwd();
-    tmpCwd = mkdtempSync(join(tmpdir(), "movehat-forklist-"));
-    process.chdir(tmpCwd);
-    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(() => {
-    process.chdir(origCwd);
-    if (existsSync(tmpCwd)) rmSync(tmpCwd, { recursive: true, force: true });
-    vi.restoreAllMocks();
-  });
-
-  it("prints 'no forks found' when the forks dir doesn't exist", async () => {
-    await forkListCommand();
-
-    const printed = logSpy.mock.calls.flat().join(" ");
-    expect(printed).toMatch(/No forks found/i);
-    expect(storageExists).not.toHaveBeenCalled();
-  });
-
-  it("prints 'no forks found' when the forks dir is empty", async () => {
-    mkdirSync(join(tmpCwd, ".movehat", "forks"), { recursive: true });
-    await forkListCommand();
-
-    const printed = logSpy.mock.calls.flat().join(" ");
-    expect(printed).toMatch(/No forks found/i);
-  });
-
-  it("lists a single valid fork in a table", async () => {
-    mkdirSync(join(tmpCwd, ".movehat", "forks", "testnet-fork"), { recursive: true });
-    storageExists.mockReturnValue(true);
-    storageLoadMetadata.mockReturnValue({
-      network: "testnet",
-      nodeUrl: "https://testnet.movementnetwork.xyz/v1",
-      chainId: 27,
-      ledgerVersion: "100",
-      timestamp: "12345",
-      epoch: "5",
-      blockHeight: "42",
-      createdAt: new Date(1700000000000).toISOString(),
-    });
-    storageListAccounts.mockReturnValue(["0xabc", "0xdef"]);
-
-    await forkListCommand();
-
-    const printed = logSpy.mock.calls.flat().join(" ");
-    expect(printed).toMatch(/testnet-fork/);
-    expect(printed).toMatch(/testnet/);
-  });
-
-  it("flags forks with invalid/missing metadata gracefully", async () => {
-    mkdirSync(join(tmpCwd, ".movehat", "forks", "broken-fork"), { recursive: true });
-    storageExists.mockReturnValue(false);
-
-    await forkListCommand();
-
-    const printed = logSpy.mock.calls.flat().join(" ");
-    expect(printed).toMatch(/broken-fork/);
-    expect(printed).toMatch(/invalid/);
-  });
-
-  it("handles metadata-load errors per-fork without aborting the list", async () => {
-    mkdirSync(join(tmpCwd, ".movehat", "forks", "fork-a"), { recursive: true });
-    mkdirSync(join(tmpCwd, ".movehat", "forks", "fork-b"), { recursive: true });
-
-    // First fork: exists() throws on metadata load; second: ok.
-    let call = 0;
-    storageExists.mockImplementation(() => {
-      call++;
-      if (call === 1) throw new Error("metadata corrupt");
-      return true;
-    });
-    storageLoadMetadata.mockReturnValue({
-      network: "testnet",
-      nodeUrl: "url",
-      chainId: 27,
-      ledgerVersion: "100",
-      timestamp: "0",
-      epoch: "0",
-      blockHeight: "0",
-      createdAt: new Date(0).toISOString(),
-    });
-    storageListAccounts.mockReturnValue([]);
-
-    await forkListCommand();
-
-    const printed = logSpy.mock.calls.flat().join(" ");
-    expect(printed).toMatch(/fork-a/);
-    expect(printed).toMatch(/error/);
-    expect(printed).toMatch(/fork-b/);
-  });
-
-  it("skips non-directory entries in the forks dir", async () => {
-    mkdirSync(join(tmpCwd, ".movehat", "forks"), { recursive: true });
-    // Plant a stray file at the forks-dir level.
-    writeFileSync(join(tmpCwd, ".movehat", "forks", "not-a-fork.txt"), "x");
-
-    // No actual fork subdirs — should still hit the "0 forks" branch.
-    await forkListCommand();
-
-    const printed = logSpy.mock.calls.flat().join(" ");
-    expect(printed).toMatch(/No forks found/i);
-  });
-});

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

@@ -1,121 +0,0 @@
-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

@@ -1,101 +0,0 @@
-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

@@ -1,110 +0,0 @@
-import { join } from 'path';
-import { existsSync } from 'fs';
-import prompts from 'prompts';
-import { loadUserConfig, resolveNetworkConfig } from '../../core/config.js';
-import { ForkManager } from '../../fork/manager.js';
-import { logger, withSpinner, createKVTable, formatCommand } from '../../ui/index.js';
-
-interface ForkCreateOptions {
-  network?: string;
-  path?: string;
-  name?: string;
-}
-
-/**
- * Create a local fork of a Movement network
- *
- * This command:
- * - Connects to the specified network RPC endpoint
- * - Downloads blockchain state (accounts, modules, resources)
- * - Creates a local fork database for testing
- * - Displays fork metadata (chain ID, ledger version, block height, epoch)
- *
- * @param options - Fork creation options
- * @param options.network - Network to fork from (e.g., 'testnet', 'mainnet')
- * @param options.path - Custom path to store fork data
- * @param options.name - Custom name for the fork
- *
- * @example
- * // Fork testnet
- * await forkCreateCommand({ network: 'testnet' });
- *
- * @example
- * // Fork with custom name
- * await forkCreateCommand({ network: 'testnet', name: 'my-fork' });
- */
-export default async function forkCreateCommand(options: ForkCreateOptions = {}) {
-  try {
-    // Load MoveHat config
-    const userConfig = await loadUserConfig();
-    const networkName = options.network || process.env.MH_CLI_NETWORK || userConfig.defaultNetwork || 'testnet';
-    const networkConfig = await resolveNetworkConfig(userConfig, networkName);
-
-    // Determine fork name and path
-    const forkName = options.name || `${networkName}-fork`;
-    const forkPath = options.path || join(process.cwd(), '.movehat', 'forks', forkName);
-
-    logger.newline();
-    logger.info(`Creating fork of ${networkName}`);
-    logger.kv('Network', networkConfig.rpc, 2);
-    logger.kv('Fork path', forkPath, 2);
-    logger.newline();
-
-    // Check if fork already exists
-    if (existsSync(forkPath)) {
-      const { overwrite } = await prompts({
-        type: 'confirm',
-        name: 'overwrite',
-        message: `Fork already exists at ${forkPath}. Overwrite?`,
-        initial: false,
-      });
-
-      if (!overwrite) {
-        logger.warning('Fork creation cancelled');
-        return;
-      }
-    }
-
-    // Create fork manager
-    const forkManager = new ForkManager(forkPath);
-
-    // Initialize fork with spinner
-    const metadata = await withSpinner(
-      'Initializing fork...',
-      async () => {
-        await forkManager.initialize(networkConfig.rpc, networkName);
-        return forkManager.getMetadata();
-      },
-      'Fork initialized successfully!'
-    );
-
-    // Show fork details
-    logger.newline();
-    logger.success('Fork created successfully!');
-    logger.newline();
-
-    logger.section('Fork Details');
-    const detailsTable = createKVTable({
-      'Chain ID': metadata.chainId.toString(),
-      'Ledger Version': metadata.ledgerVersion,
-      'Block Height': metadata.blockHeight,
-      'Epoch': metadata.epoch
-    });
-    console.log(detailsTable.toString());
-    logger.newline();
-
-    // Usage examples
-    logger.section('Usage');
-    logger.item(formatCommand(`movehat fork view-resource --fork ${forkPath} --account <ADDRESS> --resource <TYPE>`), 2);
-    logger.item(formatCommand(`movehat fork fund --fork ${forkPath} --account <ADDRESS> --amount <AMOUNT>`), 2);
-    logger.item(formatCommand('movehat fork list'), 2);
-    logger.newline();
-
-  } catch (error) {
-    logger.newline();
-    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,64 +0,0 @@
-import { join } from 'path';
-import { ForkManager } from '../../fork/manager.js';
-import { logger } from '../../ui/index.js';
-
-interface ForkFundOptions {
-  fork?: string;
-  account: string;
-  amount: string;
-  coinType?: string;
-}
-
-/**
- * Fork fund command: Fund an account in the fork
- */
-export default async function forkFundCommand(options: ForkFundOptions) {
-  try {
-    if (!options.account) {
-      throw new Error('--account is required');
-    }
-
-    if (!options.amount) {
-      throw new Error('--amount is required');
-    }
-
-    const amount = parseInt(options.amount, 10);
-    if (isNaN(amount) || amount <= 0) {
-      throw new Error('--amount must be a positive number');
-    }
-
-    // Determine fork path
-    const forkPath = options.fork || join(process.cwd(), '.movehat', 'forks', 'testnet-fork');
-    const coinType = options.coinType || '0x1::aptos_coin::AptosCoin';
-
-    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);
-    forkManager.load();
-
-    // Fund account
-    await forkManager.fundAccount(options.account, amount, coinType);
-
-    // Verify
-    const resourceType = `0x1::coin::CoinStore<${coinType}>`;
-    const coinStore = await forkManager.getResource(options.account, resourceType);
-
-    logger.newline();
-    logger.success("Account funded successfully!");
-    logger.plain(`   New balance: ${coinStore.coin.value}`);
-    logger.newline();
-
-  } catch (error) {
-    logger.newline();
-    logger.error(error instanceof Error ? error.message : String(error));
-    logger.newline();
-    process.exit(1);
-  }
-}

package/src/commands/fork/list.ts

@@ -1,98 +0,0 @@
-import { join } from 'path';
-import { existsSync, readdirSync, statSync } from 'fs';
-import { ForkStorage } from '../../fork/storage.js';
-import { logger, createTable, formatCommand } from '../../ui/index.js';
-
-/**
- * List all available local forks
- *
- * Displays forks in a formatted table showing:
- * - Fork name
- * - Network (testnet, mainnet, etc.)
- * - Chain ID
- * - Number of accounts
- * - Creation timestamp
- *
- * @example
- * // List all forks
- * await forkListCommand();
- */
-export default async function forkListCommand() {
-  try {
-    const forksDir = join(process.cwd(), '.movehat', 'forks');
-
-    if (!existsSync(forksDir)) {
-      logger.newline();
-      logger.info('No forks found');
-      logger.newline();
-      logger.plain('Create a fork with:');
-      logger.item(formatCommand('movehat fork create --network testnet'), 2);
-      logger.newline();
-      return;
-    }
-
-    const entries = readdirSync(forksDir);
-    const forkDirs = entries.filter((entry) => {
-      const fullPath = join(forksDir, entry);
-      return statSync(fullPath).isDirectory();
-    });
-
-    if (forkDirs.length === 0) {
-      logger.newline();
-      logger.info('No forks found');
-      logger.newline();
-      return;
-    }
-
-    logger.newline();
-    logger.info(`Found ${forkDirs.length} fork(s)`);
-    logger.newline();
-
-    // Create table for forks
-    const table = createTable({
-      head: ['Name', 'Network', 'Chain ID', 'Accounts', 'Created'],
-      preset: 'default',
-      colWidths: [20, 15, 12, 12, 25]
-    });
-
-    for (const forkDir of forkDirs) {
-      const forkPath = join(forksDir, forkDir);
-      const storage = new ForkStorage(forkPath);
-
-      try {
-        if (storage.exists()) {
-          const metadata = storage.loadMetadata();
-          const accounts = storage.listAccounts();
-
-          table.push([
-            forkDir,
-            metadata.network,
-            metadata.chainId.toString(),
-            accounts.length.toString(),
-            new Date(metadata.createdAt).toLocaleString()
-          ]);
-        } else {
-          table.push([forkDir, 'invalid', '-', '-', 'missing metadata']);
-        }
-      } catch (error) {
-        table.push([forkDir, 'error', '-', '-', 'error reading']);
-      }
-    }
-
-    console.log(table.toString());
-    logger.newline();
-
-    // Usage examples
-    logger.section('Usage');
-    logger.item(formatCommand('movehat fork view-resource --fork <PATH> --account <ADDR> --resource <TYPE>'), 2);
-    logger.item(formatCommand('movehat fork fund --fork <PATH> --account <ADDR> --amount <AMOUNT>'), 2);
-    logger.newline();
-
-  } catch (error) {
-    logger.newline();
-    const msg = error instanceof Error ? error.message : String(error);
-    logger.error(`Error: ${msg}`);
-    logger.newline();
-    process.exit(1);
-  }
-}