agoric 0.21.2-mainnet1B-dev-26244e8.0 → 0.21.2-orchestration-dev-096c4e8.0

package/src/start.js

@@ -1,3 +1,4 @@
+/* eslint @typescript-eslint/no-floating-promises: "warn" */
 /* global process setTimeout */
 import chalk from 'chalk';
 import { createHash } from 'crypto';
@@ -40,6 +41,7 @@ const DELEGATE0_COINS = `50000000${STAKING_DENOM}`;
 const SOLO_COINS = `13000000${STAKING_DENOM},500000000${CENTRAL_DENOM}`;
 const CHAIN_ID = 'agoriclocal';
 
+const SERVERS_ROOT_DIR = '_agstate/agoric-servers';
 const FAKE_CHAIN_DELAY =
   process.env.FAKE_CHAIN_DELAY === undefined
     ? 0
@@ -69,10 +71,10 @@ export default async function startMain(progname, rawArgs, powers, opts) {
   const pspawnEnv = { ...process.env };
   if (opts.verbose > 1) {
     // Loudly verbose logs (nondeterministic).
-    pspawnEnv.DEBUG = 'agoric,SwingSet:vat,SwingSet:ls';
+    pspawnEnv.DEBUG = 'agoric:debug,SwingSet:vat,SwingSet:ls';
   } else if (opts.verbose) {
     // Verbose vat logs (nondeterministic).
-    pspawnEnv.DEBUG = 'SwingSet:vat,SwingSet:ls';
+    pspawnEnv.DEBUG = 'agoric:info,SwingSet:vat,SwingSet:ls';
   }
 
   const pspawn = makePspawn({ env: pspawnEnv, spawn, log, chalk });
@@ -151,6 +153,7 @@ export default async function startMain(progname, rawArgs, powers, opts) {
     ]);
 
   const exists = async file => {
+    await null;
     try {
       await fs.stat(file);
       return true;
@@ -159,6 +162,12 @@ export default async function startMain(progname, rawArgs, powers, opts) {
     }
   };
 
+  const rmVerbose = async filePath => {
+    log(chalk.green(`removing ${filePath}`));
+    // rm is available on all the unix-likes, so use it for speed.
+    await pspawn('rm', ['-rf', filePath]);
+  };
+
   let agSolo;
   let agSoloBuild;
   if (opts.dockerTag) {
@@ -171,12 +180,11 @@ export default async function startMain(progname, rawArgs, powers, opts) {
     const fakeDelay =
       popts.delay === undefined ? FAKE_CHAIN_DELAY : Number(popts.delay);
 
-    const agServer = `_agstate/agoric-servers/${profileName}`;
+    const serverDir = `${SERVERS_ROOT_DIR}/${profileName}`;
 
+    await null;
     if (popts.reset) {
-      log(chalk.green(`removing ${agServer}`));
-      // rm is available on all the unix-likes, so use it for speed.
-      await pspawn('rm', ['-rf', agServer]);
+      await rmVerbose(serverDir);
     }
 
     if (!opts.dockerTag) {
@@ -197,14 +205,14 @@ export default async function startMain(progname, rawArgs, powers, opts) {
     }
 
     const fakeGCI = 'sim-chain';
-    const serverExists = await exists(agServer);
+    const serverExists = await exists(serverDir);
     if (!serverExists) {
       log(chalk.yellow(`initializing ${profileName}`));
       await pspawn(
         agSolo,
         ['init', profileName, '--egresses=fake', `--webport=${HOST_PORT}`],
         {
-          cwd: '_agstate/agoric-servers',
+          cwd: SERVERS_ROOT_DIR,
         },
       );
     }
@@ -215,7 +223,7 @@ export default async function startMain(progname, rawArgs, powers, opts) {
         agSolo,
         ['set-fake-chain', `--delay=${fakeDelay}`, fakeGCI],
         {
-          cwd: agServer,
+          cwd: serverDir,
         },
       );
     }
@@ -226,7 +234,7 @@ export default async function startMain(progname, rawArgs, powers, opts) {
     }
 
     const ps = pspawn(agSolo, [...debugOpts, 'start'], {
-      cwd: agServer,
+      cwd: serverDir,
       env: nodeDebugEnv,
     });
     process.on('SIGINT', () => ps.childProcess.kill('SIGINT'));
@@ -246,6 +254,7 @@ export default async function startMain(progname, rawArgs, powers, opts) {
     }
 
     const { cosmosChain, cosmosChainBuild } = getSDKBinaries(sdkPrefixes);
+    await null;
     if (popts.pull || popts.rebuild) {
       if (popts.dockerTag) {
         const exitStatus = await pspawn('docker', ['pull', SDK_IMAGE]);
@@ -263,17 +272,15 @@ export default async function startMain(progname, rawArgs, powers, opts) {
       }
     }
 
-    const agServer = `_agstate/agoric-servers/${profileName}-${portNum}`;
+    const serverDir = `${SERVERS_ROOT_DIR}/${profileName}-${portNum}`;
     if (popts.reset) {
-      log(chalk.green(`removing ${agServer}`));
-      // rm is available on all the unix-likes, so use it for speed.
-      await pspawn('rm', ['-rf', agServer]);
+      await rmVerbose(serverDir);
     }
 
     let chainSpawn;
     if (!popts.dockerTag) {
       chainSpawn = (args, spawnOpts = undefined) => {
-        return pspawn(cosmosChain, [...args, `--home=${agServer}`], spawnOpts);
+        return pspawn(cosmosChain, [...args, `--home=${serverDir}`], spawnOpts);
       };
     } else {
       chainSpawn = (args, spawnOpts = undefined, dockerArgs = []) =>
@@ -287,13 +294,13 @@ export default async function startMain(progname, rawArgs, powers, opts) {
             ...terminalOnlyFlags(`-it`),
             SDK_IMAGE,
             ...args,
-            `--home=/usr/src/dapp/${agServer}`,
+            `--home=/usr/src/dapp/${serverDir}`,
           ],
           spawnOpts,
         );
     }
 
-    const serverExists = await exists(agServer);
+    const serverExists = await exists(serverDir);
     if (!serverExists) {
       const exitStatus = await chainSpawn([
         'init',
@@ -308,7 +315,6 @@ export default async function startMain(progname, rawArgs, powers, opts) {
     // Get or create the essential addresses.
     const addrs = {};
     for (const keyName of ['provision', 'delegate0']) {
-      /* eslint-disable no-await-in-loop */
       let statusOut = showKey(keyName);
       const exitStatusOut = await statusOut[0];
       if (exitStatusOut) {
@@ -331,7 +337,7 @@ export default async function startMain(progname, rawArgs, powers, opts) {
       /* eslint-enable no-await-in-loop */
     }
 
-    const genesisFile = `${agServer}/config/genesis.json`;
+    const genesisFile = `${serverDir}/config/genesis.json`;
     const stampExists = await exists(`${genesisFile}.stamp`);
     if (!stampExists) {
       let exitStatus;
@@ -361,7 +367,7 @@ export default async function startMain(progname, rawArgs, powers, opts) {
         `--keyring-dir=${keysHome}`,
         '--keyring-backend=test',
         `--chain-id=${CHAIN_ID}`,
-        `${DELEGATE0_COINS}`,
+        DELEGATE0_COINS,
       ]);
       if (exitStatus) {
         return exitStatus;
@@ -382,8 +388,8 @@ export default async function startMain(progname, rawArgs, powers, opts) {
 
     // Complete the genesis file and launch the chain.
     log('read ag-chain-cosmos config');
-    const configFile = `${agServer}/config/config.toml`;
-    const appFile = `${agServer}/config/app.toml`;
+    const configFile = `${serverDir}/config/config.toml`;
+    const appFile = `${serverDir}/config/app.toml`;
     const [genesisJson, configToml, appToml] = await Promise.all([
       fs.readFile(genesisFile, 'utf-8'),
       fs.readFile(configFile, 'utf-8'),
@@ -446,9 +452,10 @@ export default async function startMain(progname, rawArgs, powers, opts) {
       return 1;
     }
 
-    const agServer = `_agstate/agoric-servers/${profileName}-${portNum}`;
+    const serverDir = `${SERVERS_ROOT_DIR}/${profileName}-${portNum}`;
 
     const { cosmosClientBuild } = getSDKBinaries(sdkPrefixes);
+    await null;
     if (popts.pull || popts.rebuild) {
       if (popts.dockerTag) {
         const exitStatus = await pspawn('docker', ['pull', SDK_IMAGE]);
@@ -474,9 +481,7 @@ export default async function startMain(progname, rawArgs, powers, opts) {
     }
 
     if (popts.reset) {
-      log(chalk.green(`removing ${agServer}`));
-      // rm is available on all the unix-likes, so use it for speed.
-      await pspawn('rm', ['-rf', agServer]);
+      await rmVerbose(serverDir);
     }
 
     let soloSpawn;
@@ -491,7 +496,7 @@ export default async function startMain(progname, rawArgs, powers, opts) {
             'run',
             `--volume=${process.cwd()}:/usr/src/dapp`,
             `--volume=${process.env.HOME}/.agoric:/root/.agoric`,
-            `-eAG_SOLO_BASEDIR=/usr/src/dapp/${agServer}`,
+            `-eAG_SOLO_BASEDIR=/usr/src/dapp/${serverDir}`,
             `--rm`,
             ...terminalOnlyFlags(`-it`),
             `--entrypoint=ag-solo`,
@@ -503,7 +508,7 @@ export default async function startMain(progname, rawArgs, powers, opts) {
         );
     }
 
-    const serverExists = await exists(agServer);
+    const serverExists = await exists(serverDir);
     // Initialise the solo directory and key.
     if (!serverExists) {
       const initArgs = [`--webport=${portNum}`];
@@ -511,7 +516,7 @@ export default async function startMain(progname, rawArgs, powers, opts) {
         initArgs.push(`--webhost=0.0.0.0`);
       }
       const exitStatus = await soloSpawn(
-        ['init', agServer, ...initArgs],
+        ['init', serverDir, ...initArgs],
         undefined,
         [`--workdir=/usr/src/dapp`],
       );
@@ -522,15 +527,15 @@ export default async function startMain(progname, rawArgs, powers, opts) {
 
     // Create the full economy chain config.
     const agServerResolve = spec =>
-      require.resolve(spec, { paths: [agServer] });
+      require.resolve(spec, { paths: [serverDir] });
     const coreConfigPath = agServerResolve(
-      '@agoric/vats/decentral-core-config.json',
+      '@agoric/vm-config/decentral-core-config.json',
     );
     const economyTemplPath = agServerResolve(
       '@agoric/cosmic-swingset/economy-template.json',
     );
     const [rawSoloAddr, coreConfigJson, economyTemplJson] = await Promise.all([
-      fs.readFile(`${agServer}/ag-cosmos-helper-address`, 'utf-8'),
+      fs.readFile(`${serverDir}/ag-cosmos-helper-address`, 'utf-8'),
       fs.readFile(coreConfigPath, 'utf-8'),
       fs.readFile(economyTemplPath, 'utf-8'),
     ]);
@@ -541,7 +546,7 @@ export default async function startMain(progname, rawArgs, powers, opts) {
     const economyConfig = JSON.parse(coreConfigJson);
     economyConfig.coreProposals = economyProposals;
     await fs.writeFile(
-      `${agServer}/decentral-economy-config.json`,
+      `${serverDir}/decentral-economy-config.json`,
       JSON.stringify(economyConfig, null, 2),
     );
 
@@ -549,13 +554,12 @@ export default async function startMain(progname, rawArgs, powers, opts) {
       return 0;
     }
 
-    const gciFile = `_agstate/agoric-servers/local-chain-${CHAIN_PORT}/config/genesis.json.sha256`;
+    const gciFile = `${SERVERS_ROOT_DIR}/local-chain-${CHAIN_PORT}/config/genesis.json.sha256`;
     process.stdout.write(`Waiting for local-chain-${CHAIN_PORT} to start...`);
     let hasGci = false;
     for await (const _ of untilTrue(() => hasGci)) {
       process.stdout.write('.');
 
-      // eslint-disable-next-line no-await-in-loop
       await new Promise((resolve, reject) => {
         fs.stat(gciFile).then(
           _2 => {
@@ -576,7 +580,7 @@ export default async function startMain(progname, rawArgs, powers, opts) {
 
     const spawnOpts = {};
     if (!popts.dockerTag) {
-      spawnOpts.cwd = agServer;
+      spawnOpts.cwd = serverDir;
     }
 
     const rpcAddrs = [`localhost:${CHAIN_PORT}`];
@@ -590,7 +594,6 @@ export default async function startMain(progname, rawArgs, powers, opts) {
     let bestRpcAddr;
     for await (const _ of untilTrue(() => bestRpcAddr)) {
       for await (const rpcAddr of rpcAddrs) {
-        // eslint-disable-next-line no-await-in-loop
         exitStatus = await keysSpawn([
           'query',
           'swingset',
@@ -639,7 +642,6 @@ export default async function startMain(progname, rawArgs, powers, opts) {
           ];
           for (/* await */ const cmd of provCmds) {
             const statusOut = capture(keysSpawn, cmd, true);
-            // eslint-disable-next-line no-await-in-loop
             exitStatus = await statusOut[0];
             if (!exitStatus) {
               const json = statusOut[1].replace(/^gas estimate: \d+$/m, '');
@@ -664,7 +666,6 @@ export default async function startMain(progname, rawArgs, powers, opts) {
         }
       }
       if (!bestRpcAddr) {
-        // eslint-disable-next-line no-await-in-loop
         await delay(2000);
       }
     }
@@ -690,6 +691,7 @@ export default async function startMain(progname, rawArgs, powers, opts) {
   }
 
   async function startTestnetDocker(profileName, startArgs, popts) {
+    await null;
     if (popts.dockerTag && popts.pull) {
       const exitStatus = await pspawn('docker', ['pull', SOLO_IMAGE]);
       if (exitStatus) {
@@ -699,12 +701,10 @@ export default async function startMain(progname, rawArgs, powers, opts) {
 
     const port = startArgs[0] || PORT;
     const netconfig = startArgs[1] || DEFAULT_NETCONFIG;
-    const agServer = `_agstate/agoric-servers/${profileName}-${port}`;
+    const serverDir = `${SERVERS_ROOT_DIR}/${profileName}-${port}`;
 
     if (popts.reset) {
-      log(chalk.green(`removing ${agServer}`));
-      // rm is available on all the unix-likes, so use it for speed.
-      await pspawn('rm', ['-rf', agServer]);
+      await rmVerbose(serverDir);
     }
 
     const setupRun = (...bonusArgs) =>
@@ -712,7 +712,7 @@ export default async function startMain(progname, rawArgs, powers, opts) {
         'run',
         `-p127.0.0.1:${HOST_PORT}:${port}`,
         `--volume=${process.cwd()}:/usr/src/dapp`,
-        `-eAG_SOLO_BASEDIR=/usr/src/dapp/${agServer}`,
+        `-eAG_SOLO_BASEDIR=/usr/src/dapp/${serverDir}`,
         `--rm`,
         ...terminalOnlyFlags(`-it`),
         SOLO_IMAGE,
@@ -727,44 +727,38 @@ export default async function startMain(progname, rawArgs, powers, opts) {
   async function startTestnetSdk(profileName, startArgs, popts) {
     const port = startArgs[0] || PORT;
     const netconfig = startArgs[1] || DEFAULT_NETCONFIG;
-    const agServer = `_agstate/agoric-servers/${profileName}-${port}`;
+    const serverDir = `${SERVERS_ROOT_DIR}/${profileName}-${port}`;
 
+    await null;
     if (popts.reset) {
-      log(chalk.green(`removing ${agServer}`));
-      // rm is available on all the unix-likes, so use it for speed.
-      await pspawn('rm', ['-rf', agServer]);
+      await rmVerbose(serverDir);
     }
 
     const setupRun = (...bonusArgs) =>
       pspawn(agSolo, [`--webport=${port}`, ...bonusArgs], {
-        env: { ...pspawnEnv, AG_SOLO_BASEDIR: agServer },
+        env: { ...pspawnEnv, AG_SOLO_BASEDIR: serverDir },
       });
 
     return setupRun('setup', `--netconfig=${netconfig}`);
   }
 
   const profiles = {
+    __proto__: null,
     dev: startFakeChain,
     'local-chain': startLocalChain,
     'local-solo': startLocalSolo,
     testnet: opts.dockerTag ? startTestnetDocker : startTestnetSdk,
   };
 
-  const popts = opts;
-
-  const args = rawArgs.slice(1);
-  const profileName = args[0] || 'dev';
+  const [_command = 'start', profileName = 'dev', ...args] = rawArgs;
   const startFn = profiles[profileName];
   if (!startFn) {
+    const profileNames = Object.keys(profiles).join(', ');
     log.error(
-      `unrecognized profile name ${profileName}; use one of: ${Object.keys(
-        profiles,
-      )
-        .sort()
-        .join(', ')}`,
+      `unrecognized profile name ${profileName}; use one of: ${profileNames}`,
     );
     return 1;
   }
 
-  return startFn(profileName, args[0] ? args.slice(1) : args, popts);
+  return startFn(profileName, args, opts);
 }

package/tools/getting-started.js

@@ -0,0 +1,273 @@
+/* global process setTimeout clearTimeout setInterval clearInterval */
+
+import fs from 'fs';
+import path from 'path';
+import tmp from 'tmp';
+import { makePromiseKit } from '@endo/promise-kit';
+import { request } from 'http';
+
+import { spawn } from 'child_process';
+
+import { makePspawn } from '../src/helpers.js';
+
+const TIMEOUT_SECONDS = 20 * 60;
+
+const dirname = new URL('./', import.meta.url).pathname;
+
+// To keep in sync with https://agoric.com/documentation/getting-started/
+
+// Note that we currently only test:
+// agoric init dapp-foo
+// agoric install
+// agoric start --reset
+// agoric deploy ./contract/deploy.js ./api/deploy.js
+// (For simple-exchange and autoswap, the above also makes and accepts offers)
+// cd ui && yarn install
+// cd ui && yarn start
+
+export const gettingStartedWorkflowTest = async (t, options = {}) => {
+  const {
+    init: initOptions = [],
+    install: installOptions = [],
+    start: startOptions = [],
+    testUnsafePlugins = false,
+  } = options;
+  // FIXME: Do a search for an unused port or allow specification.
+  const PORT = '7999';
+  process.env.PORT = PORT;
+
+  const pspawn = makePspawn({ spawn });
+
+  // Kill an entire process group.
+  const pkill = (cp, signal = 'SIGINT') => process.kill(-cp.pid, signal);
+
+  function pspawnStdout(...args) {
+    const ps = pspawn(...args);
+    ps.childProcess.stdout.on('data', chunk => {
+      process.stdout.write(chunk);
+    });
+    // ps.childProcess.unref();
+    return ps;
+  }
+
+  const defaultAgoricCmd = () => {
+    // Run all main programs with the '--sdk' flag if we are in agoric-sdk.
+    const extraArgs = fs.existsSync(`${dirname}/../../cosmic-swingset`)
+      ? ['--sdk']
+      : [];
+    const localCli = path.join(dirname, '..', 'bin', 'agoric');
+    return [localCli, ...extraArgs];
+  };
+  const { AGORIC_CMD = JSON.stringify(defaultAgoricCmd()) } = process.env;
+  const agoricCmd = JSON.parse(AGORIC_CMD);
+  function myMain(args, opts = {}) {
+    // console.error('running agoric-cli', ...extraArgs, ...args);
+    return pspawnStdout(agoricCmd[0], [...agoricCmd.slice(1), ...args], {
+      stdio: ['ignore', 'pipe', 'inherit'],
+      env: { ...process.env, DEBUG: 'agoric:debug' },
+      detached: true,
+      ...opts,
+    });
+  }
+
+  const olddir = process.cwd();
+  const { name } = tmp.dirSync({
+    unsafeCleanup: true,
+    prefix: 'agoric-cli-test-',
+  });
+
+  const finalizers = [];
+  const runFinalizers = sig => {
+    while (finalizers.length) {
+      const f = finalizers.shift();
+      try {
+        f();
+      } catch (e) {
+        // console.log(e);
+      }
+    }
+    if (sig) {
+      // We're dying due to signal.
+      process.exit(1);
+    }
+  };
+
+  await null;
+  try {
+    process.on('SIGINT', runFinalizers);
+    process.on('exit', runFinalizers);
+    process.chdir(name);
+
+    // ==============
+    // agoric init dapp-foo
+    if (process.env.AGORIC_INIT_OPTIONS) {
+      const opts = JSON.parse(process.env.AGORIC_INIT_OPTIONS);
+      initOptions.push(...opts);
+    }
+    t.is(
+      await myMain([
+        'init',
+        '--dapp-template',
+        'dapp-fungible-faucet',
+        ...initOptions,
+        'dapp-foo',
+      ]),
+      0,
+      'init dapp-foo works',
+    );
+    process.chdir('dapp-foo');
+
+    // ==============
+    // agoric install
+    if (process.env.AGORIC_INSTALL_OPTIONS) {
+      const opts = JSON.parse(process.env.AGORIC_INSTALL_OPTIONS);
+      installOptions.push(...opts);
+    }
+    t.is(await myMain(['install', ...installOptions]), 0, 'install works');
+
+    // ==============
+    // agoric start --reset
+    const startResult = makePromiseKit();
+
+    if (process.env.AGORIC_START_OPTIONS) {
+      const opts = JSON.parse(process.env.AGORIC_START_OPTIONS);
+      startOptions.push(...opts);
+    }
+
+    // TODO: Allow this to work even if the port is already used.
+    const startP = myMain(['start', '--reset', ...startOptions]);
+    finalizers.push(() => pkill(startP.childProcess, 'SIGINT'));
+
+    let stdoutStr = '';
+    if (startP.childProcess.stdout) {
+      startP.childProcess.stdout.on('data', chunk => {
+        // console.log('stdout:', chunk.toString());
+        stdoutStr += chunk.toString();
+        if (stdoutStr.match(/(^|:\s+)swingset running$/m)) {
+          startResult.resolve(true);
+        }
+      });
+    }
+    startP.childProcess.on('close', code =>
+      startResult.reject(Error(`early termination: ${code}`)),
+    );
+
+    const timeout = setTimeout(
+      startResult.reject,
+      TIMEOUT_SECONDS * 1000,
+      'timeout',
+    );
+    t.is(await startResult.promise, true, `swingset running before timeout`);
+    clearTimeout(timeout);
+
+    const openP = myMain(['open', '--no-browser'], {
+      stdio: ['ignore', 'pipe', 'inherit'],
+    });
+    t.is(await openP, 0, `open --no-browser exits successfully`);
+
+    const testDeploy = async (deployCmd, opts = {}) => {
+      const deployResult = makePromiseKit();
+      const deployP = myMain(
+        ['deploy', `--hostport=127.0.0.1:${PORT}`, ...deployCmd],
+        {
+          stdio: [opts.stdin ? 'pipe' : 'ignore', 'pipe', 'inherit'],
+        },
+      );
+
+      if (opts.stdin) {
+        // Write the input to stdin.
+        deployP.childProcess.stdin.write(opts.stdin);
+        deployP.childProcess.stdin.end();
+      }
+
+      finalizers.push(() => pkill(deployP.childProcess, 'SIGINT'));
+      const to = setTimeout(
+        deployResult.resolve,
+        TIMEOUT_SECONDS * 1000,
+        'timeout',
+      );
+      const done = await Promise.race([deployResult.promise, deployP]);
+      t.is(done, 0, `deploy ${deployCmd.join(' ')} successful before timeout`);
+      clearTimeout(to);
+    };
+
+    // ==============
+    // agoric deploy ./contract/deploy.js ./api/deploy.js
+    await testDeploy(['./contract/deploy.js', './api/deploy.js']);
+
+    for (const [suffix, code] of [
+      ['/notthere', 404],
+      ['', 200],
+    ]) {
+      let urlResolve;
+      const url = `http://127.0.0.1:${PORT}${suffix}`;
+      const urlP = new Promise(resolve => (urlResolve = resolve));
+      const urlReq = request(url, res => urlResolve(res.statusCode));
+      urlReq.setTimeout(2000);
+      urlReq.on('error', err => urlResolve(`Cannot connect to ${url}: ${err}`));
+      urlReq.end();
+      const urlTimeout = setTimeout(urlResolve, 3000, 'timeout');
+      const urlDone = await urlP;
+      clearTimeout(urlTimeout);
+      t.is(urlDone, code, `${url} gave status ${code}`);
+    }
+
+    // ==============
+    // cd ui && yarn start
+    const uiStartP = pspawn(`yarn`, ['start'], {
+      stdio: ['ignore', 'inherit', 'inherit'],
+      cwd: 'ui',
+      env: { ...process.env, PORT: '3000' },
+      detached: true,
+    });
+    finalizers.push(() => pkill(uiStartP.childProcess, 'SIGINT'));
+    const uiListening = makePromiseKit();
+    let retries = 0;
+    const ival = setInterval(() => {
+      try {
+        const resolve = status => {
+          clearInterval(ival);
+          uiListening.resolve(status);
+        };
+
+        retries += 1;
+        if (retries > 8) {
+          resolve('too many retries');
+          return;
+        }
+
+        const req = request('http://localhost:3000/', _res => {
+          resolve('listening');
+        });
+        req.setTimeout(2000);
+        req.on('error', err => {
+          if (err.code !== 'ECONNREFUSED') {
+            resolve(`Cannot connect to UI server: ${err}`);
+          }
+        });
+        req.end();
+      } catch (e) {
+        console.error('cannot make request', e);
+      }
+    }, 3000);
+    t.is(
+      await Promise.race([uiStartP, uiListening.promise]),
+      'listening',
+      `cd ui && yarn start succeeded`,
+    );
+    clearInterval(ival);
+
+    // Test that the Node.js `-r esm`-dependent plugin works.
+    await (testUnsafePlugins &&
+      testDeploy(
+        ['--allow-unsafe-plugins', `${dirname}/resm-plugin/deploy.js`],
+        { stdin: 'yes\n' },
+      ));
+
+    // TODO: When it exists, Test that the Node.js native ESM plugin works.
+  } finally {
+    runFinalizers();
+    process.off('SIGINT', runFinalizers);
+    process.chdir(olddir);
+  }
+};

package/tools/resm-plugin/deploy.js

@@ -0,0 +1,18 @@
+/* globals setTimeout */
+import { E } from '@endo/eventual-send';
+
+const PONG_TIMEOUT = 10_000;
+
+export default async function deployPlugin(
+  homePromise,
+  { installUnsafePlugin },
+) {
+  const plugin = await installUnsafePlugin('./src/plugin.js', {});
+  const result = await Promise.race([
+    E(plugin).ping(),
+    new Promise(resolve => setTimeout(resolve, PONG_TIMEOUT, 'timeout')),
+  ]);
+  if (result !== 'pong') {
+    throw Error(`ping failed ${result}`);
+  }
+}

package/tools/resm-plugin/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "@agoric/test-resm-plugin",
+  "version": "1.0.0",
+  "type": "commonjs",
+  "dependencies": {
+    "@endo/eventual-send": "^0.17.2",
+    "@endo/marshal": "^0.8.5"
+  },
+  "typeCoverage": {
+    "atLeast": 0
+  }
+}

package/tools/resm-plugin/src/output.js

@@ -0,0 +1 @@
+export const start = 'Started plugin';