@xylabs/aries 0.1.1

package/dist/commands/syncCommand.mjs

@@ -0,0 +1,66 @@
+// src/actions/sync/syncAiConfig.ts
+import {
+  copyFileSync,
+  cpSync,
+  existsSync,
+  rmSync
+} from "fs";
+import path from "path";
+import chalk from "chalk";
+function resolveMapping(from, cwd) {
+  if (from === "claude") {
+    return {
+      destDir: path.join(cwd, ".agents"),
+      destFile: path.join(cwd, "AGENTS.md"),
+      sourceDir: path.join(cwd, ".claude"),
+      sourceFile: path.join(cwd, "CLAUDE.md")
+    };
+  }
+  return {
+    destDir: path.join(cwd, ".claude"),
+    destFile: path.join(cwd, "CLAUDE.md"),
+    sourceDir: path.join(cwd, ".agents"),
+    sourceFile: path.join(cwd, "AGENTS.md")
+  };
+}
+function syncAiConfig(from) {
+  const cwd = process.cwd();
+  const mapping = resolveMapping(from, cwd);
+  if (!existsSync(mapping.sourceDir)) {
+    throw new Error(chalk.red(`Source directory not found: ${mapping.sourceDir}`));
+  }
+  if (!existsSync(mapping.sourceFile)) {
+    throw new Error(chalk.red(`Source file not found: ${mapping.sourceFile}`));
+  }
+  if (existsSync(mapping.destDir)) {
+    rmSync(mapping.destDir, { recursive: true });
+  }
+  if (existsSync(mapping.destFile)) {
+    rmSync(mapping.destFile);
+  }
+  cpSync(mapping.sourceDir, mapping.destDir, { recursive: true });
+  copyFileSync(mapping.sourceFile, mapping.destFile);
+  const label = from === "claude" ? "Claude \u2192 Codex" : "Codex \u2192 Claude";
+  console.log(chalk.green(`Synced ${label}:`));
+  console.log(`  ${path.basename(mapping.sourceDir)}/ \u2192 ${path.basename(mapping.destDir)}/`);
+  console.log(`  ${path.basename(mapping.sourceFile)} \u2192 ${path.basename(mapping.destFile)}`);
+}
+
+// src/commands/syncCommand.ts
+var syncCommand = {
+  builder: (yargs) => yargs.option("from", {
+    choices: ["claude", "agents"],
+    default: "claude",
+    describe: "Source to sync from (the authority)",
+    type: "string"
+  }),
+  command: "sync",
+  describe: "Sync AI config between Claude Code and Codex",
+  handler: (argv) => {
+    syncAiConfig(argv.from);
+  }
+};
+export {
+  syncCommand
+};
+//# sourceMappingURL=syncCommand.mjs.map

package/dist/commands/syncCommand.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/actions/sync/syncAiConfig.ts","../../src/commands/syncCommand.ts"],"sourcesContent":["import {\n  copyFileSync,\n  cpSync,\n  existsSync,\n  rmSync,\n} from 'node:fs'\nimport path from 'node:path'\n\nimport chalk from 'chalk'\n\ntype SyncSource = 'agents' | 'claude'\n\ninterface SyncMapping {\n  destDir: string\n  destFile: string\n  sourceDir: string\n  sourceFile: string\n}\n\nfunction resolveMapping(from: SyncSource, cwd: string): SyncMapping {\n  if (from === 'claude') {\n    return {\n      destDir: path.join(cwd, '.agents'),\n      destFile: path.join(cwd, 'AGENTS.md'),\n      sourceDir: path.join(cwd, '.claude'),\n      sourceFile: path.join(cwd, 'CLAUDE.md'),\n    }\n  }\n  return {\n    destDir: path.join(cwd, '.claude'),\n    destFile: path.join(cwd, 'CLAUDE.md'),\n    sourceDir: path.join(cwd, '.agents'),\n    sourceFile: path.join(cwd, 'AGENTS.md'),\n  }\n}\n\nexport function syncAiConfig(from: SyncSource): void {\n  const cwd = process.cwd()\n  const mapping = resolveMapping(from, cwd)\n\n  if (!existsSync(mapping.sourceDir)) {\n    throw new Error(chalk.red(`Source directory not found: ${mapping.sourceDir}`))\n  }\n\n  if (!existsSync(mapping.sourceFile)) {\n    throw new Error(chalk.red(`Source file not found: ${mapping.sourceFile}`))\n  }\n\n  if (existsSync(mapping.destDir)) {\n    rmSync(mapping.destDir, { recursive: true })\n  }\n\n  if (existsSync(mapping.destFile)) {\n    rmSync(mapping.destFile)\n  }\n\n  cpSync(mapping.sourceDir, mapping.destDir, { recursive: true })\n  copyFileSync(mapping.sourceFile, mapping.destFile)\n\n  const label = from === 'claude' ? 'Claude → Codex' : 'Codex → Claude'\n  console.log(chalk.green(`Synced ${label}:`))\n  console.log(`  ${path.basename(mapping.sourceDir)}/ → ${path.basename(mapping.destDir)}/`)\n  console.log(`  ${path.basename(mapping.sourceFile)} → ${path.basename(mapping.destFile)}`)\n}\n","import type { CommandModule } from 'yargs'\n\nimport { syncAiConfig } from '../actions/sync/index.ts'\n\nexport const syncCommand: CommandModule = {\n  builder: yargs =>\n    yargs\n      .option('from', {\n        choices: ['claude', 'agents'] as const,\n        default: 'claude',\n        describe: 'Source to sync from (the authority)',\n        type: 'string',\n      }),\n  command: 'sync',\n  describe: 'Sync AI config between Claude Code and Codex',\n  handler: (argv) => {\n    syncAiConfig(argv.from as 'agents' | 'claude')\n  },\n}\n"],"mappings":";AAAA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,OAAO,UAAU;AAEjB,OAAO,WAAW;AAWlB,SAAS,eAAe,MAAkB,KAA0B;AAClE,MAAI,SAAS,UAAU;AACrB,WAAO;AAAA,MACL,SAAS,KAAK,KAAK,KAAK,SAAS;AAAA,MACjC,UAAU,KAAK,KAAK,KAAK,WAAW;AAAA,MACpC,WAAW,KAAK,KAAK,KAAK,SAAS;AAAA,MACnC,YAAY,KAAK,KAAK,KAAK,WAAW;AAAA,IACxC;AAAA,EACF;AACA,SAAO;AAAA,IACL,SAAS,KAAK,KAAK,KAAK,SAAS;AAAA,IACjC,UAAU,KAAK,KAAK,KAAK,WAAW;AAAA,IACpC,WAAW,KAAK,KAAK,KAAK,SAAS;AAAA,IACnC,YAAY,KAAK,KAAK,KAAK,WAAW;AAAA,EACxC;AACF;AAEO,SAAS,aAAa,MAAwB;AACnD,QAAM,MAAM,QAAQ,IAAI;AACxB,QAAM,UAAU,eAAe,MAAM,GAAG;AAExC,MAAI,CAAC,WAAW,QAAQ,SAAS,GAAG;AAClC,UAAM,IAAI,MAAM,MAAM,IAAI,+BAA+B,QAAQ,SAAS,EAAE,CAAC;AAAA,EAC/E;AAEA,MAAI,CAAC,WAAW,QAAQ,UAAU,GAAG;AACnC,UAAM,IAAI,MAAM,MAAM,IAAI,0BAA0B,QAAQ,UAAU,EAAE,CAAC;AAAA,EAC3E;AAEA,MAAI,WAAW,QAAQ,OAAO,GAAG;AAC/B,WAAO,QAAQ,SAAS,EAAE,WAAW,KAAK,CAAC;AAAA,EAC7C;AAEA,MAAI,WAAW,QAAQ,QAAQ,GAAG;AAChC,WAAO,QAAQ,QAAQ;AAAA,EACzB;AAEA,SAAO,QAAQ,WAAW,QAAQ,SAAS,EAAE,WAAW,KAAK,CAAC;AAC9D,eAAa,QAAQ,YAAY,QAAQ,QAAQ;AAEjD,QAAM,QAAQ,SAAS,WAAW,wBAAmB;AACrD,UAAQ,IAAI,MAAM,MAAM,UAAU,KAAK,GAAG,CAAC;AAC3C,UAAQ,IAAI,KAAK,KAAK,SAAS,QAAQ,SAAS,CAAC,YAAO,KAAK,SAAS,QAAQ,OAAO,CAAC,GAAG;AACzF,UAAQ,IAAI,KAAK,KAAK,SAAS,QAAQ,UAAU,CAAC,WAAM,KAAK,SAAS,QAAQ,QAAQ,CAAC,EAAE;AAC3F;;;AC3DO,IAAM,cAA6B;AAAA,EACxC,SAAS,WACP,MACG,OAAO,QAAQ;AAAA,IACd,SAAS,CAAC,UAAU,QAAQ;AAAA,IAC5B,SAAS;AAAA,IACT,UAAU;AAAA,IACV,MAAM;AAAA,EACR,CAAC;AAAA,EACL,SAAS;AAAA,EACT,UAAU;AAAA,EACV,SAAS,CAAC,SAAS;AACjB,iBAAa,KAAK,IAA2B;AAAA,EAC/C;AACF;","names":[]}

package/dist/commands/versionCommand.mjs

@@ -0,0 +1,24 @@
+// src/actions/printVersion.ts
+import chalk from "chalk";
+function printVersion() {
+  console.log(chalk.cyan("ariestools"));
+  console.log(`  Node:    ${process.version}`);
+  console.log(`  Platform: ${process.platform}`);
+  console.log(`  Arch:     ${process.arch}`);
+}
+
+// src/actions/index.ts
+import { executeWitness, registerWitnessCommand } from "@xylabs/aries-witness-cli";
+
+// src/commands/versionCommand.ts
+var versionCommand = {
+  command: "info",
+  describe: "Display ariestools version and environment info",
+  handler: () => {
+    printVersion();
+  }
+};
+export {
+  versionCommand
+};
+//# sourceMappingURL=versionCommand.mjs.map

package/dist/commands/versionCommand.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/actions/printVersion.ts","../../src/actions/index.ts","../../src/commands/versionCommand.ts"],"sourcesContent":["import chalk from 'chalk'\n\nexport function printVersion(): void {\n  console.log(chalk.cyan('ariestools'))\n  console.log(`  Node:    ${process.version}`)\n  console.log(`  Platform: ${process.platform}`)\n  console.log(`  Arch:     ${process.arch}`)\n}\n","export { installPlugin, uninstallPlugin } from './audit/index.ts'\nexport { listSessions } from './audit/index.ts'\nexport { searchAudit } from './audit/index.ts'\nexport { showSession } from './audit/index.ts'\nexport { statusAudit } from './audit/index.ts'\nexport { runClamped } from './clamp/index.ts'\nexport { detectAiClients } from './detect/index.ts'\nexport { printVersion } from './printVersion.ts'\nexport { syncAiConfig } from './sync/index.ts'\nexport * from './wallet/index.ts'\nexport { executeWitness, registerWitnessCommand } from '@xylabs/aries-witness-cli'\n","import type { CommandModule } from 'yargs'\n\nimport { printVersion } from '../actions/index.ts'\n\nexport const versionCommand: CommandModule = {\n  command: 'info',\n  describe: 'Display ariestools version and environment info',\n  handler: () => {\n    printVersion()\n  },\n}\n"],"mappings":";AAAA,OAAO,WAAW;AAEX,SAAS,eAAqB;AACnC,UAAQ,IAAI,MAAM,KAAK,YAAY,CAAC;AACpC,UAAQ,IAAI,cAAc,QAAQ,OAAO,EAAE;AAC3C,UAAQ,IAAI,eAAe,QAAQ,QAAQ,EAAE;AAC7C,UAAQ,IAAI,eAAe,QAAQ,IAAI,EAAE;AAC3C;;;ACGA,SAAS,gBAAgB,8BAA8B;;;ACNhD,IAAM,iBAAgC;AAAA,EAC3C,SAAS;AAAA,EACT,UAAU;AAAA,EACV,SAAS,MAAM;AACb,iBAAa;AAAA,EACf;AACF;","names":[]}

package/dist/commands/walletAccountCommand.mjs

@@ -0,0 +1,536 @@
+// src/actions/wallet/account/deriveAndAdd.ts
+import chalk from "chalk";
+
+// src/actions/wallet/paths.ts
+import OS from "os";
+import PATH from "path";
+function walletRoot() {
+  const override = process.env.ARIES_WALLET_HOME;
+  if (override) return override;
+  return PATH.join(OS.homedir(), ".aries", "wallet");
+}
+function walletPaths(root = walletRoot()) {
+  return {
+    root,
+    password: PATH.join(root, "password.json"),
+    phrases: PATH.join(root, "phrases.json"),
+    active: PATH.join(root, "active.json"),
+    addressBooks: PATH.join(root, "address-books.json"),
+    contacts: PATH.join(root, "contacts.json"),
+    networks: PATH.join(root, "networks.json"),
+    session: PATH.join(root, "session.json"),
+    machineId: PATH.join(root, ".machine-id")
+  };
+}
+
+// src/actions/wallet/storage.ts
+import FS from "fs";
+import PATH2 from "path";
+function ensureWalletDir(root = walletRoot()) {
+  if (!FS.existsSync(root)) {
+    FS.mkdirSync(root, { recursive: true, mode: 448 });
+    return;
+  }
+  try {
+    FS.chmodSync(root, 448);
+  } catch {
+  }
+}
+function readJsonFile(file) {
+  if (!FS.existsSync(file)) return void 0;
+  const raw = FS.readFileSync(file, "utf8");
+  if (raw.trim().length === 0) return void 0;
+  return JSON.parse(raw);
+}
+function writeJsonFile(file, value) {
+  ensureWalletDir(PATH2.dirname(file));
+  const tmp = `${file}.tmp`;
+  FS.writeFileSync(tmp, `${JSON.stringify(value, null, 2)}
+`, { mode: 384 });
+  FS.renameSync(tmp, file);
+  try {
+    FS.chmodSync(file, 384);
+  } catch {
+  }
+}
+function deleteFile(file) {
+  if (FS.existsSync(file)) FS.unlinkSync(file);
+}
+
+// src/actions/wallet/addressBook/storage.ts
+var ADDRESS_BOOK_VERSION = 1;
+function readAllAddressBooks() {
+  return readJsonFile(walletPaths().addressBooks) ?? {};
+}
+function writeAllAddressBooks(data) {
+  writeJsonFile(walletPaths().addressBooks, data);
+}
+function readAddressBook(rootAddress) {
+  const all = readAllAddressBooks();
+  const key = rootAddress.toLowerCase();
+  return all[key] ?? {
+    rootAddress: key,
+    entries: [{ offset: "0" }, { offset: "1" }, { offset: "2" }],
+    version: ADDRESS_BOOK_VERSION
+  };
+}
+function writeAddressBook(book) {
+  const all = readAllAddressBooks();
+  all[book.rootAddress.toLowerCase()] = book;
+  writeAllAddressBooks(all);
+}
+function upsertAddressBookEntry(rootAddress, entry) {
+  const book = readAddressBook(rootAddress);
+  const existing = book.entries.find((e) => e.offset === entry.offset);
+  if (existing) {
+    if (entry.label !== void 0) existing.label = entry.label;
+  } else {
+    book.entries.push(entry);
+  }
+  writeAddressBook(book);
+  return book;
+}
+function removeAddressBookEntry(rootAddress, offset) {
+  const book = readAddressBook(rootAddress);
+  book.entries = book.entries.filter((e) => e.offset !== offset);
+  writeAddressBook(book);
+  return book;
+}
+
+// src/actions/wallet/account/getActiveWallet.ts
+import { HDWallet } from "@xyo-network/sdk-js";
+import { DEFAULT_WALLET_PATH } from "@xyo-network/xl1-protocol-sdk";
+
+// src/actions/wallet/prompt.ts
+import { execFileSync } from "child_process";
+import {
+  closeSync,
+  openSync,
+  readSync,
+  writeSync
+} from "fs";
+var CTRL_C = 3;
+var ENTER = 13;
+var NEWLINE = 10;
+var BACKSPACE_DELETE = 127;
+var BACKSPACE = 8;
+function readChars(readFd, writeFd, mask) {
+  const chars = [];
+  const buf = Buffer.alloc(1);
+  for (; ; ) {
+    const bytes = readSync(readFd, buf, 0, 1, null);
+    if (bytes === 0) break;
+    const ch = buf[0];
+    if (ch === ENTER || ch === NEWLINE) break;
+    if (ch === CTRL_C) {
+      writeSync(writeFd, "\n");
+      throw new Error("Aborted");
+    }
+    if (ch === BACKSPACE_DELETE || ch === BACKSPACE) {
+      if (chars.length > 0) {
+        chars.pop();
+        writeSync(writeFd, "\b \b");
+      }
+      continue;
+    }
+    chars.push(ch);
+    writeSync(writeFd, mask ? "*" : String.fromCodePoint(ch));
+  }
+  writeSync(writeFd, "\n");
+  return Buffer.from(chars).toString("utf8");
+}
+function saveStty(readFd) {
+  try {
+    return execFileSync("stty", ["-g"], {
+      stdio: [readFd, "pipe", "ignore"],
+      encoding: "utf8"
+    }).trim();
+  } catch {
+    return void 0;
+  }
+}
+function applyStty(readFd, args) {
+  try {
+    execFileSync("stty", args, { stdio: [readFd, "ignore", "ignore"] });
+  } catch {
+  }
+}
+function promptTty(options) {
+  const readFd = openSync("/dev/tty", "r");
+  const writeFd = openSync("/dev/tty", "w");
+  const saved = saveStty(readFd);
+  try {
+    if (saved) applyStty(readFd, ["-echo", "-icanon", "min", "1", "time", "0"]);
+    writeSync(writeFd, options.prompt);
+    return readChars(readFd, writeFd, options.mask === true);
+  } finally {
+    if (saved) applyStty(readFd, [saved]);
+    try {
+      closeSync(readFd);
+    } catch {
+    }
+    try {
+      closeSync(writeFd);
+    } catch {
+    }
+  }
+}
+function promptPassword(prompt = "Password: ") {
+  const env = process.env.ARIES_WALLET_PASSWORD;
+  if (env !== void 0 && env.length > 0) return env;
+  return promptTty({ prompt, mask: true });
+}
+
+// src/actions/wallet/session/sessionCache.ts
+import { webcrypto as webcrypto3 } from "crypto";
+
+// src/actions/wallet/passwordKey.ts
+import { webcrypto } from "crypto";
+var subtle = webcrypto.subtle;
+var INITIALIZATION_VECTOR_LENGTH = 12;
+var PBKDF2_ITERATIONS = 1e5;
+var SALT_BYTES = 16;
+var PasswordKey = class _PasswordKey {
+  password;
+  salt;
+  constructor(password, salt = _PasswordKey.generateSalt()) {
+    this.password = password;
+    this.salt = salt;
+  }
+  static async decryptString(key, data) {
+    const encryptedData = new Uint8Array(Buffer.from(data, "base64"));
+    const iv = encryptedData.slice(0, INITIALIZATION_VECTOR_LENGTH);
+    const ciphertext = encryptedData.slice(INITIALIZATION_VECTOR_LENGTH);
+    const decrypted = await subtle.decrypt({ name: "AES-GCM", iv }, key, ciphertext);
+    return new TextDecoder("utf-8").decode(decrypted);
+  }
+  static async encryptString(key, data) {
+    const iv = webcrypto.getRandomValues(new Uint8Array(INITIALIZATION_VECTOR_LENGTH));
+    const ciphertext = await subtle.encrypt({ name: "AES-GCM", iv }, key, new TextEncoder().encode(data));
+    const combined = new Uint8Array(iv.length + ciphertext.byteLength);
+    combined.set(iv, 0);
+    combined.set(new Uint8Array(ciphertext), iv.length);
+    return Buffer.from(combined).toString("base64");
+  }
+  static generateSalt() {
+    const array = new Uint8Array(SALT_BYTES);
+    webcrypto.getRandomValues(array);
+    return [...array].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+  }
+  static async getHashFromKey(key) {
+    const exported = await subtle.exportKey("raw", key);
+    const digest = await subtle.digest("SHA-256", exported);
+    return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+  }
+  static async importEncryptionKey(rawKey) {
+    return await subtle.importKey("raw", rawKey, { name: "AES-GCM" }, false, ["encrypt", "decrypt"]);
+  }
+  static async importExtractableKey(rawKey) {
+    return await subtle.importKey("raw", rawKey, { name: "AES-GCM" }, true, ["encrypt", "decrypt"]);
+  }
+  static async serializeKey(key, salt = _PasswordKey.generateSalt()) {
+    const hash = await _PasswordKey.getHashFromKey(key);
+    return { hash, salt };
+  }
+  async deriveKey() {
+    const encoder = new TextEncoder();
+    const passphraseKey = await subtle.importKey(
+      "raw",
+      encoder.encode(this.password),
+      { name: "PBKDF2" },
+      false,
+      ["deriveKey"]
+    );
+    return await subtle.deriveKey(
+      {
+        name: "PBKDF2",
+        salt: encoder.encode(this.salt),
+        iterations: PBKDF2_ITERATIONS,
+        hash: "SHA-256"
+      },
+      passphraseKey,
+      { name: "AES-GCM", length: 256 },
+      true,
+      ["encrypt", "decrypt"]
+    );
+  }
+};
+async function decryptWithKey(key, data) {
+  const exported = await subtle.exportKey("raw", key);
+  const encKey = await PasswordKey.importEncryptionKey(exported);
+  return await PasswordKey.decryptString(encKey, data);
+}
+
+// src/actions/wallet/session/machineId.ts
+import { webcrypto as webcrypto2 } from "crypto";
+import FS2 from "fs";
+import OS2 from "os";
+function generateMachineSecret() {
+  const bytes = new Uint8Array(32);
+  webcrypto2.getRandomValues(bytes);
+  return [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function loadMachineSecret() {
+  ensureWalletDir();
+  const path = walletPaths().machineId;
+  if (FS2.existsSync(path)) {
+    return FS2.readFileSync(path, "utf8").trim();
+  }
+  const secret = generateMachineSecret();
+  FS2.writeFileSync(path, `${secret}
+`, { mode: 384 });
+  try {
+    FS2.chmodSync(path, 384);
+  } catch {
+  }
+  return secret;
+}
+async function deriveMachineKey() {
+  const secret = loadMachineSecret();
+  const stable = `${OS2.hostname()}:${OS2.userInfo().username}:${secret}`;
+  const passwordKey = new PasswordKey(stable, "aries-wallet-machine-kek-v1");
+  return await passwordKey.deriveKey();
+}
+
+// src/actions/wallet/session/sessionCache.ts
+var subtle2 = webcrypto3.subtle;
+var DEFAULT_SESSION_TTL_SECONDS = 15 * 60;
+function lockSession() {
+  deleteFile(walletPaths().session);
+}
+async function readSession() {
+  const data = readJsonFile(walletPaths().session);
+  if (!data) return void 0;
+  if (data.expiresAt <= Date.now()) {
+    lockSession();
+    return void 0;
+  }
+  try {
+    const machineKey = await deriveMachineKey();
+    const exportedBase64 = await decryptWithKey(machineKey, data.encryptedKey);
+    const raw = Buffer.from(exportedBase64, "base64");
+    return await PasswordKey.importExtractableKey(
+      raw.buffer.slice(raw.byteOffset, raw.byteOffset + raw.byteLength)
+    );
+  } catch {
+    lockSession();
+    return void 0;
+  }
+}
+
+// src/actions/wallet/password/passwordStorage.ts
+function readPassword() {
+  return readJsonFile(walletPaths().password);
+}
+function hasPassword() {
+  return readPassword() !== void 0;
+}
+
+// src/actions/wallet/password/validatePassword.ts
+async function validatePassword(password) {
+  const stored = readPassword();
+  if (!stored) return void 0;
+  const passwordKey = new PasswordKey(password, stored.salt);
+  const key = await passwordKey.deriveKey();
+  const hash = await PasswordKey.getHashFromKey(key);
+  if (hash !== stored.hash) return void 0;
+  return key;
+}
+
+// src/actions/wallet/password/getActiveKey.ts
+async function getActiveKey() {
+  if (!hasPassword()) {
+    throw new Error("Wallet not initialized. Run `aries wallet create` or `aries wallet import` first.");
+  }
+  const cached = await readSession();
+  if (cached) return cached;
+  const password = promptPassword("Wallet password: ");
+  const key = await validatePassword(password);
+  if (!key) throw new Error("Incorrect password.");
+  return key;
+}
+
+// src/actions/wallet/seedPhrase/phraseStorage.ts
+function readPhrases() {
+  const data = readJsonFile(walletPaths().phrases);
+  return data?.phrases ?? [];
+}
+function readActive() {
+  return readJsonFile(walletPaths().active) ?? {};
+}
+function getActivePhrase() {
+  const phrases = readPhrases();
+  if (phrases.length === 0) return void 0;
+  const active = readActive();
+  if (active.phraseId) {
+    const found = phrases.find((p) => p.id === active.phraseId);
+    if (found) return found;
+  }
+  return phrases[0];
+}
+
+// src/actions/wallet/account/getActiveWallet.ts
+async function getActiveWallet() {
+  const record = getActivePhrase();
+  if (!record) throw new Error("No active wallet. Run `aries wallet create` or `aries wallet import` first.");
+  const key = await getActiveKey();
+  const mnemonic = await decryptWithKey(key, record.encryptedPhrase);
+  const rootWallet = await HDWallet.fromPhrase(mnemonic, DEFAULT_WALLET_PATH);
+  return {
+    record,
+    mnemonic,
+    rootWallet
+  };
+}
+async function deriveAccount(rootWallet, offset) {
+  return await rootWallet.derivePath(offset);
+}
+
+// src/actions/wallet/account/deriveAndAdd.ts
+async function deriveAndAdd(options) {
+  const { rootWallet } = await getActiveWallet();
+  const account = await deriveAccount(rootWallet, options.offset);
+  upsertAddressBookEntry(rootWallet.address, { offset: options.offset, label: options.label });
+  console.log(chalk.green(`Derived account at offset ${chalk.cyan(options.offset)}: 0x${account.address}`));
+  if (options.label) console.log(chalk.gray(`  label: ${options.label}`));
+}
+
+// src/actions/wallet/account/labelAccount.ts
+import chalk2 from "chalk";
+async function labelAccount(offset, label) {
+  const { rootWallet } = await getActiveWallet();
+  upsertAddressBookEntry(rootWallet.address, { offset, label });
+  console.log(chalk2.green(`Labeled account ${chalk2.cyan(offset)} as ${chalk2.white(label)}`));
+}
+
+// src/actions/wallet/account/listAccounts.ts
+import chalk3 from "chalk";
+async function listAccounts() {
+  const { record, rootWallet } = await getActiveWallet();
+  const book = readAddressBook(rootWallet.address);
+  console.log(chalk3.cyan(`Wallet ${record.label} (${record.id})`));
+  console.log(chalk3.gray(`  root: ${rootWallet.address}`));
+  console.log();
+  if (book.entries.length === 0) {
+    console.log(chalk3.gray("  No derived accounts. Run `aries wallet account derive <offset>`."));
+    return;
+  }
+  for (const entry of book.entries) {
+    const account = await deriveAccount(rootWallet, entry.offset);
+    const offset = chalk3.cyan(entry.offset.padEnd(6));
+    const label = chalk3.white((entry.label ?? "").padEnd(20));
+    console.log(`  ${offset} ${label} 0x${account.address}`);
+  }
+}
+
+// src/actions/wallet/account/removeAccount.ts
+import chalk4 from "chalk";
+async function removeAccount(offset) {
+  const { rootWallet } = await getActiveWallet();
+  removeAddressBookEntry(rootWallet.address, offset);
+  console.log(chalk4.green(`Removed account at offset ${chalk4.cyan(offset)} from address book`));
+}
+
+// src/actions/wallet/account/showAccount.ts
+import chalk5 from "chalk";
+async function showAccount(offset) {
+  const { rootWallet } = await getActiveWallet();
+  const book = readAddressBook(rootWallet.address);
+  const entry = book.entries.find((e) => e.offset === offset);
+  const account = await deriveAccount(rootWallet, offset);
+  console.log(chalk5.cyan(`Account ${offset}`));
+  console.log(`  ${chalk5.gray("label:")}    ${entry?.label ?? "\u2014"}`);
+  console.log(`  ${chalk5.gray("address:")}  0x${account.address}`);
+  if (account.public) console.log(`  ${chalk5.gray("public:")}   ${account.public.hex}`);
+  console.log(`  ${chalk5.gray("path:")}     ${offset}`);
+}
+
+// src/commands/walletAccountDeriveCommand.ts
+var walletAccountDeriveCommand = {
+  command: "derive <offset>",
+  describe: "Derive a new account at the given HD offset",
+  builder: (yargs) => yargs.positional("offset", {
+    type: "string",
+    demandOption: true,
+    describe: "HD path offset (e.g. 0)"
+  }).option("label", {
+    alias: "l",
+    type: "string",
+    describe: "Friendly label for the account"
+  }),
+  handler: async (argv) => {
+    await deriveAndAdd({
+      offset: argv.offset,
+      label: argv.label
+    });
+  }
+};
+
+// src/commands/walletAccountLabelCommand.ts
+var walletAccountLabelCommand = {
+  command: "label <offset> <label>",
+  describe: "Label a derived account",
+  builder: (yargs) => yargs.positional("offset", {
+    type: "string",
+    demandOption: true,
+    describe: "HD path offset"
+  }).positional("label", {
+    type: "string",
+    demandOption: true,
+    describe: "Label text"
+  }),
+  handler: async (argv) => {
+    await labelAccount(argv.offset, argv.label);
+  }
+};
+
+// src/commands/walletAccountListCommand.ts
+var walletAccountListCommand = {
+  command: "list",
+  describe: "List derived accounts in the active wallet",
+  handler: async () => {
+    await listAccounts();
+  }
+};
+
+// src/commands/walletAccountRemoveCommand.ts
+var walletAccountRemoveCommand = {
+  command: "remove <offset>",
+  describe: "Remove an account from the address book",
+  builder: (yargs) => yargs.positional("offset", {
+    type: "string",
+    demandOption: true,
+    describe: "HD path offset"
+  }),
+  handler: async (argv) => {
+    await removeAccount(argv.offset);
+  }
+};
+
+// src/commands/walletAccountShowCommand.ts
+var walletAccountShowCommand = {
+  command: "show <offset>",
+  describe: "Show details for a derived account",
+  builder: (yargs) => yargs.positional("offset", {
+    type: "string",
+    demandOption: true,
+    describe: "HD path offset (e.g. 0)"
+  }),
+  handler: async (argv) => {
+    await showAccount(argv.offset);
+  }
+};
+
+// src/commands/walletAccountCommand.ts
+var walletAccountCommand = {
+  command: "account",
+  describe: "Manage derived accounts in the active wallet",
+  builder: (yargs) => yargs.command(walletAccountListCommand).command(walletAccountShowCommand).command(walletAccountDeriveCommand).command(walletAccountLabelCommand).command(walletAccountRemoveCommand).demandCommand(1).strictCommands(),
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  handler: () => {
+  }
+};
+export {
+  walletAccountCommand
+};
+//# sourceMappingURL=walletAccountCommand.mjs.map