@toon-protocol/townhouse 0.1.0-rc5

package/dist/cli.js

@@ -0,0 +1,684 @@
+#!/usr/bin/env node
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  ConnectorAdminClient,
+  DEFAULT_ATOR_PROXY,
+  DockerOrchestrator,
+  TransportProbe,
+  WalletManager,
+  createApiServer,
+  createWizardApiServer,
+  decryptWallet,
+  encryptWallet,
+  getDefaultConfig,
+  loadConfig,
+  loadWallet,
+  saveWallet
+} from "./chunk-IB6TNCUQ.js";
+import "./chunk-UTFWPLTB.js";
+
+// src/cli.ts
+import { parseArgs } from "util";
+import { mkdirSync, writeFileSync, existsSync } from "fs";
+import { join, resolve } from "path";
+import { homedir } from "os";
+import { pathToFileURL } from "url";
+import { stringify } from "yaml";
+import Docker from "dockerode";
+
+// src/cli/browser-opener.ts
+import { spawn } from "child_process";
+var RealBrowserOpener = class {
+  async open(url) {
+    let cmd;
+    let args;
+    switch (process.platform) {
+      case "darwin":
+        cmd = "open";
+        args = [url];
+        break;
+      case "win32":
+        cmd = "cmd";
+        args = ["/c", "start", "", url];
+        break;
+      default:
+        cmd = "xdg-open";
+        args = [url];
+        break;
+    }
+    return new Promise((resolve2) => {
+      let settled = false;
+      const settle = () => {
+        if (settled) return;
+        settled = true;
+        resolve2();
+      };
+      try {
+        const child = spawn(cmd, args, {
+          stdio: ["ignore", "ignore", "ignore"],
+          detached: true
+        });
+        child.once("error", (err) => {
+          console.warn(
+            `[Townhouse] Could not open browser via ${cmd}: ${err.message}`
+          );
+          settle();
+        });
+        child.once("spawn", () => {
+          child.unref();
+          settle();
+        });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.warn(`[Townhouse] Could not open browser: ${msg}`);
+        settle();
+      }
+    });
+  }
+};
+
+// src/cli.ts
+var CliHelpRequested = class extends Error {
+  constructor() {
+    super(HELP_TEXT);
+    this.name = "CliHelpRequested";
+  }
+};
+var HELP_TEXT = `townhouse \u2014 TOON node orchestrator
+
+Usage:
+  townhouse setup [--no-browser] [--port <n>] [--config-dir <dir>]  Run the first-run setup wizard
+  townhouse init [--force] [--config-dir <dir>] [--password <pw>] [--preset <name>] [--yes]   Initialize config + wallet
+  townhouse up [--town] [--mill] [--dvm] [-c <path>] [--password <pw>]  Start nodes
+  townhouse down [-c <path>]                     Stop all nodes
+  townhouse status [-c <path>]                   Show node status
+  townhouse metrics [-c <path>]                  Show connector metrics
+  townhouse wallet show [-c <path>] [--password <pw>]  Show derived addresses
+  townhouse --help                               Show this help
+
+Flags:
+  --town       Start Town (Nostr relay) node
+  --mill       Start Mill (swap) node
+  --dvm        Start DVM (compute) node
+  --password   Wallet password (non-interactive mode)
+  --no-browser Skip opening the browser automatically (setup command)
+  --port       Override the API port (setup command, default 9400)
+  --preset     Init from a named preset (init only). Supported: demo
+  --yes        Non-interactive (init only); with --preset=demo uses demo password if --password absent
+  If no flags given, starts all enabled nodes from config.`;
+var DEFAULT_CONFIG_DIR = join(homedir(), ".townhouse");
+var DEFAULT_CONFIG_PATH = join(DEFAULT_CONFIG_DIR, "config.yaml");
+async function handleInit(force, configDir, password, preset, yes) {
+  const dir = resolve(configDir ?? DEFAULT_CONFIG_DIR);
+  const configPath = join(dir, "config.yaml");
+  if (existsSync(configPath) && !force) {
+    console.error(
+      `Config already exists at ${configPath}. Use --force to overwrite.`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  let configToWrite;
+  if (preset === "demo") {
+    const { buildDemoConfig, DEMO_DETERMINISTIC_PASSWORD } = await import("./demo-MJR47QHZ.js");
+    configToWrite = buildDemoConfig({ walletPath: join(dir, "wallet.enc") });
+    if (yes && !password) {
+      password = DEMO_DETERMINISTIC_PASSWORD;
+      console.log(
+        "[demo preset] Using deterministic demo password (insecure \u2014 demo only)."
+      );
+    }
+  } else {
+    configToWrite = getDefaultConfig();
+    configToWrite.wallet.encrypted_path = join(dir, "wallet.enc");
+  }
+  const yamlContent = stringify(configToWrite);
+  writeFileSync(configPath, yamlContent, {
+    encoding: "utf-8",
+    mode: 384
+  });
+  console.log(`Config created at ${configPath}`);
+  const walletPath = join(dir, "wallet.enc");
+  if (existsSync(walletPath) && !force) {
+    console.log(
+      `Wallet already exists at ${walletPath}. Skipping wallet generation.`
+    );
+    return;
+  }
+  const walletPassword = password ?? process.env["TOWNHOUSE_WALLET_PASSWORD"];
+  if (!walletPassword) {
+    console.error(
+      "Wallet password required. Use --password flag or TOWNHOUSE_WALLET_PASSWORD env var."
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const walletManager = new WalletManager({ encryptedPath: walletPath });
+  const { mnemonic } = await walletManager.generate();
+  console.log("");
+  console.log("=== IMPORTANT: Back up your seed phrase ===");
+  console.log("");
+  console.log(`  ${mnemonic}`);
+  console.log("");
+  console.log("This is the ONLY time your seed phrase will be shown.");
+  console.log("Store it safely. You will need it to recover your node keys.");
+  console.log("============================================");
+  console.log("");
+  const encrypted = encryptWallet(mnemonic, walletPassword);
+  await saveWallet(walletPath, encrypted);
+  console.log(`Wallet saved to ${walletPath}`);
+  console.log("");
+  console.log("Derived Node Addresses:");
+  console.log("-----------------------");
+  const allKeys = walletManager.getAllKeys();
+  for (const info of allKeys) {
+    console.log(`  ${info.nodeType.padEnd(6)} Nostr: ${info.nostrPubkey}`);
+    console.log(`  ${"".padEnd(6)} EVM:   ${info.evmAddress}`);
+  }
+  walletManager.lock();
+}
+async function handleSetup(configDir, port, noBrowser, dockerInstance, browserOpener) {
+  const dir = resolve(configDir ?? DEFAULT_CONFIG_DIR);
+  const configPath = join(dir, "config.yaml");
+  const walletPath = join(dir, "wallet.enc");
+  if (existsSync(configPath) && existsSync(walletPath)) {
+    console.log("Already initialized \u2014 run `townhouse up` to start your nodes");
+    return;
+  }
+  if (existsSync(configPath) && !existsSync(walletPath)) {
+    console.error(
+      `Found ${configPath} but no wallet at ${walletPath}.
+Delete the orphan config and re-run \`townhouse setup\`, or restore the wallet from backup.`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const docker = dockerInstance ?? new Docker();
+  const opener = browserOpener ?? new RealBrowserOpener();
+  const wizardServer = await createWizardApiServer({
+    configDir: dir,
+    configPath,
+    walletPath,
+    port,
+    docker
+  });
+  const url = `http://127.0.0.1:${port}/wizard`;
+  try {
+    await wizardServer.app.listen({ host: "127.0.0.1", port });
+  } catch (err) {
+    const e = err;
+    if (e.code === "EADDRINUSE") {
+      console.error(
+        `Port ${port} is already in use. Pass \`--port <n>\` to choose a different port.`
+      );
+      process.exitCode = 1;
+      try {
+        await wizardServer.close();
+      } catch {
+      }
+      return;
+    }
+    throw err;
+  }
+  console.log(`Wizard ready at ${url}`);
+  if (!noBrowser) {
+    await opener.open(url);
+  }
+  let shuttingDown = false;
+  const shutdown = async (sig) => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    console.log(`
+Received ${sig}, shutting down...`);
+    try {
+      await wizardServer.close();
+    } catch {
+    }
+    process.exit(0);
+  };
+  process.once("SIGINT", () => {
+    void shutdown("SIGINT");
+  });
+  process.once("SIGTERM", () => {
+    void shutdown("SIGTERM");
+  });
+}
+async function handleWalletShow(config, password) {
+  const walletPath = config.wallet.encrypted_path;
+  const result = await loadWallet(walletPath);
+  if (!result) {
+    console.error("No wallet found. Run `townhouse init` first.");
+    process.exitCode = 1;
+    return;
+  }
+  if (result.permissionsWarning) {
+    console.error(result.permissionsWarning);
+  }
+  const walletPassword = password ?? process.env["TOWNHOUSE_WALLET_PASSWORD"];
+  if (!walletPassword) {
+    console.error(
+      "Wallet password required. Use --password flag or TOWNHOUSE_WALLET_PASSWORD env var."
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const walletManager = new WalletManager({ encryptedPath: walletPath });
+  try {
+    await walletManager.fromMnemonic(
+      decryptWallet(result.wallet, walletPassword)
+    );
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`Failed to decrypt wallet: ${msg}`);
+    process.exitCode = 1;
+    return;
+  }
+  console.log(
+    "Node Type  | Nostr Pubkey                                                     | EVM Address                                | Derivation Path"
+  );
+  console.log(
+    "-----------|------------------------------------------------------------------|--------------------------------------------|--------------------------"
+  );
+  const allKeys = walletManager.getAllKeys();
+  for (const info of allKeys) {
+    console.log(
+      `${info.nodeType.padEnd(10)} | ${info.nostrPubkey} | ${info.evmAddress} | ${info.nostrDerivationPath}`
+    );
+  }
+  walletManager.lock();
+}
+async function handleStatus(docker, config) {
+  const orchestrator = new DockerOrchestrator(docker, config);
+  const statuses = await orchestrator.status();
+  console.log("Node Status:");
+  console.log("------------");
+  for (const s of statuses) {
+    const health = s.health ? ` (${s.health})` : "";
+    console.log(`  ${s.name.padEnd(12)} ${s.state}${health}`);
+  }
+  const connectorHs = config.transport.hiddenService;
+  const relayHs = config.transport.relayHiddenService;
+  if (config.transport.mode === "ator" || connectorHs?.externalUrl || relayHs?.externalUrl || config.transport.externalUrl) {
+    console.log("");
+    console.log("Hidden Services:");
+    console.log("----------------");
+    const connectorUrl = connectorHs?.externalUrl ?? config.transport.externalUrl;
+    if (connectorUrl) {
+      console.log(`  Connector (BTP):  ${connectorUrl}`);
+    }
+    if (relayHs?.externalUrl) {
+      console.log(`  Relay (Nostr):    ${relayHs.externalUrl}`);
+    }
+    if (!connectorUrl && !relayHs?.externalUrl) {
+      console.log("  (ator mode set but no externalUrl configured)");
+    }
+  }
+  try {
+    const adminClient = new ConnectorAdminClient(
+      `http://127.0.0.1:${config.connector.adminPort}`
+    );
+    const metrics = await adminClient.getMetrics();
+    const peers = await adminClient.getPeers();
+    const activePeers = peers.filter((p) => p.connected).length;
+    console.log("");
+    console.log("Connector Metrics:");
+    console.log("------------------");
+    console.log(`  Packets forwarded: ${metrics.aggregate.packetsForwarded}`);
+    console.log(`  Active peers:      ${activePeers}/${peers.length}`);
+  } catch {
+    console.log("");
+    console.log("Connector Metrics: unavailable");
+  }
+}
+async function handleMetrics(config) {
+  const adminClient = new ConnectorAdminClient(
+    `http://127.0.0.1:${config.connector.adminPort}`
+  );
+  try {
+    const metrics = await adminClient.getMetrics();
+    const peers = await adminClient.getPeers();
+    const peerMetrics = new Map(metrics.peers.map((p) => [p.peerId, p]));
+    console.log("Connector Metrics:");
+    console.log("------------------");
+    console.log(`  Packets forwarded: ${metrics.aggregate.packetsForwarded}`);
+    console.log(`  Packets rejected:  ${metrics.aggregate.packetsRejected}`);
+    console.log(`  Bytes sent:        ${metrics.aggregate.bytesSent}`);
+    console.log("");
+    console.log("Peers:");
+    console.log("------");
+    if (peers.length === 0) {
+      console.log("  No peers connected");
+    } else {
+      for (const peer of peers) {
+        const status = peer.connected ? "connected" : "disconnected";
+        const packets = peerMetrics.get(peer.id)?.packetsForwarded ?? 0;
+        console.log(`  ${peer.id.padEnd(12)} ${status}  (${packets} packets)`);
+      }
+    }
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    console.error(`Failed to fetch connector metrics: ${msg}`);
+    process.exitCode = 1;
+  }
+}
+function resolveProfiles(values, config) {
+  const explicitFlags = [];
+  if (values["town"]) explicitFlags.push("town");
+  if (values["mill"]) explicitFlags.push("mill");
+  if (values["dvm"]) explicitFlags.push("dvm");
+  if (explicitFlags.length > 0) {
+    return explicitFlags;
+  }
+  const enabled = [];
+  if (config.nodes.town.enabled) enabled.push("town");
+  if (config.nodes.mill.enabled) enabled.push("mill");
+  if (config.nodes.dvm.enabled) enabled.push("dvm");
+  return enabled;
+}
+async function handleUp(configPath, config, profiles, docker, password, dryRun = false) {
+  if (profiles.length === 0) {
+    console.log(
+      "No nodes enabled in config. Enable nodes in config.yaml first."
+    );
+    return;
+  }
+  const walletPath = config.wallet.encrypted_path;
+  let walletManager;
+  if (!existsSync(walletPath)) {
+    console.error(
+      `Wallet not found at ${walletPath}. Run \`townhouse setup\` first (or restore your wallet backup).`
+    );
+    process.exitCode = 1;
+    return;
+  } else {
+    const walletPassword = password ?? process.env["TOWNHOUSE_WALLET_PASSWORD"];
+    if (!walletPassword) {
+      throw new Error(
+        "Wallet password required to start the API. Use --password flag or TOWNHOUSE_WALLET_PASSWORD env var."
+      );
+    }
+    const loaded = await loadWallet(walletPath);
+    if (!loaded) {
+      throw new Error(`Wallet at ${walletPath} could not be read.`);
+    }
+    if (loaded.permissionsWarning) {
+      console.error(loaded.permissionsWarning);
+    }
+    walletManager = new WalletManager({ encryptedPath: walletPath });
+    try {
+      await walletManager.fromMnemonic(
+        decryptWallet(loaded.wallet, walletPassword)
+      );
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new Error(`Failed to decrypt wallet: ${msg}`);
+    }
+  }
+  const orchestrator = new DockerOrchestrator(docker, config, walletManager);
+  orchestrator.on(
+    "containerState",
+    (event) => {
+      console.log(`  ${event.name}: ${event.state}`);
+    }
+  );
+  orchestrator.on(
+    "pullProgress",
+    (event) => {
+      const progress = event.progress ? ` ${event.progress}` : "";
+      console.log(`  [pull] ${event.image}: ${event.status}${progress}`);
+    }
+  );
+  let apiServer;
+  const sigintHandler = async () => {
+    console.log("\nReceived SIGINT, shutting down gracefully...");
+    if (apiServer) {
+      try {
+        await apiServer.close();
+      } catch {
+      }
+    }
+    try {
+      await orchestrator.down();
+    } catch {
+    }
+    process.exit(0);
+  };
+  process.on("SIGINT", sigintHandler);
+  const sigtermHandler = async () => {
+    console.log("\nReceived SIGTERM, shutting down gracefully...");
+    if (apiServer) {
+      try {
+        await apiServer.close();
+      } catch {
+      }
+    }
+    try {
+      await orchestrator.down();
+    } catch {
+    }
+    process.exit(0);
+  };
+  process.on("SIGTERM", sigtermHandler);
+  let serverStarted = false;
+  if (profiles.includes("dvm") && config.nodes.dvm.enabled && !process.env["TURBO_TOKEN"]) {
+    console.warn(
+      "[townhouse] WARN: TURBO_TOKEN is not set \u2014 Arweave DVM (kind:5094) uploads will fail at first job."
+    );
+    console.warn(
+      "[townhouse] Export TURBO_TOKEN=<arweave-jwk-json> before `townhouse up` to enable uploads."
+    );
+  }
+  try {
+    console.log(`Starting nodes: ${profiles.join(", ")}...`);
+    if (!dryRun) {
+      await orchestrator.up(profiles);
+      console.log("All nodes started successfully.");
+    } else {
+      console.log("[dry-run] Skipped orchestrator.up()");
+    }
+    if (walletManager) {
+      const connectorAdmin = new ConnectorAdminClient(
+        `http://127.0.0.1:${config.connector.adminPort}`
+      );
+      const transportProbe = new TransportProbe({
+        proxyUrl: config.transport.mode === "ator" ? config.transport.socksProxy ?? DEFAULT_ATOR_PROXY : ""
+      });
+      if (config.transport.mode === "ator") {
+        transportProbe.start();
+      }
+      const apiDeps = {
+        configPath,
+        config,
+        orchestrator,
+        wallet: walletManager,
+        connectorAdmin,
+        transportProbe
+      };
+      apiServer = await createApiServer(apiDeps);
+      const { host, port } = config.api;
+      if (!dryRun) {
+        await apiServer.app.listen({
+          host: host ?? "127.0.0.1",
+          port: port ?? 9400
+        });
+        serverStarted = true;
+        console.log(
+          `
+[Townhouse API] listening on http://${host ?? "127.0.0.1"}:${port ?? 9400}`
+        );
+        console.log(
+          "  GET /nodes, GET /nodes/:type, PATCH /nodes/:type/config, GET /wallet, WS /metrics"
+        );
+      } else {
+        console.log(
+          `[dry-run] API factory invoked: configPath=${configPath} host=${host ?? "127.0.0.1"} port=${port ?? 9400} connectorAdmin=http://127.0.0.1:${config.connector.adminPort} wallet=WalletManager`
+        );
+        await apiServer.close();
+        apiServer = void 0;
+      }
+    }
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    if (msg.includes("Docker is not running") || msg.includes("ENOENT") || msg.includes("ECONNREFUSED") || msg.includes("socket")) {
+      throw new Error(
+        `Docker is not available. Please ensure Docker is running and try again. (${msg})`
+      );
+    }
+    throw error;
+  } finally {
+    if (!serverStarted) {
+      process.removeListener("SIGINT", sigintHandler);
+      process.removeListener("SIGTERM", sigtermHandler);
+    }
+  }
+}
+async function handleDown(config, docker) {
+  const orchestrator = new DockerOrchestrator(docker, config);
+  orchestrator.on(
+    "containerState",
+    (event) => {
+      console.log(`  ${event.name}: ${event.state}`);
+    }
+  );
+  console.log("Stopping nodes...");
+  await orchestrator.down();
+  console.log("All nodes stopped.");
+}
+async function main(argv, dockerInstance, browserOpener) {
+  const { values, positionals } = parseArgs({
+    args: argv,
+    options: {
+      help: { type: "boolean" },
+      force: { type: "boolean" },
+      config: { type: "string", short: "c" },
+      "config-dir": { type: "string" },
+      town: { type: "boolean" },
+      mill: { type: "boolean" },
+      dvm: { type: "boolean" },
+      password: { type: "string" },
+      "dry-run": { type: "boolean" },
+      "no-browser": { type: "boolean" },
+      port: { type: "string" },
+      preset: { type: "string" },
+      yes: { type: "boolean" }
+    },
+    strict: false,
+    allowPositionals: true
+  });
+  if (values.help) {
+    console.log(HELP_TEXT);
+    throw new CliHelpRequested();
+  }
+  const command = positionals[0];
+  if (!command) {
+    console.log(HELP_TEXT);
+    throw new CliHelpRequested();
+  }
+  switch (command) {
+    case "setup": {
+      const portStr = values["port"];
+      const port = portStr ? Number(portStr) : 9400;
+      if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        console.error("--port must be an integer between 1 and 65535");
+        process.exitCode = 1;
+        break;
+      }
+      await handleSetup(
+        values["config-dir"],
+        port,
+        values["no-browser"] === true,
+        dockerInstance,
+        browserOpener
+      );
+      break;
+    }
+    case "init": {
+      const presetVal = values.preset;
+      if (presetVal !== void 0 && presetVal !== "demo") {
+        console.error(`Unknown preset: ${presetVal}. Supported: demo`);
+        process.exitCode = 1;
+        break;
+      }
+      await handleInit(
+        values.force === true,
+        values["config-dir"],
+        values.password,
+        presetVal,
+        values.yes === true
+      );
+      break;
+    }
+    case "wallet": {
+      const subCommand = positionals[1];
+      if (subCommand === "show") {
+        const configPath = values.config ?? DEFAULT_CONFIG_PATH;
+        const config = loadConfig(configPath);
+        await handleWalletShow(config, values.password);
+      } else {
+        console.error(
+          "Usage: townhouse wallet show [-c <path>] [--password <pw>]"
+        );
+        process.exitCode = 1;
+      }
+      break;
+    }
+    case "status": {
+      const configPath = values.config ?? DEFAULT_CONFIG_PATH;
+      const config = loadConfig(configPath);
+      const docker = dockerInstance ?? new Docker();
+      await handleStatus(docker, config);
+      break;
+    }
+    case "up": {
+      const configPath = values.config ?? DEFAULT_CONFIG_PATH;
+      const config = loadConfig(configPath);
+      const docker = dockerInstance ?? new Docker();
+      const profiles = resolveProfiles(values, config);
+      await handleUp(
+        configPath,
+        config,
+        profiles,
+        docker,
+        values.password,
+        values["dry-run"] === true
+      );
+      break;
+    }
+    case "down": {
+      const configPath = values.config ?? DEFAULT_CONFIG_PATH;
+      const config = loadConfig(configPath);
+      const docker = dockerInstance ?? new Docker();
+      await handleDown(config, docker);
+      break;
+    }
+    case "metrics": {
+      const configPath = values.config ?? DEFAULT_CONFIG_PATH;
+      const config = loadConfig(configPath);
+      await handleMetrics(config);
+      break;
+    }
+    default: {
+      const sanitized = command.replace(/[\x00-\x1f\x7f]/g, "");
+      console.error(`Unknown command: ${sanitized}`);
+      console.log(HELP_TEXT);
+      process.exitCode = 1;
+    }
+  }
+}
+var invokedFile = process.argv[1];
+var invokedDirectly = typeof invokedFile === "string" && import.meta.url === pathToFileURL(invokedFile).href;
+if (invokedDirectly) {
+  main(process.argv.slice(2)).catch((error) => {
+    if (error instanceof CliHelpRequested) {
+      process.exit(0);
+    }
+    console.error("[Townhouse] Error:", error);
+    process.exit(1);
+  });
+}
+export {
+  CliHelpRequested,
+  main
+};
+//# sourceMappingURL=cli.js.map