movehat 0.1.8 → 0.2.0

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

@@ -0,0 +1,266 @@
+import { describe, it, expect, vi } from 'vitest';
+import { defaultChildProcessAdapter } from '../childProcessAdapter.js';
+
+const NODE = process.execPath;
+
+describe('defaultChildProcessAdapter', () => {
+  it('captures stdout and zero exit code on success', async () => {
+    const result = await defaultChildProcessAdapter.run({
+      command: NODE,
+      args: ['-e', "process.stdout.write('hello-stdout')"],
+    });
+
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toBe('hello-stdout');
+    expect(result.stderr).toBe('');
+  });
+
+  it('captures stderr separately from stdout', async () => {
+    const result = await defaultChildProcessAdapter.run({
+      command: NODE,
+      args: ['-e', "process.stderr.write('boom'); process.exit(2)"],
+    });
+
+    expect(result.exitCode).toBe(2);
+    expect(result.stdout).toBe('');
+    expect(result.stderr).toBe('boom');
+  });
+
+  it('pipes stdin to the child process', async () => {
+    const result = await defaultChildProcessAdapter.run({
+      command: NODE,
+      args: [
+        '-e',
+        "let d=''; process.stdin.on('data', c => d += c); process.stdin.on('end', () => process.stdout.write(d.toUpperCase()))",
+      ],
+      stdin: 'piped-input',
+    });
+
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toBe('PIPED-INPUT');
+  });
+
+  it('passes env to the child process', async () => {
+    const result = await defaultChildProcessAdapter.run({
+      command: NODE,
+      args: ['-e', 'process.stdout.write(process.env.MH_TEST_VAR ?? "missing")'],
+      env: { ...process.env, MH_TEST_VAR: 'present' },
+    });
+
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toBe('present');
+  });
+
+  it('rejects when the command times out', async () => {
+    await expect(
+      defaultChildProcessAdapter.run({
+        command: NODE,
+        args: ['-e', 'setTimeout(() => {}, 5000)'],
+        timeoutMs: 50,
+      })
+    ).rejects.toThrow(/timed out/);
+  });
+
+  it('aborts a running command with exitCode -1 and signal SIGTERM', async () => {
+    const controller = new AbortController();
+    const start = Date.now();
+    const promise = defaultChildProcessAdapter.run({
+      command: NODE,
+      args: ['-e', 'setTimeout(() => {}, 5000)'],
+      signal: controller.signal,
+    });
+
+    setTimeout(() => controller.abort(), 20);
+
+    const result = await promise;
+    const elapsed = Date.now() - start;
+
+    expect(result.exitCode).toBe(-1);
+    expect(result.signal).toBe('SIGTERM');
+    expect(elapsed).toBeLessThan(500);
+  });
+
+  it('rejects synchronously when signal is already aborted', async () => {
+    const controller = new AbortController();
+    controller.abort();
+
+    await expect(
+      defaultChildProcessAdapter.run({
+        command: NODE,
+        args: ['-e', "process.stdout.write('never')"],
+        signal: controller.signal,
+      })
+    ).rejects.toThrow(/aborted/);
+  });
+
+  it('rejects when the command does not exist', async () => {
+    await expect(
+      defaultChildProcessAdapter.run({
+        command: '/nonexistent/path/to/binary-xyz',
+        args: [],
+      })
+    ).rejects.toThrow();
+  });
+});
+
+describe('defaultChildProcessAdapter.spawn', () => {
+  it('returns a handle with pid and streams, and exits cleanly when the child finishes on its own', async () => {
+    const child = defaultChildProcessAdapter.spawn({
+      command: NODE,
+      args: ['-e', "process.stdout.write('hi'); process.exit(0)"],
+    });
+
+    expect(typeof child.pid).toBe('number');
+    expect(child.stdout).not.toBeNull();
+    expect(child.stderr).not.toBeNull();
+    expect(child.stdin).not.toBeNull();
+
+    let captured = '';
+    child.stdout?.on('data', (chunk: Buffer) => {
+      captured += chunk.toString('utf8');
+    });
+
+    const result = await child.exited;
+    expect(result.code).toBe(0);
+    expect(result.signal).toBeNull();
+    expect(captured).toBe('hi');
+  });
+
+  it('kill(SIGTERM) terminates a long-running child and surfaces the signal in exited', async () => {
+    const child = defaultChildProcessAdapter.spawn({
+      command: NODE,
+      args: ['-e', 'setInterval(() => {}, 1000)'],
+    });
+
+    const start = Date.now();
+    const killed = child.kill('SIGTERM');
+    expect(killed).toBe(true);
+
+    const result = await child.exited;
+    const elapsed = Date.now() - start;
+
+    expect(result.signal).toBe('SIGTERM');
+    expect(result.code).toBeNull();
+    expect(elapsed).toBeLessThan(500);
+  });
+
+  it('with stdio: ignore, exposes null streams but still resolves exited', async () => {
+    const child = defaultChildProcessAdapter.spawn({
+      command: NODE,
+      args: ['-e', "process.stdout.write('hidden'); process.exit(0)"],
+      stdio: 'ignore',
+    });
+
+    expect(child.stdout).toBeNull();
+    expect(child.stderr).toBeNull();
+    expect(child.stdin).toBeNull();
+
+    const result = await child.exited;
+    expect(result.code).toBe(0);
+  });
+
+  it('exited can be awaited more than once', async () => {
+    const child = defaultChildProcessAdapter.spawn({
+      command: NODE,
+      args: ['-e', 'process.exit(7)'],
+    });
+
+    const first = await child.exited;
+    const second = await child.exited;
+
+    expect(first.code).toBe(7);
+    expect(second.code).toBe(7);
+  });
+
+  it('exited resolves when the command does not exist (error event)', async () => {
+    // Spawning a nonexistent binary fires `error` (ENOENT), not `exit`.
+    // exited must still settle so the caller doesn't hang.
+    const child = defaultChildProcessAdapter.spawn({
+      command: '/nonexistent/path/to/binary-xyz',
+      args: [],
+    });
+
+    const result = await child.exited;
+
+    // When the OS rejects the spawn, no exit code or signal is meaningful.
+    expect(result.code).toBeNull();
+    expect(result.signal).toBeNull();
+  });
+});
+
+describe('defaultChildProcessAdapter.run with inheritStdio', () => {
+  it('returns empty stdout and stderr when inheritStdio is true', async () => {
+    // The child writes to stdout, but the parent inherits stdio so the bytes
+    // never go through the captured pipe — the adapter cannot see them.
+    const result = await defaultChildProcessAdapter.run({
+      command: NODE,
+      args: ['-e', "process.stdout.write('would-be-captured'); process.exit(0)"],
+      inheritStdio: true,
+    });
+
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toBe('');
+    expect(result.stderr).toBe('');
+  });
+
+  it('still propagates exit code under inheritStdio', async () => {
+    const result = await defaultChildProcessAdapter.run({
+      command: NODE,
+      args: ['-e', 'process.exit(42)'],
+      inheritStdio: true,
+    });
+
+    expect(result.exitCode).toBe(42);
+    expect(result.stdout).toBe('');
+    expect(result.stderr).toBe('');
+  });
+
+  it('explicit timeoutMs is still honored under inheritStdio', async () => {
+    // Positive control: the conditional-skip applies only when timeoutMs
+    // is omitted. An explicit value forces the timer back on.
+    await expect(
+      defaultChildProcessAdapter.run({
+        command: NODE,
+        args: ['-e', 'setTimeout(() => {}, 5000)'],
+        inheritStdio: true,
+        timeoutMs: 50,
+      })
+    ).rejects.toThrow(/timed out after 50ms/);
+  });
+
+  it('omits the default timeout when inheritStdio is true (short child completes naturally)', async () => {
+    // We can't wait 5 minutes to prove the default timeout isn't set, but
+    // we can prove that a child running with inheritStdio:true and no
+    // explicit timeoutMs completes via the natural exit path with no
+    // timeout-derived rejection. Combined with the test above, the
+    // conditional-skip behavior is pinned in both directions.
+    const result = await defaultChildProcessAdapter.run({
+      command: NODE,
+      args: ['-e', "setTimeout(() => process.exit(0), 50)"],
+      inheritStdio: true,
+    });
+    expect(result.exitCode).toBe(0);
+  });
+
+  it('does not schedule a setTimeout when inheritStdio is true and timeoutMs is omitted', async () => {
+    // Direct evidence (review follow-up): spy on globalThis.setTimeout and
+    // assert no timer scheduled with the DEFAULT_TIMEOUT_MS (300000ms) value.
+    // Short-running children may legitimately schedule small timers via
+    // their own logic, so we filter the spy calls to the default-timeout
+    // duration specifically — that's the value the regression repaired.
+    const setTimeoutSpy = vi.spyOn(globalThis, 'setTimeout');
+    try {
+      await defaultChildProcessAdapter.run({
+        command: NODE,
+        args: ['-e', 'process.exit(0)'],
+        inheritStdio: true,
+      });
+      const defaultTimeoutCalls = setTimeoutSpy.mock.calls.filter(
+        (args) => args[1] === 5 * 60 * 1000
+      );
+      expect(defaultTimeoutCalls).toHaveLength(0);
+    } finally {
+      setTimeoutSpy.mockRestore();
+    }
+  });
+});

package/src/utils/__tests__/runCli.test.ts

@@ -0,0 +1,240 @@
+import { describe, it, expect } from 'vitest';
+import { CliExecutionError } from '../../errors.js';
+import type {
+  ChildProcessAdapter,
+  RunInput,
+  RunResult,
+} from '../childProcessAdapter.js';
+import { redactSecrets, runCli } from '../runCli.js';
+
+function makeAdapter(result: RunResult, capture?: { last?: RunInput }): ChildProcessAdapter {
+  return {
+    async run(input) {
+      if (capture) capture.last = input;
+      return result;
+    },
+    spawn() {
+      throw new Error('spawn not used in runCli tests');
+    },
+  };
+}
+
+describe('redactSecrets', () => {
+  it('replaces ed25519-priv-0x… literals', () => {
+    const key = '0x' + 'a'.repeat(64);
+    const input = `Loaded key ed25519-priv-${key} ok`;
+    expect(redactSecrets(input)).toBe('Loaded key ***REDACTED*** ok');
+  });
+
+  it('redacts private_key labelled values', () => {
+    const input = 'private_key: 0x' + 'b'.repeat(64);
+    expect(redactSecrets(input)).toBe('***REDACTED***');
+  });
+
+  it('redacts priv-key labelled values with hyphen variants', () => {
+    const input = 'priv-key = 0x' + 'c'.repeat(64);
+    expect(redactSecrets(input)).toBe('***REDACTED***');
+  });
+
+  it('leaves regular hex addresses alone', () => {
+    const input = 'Account 0x1234 deployed module counter';
+    expect(redactSecrets(input)).toBe(input);
+  });
+
+  it('is a no-op on empty input', () => {
+    expect(redactSecrets('')).toBe('');
+  });
+});
+
+describe('runCli', () => {
+  it('returns redacted stdout and stderr on success', async () => {
+    const key = 'ed25519-priv-0x' + 'a'.repeat(64);
+    const adapter = makeAdapter({
+      exitCode: 0,
+      stdout: `ok ${key}`,
+      stderr: '',
+    });
+
+    const result = await runCli({ command: 'fake', args: [] }, { adapter });
+
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toBe('ok ***REDACTED***');
+    expect(result.stderr).toBe('');
+  });
+
+  it('throws CliExecutionError with redacted stderr on non-zero exit', async () => {
+    const adapter = makeAdapter({
+      exitCode: 1,
+      stdout: '',
+      stderr: 'boom private_key: 0x' + 'd'.repeat(64),
+    });
+
+    await expect(
+      runCli({ command: 'movement', args: ['publish'] }, { adapter })
+    ).rejects.toMatchObject({
+      name: 'CliExecutionError',
+      command: 'movement',
+      exitCode: 1,
+    });
+
+    try {
+      await runCli({ command: 'movement', args: ['publish'] }, { adapter });
+    } catch (e) {
+      expect(e).toBeInstanceOf(CliExecutionError);
+      const err = e as CliExecutionError;
+      expect(err.stderr).toBe('boom ***REDACTED***');
+      expect(err.stderr).not.toContain('private_key');
+      expect(err.args).toEqual(['publish']);
+    }
+  });
+
+  it('does not throw on non-zero exit when throwOnNonZeroExit is false', async () => {
+    const adapter = makeAdapter({
+      exitCode: 2,
+      stdout: 'partial',
+      stderr: 'warn',
+    });
+
+    const result = await runCli(
+      { command: 'fake', args: [] },
+      { adapter, throwOnNonZeroExit: false }
+    );
+
+    expect(result.exitCode).toBe(2);
+    expect(result.stdout).toBe('partial');
+    expect(result.stderr).toBe('warn');
+  });
+
+  it('passes the input through to the adapter unchanged', async () => {
+    const capture: { last?: RunInput } = {};
+    const adapter = makeAdapter({ exitCode: 0, stdout: '', stderr: '' }, capture);
+    const env = { FOO: 'bar' };
+    const signal = new AbortController().signal;
+
+    await runCli(
+      {
+        command: 'movement',
+        args: ['move', 'build'],
+        cwd: '/tmp/pkg',
+        env,
+        stdin: 'hello',
+        timeoutMs: 1234,
+        signal,
+      },
+      { adapter }
+    );
+
+    expect(capture.last).toEqual({
+      command: 'movement',
+      args: ['move', 'build'],
+      cwd: '/tmp/pkg',
+      env,
+      stdin: 'hello',
+      timeoutMs: 1234,
+      signal,
+    });
+  });
+
+  it('truncates stdoutPreview on CliExecutionError', async () => {
+    const longStdout = 'x'.repeat(5000);
+    const adapter = makeAdapter({
+      exitCode: 1,
+      stdout: longStdout,
+      stderr: '',
+    });
+
+    try {
+      await runCli({ command: 'fake', args: [] }, { adapter });
+      expect.fail('should have thrown');
+    } catch (e) {
+      const err = e as CliExecutionError;
+      expect(err.stdoutPreview.length).toBe(2000);
+    }
+  });
+
+  it('redacts secret-shaped args inside CliExecutionError.args', async () => {
+    const key = 'ed25519-priv-0x' + 'a'.repeat(64);
+    const adapter = makeAdapter({ exitCode: 1, stdout: '', stderr: '' });
+
+    try {
+      await runCli(
+        { command: 'movement', args: ['publish', '--private-key', key] },
+        { adapter }
+      );
+      expect.fail('should have thrown');
+    } catch (e) {
+      const err = e as CliExecutionError;
+      expect(err.args[0]).toBe('publish');
+      expect(err.args[1]).toBe('--private-key');
+      expect(err.args[2]).toBe('***REDACTED***');
+    }
+  });
+
+  it('preserves non-secret args unchanged', async () => {
+    const adapter = makeAdapter({ exitCode: 1, stdout: '', stderr: '' });
+    const args = ['move', 'publish', '--package-dir', '/tmp/pkg'];
+
+    try {
+      await runCli({ command: 'movement', args }, { adapter });
+      expect.fail('should have thrown');
+    } catch (e) {
+      const err = e as CliExecutionError;
+      expect(Array.from(err.args)).toEqual(args);
+    }
+  });
+
+  it('forwards inheritStdio flag to the adapter unchanged', async () => {
+    const capture: { last?: RunInput } = {};
+    const adapter = makeAdapter(
+      { exitCode: 0, stdout: '', stderr: '' },
+      capture
+    );
+
+    await runCli(
+      { command: 'mocha', args: ['--watch'], inheritStdio: true },
+      { adapter }
+    );
+
+    expect(capture.last?.inheritStdio).toBe(true);
+  });
+
+  it('propagates AbortSignal to a slow adapter and returns the killed result', async () => {
+    const slowAdapter: ChildProcessAdapter = {
+      run(input) {
+        return new Promise((resolve) => {
+          const t = setTimeout(
+            () => resolve({ exitCode: 0, stdout: '', stderr: '' }),
+            5000
+          );
+          input.signal?.addEventListener('abort', () => {
+            clearTimeout(t);
+            resolve({
+              exitCode: -1,
+              stdout: '',
+              stderr: '',
+              signal: 'SIGTERM',
+            });
+          });
+        });
+      },
+      spawn() {
+        throw new Error('spawn not used in this test');
+      },
+    };
+
+    const controller = new AbortController();
+    const start = Date.now();
+    const promise = runCli(
+      { command: 'movement', args: ['move', 'test'], signal: controller.signal },
+      { adapter: slowAdapter, throwOnNonZeroExit: false }
+    );
+    setTimeout(() => controller.abort(), 20);
+
+    const result = await promise;
+    const elapsed = Date.now() - start;
+
+    expect(result.exitCode).toBe(-1);
+    expect(result.signal).toBe('SIGTERM');
+    expect(elapsed).toBeLessThan(500);
+  });
+});

package/src/utils/address.ts

@@ -0,0 +1,56 @@
+/**
+ * Address normalization helpers shared across the fork code.
+ *
+ * Two normalization variants live in production today and are preserved here
+ * with identical semantics so the in-place migration in M1.2 is behavior-
+ * preserving:
+ *
+ *   - `normalizeAddress`      → lowercase + `0x` + left-pad to 64 hex chars.
+ *                                Used by `fork/manager.ts` for storage keys.
+ *   - `normalizeAddressShort` → lowercase + `0x`, no padding.
+ *                                Used by `fork/api.ts` for HTTP paths.
+ */
+
+/**
+ * Lowercase the input, ensure a `0x` prefix, and left-pad the hex tail to
+ * 64 characters (66 total). Already-padded inputs are returned unchanged
+ * (apart from case folding).
+ *
+ * No validation: callers that need to reject non-hex input should consult
+ * `isHexAddress` first.
+ */
+export function normalizeAddress(input: string): string {
+  let normalized = input.toLowerCase();
+
+  if (!normalized.startsWith('0x')) {
+    normalized = `0x${normalized}`;
+  }
+
+  if (normalized.length < 66) {
+    normalized = '0x' + normalized.slice(2).padStart(64, '0');
+  }
+
+  return normalized;
+}
+
+/**
+ * Lowercase the input and ensure a `0x` prefix. Length is preserved — no
+ * padding is applied. Suitable for callers that pass addresses straight to
+ * an HTTP endpoint that accepts short forms.
+ */
+export function normalizeAddressShort(input: string): string {
+  const lower = input.toLowerCase();
+  return lower.startsWith('0x') ? lower : `0x${lower}`;
+}
+
+/**
+ * Returns true when the input is a syntactically valid hex address: optional
+ * `0x` prefix followed by 1 to 64 hex characters (case insensitive).
+ */
+export function isHexAddress(input: string): boolean {
+  const stripped = input.startsWith('0x') || input.startsWith('0X')
+    ? input.slice(2)
+    : input;
+  if (stripped.length === 0 || stripped.length > 64) return false;
+  return /^[0-9a-fA-F]+$/.test(stripped);
+}