movehat 0.2.4 → 0.2.5

package/src/core/__tests__/movementProfile.test.ts

@@ -1,131 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import {
-  chmodSync,
-  existsSync,
-  mkdirSync,
-  mkdtempSync,
-  rmSync,
-  writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import {
-  removeKeyFile,
-  removeKeyFileSyncBestEffort,
-  writeTempKeyFile,
-} from "../movementProfile.js";
-
-/**
- * Unit tests for the two distinct cleanup helpers in movementProfile:
- *
- *   - `removeKeyFileSyncBestEffort`: for SIGINT/SIGTERM handlers where
- *     the event loop is dead. Never throws, never logs, always returns
- *     void. We only test that it doesn't throw.
- *
- *   - `removeKeyFile`: for normal `finally` cleanup paths. Returns
- *     `null` when the file is gone (removed OR already absent — both
- *     are benign), and returns an `Error` only when the file STILL
- *     exists on disk after the unlink attempt failed. The Error path
- *     is exactly the case the caller must surface as a warning,
- *     because a private-key temp file would otherwise persist
- *     silently.
- */
-
-describe("movementProfile cleanup helpers", () => {
-  let scratchDir: string;
-
-  beforeEach(() => {
-    scratchDir = mkdtempSync(join(tmpdir(), "movehat-profile-test-"));
-  });
-
-  afterEach(() => {
-    if (existsSync(scratchDir)) {
-      // Force chmod in case a test left it un-removable, then rmSync.
-      try {
-        chmodSync(scratchDir, 0o700);
-      } catch {
-        /* best-effort */
-      }
-      rmSync(scratchDir, { recursive: true, force: true });
-    }
-  });
-
-  describe("writeTempKeyFile", () => {
-    it("creates a 0o600 file in os.tmpdir() with the key as contents", () => {
-      const path = writeTempKeyFile("ed25519-priv-0x" + "a".repeat(64));
-      try {
-        expect(path.startsWith(tmpdir())).toBe(true);
-        expect(path).toMatch(/movehat-key-/);
-        expect(existsSync(path)).toBe(true);
-      } finally {
-        if (existsSync(path)) rmSync(path);
-      }
-    });
-  });
-
-  describe("removeKeyFileSyncBestEffort", () => {
-    it("removes an existing file", () => {
-      const path = join(scratchDir, "key");
-      writeFileSync(path, "x", { mode: 0o600 });
-      removeKeyFileSyncBestEffort(path);
-      expect(existsSync(path)).toBe(false);
-    });
-
-    it("does not throw when the file is already gone", () => {
-      const path = join(scratchDir, "never-existed");
-      expect(() => removeKeyFileSyncBestEffort(path)).not.toThrow();
-    });
-
-    it("does not throw when the path is a non-empty directory (would fail in stricter callers)", () => {
-      const dirPath = join(scratchDir, "i-am-a-directory");
-      mkdirSync(dirPath);
-      writeFileSync(join(dirPath, "child"), "x");
-      expect(() => removeKeyFileSyncBestEffort(dirPath)).not.toThrow();
-      // The dir still exists — best-effort doesn't fight EISDIR.
-      expect(existsSync(dirPath)).toBe(true);
-    });
-  });
-
-  describe("removeKeyFile", () => {
-    it("returns null when the file is removed cleanly", () => {
-      const path = join(scratchDir, "key-to-remove");
-      writeFileSync(path, "x", { mode: 0o600 });
-      const err = removeKeyFile(path);
-      expect(err).toBeNull();
-      expect(existsSync(path)).toBe(false);
-    });
-
-    it("returns null when the file was already gone (ENOENT is benign)", () => {
-      const path = join(scratchDir, "never-existed");
-      const err = removeKeyFile(path);
-      expect(err).toBeNull();
-    });
-
-    it("returns null when the file disappears between the unlink attempt and the existsSync check (race)", () => {
-      // Hard to provoke a real race deterministically. The contract is
-      // documented; the previous test covers the ENOENT short-circuit
-      // which is the common race outcome.
-      const path = join(scratchDir, "raced");
-      const err = removeKeyFile(path);
-      expect(err).toBeNull();
-    });
-
-    it("returns an Error when the path is a directory AND still exists post-attempt", () => {
-      // unlinkSync on a directory throws EISDIR (or EPERM on some
-      // platforms). existsSync afterwards still returns true, so this
-      // is the "preocupante" path the caller must surface as a warning
-      // — the file (here, a directory occupying the key-file path) is
-      // still on disk.
-      const dirPath = join(scratchDir, "key-but-actually-a-dir");
-      mkdirSync(dirPath);
-      writeFileSync(join(dirPath, "child"), "x"); // make sure it's not empty
-      const err = removeKeyFile(dirPath);
-      expect(err).not.toBeNull();
-      expect(err).toBeInstanceOf(Error);
-      // Error code is platform-dependent (EISDIR on linux, EPERM on
-      // macos), so just assert we got something Error-shaped.
-      expect((err as NodeJS.ErrnoException).code).toMatch(/^E/);
-      expect(existsSync(dirPath)).toBe(true);
-    });
-  });
-});

package/src/core/__tests__/shell.test.ts

@@ -1,138 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  escapeShellArg,
-  validateAndEscapePath,
-  validateAndEscapeProfile,
-} from '../shell.js';
-
-describe('escapeShellArg', () => {
-  it('should wrap simple strings in single quotes', () => {
-    expect(escapeShellArg('hello')).toBe("'hello'");
-  });
-
-  it('should escape single quotes within strings', () => {
-    expect(escapeShellArg("it's")).toBe("'it'\\''s'");
-  });
-
-  it('should handle multiple single quotes', () => {
-    expect(escapeShellArg("it's a 'test'")).toBe("'it'\\''s a '\\''test'\\'''");
-  });
-
-  it('should handle empty strings', () => {
-    expect(escapeShellArg('')).toBe("''");
-  });
-
-  it('should handle strings with spaces', () => {
-    expect(escapeShellArg('hello world')).toBe("'hello world'");
-  });
-
-  it('should handle paths with spaces', () => {
-    expect(escapeShellArg('/path/to/my project')).toBe("'/path/to/my project'");
-  });
-
-  it('should throw for non-string input', () => {
-    expect(() => escapeShellArg(123 as any)).toThrow('Shell argument must be a string');
-    expect(() => escapeShellArg(null as any)).toThrow('Shell argument must be a string');
-    expect(() => escapeShellArg(undefined as any)).toThrow('Shell argument must be a string');
-  });
-
-  it('should handle special characters safely', () => {
-    // These should be safely wrapped, not executed
-    expect(escapeShellArg('$(whoami)')).toBe("'$(whoami)'");
-    expect(escapeShellArg('`ls`')).toBe("'`ls`'");
-  });
-});
-
-describe('validateAndEscapePath', () => {
-  it('should accept valid paths', () => {
-    expect(validateAndEscapePath('/home/user/project')).toBe("'/home/user/project'");
-    expect(validateAndEscapePath('./my-project')).toBe("'./my-project'");
-    expect(validateAndEscapePath('C:\\Users\\project')).toBe("'C:\\Users\\project'");
-  });
-
-  it('should accept paths with spaces', () => {
-    expect(validateAndEscapePath('/home/user/my project')).toBe("'/home/user/my project'");
-  });
-
-  it('should accept paths with dots and underscores', () => {
-    expect(validateAndEscapePath('./my_project.test')).toBe("'./my_project.test'");
-  });
-
-  it('should reject paths with semicolons (command chaining)', () => {
-    expect(() => validateAndEscapePath('/path; rm -rf /')).toThrow('potentially dangerous characters');
-  });
-
-  it('should reject paths with pipes', () => {
-    expect(() => validateAndEscapePath('/path | cat /etc/passwd')).toThrow('potentially dangerous characters');
-  });
-
-  it('should reject paths with backticks (command substitution)', () => {
-    expect(() => validateAndEscapePath('/path/`whoami`')).toThrow('potentially dangerous characters');
-  });
-
-  it('should reject paths with $() (command substitution)', () => {
-    expect(() => validateAndEscapePath('/path/$(whoami)')).toThrow('potentially dangerous characters');
-  });
-
-  it('should reject paths with ampersand', () => {
-    expect(() => validateAndEscapePath('/path & echo hacked')).toThrow('potentially dangerous characters');
-  });
-
-  it('should reject paths with curly braces', () => {
-    expect(() => validateAndEscapePath('/path/{a,b}')).toThrow('potentially dangerous characters');
-  });
-
-  it('should reject paths with redirects', () => {
-    expect(() => validateAndEscapePath('/path > /etc/passwd')).toThrow('potentially dangerous characters');
-    expect(() => validateAndEscapePath('/path < /etc/passwd')).toThrow('potentially dangerous characters');
-  });
-
-  it('should throw for empty paths', () => {
-    expect(() => validateAndEscapePath('')).toThrow('must be a non-empty string');
-  });
-
-  it('should throw for non-string input', () => {
-    expect(() => validateAndEscapePath(null as any)).toThrow('must be a non-empty string');
-    expect(() => validateAndEscapePath(undefined as any)).toThrow('must be a non-empty string');
-  });
-
-  it('should use custom name in error messages', () => {
-    expect(() => validateAndEscapePath('', 'Move directory')).toThrow('Invalid Move directory');
-  });
-});
-
-describe('validateAndEscapeProfile', () => {
-  it('should accept valid profile names', () => {
-    expect(validateAndEscapeProfile('default')).toBe("'default'");
-    expect(validateAndEscapeProfile('my-profile')).toBe("'my-profile'");
-    expect(validateAndEscapeProfile('profile_123')).toBe("'profile_123'");
-  });
-
-  it('should accept alphanumeric names', () => {
-    expect(validateAndEscapeProfile('Profile1')).toBe("'Profile1'");
-    expect(validateAndEscapeProfile('test123')).toBe("'test123'");
-  });
-
-  it('should reject profiles with spaces', () => {
-    expect(() => validateAndEscapeProfile('my profile')).toThrow('Only alphanumeric');
-  });
-
-  it('should reject profiles with special characters', () => {
-    expect(() => validateAndEscapeProfile('profile;rm')).toThrow('Only alphanumeric');
-    expect(() => validateAndEscapeProfile('profile$test')).toThrow('Only alphanumeric');
-    expect(() => validateAndEscapeProfile('profile/test')).toThrow('Only alphanumeric');
-  });
-
-  it('should reject profiles with dots', () => {
-    expect(() => validateAndEscapeProfile('profile.test')).toThrow('Only alphanumeric');
-  });
-
-  it('should throw for empty profiles', () => {
-    expect(() => validateAndEscapeProfile('')).toThrow('must be a non-empty string');
-  });
-
-  it('should throw for non-string input', () => {
-    expect(() => validateAndEscapeProfile(null as any)).toThrow('must be a non-empty string');
-    expect(() => validateAndEscapeProfile(undefined as any)).toThrow('must be a non-empty string');
-  });
-});

package/src/core/config.ts

@@ -1,286 +0,0 @@
-import { pathToFileURL } from "url";
-import { join } from "path";
-import { existsSync, statSync } from "fs";
-import { Account, Ed25519PrivateKey, PrivateKey, PrivateKeyVariants } from "@aptos-labs/ts-sdk";
-import { MovehatConfig, MovehatUserConfig } from "../types/config.js";
-import { logger } from "../ui/index.js";
-
-interface ConfigCacheEntry {
-  mtimeMs: number;
-  config: MovehatUserConfig;
-}
-
-// Keyed by resolved absolute path. One entry per config file the process
-// has loaded. Closes #62 — the previous `?t=Date.now()` cache-bust
-// created a fresh Node loader module per call.
-//
-// Note on concurrency: two `loadUserConfig()` calls racing on a cold
-// cache may both invoke `import()`. Node's loader cache deduplicates by
-// URL so both resolve to the same module, and both writers store the
-// same value here. No corruption, no in-flight-promise memoization
-// needed.
-const configCache = new Map<string, ConfigCacheEntry>();
-
-/**
- * Loads the user's movehat.config.{ts,js} from the current working directory.
- *
- * Cached by `{ absPath, mtimeMs }`: a second call with no edit returns
- * the parsed object directly and skips both the tsx loader register
- * dance and the dynamic `import()`. Edits invalidate via the file's
- * mtime.
- *
- * @throws {Error} If the configuration file is not found or fails to load
- * @security This function loads and executes code from the current working directory.
- *           It should only be called from trusted project directories.
- */
-export async function loadUserConfig(): Promise<MovehatUserConfig> {
-  const cwd = process.cwd();
-
-  const possiblePaths = [
-    join(cwd, "movehat.config.ts"),
-    join(cwd, "movehat.config.js"),
-  ];
-
-  let configPath: string | null = null;
-  for (const path of possiblePaths) {
-    if (existsSync(path)) {
-      configPath = path;
-      break;
-    }
-  }
-
-  if (!configPath) {
-    throw new Error(
-      "Configuration file not found. Expected 'movehat.config.ts' or 'movehat.config.js' in the current directory."
-    );
-  }
-
-  try {
-    const { mtimeMs } = statSync(configPath);
-
-    const cached = configCache.get(configPath);
-    if (cached && cached.mtimeMs === mtimeMs) {
-      return cached.config;
-    }
-
-    let configModule;
-
-    if (configPath.endsWith('.ts')) {
-      const { register } = await import('tsx/esm/api');
-      const unregister = register();
-
-      try {
-        const configUrl = pathToFileURL(configPath).href;
-        configModule = await import(configUrl + '?mtime=' + mtimeMs);
-      } finally {
-        unregister();
-      }
-    } else {
-      const configUrl = pathToFileURL(configPath).href;
-      configModule = await import(configUrl + '?mtime=' + mtimeMs);
-    }
-
-    const userConfig = configModule.default as MovehatUserConfig;
-
-    if (!userConfig.networks || Object.keys(userConfig.networks).length === 0) {
-      throw new Error(
-        "No networks defined in configuration. Add at least one network in the 'networks' field."
-      );
-    }
-
-    configCache.set(configPath, { mtimeMs, config: userConfig });
-
-    return userConfig;
-  } catch (error) {
-    throw new Error(`Failed to load configuration file '${configPath}': ${error}`);
-  }
-}
-
-/**
- * Clear the in-memory config cache. Test-only escape hatch.
- *
- * @internal Not part of the public API surface. Imported via relative
- *           path from `core/__tests__/config.test.ts` only.
- */
-export function _resetConfigCache(): void {
-  configCache.clear();
-}
-
-/**
- * Resolve configuration for a specific network
- * Merges global settings with network-specific settings
- */
-export async function resolveNetworkConfig(
-  userConfig: MovehatUserConfig,
-  networkName?: string
-): Promise<MovehatConfig> {
-  // Determine which network to use
-  // Default to "testnet" for testing with simulation
-  const selectedNetwork =
-    networkName ||
-    process.env.MH_CLI_NETWORK ||
-    process.env.MH_DEFAULT_NETWORK ||
-    userConfig.defaultNetwork ||
-    "testnet";
-
-  // Check if network exists in config
-  let networkConfig = userConfig.networks[selectedNetwork];
-
-  // Special case: Auto-generate config for testnet (public test network)
-  // This provides a better dev experience - no local setup required
-  if (!networkConfig && selectedNetwork === "testnet") {
-    networkConfig = {
-      url: "https://testnet.movementnetwork.xyz/v1",
-      chainId: "testnet",
-    };
-    logger.info("testnet not found in config - using default Movement testnet configuration");
-  }
-
-  // Special case: Auto-generate config for local fork server
-  if (!networkConfig && selectedNetwork === "local") {
-    networkConfig = {
-      url: "http://localhost:8080/v1",
-      chainId: "local",
-    };
-    logger.info("Local network not found in config - using default fork server configuration");
-  }
-
-  if (!networkConfig) {
-    const availableNetworks = Object.keys(userConfig.networks).join(", ");
-    throw new Error(
-      `Network '${selectedNetwork}' not found in configuration.\nAvailable networks: ${availableNetworks}, testnet (auto-generated), local (auto-generated)`
-    );
-  }
-
-  // Get accounts using Hardhat-style resolution:
-  // 1. Network-specific accounts (if defined)
-  // 2. Global accounts from config (if defined)
-  // 3. PRIVATE_KEY environment variable (Hardhat-style, no MH_ prefix)
-  // 4. Error if nothing found
-
-  let accounts: string[] = [];
-
-  // 1. Check network-specific accounts
-  if (networkConfig.accounts && networkConfig.accounts.length > 0) {
-    accounts = [...networkConfig.accounts].filter(Boolean);
-  }
-
-  // 2. If no network-specific accounts, use global accounts
-  if (accounts.length === 0 && userConfig.accounts && userConfig.accounts.length > 0) {
-    accounts = [...userConfig.accounts].filter(Boolean);
-  }
-
-  // 3. If still no accounts, check PRIVATE_KEY env var (Hardhat-style)
-  if (accounts.length === 0 && process.env.PRIVATE_KEY) {
-    accounts = [process.env.PRIVATE_KEY];
-  }
-
-  // 4. Validate we have at least one account (unless using testnet/local)
-  if (accounts.length === 0 || !accounts[0]) {
-    // Special case: Auto-generate test accounts for testing networks
-    // testnet = public Movement test network (recommended)
-    // local = local fork server
-    if (selectedNetwork === "testnet" || selectedNetwork === "local") {
-      // Security: Using a deterministic test account (like Hardhat's default accounts)
-      // This is SAFE because:
-      // 1. Only used for testnet/local (never mainnet - that throws error below)
-      // 2. Perfect for transaction simulation (no real funds)
-      // 3. Deterministic = consistent test results
-      const testPrivateKey = "0x0000000000000000000000000000000000000000000000000000000000000001";
-      accounts = [testPrivateKey];
-      logger.newline();
-      logger.warning("[TESTNET] Using auto-generated test account (safe for testing only)");
-      logger.warning("[TESTNET] For mainnet, set PRIVATE_KEY in .env");
-      logger.newline();
-    } else {
-      // For any other network (especially mainnet), REQUIRE explicit configuration
-      // This prevents accidentally using the test key on production networks
-      throw new Error(
-        `Network '${selectedNetwork}' has no accounts configured.\n` +
-        `\n` +
-        `SECURITY: This network requires explicit account configuration.\n` +
-        `\n` +
-        `Options:\n` +
-        `  1. Set PRIVATE_KEY in your .env file (recommended for ${selectedNetwork})\n` +
-        `  2. Add 'accounts: ["0x..."]' globally in movehat.config.ts\n` +
-        `  3. Add 'accounts: ["0x..."]' to the '${selectedNetwork}' network config\n` +
-        `\n` +
-        `For testing without configuration, use:\n` +
-        `  movehat <command> --network testnet (auto-generates safe test accounts)`
-      );
-    }
-  }
-
-  // Merge named addresses (network-specific overrides global)
-  const mergedNamedAddresses = {
-    ...(userConfig.namedAddresses || {}),
-    ...(networkConfig.namedAddresses || {}),
-  };
-
-  // Capture the primary key after the L178 guard guaranteed it exists
-  // (either present from the start, or auto-assigned by the testnet/local
-  // branch; the else-branch throws). Pulling into a local lets TS see
-  // the non-undefined narrowing.
-  const primaryKey = accounts[0];
-  if (!primaryKey) {
-    throw new Error("invariant: accounts[0] must exist after the L178 guard");
-  }
-
-  // Derive the deployer account address from the resolved private key.
-  // Without this, consumers reading `config.account` got an empty string
-  // (the previous "Will be derived from privateKey in runtime" TODO was
-  // never wired). Falls back to "" on malformed keys so we don't break
-  // existing callers that don't need the field.
-  const accountAddress = deriveAccountAddress(primaryKey);
-
-  // Build resolved config
-  const resolvedConfig: MovehatConfig = {
-    network: selectedNetwork,
-    rpc: networkConfig.url,
-    privateKey: primaryKey,
-    allAccounts: accounts,
-    profile: networkConfig.profile || "default",
-    moveDir: userConfig.moveDir || "./move",
-    account: accountAddress,
-    namedAddresses: mergedNamedAddresses,
-    networkConfig: networkConfig,
-  };
-
-  return resolvedConfig;
-}
-
-/**
- * Derive the on-chain account address from a private key. Strips the
- * `ed25519-priv-` prefix that Movement CLI sometimes emits; returns ""
- * on any parse failure so existing callers that don't consume the field
- * keep working unchanged. Emits a console.warn on failure so a
- * misconfigured `PRIVATE_KEY` surfaces here (loud, at config-resolution
- * time) instead of as a cryptic "Hex string is too short" SDK error
- * later in the call chain.
- */
-function deriveAccountAddress(privateKeyHex: string | undefined): string {
-  if (!privateKeyHex) return "";
-  try {
-    // Format into AIP-80 shape so the SDK doesn't emit a deprecation
-    // warning on each derivation. `formatPrivateKey` is idempotent for
-    // already-prefixed inputs.
-    const formatted = PrivateKey.formatPrivateKey(
-      privateKeyHex,
-      PrivateKeyVariants.Ed25519,
-    );
-    const account = Account.fromPrivateKey({
-      privateKey: new Ed25519PrivateKey(formatted),
-    });
-    return account.accountAddress.toString();
-  } catch (err) {
-    // The private key may have come from several sources (network.accounts,
-    // global accounts, PRIVATE_KEY env, auto-generated testnet key). Keep
-    // the hint generic so it never points at the wrong source.
-    logger.warning(
-      `Could not derive account address from the resolved private key: ${
-        (err as Error).message
-      }. Verify the key configured for this network is a valid Ed25519 private key (with or without the "ed25519-priv-" prefix).`
-    );
-    return "";
-  }
-}

package/src/core/contract.ts

@@ -1,103 +0,0 @@
-import {
-  Account,
-  Aptos,
-  type InputViewFunctionData,
-  type MoveFunctionId,
-} from "@aptos-labs/ts-sdk";
-import { logger } from "../ui/index.js";
-
-export interface TransactionResult {
-  hash: string;
-  success: boolean;
-  vm_status: string;
-}
-
-export class MoveContract {
-  constructor(
-    private aptos: Aptos,
-    private moduleAddress: string,
-    private moduleName: string
-  ) {}
-
-  async call(
-    signer: Account,
-    functionName: string,
-    // any[]: Move entry-function arguments are heterogeneous primitives
-    // (u8/u64/string/bool/address/vector) passed through to the Aptos
-    // SDK's `functionArguments`, which validates at submit time. A
-    // narrower union here would force casts at every call site for
-    // little safety gain.
-    args: any[] = [],
-    typeArgs: string[] = []
-  ): Promise<TransactionResult> {
-    const functionFullName = `${this.moduleAddress}::${this.moduleName}::${functionName}`;
-
-    logger.step(`Calling ${functionFullName}...`);
-
-    const transaction = await this.aptos.transaction.build.simple({
-      sender: signer.accountAddress,
-      data: {
-        function: functionFullName as MoveFunctionId,
-        typeArguments: typeArgs,
-        functionArguments: args,
-      },
-    });
-
-    const signature = this.aptos.transaction.sign({
-      signer,
-      transaction,
-    });
-
-    const committedTxn = await this.aptos.transaction.submit.simple({
-      transaction,
-      senderAuthenticator: signature,
-    });
-
-    const response = await this.aptos.waitForTransaction({
-      transactionHash: committedTxn.hash,
-    });
-
-    logger.success(
-      `Transaction ${committedTxn.hash} committed with status: ${response.vm_status}`
-    );
-    logger.newline();
-
-    return {
-      hash: committedTxn.hash,
-      success: response.success,
-      vm_status: response.vm_status,
-    };
-  }
-
-  async view<T = unknown>(
-    functionName: string,
-    // any[]: see `call()` above — Move view-function arguments share
-    // the same SDK-validated boundary semantics.
-    args: any[] = [],
-    typeArgs: string[] = []
-  ): Promise<T> {
-    const functionFullName = `${this.moduleAddress}::${this.moduleName}::${functionName}`;
-
-    const payload: InputViewFunctionData = {
-      function: functionFullName as MoveFunctionId,
-      typeArguments: typeArgs,
-      functionArguments: args,
-    };
-
-    const result = await this.aptos.view({ payload });
-
-    return (result.length === 1 ? result[0] : result) as T;
-  }
-
-  getModuleId(): string {
-    return `${this.moduleAddress}::${this.moduleName}`;
-  }
-}
-
-export function getContract(
-    aptos: Aptos,
-    moduleAddress: string,
-    moduleName: string
-): MoveContract {
-    return new MoveContract(aptos, moduleAddress, moduleName);
-}