moneyos 0.4.1 → 0.5.0

package/README.md

@@ -26,6 +26,10 @@ moneyos auth unlock
 moneyos auth lock
 moneyos auth status
 moneyos auth change-password
+moneyos add <tool>
+moneyos remove <tool>
+moneyos tools
+moneyos swap <amount> <tokenIn> <tokenOut> [--chain <id>] [--provider odos]
 moneyos backup export [--out ./wallet-backup.json] [--force]
 moneyos backup restore <path> [--force]
 moneyos backup status
@@ -41,8 +45,9 @@ Example:
 ```bash
 moneyos init
 moneyos auth unlock
-moneyos balance USDC
-moneyos backup status
+moneyos add swap
+moneyos tools
+moneyos swap 0.1 RYZE ETH
 ```
 
 ## SDK
@@ -62,14 +67,48 @@ const tx = await moneyos.send("USDC", "0x...", "10");
 console.log(tx.hash);
 ```
 
+If you want a local script or workflow to reuse an already-unlocked MoneyOS
+session, unlock first in the terminal:
+
+```bash
+moneyos auth unlock
+```
+
+Then attach that session explicitly in code:
+
+```ts
+import { createMoneyOS, connectLocalSession } from "moneyos";
+
+const execute = await connectLocalSession();
+const moneyos = createMoneyOS({
+  chainId: 42161,
+  execute,
+});
+```
+
+Tool packages should still execute against `moneyos.runtime`; they should not
+import `connectLocalSession()` themselves.
+
 The runtime seam is intentionally small. `createMoneyOS` can also take injected
 `execute`, `read`, and `assets` implementations, which is how external packages
 plug in.
 
-Swap is no longer built into the root SDK or CLI. The canonical implementation
-lives in `@moneyos/swap`, which executes against `moneyos.runtime`.
+Swap still lives in the separate `@moneyos/swap` package, but the root CLI now
+owns first-class tool install/use UX for CLI-integrated packages.
+
+For CLI usage, install the root package and then add tools into the user-level
+MoneyOS tool home:
+
+```bash
+npm install moneyos
+moneyos init
+moneyos auth unlock
+moneyos add swap
+moneyos tools
+moneyos swap 0.1 RYZE ETH
+```
 
-Install it alongside the root package:
+For direct package usage, install the tool package alongside `moneyos`:
 
 ```bash
 npm install moneyos @moneyos/swap
@@ -109,7 +148,8 @@ Published packages:
 - `@moneyos/swap`
 
 Current `moneyos` releases no longer bundle swap into the root SDK or CLI. If
-you want swap, install `@moneyos/swap` alongside `moneyos`.
+you want swap from the root CLI, install `moneyos` and then run
+`moneyos add swap`.
 
 ## Current wallet model
 
@@ -119,6 +159,7 @@ What is landed in code today:
 - `~/.moneyos/config.json` now stores only non-secret settings such as chain and RPC configuration
 - `MONEYOS_PRIVATE_KEY` remains an explicit override for ephemeral CI or agent runs
 - `moneyos auth unlock` opens a short-lived local session for write commands
+- workflow scripts can attach to that unlocked session with `connectLocalSession()`
 - `moneyos auth change-password` rotates the local wallet password and locks the current session
 - `moneyos backup export|restore|status` manages encrypted wallet backups
 - Normal wallet commands resolve their write path through one shared session-aware flow

package/dist/cli/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli/index.ts
-import { Command as Command7 } from "commander";
+import { Command as Command10 } from "commander";
 import { realpathSync } from "fs";
 import { resolve as resolve3 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
@@ -511,6 +511,15 @@ function saveConfig(config, path = CONFIG_FILE) {
 function getConfigPath() {
   return CONFIG_FILE;
 }
+function getToolHomeDir() {
+  return join3(CONFIG_DIR, "tools");
+}
+function getToolHomePackageJsonPath() {
+  return join3(getToolHomeDir(), "package.json");
+}
+function getToolRegistryPath() {
+  return join3(getToolHomeDir(), "registry.json");
+}
 function getWalletPath(config) {
   return config?.walletPath ?? join3(CONFIG_DIR, "wallet.json");
 }
@@ -1442,6 +1451,43 @@ import {
   parseUnits,
   encodeFunctionData
 } from "viem";
+
+// src/core/assets.ts
+var DefaultAssetRegistry = class {
+  nativeTokenAddress = NATIVE_TOKEN_ADDRESS;
+  getToken = getToken;
+  getTokenAddress = getTokenAddress;
+  getChain = getChain;
+};
+
+// src/core/no-executor.ts
+var NO_SIGNING_ACCOUNT_ERROR = "No signing account configured. Set `signer`, `privateKey`, or `execute` in MoneyOS config.";
+function throwNoSigningAccount() {
+  throw new Error(NO_SIGNING_ACCOUNT_ERROR);
+}
+function createNoExecutorClient() {
+  return {
+    mode: "eoa",
+    getAddress() {
+      return throwNoSigningAccount();
+    },
+    async send(_call) {
+      return throwNoSigningAccount();
+    },
+    async sendBatch(_calls) {
+      return throwNoSigningAccount();
+    },
+    capabilities() {
+      return {
+        sponsoredGas: false,
+        batching: false,
+        simulation: false
+      };
+    }
+  };
+}
+
+// src/core/client.ts
 var ERC20_ABI = [
   {
     name: "balanceOf",
@@ -1475,12 +1521,6 @@ var ERC20_ABI = [
     outputs: [{ name: "", type: "string" }]
   }
 ];
-var DefaultAssetRegistry = class {
-  nativeTokenAddress = NATIVE_TOKEN_ADDRESS;
-  getToken = getToken;
-  getTokenAddress = getTokenAddress;
-  getChain = getChain;
-};
 var MoneyOS = class {
   read;
   executor;
@@ -1526,9 +1566,7 @@ var MoneyOS = class {
   }
   requireExecutor() {
     if (!this.executor) {
-      throw new Error(
-        "No signing account configured. Set `signer`, `privateKey`, or `execute` in MoneyOS config."
-      );
+      throw new Error(NO_SIGNING_ACCOUNT_ERROR);
     }
     return this.executor;
   }
@@ -1605,6 +1643,23 @@ var MoneyOS = class {
   }
 };
 
+// src/local-session.ts
+async function connectLocalSession(options = {}) {
+  const socketPath = options.socketPath ?? getSessionSocketPath();
+  const tokenPath = options.tokenPath ?? getSessionTokenPath();
+  const session = await getSessionStatus(socketPath, tokenPath);
+  if (!session) {
+    throw new Error(
+      "No active local MoneyOS session found. Run `moneyos auth unlock` locally first."
+    );
+  }
+  return new SessionExecutionClient({
+    socketPath,
+    tokenPath,
+    address: session.address
+  });
+}
+
 // src/cli/wallet.ts
 function resolveEnvPrivateKey(explicit) {
   return explicit ?? process.env.MONEYOS_PRIVATE_KEY;
@@ -1665,16 +1720,15 @@ async function buildCliMoneyOSConfig(config, options = {}) {
   }
   const socketPath = getSessionPath(options);
   const tokenPath = getTokenPath(options);
-  const session = await getSessionStatus(socketPath, tokenPath);
-  if (session) {
+  try {
     return {
       ...moneyosConfig,
-      execute: new SessionExecutionClient({
+      execute: await connectLocalSession({
         socketPath,
-        tokenPath,
-        address: session.address
+        tokenPath
       })
     };
+  } catch {
   }
   const wallet = getWalletStore(config, options);
   if (wallet.exists()) {
@@ -2089,21 +2143,341 @@ backupCommand.command("status").description("Show the local wallet backup status
   console.log(formatBackupStatus(status));
 });
 
+// src/cli/commands/tools.ts
+import { Command as Command9 } from "commander";
+
+// src/cli/tools/manager.ts
+import { spawn as spawn2 } from "child_process";
+import { createRequire } from "module";
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname4, join as join4 } from "path";
+import { pathToFileURL } from "url";
+import { Command as Command8, CommanderError } from "commander";
+
+// src/cli/tools/runtime.ts
+import { Command as Command7 } from "commander";
+var defaultCreateMoneyOSCliContextDependencies = {
+  loadConfig,
+  connectLocalSession,
+  createReadClient: ({ chainId, rpcUrl }) => new ViemReadClient({
+    defaultChainId: chainId,
+    rpcUrl
+  }),
+  createAssets: () => new DefaultAssetRegistry()
+};
+function createMoneyOSCliContext(deps = defaultCreateMoneyOSCliContextDependencies) {
+  return {
+    Command: Command7,
+    async getRuntime(options = {}) {
+      const config = deps.loadConfig();
+      const chainId = options.chainId ?? config.chainId ?? 42161;
+      const rpcUrl = config.rpcUrl;
+      return {
+        read: deps.createReadClient({ chainId, rpcUrl }),
+        execute: options.requireSession ? await deps.connectLocalSession() : createNoExecutorClient(),
+        assets: deps.createAssets(),
+        config: {
+          defaultChainId: chainId,
+          rpcUrl
+        }
+      };
+    }
+  };
+}
+
+// src/cli/tools/manager.ts
+var RESERVED_ROOT_COMMANDS = /* @__PURE__ */ new Set(["init", "auth", "backup", "balance", "send", "keystore", "add", "remove", "tools", "help", "__session-daemon"]);
+var FIRST_PARTY_TOOL_ALIASES = { swap: "@moneyos/swap" };
+var SHARED_TOOL_HOME_DEPENDENCIES = { "@moneyos/core": "^0.1.0", viem: "^2.45.1" };
+var VALID_COMMAND_SEGMENT = /^[A-Za-z0-9][A-Za-z0-9-]*$/;
+var getPaths = () => ({
+  rootDir: getToolHomeDir(),
+  packageJsonPath: getToolHomePackageJsonPath(),
+  registryPath: getToolRegistryPath()
+});
+function ensureToolHome(paths) {
+  if (!existsSync5(paths.rootDir)) mkdirSync4(paths.rootDir, { recursive: true, mode: 448 });
+  const exists = existsSync5(paths.packageJsonPath);
+  const parsed = exists ? JSON.parse(readFileSync4(paths.packageJsonPath, "utf8")) : void 0;
+  const packageJson = {
+    name: parsed?.name ?? "moneyos-tools",
+    private: parsed?.private ?? true,
+    description: parsed?.description ?? "User-level installed MoneyOS CLI tools",
+    dependencies: { ...parsed?.dependencies ?? {} }
+  };
+  let changed = !exists;
+  for (const [name, version2] of Object.entries(SHARED_TOOL_HOME_DEPENDENCIES)) {
+    if (packageJson.dependencies[name] !== version2) {
+      packageJson.dependencies[name] = version2;
+      changed = true;
+    }
+  }
+  if (changed) writeFileSync3(paths.packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
+`, { mode: 384 });
+  if (!existsSync5(paths.registryPath)) writeFileSync3(paths.registryPath, "[]\n", { mode: 384 });
+}
+function parseRegistryEntry(value) {
+  if (typeof value !== "object" || value === null) throw new Error("Invalid tool registry entry.");
+  const entry = value;
+  if (typeof entry.packageName !== "string" || typeof entry.packageVersion !== "string" || entry.toolVersion !== 1 || typeof entry.name !== "string" || typeof entry.description !== "string" || !Array.isArray(entry.commandPath) || entry.commandPath.length === 0 || entry.commandPath.some((segment) => typeof segment !== "string" || !VALID_COMMAND_SEGMENT.test(segment))) throw new Error("Invalid tool registry entry.");
+  return { packageName: entry.packageName, packageVersion: entry.packageVersion, toolVersion: 1, name: entry.name, commandPath: [...entry.commandPath], description: entry.description };
+}
+function parseLoadedTool(packageName, packageVersion, value) {
+  if (typeof value !== "object" || value === null) throw new Error(`Package ${packageName} does not export \`moneyosCliTool\`.`);
+  const tool = value;
+  if (tool.version !== 1 || typeof tool.name !== "string" || typeof tool.description !== "string" || !Array.isArray(tool.commandPath) || tool.commandPath.length === 0 || tool.commandPath.some((segment) => typeof segment !== "string" || !VALID_COMMAND_SEGMENT.test(segment)) || typeof tool.createCommand !== "function") throw new Error(`Package ${packageName} exports an invalid \`moneyosCliTool\`.`);
+  return { packageName, packageVersion, toolVersion: 1, name: tool.name, commandPath: [...tool.commandPath], description: tool.description, createCommand: tool.createCommand };
+}
+function readRegistry(paths) {
+  ensureToolHome(paths);
+  const parsed = JSON.parse(readFileSync4(paths.registryPath, "utf8"));
+  if (!Array.isArray(parsed)) throw new Error(`Tool registry at ${paths.registryPath} is invalid.`);
+  return parsed.map(parseRegistryEntry);
+}
+function writeRegistry(paths, entries) {
+  ensureToolHome(paths);
+  writeFileSync3(paths.registryPath, `${JSON.stringify(entries, null, 2)}
+`, { mode: 384 });
+}
+function getConflict(entry, entries) {
+  const path = entry.commandPath.join(" ");
+  if (RESERVED_ROOT_COMMANDS.has(entry.name) || RESERVED_ROOT_COMMANDS.has(entry.commandPath[0])) {
+    return `reserved root command collision for ${path}`;
+  }
+  for (const other of entries) {
+    if (other.packageName === entry.packageName) continue;
+    const otherPath = other.commandPath.join(" ");
+    if (path === otherPath || path.startsWith(`${otherPath} `) || otherPath.startsWith(`${path} `)) {
+      return `command path ${path} collides with installed tool path ${otherPath}`;
+    }
+  }
+}
+async function runNpm(paths, args) {
+  await new Promise((resolve4, reject) => {
+    const child = spawn2("npm", args, { cwd: paths.rootDir, stdio: "pipe" });
+    let stderr = "";
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", reject);
+    child.on("close", (code) => code === 0 ? resolve4() : reject(new Error(stderr.trim() || `npm ${args[0]} failed with exit code ${String(code)}.`)));
+  });
+}
+async function loadInstalledToolFromFs(paths, packageName) {
+  const toolRequire = createRequire(paths.packageJsonPath);
+  let entryPath;
+  try {
+    entryPath = toolRequire.resolve(packageName);
+  } catch {
+    throw new Error(`Package ${packageName} is missing from ${join4(paths.rootDir, "node_modules")}.`);
+  }
+  for (let root = dirname4(entryPath); root !== dirname4(root); root = dirname4(root)) {
+    const packageJsonPath2 = join4(root, "package.json");
+    if (!existsSync5(packageJsonPath2)) continue;
+    const packageJson = JSON.parse(readFileSync4(packageJsonPath2, "utf8"));
+    if (packageJson.name === packageName && typeof packageJson.version === "string") {
+      const moduleNamespace = await import(pathToFileURL(entryPath).href);
+      return parseLoadedTool(
+        packageJson.name,
+        packageJson.version,
+        moduleNamespace.moneyosCliTool ?? moduleNamespace.default?.moneyosCliTool
+      );
+    }
+  }
+  throw new Error(`Could not find package.json for installed package ${packageName}.`);
+}
+function createCliToolManager(params = {}) {
+  const paths = params.paths ?? getPaths();
+  const cliContext = params.cliContext ?? createMoneyOSCliContext();
+  const install = params.packageManager?.install ?? ((toolPaths, spec) => runNpm(toolPaths, ["install", "--save-exact", "--no-fund", "--no-audit", spec]));
+  const uninstall = params.packageManager?.uninstall ?? ((toolPaths, packageName) => runNpm(toolPaths, ["uninstall", "--no-fund", "--no-audit", packageName]));
+  const loadInstalledTool = params.moduleLoader ? async (toolPaths, packageName) => {
+    const loaded = await params.moduleLoader(toolPaths, packageName);
+    return parseLoadedTool(loaded.packageName, loaded.packageVersion, loaded.cliTool);
+  } : loadInstalledToolFromFs;
+  const sameMetadata = (left, right) => left.packageName === right.packageName && left.packageVersion === right.packageVersion && left.toolVersion === right.toolVersion && left.name === right.name && left.description === right.description && left.commandPath.join("\0") === right.commandPath.join("\0");
+  const resolveInstalledTool = (input, entries) => entries.find((entry) => entry.packageName === input) ?? entries.find((entry) => entry.packageName === FIRST_PARTY_TOOL_ALIASES[input]) ?? (() => {
+    const matches = entries.filter((entry) => entry.name === input || entry.commandPath.join(" ") === input);
+    return matches.length === 1 ? matches[0] : void 0;
+  })();
+  async function invoke(entry, args) {
+    let command;
+    try {
+      const loaded = await loadInstalledTool(paths, entry.packageName);
+      if (!sameMetadata(entry, loaded)) throw new Error("installed metadata does not match registry");
+      command = loaded.createCommand(cliContext);
+      if (!(command instanceof Command8) || command.name() !== entry.commandPath[entry.commandPath.length - 1]) {
+        throw new Error("createCommand() did not return the expected command");
+      }
+      command.exitOverride();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Installed tool ${entry.commandPath.join(" ")} is broken: ${message}. Run \`moneyos add ${entry.packageName}\` to repair it or \`moneyos remove ${entry.packageName}\` to uninstall it.`);
+    }
+    try {
+      await command.parseAsync([process.execPath, entry.commandPath[entry.commandPath.length - 1], ...args]);
+    } catch (error) {
+      if (error instanceof CommanderError) {
+        if (error.code !== "commander.helpDisplayed") process.exitCode = error.exitCode || 1;
+        return;
+      }
+      throw error;
+    }
+  }
+  return {
+    getRegistryEntries() {
+      return readRegistry(paths);
+    },
+    mountInstalledToolCommands(program) {
+      let entries;
+      try {
+        entries = readRegistry(paths);
+      } catch {
+        return;
+      }
+      const groups = /* @__PURE__ */ new Map();
+      for (const entry of entries) {
+        if (getConflict(entry, entries)) continue;
+        let parent = program;
+        const segments = [];
+        for (const segment of entry.commandPath.slice(0, -1)) {
+          segments.push(segment);
+          const key = segments.join(" ");
+          const group = groups.get(key) ?? new Command8(segment).description("Installed MoneyOS tool commands");
+          if (!groups.has(key)) {
+            groups.set(key, group);
+            parent.addCommand(group);
+          }
+          parent = group;
+        }
+        parent.addCommand(
+          new Command8(entry.commandPath[entry.commandPath.length - 1]).description(entry.description).allowUnknownOption(true).allowExcessArguments(true).helpOption(false).argument("[args...]").action(async (args) => {
+            await invoke(entry, args);
+          })
+        );
+      }
+    },
+    async addTool(input) {
+      const spec = FIRST_PARTY_TOOL_ALIASES[input] ?? input;
+      const entries = readRegistry(paths);
+      const previous = resolveInstalledTool(input, entries);
+      ensureToolHome(paths);
+      const before = JSON.parse(readFileSync4(paths.packageJsonPath, "utf8")).dependencies ?? {};
+      await install(paths, spec);
+      const after = JSON.parse(readFileSync4(paths.packageJsonPath, "utf8")).dependencies ?? {};
+      const changed = previous?.packageName ?? Object.keys(after).find((name) => before[name] !== after[name] && !(name in SHARED_TOOL_HOME_DEPENDENCIES));
+      try {
+        const loaded = await loadInstalledTool(paths, changed ?? spec);
+        const next = previous ? entries.filter((entry2) => entry2.packageName !== previous.packageName) : entries;
+        const conflict = getConflict(loaded, next);
+        if (conflict) throw new Error(conflict);
+        const entry = { packageName: loaded.packageName, packageVersion: loaded.packageVersion, toolVersion: loaded.toolVersion, name: loaded.name, commandPath: loaded.commandPath, description: loaded.description };
+        writeRegistry(paths, [...next, entry]);
+        return entry;
+      } catch (error) {
+        try {
+          if (previous) await install(paths, `${previous.packageName}@${previous.packageVersion}`);
+          else if (changed) await uninstall(paths, changed);
+        } catch {
+        }
+        throw error;
+      }
+    },
+    async removeTool(input) {
+      const entries = readRegistry(paths);
+      const entry = resolveInstalledTool(input, entries);
+      if (!entry) throw new Error(`Tool ${input} is not installed.`);
+      await uninstall(paths, entry.packageName);
+      writeRegistry(paths, entries.filter((installed) => installed.packageName !== entry.packageName));
+      return entry;
+    },
+    async listTools() {
+      const entries = readRegistry(paths);
+      const tools = await Promise.all(entries.map(async (entry) => {
+        const conflict = getConflict(entry, entries);
+        if (conflict) return { ...entry, state: "conflict", problems: [conflict] };
+        try {
+          const loaded = await loadInstalledTool(paths, entry.packageName);
+          if (!sameMetadata(entry, loaded)) throw new Error("installed metadata does not match registry");
+          return { ...entry, state: "ok", problems: [] };
+        } catch (error) {
+          return { ...entry, state: "broken", problems: [error instanceof Error ? error.message : String(error)] };
+        }
+      }));
+      return tools.sort((left, right) => left.commandPath.join(" ").localeCompare(right.commandPath.join(" ")));
+    }
+  };
+}
+function formatToolStatusTable(tools) {
+  if (tools.length === 0) return "No tools installed.";
+  const commandWidth = Math.max("COMMAND".length, ...tools.map((tool) => tool.commandPath.join(" ").length));
+  const packageWidth = Math.max("PACKAGE".length, ...tools.map((tool) => tool.packageName.length));
+  const versionWidth = Math.max("VERSION".length, ...tools.map((tool) => tool.packageVersion.length));
+  const lines = [`${"COMMAND".padEnd(commandWidth)}  ${"PACKAGE".padEnd(packageWidth)}  ${"VERSION".padEnd(versionWidth)}  STATE`];
+  for (const tool of tools) {
+    lines.push(`${tool.commandPath.join(" ").padEnd(commandWidth)}  ${tool.packageName.padEnd(packageWidth)}  ${tool.packageVersion.padEnd(versionWidth)}  ${tool.state}`);
+    for (const problem of tool.problems) lines.push(`  ${problem}`);
+  }
+  return lines.join("\n");
+}
+
+// src/cli/commands/tools.ts
+function formatError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function createAddToolCommand(toolManager) {
+  return new Command9("add").description("Install or update a MoneyOS CLI tool into the user tool home").argument("<tool>", "Tool alias or npm package spec").action(async (tool) => {
+    try {
+      const entry = await toolManager.addTool(tool);
+      console.log(
+        `Installed ${entry.packageName}@${entry.packageVersion} as \`moneyos ${entry.commandPath.join(" ")}\`.`
+      );
+    } catch (error) {
+      console.error(formatError(error));
+      process.exitCode = 1;
+    }
+  });
+}
+function createRemoveToolCommand(toolManager) {
+  return new Command9("remove").description("Remove an installed MoneyOS CLI tool from the user tool home").argument("<tool>", "Installed tool name, command path, or npm package").action(async (tool) => {
+    try {
+      const entry = await toolManager.removeTool(tool);
+      console.log(
+        `Removed ${entry.packageName} from \`moneyos ${entry.commandPath.join(" ")}\`.`
+      );
+    } catch (error) {
+      console.error(formatError(error));
+      process.exitCode = 1;
+    }
+  });
+}
+function createToolsCommand(toolManager) {
+  return new Command9("tools").description("List installed MoneyOS CLI tools from the registry").action(async () => {
+    try {
+      console.log(formatToolStatusTable(await toolManager.listTools()));
+    } catch (error) {
+      console.error(formatError(error));
+      process.exitCode = 1;
+    }
+  });
+}
+
 // src/cli/version.ts
-import { readFileSync as readFileSync4 } from "fs";
+import { readFileSync as readFileSync5 } from "fs";
 import { fileURLToPath } from "url";
-import { dirname as dirname4, resolve as resolve2 } from "path";
+import { dirname as dirname5, resolve as resolve2 } from "path";
 var packageJsonPath = resolve2(
-  dirname4(fileURLToPath(import.meta.url)),
+  dirname5(fileURLToPath(import.meta.url)),
   "../../package.json"
 );
 var version = JSON.parse(
-  readFileSync4(packageJsonPath, "utf8")
+  readFileSync5(packageJsonPath, "utf8")
 ).version;
 
 // src/cli/index.ts
-function createProgram() {
-  const program = new Command7();
+function createProgram(options = {}) {
+  const program = new Command10();
+  const toolManager = options.toolManager ?? createCliToolManager();
   program.name("moneyos").description("The operating system for money").version(version);
   program.addCommand(initCommand);
   program.addCommand(balanceCommand);
@@ -2111,6 +2485,10 @@ function createProgram() {
   program.addCommand(keystoreCommand);
   program.addCommand(authCommand);
   program.addCommand(backupCommand);
+  program.addCommand(createAddToolCommand(toolManager));
+  program.addCommand(createRemoveToolCommand(toolManager));
+  program.addCommand(createToolsCommand(toolManager));
+  toolManager.mountInstalledToolCommands(program);
   program.command("__session-daemon", { hidden: true }).action(async () => {
     await runSessionDaemonProcess();
   });