movehat 0.2.3 → 0.2.5

package/src/__tests__/harness/script.test.ts

@@ -1,245 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-
-import { Harness } from "../../harness/index.js";
-import { CliExecutionError } from "../../errors.js";
-import type {
-  ChildProcessAdapter,
-  RunInput,
-  RunResult,
-} from "../../utils/childProcessAdapter.js";
-import { setupHarnessTestFixture, type HarnessTestFixture } from "./_fixture.js";
-
-describe("Harness.runMoveScript", () => {
-  let fixture: HarnessTestFixture;
-
-  const TX_HASH =
-    "0x9999999999999999999999999999999999999999999999999999999999999999";
-
-  beforeEach(() => {
-    fixture = setupHarnessTestFixture({ withTmpHome: true });
-  });
-
-  afterEach(() => {
-    fixture.teardown();
-  });
-
-  function makeAdapter(result: RunResult): {
-    adapter: ChildProcessAdapter;
-    calls: RunInput[];
-  } {
-    const calls: RunInput[] = [];
-    const adapter: ChildProcessAdapter = {
-      async run(input) {
-        calls.push(input);
-        if (input.args[1] === "run-script") return result;
-        throw new Error(`unexpected movement subcommand: ${input.args[1]}`);
-      },
-      spawn() {
-        throw new Error("spawn not used in script tests");
-      },
-    };
-    return { adapter, calls };
-  }
-
-  function successStdout(): string {
-    return [
-      `transaction hash: ${TX_HASH}`,
-      '{ "Result": { "success": true, "vm_status": "Executed successfully" } }',
-    ].join("\n");
-  }
-
-  it("happy path with .move source: uses --script-path and returns parsed MoveScriptResult", async () => {
-    const scriptPath = join(fixture.tmpCwd, "scripts", "init.move");
-    mkdirSync(join(fixture.tmpCwd, "scripts"), { recursive: true });
-    writeFileSync(scriptPath, "// dummy move script\n");
-
-    const { adapter, calls } = makeAdapter({
-      exitCode: 0,
-      stdout: successStdout(),
-      stderr: "",
-    });
-
-    const harness = await Harness.createLive("testnet");
-    try {
-      const result = await harness.runMoveScript({
-        scriptPath,
-        args: ["u64:42", "bool:true"],
-        typeArgs: ["0x1::aptos_coin::AptosCoin"],
-        adapter,
-      });
-
-      expect(result.txHash).toBe(TX_HASH);
-      expect(result.success).toBe(true);
-      expect(result.vmStatus).toBe("Executed successfully");
-
-      expect(calls).toHaveLength(1);
-      const call = calls[0]!;
-      expect(call.args.slice(0, 2)).toEqual(["move", "run-script"]);
-      expect(call.args).toContain("--script-path");
-      expect(call.args).not.toContain("--compiled-script-path");
-      expect(call.args).toContain(scriptPath);
-      expect(call.args).toContain("--type-args");
-      expect(call.args).toContain("0x1::aptos_coin::AptosCoin");
-      expect(call.args).toContain("--args");
-      expect(call.args).toContain("u64:42");
-      expect(call.args).toContain("bool:true");
-    } finally {
-      await harness.cleanup();
-    }
-  });
-
-  it("happy path with .mv compiled: uses --compiled-script-path", async () => {
-    const scriptPath = join(fixture.tmpCwd, "build", "init.mv");
-    mkdirSync(join(fixture.tmpCwd, "build"), { recursive: true });
-    writeFileSync(scriptPath, "compiled bytecode placeholder");
-
-    const { adapter, calls } = makeAdapter({
-      exitCode: 0,
-      stdout: successStdout(),
-      stderr: "",
-    });
-
-    const harness = await Harness.createLive("testnet");
-    try {
-      const result = await harness.runMoveScript({ scriptPath, adapter });
-
-      expect(result.txHash).toBe(TX_HASH);
-      const call = calls[0]!;
-      expect(call.args).toContain("--compiled-script-path");
-      expect(call.args).not.toContain("--script-path");
-    } finally {
-      await harness.cleanup();
-    }
-  });
-
-  it("unsupported extension throws synchronously before any CLI call", async () => {
-    const scriptPath = join(fixture.tmpCwd, "notes.txt");
-    writeFileSync(scriptPath, "not a script");
-
-    const { adapter, calls } = makeAdapter({
-      exitCode: 0,
-      stdout: successStdout(),
-      stderr: "",
-    });
-
-    const harness = await Harness.createLive("testnet");
-    try {
-      let caught: unknown;
-      try {
-        await harness.runMoveScript({ scriptPath, adapter });
-      } catch (err) {
-        caught = err;
-      }
-      expect(caught).toBeInstanceOf(Error);
-      expect((caught as Error).message).toMatch(/unsupported script extension/i);
-      expect(calls).toHaveLength(0);
-    } finally {
-      await harness.cleanup();
-    }
-  });
-
-  it("missing script file throws before any CLI call", async () => {
-    const scriptPath = join(fixture.tmpCwd, "scripts", "missing.move");
-    const { adapter, calls } = makeAdapter({
-      exitCode: 0,
-      stdout: successStdout(),
-      stderr: "",
-    });
-
-    const harness = await Harness.createLive("testnet");
-    try {
-      let caught: unknown;
-      try {
-        await harness.runMoveScript({ scriptPath, adapter });
-      } catch (err) {
-        caught = err;
-      }
-      expect(caught).toBeInstanceOf(Error);
-      expect((caught as Error).message).toMatch(/script not found/i);
-      expect(calls).toHaveLength(0);
-    } finally {
-      await harness.cleanup();
-    }
-  });
-
-  it("CLI failure rethrows CliExecutionError and removes the temp profile", async () => {
-    const scriptPath = join(fixture.tmpCwd, "scripts", "fail.move");
-    mkdirSync(join(fixture.tmpCwd, "scripts"), { recursive: true });
-    writeFileSync(scriptPath, "// dummy\n");
-
-    const { adapter } = makeAdapter({
-      exitCode: 1,
-      stdout: "",
-      stderr: "compile error: undefined identifier",
-    });
-
-    const harness = await Harness.createLive("testnet");
-    try {
-      let caught: unknown;
-      try {
-        await harness.runMoveScript({ scriptPath, adapter });
-      } catch (err) {
-        caught = err;
-      }
-      expect(caught).toBeInstanceOf(CliExecutionError);
-      // Temp profile cleaned up in finally.
-      expect(existsSync(join(fixture.tmpHome!, ".aptos", "config.yaml"))).toBe(false);
-    } finally {
-      await harness.cleanup();
-    }
-  });
-
-  it("CLI succeeded but output has no txHash: throws clear non-CliExecutionError", async () => {
-    const scriptPath = join(fixture.tmpCwd, "scripts", "weird.move");
-    mkdirSync(join(fixture.tmpCwd, "scripts"), { recursive: true });
-    writeFileSync(scriptPath, "// dummy\n");
-
-    const { adapter } = makeAdapter({
-      exitCode: 0,
-      stdout: "ran successfully but no hash here",
-      stderr: "",
-    });
-
-    const harness = await Harness.createLive("testnet");
-    try {
-      let caught: unknown;
-      try {
-        await harness.runMoveScript({ scriptPath, adapter });
-      } catch (err) {
-        caught = err;
-      }
-      expect(caught).toBeInstanceOf(Error);
-      expect(caught).not.toBeInstanceOf(CliExecutionError);
-      expect((caught as Error).message).toMatch(/Could not parse transaction hash/);
-    } finally {
-      await harness.cleanup();
-    }
-  });
-
-  it("`success: false` in Result JSON surfaces in MoveScriptResult.success", async () => {
-    const scriptPath = join(fixture.tmpCwd, "scripts", "bad.move");
-    mkdirSync(join(fixture.tmpCwd, "scripts"), { recursive: true });
-    writeFileSync(scriptPath, "// dummy\n");
-
-    const { adapter } = makeAdapter({
-      exitCode: 0,
-      stdout: [
-        `transaction hash: ${TX_HASH}`,
-        '{ "Result": { "success": false, "vm_status": "ABORTED" } }',
-      ].join("\n"),
-      stderr: "",
-    });
-
-    const harness = await Harness.createLive("testnet");
-    try {
-      const result = await harness.runMoveScript({ scriptPath, adapter });
-      expect(result.txHash).toBe(TX_HASH);
-      expect(result.success).toBe(false);
-      expect(result.vmStatus).toBe("ABORTED");
-    } finally {
-      await harness.cleanup();
-    }
-  });
-});

package/src/__tests__/harness/view.test.ts

@@ -1,104 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-import { Harness } from "../../harness/index.js";
-import { setupHarnessTestFixture, type HarnessTestFixture } from "./_fixture.js";
-
-/**
- * Tests for `Harness.runViewFunction` — the SDK delegation path.
- *
- * The Aptos SDK isn't behind an injectable adapter, so we monkey-patch
- * `harness.runtime.aptos.view` after `createLive`. Acceptable here
- * because the function under test is a 6-line wrapper that only
- * forwards options.
- */
-describe("Harness.runViewFunction", () => {
-  let fixture: HarnessTestFixture;
-
-  beforeEach(() => {
-    fixture = setupHarnessTestFixture();
-  });
-
-  afterEach(() => {
-    fixture.teardown();
-  });
-
-  it("happy path: forwards correct payload to aptos.view and returns the raw result array", async () => {
-    const harness = await Harness.createLive("testnet");
-    try {
-      const fake = vi.fn().mockResolvedValue([42n, "hello"]);
-      // Monkey-patch — the SDK boundary isn't behind an adapter.
-      harness.runtime.aptos.view = fake as never;
-
-      const result = await harness.runViewFunction({
-        function: "0xCAFE::counter::get",
-        typeArguments: ["0x1::aptos_coin::AptosCoin"],
-        functionArguments: ["0xdeployer", 1n],
-      });
-
-      expect(result).toEqual([42n, "hello"]);
-      expect(fake).toHaveBeenCalledTimes(1);
-      expect(fake).toHaveBeenCalledWith({
-        payload: {
-          function: "0xCAFE::counter::get",
-          typeArguments: ["0x1::aptos_coin::AptosCoin"],
-          functionArguments: ["0xdeployer", 1n],
-        },
-      });
-    } finally {
-      await harness.cleanup();
-    }
-  });
-
-  it("defaults typeArguments and functionArguments to empty arrays when omitted", async () => {
-    const harness = await Harness.createLive("testnet");
-    try {
-      const fake = vi.fn().mockResolvedValue([0n]);
-      harness.runtime.aptos.view = fake as never;
-
-      const result = await harness.runViewFunction({
-        function: "0xCAFE::counter::count",
-      });
-
-      expect(result).toEqual([0n]);
-      expect(fake).toHaveBeenCalledWith({
-        payload: {
-          function: "0xCAFE::counter::count",
-          typeArguments: [],
-          functionArguments: [],
-        },
-      });
-    } finally {
-      await harness.cleanup();
-    }
-  });
-
-  it("passes empty results through unchanged", async () => {
-    const harness = await Harness.createLive("testnet");
-    try {
-      const fake = vi.fn().mockResolvedValue([]);
-      harness.runtime.aptos.view = fake as never;
-
-      const result = await harness.runViewFunction({
-        function: "0xCAFE::nothing::nothing",
-      });
-
-      expect(result).toEqual([]);
-    } finally {
-      await harness.cleanup();
-    }
-  });
-
-  it("rethrows errors from aptos.view", async () => {
-    const harness = await Harness.createLive("testnet");
-    try {
-      const fake = vi.fn().mockRejectedValue(new Error("module not found"));
-      harness.runtime.aptos.view = fake as never;
-
-      await expect(
-        harness.runViewFunction({ function: "0xCAFE::missing::get" })
-      ).rejects.toThrow(/module not found/);
-    } finally {
-      await harness.cleanup();
-    }
-  });
-});

package/src/__tests__/runtime.test.ts

@@ -1,182 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { initRuntime } from "../runtime.js";
-import { _resetConfigCache } from "../core/config.js";
-import { AccountManager } from "../core/AccountManager.js";
-
-/**
- * Behavioral tests for `runtime.ts` covering the paths
- * `__tests__/deployContract.test.ts` doesn't exercise:
- *   - initRuntime returns a fully-wired MovehatRuntime
- *   - accountIndex selection + out-of-range error
- *   - config override merging
- *   - getAccountByIndex bounds error
- *   - switchNetwork delegates back into initRuntime
- *
- * Mainnet/security gates live in `resolveNetworkConfig` and are
- * covered in `core/__tests__/config.test.ts` to avoid re-driving the
- * same branch through two layers.
- */
-
-const TEST_KEY_A =
-  "0x0000000000000000000000000000000000000000000000000000000000000001";
-const TEST_KEY_B =
-  "0x0000000000000000000000000000000000000000000000000000000000000002";
-
-function writeConfig(cwd: string, body: string): void {
-  writeFileSync(join(cwd, "movehat.config.js"), body);
-}
-
-const CONFIG_TWO_NETWORKS_TWO_ACCOUNTS = `export default {
-  defaultNetwork: "testnet",
-  networks: {
-    testnet: {
-      url: "https://testnet.movementnetwork.xyz/v1",
-      chainId: "testnet",
-      accounts: ["${TEST_KEY_A}", "${TEST_KEY_B}"]
-    },
-    custom: {
-      url: "https://custom.example.com/v1",
-      chainId: "custom",
-      accounts: ["${TEST_KEY_A}"]
-    }
-  }
-};
-`;
-
-describe("initRuntime", () => {
-  let tmpCwd: string;
-  let origCwd: string;
-
-  beforeEach(() => {
-    origCwd = process.cwd();
-    tmpCwd = mkdtempSync(join(tmpdir(), "movehat-runtime-test-"));
-    process.chdir(tmpCwd);
-    _resetConfigCache();
-    AccountManager.clearPool();
-    writeConfig(tmpCwd, CONFIG_TWO_NETWORKS_TWO_ACCOUNTS);
-  });
-
-  afterEach(() => {
-    process.chdir(origCwd);
-    rmSync(tmpCwd, { recursive: true, force: true });
-    _resetConfigCache();
-    AccountManager.clearPool();
-  });
-
-  it("returns a runtime bound to defaultNetwork when no network is passed", async () => {
-    const runtime = await initRuntime();
-
-    expect(runtime.network.name).toBe("testnet");
-    expect(runtime.network.rpc).toContain("testnet.movementnetwork.xyz");
-    expect(runtime.config.network).toBe("testnet");
-    expect(runtime.aptos).toBeDefined();
-    expect(runtime.account).toBeDefined();
-    // accounts array reflects both keys configured.
-    expect(runtime.accounts).toHaveLength(2);
-  });
-
-  it("switches network via the `network` option", async () => {
-    const runtime = await initRuntime({ network: "custom" });
-
-    expect(runtime.network.name).toBe("custom");
-    expect(runtime.network.rpc).toContain("custom.example.com");
-    expect(runtime.accounts).toHaveLength(1);
-  });
-
-  it("selects a specific account via `accountIndex`", async () => {
-    const runtime = await initRuntime({ accountIndex: 1 });
-
-    // The primary `account` is the indexed pick.
-    expect(runtime.account.accountAddress.toString()).toBe(
-      runtime.accounts[1]!.accountAddress.toString()
-    );
-    expect(runtime.account.accountAddress.toString()).not.toBe(
-      runtime.accounts[0]!.accountAddress.toString()
-    );
-  });
-
-  it("throws a clear error when accountIndex is out of range", async () => {
-    await expect(initRuntime({ accountIndex: 5 })).rejects.toThrow(
-      /Account index 5 not found/
-    );
-  });
-
-  it("merges `configOverride` on top of the loaded user config", async () => {
-    const runtime = await initRuntime({
-      configOverride: { defaultNetwork: "custom" },
-    });
-
-    // The override flips defaultNetwork → 'custom' so resolveNetworkConfig
-    // picks the custom entry without requiring an explicit `network` arg.
-    expect(runtime.network.name).toBe("custom");
-  });
-
-  it("getAccountByIndex returns the account at the given slot", async () => {
-    const runtime = await initRuntime();
-    expect(runtime.getAccountByIndex(0).accountAddress.toString()).toBe(
-      runtime.accounts[0]!.accountAddress.toString()
-    );
-    expect(runtime.getAccountByIndex(1).accountAddress.toString()).toBe(
-      runtime.accounts[1]!.accountAddress.toString()
-    );
-  });
-
-  it("getAccountByIndex throws on out-of-range index", async () => {
-    const runtime = await initRuntime();
-    expect(() => runtime.getAccountByIndex(99)).toThrow(
-      /Account index 99 out of range/
-    );
-  });
-
-  it("createAccount returns a fresh account each call (pool grows)", async () => {
-    const runtime = await initRuntime();
-    const before = AccountManager.getPoolSize();
-    const a = runtime.createAccount();
-    const b = runtime.createAccount();
-    expect(a.accountAddress.toString()).not.toBe(b.accountAddress.toString());
-    expect(AccountManager.getPoolSize()).toBe(before + 2);
-  });
-
-  it("getAccount loads from a private key hex", async () => {
-    const runtime = await initRuntime();
-    const acc = runtime.getAccount(TEST_KEY_B);
-    expect(acc.accountAddress.toString()).toBe(
-      runtime.accounts[1]!.accountAddress.toString()
-    );
-  });
-
-  it("switchNetwork returns a new runtime bound to the requested network", async () => {
-    const runtime = await initRuntime();
-    expect(runtime.network.name).toBe("testnet");
-
-    const switched = await runtime.switchNetwork("custom");
-    expect(switched.network.name).toBe("custom");
-    expect(switched.network.rpc).toContain("custom.example.com");
-    // Original runtime is unaffected — switchNetwork builds fresh.
-    expect(runtime.network.name).toBe("testnet");
-  });
-
-  it("getDeployment / getDeployments / getDeploymentAddress return null/empty for an unused network", async () => {
-    const runtime = await initRuntime();
-    // Nothing deployed in the tmp cwd, so these all short-circuit.
-    expect(runtime.getDeployment("counter")).toBeNull();
-    expect(runtime.getDeployments()).toEqual({});
-    expect(runtime.getDeploymentAddress("counter")).toBeNull();
-  });
-
-  it("getContract returns a MoveContract bound to the requested address+module", async () => {
-    const runtime = await initRuntime();
-    const dummyAddr = "0x" + "a".repeat(64);
-    const contract = runtime.getContract(dummyAddr, "counter");
-    expect(contract).toBeDefined();
-    // MoveContract holds the address+module pair; assert shape, not behavior
-    // (call/view would require a real chain).
-    expect(contract).toHaveProperty("call");
-    expect(contract).toHaveProperty("view");
-  });
-});
-

package/src/cli.ts

@@ -1,164 +0,0 @@
-#!/usr/bin/env node
-import { Command, InvalidOptionArgumentError } from 'commander';
-import { readFileSync } from 'fs';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-import testCommand from './commands/test.js';
-import testMoveCommand from './commands/test-move.js';
-import compileCommand from './commands/compile.js';
-import initCommand from './commands/init.js';
-import runCommand from './commands/run.js';
-import updateCommand from './commands/update.js';
-import forkCreateCommand from './commands/fork/create.js';
-import forkViewResourceCommand from './commands/fork/view-resource.js';
-import forkFundCommand from './commands/fork/fund.js';
-import forkListCommand from './commands/fork/list.js';
-import forkServeCommand from './commands/fork/serve.js';
-import { checkForUpdates } from './helpers/version-check.js';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const packageJson = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf-8'));
-const version = packageJson.version;
-const packageName = packageJson.name;
-
-/**
- * Parse and validate port number
- */
-function parsePort(value: string): number {
-  const port = Number.parseInt(value, 10);
-  if (isNaN(port) || port < 1 || port > 65535) {
-    throw new InvalidOptionArgumentError('Port must be an integer between 1 and 65535');
-  }
-  return port;
-}
-
-// Check for updates at startup (skip if running update command or help)
-const args = process.argv.slice(2);
-const isUpdateCommand = args.includes('update');
-const isHelpOnly = args.length === 0 || args.includes('-h') || args.includes('--help');
-
-if (!isUpdateCommand && !isHelpOnly) {
-  checkForUpdates(version, packageName);
-}
-
-const program = new Command();
-
-program
-  .name('movehat')
-  .description('A CLI tool for managing Move smart contracts')
-  .version(version)
-  .option('--network <name>', 'Network to use (testnet, mainnet, local, etc.)')
-  .option('--redeploy', 'Force redeploy even if already deployed')
-  .option('-v, --verbose', 'Show subprocess output (movement node, aptos move) for debugging')
-  .hook('preAction', (thisCommand) => {
-    // Store network option in environment for commands to access
-    const options = thisCommand.opts();
-    if (options.network) {
-      process.env.MH_CLI_NETWORK = options.network;
-    }
-    if (options.redeploy) {
-      process.env.MH_CLI_REDEPLOY = 'true';
-    }
-    if (options.verbose) {
-      process.env.MOVEHAT_VERBOSE = '1';
-    }
-  });
-
-program
-    .command('init [project-name]')
-    .description('Initialize a new Move project in the current directory')
-    .action((projectName) => {
-        initCommand(projectName);
-    });
-
-program
-    .command('compile')
-    .description('Compile Move smart contracts using Movement CLI')
-    .action(compileCommand);
-
-program
-    .command('run <script>')
-    .description('Run a TypeScript/JavaScript script (e.g., deployment script)')
-    .action(runCommand);
-
-program
-    .command('test')
-    .description('Run tests (interactive menu if no flags provided)')
-    .option('--move', 'Run only Move unit tests (fast, no node required)')
-    .option('--ts', 'Run only TypeScript integration tests (starts local node)')
-    .option('--all', 'Run all tests (Move + TypeScript)')
-    .option('--watch', 'Run TypeScript tests in watch mode (implies --ts)')
-    .option('--filter <pattern>', 'Filter Move tests by name pattern')
-    // Legacy flags for backward compatibility
-    .option('--move-only', 'Alias for --move (deprecated)')
-    .option('--ts-only', 'Alias for --ts (deprecated)')
-    .action((options) => {
-        // --watch implies --ts
-        if (options.watch && !options.ts && !options.all) {
-            options.ts = true;
-        }
-        testCommand(options);
-    });
-
-program
-    .command('test:move')
-    .description('Run Move unit tests')
-    .option('--filter <pattern>', 'Filter tests by name pattern')
-    .option('--ignore-warnings', 'Ignore compilation warnings')
-    .action((options) => testMoveCommand(options));
-
-program
-    .command('test:ts')
-    .description('Run TypeScript integration tests')
-    .option('--watch', 'Run tests in watch mode')
-    .action((options) => testCommand({ tsOnly: true, watch: options.watch }));
-
-program
-    .command('update')
-    .description('Check for updates and upgrade to the latest version')
-    .action(() => updateCommand());
-
-// Fork commands
-const fork = program
-    .command('fork')
-    .description('Manage local forks of Movement networks');
-
-fork
-    .command('create')
-    .description('Create a new fork from a network')
-    .option('-n, --name <name>', 'Name for the fork')
-    .option('-p, --path <path>', 'Custom path for the fork')
-    .action((options) => forkCreateCommand(options));
-
-fork
-    .command('view-resource')
-    .description('View a resource from the fork')
-    .option('-f, --fork <path>', 'Path to the fork')
-    .requiredOption('-a, --account <address>', 'Account address')
-    .requiredOption('-r, --resource <type>', 'Resource type')
-    .action((options) => forkViewResourceCommand(options));
-
-fork
-    .command('fund')
-    .description('Fund an account in the fork')
-    .option('-f, --fork <path>', 'Path to the fork')
-    .requiredOption('-a, --account <address>', 'Account address')
-    .requiredOption('--amount <amount>', 'Amount to fund')
-    .option('--coin-type <type>', 'Coin type', '0x1::aptos_coin::AptosCoin')
-    .action((options) => forkFundCommand(options));
-
-fork
-    .command('list')
-    .description('List all available forks')
-    .action(() => forkListCommand());
-
-fork
-    .command('serve')
-    .description('Start a local RPC server serving the fork')
-    .option('-f, --fork <path>', 'Path to the fork')
-    .option('-p, --port <port>', 'Port to listen on (default: 8080)', parsePort, 8080)
-    .option('--host <host>', 'Interface to bind (default: 127.0.0.1; use 0.0.0.0 to expose to LAN)', '127.0.0.1')
-    .action((options) => forkServeCommand(options));
-
-program.parse(process.argv);