agoric 0.21.2-other-dev-8f8782b.0 → 0.21.2-other-dev-fbe72e7.0.fbe72e7

package/src/lib/packageManager.js

@@ -0,0 +1,24 @@
+// @ts-check
+
+/**
+ * @import { execFileSync } from 'child_process';
+ */
+
+/**
+ * Omits the root
+ *
+ * @param {{ execFileSync: execFileSync }} io
+ * @param {string} [root]
+ * @returns {Array<{ location: string, name: string }>}
+ */
+export const listWorkspaces = ({ execFileSync }, root) => {
+  const out = execFileSync('npm', ['query', '.workspace'], {
+    stdio: ['ignore', 'pipe', 'inherit'],
+    shell: true,
+    encoding: 'utf-8',
+    cwd: root,
+  });
+  /** @type {Array<{ location: string, name: string, description: string }>} */
+  const result = JSON.parse(out);
+  return result.filter(({ location }) => location !== '.');
+};

package/src/lib/wallet.js

@@ -1,16 +1,18 @@
 // @ts-check
-/* global process */
+/* eslint-env node */
 
 import { iterateReverse } from '@agoric/casting';
+import { boardSlottingMarshaller } from '@agoric/client-utils';
 import { makeWalletStateCoalescer } from '@agoric/smart-wallet/src/utils.js';
-import { execSwingsetTransaction, pollBlocks, pollTx } from './chain.js';
-import { boardSlottingMarshaller, makeRpcUtils } from './rpc.js';
+import { Fail } from '@endo/errors';
+import { execSwingsetTransaction, pollTx } from './chain.js';
 
-/** @typedef {import('@agoric/smart-wallet/src/smartWallet.js').CurrentWalletRecord} CurrentWalletRecord  */
-/** @typedef {import('@agoric/vats/tools/board-utils.js').AgoricNamesRemotes} AgoricNamesRemotes  */
+/**
+ * @import {CurrentWalletRecord} from '@agoric/smart-wallet/src/smartWallet.js';
+ * @import {AgoricNamesRemotes} from '@agoric/vats/tools/board-utils.js';
+ * @import {MinimalNetworkConfig, VstorageKit} from '@agoric/client-utils';
+ */
 
-const { values } = Object;
-const { Fail } = assert;
 const marshaller = boardSlottingMarshaller();
 
 /** @type {CurrentWalletRecord} */
@@ -23,18 +25,18 @@ const emptyCurrentRecord = {
 
 /**
  * @param {string} addr
- * @param {Pick<import('./rpc.js').RpcUtils, 'readLatestHead'>} io
- * @returns {Promise<import('@agoric/smart-wallet/src/smartWallet').CurrentWalletRecord>}
+ * @param {Pick<VstorageKit, 'readPublished'>} io
+ * @returns {Promise<import('@agoric/smart-wallet/src/smartWallet.js').CurrentWalletRecord>}
  */
-export const getCurrent = async (addr, { readLatestHead }) => {
+export const getCurrent = async (addr, { readPublished }) => {
   // Partial because older writes may not have had all properties
   // NB: assumes changes are only additions
   let current =
-    /** @type {Partial<import('@agoric/smart-wallet/src/smartWallet').CurrentWalletRecord> | undefined} */ (
-      await readLatestHead(`published.wallet.${addr}.current`)
+    /** @type {Partial<import('@agoric/smart-wallet/src/smartWallet.js').CurrentWalletRecord> | undefined} */ (
+      await readPublished(`wallet.${addr}.current`)
     );
   if (current === undefined) {
-    throw new Error(`undefined current node for ${addr}`);
+    throw Error(`undefined current node for ${addr}`);
   }
 
   // Repair a type misunderstanding seen in the wild.
@@ -58,16 +60,15 @@ export const getCurrent = async (addr, { readLatestHead }) => {
 
 /**
  * @param {string} addr
- * @param {Pick<import('./rpc.js').RpcUtils, 'readLatestHead'>} io
- * @returns {Promise<import('@agoric/smart-wallet/src/smartWallet').UpdateRecord>}
+ * @param {Pick<VstorageKit, 'readPublished'>} io
+ * @returns {Promise<import('@agoric/smart-wallet/src/smartWallet.js').UpdateRecord>}
  */
-export const getLastUpdate = (addr, { readLatestHead }) => {
-  // @ts-expect-error cast
-  return readLatestHead(`published.wallet.${addr}`);
+export const getLastUpdate = (addr, { readPublished }) => {
+  return readPublished(`wallet.${addr}`);
 };
 
 /**
- * @param {import('@agoric/smart-wallet/src/smartWallet').BridgeAction} bridgeAction
+ * @param {import('@agoric/smart-wallet/src/smartWallet.js').BridgeAction} bridgeAction
  * @param {Pick<import('stream').Writable,'write'>} [stdout]
  */
 export const outputAction = (bridgeAction, stdout = process.stdout) => {
@@ -76,11 +77,11 @@ export const outputAction = (bridgeAction, stdout = process.stdout) => {
   stdout.write('\n');
 };
 
-const sendHint =
+export const sendHint =
   'Now use `agoric wallet send ...` to sign and broadcast the offer.\n';
 
 /**
- * @param {import('@agoric/smart-wallet/src/smartWallet').BridgeAction} bridgeAction
+ * @param {import('@agoric/smart-wallet/src/smartWallet.js').BridgeAction} bridgeAction
  * @param {{
  *   stdout: Pick<import('stream').Writable,'write'>,
  *   stderr: Pick<import('stream').Writable,'write'>,
@@ -94,25 +95,38 @@ export const outputActionAndHint = (bridgeAction, { stdout, stderr }) => {
 /**
  * @param {import('@agoric/smart-wallet/src/offers.js').OfferSpec} offer
  * @param {Pick<import('stream').Writable,'write'>} [stdout]
+ * @param {Pick<import('stream').Writable,'write'>} [stderr]
  */
-export const outputExecuteOfferAction = (offer, stdout = process.stdout) => {
-  /** @type {import('@agoric/smart-wallet/src/smartWallet').BridgeAction} */
+export const outputExecuteOfferAction = (
+  offer,
+  stdout = process.stdout,
+  stderr = process.stderr,
+) => {
+  /** @type {import('@agoric/smart-wallet/src/smartWallet.js').BridgeAction} */
   const spendAction = {
     method: 'executeOffer',
     offer,
   };
   outputAction(spendAction, stdout);
+  stderr.write(sendHint);
 };
 
 /**
  * @deprecated use `.current` node for current state
- * @param {import('@agoric/casting').Follower<import('@agoric/casting').ValueFollowerElement<import('@agoric/smart-wallet/src/smartWallet').UpdateRecord>>} follower
+ * @param {import('@agoric/casting').Follower<import('@agoric/casting').ValueFollowerElement<import('@agoric/smart-wallet/src/smartWallet.js').UpdateRecord>>} follower
  * @param {Brand<'set'>} [invitationBrand]
  */
 export const coalesceWalletState = async (follower, invitationBrand) => {
   // values with oldest last
   const history = [];
   for await (const followerElement of iterateReverse(follower)) {
+    if ('error' in followerElement) {
+      console.error(
+        'Skipping wallet update due to error:',
+        followerElement.error,
+      );
+      continue;
+    }
     history.push(followerElement.value);
   }
 
@@ -129,12 +143,13 @@ export const coalesceWalletState = async (follower, invitationBrand) => {
  * Sign and broadcast a wallet-action.
  *
  * @throws { Error & { code: number } } if transaction fails
- * @param {import('@agoric/smart-wallet/src/smartWallet').BridgeAction} bridgeAction
- * @param {import('./rpc').MinimalNetworkConfig & {
+ * @param {import('@agoric/smart-wallet/src/smartWallet.js').BridgeAction} bridgeAction
+ * @param {MinimalNetworkConfig & {
  *   from: string,
+ *   fees?: string,
  *   verbose?: boolean,
  *   keyring?: {home?: string, backend: string},
- *   stdout: Pick<import('stream').Writable, 'write'>,
+ *   stdout?: Pick<import('stream').Writable, 'write'>,
  *   execFileSync: typeof import('child_process').execFileSync,
  *   delay: (ms: number) => Promise<void>,
  *   dryRun?: boolean,
@@ -159,7 +174,7 @@ export const sendAction = async (bridgeAction, opts) => {
   assert(out); // not dry run
   const tx = JSON.parse(out);
   if (tx.code !== 0) {
-    const err = Error(`failed to send action. code: ${tx.code}`);
+    const err = Error(`failed to send tx: ${tx.raw_log} code: ${tx.code}`);
     // @ts-expect-error XXX how to add properties to an error?
     err.code = tx.code;
     throw err;
@@ -174,7 +189,7 @@ export const sendAction = async (bridgeAction, opts) => {
  */
 export const findContinuingIds = (current, agoricNames) => {
   // XXX should runtime type-check
-  /** @type {{ offerToUsedInvitation: [string, Amount<'set'>][]}} */
+  /** @type {{ offerToUsedInvitation: [string, InvitationAmount][]}} */
   const { offerToUsedInvitation: entries } = /** @type {any} */ (current);
 
   Array.isArray(entries) || Fail`entries must be an array: ${entries}`;
@@ -198,118 +213,3 @@ export const findContinuingIds = (current, agoricNames) => {
   }
   return found;
 };
-
-export const makeWalletUtils = async (
-  { fetch, execFileSync, delay },
-  networkConfig,
-) => {
-  const { agoricNames, fromBoard, readLatestHead, vstorage } =
-    await makeRpcUtils({ fetch }, networkConfig);
-  /**
-   * @param {string} from
-   * @param {number|string} [minHeight]
-   */
-  const storedWalletState = async (from, minHeight = undefined) => {
-    const m = boardSlottingMarshaller(fromBoard.convertSlotToVal);
-
-    const history = await vstorage.readFully(
-      `published.wallet.${from}`,
-      minHeight,
-    );
-
-    /** @type {{ Invitation: Brand<'set'> }} */
-    // @ts-expect-error XXX how to narrow AssetKind to set?
-    const { Invitation } = agoricNames.brand;
-    const coalescer = makeWalletStateCoalescer(Invitation);
-    // update with oldest first
-    for (const txt of history.reverse()) {
-      const { body, slots } = JSON.parse(txt);
-      const record = m.fromCapData({ body, slots });
-      coalescer.update(record);
-    }
-    const coalesced = coalescer.state;
-    harden(coalesced);
-    return coalesced;
-  };
-
-  /**
-   * Get OfferStatus by id, polling until available.
-   *
-   * @param {string} from
-   * @param {string|number} id
-   * @param {number|string} minHeight
-   * @param {boolean} [untilNumWantsSatisfied]
-   */
-  const pollOffer = async (
-    from,
-    id,
-    minHeight,
-    untilNumWantsSatisfied = false,
-  ) => {
-    const lookup = async () => {
-      // eslint-disable-next-line @jessie.js/no-nested-await, no-await-in-loop
-      const { offerStatuses } = await storedWalletState(from, minHeight);
-      const offerStatus = [...offerStatuses.values()].find(s => s.id === id);
-      if (!offerStatus) throw Error('retry');
-      harden(offerStatus);
-      if (untilNumWantsSatisfied && !('numWantsSatisfied' in offerStatus)) {
-        throw Error('retry (no numWantsSatisfied yet)');
-      }
-      return offerStatus;
-    };
-    const retryMessage = 'offer not in wallet at block';
-    const opts = { ...networkConfig, execFileSync, delay, retryMessage };
-    return pollBlocks(opts)(lookup);
-  };
-
-  return {
-    networkConfig,
-    agoricNames,
-    fromBoard,
-    vstorage,
-    readLatestHead,
-    storedWalletState,
-    pollOffer,
-  };
-};
-
-/**
- * @param {{
- *   brand: Record<string, Brand>,
- *   vbankAsset: Record<string, { brand: Brand, displayInfo: DisplayInfo }>,
- * }} agoricNames
- * @param {(msg: string) => Error} makeError error constructor
- * @returns {(a: string) => Amount<'nat'>}
- */
-export const makeParseAmount =
-  (agoricNames, makeError = msg => RangeError(msg)) =>
-  opt => {
-    assert.typeof(opt, 'string', 'parseAmount expected string');
-    const m = opt.match(/^(?<value>[\d_]+(\.[\d_]+)?)(?<brand>[A-Z]\w*?)$/);
-    if (!m || !m.groups) {
-      throw makeError(`invalid amount: ${opt}`);
-    }
-    const anyBrand = agoricNames.brand[m.groups.brand];
-    if (!anyBrand) {
-      throw makeError(`unknown brand: ${m.groups.brand}`);
-    }
-    const assetDesc = values(agoricNames.vbankAsset).find(
-      d => d.brand === anyBrand,
-    );
-    if (!assetDesc) {
-      throw makeError(`unknown brand: ${m.groups.brand}`);
-    }
-    const { displayInfo } = assetDesc;
-    if (!displayInfo.decimalPlaces || displayInfo.assetKind !== 'nat') {
-      throw makeError(`bad brand: ${displayInfo}`);
-    }
-    const value = BigInt(
-      Number(m.groups.value.replace(/_/g, '')) *
-        10 ** displayInfo.decimalPlaces,
-    );
-    /** @type {Brand<'nat'>} */
-    // @ts-expect-error dynamic cast
-    const natBrand = anyBrand;
-    const amt = { value, brand: natBrand };
-    return amt;
-  };

package/src/main-publish.js

@@ -1,4 +1,4 @@
-/* global process */
+/* eslint-env node */
 // @ts-check
 
 import path from 'path';
@@ -31,9 +31,9 @@ const publishMain = async (progname, rawArgs, powers, opts) => {
     chainID,
   };
 
+  await null;
   for (const bundlePath of rawArgs.slice(1)) {
     // AWAIT
-    // eslint-disable-next-line no-await-in-loop,@jessie.js/no-nested-await
     const bundleText = await fs.readFile(bundlePath, 'utf-8');
     const bundle = parseLocatedJson(bundleText, bundlePath);
 
@@ -53,7 +53,6 @@ const publishMain = async (progname, rawArgs, powers, opts) => {
     });
 
     // AWAIT
-    // eslint-disable-next-line no-await-in-loop,@jessie.js/no-nested-await
     const hashedBundle = await publishBundle(bundle, connectionSpec);
     process.stdout.write(`${JSON.stringify(hashedBundle)}\n`);
   }

package/src/main.js

@@ -1,26 +1,26 @@
-/* eslint-disable @jessie.js/no-nested-await */
-/* global process */
+/* eslint-env node */
 import { Command } from 'commander';
 import path from 'path';
 import url from 'url';
-import { assert, details as X } from '@agoric/assert';
+import { assert, X } from '@endo/errors';
 import {
   DEFAULT_KEEP_POLLING_SECONDS,
   DEFAULT_JITTER_SECONDS,
 } from '@agoric/casting';
+import { makeWalletCommand } from './commands/wallet.js';
 import cosmosMain from './cosmos.js';
 import deployMain from './deploy.js';
-import runMain from './run.js';
-import publishMain from './main-publish.js';
+import followMain from './follow.js';
 import initMain from './init.js';
 import installMain from './install.js';
+import { statPlans } from './lib/bundles.js';
+import publishMain from './main-publish.js';
+import walletMain from './open.js';
+import runMain from './run.js';
 import setDefaultsMain from './set-defaults.js';
 import startMain from './start.js';
-import followMain from './follow.js';
-import walletMain from './open.js';
-import { makeWalletCommand } from './commands/wallet.js';
 
-const DEFAULT_DAPP_TEMPLATE = 'dapp-fungible-faucet';
+const DEFAULT_DAPP_TEMPLATE = 'dapp-offer-up';
 const DEFAULT_DAPP_URL_BASE = 'https://github.com/Agoric/';
 const DEFAULT_DAPP_BRANCH = undefined;
 
@@ -36,6 +36,7 @@ const main = async (progname, rawArgs, powers) => {
   const program = new Command();
 
   async function isNotBasedir() {
+    await null;
     try {
       await fs.stat(STAMP);
       return false;
@@ -46,6 +47,7 @@ const main = async (progname, rawArgs, powers) => {
     return true;
   }
 
+  // XXX exits process when fn resolves
   function subMain(fn, args, options) {
     return fn(progname, args, powers, options).then(
       // This seems to be the only way to propagate the exit code.
@@ -57,46 +59,40 @@ const main = async (progname, rawArgs, powers) => {
   const pkg = JSON.parse(pj);
   program.name(pkg.name).version(pkg.version);
 
-  program
-    .option('--sdk', 'use the Agoric SDK containing this program')
-    .option('--no-sdk', 'do not use the Agoric SDK containing this program')
-    .option('--docker-tag <tag>', 'image tag to use for Docker containers')
-    .option(
+  const cmdOpts = { verbose: 0 };
+  const addCmdOpts = baseCmd =>
+    baseCmd.option(
       '-v, --verbose',
       'verbosity that can be increased',
-      (_value, previous) => previous + 1,
-      0,
+      (_value, _previous) => (cmdOpts.verbose += 1),
     );
+  /** @type {typeof program.command} */
+  const baseCmd = (nameAndParams, ...rest) =>
+    addCmdOpts(program.command(nameAndParams, ...rest));
+
+  addCmdOpts(
+    program
+      .enablePositionalOptions()
+      .option('--sdk', 'use the Agoric SDK containing this program')
+      .option('--no-sdk', 'do not use the Agoric SDK containing this program'),
+  );
 
   // Add each of the commands.
-  program
-    .command('cosmos <command...>')
+  baseCmd('cosmos <command...>')
+    .passThroughOptions(true)
+    .option('--docker-tag <tag>', 'image tag to use for Docker containers')
     .description('client for an Agoric Cosmos chain')
     .action(async (command, _options, cmd) => {
-      const opts = { ...program.opts(), ...cmd.opts() };
+      const opts = { ...program.opts(), ...cmd.opts(), ...cmdOpts };
       return subMain(cosmosMain, ['cosmos', ...command], opts);
     });
 
-  const ibcSetup = path.join(
-    dirname,
-    '..',
-    'node_modules',
-    '.bin',
-    'ibc-setup',
-  );
-  program.command(
-    'ibc-setup <command...>',
-    'set up Inter Blockchain Communication',
-    { executableFile: ibcSetup },
-  );
-
-  program
-    .command('open')
+  baseCmd('open')
     .description('launch the Agoric UI')
     .option(
       '--hostport <host:port>',
       'host and port to connect to VM',
-      '127.0.0.1:8000',
+      'localhost:8000',
     )
     .option('--no-browser', `just display the URL, don't open a browser`)
     .option(
@@ -112,12 +108,11 @@ const main = async (progname, rawArgs, powers) => {
       },
     )
     .action(async (_options, cmd) => {
-      const opts = { ...program.opts(), ...cmd.opts() };
+      const opts = { ...program.opts(), ...cmd.opts(), ...cmdOpts };
       return subMain(walletMain, ['wallet'], opts);
     });
 
-  program
-    .command('init <project>')
+  baseCmd('init <project>')
     .description('create a new Dapp directory named <project>')
     .option(
       '--dapp-template <name>',
@@ -134,13 +129,17 @@ const main = async (progname, rawArgs, powers) => {
       'use this branch instead of the repository HEAD',
       DEFAULT_DAPP_BRANCH,
     )
+    // Tolerate @agoric/create-dapp's `agoric init --version` invocation.
+    .option('-V, --version', 'output the version number', () => {
+      console.log(pkg.version);
+      process.exit(0);
+    })
     .action(async (project, _options, cmd) => {
-      const opts = { ...program.opts(), ...cmd.opts() };
+      const opts = { ...program.opts(), ...cmd.opts(), ...cmdOpts };
       return subMain(initMain, ['init', project], opts);
     });
 
-  program
-    .command('set-defaults <program> <config-dir>')
+  baseCmd('set-defaults <program> <config-dir>')
     .description('update the configuration files for <program> in <config-dir>')
     .option(
       '--enable-cors',
@@ -168,49 +167,28 @@ const main = async (progname, rawArgs, powers) => {
       '',
     )
     .action(async (prog, configDir, _options, cmd) => {
-      const opts = { ...program.opts(), ...cmd.opts() };
+      const opts = { ...program.opts(), ...cmd.opts(), ...cmdOpts };
       return subMain(setDefaultsMain, ['set-defaults', prog, configDir], opts);
     });
 
-  const ibcRelayer = path.join(
-    dirname,
-    '..',
-    'node_modules',
-    '.bin',
-    'ibc-relayer',
-  );
-  program.command(
-    'ibc-relayer',
-    'run an Inter Blockchain Communications relayer',
-    {
-      executableFile: ibcRelayer,
-    },
-  );
-
-  program
-    .command('install [force-sdk-version]')
+  baseCmd('install [force-sdk-version]')
     .description('install Dapp dependencies')
     .action(async (forceSdkVersion, _options, cmd) => {
       await isNotBasedir();
-      const opts = { ...program.opts(), ...cmd.opts() };
+      const opts = { ...program.opts(), ...cmd.opts(), ...cmdOpts };
       return subMain(installMain, ['install', forceSdkVersion], opts);
     });
 
-  program
-    .command('follow <path-spec...>')
+  baseCmd('follow <path-spec...>')
     .description('follow an Agoric Casting leader')
     .option(
-      '--proof <strict | optimistic | none>',
-      'set proof mode',
+      '--proof <none>',
+      `set proof mode (currently only 'none' is supported)`,
       value => {
-        assert(
-          ['strict', 'optimistic', 'none'].includes(value),
-          X`--proof must be one of 'strict', 'optimistic', or 'none'`,
-          TypeError,
-        );
+        assert.equal(value, 'none', X`--proof can only be 'none'`, TypeError);
         return value;
       },
-      'optimistic',
+      'none',
     )
     .option(
       '--sleep <seconds>',
@@ -270,61 +248,59 @@ const main = async (progname, rawArgs, powers) => {
     )
     .option('-B, --bootstrap <config>', 'network bootstrap configuration')
     .action(async (pathSpecs, _options, cmd) => {
-      const opts = { ...program.opts(), ...cmd.opts() };
+      const opts = { ...program.opts(), ...cmd.opts(), ...cmdOpts };
       return subMain(followMain, ['follow', ...pathSpecs], opts);
     });
 
-  const addRunOptions = cmd =>
-    cmd
-      .option(
-        '--allow-unsafe-plugins',
-        `CAREFUL: installed Agoric VM plugins will also have all your user's privileges`,
-        false,
-      )
-      .option(
-        '--hostport <host:port>',
-        'host and port to connect to VM',
-        '127.0.0.1:8000',
-      )
-      .option(
-        '--need <subsystems>',
-        'comma-separated names of subsystems to wait for',
-        'local,agoric,wallet',
-      )
-      .option(
-        '--provide <subsystems>',
-        'comma-separated names of subsystems this script initializes',
-        '',
-      );
-
-  program
-    .command('run <script> [script-args...]')
+  baseCmd('run <script> [script-args...]')
     .description(
       'run a script with all your user privileges and some Agoric endowments',
     )
+    .passThroughOptions(true)
     .action(async (script, scriptArgs, _options, cmd) => {
-      const opts = { ...program.opts(), ...cmd.opts(), scriptArgs };
-      return subMain(runMain, ['run', script], opts);
+      const opts = { ...program.opts(), ...cmd.opts(), ...cmdOpts, scriptArgs };
+      await runMain(progname, ['run', script], powers, opts);
+
+      if (opts.verbose) {
+        await statPlans(process.cwd());
+      }
     });
 
-  addRunOptions(
-    program
-      .command('deploy [script...]')
-      .option(
-        '--target <target>',
-        'One of agoric, local, cosmos, or sim',
-        'agoric',
-      )
-      .description(
-        'run multiple scripts with all your user privileges against the local Agoric VM',
-      ),
-  ).action(async (scripts, _options, cmd) => {
-    const opts = { ...program.opts(), ...cmd.opts() };
-    return subMain(deployMain, ['deploy', ...scripts], opts);
-  });
+  baseCmd('deploy [script...]')
+    .option(
+      '--target <target>',
+      'One of agoric, local, cosmos, or sim',
+      'agoric',
+    )
+    .option(
+      '--allow-unsafe-plugins',
+      `CAREFUL: installed Agoric VM plugins will also have all your user's privileges`,
+      false,
+    )
+    .option(
+      '--hostport <host:port>',
+      'host and port to connect to VM',
+      '127.0.0.1:8000',
+    )
+    .option(
+      '--need <subsystems>',
+      'comma-separated names of subsystems to wait for',
+      'local,agoric,wallet',
+    )
+    .option(
+      '--provide <subsystems>',
+      'comma-separated names of subsystems this script initializes',
+      '',
+    )
+    .description(
+      'run multiple scripts with all your user privileges against the local Agoric VM',
+    )
+    .action(async (scripts, _options, cmd) => {
+      const opts = { ...program.opts(), ...cmd.opts() };
+      return subMain(deployMain, ['deploy', ...scripts], opts);
+    });
 
-  program
-    .command('publish [bundle...]')
+  baseCmd('publish [bundle...]')
     .option(
       '-c, --chain-id <chainID>',
       'The ID of the destination chain',
@@ -345,10 +321,9 @@ const main = async (progname, rawArgs, powers) => {
       return subMain(publishMain, ['publish', ...bundles], opts);
     });
 
-  program.addCommand(await makeWalletCommand());
+  await makeWalletCommand(baseCmd);
 
-  program
-    .command('start [profile] [args...]')
+  baseCmd('start [profile] [args...]')
     .description(
       `\
 start an Agoric VM
@@ -360,6 +335,7 @@ agoric start local-solo [portNum] [provisionPowers] - local solo VM
 `,
     )
     .option('-d, --debug', 'run in JS debugger mode')
+    .option('--docker-tag <tag>', 'image tag to use for Docker containers')
     .option('--reset', 'clear all VM state before starting')
     .option('--no-restart', 'do not actually start the VM')
     .option('--pull', 'for Docker-based VM, pull the image before running')
@@ -383,19 +359,13 @@ agoric start local-solo [portNum] [provisionPowers] - local solo VM
     )
     .action(async (profile, args, _options, cmd) => {
       await isNotBasedir();
-      const opts = { ...program.opts(), ...cmd.opts() };
+      const opts = { ...program.opts(), ...cmd.opts(), ...cmdOpts };
       return subMain(startMain, ['start', profile, ...args], opts);
     });
 
   // Throw an error instead of exiting directly.
   program.exitOverride();
 
-  // Hack: cosmos arguments are always unparsed.
-  const cosmosIndex = rawArgs.indexOf('cosmos');
-  if (cosmosIndex >= 0) {
-    rawArgs.splice(cosmosIndex + 1, 0, '--');
-  }
-
   try {
     await program.parseAsync(rawArgs, { from: 'user' });
   } catch (e) {