@deeeed/metamask-harness 0.2.0

package/runner/src/commands/debug.ts

@@ -0,0 +1,44 @@
+// debug — open the debug console by composing the porcelain: extension `debug`
+// (--worker → `debug worker`); mobile `debug` (--dev-menu → `dev-menu`).
+// Cross-platform flag misuse teaches (exit 2).
+
+import { EXIT, flag, parseFlags, resolveAdapter, spawnPorcelain, targetOf, usageOut } from './shared.ts';
+
+const DEBUG_BOOLEANS = new Set(['worker', 'devMenu', 'json']);
+
+export async function handleDebug(argv: string[]): Promise<number> {
+  const { options } = parseFlags(argv, DEBUG_BOOLEANS);
+  const json = flag(options, 'json');
+  const target = targetOf(options);
+  const adapter = resolveAdapter(options, target);
+
+  if (!adapter) return usageOut(json, 'debug', `could not detect the MetaMask repo type for ${target}`);
+  if (adapter === 'core') return usageOut(json, 'debug', 'core is headless; there is no debug console.');
+
+  const worker = flag(options, 'worker');
+  const devMenu = flag(options, 'devMenu');
+  if (adapter === 'mobile' && worker) {
+    return usageOut(json, 'debug', '--worker is extension-only (service-worker DevTools). Use --dev-menu on mobile.');
+  }
+  if (adapter === 'extension' && devMenu) {
+    return usageOut(json, 'debug', '--dev-menu is mobile-only (RN developer menu). Use --worker on the extension.');
+  }
+
+  let args: string[];
+  if (adapter === 'extension') {
+    args = worker ? ['debug', 'worker'] : ['debug'];
+  } else {
+    args = devMenu ? ['dev-menu'] : ['debug'];
+  }
+  const result = spawnPorcelain(adapter, args, target, json);
+  if (json) {
+    console.log(
+      JSON.stringify(
+        { schemaVersion: 1, command: 'debug', adapter, mode: worker ? 'worker' : devMenu ? 'dev-menu' : 'default', exitCode: result.status === 0 ? EXIT.ok : EXIT.runtime },
+        null,
+        2,
+      ),
+    );
+  }
+  return result.status === 0 ? EXIT.ok : EXIT.runtime;
+}

package/runner/src/commands/fixtures.ts

@@ -0,0 +1,99 @@
+// fixtures <sync|set> — manage wallet DATA (never overlay/runtime state). `sync`
+// re-renders the wallet fixture files; `set` applies THE canonical fixture (SRP/
+// password read FROM the fixture, never typed) and always teaches the edit path.
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { walletFixturePath } from '../paths.ts';
+import type { MetaMaskRecipeAdapter } from '../types.ts';
+import { EXIT, flag, parseFlags, resolveAdapter, spawnPorcelain, str, targetOf, usageOut } from './shared.ts';
+
+// One node injected from cli.ts so `fixtures set` can reuse the real engine path
+// (`call`'s one-node machinery) without a circular import.
+export interface CommandDeps {
+  runOneNode: (
+    adapter: MetaMaskRecipeAdapter,
+    action: string,
+    args: Record<string, string>,
+    target: string,
+    actionManifest: string | undefined,
+  ) => Promise<{ status: 'pass' | 'fail' }>;
+}
+
+const FIXTURES_BOOLEANS = new Set(['json']);
+
+export async function handleFixtures(argv: string[], deps: CommandDeps): Promise<number> {
+  const { positional, options } = parseFlags(argv, FIXTURES_BOOLEANS);
+  const json = flag(options, 'json');
+  const sub = positional[0];
+  if (sub !== 'sync' && sub !== 'set') {
+    return usageOut(json, 'fixtures', 'fixtures requires a subcommand: mm-harness fixtures <sync|set>');
+  }
+  const target = targetOf(options);
+  const adapter = resolveAdapter(options, target);
+  if (!adapter) return usageOut(json, 'fixtures', `could not detect the MetaMask repo type for ${target}`);
+  if (adapter === 'core') return usageOut(json, 'fixtures', 'core is headless; it has no wallet fixture.');
+
+  const canonicalFixture = walletFixturePath(target);
+
+  if (sub === 'sync') {
+    // Re-render the wallet fixture files onto the checkout (wallet DATA only).
+    const result = spawnPorcelain(adapter, ['sync'], target, json);
+    if (json) {
+      console.log(
+        JSON.stringify(
+          { schemaVersion: 1, command: 'fixtures', action: 'sync', adapter, fixture: canonicalFixture, exitCode: result.status === 0 ? EXIT.ok : EXIT.runtime },
+          null,
+          2,
+        ),
+      );
+    }
+    return result.status === 0 ? EXIT.ok : EXIT.runtime;
+  }
+
+  // set — apply THE canonical wallet fixture (password read FROM the fixture).
+  // Env-gap resolution (docs/CLI-SPEC.md Part 4): flag > env RECIPE_WALLET_FIXTURE
+  // > the slot's canonical fixture.
+  const fixturePath = path.resolve(str(options, 'fixture') ?? process.env.RECIPE_WALLET_FIXTURE ?? canonicalFixture);
+  let status: 'pass' | 'fail';
+  if (adapter === 'mobile') {
+    // Grounded porcelain: mm-recipe setup-wallet [<fixture>].
+    const result = spawnPorcelain('mobile', ['setup-wallet', fixturePath], target, json);
+    status = result.status === 0 ? 'pass' : 'fail';
+  } else {
+    // Extension has no standalone porcelain set arm — reuse call's one-node
+    // machinery via the real engine path (metamask.wallet.setup in the manifest).
+    if (!fs.existsSync(fixturePath)) {
+      return usageOut(
+        json,
+        'fixtures',
+        `no wallet fixture at ${fixturePath}.\n  Create it (or pass --fixture <path>), then re-run: mm-harness fixtures set`,
+      );
+    }
+    const previousFixtureEnv = process.env.RECIPE_WALLET_FIXTURE;
+    process.env.RECIPE_WALLET_FIXTURE = fixturePath;
+    try {
+      const result = await deps.runOneNode('extension', 'metamask.wallet.setup', {}, target, str(options, 'actionManifest'));
+      status = result.status;
+    } finally {
+      if (previousFixtureEnv === undefined) delete process.env.RECIPE_WALLET_FIXTURE;
+      else process.env.RECIPE_WALLET_FIXTURE = previousFixtureEnv;
+    }
+  }
+
+  // Always teach where to customize the wallet.
+  const teaching = `Wallet fixture applied.  Want different accounts? Edit: ${canonicalFixture}`;
+  if (json) {
+    console.log(
+      JSON.stringify(
+        { schemaVersion: 1, command: 'fixtures', action: 'set', adapter, fixture: fixturePath, canonicalFixture, status, exitCode: status === 'pass' ? EXIT.ok : EXIT.runtime, message: teaching },
+        null,
+        2,
+      ),
+    );
+  } else {
+    console.error(teaching);
+  }
+  return status === 'pass' ? EXIT.ok : EXIT.runtime;
+}

package/runner/src/commands/launch.ts

@@ -0,0 +1,397 @@
+// launch — start the app (Metro/build + surface), auto-ensure the runtime overlay,
+// and heal transport within bounds. Owns launch grammar, build-tier selection,
+// quick-launch change detection, and the --json contract. Device orchestration is
+// not rewritten: each tier composes the same porcelain the standalone bins expose,
+// and --verify reuses the overlay `live` sequence via handleHarness.
+
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+
+import { handleHarness } from '../harness.ts';
+import { recipeRuntimePath } from '../paths.ts';
+import type { MetaMaskRecipeAdapter } from '../types.ts';
+import {
+  EXIT,
+  flag,
+  parseFlags,
+  resolveAdapter,
+  spawnPorcelain,
+  str,
+  targetOf,
+  usageOut,
+} from './shared.ts';
+import type { DeviceAdapter } from './shared.ts';
+import {
+  RECOVERY_CODE,
+  checkHealBounds,
+  ensureOverlay,
+  newHealState,
+  parseHeal,
+} from '../heal-bounds.ts';
+import type { HealState } from '../heal-bounds.ts';
+
+interface LaunchFailure {
+  code: string;
+  message: string;
+  recoverable: boolean;
+  userAction?: string;
+  exitCode: number;
+  // The original porcelain output, surfaced verbatim (never replaced by the note).
+  originalError?: string;
+}
+
+const LAUNCH_BOOLEANS = new Set([
+  'build',
+  'watch',
+  'verify',
+  'sidepanel',
+  'fullscreen',
+  'runway',
+  'json',
+  'jsonStream',
+  'yes',
+]);
+
+export async function handleLaunch(argv: string[]): Promise<number> {
+  const { positional, options } = parseFlags(argv, LAUNCH_BOOLEANS);
+  const json = flag(options, 'json');
+  const target = targetOf(options);
+
+  const heal = parseHeal(options, 'auto');
+  if (typeof heal !== 'string') return usageOut(json, 'launch', heal.error);
+
+  // Grammar: mobile requires an ios|android positional (also disambiguates the
+  // adapter); extension takes no positional; core is headless (teaching error).
+  const posToken = positional[0];
+  const mobileTargetToken = posToken === 'ios' || posToken === 'android' ? posToken : undefined;
+  const platformFlag = str(options, 'platform');
+  const platformMobileToken =
+    platformFlag === 'ios' || platformFlag === 'android' ? platformFlag : undefined;
+  const mobileTarget = mobileTargetToken ?? platformMobileToken;
+  const adapterHint: MetaMaskRecipeAdapter | undefined = mobileTarget ? 'mobile' : undefined;
+  const adapter = resolveAdapter(options, target, adapterHint);
+
+  if (!adapter) {
+    return usageOut(
+      json,
+      'launch',
+      `could not detect the MetaMask repo type for ${target}\n  Next: pass --adapter mobile|extension, or run inside a checkout.`,
+    );
+  }
+  if (adapter === 'core') {
+    return usageOut(json, 'launch', 'core is headless; there is nothing to launch. Use: mm-harness verify');
+  }
+  if (adapter === 'mobile' && !mobileTarget) {
+    return usageOut(
+      json,
+      'launch',
+      'target is required for mobile.\n  Run: mm-harness launch ios   or   mm-harness launch android',
+    );
+  }
+
+  const wantBuild = flag(options, 'build');
+  const wantVerify = flag(options, 'verify');
+  const wantWatch = flag(options, 'watch');
+  const wantRunway = flag(options, 'runway');
+
+  // --runway is mobile-only.
+  if (wantRunway && adapter !== 'mobile') {
+    return usageOut(json, 'launch', 'runway is mobile-only. Drop --runway for the extension.');
+  }
+  // --fullscreen is the explicit override when both display flags are passed.
+  const displayMode =
+    flag(options, 'sidepanel') && !flag(options, 'fullscreen') ? 'sidepanel' : 'fullscreen';
+
+  // Env-gap flags (docs/CLI-SPEC.md Part 4): --device / --cdp-port / --watcher-port.
+  // Resolution is flag > env > config/default: setting the env from the flag makes
+  // the flag win; an absent flag leaves the agent/CI env untouched; the porcelain
+  // owns config/default. Ports must be numeric (teaching error otherwise).
+  for (const portFlag of ['cdpPort', 'watcherPort'] as const) {
+    const value = str(options, portFlag);
+    if (value !== undefined && !/^\d+$/u.test(value)) {
+      return usageOut(json, 'launch', `--${portFlag === 'cdpPort' ? 'cdp-port' : 'watcher-port'} must be numeric (got: ${value}).`);
+    }
+  }
+  applyLaunchEnvOverrides(options, adapter, mobileTarget);
+
+  const tier = wantVerify ? 'verify' : wantBuild ? 'build' : 'quick';
+  const state = newHealState();
+
+  // Quick-launch change detection: refuse a quick relaunch on a stale native
+  // build (native inputs changed since the recorded build baseline).
+  if (tier === 'quick' && nativeInputsChanged(target, adapter)) {
+    return usageOut(
+      json,
+      'launch',
+      `native build inputs changed since last build — run: mm-harness launch ${
+        adapter === 'mobile' ? `${mobileTarget} ` : ''
+      }--build`,
+    );
+  }
+
+  // Auto-ensure overlay (install phase).
+  const ensured = await ensureOverlay(adapter, target, heal, state, json);
+  if (!ensured.ok) {
+    return launchFail(json, adapter, mobileTarget, tier, state, {
+      code: 'OVERLAY_INSTALL_FAILED',
+      message: ensured.error ?? 'overlay install failed',
+      recoverable: false,
+      exitCode: EXIT.infra,
+    });
+  }
+
+  // --verify absorbs the retired `live` sequence: overlay ensured above → launch
+  // → CDP/bridge poll → smoke verify, all via the existing overlay orchestration.
+  if (tier === 'verify') {
+    const liveArgs = ['live', '--adapter', adapter, '--target', target];
+    if (adapter === 'mobile' && mobileTarget) liveArgs.push('--platform', mobileTarget);
+    if (json) liveArgs.push('--json');
+    const code = await handleHarness(liveArgs);
+    // handleHarness owns its own summary in --json mode; the overlay mutations we
+    // performed are surfaced to stderr in human mode above.
+    return code;
+  }
+
+  // Compose the launch tier via the porcelain (same path the porcelain commands use).
+  const launchArgs = launchComposition(adapter, mobileTarget, tier, wantWatch);
+  let attempt = spawnPorcelain(adapter, launchArgs, target, json);
+
+  if (attempt.status === 0) {
+    return finishLaunch(json, adapter, mobileTarget, tier, displayMode, target, state);
+  }
+
+  // Bounds are ALWAYS enforced regardless of --heal.
+  if (heal === 'off') {
+    return launchFail(json, adapter, mobileTarget, tier, state, {
+      code: 'LAUNCH_FAILED',
+      message: `launch ${adapter}${mobileTarget ? ` ${mobileTarget}` : ''} failed (healing off)`,
+      recoverable: false,
+      exitCode: EXIT.infra,
+    });
+  }
+  // Healing bounds (shared module — policy, not per-command). null = ok to proceed.
+  const bound = checkHealBounds(target, attempt.output, state);
+  if (bound !== null) {
+    return launchFail(json, adapter, mobileTarget, tier, state, {
+      code: bound.code,
+      message: bound.message,
+      recoverable: false,
+      userAction: bound.userAction,
+      exitCode: bound.exitCode,
+      originalError: bound.originalError,
+    });
+  }
+
+  // Infra recovery: attempt the SAME launch exactly once (the porcelain restarts
+  // Metro / reopens Chrome). Push recoveryCode BEFORE the attempt so any
+  // subsequent checkHealBounds call sees it and refuses a second loop.
+  const recoveryCode = RECOVERY_CODE[adapter];
+  state.attemptedRecoveries.push(recoveryCode);
+  attempt = spawnPorcelain(adapter, launchArgs, target, json);
+  if (attempt.status === 0) {
+    state.recovered.push(recoveryCode);
+    return finishLaunch(json, adapter, mobileTarget, tier, displayMode, target, state);
+  }
+  // Second attempt failed — same-recovery-twice bound hit.
+  return launchFail(json, adapter, mobileTarget, tier, state, {
+    code: 'SAME_RECOVERY_TWICE',
+    message: `launch ${adapter}${mobileTarget ? ` ${mobileTarget}` : ''} failed again after ${recoveryCode} recovery — refusing to loop.`,
+    recoverable: false,
+    exitCode: EXIT.bounded,
+    originalError: attempt.output.trim() || undefined,
+  });
+}
+
+// Map the env-gap flags onto the env vars the porcelain reads. Only the canonical
+// var plus its documented aliases are set, and only when the flag is present, so
+// flag > env > config/default holds. --device targets the simulator (ios) or the
+// adb serial (android); ports are set with their runtime aliases.
+function applyLaunchEnvOverrides(
+  options: Record<string, string | boolean>,
+  adapter: DeviceAdapter,
+  mobileTarget: string | undefined,
+): void {
+  const device = str(options, 'device');
+  if (device && adapter === 'mobile') {
+    if (mobileTarget === 'android') {
+      process.env.ADB_SERIAL = device;
+      process.env.ANDROID_SERIAL = device;
+      process.env.ANDROID_DEVICE = device;
+    } else {
+      process.env.IOS_SIMULATOR = device;
+    }
+  }
+  const cdpPort = str(options, 'cdpPort');
+  if (cdpPort) {
+    process.env.CDP_PORT = cdpPort;
+    process.env.RECIPE_CDP_PORT = cdpPort;
+  }
+  const watcherPort = str(options, 'watcherPort');
+  if (watcherPort) {
+    process.env.WATCHER_PORT = watcherPort;
+    process.env.RECIPE_WATCHER_PORT = watcherPort;
+    process.env.METRO_PORT = watcherPort;
+  }
+}
+
+// Native build inputs changed vs the recorded build baseline (git diff heuristic,
+// mirrors the farm-layer native-diff). No baseline recorded → cannot be stale →
+// allow the quick launch.
+function nativeInputsChanged(target: string, adapter: MetaMaskRecipeAdapter): boolean {
+  const baselineFile = recipeRuntimePath(target, '.last-build-ref');
+  let baseline: string;
+  try {
+    baseline = fs.readFileSync(baselineFile, 'utf8').trim();
+  } catch {
+    return false;
+  }
+  if (!baseline) return false;
+  const paths =
+    adapter === 'mobile'
+      ? ['ios', 'android', 'package.json', 'yarn.lock']
+      : ['package.json', 'yarn.lock', 'webpack.config.js'];
+  try {
+    const diff = execFileSync('git', ['-C', target, 'diff', '--name-only', baseline, '--', ...paths], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim();
+    return diff.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+// Map (adapter, tier) → the grounded porcelain sub-command.
+//   mobile quick : mm-recipe <ios|android>       (quick relaunch)
+//   mobile build : mm-recipe up                  (decision-aware full build)
+//   extension quick: mme-recipe rebuild          (snapshot dist + reopen)
+//   extension build: mme-recipe build            (webpack build)
+//   extension watch: mme-recipe watch            (webpack watch)
+function launchComposition(
+  adapter: DeviceAdapter,
+  mobileTarget: string | undefined,
+  tier: 'quick' | 'build' | 'verify',
+  wantWatch: boolean,
+): string[] {
+  if (adapter === 'mobile') {
+    if (tier === 'build') return ['up'];
+    return [mobileTarget ?? 'ios'];
+  }
+  // extension
+  if (wantWatch) return ['watch'];
+  if (tier === 'build') return ['build'];
+  return ['rebuild'];
+}
+
+// Apply the extension display mode AFTER the base launch succeeded, then emit the
+// pass summary. Fullscreen = the plain rebuild/build/watch launch above (the
+// default popup/home window). Sidepanel additionally drives the chrome.sidePanel
+// mechanism via the porcelain: `mme-recipe sidepanel open`
+// (orchestration/porcelain/mme-recipe → orchestration/extension/sidepanel-toggle.sh `open`), so
+// --sidepanel and --fullscreen compose DIFFERENT porcelain calls and the display
+// mode actually reaches orchestration. Mobile has no side panel, so the flag is a
+// no-op there.
+function finishLaunch(
+  json: boolean,
+  adapter: DeviceAdapter,
+  mobileTarget: string | undefined,
+  tier: string,
+  displayMode: string,
+  target: string,
+  state: HealState,
+): number {
+  if (adapter === 'extension' && displayMode === 'sidepanel') {
+    const sidepanel = spawnPorcelain('extension', ['sidepanel', 'open'], target, json);
+    if (sidepanel.status !== 0) {
+      return launchFail(json, adapter, mobileTarget, tier, state, {
+        code: 'SIDEPANEL_OPEN_FAILED',
+        message: 'app launched but opening the side panel failed.',
+        recoverable: false,
+        exitCode: EXIT.runtime,
+        originalError: sidepanel.output.trim() || undefined,
+      });
+    }
+  }
+  return launchPass(json, adapter, mobileTarget, tier, displayMode, state);
+}
+
+function launchPass(
+  json: boolean,
+  adapter: DeviceAdapter,
+  mobileTarget: string | undefined,
+  tier: string,
+  displayMode: string,
+  state: HealState,
+): number {
+  if (json) {
+    console.log(
+      JSON.stringify(
+        {
+          schemaVersion: 1,
+          command: 'launch',
+          adapter,
+          platform: mobileTarget ?? (adapter === 'extension' ? displayMode : null),
+          tier,
+          status: 'pass',
+          phase: 'launch',
+          recovered: state.recovered,
+          mutations: state.mutations,
+          exitCode: EXIT.ok,
+        },
+        null,
+        2,
+      ),
+    );
+  } else {
+    console.error(`✓ launch ${adapter}${mobileTarget ? ` ${mobileTarget}` : ''} (${tier}) ready`);
+  }
+  return EXIT.ok;
+}
+
+function launchFail(
+  json: boolean,
+  adapter: DeviceAdapter,
+  mobileTarget: string | undefined,
+  tier: string,
+  state: HealState,
+  failure: LaunchFailure,
+): number {
+  if (json) {
+    console.log(
+      JSON.stringify(
+        {
+          schemaVersion: 1,
+          command: 'launch',
+          adapter,
+          platform: mobileTarget ?? null,
+          tier,
+          status: 'fail',
+          phase: state.attemptedRecoveries.length ? 'recover' : 'launch',
+          recovered: state.recovered,
+          mutations: state.mutations,
+          recoverable: failure.recoverable,
+          attemptedRecoveries: state.attemptedRecoveries,
+          exitCode: failure.exitCode,
+          error: {
+            code: failure.code,
+            message: failure.message,
+            retryable: failure.recoverable,
+            userAction: failure.userAction ?? null,
+            // The classification note is in `message`; the REAL failure text lives
+            // here verbatim so it is never lost.
+            originalError: failure.originalError ?? null,
+          },
+        },
+        null,
+        2,
+      ),
+    );
+  } else {
+    console.error(
+      `✗ launch ${adapter}${mobileTarget ? ` ${mobileTarget}` : ''} failed\n  ${failure.message}` +
+        (failure.originalError ? `\n  --- original failure ---\n${failure.originalError}` : '') +
+        (failure.userAction ? `\n  Next: ${failure.userAction}` : ''),
+    );
+  }
+  return failure.exitCode;
+}

package/runner/src/commands/logs.ts

@@ -0,0 +1,60 @@
+// logs — tail Metro/webpack + app logs by composing the porcelain `logs` (+
+// --full). Teaches (exit 2) when nothing is running for the checkout.
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { recipeRuntimePath } from '../paths.ts';
+import { EXIT, flag, parseFlags, resolveAdapter, spawnPorcelain, str, targetOf, usageOut } from './shared.ts';
+
+const LOGS_BOOLEANS = new Set(['full', 'json']);
+
+export async function handleLogs(argv: string[]): Promise<number> {
+  const { options } = parseFlags(argv, LOGS_BOOLEANS);
+  const json = flag(options, 'json');
+  const target = targetOf(options);
+  const adapter = resolveAdapter(options, target);
+
+  if (!adapter) return usageOut(json, 'logs', `could not detect the MetaMask repo type for ${target}`);
+  if (adapter === 'core') return usageOut(json, 'logs', 'core is headless; there are no app/Metro logs.');
+
+  const source = str(options, 'source') ?? 'metro';
+  if (source !== 'metro' && source !== 'app') {
+    return usageOut(json, 'logs', '--source must be metro or app.');
+  }
+
+  // Env-gap flag (docs/CLI-SPEC.md Part 4): --events sets the compact event count
+  // the porcelain reads from RECIPE_LOG_EVENTS. Resolution is flag > env > default:
+  // the flag wins by setting the env; an absent flag leaves the agent/CI env alone.
+  const events = str(options, 'events');
+  if (events !== undefined) {
+    if (!/^\d+$/u.test(events)) return usageOut(json, 'logs', `--events must be numeric (got: ${events}).`);
+    process.env.RECIPE_LOG_EVENTS = events;
+  }
+
+  // Nothing running → teaching error pointing at launch. The log file is the
+  // signal that Metro/webpack has been started for this checkout.
+  const logFile = recipeRuntimePath(target, adapter === 'mobile' ? 'metro.log' : 'webpack.log');
+  if (!fs.existsSync(logFile)) {
+    const launchHint = adapter === 'mobile' ? 'mm-harness launch ios' : 'mm-harness launch';
+    return usageOut(
+      json,
+      'logs',
+      `nothing running for this checkout (no ${path.basename(logFile)}).\n  Start it first: ${launchHint}`,
+    );
+  }
+
+  const args = ['logs'];
+  if (flag(options, 'full')) args.push('--full');
+  const result = spawnPorcelain(adapter, args, target, json);
+  if (json) {
+    console.log(
+      JSON.stringify(
+        { schemaVersion: 1, command: 'logs', adapter, source, logFile, exitCode: result.status === 0 ? EXIT.ok : EXIT.runtime },
+        null,
+        2,
+      ),
+    );
+  }
+  return result.status === 0 ? EXIT.ok : EXIT.runtime;
+}