neozip-cli 0.80.0 → 0.95.0

package/dist/src/account/profile-crypto.js

@@ -0,0 +1,85 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveProfileKey = deriveProfileKey;
+exports.encryptJson = encryptJson;
+exports.decryptJson = decryptJson;
+const crypto = __importStar(require("node:crypto"));
+const os = __importStar(require("node:os"));
+const PROFILE_KDF_INFO = "NeoZip/McpProfileSecrets/v1";
+const PROFILE_KDF_SALT = Buffer.from("NeoZipMcpProfileStoreSalt-v1", "utf8");
+function deriveProfileKey() {
+    const passphrase = process.env.NEOZIP_UNLOCK_PASSPHRASE?.trim() ||
+        `${os.hostname()}:${os.userInfo().username}:neozip-mcp-profile`;
+    const okm = crypto.hkdfSync("sha256", Buffer.from(passphrase, "utf8"), PROFILE_KDF_SALT, PROFILE_KDF_INFO, 32);
+    return Buffer.from(okm);
+}
+function encryptJson(payload) {
+    const key = deriveProfileKey();
+    const iv = crypto.randomBytes(12);
+    const plaintext = Buffer.from(JSON.stringify(payload), "utf8");
+    try {
+        const cipher = crypto.createCipheriv("aes-256-gcm", key, iv);
+        const ct = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+        const tag = cipher.getAuthTag();
+        return JSON.stringify({
+            v: 1,
+            iv: iv.toString("base64"),
+            tag: tag.toString("base64"),
+            data: ct.toString("base64"),
+        });
+    }
+    finally {
+        key.fill(0);
+        plaintext.fill(0);
+    }
+}
+function decryptJson(encrypted) {
+    const key = deriveProfileKey();
+    const parsed = JSON.parse(encrypted);
+    const iv = Buffer.from(parsed.iv, "base64");
+    const tag = Buffer.from(parsed.tag, "base64");
+    const ct = Buffer.from(parsed.data, "base64");
+    try {
+        const decipher = crypto.createDecipheriv("aes-256-gcm", key, iv);
+        decipher.setAuthTag(tag);
+        const pt = Buffer.concat([decipher.update(ct), decipher.final()]);
+        return JSON.parse(pt.toString("utf8"));
+    }
+    finally {
+        key.fill(0);
+    }
+}
+//# sourceMappingURL=profile-crypto.js.map

package/dist/src/account/profile-store.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.savePhoneVerified = exports.saveIdentityProvision = exports.saveWalletLink = exports.saveEvmWallet = exports.saveAccessToken = void 0;
+exports.getMcpProfileDir = getMcpProfileDir;
+exports.listProfiles = listProfiles;
+exports.getActiveProfileId = getActiveProfileId;
+exports.getActiveProfile = getActiveProfile;
+exports.selectProfile = selectProfile;
+exports.createProfile = createProfile;
+exports.updateProfile = updateProfile;
+exports.removeProfile = removeProfile;
+exports.readSecrets = readSecrets;
+exports.readActiveSecrets = readActiveSecrets;
+exports.logoutProfile = logoutProfile;
+exports.clearProfileCredentialsFromEnv = clearProfileCredentialsFromEnv;
+exports.applyActiveProfileToEnv = applyActiveProfileToEnv;
+const store_1 = require("../connection/store");
+Object.defineProperty(exports, "saveAccessToken", { enumerable: true, get: function () { return store_1.saveAccessToken; } });
+Object.defineProperty(exports, "saveEvmWallet", { enumerable: true, get: function () { return store_1.saveEvmWallet; } });
+Object.defineProperty(exports, "saveIdentityProvision", { enumerable: true, get: function () { return store_1.saveIdentityProvision; } });
+Object.defineProperty(exports, "savePhoneVerified", { enumerable: true, get: function () { return store_1.savePhoneVerified; } });
+Object.defineProperty(exports, "saveWalletLink", { enumerable: true, get: function () { return store_1.saveWalletLink; } });
+const migrate_1 = require("../connection/migrate");
+function getMcpProfileDir() {
+    return (0, store_1.getConnectionDir)();
+}
+function ensureMigrated() {
+    if ((0, migrate_1.hasLegacyMcpProfiles)()) {
+        (0, migrate_1.migrateFromMcpProfileStore)();
+    }
+}
+function toProfile(meta) {
+    if (!meta)
+        return null;
+    return {
+        id: meta.id,
+        label: meta.label,
+        tokenServiceUrl: meta.tokenServiceOrigin,
+        email: meta.email,
+        emailVerified: meta.emailVerified,
+        evmAddress: meta.evmAddress,
+        walletId: meta.walletId,
+        linkId: meta.linkId,
+        identityKeyId: meta.identityKeyId,
+        x25519Fingerprint: meta.x25519Fingerprint,
+        createdAt: meta.createdAt,
+        updatedAt: meta.updatedAt,
+    };
+}
+function toSecrets(secrets) {
+    if (!secrets)
+        return null;
+    return {
+        accessToken: secrets.accessToken,
+        evmPrivateKey: secrets.evmPrivateKeyHex,
+        accessTokenObtainedAt: secrets.accessTokenObtainedAt,
+        accessTokenExpiresAt: secrets.accessTokenExpiresAt,
+    };
+}
+function listProfiles() {
+    ensureMigrated();
+    return (0, store_1.listConnections)().map((c) => ({
+        id: c.id,
+        label: c.label,
+        tokenServiceUrl: c.tokenServiceOrigin,
+        email: c.email,
+        emailVerified: c.emailVerified,
+        evmAddress: c.evmAddress,
+        walletId: c.walletId,
+        linkId: c.linkId,
+        identityKeyId: c.identityKeyId,
+        x25519Fingerprint: c.x25519Fingerprint,
+        createdAt: c.createdAt,
+        updatedAt: c.updatedAt,
+    }));
+}
+function getActiveProfileId() {
+    ensureMigrated();
+    return (0, store_1.getActiveConnectionId)();
+}
+function getActiveProfile() {
+    ensureMigrated();
+    return toProfile((0, store_1.getActiveConnection)());
+}
+function selectProfile(profileId) {
+    ensureMigrated();
+    return toProfile((0, store_1.selectConnection)(profileId));
+}
+function createProfile(input) {
+    ensureMigrated();
+    return toProfile((0, store_1.createConnection)({ label: input.label, tokenServiceUrl: input.tokenServiceUrl }));
+}
+function updateProfile(profileId, patch) {
+    ensureMigrated();
+    const mapped = { ...patch };
+    if (patch.tokenServiceUrl) {
+        mapped.tokenServiceOrigin = patch.tokenServiceUrl;
+        delete mapped.tokenServiceUrl;
+    }
+    return toProfile((0, store_1.updateConnection)(profileId, mapped));
+}
+function removeProfile(_profileId, confirm) {
+    if (!confirm) {
+        throw new Error("Set confirm: true to delete the profile and its secrets.");
+    }
+    throw new Error("Profile removal via account_remove is deprecated. Use neozip connect logout.");
+}
+function readSecrets(profileId) {
+    ensureMigrated();
+    return toSecrets((0, store_1.readConnectionSecrets)(profileId));
+}
+function readActiveSecrets() {
+    ensureMigrated();
+    return toSecrets((0, store_1.readActiveConnectionSecrets)());
+}
+function logoutProfile(profileId) {
+    ensureMigrated();
+    const out = (0, store_1.logoutConnection)(profileId);
+    return { ...out, profileId: out.connectionId };
+}
+function clearProfileCredentialsFromEnv() {
+    (0, store_1.clearConnectionCredentialsFromEnv)();
+}
+function applyActiveProfileToEnv() {
+    ensureMigrated();
+    const out = (0, store_1.applyActiveConnectionToEnv)();
+    return { applied: out.applied, profileId: out.connectionId };
+}
+//# sourceMappingURL=profile-store.js.map

package/dist/src/account/require-account.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireAccountReady = requireAccountReady;
+const phase_1 = require("../connection/phase");
+const store_1 = require("../connection/store");
+const token_auth_1 = require("../connection/token-auth");
+async function requireAccountReady(context) {
+    const phase = (0, phase_1.computeConnectionPhase)();
+    const meta = (0, store_1.getActiveConnection)();
+    const secrets = (0, store_1.readActiveConnectionSecrets)();
+    if (secrets?.accessToken?.trim() && (0, token_auth_1.isAccessTokenExpired)(secrets)) {
+        return [
+            `${context} requires a valid Token Service access token.`,
+            (0, token_auth_1.formatTokenReauthGuidance)(meta?.email),
+        ].join("\n\n");
+    }
+    if (phase !== "ready") {
+        const nextCmd = (0, phase_1.nextConnectCommand)(phase, {
+            email: meta?.email,
+            phoneE164: meta?.phoneE164,
+        });
+        const parts = [
+            `${context} requires a fully initialized NeoZip account (phase: ${phase}).`,
+        ];
+        if (nextCmd)
+            parts.push(`Run: ${nextCmd}`);
+        parts.push("Reload MCP after setup so credentials load into this session.");
+        return parts.join(" ");
+    }
+    return null;
+}
+//# sourceMappingURL=require-account.js.map

package/dist/src/account/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/src/account/wallet-evm.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateEvmIdentity = generateEvmIdentity;
+exports.evmIdentityFromMnemonic = evmIdentityFromMnemonic;
+exports.evmIdentityFromPrivateKey = evmIdentityFromPrivateKey;
+exports.signEvmMessage = signEvmMessage;
+exports.rawEoaBytes = rawEoaBytes;
+const ethers_1 = require("ethers");
+function generateEvmIdentity() {
+    const wallet = ethers_1.Wallet.createRandom();
+    return {
+        address: wallet.address,
+        privateKey: wallet.privateKey,
+        mnemonic: wallet.mnemonic?.phrase ?? null,
+    };
+}
+function evmIdentityFromMnemonic(mnemonic) {
+    const phrase = mnemonic.trim().split(/\s+/).join(" ");
+    const wallet = ethers_1.Wallet.fromPhrase(phrase);
+    return {
+        address: wallet.address,
+        privateKey: wallet.privateKey,
+        mnemonic: wallet.mnemonic?.phrase ?? phrase,
+    };
+}
+function evmIdentityFromPrivateKey(privateKey) {
+    const raw = privateKey.trim();
+    const normalized = raw.startsWith("0x") ? raw : `0x${raw}`;
+    const wallet = new ethers_1.Wallet(normalized);
+    return {
+        address: wallet.address,
+        privateKey: wallet.privateKey,
+        mnemonic: null,
+    };
+}
+function signEvmMessage(privateKey, message) {
+    const wallet = new ethers_1.Wallet(privateKey);
+    return wallet.signMessage(message);
+}
+function rawEoaBytes(privateKey) {
+    const stripped = privateKey.startsWith("0x")
+        ? privateKey.slice(2)
+        : privateKey;
+    return Buffer.from(stripped, "hex");
+}
+//# sourceMappingURL=wallet-evm.js.map

package/dist/src/account/wallet-setup.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runWalletEnsureAndAttach = runWalletEnsureAndAttach;
+/**
+ * Local orchestration for linking the Data Wallet to a Token Service account.
+ *
+ * The individual HTTP calls live in `neozip-blockchain/token-service`; this
+ * module composes the challenge/complete pairs around a local EVM signer, since
+ * signing requires the wallet's private key, which never leaves the CLI host.
+ */
+const token_service_1 = require("neozip-blockchain/token-service");
+const wallet_evm_1 = require("./wallet-evm");
+/**
+ * Ensure a wallet record exists for `evmAddress` and attach it to the
+ * authenticated account as the primary wallet, signing both challenges locally.
+ */
+async function runWalletEnsureAndAttach(baseUrl, accessToken, evmPrivateKey, evmAddress) {
+    const ensureCh = await (0, token_service_1.requestWalletEnsureChallenge)(baseUrl, evmAddress);
+    const ensureSig = await (0, wallet_evm_1.signEvmMessage)(evmPrivateKey, ensureCh.message);
+    const ensured = await (0, token_service_1.completeWalletEnsure)(baseUrl, {
+        evmAddress,
+        challengeId: ensureCh.challengeId,
+        evmSignature: ensureSig,
+    });
+    const attachCh = await (0, token_service_1.requestWalletAttachChallenge)(baseUrl, accessToken, ensured.walletId);
+    const attachSig = await (0, wallet_evm_1.signEvmMessage)(evmPrivateKey, attachCh.message);
+    const { linkId } = await (0, token_service_1.completeWalletAttach)(baseUrl, accessToken, ensured.walletId, {
+        challengeId: attachCh.challengeId,
+        evmSignature: attachSig,
+    });
+    return { walletId: ensured.walletId, evmAddress: ensured.evmAddress, linkId };
+}
+//# sourceMappingURL=wallet-setup.js.map

package/dist/src/archive/crypto-self.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchCryptoSelf = fetchCryptoSelf;
+const recipient_lookup_1 = require("./recipient-lookup");
+const token_auth_1 = require("../connection/token-auth");
+const store_1 = require("../connection/store");
+function pickString(obj, key) {
+    const v = obj[key];
+    return typeof v === "string" && v.length > 0 ? v : null;
+}
+function parseCryptoSelfBody(parsed, status) {
+    if (parsed.success !== true) {
+        const err = typeof parsed.error === "string"
+            ? parsed.error
+            : "Unexpected /crypto/self response";
+        const hint = typeof parsed.hint === "string" ? parsed.hint : undefined;
+        return { ok: false, status, error: err, hint };
+    }
+    const cryptoRaw = parsed.crypto;
+    if (!cryptoRaw || typeof cryptoRaw !== "object") {
+        return { ok: false, status, error: "crypto/self missing crypto object" };
+    }
+    const c = cryptoRaw;
+    const walletId = typeof c.walletId === "number" ? c.walletId : Number(c.walletId);
+    const identityKeyIdRaw = c.identityKeyId;
+    const identityKeyId = typeof identityKeyIdRaw === "number"
+        ? identityKeyIdRaw
+        : identityKeyIdRaw == null
+            ? null
+            : Number.isFinite(Number(identityKeyIdRaw))
+                ? Number(identityKeyIdRaw)
+                : null;
+    const evmAddress = pickString(c, "evmAddress");
+    const x25519PublicKey = pickString(c, "x25519PublicKey");
+    if (!Number.isFinite(walletId) || !evmAddress || !x25519PublicKey) {
+        return { ok: false, status, error: "crypto/self crypto object incomplete" };
+    }
+    const recipientSuites = Array.isArray(c.recipientSuites)
+        ? c.recipientSuites.filter((s) => typeof s === "string")
+        : [];
+    return {
+        ok: true,
+        data: {
+            userId: typeof parsed.userId === "number"
+                ? parsed.userId
+                : Number(parsed.userId),
+            email: typeof parsed.email === "string" ? parsed.email : "",
+            phoneE164: typeof parsed.phoneE164 === "string" ? parsed.phoneE164 : null,
+            phoneVerified: parsed.phoneVerified === true,
+            walletId,
+            identityKeyId,
+            evmAddress,
+            x25519PublicKey,
+            cryptoProvisionedAt: typeof c.cryptoProvisionedAt === "string"
+                ? c.cryptoProvisionedAt
+                : null,
+            mlkem768PublicKeyB64: typeof c.mlkem768PublicKeyB64 === "string"
+                ? c.mlkem768PublicKeyB64
+                : null,
+            recipientSuites,
+        },
+    };
+}
+async function fetchCryptoSelf(config, options) {
+    const accessToken = config.tokenServiceAccessToken?.trim();
+    if (!accessToken) {
+        return {
+            ok: false,
+            status: 0,
+            error: "NEOZIP_TOKEN_SERVICE_ACCESS_TOKEN not configured. Complete token_service_verify and set the token in MCP env.",
+        };
+    }
+    const baseUrl = (0, recipient_lookup_1.resolveTokenServiceBaseUrl)(config, options?.serverUrl);
+    const response = await fetch(`${baseUrl}/crypto/self`, {
+        headers: { Authorization: `Bearer ${accessToken}` },
+    });
+    const ct = response.headers.get("content-type") || "";
+    if (!ct.includes("json")) {
+        return {
+            ok: false,
+            status: response.status,
+            error: `Token Service returned non-JSON (HTTP ${response.status})`,
+        };
+    }
+    let parsed;
+    try {
+        parsed = (await response.json());
+    }
+    catch {
+        return {
+            ok: false,
+            status: response.status,
+            error: `Invalid JSON from Token Service (HTTP ${response.status})`,
+        };
+    }
+    if (response.status === 404) {
+        const err = typeof parsed.error === "string"
+            ? parsed.error
+            : "Identity key not found";
+        const hint = typeof parsed.hint === "string" ? parsed.hint : undefined;
+        return { ok: false, status: 404, error: err, hint };
+    }
+    if (!response.ok) {
+        const err = typeof parsed.error === "string"
+            ? parsed.error
+            : `HTTP ${response.status}`;
+        const authHint = (0, token_auth_1.tokenServiceAuthErrorMessage)(response.status, (0, store_1.getActiveConnection)()?.email);
+        return {
+            ok: false,
+            status: response.status,
+            error: authHint ?? err,
+            hint: authHint ? 'Re-run neozip connect verify.' : undefined,
+        };
+    }
+    return parseCryptoSelfBody(parsed, response.status);
+}
+//# sourceMappingURL=crypto-self.js.map

package/dist/src/archive/identity-key.js

@@ -0,0 +1,217 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdentityKeyVersionError = exports.IdentityKeyTamperError = void 0;
+exports.unwrapX25519PrivateKey = unwrapX25519PrivateKey;
+exports.hasConfiguredIdentityKey = hasConfiguredIdentityKey;
+exports.resolveIdentityPrivateKeyHex = resolveIdentityPrivateKeyHex;
+const crypto = __importStar(require("node:crypto"));
+const ethers_1 = require("ethers");
+const wallet_identity_1 = require("../constants/wallet-identity");
+const crypto_self_1 = require("./crypto-self");
+const recipient_lookup_1 = require("./recipient-lookup");
+class IdentityKeyTamperError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "IdentityKeyTamperError";
+    }
+}
+exports.IdentityKeyTamperError = IdentityKeyTamperError;
+class IdentityKeyVersionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "IdentityKeyVersionError";
+    }
+}
+exports.IdentityKeyVersionError = IdentityKeyVersionError;
+function buildCanonicalAad(params) {
+    const lowerAddr = params.evmAddress.toLowerCase();
+    const addrBytes = Buffer.from(lowerAddr, "ascii");
+    if (params.x25519SpkiDer.length !== 44) {
+        throw new Error(`Unexpected SPKI DER length ${params.x25519SpkiDer.length}, expected 44 bytes`);
+    }
+    return Buffer.concat([
+        addrBytes,
+        Buffer.from([wallet_identity_1.WRAP_FORMAT_VERSION]),
+        params.x25519SpkiDer,
+    ]);
+}
+function deriveKek(rawEoaPrivBytes, saltB64) {
+    if (rawEoaPrivBytes.length !== 32) {
+        throw new Error("EOA private key must be 32 bytes");
+    }
+    const salt = Buffer.from(saltB64, "base64");
+    if (salt.length !== wallet_identity_1.WRAP_KDF_SALT_LEN) {
+        throw new Error(`Wrap KDF salt must be ${wallet_identity_1.WRAP_KDF_SALT_LEN} bytes`);
+    }
+    const okm = crypto.hkdfSync("sha256", rawEoaPrivBytes, salt, wallet_identity_1.WRAP_KDF_INFO, 32);
+    return Buffer.from(okm);
+}
+function pkcs8FromRaw(rawPriv) {
+    const prefix = Buffer.from("302e020100300506032b656e04200420", "hex");
+    return Buffer.concat([prefix, rawPriv]);
+}
+function unwrapX25519PrivateKey(params) {
+    const { bundle } = params;
+    if (bundle.wrapFormatVersion !== wallet_identity_1.WRAP_FORMAT_VERSION) {
+        throw new IdentityKeyVersionError(`Unsupported wrap format version ${bundle.wrapFormatVersion}`);
+    }
+    if (bundle.wrapAead !== wallet_identity_1.WRAP_AEAD || bundle.wrapKdfInfo !== wallet_identity_1.WRAP_KDF_INFO) {
+        throw new IdentityKeyVersionError("Unsupported wrap format");
+    }
+    const expectedSpki = Buffer.from(params.expectedSpkiDerB64, "base64");
+    if (expectedSpki.length !== 44 ||
+        !expectedSpki.subarray(0, wallet_identity_1.X25519_SPKI_PREFIX.length).equals(wallet_identity_1.X25519_SPKI_PREFIX)) {
+        throw new IdentityKeyTamperError("Invalid server X25519 SPKI");
+    }
+    const recomputedAad = buildCanonicalAad({
+        evmAddress: params.expectedEvmAddress,
+        x25519SpkiDer: expectedSpki,
+    });
+    const advertisedAad = Buffer.from(bundle.wrapAadB64, "base64");
+    if (advertisedAad.length !== recomputedAad.length ||
+        !crypto.timingSafeEqual(advertisedAad, recomputedAad)) {
+        throw new IdentityKeyTamperError("Wrap AAD does not match local recomputation");
+    }
+    const kek = deriveKek(params.rawEoaPrivBytes, bundle.wrapKdfSaltB64);
+    const iv = Buffer.from(bundle.wrapIvB64, "base64");
+    if (iv.length !== wallet_identity_1.WRAP_IV_LEN) {
+        kek.fill(0);
+        throw new IdentityKeyVersionError(`Invalid wrap IV length ${iv.length}`);
+    }
+    const wrapped = Buffer.from(bundle.wrappedPrivateKeyB64, "base64");
+    const ct = wrapped.subarray(0, wrapped.length - 16);
+    const tag = wrapped.subarray(wrapped.length - 16);
+    try {
+        const decipher = crypto.createDecipheriv("aes-256-gcm", kek, iv);
+        decipher.setAAD(recomputedAad);
+        decipher.setAuthTag(tag);
+        const pt = Buffer.concat([decipher.update(ct), decipher.final()]);
+        if (pt.length !== 32) {
+            pt.fill(0);
+            throw new IdentityKeyTamperError("Unwrapped key length is not 32 bytes");
+        }
+        return pt;
+    }
+    finally {
+        kek.fill(0);
+    }
+}
+async function fetchJson(url, init) {
+    const response = await fetch(url, init);
+    const ct = response.headers.get("content-type") || "";
+    if (!ct.includes("json")) {
+        return { ok: response.ok, status: response.status, data: null };
+    }
+    try {
+        return {
+            ok: response.ok,
+            status: response.status,
+            data: (await response.json()),
+        };
+    }
+    catch {
+        return { ok: response.ok, status: response.status, data: null };
+    }
+}
+async function loadIdentityKeyFromWallet(config) {
+    const accessToken = config.tokenServiceAccessToken?.trim();
+    const walletKey = config.walletKey?.trim();
+    if (!accessToken || !walletKey) {
+        throw new Error("Wallet identity key requires NEOZIP_TOKEN_SERVICE_ACCESS_TOKEN and NEOZIP_WALLET_PASSKEY in MCP env.");
+    }
+    const self = await (0, crypto_self_1.fetchCryptoSelf)(config);
+    if (!self.ok) {
+        throw new Error(self.hint
+            ? `${self.error} (${self.hint})`
+            : self.error);
+    }
+    const walletId = self.data.walletId;
+    const expectedSpkiB64 = self.data.x25519PublicKey;
+    const baseUrl = (0, recipient_lookup_1.resolveTokenServiceBaseUrl)(config);
+    const auth = { Authorization: `Bearer ${accessToken}` };
+    const keyRes = await fetchJson(`${baseUrl}/identity/wallets/${walletId}/identity-key`, {
+        headers: auth,
+    });
+    if (!keyRes.ok || !keyRes.data?.success || !keyRes.data.identityKey) {
+        throw new Error(keyRes.data?.error ||
+            `Failed to fetch identity key (HTTP ${keyRes.status})`);
+    }
+    const bundle = keyRes.data.identityKey;
+    const wallet = new ethers_1.Wallet(walletKey);
+    const rawEoa = Buffer.from(wallet.privateKey.startsWith("0x")
+        ? wallet.privateKey.slice(2)
+        : wallet.privateKey, "hex");
+    const expectedAddr = bundle.evmAddress || wallet.address;
+    let x25519Private = null;
+    try {
+        x25519Private = unwrapX25519PrivateKey({
+            rawEoaPrivBytes: rawEoa,
+            bundle,
+            expectedEvmAddress: expectedAddr,
+            expectedSpkiDerB64: expectedSpkiB64,
+        });
+        const hex = x25519Private.toString("hex");
+        return hex;
+    }
+    finally {
+        rawEoa.fill(0);
+        if (x25519Private)
+            x25519Private.fill(0);
+    }
+}
+function hasConfiguredIdentityKey(config) {
+    return Boolean(config.identityPrivateKeyHex?.trim() ||
+        (config.tokenServiceAccessToken?.trim() && config.walletKey?.trim()));
+}
+/**
+ * Resolve X25519 private key hex for recipient-encrypted archives.
+ * Never pass through MCP tool arguments — env/config only.
+ */
+async function resolveIdentityPrivateKeyHex(config) {
+    const envHex = config.identityPrivateKeyHex?.trim();
+    if (envHex) {
+        const clean = envHex.startsWith("0x") ? envHex.slice(2) : envHex;
+        if (!/^[0-9a-fA-F]{64}$/.test(clean)) {
+            throw new Error("NEOZIP_IDENTITY_PRIVATE_KEY_HEX must be 64 hex characters (32-byte X25519 key)");
+        }
+        return clean.toLowerCase();
+    }
+    if (config.tokenServiceAccessToken && config.walletKey) {
+        return loadIdentityKeyFromWallet(config);
+    }
+    return null;
+}
+//# sourceMappingURL=identity-key.js.map