@deeeed/metamask-harness 0.5.0 → 0.6.0

package/src/paths.ts

@@ -1,198 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-
-import type {
-  RecipeHarnessBrowserExtensionModule,
-  RecipeHarnessCdpModule,
-  RecipeHarnessModule,
-  RecipeHarnessReactNativeBridgeModule,
-  RecipeProtocolModule,
-  MetaMaskRecipeAdapter,
-} from './types.ts';
-
-export const runnerDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const pathDefaults = readPathDefaults();
-export const DEFAULT_RECIPE_RUNTIME_DIR = pathDefaults.recipeRuntimeDir;
-export const DEFAULT_RECIPE_HARNESS_ROOT = pathDefaults.recipeHarnessRoot;
-
-export function recipeRuntimeDir() {
-  return validateRelativeRecipePath('RECIPE_RUNTIME_DIR', process.env.RECIPE_RUNTIME_DIR || DEFAULT_RECIPE_RUNTIME_DIR);
-}
-
-export function recipeHarnessRoot() {
-  return validateRelativeRecipePath('RECIPE_HARNESS_ROOT', process.env.RECIPE_HARNESS_ROOT || DEFAULT_RECIPE_HARNESS_ROOT);
-}
-
-
-function readPathDefaults(): { recipeRuntimeDir: string; recipeHarnessRoot: string } {
-  const defaultsPath = path.join(runnerDir, 'adapters/shared/path-defaults.json');
-  const parsed = JSON.parse(fs.readFileSync(defaultsPath, 'utf8')) as Partial<{ recipeRuntimeDir: string; recipeHarnessRoot: string }>;
-  return {
-    recipeRuntimeDir: validateRelativeRecipePath('recipeRuntimeDir', parsed.recipeRuntimeDir || ''),
-    recipeHarnessRoot: validateRelativeRecipePath('recipeHarnessRoot', parsed.recipeHarnessRoot || ''),
-  };
-}
-
-function validateRelativeRecipePath(name: string, value: string): string {
-  if (!value || path.isAbsolute(value)) throw new Error(`${name} must be a non-empty relative path: ${value}`);
-  if (!/^[A-Za-z0-9._/-]+$/u.test(value)) throw new Error(`${name} contains unsupported characters: ${value}`);
-  for (const part of value.split('/')) {
-    if (!part || part === '.' || part === '..') throw new Error(`${name} contains unsafe path component: ${value}`);
-  }
-  return value;
-}
-
-export function recipeRuntimePath(projectRoot: string, ...segments: string[]) {
-  return path.join(projectRoot, recipeRuntimeDir(), ...segments);
-}
-
-export function recipeHarnessPath(projectRoot: string, ...segments: string[]) {
-  return path.join(projectRoot, recipeHarnessRoot(), ...segments);
-}
-
-export function walletFixturePath(projectRoot: string) {
-  return recipeRuntimePath(projectRoot, 'wallet-fixture.json');
-}
-
-export function extensionIdPath(projectRoot: string) {
-  return recipeRuntimePath(projectRoot, 'extension.id');
-}
-
-export function recipeWatchLogCandidates() {
-  return [
-    path.join(recipeRuntimeDir(), 'webpack.log'),
-    path.join(recipeRuntimeDir(), 'recipe-harness-webpack.log'),
-  ];
-}
-
-export function resolveLocalProtocolRoot() {
-  const candidates = [
-    process.env.FARMSLOT_ROOT,
-    readConfiguredProtocolRoot(),
-    findProtocolRoot(runnerDir),
-    findProtocolRoot(process.cwd()),
-  ].filter(Boolean);
-  const root = candidates[0];
-  return root ? path.resolve(root) : undefined;
-}
-
-export function resolveRequiredLocalProtocolRoot(reason: string) {
-  const root = resolveLocalProtocolRoot();
-  if (!root) {
-    throw new Error(
-      `${reason} requires a local protocol/runtime checkout. Set FARMSLOT_ROOT or create .farmslot-root for this dev-only path.`,
-    );
-  }
-  return root;
-}
-
-function readConfiguredProtocolRoot() {
-  const configPath = path.join(runnerDir, '.farmslot-root');
-  if (!fs.existsSync(configPath)) return undefined;
-  const value = fs.readFileSync(configPath, 'utf8').trim();
-  return value || undefined;
-}
-
-function findProtocolRoot(start) {
-  let dir = path.resolve(start);
-  while (dir !== path.dirname(dir)) {
-    if (isProtocolRoot(dir)) return dir;
-    const sibling = path.join(dir, 'farmslot');
-    if (isProtocolRoot(sibling)) return sibling;
-    dir = path.dirname(dir);
-  }
-  return undefined;
-}
-
-function isProtocolRoot(candidate) {
-  return (
-    fs.existsSync(path.join(candidate, 'packages/recipe-harness/package.json')) &&
-    fs.existsSync(path.join(candidate, 'packages/protocol/package.json'))
-  );
-}
-
-export function assertAdapter(adapter: unknown): asserts adapter is MetaMaskRecipeAdapter {
-  if (adapter !== 'mobile' && adapter !== 'extension' && adapter !== 'core') {
-    throw new Error('Adapter must be mobile, extension, or core.');
-  }
-}
-
-export function manifestPath(adapter: MetaMaskRecipeAdapter) {
-  assertAdapter(adapter);
-  return path.join(runnerDir, 'library/manifests', `${adapter}.action-manifest.json`);
-}
-
-export function recipePath(name: string) {
-  return path.join(runnerDir, 'library/recipes', name);
-}
-
-export function readJson(file: string): unknown {
-  return JSON.parse(fs.readFileSync(file, 'utf8'));
-}
-
-export async function importRecipeHarness(): Promise<RecipeHarnessModule> {
-  return importProtocolPackage(
-    '@farmslot/recipe-harness',
-    'packages/recipe-harness/src/index.ts',
-  ) as Promise<RecipeHarnessModule>;
-}
-
-export async function importRecipeHarnessRuntimeCdp(): Promise<RecipeHarnessCdpModule> {
-  return importProtocolPackage(
-    '@farmslot/recipe-harness/runtime/cdp',
-    'packages/recipe-harness/src/runtime/cdp.ts',
-  ) as Promise<RecipeHarnessCdpModule>;
-}
-
-export async function importRecipeHarnessRuntimeBrowserExtension(): Promise<RecipeHarnessBrowserExtensionModule> {
-  return importProtocolPackage(
-    '@farmslot/recipe-harness/runtime/browser-extension',
-    'packages/recipe-harness/src/runtime/browser-extension.ts',
-  ) as Promise<RecipeHarnessBrowserExtensionModule>;
-}
-
-export async function importRecipeHarnessRuntimeReactNativeBridge(): Promise<RecipeHarnessReactNativeBridgeModule> {
-  return importProtocolPackage(
-    '@farmslot/recipe-harness/runtime/react-native-bridge',
-    'packages/recipe-harness/src/runtime/react-native-bridge.ts',
-  ) as Promise<RecipeHarnessReactNativeBridgeModule>;
-}
-
-export async function importRecipeHarnessCli(): Promise<{
-  runRecipeHarnessCli: (argv: string[]) => Promise<void>;
-}> {
-  return importProtocolPackage(
-    '@farmslot/recipe-harness/cli',
-    'packages/recipe-harness/src/cli/index.ts',
-  ) as Promise<{ runRecipeHarnessCli: (argv: string[]) => Promise<void> }>;
-}
-
-export async function importRecipeProtocol(): Promise<RecipeProtocolModule> {
-  return importProtocolPackage(
-    '@farmslot/protocol',
-    'packages/protocol/src/index.ts',
-  ) as Promise<RecipeProtocolModule>;
-}
-
-async function importProtocolPackage(packageName: string, localSourceEntry: string) {
-  try {
-    return await import(packageName);
-  } catch (error) {
-    if (!isMissingPackageError(error, packageName)) throw error;
-  }
-
-  const root = resolveLocalProtocolRoot();
-  if (!root) {
-    throw new Error(
-      `${packageName} is not installed. Install @farmslot/* packages normally, or set FARMSLOT_ROOT/use npm run dev:link-farmslot while co-developing protocol packages locally.`,
-    );
-  }
-  return import(pathToFileURL(path.join(root, localSourceEntry)).href);
-}
-
-function isMissingPackageError(error: unknown, packageName: string) {
-  if (!(error instanceof Error)) return false;
-  const code = (error as NodeJS.ErrnoException).code;
-  return code === 'ERR_MODULE_NOT_FOUND' && error.message.includes(packageName);
-}

package/src/progress.ts

@@ -1,117 +0,0 @@
-/**
- * progress.ts — structured progress events for long recipe CLI operations.
- *
- * Human mode: short lines on stderr.
- * Machine mode: JSONL on stderr when --json or RECIPE_PROGRESS_JSON=1.
- */
-import path from 'node:path';
-import { parseArgs } from 'node:util';
-import { color } from './cli-color.ts';
-
-function shouldEmitJson(explicit: boolean): boolean {
-  if (explicit) return true;
-  const env = process.env.RECIPE_PROGRESS_JSON;
-  return env === '1' || env === 'true';
-}
-
-interface ProgressEvent {
-  command?: string;
-  phase?: string;
-  message?: string;
-  status?: string;
-  elapsedMs?: number;
-  [key: string]: unknown;
-}
-
-export function emitProgress(event: ProgressEvent, { json = false }: { json?: boolean } = {}): void {
-  const payload = {
-    schemaVersion: 1,
-    type: 'progress',
-    ts: new Date().toISOString(),
-    ...event,
-  };
-  if (json || shouldEmitJson(false)) {
-    process.stderr.write(`${JSON.stringify(payload)}\n`);
-    return;
-  }
-  const stream = process.stderr;
-  const prefix = color('label', 'recipe', { stream });
-  if (payload.phase === 'done') {
-    const statusStyle = payload.status === 'pass' ? 'ok' : 'err';
-    const statusWord = payload.status === 'pass' ? 'done' : 'failed';
-    const cmd = payload.command ? color('cmd', `${payload.command}`, { stream }) : '';
-    const elapsed = Number.isFinite(payload.elapsedMs)
-      ? color('comment', ` (${Math.round((payload.elapsedMs as number) / 1000)}s)`, { stream })
-      : '';
-    process.stderr.write(`${prefix}: ${cmd} ${color(statusStyle, statusWord, { stream })} ${payload.message || ''}${elapsed}\n`);
-    return;
-  }
-  const cmd = payload.command ? `${color('cmd', payload.command, { stream })}: ` : '';
-  const phase = payload.phase ? `${color('accent', `[${payload.phase}]`, { stream })} ` : '';
-  const elapsed = Number.isFinite(payload.elapsedMs)
-    ? color('comment', ` (${Math.round((payload.elapsedMs as number) / 1000)}s)`, { stream })
-    : '';
-  process.stderr.write(`${prefix}: ${cmd}${phase}${payload.message || ''}${elapsed}\n`);
-}
-
-function usage(): void {
-  console.error(`Usage:
-  progress emit --command <name> --phase <id> --message <text> [--elapsed-ms <n>] [--json]
-  progress done --command <name> --status pass|fail --message <text> [--elapsed-ms <n>] [--json]`);
-}
-
-async function main(): Promise<void> {
-  const [command, ...rest] = process.argv.slice(2);
-  if (!command || command === '--help' || command === '-h') {
-    usage();
-    process.exit(command ? 0 : 2);
-  }
-
-  const { values } = parseArgs({
-    args: rest,
-    options: {
-      command: { type: 'string' },
-      phase: { type: 'string' },
-      message: { type: 'string' },
-      status: { type: 'string' },
-      'elapsed-ms': { type: 'string' },
-      json: { type: 'boolean', default: false },
-    },
-    allowPositionals: false,
-  });
-
-  const elapsedMs = values['elapsed-ms'] ? Number.parseInt(values['elapsed-ms'], 10) : undefined;
-  const json = values.json || shouldEmitJson(false);
-
-  if (command === 'emit') {
-    emitProgress({
-      command: values.command || 'recipe',
-      phase: values.phase || 'working',
-      message: values.message || '',
-      elapsedMs: Number.isFinite(elapsedMs) ? elapsedMs : undefined,
-    }, { json });
-    return;
-  }
-
-  if (command === 'done') {
-    emitProgress({
-      command: values.command || 'recipe',
-      phase: 'done',
-      status: values.status || 'pass',
-      message: values.message || '',
-      elapsedMs: Number.isFinite(elapsedMs) ? elapsedMs : undefined,
-    }, { json });
-    return;
-  }
-
-  usage();
-  process.exit(2);
-}
-
-const isMain = process.argv[1] && path.resolve(process.argv[1]) === path.resolve(import.meta.filename ?? '');
-if (isMain) {
-  main().catch((error: unknown) => {
-    console.error(error instanceof Error ? error.message : String(error));
-    process.exit(1);
-  });
-}

package/src/recording-target.ts

@@ -1,147 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import fs from 'node:fs';
-import path from 'node:path';
-
-import type { RecordingTarget, RecordingTargetContext, RecordingTargetProvider } from '@farmslot/recipe-harness';
-
-import type { MetaMaskRecipeAdapter } from './types.ts';
-
-export function createMetaMaskRecordingTargetProvider(
-  adapter: MetaMaskRecipeAdapter,
-): RecordingTargetProvider {
-  return {
-    async resolveRecordingTarget(context: RecordingTargetContext): Promise<RecordingTarget> {
-      if (adapter === 'extension') {
-        const pid = resolveExtensionBrowserPid(
-          context.projectRoot,
-          context.artifactsDir,
-          context.env.CDP_PORT ?? context.env.RECIPE_CDP_PORT ?? process.env.CDP_PORT ?? process.env.RECIPE_CDP_PORT,
-        );
-        if (!pid) {
-          throw new Error(
-            'Could not resolve the extension browser PID for --record-video. Ensure the slot browser is running and CDP_PORT is set.',
-          );
-        }
-        return { kind: 'pid', pid };
-      }
-      if (adapter === 'mobile') {
-        const platform = (context.env.PLATFORM ?? process.env.PLATFORM ?? 'ios').trim().toLowerCase();
-        if (platform === 'android' || context.env.ADB_SERIAL || process.env.ADB_SERIAL) {
-          throw new Error('--record-video is not implemented for mobile Android replay yet.');
-        }
-        const simulator = resolveMobileIosSimulatorName(context.env);
-        if (!simulator) {
-          throw new Error(
-            'Could not resolve an iOS simulator name for --record-video. Set IOS_SIMULATOR or pass --simulator to the recipe hook.',
-          );
-        }
-        const pid = resolveMobileIosSimulatorPid(simulator);
-        if (pid) return { kind: 'pid', pid };
-        return { kind: 'app-window', appName: 'Simulator', windowName: simulator };
-      }
-      throw new Error(`--record-video is not implemented for the ${adapter} adapter.`);
-    },
-  };
-}
-
-export function captureHelperSupportsRecordSessionSnapshots(projectRoot: string): boolean {
-  const result = spawnSync(captureHelperPath(), ['version', '--json'], {
-    cwd: projectRoot,
-    encoding: 'utf8',
-  });
-  if (result.status !== 0) return false;
-  try {
-    const parsed = JSON.parse(result.stdout) as { capabilities?: unknown };
-    return Array.isArray(parsed.capabilities) && parsed.capabilities.includes('record_session_snapshot');
-  } catch {
-    return false;
-  }
-}
-
-export function resolveMobileIosSimulatorName(
-  env: Record<string, string | undefined> = process.env as Record<string, string | undefined>,
-): string | undefined {
-  const explicit = env.IOS_SIMULATOR?.trim() || env.SIM_UDID?.trim();
-  if (explicit) return explicit;
-  const slot = env.FARMSLOT_SLOT_ID?.trim() || env.SLOT_ID?.trim();
-  if (!slot) return undefined;
-  const suffix = slot.includes('-') ? slot.slice(slot.lastIndexOf('-') + 1) : slot;
-  return suffix || undefined;
-}
-
-export function resolveMobileIosSimulatorPid(simulator: string): number | null {
-  const result = spawnSync(
-    captureHelperPath(),
-    ['resolve', '--app-name', 'Simulator', '--window-name', simulator, '--json'],
-    { encoding: 'utf8' },
-  );
-  if (result.status !== 0) return null;
-  try {
-    const parsed = JSON.parse(result.stdout) as { selected?: { pid?: unknown } };
-    return parsePositivePid(parsed.selected?.pid);
-  } catch {
-    return null;
-  }
-}
-
-export function resolveExtensionBrowserPid(
-  projectRoot: string,
-  artifactsDir: string,
-  cdpPort: string | undefined,
-): number | null {
-  const explicit = parsePositivePid(process.env.METAMASK_RECIPE_EXTENSION_BROWSER_PID);
-  if (explicit) return explicit;
-  if (cdpPort) {
-    const lsof = spawnSync('lsof', ['-nP', `-iTCP:${cdpPort}`, '-sTCP:LISTEN', '-t'], {
-      cwd: projectRoot,
-      encoding: 'utf8',
-    });
-    if (lsof.status === 0) {
-      const pid = parsePositivePid(String(lsof.stdout).split(/\s+/u).find(Boolean));
-      if (pid) return pid;
-    }
-  }
-  for (const file of [
-    path.join(artifactsDir, 'extension-runtime/runtime.json'),
-    path.join(projectRoot, 'temp/recipe/runtime/runtime.json'),
-  ]) {
-    const pid = parsePositivePid(readJsonFile(file)?.pid);
-    if (pid) return pid;
-  }
-  for (const file of [
-    path.join(projectRoot, 'temp/recipe/runtime/chromium.pid'),
-    path.join(projectRoot, 'temp/recipe/runtime/browser.pid'),
-  ]) {
-    const pid = parsePositivePid(readTextFile(file));
-    if (pid) return pid;
-  }
-  return null;
-}
-
-function captureHelperPath(): string {
-  return process.env.CAPTURE_HELPER_PATH || 'capture-helper';
-}
-
-function parsePositivePid(value: unknown): number | null {
-  const pid = Number(String(value ?? '').trim());
-  return Number.isInteger(pid) && pid > 0 ? pid : null;
-}
-
-function readJsonFile(file: string): Record<string, unknown> | null {
-  if (!fs.existsSync(file)) return null;
-  try {
-    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
-    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
-  } catch {
-    return null;
-  }
-}
-
-function readTextFile(file: string): string {
-  if (!fs.existsSync(file)) return '';
-  try {
-    return fs.readFileSync(file, 'utf8');
-  } catch {
-    return '';
-  }
-}