mycomesh-consumer 0.1.31 → 0.1.33

package/src/consumer.mjs

@@ -1,11 +1,18 @@
 import { spawn as defaultSpawn } from "node:child_process";
-import { createRequire } from "node:module";
-import { fileURLToPath } from "node:url";
+import { existsSync, readFileSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import * as readline from "node:readline/promises";
 
-const CONSUMER_RELEASE_VERSION = "0.1.31";
-const DEFAULT_NODE_IMAGE =
-  "ghcr.io/charleslzp/mycomesh-node@sha256:ba6746dcfe3c3a8cfe49eece9ac1d5c39a088ea1f8d4601f61de23c15b7f5943";
-const API_COMMANDS = new Set(["health", "models", "responses", "chat"]);
+import {
+  DEFAULT_BASE_URL,
+  DEFAULT_MAX_FEE_UNITS,
+  DEFAULT_RELAY_URL,
+  NativeConsumerState,
+  createConsumerServer,
+} from "./consumer-runtime.mjs";
+
+export const CONSUMER_RELEASE_VERSION = "0.1.33";
+export const API_COMMANDS = new Set(["health", "models", "responses", "chat"]);
 const API_VALUE_OPTIONS = new Set([
   "--base-url",
   "--api-key",
@@ -21,35 +28,33 @@ const API_VALUE_OPTIONS = new Set([
   "--max-completion-tokens",
 ]);
 
-const HELP = `Usage: mycomesh-consumer [options] [-- codex-options]
-
-Start the local MycoMesh Consumer. No options are needed.
+export const CONSUMER_HELP = `Usage: mycomesh-consumer [options] [-- codex-options]
 
-The default command starts the pinned Docker runtime, opens the local
-credentials page with the export URL and payment key, then opens Codex through
-the loopback Consumer at http://127.0.0.1:8110/v1.
+Start the local MycoMesh Consumer without Docker, Python, or a public Gateway.
+The process owns one persisted V8 payment key, selects healthy Relays, and
+exposes an OpenAI-compatible loopback API.
 
 Options:
-  --no-browser          Print the credentials URL without opening it
-  --no-codex            Start the Consumer and credentials page without Codex
-  --stop                Stop the Consumer without deleting its payment key
-  --reset-local         Confirm and delete the local Consumer volume
-  --codex-command PATH  Codex executable (default: codex)
+  --no-browser          Print the local credentials URL without opening it
+  --codex               Start an optional Codex client after Relay readiness
+  --no-codex            Keep only the Consumer API running (default)
+  --stop                Stop a previously started native Consumer
+  --reset-local         Confirm and delete the local Consumer data directory
+  --codex-command PATH  Codex executable for --codex (default: codex on PATH)
   --ready-timeout SEC   Relay readiness timeout (default: 1800)
-  --proxy URL           Optional proxy for Consumer network traffic
-  --node-image IMAGE    Advanced: override the pinned Consumer image
-  --dry-run             Print the planned Docker operations
+  --data-dir DIR        Payment key and history directory
+  --relay URLS          Comma-separated Relay URLs for automatic failover
+  --proxy URL           Optional outbound HTTP proxy
+  --host HOST           Listen address (default: 127.0.0.1)
+  --port PORT           Listen port (default: 8110)
+  --max-fee UNITS       Maximum fee per request (default: 100000)
+  --dry-run             Print the native startup plan
   -h, --help            Show this help
   -v, --version         Show the package version
 
-Existing API commands remain available:
-  mycomesh-consumer health
-  mycomesh-consumer models
-  mycomesh-consumer responses "hello"
-  mycomesh-consumer chat "hello"
-
-Docker Desktop/Engine is required. The payment key and Consumer state remain
-in a protected Docker volume; no wallet signature or browser session is used.`;
+The browser page displays only the export URL/key, prepaid balance, key
+operations, and local consumption history. No browser conversation state is
+created.`;
 
 class ConsumerCliError extends Error {
   constructor(message, exitCode = 1) {
@@ -66,22 +71,61 @@ export async function main(argv, dependencies = {}) {
   try {
     const parsed = parseArguments(argv, env);
     if (parsed.help) {
-      stdout.write(`${HELP}\n`);
+      stdout.write(`${CONSUMER_HELP}\n`);
       return 0;
     }
     if (parsed.version) {
       stdout.write(`${CONSUMER_RELEASE_VERSION}\n`);
       return 0;
     }
-    const script = dependencies.scriptPath
-      ?? fileURLToPath(new URL("../scripts/start-consumer.sh", import.meta.url));
-    return await runScript(script, toScriptArgs(parsed), {
-      env,
-      spawn: dependencies.spawn ?? defaultSpawn,
-    });
+    if (parsed.dryRun) {
+      stdout.write(`Native Consumer: ${parsed.host}:${parsed.port}\n`);
+      stdout.write(`Data directory: ${parsed.dataDir}\n`);
+      stdout.write(`Relays: ${parsed.relayUrls}\n`);
+      stdout.write("Docker: disabled\n");
+      return 0;
+    }
+    if (parsed.stop) return stopConsumer(parsed, stdout, stderr);
+    if (parsed.resetLocal) return await resetConsumer(parsed, env, stdout, stderr);
+
+    const state = dependencies.createState
+      ? dependencies.createState(parsed, env)
+      : new NativeConsumerState({
+          env: { ...env, MYCOMESH_CONSUMER_DATA_DIR: parsed.dataDir },
+          dataDir: parsed.dataDir,
+          relayUrls: parsed.relayUrls,
+          proxy: parsed.proxy,
+          baseUrl: parsed.baseUrl,
+          maxFeeUnits: parsed.maxFeeUnits,
+        });
+    const runtime = dependencies.createServer
+      ? dependencies.createServer(state, parsed)
+      : createConsumerServer(state, { host: parsed.host, port: parsed.port });
+    await runtime.listen();
+    const rootUrl = `${parsed.scheme}://${parsed.hostForUrl}:${parsed.port}`;
+    const credentialsUrl = `${rootUrl}/`;
+    writePid(parsed.dataDir);
+    stdout.write(`MycoMesh Consumer credentials: ${credentialsUrl}\n`);
+    stdout.write(`OpenAI API: ${state.baseUrl}\n`);
+    if (!parsed.noBrowser) openBrowser(credentialsUrl, stderr);
+
+    const shutdown = async () => {
+      clearPid(parsed.dataDir);
+      await runtime.close();
+    };
+    if (parsed.noCodex) {
+      await waitForSignal(shutdown);
+      return 0;
+    }
+    await waitUntilReady(state, parsed.readyTimeout, stdout);
+    const code = await runCodex(parsed, state, dependencies.spawn ?? defaultSpawn, stdout, stderr);
+    await shutdown();
+    return code;
   } catch (error) {
     const exitCode = error instanceof ConsumerCliError ? error.exitCode : 1;
-    const message = error instanceof Error ? error.message : String(error);
+    const message = error?.code === "EADDRINUSE"
+      ? `port ${error.port || "requested"} is already in use; stop the old Consumer or choose --port with a matching --base-url`
+      : error instanceof Error ? error.message : String(error);
     stderr.write(`mycomesh consumer: ${message}\n`);
     return exitCode;
   }
@@ -89,12 +133,20 @@ export async function main(argv, dependencies = {}) {
 
 export function parseArguments(argv, env = process.env) {
   const parsed = {
-    nodeImage: env.MYCOMESH_NODE_IMAGE || DEFAULT_NODE_IMAGE,
-    codexCommand: env.MYCOMESH_CODEX_COMMAND || bundledCodexCommand(),
-    readyTimeout: env.MYCOMESH_CONSUMER_READY_TIMEOUT_SECONDS || undefined,
-    proxy: env.MYCOMESH_CONSUMER_PROXY || undefined,
+    baseUrl: env.MYCOMESH_CONSUMER_PUBLIC_BASE_URL || DEFAULT_BASE_URL,
+    baseUrlExplicit: Boolean(env.MYCOMESH_CONSUMER_PUBLIC_BASE_URL),
+    dataDir: env.MYCOMESH_CONSUMER_DATA_DIR || join(env.HOME || process.cwd(), ".mycomesh", "consumer"),
+    relayUrls: env.MYCOMESH_V8_RELAY_URLS || env.MYCOMESH_CONSUMER_RELAY_URL || DEFAULT_RELAY_URL,
+    proxy: env.MYCOMESH_CONSUMER_PROXY || "",
+    codexCommand: env.MYCOMESH_CODEX_COMMAND || "codex",
+    readyTimeout: parsePositive(env.MYCOMESH_CONSUMER_READY_TIMEOUT_SECONDS || "1800", "ready timeout", 86400),
+    maxFeeUnits: parsePositive(env.MYCOMESH_V8_MAX_FEE_UNITS || String(DEFAULT_MAX_FEE_UNITS), "max fee"),
+    host: env.MYCOMESH_CONSUMER_HOST || "127.0.0.1",
+    hostForUrl: env.MYCOMESH_CONSUMER_HOST || "127.0.0.1",
+    port: parsePositive(env.MYCOMESH_CONSUMER_PORT || "8110", "port", 65535),
+    scheme: "http",
     noBrowser: false,
-    noCodex: false,
+    noCodex: env.MYCOMESH_CONSUMER_START_CODEX !== "1",
     stop: false,
     resetLocal: false,
     dryRun: false,
@@ -102,72 +154,44 @@ export function parseArguments(argv, env = process.env) {
     version: false,
     codexArgs: [],
   };
-
   for (let index = 0; index < argv.length; index += 1) {
     const token = argv[index];
-    if (token === "--") {
-      parsed.codexArgs = argv.slice(index + 1);
-      break;
-    }
-    if (token === "-h" || token === "--help") {
-      parsed.help = true;
-      continue;
-    }
-    if (token === "-v" || token === "--version") {
-      parsed.version = true;
-      continue;
-    }
-    if (token === "--no-browser") {
-      parsed.noBrowser = true;
-      continue;
-    }
-    if (token === "--no-codex") {
-      parsed.noCodex = true;
-      continue;
-    }
-    if (token === "--stop") {
-      parsed.stop = true;
-      continue;
-    }
-    if (token === "--reset-local") {
-      parsed.resetLocal = true;
-      continue;
-    }
-    if (token === "--dry-run") {
-      parsed.dryRun = true;
-      continue;
-    }
+    if (token === "--") { parsed.codexArgs = argv.slice(index + 1); break; }
+    if (token === "-h" || token === "--help") { parsed.help = true; continue; }
+    if (token === "-v" || token === "--version") { parsed.version = true; continue; }
+    if (token === "--no-browser") { parsed.noBrowser = true; continue; }
+    if (token === "--codex") { parsed.noCodex = false; continue; }
+    if (token === "--no-codex") { parsed.noCodex = true; continue; }
+    if (token === "--stop") { parsed.stop = true; continue; }
+    if (token === "--reset-local") { parsed.resetLocal = true; continue; }
+    if (token === "--dry-run") { parsed.dryRun = true; continue; }
     const separator = token.indexOf("=");
     const name = separator === -1 ? token : token.slice(0, separator);
     let value = separator === -1 ? undefined : token.slice(separator + 1);
-    if (!["--node-image", "--codex-command", "--ready-timeout", "--proxy"].includes(name)) {
-      throw new ConsumerCliError(`unknown option: ${token}`, 2);
-    }
-    if (value === undefined) {
-      index += 1;
-      value = argv[index];
-    }
+    const options = new Set(["--base-url", "--data-dir", "--relay", "--proxy", "--codex-command", "--ready-timeout", "--host", "--port", "--max-fee"]);
+    if (!options.has(name)) throw new ConsumerCliError(`unknown option: ${token}`, 2);
+    if (value === undefined) { index += 1; value = argv[index]; }
     if (!value) throw new ConsumerCliError(`${name} requires a value`, 2);
-    if (name === "--node-image") parsed.nodeImage = value;
-    if (name === "--codex-command") parsed.codexCommand = value;
-    if (name === "--ready-timeout") parsed.readyTimeout = value;
+    if (name === "--base-url") { parsed.baseUrl = value; parsed.baseUrlExplicit = true; }
+    if (name === "--data-dir") parsed.dataDir = value;
+    if (name === "--relay") parsed.relayUrls = value;
     if (name === "--proxy") parsed.proxy = value;
+    if (name === "--codex-command") parsed.codexCommand = value;
+    if (name === "--ready-timeout") parsed.readyTimeout = parsePositive(value, name, 86400);
+    if (name === "--host") { parsed.host = value; parsed.hostForUrl = value.includes(":") ? `[${value}]` : value; }
+    if (name === "--port") parsed.port = parsePositive(value, name, 65535);
+    if (name === "--max-fee") parsed.maxFeeUnits = parsePositive(value, name);
   }
-  if (!/^[A-Za-z0-9][A-Za-z0-9._/-]*@sha256:[a-f0-9]{64}$/.test(parsed.nodeImage)) {
-    throw new ConsumerCliError("Consumer image must be pinned by digest", 2);
-  }
-  if (parsed.readyTimeout && !/^[1-9][0-9]*$/.test(parsed.readyTimeout)) {
-    throw new ConsumerCliError("--ready-timeout must be a positive integer", 2);
-  }
+  if (!parsed.baseUrlExplicit) parsed.baseUrl = `http://${parsed.hostForUrl}:${parsed.port}/v1`;
+  try { new URL(parsed.baseUrl); } catch { throw new ConsumerCliError("--base-url must be an absolute URL", 2); }
   return parsed;
 }
 
-function bundledCodexCommand() {
-  try {
-    return createRequire(import.meta.url).resolve("@openai/codex/bin/codex.js");
-  } catch {
-    return "codex";
-  }
+function parsePositive(value, label, maximum = Number.MAX_SAFE_INTEGER) {
+  if (!/^[1-9][0-9]*$/.test(String(value))) throw new ConsumerCliError(`${label} must be a positive integer`, 2);
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed) || parsed > maximum) throw new ConsumerCliError(`${label} is too large`, 2);
+  return parsed;
 }
 
 export function isApiInvocation(argv) {
@@ -185,34 +209,91 @@ export function isApiInvocation(argv) {
   return false;
 }
 
-export function toScriptArgs(parsed) {
-  const args = ["--node-image", parsed.nodeImage];
-  if (parsed.codexCommand) args.push("--codex-command", parsed.codexCommand);
-  if (parsed.readyTimeout) args.push("--ready-timeout", parsed.readyTimeout);
-  if (parsed.proxy) args.push("--proxy", parsed.proxy);
-  if (parsed.noBrowser) args.push("--no-browser");
-  if (parsed.noCodex) args.push("--no-codex");
-  if (parsed.stop) args.push("--stop");
-  if (parsed.resetLocal) args.push("--reset-local");
-  if (parsed.dryRun) args.push("--dry-run");
-  if (parsed.codexArgs.length) args.push("--", ...parsed.codexArgs);
-  return args;
+async function waitUntilReady(state, timeoutSeconds, stdout) {
+  const started = Date.now();
+  stdout.write("Waiting for a healthy Settlement V8 Relay...\n");
+  while (true) {
+    try { await state.chooseRelay(); return; } catch (error) {
+      if (Date.now() - started >= timeoutSeconds * 1000) throw new ConsumerCliError(`timed out waiting for a healthy Relay: ${error.message}`);
+      await new Promise((resolve) => setTimeout(resolve, 2000));
+    }
+  }
 }
 
-function runScript(script, args, { env, spawn }) {
-  return new Promise((resolve, reject) => {
+function runCodex(parsed, state, spawn, stdout, stderr) {
+  return new Promise((resolve) => {
+    const args = [
+      "-c", 'model="gpt-5.5"',
+      "-c", 'model_provider="mycomesh"',
+      "-c", 'model_providers.mycomesh.name="MycoMesh"',
+      "-c", `model_providers.mycomesh.base_url="${state.baseUrl}"`,
+      "-c", 'model_providers.mycomesh.env_key="OPENAI_API_KEY"',
+      "-c", 'model_providers.mycomesh.wire_api="responses"',
+      ...parsed.codexArgs,
+    ];
+    const env = { ...process.env, OPENAI_BASE_URL: state.baseUrl, OPENAI_API_KEY: state.paymentKey };
     let child;
-    try {
-      child = spawn("bash", [script, ...args], { env: { ...env }, stdio: "inherit" });
-    } catch (error) {
-      reject(new ConsumerCliError(`could not start bash: ${error.message}`));
-      return;
-    }
-    child.once("error", (error) => reject(new ConsumerCliError(`could not start bash: ${error.message}`)));
-    child.once("exit", (code, signal) => {
-      resolve(typeof code === "number" ? code : 128 + ({ SIGHUP: 1, SIGINT: 2, SIGTERM: 15 }[signal] ?? 1));
-    });
+    try { child = spawn(parsed.codexCommand, args, { env, stdio: "inherit" }); }
+    catch (error) { stderr.write(`mycomesh consumer: could not start Codex: ${error.message}\n`); resolve(127); return; }
+    stdout.write("Opening Codex through the native MycoMesh Consumer.\n");
+    child.once("error", (error) => { stderr.write(`mycomesh consumer: Codex failed: ${error.message}\n`); resolve(127); });
+    child.once("exit", (code, signal) => resolve(typeof code === "number" ? code : 128 + ({ SIGINT: 2, SIGTERM: 15 }[signal] || 1)));
   });
 }
 
-export { CONSUMER_RELEASE_VERSION, DEFAULT_NODE_IMAGE, HELP as CONSUMER_HELP };
+function writePid(dataDir) {
+  try { writeFileSync(join(dataDir, "consumer.pid"), `${process.pid}\n`, { mode: 0o600 }); } catch {}
+}
+
+function clearPid(dataDir) {
+  try { unlinkSync(join(dataDir, "consumer.pid")); } catch {}
+}
+
+function stopConsumer(parsed, stdout, stderr) {
+  const pidPath = join(parsed.dataDir, "consumer.pid");
+  if (!existsSync(pidPath)) { stdout.write("No native Consumer is running.\n"); return 0; }
+  const pid = Number(readFileSync(pidPath, "utf8").trim());
+  if (!Number.isInteger(pid) || pid <= 1) { clearPid(parsed.dataDir); stderr.write("Removed an invalid Consumer pid file.\n"); return 0; }
+  try { process.kill(pid, "SIGTERM"); stdout.write(`Stopped native Consumer process ${pid}.\n`); }
+  catch (error) { if (error.code !== "ESRCH") throw error; stdout.write("Native Consumer was already stopped.\n"); }
+  clearPid(parsed.dataDir);
+  return 0;
+}
+
+async function resetConsumer(parsed, env, stdout, stderr) {
+  const confirmed = env.MYCOMESH_CONFIRM_RESET === "RESET";
+  if (!confirmed && process.stdin.isTTY) {
+    const prompt = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await prompt.question("This removes the local payment key and history. Type RESET to continue: ");
+    prompt.close();
+    if (answer !== "RESET") throw new ConsumerCliError("local Consumer reset cancelled", 2);
+  } else if (!confirmed) {
+    throw new ConsumerCliError("set MYCOMESH_CONFIRM_RESET=RESET to reset a non-interactive Consumer", 2);
+  }
+  clearPid(parsed.dataDir);
+  rmSync(parsed.dataDir, { recursive: true, force: true });
+  stdout.write("Native Consumer local state removed.\n");
+  return 0;
+}
+
+function openBrowser(url, stderr) {
+  const platform = process.platform;
+  let command;
+  let args;
+  if (platform === "darwin") { command = "open"; args = [url]; }
+  else if (platform === "win32") { command = "cmd"; args = ["/c", "start", "", url]; }
+  else { command = "xdg-open"; args = [url]; }
+  try {
+    const child = defaultSpawn(command, args, { stdio: "ignore", detached: true });
+    child.unref?.();
+  } catch { stderr.write(`Open ${url} in a browser.\n`); }
+}
+
+function waitForSignal(shutdown) {
+  return new Promise((resolve) => {
+    let closed = false;
+    const finish = async () => { if (closed) return; closed = true; process.removeListener("SIGINT", finish); process.removeListener("SIGTERM", finish); await shutdown(); resolve(); };
+    process.once("SIGINT", finish);
+    process.once("SIGTERM", finish);
+  });
+}

package/consumer.compose.yml

@@ -1,90 +0,0 @@
-services:
-  consumer-volume-init:
-    image: ${MYCOMESH_NODE_IMAGE:?MYCOMESH_NODE_IMAGE is required}
-    user: "0:0"
-    network_mode: none
-    restart: "no"
-    read_only: true
-    security_opt:
-      - no-new-privileges:true
-    cap_drop:
-      - ALL
-    cap_add:
-      - CHOWN
-      - DAC_OVERRIDE
-    volumes:
-      - mycomesh-consumer-data:/volumes/consumer
-    entrypoint: ["/bin/sh", "-ec", "chown -R 10001:10001 /volumes/consumer"]
-
-  consumer:
-    image: ${MYCOMESH_NODE_IMAGE:?MYCOMESH_NODE_IMAGE is required}
-    user: "10001:10001"
-    restart: unless-stopped
-    pids_limit: 128
-    mem_limit: 256m
-    cpus: "1.0"
-    logging:
-      driver: json-file
-      options:
-        max-size: 10m
-        max-file: "3"
-    init: true
-    read_only: true
-    security_opt:
-      - no-new-privileges:true
-    cap_drop:
-      - ALL
-    working_dir: /data
-    environment:
-      MYCOMESH_CONSUMER_DATA_DIR: /data
-      MYCOMESH_CONSUMER_PROTOCOL_VERSION: ${MYCOMESH_CONSUMER_PROTOCOL_VERSION:-8}
-      MYCOMESH_CONSUMER_NETWORK_CONFIG: ${MYCOMESH_CONSUMER_NETWORK_CONFIG:-/app/deployments/sepolia-provider-network-v8.json}
-      MYCOMESH_CONSUMER_PUBLIC_BASE_URL: http://127.0.0.1:8110/v1
-      MYCOMESH_V7_RELAY_URLS: ${MYCOMESH_V7_RELAY_URLS:-https://bridge.mycomesh.xyz}
-      MYCOMESH_V7_MAX_FEE_UNITS: ${MYCOMESH_V7_MAX_FEE_UNITS:-100000}
-      MYCOMESH_V7_REQUEST_TIMEOUT_SECONDS: ${MYCOMESH_V7_REQUEST_TIMEOUT_SECONDS:-300}
-      MYCOMESH_V8_RELAY_URLS: ${MYCOMESH_V8_RELAY_URLS:-https://bridge.mycomesh.xyz}
-      MYCOMESH_V8_MAX_FEE_UNITS: ${MYCOMESH_V8_MAX_FEE_UNITS:-100000}
-      HTTP_PROXY: ${MYCOMESH_CONSUMER_HTTP_PROXY:-}
-      HTTPS_PROXY: ${MYCOMESH_CONSUMER_HTTPS_PROXY:-}
-      ALL_PROXY: ${MYCOMESH_CONSUMER_ALL_PROXY:-}
-      NO_PROXY: ${MYCOMESH_CONSUMER_NO_PROXY:-127.0.0.1,localhost,::1}
-      http_proxy: ${MYCOMESH_CONSUMER_HTTP_PROXY:-}
-      https_proxy: ${MYCOMESH_CONSUMER_HTTPS_PROXY:-}
-      all_proxy: ${MYCOMESH_CONSUMER_ALL_PROXY:-}
-      no_proxy: ${MYCOMESH_CONSUMER_NO_PROXY:-127.0.0.1,localhost,::1}
-    extra_hosts:
-      - host.docker.internal:host-gateway
-    ports:
-      - "127.0.0.1:8110:8110"
-    volumes:
-      - mycomesh-consumer-data:/data
-    tmpfs:
-      - /tmp:size=32m,mode=1777
-    depends_on:
-      consumer-volume-init:
-        condition: service_completed_successfully
-    stop_grace_period: 15s
-    healthcheck:
-      test:
-        - CMD
-        - python
-        - -c
-        - "import json, urllib.request; value=json.load(urllib.request.urlopen('http://127.0.0.1:8110/health', timeout=3)); assert value.get('ok') is True; assert value.get('gateway_dependency') is False; assert value.get('browser_app_ready') is True"
-      interval: 15s
-      timeout: 5s
-      retries: 4
-      start_period: 10s
-    entrypoint: ["sh", "-ec"]
-    command:
-      - >-
-        if [ "$${MYCOMESH_CONSUMER_PROTOCOL_VERSION:-8}" = "8" ]; then
-          exec python -m gateway.consumer_v8 serve --host 0.0.0.0 --port 8110;
-        elif [ "$${MYCOMESH_CONSUMER_PROTOCOL_VERSION:-8}" = "7" ]; then
-          exec python -m gateway.consumer_v7 serve --host 0.0.0.0 --port 8110;
-        else
-          exec python -m gateway.local_consumer serve --host 0.0.0.0 --port 8110;
-        fi
-
-volumes:
-  mycomesh-consumer-data: