movehat 0.1.8 → 0.2.0

package/src/harness/script.ts

@@ -0,0 +1,196 @@
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { extname, join } from "path";
+import { randomUUID } from "crypto";
+import type { MovehatRuntime } from "../types/runtime.js";
+import type {
+  RunMoveScriptOptions,
+  MoveScriptResult,
+} from "../types/harness.js";
+import { validatePathSafety, validateProfileSafety } from "../core/shell.js";
+import { CliExecutionError } from "../errors.js";
+import { runCli } from "../utils/runCli.js";
+import { parseTxHash } from "../utils/parseCliOutput.js";
+import { logger } from "../ui/index.js";
+import {
+  withYamlLock,
+  addProfile,
+  removeProfile,
+  removeProfileSync,
+  ensureSignalHandler,
+  cleanupCallbacks,
+} from "../core/movementProfile.js";
+
+/**
+ * Execute a Move script via `movement move run-script`.
+ *
+ * Auto-detects the script kind from the extension:
+ *   - `.move` source → `--script-path` (CLI compiles inline)
+ *   - `.mv` compiled bytecode → `--compiled-script-path`
+ *
+ * Reuses Publisher's security model via the shared `movementProfile`
+ * helpers: per-deploy unique profile, atomic 0o600 yaml writes under
+ * the mutex, SIGINT-safe sync cleanup, `--profile` auth (key never
+ * appears in `ps` output).
+ *
+ * Returns {@link MoveScriptResult}. `txHash` is guaranteed; `success`
+ * and `vmStatus` are best-effort parsed from the CLI's Result JSON.
+ *
+ * @internal — called from `Harness.runMoveScript`.
+ */
+export async function runMoveScript(
+  runtime: MovehatRuntime,
+  options: RunMoveScriptOptions
+): Promise<MoveScriptResult> {
+  const config = runtime.config;
+  const account = runtime.account;
+
+  // Synchronous validation before any CLI call.
+  if (!options.scriptPath || typeof options.scriptPath !== "string") {
+    throw new Error(
+      "Harness.runMoveScript requires options.scriptPath (string path to .move or .mv)."
+    );
+  }
+  const ext = extname(options.scriptPath).toLowerCase();
+  let scriptFlag: "--script-path" | "--compiled-script-path";
+  if (ext === ".move") {
+    scriptFlag = "--script-path";
+  } else if (ext === ".mv") {
+    scriptFlag = "--compiled-script-path";
+  } else {
+    throw new Error(
+      `Harness.runMoveScript: unsupported script extension '${ext || "<none>"}'. ` +
+        `Expected '.move' (source — CLI auto-compiles) or '.mv' (pre-compiled bytecode).`
+    );
+  }
+  if (!existsSync(options.scriptPath)) {
+    throw new Error(
+      `Harness.runMoveScript: script not found at '${options.scriptPath}'.`
+    );
+  }
+
+  const safeScriptPath = validatePathSafety(options.scriptPath, "script path");
+  const profile = `movehat-script-${randomUUID().slice(0, 8)}`;
+  const safeProfile = validateProfileSafety(profile);
+
+  logger.step(
+    `Running Move script '${options.scriptPath}' on ${config.network}...`
+  );
+
+  try {
+    const deployerAddress = account.accountAddress.toString();
+
+    let cleanPrivateKey = config.privateKey;
+    if (cleanPrivateKey.startsWith("ed25519-priv-")) {
+      cleanPrivateKey = cleanPrivateKey.replace("ed25519-priv-", "");
+    }
+
+    const movementConfigPath = join(homedir(), ".aptos", "config.yaml");
+
+    ensureSignalHandler();
+    const syncCleanup = () => removeProfileSync(movementConfigPath, profile);
+    cleanupCallbacks.add(syncCleanup);
+
+    await withYamlLock(() =>
+      addProfile(movementConfigPath, profile, {
+        private_key: cleanPrivateKey,
+        public_key: account.publicKey.toString(),
+        account: deployerAddress,
+        rest_url: config.rpc,
+      })
+    );
+
+    let scriptOut = "";
+    try {
+      const typeArgsFragment: string[] =
+        options.typeArgs && options.typeArgs.length > 0
+          ? ["--type-args", ...options.typeArgs]
+          : [];
+      const argsFragment: string[] =
+        options.args && options.args.length > 0
+          ? ["--args", ...options.args]
+          : [];
+
+      const result = await runCli(
+        {
+          command: "movement",
+          args: [
+            "move",
+            "run-script",
+            "--profile",
+            safeProfile,
+            "--url",
+            config.rpc,
+            "--assume-yes",
+            scriptFlag,
+            safeScriptPath,
+            ...typeArgsFragment,
+            ...argsFragment,
+          ],
+          timeoutMs: 120000,
+        },
+        { adapter: options.adapter }
+      );
+      scriptOut = result.stdout;
+      if (result.stdout) console.log(result.stdout.trim());
+      if (result.stderr) console.error(result.stderr.trim());
+    } finally {
+      await withYamlLock(() => removeProfile(movementConfigPath, profile)).catch(
+        (err) => {
+          const cleanupMsg = err instanceof Error ? err.message : String(err);
+          logger.warning(
+            `Failed to remove script profile "${profile}" from ${movementConfigPath}: ${cleanupMsg}. ` +
+              `Run 'movement config delete-profile --profile ${profile}' to clean up manually.`
+          );
+        }
+      );
+      cleanupCallbacks.delete(syncCleanup);
+    }
+
+    const txHash = parseTxHash(scriptOut);
+    if (!txHash) {
+      throw new Error(
+        `Could not parse transaction hash from 'move run-script' output. ` +
+          `Captured stdout:\n${scriptOut.slice(0, 1000)}`
+      );
+    }
+
+    const success = parseSuccess(scriptOut);
+    const vmStatus = parseVmStatus(scriptOut);
+
+    logger.success(`Move script executed (tx ${txHash}).`);
+
+    const out: MoveScriptResult = { txHash };
+    if (success !== undefined) out.success = success;
+    if (vmStatus !== undefined) out.vmStatus = vmStatus;
+    return out;
+  } catch (error) {
+    if (error instanceof CliExecutionError) {
+      if (error.stdoutPreview) console.log(error.stdoutPreview);
+      logger.error(`Failed to run Move script: ${error.message}\n${error.stderr}`);
+    } else {
+      const err = error instanceof Error ? error : new Error(String(error));
+      logger.error(`Failed to run Move script: ${err.message}`);
+    }
+    throw error;
+  }
+}
+
+/**
+ * Best-effort parse of the `"success": true|false` field from
+ * Movement CLI's Result JSON block. Returns `undefined` on no match.
+ */
+function parseSuccess(stdout: string): boolean | undefined {
+  const m = stdout.match(/"success"\s*:\s*(true|false)/);
+  if (!m) return undefined;
+  return m[1] === "true";
+}
+
+/**
+ * Best-effort parse of the `"vm_status"` string. Returns `undefined`
+ * on no match.
+ */
+function parseVmStatus(stdout: string): string | undefined {
+  const m = stdout.match(/"vm_status"\s*:\s*"([^"]*)"/);
+  return m?.[1];
+}

package/src/harness/view.ts

@@ -0,0 +1,34 @@
+import type { MoveFunctionId } from "@aptos-labs/ts-sdk";
+import type { MovehatRuntime } from "../types/runtime.js";
+import type { RunViewFunctionOptions } from "../types/harness.js";
+
+/**
+ * Execute a Move view function via the Aptos SDK (no CLI invocation).
+ *
+ * Returns the SDK's raw `unknown[]` — the Move boundary may return a
+ * tuple of any arity. Callers destructure:
+ *
+ * ```ts
+ * const [count] = await harness.runViewFunction({
+ *   function: "0xCAFE::counter::get",
+ *   functionArguments: ["0xdeployer"],
+ * });
+ * ```
+ *
+ * Works on all 3 harness modes (createLocal, createFork, createLive) —
+ * view functions read on-chain state without writing.
+ *
+ * @internal — called from `Harness.runViewFunction`.
+ */
+export async function runViewFunction(
+  runtime: MovehatRuntime,
+  options: RunViewFunctionOptions
+): Promise<unknown[]> {
+  return runtime.aptos.view({
+    payload: {
+      function: options.function as MoveFunctionId,
+      typeArguments: options.typeArguments ?? [],
+      functionArguments: (options.functionArguments ?? []) as never[],
+    },
+  });
+}

package/src/helpers/__tests__/semver-utils.test.ts

@@ -0,0 +1,121 @@
+import { describe, it, expect } from 'vitest';
+import { isNewerVersion } from '../semver-utils.js';
+
+describe('isNewerVersion', () => {
+  describe('standard semver comparisons', () => {
+    it('should detect newer major version', () => {
+      expect(isNewerVersion('1.0.0', '2.0.0')).toBe(true);
+      expect(isNewerVersion('0.1.0', '1.0.0')).toBe(true);
+    });
+
+    it('should detect newer minor version', () => {
+      expect(isNewerVersion('1.0.0', '1.1.0')).toBe(true);
+      expect(isNewerVersion('1.5.0', '1.6.0')).toBe(true);
+    });
+
+    it('should detect newer patch version', () => {
+      expect(isNewerVersion('1.0.0', '1.0.1')).toBe(true);
+      expect(isNewerVersion('1.0.9', '1.0.10')).toBe(true);
+    });
+
+    it('should return false for same version', () => {
+      expect(isNewerVersion('1.0.0', '1.0.0')).toBe(false);
+      expect(isNewerVersion('2.5.3', '2.5.3')).toBe(false);
+    });
+
+    it('should return false for older versions', () => {
+      expect(isNewerVersion('2.0.0', '1.0.0')).toBe(false);
+      expect(isNewerVersion('1.1.0', '1.0.0')).toBe(false);
+      expect(isNewerVersion('1.0.1', '1.0.0')).toBe(false);
+    });
+  });
+
+  describe('variable-length version handling', () => {
+    it('should handle two-part versions', () => {
+      expect(isNewerVersion('1.0', '1.1')).toBe(true);
+      expect(isNewerVersion('1.0', '2.0')).toBe(true);
+      expect(isNewerVersion('1.1', '1.0')).toBe(false);
+    });
+
+    it('should compare versions with different lengths', () => {
+      expect(isNewerVersion('1.0', '1.0.1')).toBe(true);
+      expect(isNewerVersion('1.0.0', '1.1')).toBe(true);
+      expect(isNewerVersion('1.0.1', '1.0')).toBe(false);
+    });
+
+    it('should handle four-part versions', () => {
+      expect(isNewerVersion('1.0.0.0', '1.0.0.1')).toBe(true);
+      expect(isNewerVersion('1.0.0.1', '1.0.0.0')).toBe(false);
+    });
+
+    it('should treat missing parts as zero', () => {
+      expect(isNewerVersion('1.0', '1.0.0')).toBe(false);
+      expect(isNewerVersion('1.0.0', '1.0')).toBe(false);
+    });
+  });
+
+  describe('pre-release version handling', () => {
+    it('should consider stable newer than pre-release with same base', () => {
+      expect(isNewerVersion('1.0.0-alpha', '1.0.0')).toBe(true);
+      expect(isNewerVersion('1.0.0-beta.1', '1.0.0')).toBe(true);
+      expect(isNewerVersion('1.0.0-rc.1', '1.0.0')).toBe(true);
+    });
+
+    it('should consider pre-release older than stable with same base', () => {
+      expect(isNewerVersion('1.0.0', '1.0.0-alpha')).toBe(false);
+      expect(isNewerVersion('1.0.0', '1.0.0-beta.1')).toBe(false);
+    });
+
+    it('should strip pre-release tags for base comparison', () => {
+      expect(isNewerVersion('1.0.0-alpha', '1.1.0-alpha')).toBe(true);
+      expect(isNewerVersion('1.0.0-alpha', '2.0.0-beta')).toBe(true);
+    });
+
+    it('should handle complex pre-release tags', () => {
+      expect(isNewerVersion('1.0.0-alpha.0', '1.0.0')).toBe(true);
+      expect(isNewerVersion('1.0.0-beta.2.3', '1.0.0')).toBe(true);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle large version numbers', () => {
+      expect(isNewerVersion('100.200.300', '100.200.301')).toBe(true);
+      expect(isNewerVersion('999.999.999', '1000.0.0')).toBe(true);
+    });
+
+    it('should handle version 0.x.x correctly', () => {
+      expect(isNewerVersion('0.0.1', '0.0.2')).toBe(true);
+      expect(isNewerVersion('0.1.0', '0.2.0')).toBe(true);
+      expect(isNewerVersion('0.9.9', '1.0.0')).toBe(true);
+    });
+
+    it('should throw for invalid version format', () => {
+      expect(() => isNewerVersion('invalid', '1.0.0')).toThrow('Invalid version format');
+      expect(() => isNewerVersion('1.0.0', 'invalid')).toThrow('Invalid version format');
+      expect(() => isNewerVersion('1.a.0', '1.0.0')).toThrow('Invalid version format');
+      expect(() => isNewerVersion('1..0', '1.0.0')).toThrow('Invalid version format');
+    });
+
+    it('should reject versions with unstripped "v" prefix', () => {
+      // isNewerVersion expects pre-stripped versions; callers must remove leading "v".
+      expect(() => isNewerVersion('v1.0.0', '1.0.0')).toThrow('Invalid version format');
+    });
+  });
+
+  describe('real-world scenarios', () => {
+    it('should handle npm-style version bumps', () => {
+      // Patch bump
+      expect(isNewerVersion('0.1.5', '0.1.6')).toBe(true);
+      // Minor bump
+      expect(isNewerVersion('0.1.6', '0.2.0')).toBe(true);
+      // Major bump
+      expect(isNewerVersion('0.9.9', '1.0.0')).toBe(true);
+    });
+
+    it('should handle movehat version progression', () => {
+      expect(isNewerVersion('0.0.1', '0.1.0')).toBe(true);
+      expect(isNewerVersion('0.1.0', '0.1.1')).toBe(true);
+      expect(isNewerVersion('0.1.9', '0.1.10')).toBe(true);
+    });
+  });
+});

package/src/helpers/index.ts

@@ -26,16 +26,10 @@ export { AccountManager } from "../core/AccountManager.js";
 export type { StoredAccount } from "../core/AccountManager.js";
 export { LocalNodeManager } from "../node/LocalNodeManager.js";
 export type { LocalNodeOptions, LocalNodeInfo } from "../node/LocalNodeManager.js";
-export {
-  setupLocalTesting,
-  stopLocalTesting,
-  getCurrentForkManager,
-  getCurrentLocalNode,
-  resetForkState,
-} from "./setupLocalTesting.js";
+export { setupLocalTesting } from "./setupLocalTesting.js";
+export type { LocalTestingContext } from "./setupLocalTesting.js";
 export {
   setupTestFixture,
-  teardownTestFixture,
   setupMinimalFixture,
 } from "./testFixtures.js";
 export type { TestFixture } from "./testFixtures.js";

package/src/helpers/move-tests.ts

@@ -1,12 +1,12 @@
-import { spawn } from "child_process";
 import { existsSync } from "fs";
 import { resolve } from "path";
 import { loadUserConfig } from "../core/config.js";
+import { runCli } from "../utils/runCli.js";
 
 interface RunMoveTestsOptions {
-  filter?: string;
-  ignoreWarnings?: boolean;
-  skipIfMissing?: boolean; // If true, skip gracefully when Move dir missing (for orchestrated tests)
+  filter?: string | undefined;
+  ignoreWarnings?: boolean | undefined;
+  skipIfMissing?: boolean | undefined; // If true, skip gracefully when Move dir missing (for orchestrated tests)
 }
 
 /**
@@ -44,25 +44,29 @@ export async function runMoveTests(options: RunMoveTestsOptions = {}): Promise<v
     args.push("--ignore-compile-warnings");
   }
 
-  return new Promise<void>((resolve, reject) => {
-    const child = spawn("movement", args, {
-      stdio: "inherit",
-      cwd: process.cwd(),
-    });
+  let result;
+  try {
+    result = await runCli(
+      {
+        command: "movement",
+        args,
+        cwd: process.cwd(),
+        inheritStdio: true,
+      },
+      { throwOnNonZeroExit: false }
+    );
+  } catch (error) {
+    // Spawn-time failure (ENOENT, etc.). The original code logged a
+    // Movement-CLI-install hint here; keep that.
+    console.error(`Failed to run Move tests: ${(error as Error).message}`);
+    console.error("   Make sure Movement CLI is installed");
+    throw error;
+  }
 
-    child.on("exit", (code) => {
-      if (code === 0) {
-        console.log("\n✓ Move tests passed");
-        resolve();
-      } else {
-        reject(new Error("Move tests failed"));
-      }
-    });
+  if (result.exitCode === 0) {
+    console.log("\n✓ Move tests passed");
+    return;
+  }
 
-    child.on("error", (error) => {
-      console.error(`Failed to run Move tests: ${error.message}`);
-      console.error("   Make sure Movement CLI is installed");
-      reject(error);
-    });
-  });
+  throw new Error("Move tests failed");
 }

package/src/helpers/npm-registry.ts

@@ -29,9 +29,10 @@ export async function fetchLatestVersion(
       ? setTimeout(() => controller.abort(), timeout)
       : undefined;
 
-    const response = await fetch(`https://registry.npmjs.org/${packageName}`, {
-      signal: controller?.signal,
-    });
+    const response = await fetch(
+      `https://registry.npmjs.org/${packageName}`,
+      controller ? { signal: controller.signal } : {}
+    );
 
     if (timeoutId) clearTimeout(timeoutId);
 

package/src/helpers/semver-utils.ts

@@ -4,9 +4,10 @@
  * Handles variable-length versions (1.2, 1.2.3, 1.2.3.4, etc.)
  */
 export function isNewerVersion(currentVersion: string, newVersion: string): boolean {
-  // Remove any pre-release tags (e.g., -alpha.0, -beta.1)
-  const cleanCurrent = currentVersion.split("-")[0];
-  const cleanNew = newVersion.split("-")[0];
+  // Remove any pre-release tags (e.g., -alpha.0, -beta.1).
+  // String.split always returns ≥1 element; `?? ""` is a no-op narrowing.
+  const cleanCurrent = currentVersion.split("-")[0] ?? "";
+  const cleanNew = newVersion.split("-")[0] ?? "";
 
   // Split and validate numeric parts
   const currentParts = cleanCurrent.split(".").map((part) => {

package/src/helpers/setup.ts

@@ -8,6 +8,7 @@ import {
 import { loadUserConfig, resolveNetworkConfig } from "../core/config.js";
 import { MovehatConfig } from "../types/config.js";
 import { AccountManager } from "../core/AccountManager.js";
+import { logger } from "../ui/index.js";
 
 export interface TestEnvironment {
   aptos: Aptos;
@@ -21,8 +22,10 @@ export async function setupTestEnvironment(networkName?: string): Promise<TestEn
   const network = networkName || process.env.MH_CLI_NETWORK;
   const config = await resolveNetworkConfig(userConfig, network);
 
+  // Movement Network uses custom chain IDs, so we need to use Network.CUSTOM
+  // and let the SDK fetch the actual chainId from the node
   const aptosConfig = new AptosConfig({
-    network: config.network as Network,
+    network: Network.CUSTOM,
     fullnode: config.rpc,
   });
 
@@ -31,10 +34,11 @@ export async function setupTestEnvironment(networkName?: string): Promise<TestEn
   // Load account using AccountManager
   const account = AccountManager.loadAccountFromPrivateKey(config.privateKey);
 
-  console.log(`✅ Test environment ready`);
-  console.log(`   Account: ${account.accountAddress.toString()}`);
-  console.log(`   Network: ${config.network}`);
-  console.log(`   RPC: ${config.rpc}\n`);
+  logger.success("Test environment ready");
+  logger.plain(`   Account: ${account.accountAddress.toString()}`);
+  logger.plain(`   Network: ${config.network}`);
+  logger.plain(`   RPC: ${config.rpc}`);
+  logger.newline();
 
   return {
     aptos,