movehat 0.2.1 → 0.2.2

package/src/node/__tests__/LocalNodeManager.test.ts

@@ -126,17 +126,18 @@ describe("LocalNodeManager — start / stop / lifecycle", () => {
     expect(info.testDir).toBe(tmpDir);
   });
 
-  it("honors custom ports from constructor options", () => {
+  it("honors custom faucet/ready ports; apiPort is pinned to 8080 (see F9)", () => {
     const { adapter } = buildFakeAdapter();
     const mgr = new LocalNodeManager({
       adapter,
       testDir: tmpDir,
-      apiPort: 9000,
       faucetPort: 9001,
       readyPort: 9002,
     });
     const info = mgr.getNodeInfo();
-    expect(info.rpcUrl).toContain(":9000");
+    // Movement CLI does not accept a flag for the REST API port; see
+    // LocalNodeManager.api-port.test.ts for the F9 contract.
+    expect(info.rpcUrl).toBe("http://127.0.0.1:8080");
     expect(info.faucetUrl).toContain(":9001");
     expect(info.readyUrl).toContain(":9002");
   });

package/src/templates/move/Move.toml

@@ -1,5 +1,5 @@
 [package]
-name = "{{projectName}}"
+name = "{{movePackageName}}"
 version = "1.0.0"
 authors = []
 

package/src/templates/move/sources/Counter.move

@@ -33,7 +33,16 @@ module counter::counter {
 
     public entry fun increment(account: &signer) acquires Counter {
         let account_addr = signer::address_of(account);
-        assert!(exists<Counter>(account_addr), E_NOT_INITIALIZED);
+
+        // Auto-init: create Counter if it doesn't exist yet. Defense in
+        // depth so the module stays usable even if a caller skips the
+        // dedicated `init` entry function.
+        if (!exists<Counter>(account_addr)) {
+            move_to(account, Counter {
+                value: 0,
+                increment_events: account::new_event_handle<IncrementEvent>(account),
+            });
+        };
 
         let counter = borrow_global_mut<Counter>(account_addr);
         let old_value = counter.value;
@@ -56,14 +65,32 @@ module counter::counter {
     public fun test_increment(account: &signer) acquires Counter {
         let addr = signer::address_of(account);
         aptos_framework::account::create_account_for_test(addr);
-        
+
         init(account);
         assert!(get(addr) == 0, 0);
-        
+
         increment(account);
         assert!(get(addr) == 1, 1);
-        
+
         increment(account);
         assert!(get(addr) == 2, 2);
     }
+
+    // Regression guard: increment must auto-create the Counter resource
+    // when called against a never-initialized account. Locks the
+    // defense-in-depth behavior so a future refactor can't accidentally
+    // remove it.
+    #[test(account = @0x2)]
+    public fun test_increment_auto_inits(account: &signer) acquires Counter {
+        let addr = signer::address_of(account);
+        aptos_framework::account::create_account_for_test(addr);
+
+        // Skip init entirely — increment must create the resource.
+        increment(account);
+        assert!(get(addr) == 1, 0);
+
+        // Idempotent: a second increment uses the now-existing resource.
+        increment(account);
+        assert!(get(addr) == 2, 1);
+    }
 }

package/src/templates/scripts/deploy-counter.ts

@@ -31,6 +31,16 @@ async function main() {
     // Interact with the freshly deployed module via the runtime helper.
     const counter = harness.runtime.getContract(deployment.address, "counter");
 
+    // Counter is a Move resource — it must be created explicitly per
+    // account before any method that reads or mutates it. The dedicated
+    // `init` entry function does this once per signer. (The module also
+    // auto-inits inside `increment` as defense in depth, so this call is
+    // technically optional today, but kept for pedagogy: real-world Move
+    // modules usually require an explicit init step.)
+    console.log("\n🔧 Initializing counter resource for this account...");
+    const initTx = await counter.call(harness.runtime.account, "init", []);
+    console.log(`   Init tx: ${initTx.hash}`);
+
     console.log("\n📝 Incrementing counter...");
     const txResult = await counter.call(harness.runtime.account, "increment", []);
     console.log(`✅ Transaction hash: ${txResult.hash}`);

package/src/types/config.ts

@@ -55,7 +55,14 @@ export interface LocalTestOptions {
     nodeSilent?: boolean;               // Suppress node output (default: false)
 
     // Fork options (when mode='fork')
-    forkNetwork?: 'testnet' | string;   // Network to fork from (default: 'testnet')
+    forkNetwork?: 'testnet' | 'mainnet' | string;   // Network to fork from (default: 'testnet')
+    /**
+     * RPC URL override used when forking a non-built-in network.
+     * Required when `forkNetwork` is not one of the built-in names
+     * (`'testnet'`, `'mainnet'`). Ignored when a fork already exists
+     * on disk (the saved metadata's nodeUrl is reused).
+     */
+    forkRpcUrl?: string;
     forkName?: string;                  // Name for the fork (default: 'test-local')
     forkPort?: number;                  // Fork server port (default: 8080)
     forkResetState?: boolean;           // Clear fork state before tests (default: true)

package/src/utils/__tests__/childProcessAdapter.maxBuffer.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, it } from "vitest";
+import { defaultChildProcessAdapter } from "../childProcessAdapter.js";
+
+/**
+ * F4 — `run()` must reject when child output exceeds `maxBuffer`.
+ *
+ * Without this cap, the stdout/stderr Buffer arrays in
+ * DefaultChildProcessAdapter grow without limit. A buggy or hostile
+ * subprocess can OOM the parent process. F4 adds an opt-in byte cap
+ * with kill-on-overflow semantics.
+ */
+
+const NODE = process.execPath;
+
+describe("F4 — ChildProcessAdapter.run maxBuffer", () => {
+  it("rejects with a maxBuffer error when stdout exceeds the cap", async () => {
+    // 8KiB of output, cap at 1KiB → must abort.
+    const script = `process.stdout.write('x'.repeat(8 * 1024)); setTimeout(() => {}, 30000);`;
+    await expect(
+      defaultChildProcessAdapter.run({
+        command: NODE,
+        args: ["-e", script],
+        maxBuffer: 1024,
+        timeoutMs: 10_000,
+      })
+    ).rejects.toThrow(/maxBuffer|exceeded/i);
+  });
+
+  it("rejects with a maxBuffer error when stderr exceeds the cap", async () => {
+    const script = `process.stderr.write('y'.repeat(8 * 1024)); setTimeout(() => {}, 30000);`;
+    await expect(
+      defaultChildProcessAdapter.run({
+        command: NODE,
+        args: ["-e", script],
+        maxBuffer: 1024,
+        timeoutMs: 10_000,
+      })
+    ).rejects.toThrow(/maxBuffer|exceeded/i);
+  });
+
+  it("does NOT throw when output stays under the cap", async () => {
+    const script = `process.stdout.write('ok'); process.exit(0);`;
+    const result = await defaultChildProcessAdapter.run({
+      command: NODE,
+      args: ["-e", script],
+      maxBuffer: 1024,
+    });
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toBe("ok");
+  });
+});

package/src/utils/childProcessAdapter.ts

@@ -38,8 +38,17 @@ export interface RunInput {
    * Default: `false`.
    */
   inheritStdio?: boolean;
+  /**
+   * Maximum combined bytes (stdout + stderr) the captured Buffers may
+   * grow to before the child is killed and the promise rejects. Defaults
+   * to 64 MiB. Set to `Infinity` to disable. Ignored when
+   * `inheritStdio` is `true` (no buffering happens).
+   */
+  maxBuffer?: number;
 }
 
+const DEFAULT_MAX_BUFFER = 64 * 1024 * 1024;
+
 export interface RunResult {
   /**
    * Numeric exit code from the child. `-1` when the child was terminated by
@@ -114,10 +123,31 @@ class DefaultChildProcessAdapter implements ChildProcessAdapter {
 
       const stdoutChunks: Buffer[] = [];
       const stderrChunks: Buffer[] = [];
+      let totalBytes = 0;
+      let overflowed = false;
+      const maxBuffer = input.maxBuffer ?? DEFAULT_MAX_BUFFER;
+
+      const onChunk = (chunks: Buffer[]) => (chunk: Buffer) => {
+        if (overflowed) return;
+        totalBytes += chunk.length;
+        if (totalBytes > maxBuffer) {
+          overflowed = true;
+          clearTimer();
+          input.signal?.removeEventListener('abort', onAbort);
+          child.kill('SIGTERM');
+          reject(
+            new Error(
+              `Command output exceeded maxBuffer (${maxBuffer} bytes): ${input.command}`
+            )
+          );
+          return;
+        }
+        chunks.push(chunk);
+      };
 
       // Streams are null when stdio is 'inherit'; the `?.` covers that.
-      child.stdout?.on('data', (chunk: Buffer) => stdoutChunks.push(chunk));
-      child.stderr?.on('data', (chunk: Buffer) => stderrChunks.push(chunk));
+      child.stdout?.on('data', onChunk(stdoutChunks));
+      child.stderr?.on('data', onChunk(stderrChunks));
 
       let timeoutHandle: NodeJS.Timeout | undefined;
       const clearTimer = () => {