movehat 0.1.8 → 0.2.0

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

@@ -0,0 +1,247 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { vol, fs as memfsFs } from 'memfs';
+
+// Mock fs module
+vi.mock('fs', () => ({
+  default: memfsFs,
+  ...memfsFs,
+}));
+
+// Import after mock
+const {
+  validateSafeName,
+  saveDeployment,
+  loadDeployment,
+  getAllDeployments,
+  getDeployedAddress,
+} = await import('../deployments.js');
+
+describe('validateSafeName', () => {
+  it('should accept valid names', () => {
+    expect(() => validateSafeName('testnet', 'network')).not.toThrow();
+    expect(() => validateSafeName('counter', 'module')).not.toThrow();
+    expect(() => validateSafeName('my-module', 'module')).not.toThrow();
+    expect(() => validateSafeName('module_v2', 'module')).not.toThrow();
+    expect(() => validateSafeName('Module123', 'module')).not.toThrow();
+  });
+
+  it('should reject path traversal attempts', () => {
+    expect(() => validateSafeName('../etc/passwd', 'network')).toThrow('Path traversal');
+    expect(() => validateSafeName('..\\windows', 'network')).toThrow('Path traversal');
+    expect(() => validateSafeName('foo/../bar', 'module')).toThrow('Path traversal');
+  });
+
+  it('should reject slashes', () => {
+    expect(() => validateSafeName('path/to/file', 'network')).toThrow('Path traversal');
+    expect(() => validateSafeName('path\\to\\file', 'network')).toThrow('Path traversal');
+  });
+
+  it('should reject special characters', () => {
+    expect(() => validateSafeName('test;rm', 'module')).toThrow('Only alphanumeric');
+    expect(() => validateSafeName('test$var', 'module')).toThrow('Only alphanumeric');
+    expect(() => validateSafeName('test space', 'module')).toThrow('Only alphanumeric');
+    expect(() => validateSafeName('test.module', 'module')).toThrow('Only alphanumeric');
+  });
+
+  it('should reject hidden files (starting with dot)', () => {
+    expect(() => validateSafeName('.hidden', 'network')).toThrow('cannot start with a dot');
+    expect(() => validateSafeName('.gitignore', 'module')).toThrow('cannot start with a dot');
+  });
+
+  it('should reject empty strings', () => {
+    expect(() => validateSafeName('', 'network')).toThrow('must be a non-empty string');
+  });
+
+  it('should reject non-string input', () => {
+    expect(() => validateSafeName(null as any, 'network')).toThrow('must be a non-empty string');
+    expect(() => validateSafeName(undefined as any, 'module')).toThrow('must be a non-empty string');
+  });
+
+  it('should use correct type in error messages', () => {
+    expect(() => validateSafeName('bad name', 'network')).toThrow('Invalid network name');
+    expect(() => validateSafeName('bad name', 'module')).toThrow('Invalid module name');
+  });
+});
+
+describe('saveDeployment and loadDeployment', () => {
+  beforeEach(() => {
+    vol.reset();
+    // Create initial directory structure
+    vol.fromJSON({
+      '/project/.gitkeep': '',
+    });
+    // Mock process.cwd
+    vi.spyOn(process, 'cwd').mockReturnValue('/project');
+  });
+
+  afterEach(() => {
+    vol.reset();
+    vi.restoreAllMocks();
+  });
+
+  it('should save and load deployment', () => {
+    const deployment = {
+      address: '0x1234',
+      moduleName: 'counter',
+      network: 'testnet',
+      deployer: '0xabcd',
+      timestamp: 1704985623564,
+      txHash: '0x5678',
+    };
+
+    // Mock console.log to suppress output
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    saveDeployment(deployment);
+
+    const loaded = loadDeployment('testnet', 'counter');
+    expect(loaded).toEqual(deployment);
+  });
+
+  it('should return null for non-existent deployment', () => {
+    const loaded = loadDeployment('testnet', 'nonexistent');
+    expect(loaded).toBeNull();
+  });
+
+  it('should create directories if they do not exist', () => {
+    const deployment = {
+      address: '0x1234',
+      moduleName: 'token',
+      network: 'mainnet',
+      deployer: '0xabcd',
+      timestamp: Date.now(),
+    };
+
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    saveDeployment(deployment);
+
+    expect(vol.existsSync('/project/deployments')).toBe(true);
+    expect(vol.existsSync('/project/deployments/mainnet')).toBe(true);
+  });
+
+  it('should reject invalid network names when saving', () => {
+    const deployment = {
+      address: '0x1234',
+      moduleName: 'counter',
+      network: '../etc',
+      deployer: '0xabcd',
+      timestamp: Date.now(),
+    };
+
+    expect(() => saveDeployment(deployment)).toThrow('Path traversal');
+  });
+
+  it('should reject invalid module names when saving', () => {
+    const deployment = {
+      address: '0x1234',
+      moduleName: 'counter;rm -rf',
+      network: 'testnet',
+      deployer: '0xabcd',
+      timestamp: Date.now(),
+    };
+
+    expect(() => saveDeployment(deployment)).toThrow('Only alphanumeric');
+  });
+});
+
+describe('getAllDeployments', () => {
+  beforeEach(() => {
+    vol.reset();
+    vi.spyOn(process, 'cwd').mockReturnValue('/project');
+  });
+
+  afterEach(() => {
+    vol.reset();
+    vi.restoreAllMocks();
+  });
+
+  it('should return empty object for non-existent network', () => {
+    vol.fromJSON({
+      '/project/.gitkeep': '',
+    });
+
+    const deployments = getAllDeployments('nonexistent');
+    expect(deployments).toEqual({});
+  });
+
+  it('should return all deployments for a network', () => {
+    vol.fromJSON({
+      '/project/deployments/testnet/counter.json': JSON.stringify({
+        address: '0x1',
+        moduleName: 'counter',
+        network: 'testnet',
+        deployer: '0xd1',
+        timestamp: 1000,
+      }),
+      '/project/deployments/testnet/token.json': JSON.stringify({
+        address: '0x2',
+        moduleName: 'token',
+        network: 'testnet',
+        deployer: '0xd2',
+        timestamp: 2000,
+      }),
+    });
+
+    const deployments = getAllDeployments('testnet');
+
+    expect(Object.keys(deployments)).toHaveLength(2);
+    expect(deployments['counter']?.address).toBe('0x1');
+    expect(deployments['token']?.address).toBe('0x2');
+  });
+
+  it('should ignore non-JSON files', () => {
+    vol.fromJSON({
+      '/project/deployments/testnet/counter.json': JSON.stringify({
+        address: '0x1',
+        moduleName: 'counter',
+        network: 'testnet',
+        deployer: '0xd1',
+        timestamp: 1000,
+      }),
+      '/project/deployments/testnet/README.md': '# Readme',
+      '/project/deployments/testnet/.gitkeep': '',
+    });
+
+    const deployments = getAllDeployments('testnet');
+
+    expect(Object.keys(deployments)).toHaveLength(1);
+    expect(deployments['counter']).toBeDefined();
+  });
+});
+
+describe('getDeployedAddress', () => {
+  beforeEach(() => {
+    vol.reset();
+    vi.spyOn(process, 'cwd').mockReturnValue('/project');
+  });
+
+  afterEach(() => {
+    vol.reset();
+    vi.restoreAllMocks();
+  });
+
+  it('should return address for existing deployment', () => {
+    vol.fromJSON({
+      '/project/deployments/testnet/counter.json': JSON.stringify({
+        address: '0x1234abcd',
+        moduleName: 'counter',
+        network: 'testnet',
+        deployer: '0xd1',
+        timestamp: 1000,
+      }),
+    });
+
+    const address = getDeployedAddress('testnet', 'counter');
+    expect(address).toBe('0x1234abcd');
+  });
+
+  it('should return null for non-existent deployment', () => {
+    vol.fromJSON({
+      '/project/.gitkeep': '',
+    });
+
+    const address = getDeployedAddress('testnet', 'nonexistent');
+    expect(address).toBeNull();
+  });
+});

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

@@ -0,0 +1,138 @@
+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,11 +1,33 @@
 import { pathToFileURL } from "url";
 import { join } from "path";
-import { existsSync } from "fs";
+import { existsSync, statSync } from "fs";
+import { Account, Ed25519PrivateKey } from "@aptos-labs/ts-sdk";
 import { MovehatConfig, MovehatUserConfig } from "../types/config.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.js from the current working directory.
- * 
+ * 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.
@@ -13,7 +35,6 @@ import { MovehatConfig, MovehatUserConfig } from "../types/config.js";
 export async function loadUserConfig(): Promise<MovehatUserConfig> {
   const cwd = process.cwd();
 
-  // Try to find config file (.ts first, then .js)
   const possiblePaths = [
     join(cwd, "movehat.config.ts"),
     join(cwd, "movehat.config.js"),
@@ -34,41 +55,56 @@ export async function loadUserConfig(): Promise<MovehatUserConfig> {
   }
 
   try {
+    const { mtimeMs } = statSync(configPath);
+
+    const cached = configCache.get(configPath);
+    if (cached && cached.mtimeMs === mtimeMs) {
+      return cached.config;
+    }
+
     let configModule;
 
     if (configPath.endsWith('.ts')) {
-      // For TypeScript files, we need to use tsx's import system
-      // Register tsx loader for .ts files
       const { register } = await import('tsx/esm/api');
       const unregister = register();
 
       try {
         const configUrl = pathToFileURL(configPath).href;
-        configModule = await import(configUrl + '?t=' + Date.now());
+        configModule = await import(configUrl + '?mtime=' + mtimeMs);
       } finally {
         unregister();
       }
     } else {
-      // For .js files, use standard import
       const configUrl = pathToFileURL(configPath).href;
-      configModule = await import(configUrl + '?t=' + Date.now());
+      configModule = await import(configUrl + '?mtime=' + mtimeMs);
     }
 
     const userConfig = configModule.default as MovehatUserConfig;
 
-    // Validate that networks are defined
     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
@@ -178,18 +214,66 @@ export async function resolveNetworkConfig(
     ...(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: accounts[0],
+    privateKey: primaryKey,
     allAccounts: accounts,
     profile: networkConfig.profile || "default",
     moveDir: userConfig.moveDir || "./move",
-    account: "", // Will be derived from privateKey in runtime
+    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 {
+    const stripped = privateKeyHex.startsWith("ed25519-priv-")
+      ? privateKeyHex.slice("ed25519-priv-".length)
+      : privateKeyHex;
+    const account = Account.fromPrivateKey({
+      privateKey: new Ed25519PrivateKey(stripped),
+    });
+    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.
+    console.warn(
+      `[movehat] 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

@@ -4,6 +4,7 @@ import {
   type InputViewFunctionData,
   type MoveFunctionId,
 } from "@aptos-labs/ts-sdk";
+import { logger } from "../ui/index.js";
 
 export interface TransactionResult {
   hash: string;
@@ -21,12 +22,17 @@ export class MoveContract {
   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}`;
 
-    console.log(`📝 Calling ${functionFullName}...`);
+    logger.step(`Calling ${functionFullName}...`);
 
     const transaction = await this.aptos.transaction.build.simple({
       sender: signer.accountAddress,
@@ -51,9 +57,10 @@ export class MoveContract {
       transactionHash: committedTxn.hash,
     });
 
-    console.log(
-      `✅ Transaction ${committedTxn.hash} committed with status: ${response.vm_status}\n`
+    logger.success(
+      `Transaction ${committedTxn.hash} committed with status: ${response.vm_status}`
     );
+    logger.newline();
 
     return {
       hash: committedTxn.hash,
@@ -62,8 +69,10 @@ export class MoveContract {
     };
   }
 
-  async view<T = any>(
+  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> {

package/src/core/deployments.ts

@@ -1,5 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "fs";
 import { join } from "path";
+import { logger } from "../ui/index.js";
 
 export interface DeploymentInfo {
   address: string;
@@ -7,8 +8,8 @@ export interface DeploymentInfo {
   network: string;
   deployer: string;
   timestamp: number;
-  txHash?: string;
-  blockNumber?: string;
+  txHash?: string | undefined;
+  blockNumber?: string | undefined;
 }
 
 /**
@@ -30,20 +31,21 @@ export function validateSafeName(name: string, type: "network" | "module"): void
     );
   }
 
-  // Only allow alphanumeric, hyphens, underscores
-  const safePattern = /^[a-zA-Z0-9_-]+$/;
-  if (!safePattern.test(name)) {
+  // Reject hidden-file names first so the error message is specific
+  // (otherwise the alphanumeric check below would fire generically).
+  if (name.startsWith(".")) {
     throw new Error(
       `Invalid ${type} name: "${name}"\n` +
-      `Only alphanumeric characters, hyphens (-), and underscores (_) are allowed.`
+      `Names cannot start with a dot (.) to prevent hidden file creation.`
     );
   }
 
-  // Additional check: prevent starting with dot (hidden files)
-  if (name.startsWith(".")) {
+  // Only allow alphanumeric, hyphens, underscores
+  const safePattern = /^[a-zA-Z0-9_-]+$/;
+  if (!safePattern.test(name)) {
     throw new Error(
       `Invalid ${type} name: "${name}"\n` +
-      `Names cannot start with a dot (.) to prevent hidden file creation.`
+      `Only alphanumeric characters, hyphens (-), and underscores (_) are allowed.`
     );
   }
 }
@@ -89,8 +91,8 @@ export function saveDeployment(deployment: DeploymentInfo): void {
 
   try {
     writeFileSync(filePath, JSON.stringify(deployment, null, 2), "utf-8");
-    console.log(
-      `💾 Deployment saved: deployments/${deployment.network}/${deployment.moduleName}.json`
+    logger.success(
+      `Deployment saved: deployments/${deployment.network}/${deployment.moduleName}.json`
     );
   } catch (error) {
     console.error(