moneyos 0.5.0 → 0.5.1

package/CHANGELOG.md

@@ -0,0 +1,158 @@
+# Changelog
+
+All notable changes to the repo's current `main` branch are documented here.
+
+## 0.5.1 - 2026-04-13
+
+### Fixed
+
+- publish workflow now upgrades npm to latest before publish, which
+  activates the Trusted Publishing OIDC exchange that Node 22's bundled
+  npm does not support out of the box; without this the previous
+  prerelease attempts failed at npm auth despite correct Trusted
+  Publisher configuration
+- publish command now includes `--provenance` again; it was accidentally
+  dropped during the `0.5.1-rc.1` auth-path revert, which would have
+  resulted in unsigned releases even if publish succeeded
+
+## 0.5.1-rc.1 - 2026-04-13
+
+### Changed
+
+- root release publishing now runs from a tag-triggered GitHub Actions workflow
+  that verifies tag-to-version alignment, reruns lint/typecheck/tests, verifies
+  packed tarballs, and publishes with npm Trusted Publishing plus provenance
+- root release package metadata now uses the canonical `1231CheGites/MoneyOS`
+  GitHub URL casing for repository links and provenance alignment
+- `CONTRIBUTING.md` now documents the forward release tag convention:
+  `moneyos-v<version>` for root releases and `moneyos-<package>-v<version>` for
+  workspace packages, with bare `v<version>` retained only for historical tags
+- the publish workflow now isolates the actual `npm publish` command from
+  token-based npm auth config and publishes prerelease versions under the
+  `next` dist-tag instead of `latest`
+
+## 0.5.0 - 2026-04-12
+
+### Added
+
+- `moneyos` now ships first-class CLI tool install/use UX with `moneyos add`,
+  `moneyos remove`, and `moneyos tools`
+- root CLI tool loading now uses a user-scoped registry and lazy-loads
+  installed tool packages on demand instead of baking tool logic into root
+
+### Fixed
+
+- runtime errors thrown by installed tools now pass through to the user instead
+  of being mislabeled as broken-tool repair errors; only load/validation
+  failures are wrapped as installed-tool breakage
+
+## 0.4.1 - 2026-04-12
+
+### Fixed
+
+- fixed the published `moneyos` CLI entrypoint so `npm install moneyos` now
+  produces a working `moneyos` binary from `node_modules/.bin`; `0.4.0`
+  incorrectly exited without printing help or version because the entrypoint
+  guard did not resolve npm's symlinked bin path
+
+## 0.4.0 - 2026-04-12
+
+### Changed
+
+- `moneyos` now treats swap as an external package instead of a built-in root
+  workflow; install `@moneyos/swap` separately when you want swap support
+- the root README and developer docs now point at the published workspace
+  packages and the current package boundary split
+
+## 0.3.4 - 2026-04-12
+
+### Added
+
+- added `moneyos auth change-password` so users can rotate the active wallet
+  password without changing wallet identity metadata; a successful rotation
+  also locks the current local session and leaves existing backup files as
+  old-password snapshots until a fresh export is created
+
+### Changed
+
+- added CLI-level regression coverage for legacy plaintext wallet migration,
+  `moneyos init --force`, malformed `moneyos init --key`, backup export
+  messaging, and wallet password rotation flows
+
+### Fixed
+
+- `moneyos backup export` now states plainly that exported backups use the same
+  wallet password as the active wallet and that restore requires that same
+  password
+- insecure backup export destinations now report destination-specific
+  permission errors instead of misleading wallet-path errors
+
+## 0.3.3 - 2026-04-11
+
+### Removed
+
+- removed the unused Particle executor workspace, smoke script, and supporting
+  docs/build references so the repo matches the current local-wallet-first
+  product surface
+
+## 0.3.2 - 2026-04-11
+
+### Changed
+
+- corrected the README's published-package section so the npm package page no
+  longer claims `moneyos` is still on a pre-encrypted-wallet release
+
+## 0.3.1 - 2026-04-11
+
+### Fixed
+
+- `moneyos --version` now reports the package version from `package.json`
+  instead of a stale hardcoded string
+- added regression coverage to keep the CLI version output aligned with the
+  published package version
+
+## 0.3.0 - 2026-04-11
+
+### Added
+
+- encrypted local wallet storage at `~/.moneyos/wallet.json`
+- `moneyos auth unlock|lock|status` for local session-based write access
+- encrypted wallet backup support via `moneyos backup export|restore|status`
+- tests for encrypted wallet storage, session lifecycle, prompt TTY gating, and
+  backup safety checks
+- GitHub Actions CI workflow running lint, typecheck, tests, and builds across
+  the root package and every workspace package on every pull request and on
+  pushes to `main`
+
+### Changed
+
+- `~/.moneyos/config.json` now stores non-secret settings only
+- legacy plaintext `config.json.privateKey` state is treated as import-only, not
+  active runtime wallet state
+- the removed 1Password-backed wallet model remains unsupported
+- the README and wallet architecture docs now describe the encrypted-wallet
+  model as the current source of truth
+- `@moneyos/core` is now bundled into the published `moneyos` package; it is
+  internal workspace plumbing and consumers no longer need to resolve it
+- `package-lock.json` is now tracked in git for reproducible installs across CI
+  and developer machines
+
+### Fixed
+
+- session-backed `send` and `swap` no longer use the same `750ms` timeout as
+  `auth status` and `auth lock`
+- session-backed send requests now use a longer RPC-appropriate timeout budget
+- the daemon send path has regression coverage for slow local IPC round trips
+- a leaky wallet-path test now uses an isolated tmpdir instead of the
+  developer's real `~/.moneyos/wallet.json`
+- the published `moneyos` tarball now installs cleanly as a standalone package;
+  earlier builds leaked `@moneyos/core` as a runtime import in both the emitted
+  JS and the emitted type declarations, so `npm install moneyos` in a clean
+  directory could not resolve its own runtime dependencies
+- `EOAExecutor.send` now awaits the transaction receipt before resolving and
+  throws on a non-success receipt; sequenced flows like "approve then swap" now
+  work on the first attempt against a fresh wallet, and viem's in-memory nonce
+  manager no longer drifts past the chain when a preflight rejects a queued
+  transaction
+- session tests now use short socket and token paths so they no longer break in
+  long temp directories (the POSIX 108-byte unix socket path limit)

package/dist/cli/index.js

@@ -4,7 +4,7 @@
 import { Command as Command10 } from "commander";
 import { realpathSync } from "fs";
 import { resolve as resolve3 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/cli/commands/init.ts
 import { Command } from "commander";
@@ -2151,7 +2151,7 @@ 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 { fileURLToPath, pathToFileURL } from "url";
 import { Command as Command8, CommanderError } from "commander";
 
 // src/cli/tools/runtime.ts
@@ -2186,16 +2186,46 @@ function createMoneyOSCliContext(deps = defaultCreateMoneyOSCliContextDependenci
 }
 
 // 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 DEFAULT_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) {
+function findRootPackageJsonPath() {
+  let currentDir = dirname4(fileURLToPath(import.meta.url));
+  while (true) {
+    const candidate = join4(currentDir, "package.json");
+    if (existsSync5(candidate)) {
+      const packageJson = JSON.parse(readFileSync4(candidate, "utf8"));
+      if (packageJson.name === "moneyos") return candidate;
+    }
+    const parentDir = dirname4(currentDir);
+    if (parentDir === currentDir) {
+      throw new Error("Could not find the root moneyos package.json.");
+    }
+    currentDir = parentDir;
+  }
+}
+function getSharedToolHomeDependencies() {
+  const rootPackageJsonPath = findRootPackageJsonPath();
+  const packageJson = JSON.parse(readFileSync4(rootPackageJsonPath, "utf8"));
+  const coreVersion = packageJson.moneyos?.toolHomeDependencies?.["@moneyos/core"];
+  const viemVersion = packageJson.dependencies?.viem;
+  if (typeof coreVersion !== "string" || typeof viemVersion !== "string") {
+    throw new Error(`Root package metadata at ${rootPackageJsonPath} is missing tool-home dependency versions.`);
+  }
+  return { "@moneyos/core": coreVersion, viem: viemVersion };
+}
+function collectReservedRootCommandNames(program) {
+  return /* @__PURE__ */ new Set([
+    "help",
+    ...program.commands.flatMap((command) => [command.name(), ...command.aliases()])
+  ]);
+}
+function ensureToolHome(paths, sharedToolHomeDependencies) {
   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;
@@ -2206,7 +2236,7 @@ function ensureToolHome(paths) {
     dependencies: { ...parsed?.dependencies ?? {} }
   };
   let changed = !exists;
-  for (const [name, version2] of Object.entries(SHARED_TOOL_HOME_DEPENDENCIES)) {
+  for (const [name, version2] of Object.entries(sharedToolHomeDependencies)) {
     if (packageJson.dependencies[name] !== version2) {
       packageJson.dependencies[name] = version2;
       changed = true;
@@ -2228,20 +2258,9 @@ function parseLoadedTool(packageName, packageVersion, 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) {
+function getConflict(entry, entries, reservedRootCommands) {
   const path = entry.commandPath.join(" ");
-  if (RESERVED_ROOT_COMMANDS.has(entry.name) || RESERVED_ROOT_COMMANDS.has(entry.commandPath[0])) {
+  if (reservedRootCommands.has(entry.name) || reservedRootCommands.has(entry.commandPath[0])) {
     return `reserved root command collision for ${path}`;
   }
   for (const other of entries) {
@@ -2289,6 +2308,9 @@ async function loadInstalledToolFromFs(paths, packageName) {
 function createCliToolManager(params = {}) {
   const paths = params.paths ?? getPaths();
   const cliContext = params.cliContext ?? createMoneyOSCliContext();
+  const sharedToolHomeDependencies = params.sharedToolHomeDependencies ?? getSharedToolHomeDependencies();
+  const sharedToolHomeDependencyNames = new Set(Object.keys(sharedToolHomeDependencies));
+  let reservedRootCommands = new Set(params.reservedRootCommands ?? DEFAULT_RESERVED_ROOT_COMMANDS);
   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) => {
@@ -2300,6 +2322,17 @@ function createCliToolManager(params = {}) {
     const matches = entries.filter((entry) => entry.name === input || entry.commandPath.join(" ") === input);
     return matches.length === 1 ? matches[0] : void 0;
   })();
+  const getRegistryEntries = () => {
+    ensureToolHome(paths, sharedToolHomeDependencies);
+    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);
+  };
+  const writeRegistryEntries = (entries) => {
+    ensureToolHome(paths, sharedToolHomeDependencies);
+    writeFileSync3(paths.registryPath, `${JSON.stringify(entries, null, 2)}
+`, { mode: 384 });
+  };
   async function invoke(entry, args) {
     let command;
     try {
@@ -2326,18 +2359,19 @@ function createCliToolManager(params = {}) {
   }
   return {
     getRegistryEntries() {
-      return readRegistry(paths);
+      return getRegistryEntries();
     },
     mountInstalledToolCommands(program) {
       let entries;
       try {
-        entries = readRegistry(paths);
+        entries = getRegistryEntries();
       } catch {
         return;
       }
+      reservedRootCommands = collectReservedRootCommandNames(program);
       const groups = /* @__PURE__ */ new Map();
       for (const entry of entries) {
-        if (getConflict(entry, entries)) continue;
+        if (getConflict(entry, entries, reservedRootCommands)) continue;
         let parent = program;
         const segments = [];
         for (const segment of entry.commandPath.slice(0, -1)) {
@@ -2359,20 +2393,20 @@ function createCliToolManager(params = {}) {
     },
     async addTool(input) {
       const spec = FIRST_PARTY_TOOL_ALIASES[input] ?? input;
-      const entries = readRegistry(paths);
+      const entries = getRegistryEntries();
       const previous = resolveInstalledTool(input, entries);
-      ensureToolHome(paths);
+      ensureToolHome(paths, sharedToolHomeDependencies);
       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));
+      const changed = previous?.packageName ?? Object.keys(after).find((name) => before[name] !== after[name] && !sharedToolHomeDependencyNames.has(name));
       try {
         const loaded = await loadInstalledTool(paths, changed ?? spec);
         const next = previous ? entries.filter((entry2) => entry2.packageName !== previous.packageName) : entries;
-        const conflict = getConflict(loaded, next);
+        const conflict = getConflict(loaded, next, reservedRootCommands);
         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]);
+        writeRegistryEntries([...next, entry]);
         return entry;
       } catch (error) {
         try {
@@ -2384,17 +2418,17 @@ function createCliToolManager(params = {}) {
       }
     },
     async removeTool(input) {
-      const entries = readRegistry(paths);
+      const entries = getRegistryEntries();
       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));
+      writeRegistryEntries(entries.filter((installed) => installed.packageName !== entry.packageName));
       return entry;
     },
     async listTools() {
-      const entries = readRegistry(paths);
+      const entries = getRegistryEntries();
       const tools = await Promise.all(entries.map(async (entry) => {
-        const conflict = getConflict(entry, entries);
+        const conflict = getConflict(entry, entries, reservedRootCommands);
         if (conflict) return { ...entry, state: "conflict", problems: [conflict] };
         try {
           const loaded = await loadInstalledTool(paths, entry.packageName);
@@ -2464,10 +2498,10 @@ function createToolsCommand(toolManager) {
 
 // src/cli/version.ts
 import { readFileSync as readFileSync5 } from "fs";
-import { fileURLToPath } from "url";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import { dirname as dirname5, resolve as resolve2 } from "path";
 var packageJsonPath = resolve2(
-  dirname5(fileURLToPath(import.meta.url)),
+  dirname5(fileURLToPath2(import.meta.url)),
   "../../package.json"
 );
 var version = JSON.parse(
@@ -2488,10 +2522,10 @@ function createProgram(options = {}) {
   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();
   });
+  toolManager.mountInstalledToolCommands(program);
   return program;
 }
 function resolveEntrypointPath(path) {
@@ -2502,7 +2536,7 @@ function resolveEntrypointPath(path) {
   }
 }
 function isEntrypointPath(cliEntry, moduleUrl) {
-  return typeof cliEntry === "string" && resolveEntrypointPath(cliEntry) === fileURLToPath2(moduleUrl);
+  return typeof cliEntry === "string" && resolveEntrypointPath(cliEntry) === fileURLToPath3(moduleUrl);
 }
 if (isEntrypointPath(process.argv[1], import.meta.url)) {
   void createProgram().parseAsync(process.argv).catch((error) => {