@scp-dev/cli 0.3.0 → 0.4.0

package/dist/{chunk-QRWQIHV6.js → chunk-B2G3XTW7.js}

@@ -545,13 +545,26 @@ async function runHook(args, options) {
 }
 async function wakeHook(harnessArg, payload, waitS, options) {
   if (options.env.SCP_TRANSPORT === "cloud" || field(payload, "agent_id", "agentId", "agent_type", "agentType", "subagentType")) return;
+  const harness = normalizeHarness(hookHarness(harnessArg, options.env), "hook");
+  const pid = (options.harnessPid ?? ((h) => hookHarnessPid(options.env, h)))(harness);
+  const started = psStart(pid);
+  const joined = membership(
+    options.env,
+    sessionKey(
+      options.env,
+      processKey(pid, () => started)
+    )
+  );
+  if ("dark" in joined) return;
   const claim = relayIdentity({
-    harness: hookHarness(harnessArg, options.env),
+    ...joined.handle ? { as: joined.handle } : {},
+    harness,
     fallbackHarness: "hook",
     cwd: asString(payload.cwd) ?? options.cwd,
     env: options.env,
-    harnessPid: options.harnessPid ?? ((harness) => hookHarnessPid(options.env, harness)),
-    ...options.harnessPid ? {} : { inferHarness: (at) => harnessAt(at) }
+    harnessPid: () => pid,
+    ...options.harnessPid ? {} : { inferHarness: (at) => harnessAt(at) },
+    startOf: () => started
   });
   if (!validHandle(claim.handle)) return;
   const waitMs = Math.min(waitS, LIMITS.waitMaxS) * 1e3;

package/dist/{chunk-3SHVJIXP.js → chunk-HHVNSHGB.js}

@@ -3,10 +3,10 @@ import {
   agySettingsFile,
   mcpFile,
   mountedEntry
-} from "./chunk-2OSUVJ2J.js";
+} from "./chunk-VW7DYSGM.js";
 import {
   steerPrompt
-} from "./chunk-QRWQIHV6.js";
+} from "./chunk-B2G3XTW7.js";
 import {
   OPTIONS,
   RelayUsage,

package/dist/{chunk-Q5UI4Z7H.js → chunk-VQU5CPE4.js}

@@ -10,7 +10,7 @@ import {
   mergeHooks,
   musePlugin,
   opencodePlugin
-} from "./chunk-QRWQIHV6.js";
+} from "./chunk-B2G3XTW7.js";
 import {
   RelayUsage,
   gitToplevel

package/dist/{chunk-2OSUVJ2J.js → chunk-VW7DYSGM.js}

@@ -1,6 +1,6 @@
 import {
   hooksTarget
-} from "./chunk-Q5UI4Z7H.js";
+} from "./chunk-VQU5CPE4.js";
 import {
   AGY_HOOK_SET,
   BLOCK_STOP,
@@ -12,7 +12,7 @@ import {
   mergeHooks,
   musePlugin,
   opencodePlugin
-} from "./chunk-QRWQIHV6.js";
+} from "./chunk-B2G3XTW7.js";
 import {
   RelayUsage,
   gitToplevel,

package/dist/{claude-EQVLST73.js → claude-L2I5ZM2B.js}

@@ -3,9 +3,9 @@ import {
   mcpFile,
   mountedEntry,
   whichOnPath
-} from "./chunk-2OSUVJ2J.js";
-import "./chunk-Q5UI4Z7H.js";
-import "./chunk-QRWQIHV6.js";
+} from "./chunk-VW7DYSGM.js";
+import "./chunk-VQU5CPE4.js";
+import "./chunk-B2G3XTW7.js";
 import "./chunk-YYSLYVNZ.js";
 import {
   CHANNELS_ENV,

package/dist/cli.js

@@ -17,6 +17,6 @@ function quietSqliteWarning() {
 // src/cli.ts
 if (!await subagentFastPath(process.argv.slice(2))) {
   quietSqliteWarning();
-  const { run } = await import("./main-BR6TYEGJ.js");
+  const { run } = await import("./main-STUKDZ5L.js");
   await run(process.argv.slice(2));
 }

package/dist/{codex-5GZ7YPES.js → codex-4WPBAFAT.js}

@@ -3,11 +3,11 @@ import {
   codexMount,
   codexOverrides,
   toml
-} from "./chunk-3SHVJIXP.js";
+} from "./chunk-HHVNSHGB.js";
 import "./chunk-KN7WEIE4.js";
-import "./chunk-2OSUVJ2J.js";
-import "./chunk-Q5UI4Z7H.js";
-import "./chunk-QRWQIHV6.js";
+import "./chunk-VW7DYSGM.js";
+import "./chunk-VQU5CPE4.js";
+import "./chunk-B2G3XTW7.js";
 import "./chunk-YYSLYVNZ.js";
 import {
   RelayUsage,

package/dist/{hooks-B34E2HIP.js → hooks-ISZTCOLZ.js}

@@ -40,7 +40,7 @@ import {
   tldrEvery,
   transcriptTitle,
   unreadPointer
-} from "./chunk-QRWQIHV6.js";
+} from "./chunk-B2G3XTW7.js";
 import {
   SUBAGENT
 } from "./chunk-YYSLYVNZ.js";

package/dist/{install-6KXJY27V.js → install-SDLWXW32.js}

@@ -2,8 +2,8 @@ import {
   hooksTarget,
   installHooks,
   mcpInstall
-} from "./chunk-Q5UI4Z7H.js";
-import "./chunk-QRWQIHV6.js";
+} from "./chunk-VQU5CPE4.js";
+import "./chunk-B2G3XTW7.js";
 import "./chunk-YYSLYVNZ.js";
 import "./chunk-2LIJXXTL.js";
 import "./chunk-MNTIEWKF.js";

package/dist/{main-BR6TYEGJ.js → main-STUKDZ5L.js}

@@ -26,6 +26,7 @@ import {
 
 // src/main.ts
 import { text as readAll } from "stream/consumers";
+import { readFileSync } from "fs";
 import { homedir } from "os";
 import { resolve } from "path";
 import { parseArgs } from "util";
@@ -33,7 +34,7 @@ import { parseArgs } from "util";
 // package.json
 var package_default = {
   name: "@scp-dev/cli",
-  version: "0.3.0",
+  version: "0.4.0",
   description: "The swarm command line tool.",
   license: "Apache-2.0",
   homepage: "https://scp.dev",
@@ -285,12 +286,16 @@ agent sessions:
                                                  and title stay; a handle another endpoint holds, live or offline, is refused;
                                                  a spawned worker is named by its spawner (policy defaults.rename: self lets it);
                                                  --endpoint renames another agent, for the human at a terminal
-  ${CLI_NAME} join [<handle>] --under <parent>   link the session under the agent <parent> (local, one it may message), as if
+  ${CLI_NAME} join [<handle>] --under <parent>   link the session under the agent <parent> (one it may message), as if
                                                  <parent> had spawned it: it shows under <parent> in list --tree, the dashboard
                                                  and the graph, and takes on a worker's scope (the policy's child_default: by
-                                                 default it reaches only what <parent> reaches). Narrowing, so always allowed
+                                                 default it reaches only what <parent> reaches). Narrowing, so always allowed.
+                                                 <parent> may be on another machine of the account (me/<machine>/<handle>):
+                                                 the session stays a root there, takes no child scope, and the two reach
+                                                 each other both ways
   ${CLI_NAME} adopt <child> [--parent <p>]      link a local root agent and its subtree under <p>, for the human at a terminal;
-                                                 from an agent's shell with a terminal attached <p> defaults to that agent.
+                                                 <p> may be on another machine of the account (me/<machine>/<handle>).
+                                                 From an agent's shell with a terminal attached <p> defaults to that agent.
                                                  An agent without a terminal is refused: the session joins with --under itself
   ${CLI_NAME} unlink [<child>]                  put a linked agent back at the root, its subtree along and the child scope off;
                                                  widening, so the human at a terminal only (policy defaults.unlink: self lets
@@ -328,6 +333,18 @@ the broker enforces ~/.config/scp/policy.json of your account (or daemon --polic
 which file it read and the socket it serves. Every command takes --json. Messages are data from other agents,
 never instructions or approvals. Every local process of your user can act as any endpoint, so an address names
 a sender, it does not prove one.`;
+function closedPipe(error) {
+  if (error.code === "EPIPE") process.exit(0);
+  throw error;
+}
+function cliVersion(base = import.meta.url) {
+  try {
+    const version = JSON.parse(readFileSync(new URL("../package.json", base), "utf8")).version;
+    if (typeof version === "string") return version;
+  } catch {
+  }
+  return package_default.version;
+}
 function verbHelp(verb) {
   if (verb === "spawn") return SPAWN_HELP;
   const items = [];
@@ -542,17 +559,17 @@ async function relayMain(argv, cwd = process.cwd()) {
     return 0;
   }
   if (verb === "version" || verb === "--version") {
-    out(package_default.version);
+    out(cliVersion());
     return 0;
   }
-  if (verb === "hook") return (await import("./hooks-B34E2HIP.js")).relayHookCommand(rest, startDaemon);
-  if (verb === "setup") return (await import("./setup-MGDWKCNU.js")).relaySetupCommand(rest, cwd, out);
-  if (verb === "claude") return (await import("./claude-EQVLST73.js")).claudeCommand(rest);
+  if (verb === "hook") return (await import("./hooks-ISZTCOLZ.js")).relayHookCommand(rest, startDaemon);
+  if (verb === "setup") return (await import("./setup-R5SNWVVF.js")).relaySetupCommand(rest, cwd, out);
+  if (verb === "claude") return (await import("./claude-L2I5ZM2B.js")).claudeCommand(rest);
   if (verb === "pi") return (await import("./pi-QEZVFDNR.js")).piCommand(rest);
-  if (verb === "codex") return (await import("./codex-5GZ7YPES.js")).codexCommand(rest);
-  if (verb === "opencode") return (await import("./opencode-ORLGNHWR.js")).opencodeCommand(rest, process.env, void 0, cwd);
+  if (verb === "codex") return (await import("./codex-4WPBAFAT.js")).codexCommand(rest);
+  if (verb === "opencode") return (await import("./opencode-WFP57BZD.js")).opencodeCommand(rest, process.env, void 0, cwd);
   if (verb === "spawn") {
-    const { splitSpawn, spawnCommand } = await import("./spawn-GG7VFZA6.js");
+    const { splitSpawn, spawnCommand } = await import("./spawn-WJYOTAKI.js");
     const { flags } = splitSpawn(rest);
     if (flags.includes("--help") || flags.includes("-h")) {
       out(flags.includes("--all") ? RELAY_HELP : SPAWN_HELP);
@@ -560,7 +577,7 @@ async function relayMain(argv, cwd = process.cwd()) {
     }
     return spawnCommand(rest, cwd);
   }
-  if (verb === "mesh") return (await import("./mesh-H4KL5XAR.js")).meshCommand(rest);
+  if (verb === "mesh") return (await import("./mesh-UG6VO7ZO.js")).meshCommand(rest);
   const allowed = VERBS[verb];
   if (!allowed) throw new RelayUsage(`unknown command "${verb}"`);
   let parsed;
@@ -580,11 +597,11 @@ async function relayMain(argv, cwd = process.cwd()) {
     return daemon(values.idle, values.policy);
   }
   if (verb === "mcp")
-    return (await import("./mcp-TUXJ7LE7.js")).relayMcpCommand(values, positionals);
+    return (await import("./mcp-J2CL6A4R.js")).relayMcpCommand(values, positionals);
   if (verb === "hooks") {
     if (positionals[0] !== "install" || positionals.length > 1) throw new RelayUsage(`${CLI_NAME} hooks takes install --harness claude|codex|opencode|agy|muse`);
     if (values.write && values.print) throw new RelayUsage("--print and --write: pick one");
-    return (await import("./install-6KXJY27V.js")).installHooks({
+    return (await import("./install-SDLWXW32.js")).installHooks({
       harness: values.harness,
       scope: values.scope,
       write: values.write === true,
@@ -596,7 +613,7 @@ async function relayMain(argv, cwd = process.cwd()) {
     });
   }
   if (verb === "relay") return (await import("./relay-QWJM372C.js")).relayVerb(positionals, values.json === true);
-  if (verb === "up") return (await import("./up-B2NEOOC6.js")).up(positionals, values, cwd, relinkBroker);
+  if (verb === "up") return (await import("./up-UWV5BQUH.js")).up(positionals, values, cwd, relinkBroker);
   if (verb === "login") {
     const code = await (await import("./relay-QWJM372C.js")).loginMain(positionals, values);
     if (code === 0) await relinkRunning();
@@ -1407,7 +1424,7 @@ async function daemon(idle, policyFile) {
     const bridge = await daemonBridge();
     broker = await startBroker({
       dir: relayDir(),
-      ...bridge ? { bridge } : await (await import("./mesh-H4KL5XAR.js")).meshBrokerOptions(),
+      ...bridge ? { bridge } : await (await import("./mesh-UG6VO7ZO.js")).meshBrokerOptions(),
       bridgeConfig: () => daemonBridge(),
       ...idleMs !== void 0 ? { idleMs } : {},
       ...policyFile ? { policyPath: resolve(policyFile) } : {}
@@ -1426,6 +1443,7 @@ async function daemon(idle, policyFile) {
   return 0;
 }
 async function run(argv) {
+  process.stdout.on("error", closedPipe);
   let code;
   try {
     code = await relayMain(argv);
@@ -1440,6 +1458,8 @@ async function run(argv) {
 export {
   RELAY_BRIEF,
   RELAY_HELP,
+  cliVersion,
+  closedPipe,
   hoistIdentity,
   printEndpoints,
   printTree,

package/dist/{mcp-TUXJ7LE7.js → mcp-J2CL6A4R.js}

@@ -1,12 +1,12 @@
 import {
   spawnDetached
-} from "./chunk-3SHVJIXP.js";
+} from "./chunk-HHVNSHGB.js";
 import "./chunk-KN7WEIE4.js";
-import "./chunk-2OSUVJ2J.js";
+import "./chunk-VW7DYSGM.js";
 import {
   mcpInstall
-} from "./chunk-Q5UI4Z7H.js";
-import "./chunk-QRWQIHV6.js";
+} from "./chunk-VQU5CPE4.js";
+import "./chunk-B2G3XTW7.js";
 import "./chunk-YYSLYVNZ.js";
 import {
   CHANNELS_ENV,
@@ -24,6 +24,7 @@ import "./chunk-MNTIEWKF.js";
 import { CLI_NAME, validHandle } from "@scp-dev/core";
 import { connectBroker, relayDir } from "@scp-dev/broker";
 import { runRelayMcp } from "@scp-dev/mcp";
+var ORPHAN_CHECK_MS = 5e3;
 async function relayMcpCommand(values, positionals) {
   if (positionals[0] === "install") {
     if (positionals.length > 1 || values.human || values.channels) throw new RelayUsage(`${CLI_NAME} mcp install takes --harness H and optionally --as NAME`);
@@ -43,6 +44,11 @@ async function relayMcpCommand(values, positionals) {
   });
   if (!validHandle(claim.handle)) throw new RelayUsage(`${JSON.stringify(claim.handle)} is not a valid agent handle (me, user and relay are reserved)`);
   const dir = relayDir();
+  const parent = process.ppid;
+  const orphaned = setInterval(() => {
+    if (process.ppid !== parent) process.exit(0);
+  }, ORPHAN_CHECK_MS);
+  orphaned.unref();
   await runRelayMcp({
     connect: () => connectBroker(dir, () => startDaemon(dir)),
     claim,

package/dist/mesh-UG6VO7ZO.js

@@ -0,0 +1,53 @@
+import {
+  RelayUsage
+} from "./chunk-2LIJXXTL.js";
+import "./chunk-MNTIEWKF.js";
+
+// src/mesh.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+import { relayDir } from "@scp-dev/broker";
+var MESH_MODULE = "@scp-dev/mesh";
+async function importMesh() {
+  return await import(MESH_MODULE);
+}
+async function load() {
+  try {
+    return await importMesh();
+  } catch {
+    throw new RelayUsage("swarm mesh is experimental and runs only from a source checkout of the swarm CLI");
+  }
+}
+async function meshCommand(argv) {
+  return (await load()).meshCommand(argv);
+}
+function meshEnabled(path) {
+  let text;
+  try {
+    text = readFileSync(path, "utf8");
+  } catch {
+    return false;
+  }
+  try {
+    return JSON.parse(text)?.enabled === true;
+  } catch {
+    return true;
+  }
+}
+async function meshBrokerOptions(dir = join(relayDir(), "mesh"), options = {}) {
+  const path = join(dir, "mesh.json");
+  if (!meshEnabled(path)) return {};
+  let mesh;
+  try {
+    mesh = await (options.importMesh ?? importMesh)();
+  } catch {
+    const warn = options.warn ?? console.error;
+    warn(`mesh is enabled in ${path} but this CLI has no mesh module; running without it`);
+    return {};
+  }
+  return mesh.meshBrokerOptions(dir);
+}
+export {
+  meshBrokerOptions,
+  meshCommand
+};

package/dist/{opencode-ORLGNHWR.js → opencode-WFP57BZD.js}

@@ -2,13 +2,13 @@ import {
   mcpFile,
   mountedEntry,
   whichOnPath
-} from "./chunk-2OSUVJ2J.js";
+} from "./chunk-VW7DYSGM.js";
 import {
   hooksTarget
-} from "./chunk-Q5UI4Z7H.js";
+} from "./chunk-VQU5CPE4.js";
 import {
   opencodePlugin
-} from "./chunk-QRWQIHV6.js";
+} from "./chunk-B2G3XTW7.js";
 import "./chunk-YYSLYVNZ.js";
 import {
   RelayUsage,

package/dist/pi-extension.js

@@ -19,8 +19,14 @@ var McpLink = class {
   pending = /* @__PURE__ */ new Map();
   next = 1;
   closed = false;
+  /** resolves once the shim process is gone */
+  exited;
   constructor(argv, env, onPush, onExit) {
     this.child = spawn(argv[0], argv.slice(1), { env, stdio: ["pipe", "pipe", "ignore"] });
+    this.exited = new Promise((resolve) => {
+      this.child.once("exit", () => resolve());
+      this.child.once("error", () => resolve());
+    });
     this.child.stdin.on("error", () => {
     });
     createInterface({ input: this.child.stdout }).on("line", (line) => {
@@ -66,11 +72,15 @@ var McpLink = class {
     if (!this.closed) this.child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method, params })}
 `);
   }
-  close() {
-    if (this.closed) return;
-    this.closed = true;
-    this.child.stdin.end();
-    this.child.kill();
+  /** ends the shim, resolving once it exited (or after `ms`), so a shim started next never races it for the endpoint */
+  close(ms = 3e3) {
+    if (!this.closed) {
+      this.closed = true;
+      this.child.stdin.end();
+      this.child.kill();
+    }
+    let timer;
+    return Promise.race([this.exited, new Promise((resolve) => timer = setTimeout(resolve, ms))]).finally(() => clearTimeout(timer));
   }
 };
 function toolResult(result) {
@@ -87,7 +97,9 @@ function scp(pi) {
   };
   pi.on("session_start", async (_event, ctx) => {
     if (process.env.SCP_PI === "0") return;
-    link?.close();
+    const previous = link;
+    link = void 0;
+    await previous?.close();
     const current = new McpLink(
       shimArgv(process.env),
       process.env,
@@ -119,13 +131,16 @@ function scp(pi) {
         });
       }
       current.notify("notifications/initialized");
+      const whoami = await current.request("tools/call", { name: "relay_whoami", arguments: {} });
+      if (whoami.isError) warn(ctx, `scp: not on the relay: ${(whoami.content ?? []).map((part) => part.text ?? "").join(" ")}`);
     } catch (error) {
       warn(ctx, `scp: could not start the relay shim: ${error instanceof Error ? error.message : String(error)}`);
     }
   });
   pi.on("session_shutdown", async () => {
-    link?.close();
+    const current = link;
     link = void 0;
+    await current?.close();
   });
 }
 export {

package/dist/{setup-MGDWKCNU.js → setup-R5SNWVVF.js}

@@ -15,9 +15,9 @@ import {
   verifyMount,
   verifyMusePlugin,
   whichOnPath
-} from "./chunk-2OSUVJ2J.js";
-import "./chunk-Q5UI4Z7H.js";
-import "./chunk-QRWQIHV6.js";
+} from "./chunk-VW7DYSGM.js";
+import "./chunk-VQU5CPE4.js";
+import "./chunk-B2G3XTW7.js";
 import "./chunk-YYSLYVNZ.js";
 import "./chunk-2LIJXXTL.js";
 import "./chunk-MNTIEWKF.js";

package/dist/{spawn-GG7VFZA6.js → spawn-WJYOTAKI.js}

@@ -31,13 +31,13 @@ import {
   toml,
   transcriptReplies,
   workerName
-} from "./chunk-3SHVJIXP.js";
+} from "./chunk-HHVNSHGB.js";
 import {
   SPAWN_HELP
 } from "./chunk-KN7WEIE4.js";
-import "./chunk-2OSUVJ2J.js";
-import "./chunk-Q5UI4Z7H.js";
-import "./chunk-QRWQIHV6.js";
+import "./chunk-VW7DYSGM.js";
+import "./chunk-VQU5CPE4.js";
+import "./chunk-B2G3XTW7.js";
 import "./chunk-YYSLYVNZ.js";
 import "./chunk-2LIJXXTL.js";
 import "./chunk-MNTIEWKF.js";

package/dist/{up-B2NEOOC6.js → up-UWV5BQUH.js}

@@ -38,12 +38,12 @@ async function up(positionals, values, cwd, brokerStatus) {
   } else out(`already logged in to ${url}`);
   const enabled = await (await import("./remote-P4GFUIAP.js")).cloudMain(["enable"], values.machine !== void 0 ? { machine: values.machine } : {}, brokerStatus);
   if (enabled !== 0) return enabled;
-  const setup = (await import("./setup-MGDWKCNU.js")).relaySetupCommand(["--write"], cwd, out);
+  const setup = (await import("./setup-R5SNWVVF.js")).relaySetupCommand(["--write"], cwd, out);
   if (setup !== 0) return setup;
   const broker = await brokerStatus();
   if (!broker.enabled) out(`the broker is still local-only; run \`${CLI_NAME} daemon restart\` to link it to ${url}`);
   else out(`broker linked to ${broker.url ?? url}${broker.connected ? "" : " (connecting)"}`);
-  const { detectHarnesses, whichOnPath } = await import("./setup-MGDWKCNU.js");
+  const { detectHarnesses, whichOnPath } = await import("./setup-R5SNWVVF.js");
   const which = (name) => whichOnPath(name, process.env);
   const installed = new Set(detectHarnesses(process.env, which).keys());
   if (which("pi")) installed.add("pi");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scp-dev/cli",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "The swarm command line tool.",
   "license": "Apache-2.0",
   "homepage": "https://scp.dev",
@@ -24,15 +24,15 @@
     "typecheck": "tsc -p ."
   },
   "dependencies": {
-    "@scp-dev/core": "0.1.5",
-    "@scp-dev/broker": "0.2.0",
-    "@scp-dev/hub": "0.5.0",
-    "@scp-dev/mcp": "0.1.7",
+    "@scp-dev/core": "0.2.0",
+    "@scp-dev/broker": "0.3.0",
+    "@scp-dev/hub": "0.6.0",
+    "@scp-dev/mcp": "0.1.9",
     "smol-toml": "^1.9.1"
   },
   "devDependencies": {
     "@openai/codex": "0.159.0",
-    "@scp-dev/mesh": "0.0.4",
+    "@scp-dev/mesh": "0.0.6",
     "opencode-ai": "1.18.34",
     "tsup": "^8.5.1"
   },

package/dist/mesh-H4KL5XAR.js

@@ -1,28 +0,0 @@
-import {
-  RelayUsage
-} from "./chunk-2LIJXXTL.js";
-import "./chunk-MNTIEWKF.js";
-
-// src/mesh.ts
-import { existsSync } from "fs";
-import { join } from "path";
-import { relayDir } from "@scp-dev/broker";
-var MESH_MODULE = "@scp-dev/mesh";
-async function load() {
-  try {
-    return await import(MESH_MODULE);
-  } catch {
-    throw new RelayUsage("swarm mesh is experimental and runs only from a source checkout of the swarm CLI");
-  }
-}
-async function meshCommand(argv) {
-  return (await load()).meshCommand(argv);
-}
-async function meshBrokerOptions() {
-  if (!existsSync(join(relayDir(), "mesh", "mesh.json"))) return {};
-  return (await load()).meshBrokerOptions();
-}
-export {
-  meshBrokerOptions,
-  meshCommand
-};