@dominusnode/pi-extension 1.2.0 → 1.5.2

package/dist/toolkit.js

@@ -65,6 +65,7 @@ exports.checkDnsRebinding = checkDnsRebinding;
 exports.stripDangerousKeys = stripDangerousKeys;
 exports.formatBytes = formatBytes;
 exports.formatCents = formatCents;
+const crypto = __importStar(require("node:crypto"));
 const http = __importStar(require("node:http"));
 const tls = __importStar(require("node:tls"));
 const dns = __importStar(require("dns/promises"));
@@ -97,7 +98,7 @@ exports.BLOCKED_HOSTNAMES = new Set([
 // ---------------------------------------------------------------------------
 /** Remove any dn_live_* or dn_test_* tokens from error messages. */
 function scrubCredentials(msg) {
-    return msg.replace(/dn_(live|test)_[A-Za-z0-9_-]+/g, "dn_$1_***REDACTED***");
+    return msg.replace(/dn_(live|test|proxy)_[A-Za-z0-9_-]+/g, "dn_$1_***REDACTED***");
 }
 function safeError(err) {
     const raw = err instanceof Error ? err.message : String(err);
@@ -109,7 +110,8 @@ function safeError(err) {
 function truncate(text, max = MAX_RESPONSE_CHARS) {
     if (text.length <= max)
         return text;
-    return text.slice(0, max) + `\n\n... [truncated, ${text.length - max} chars omitted]`;
+    return (text.slice(0, max) +
+        `\n\n... [truncated, ${text.length - max} chars omitted]`);
 }
 // ---------------------------------------------------------------------------
 // SSRF Protection
@@ -270,7 +272,9 @@ function validateTargetUrl(url) {
     if (hostname.endsWith(".localhost")) {
         throw new Error("Requests to localhost/loopback addresses are blocked");
     }
-    if (hostname.endsWith(".local") || hostname.endsWith(".internal") || hostname.endsWith(".arpa")) {
+    if (hostname.endsWith(".local") ||
+        hostname.endsWith(".internal") ||
+        hostname.endsWith(".arpa")) {
         throw new Error("Requests to internal network hostnames are blocked");
     }
     return parsed;
@@ -306,11 +310,15 @@ async function checkDnsRebinding(hostname) {
     try {
         resolvedIps.push(...(await dns.resolve4(stripped)));
     }
-    catch { /* NODATA/NXDOMAIN for A is fine */ }
+    catch {
+        /* NODATA/NXDOMAIN for A is fine */
+    }
     try {
         resolvedIps.push(...(await dns.resolve6(stripped)));
     }
-    catch { /* NODATA/NXDOMAIN for AAAA is fine */ }
+    catch {
+        /* NODATA/NXDOMAIN for AAAA is fine */
+    }
     for (const ip of resolvedIps) {
         if (isPrivateIp(ip)) {
             throw new Error(`DNS rebinding detected: hostname resolves to private IP ${ip}`);
@@ -388,7 +396,9 @@ class DominusNodeToolkit {
     constructor(options = {}) {
         this.apiKey = options.apiKey || process.env["DOMINUSNODE_API_KEY"] || "";
         // H-6: Validate baseUrl
-        const rawBase = (options.baseUrl || process.env["DOMINUSNODE_BASE_URL"] || "https://api.dominusnode.com").replace(/\/+$/, "");
+        const rawBase = (options.baseUrl ||
+            process.env["DOMINUSNODE_BASE_URL"] ||
+            "https://api.dominusnode.com").replace(/\/+$/, "");
         try {
             const parsedBase = new URL(rawBase);
             if (parsedBase.protocol !== "https:" && parsedBase.protocol !== "http:")
@@ -396,7 +406,9 @@ class DominusNodeToolkit {
             if (parsedBase.username || parsedBase.password)
                 throw new Error("embedded credentials not allowed in base URL");
             // H-1: Warn on HTTP base URL in production
-            if (parsedBase.protocol === "http:" && parsedBase.hostname !== "localhost" && parsedBase.hostname !== "127.0.0.1") {
+            if (parsedBase.protocol === "http:" &&
+                parsedBase.hostname !== "localhost" &&
+                parsedBase.hostname !== "127.0.0.1") {
                 console.warn("[DominusNode] WARNING: baseUrl uses HTTP — API key will be sent unencrypted");
             }
         }
@@ -405,21 +417,81 @@ class DominusNodeToolkit {
         }
         this.baseUrl = rawBase;
         // H-2: Validate proxyHost against private/internal IPs
-        const rawProxyHost = options.proxyHost || process.env["DOMINUSNODE_PROXY_HOST"] || "proxy.dominusnode.com";
-        if (exports.BLOCKED_HOSTNAMES.has(rawProxyHost.toLowerCase()) || isPrivateIp(rawProxyHost)) {
+        const rawProxyHost = options.proxyHost ||
+            process.env["DOMINUSNODE_PROXY_HOST"] ||
+            "proxy.dominusnode.com";
+        if (exports.BLOCKED_HOSTNAMES.has(rawProxyHost.toLowerCase()) ||
+            isPrivateIp(rawProxyHost)) {
             throw new Error("DOMINUSNODE_PROXY_HOST must not be a private or loopback address");
         }
-        if (rawProxyHost.endsWith(".localhost") || rawProxyHost.endsWith(".local") ||
-            rawProxyHost.endsWith(".internal") || rawProxyHost.endsWith(".arpa")) {
+        if (rawProxyHost.endsWith(".localhost") ||
+            rawProxyHost.endsWith(".local") ||
+            rawProxyHost.endsWith(".internal") ||
+            rawProxyHost.endsWith(".arpa")) {
             throw new Error("DOMINUSNODE_PROXY_HOST must not use internal network TLDs");
         }
         this.proxyHost = rawProxyHost;
         const portVal = Number(options.proxyPort ?? process.env["DOMINUSNODE_PROXY_PORT"] ?? 8080);
-        this.proxyPort = isNaN(portVal) || portVal < 1 || portVal > 65535 ? 8080 : portVal;
+        this.proxyPort =
+            isNaN(portVal) || portVal < 1 || portVal > 65535 ? 8080 : portVal;
         // H-2: Validate timeout option; store but use REQUEST_TIMEOUT_MS constant for requests
         const tVal = Number(options.timeout ?? 30000);
-        this.timeout = Number.isFinite(tVal) && tVal >= 1000 && tVal <= 120000 ? tVal : 30000;
-        this.agentSecret = options.agentSecret || process.env["DOMINUSNODE_AGENT_SECRET"];
+        this.timeout =
+            Number.isFinite(tVal) && tVal >= 1000 && tVal <= 120000 ? tVal : 30000;
+        this.agentSecret =
+            options.agentSecret || process.env["DOMINUSNODE_AGENT_SECRET"];
+    }
+    // -----------------------------------------------------------------------
+    // SHA-256 Proof-of-Work solver
+    // -----------------------------------------------------------------------
+    static _countLeadingZeroBits(buf) {
+        let count = 0;
+        for (const byte of buf) {
+            if (byte === 0) {
+                count += 8;
+                continue;
+            }
+            let mask = 0x80;
+            while (mask && !(byte & mask)) {
+                count++;
+                mask >>= 1;
+            }
+            break;
+        }
+        return count;
+    }
+    async _solvePoW() {
+        try {
+            const resp = await fetch(`${this.baseUrl}/api/auth/pow/challenge`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                redirect: "error",
+            });
+            if (!resp.ok)
+                return null;
+            const text = await resp.text();
+            if (text.length > 10_485_760)
+                return null;
+            const challenge = JSON.parse(text);
+            const prefix = challenge.prefix ?? "";
+            const difficulty = challenge.difficulty ?? 20;
+            const challengeId = challenge.challengeId ?? "";
+            if (!prefix || !challengeId)
+                return null;
+            for (let nonce = 0; nonce < 100_000_000; nonce++) {
+                const hash = crypto
+                    .createHash("sha256")
+                    .update(prefix + nonce.toString())
+                    .digest();
+                if (DominusNodeToolkit._countLeadingZeroBits(hash) >= difficulty) {
+                    return { challengeId, nonce: nonce.toString() };
+                }
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
     }
     // -----------------------------------------------------------------------
     // Authentication
@@ -427,7 +499,8 @@ class DominusNodeToolkit {
     async _authenticate() {
         if (!this.apiKey)
             throw new Error("Dominus Node API key is required. Set DOMINUSNODE_API_KEY env var.");
-        if (!this.apiKey.startsWith("dn_live_") && !this.apiKey.startsWith("dn_test_")) {
+        if (!this.apiKey.startsWith("dn_live_") &&
+            !this.apiKey.startsWith("dn_test_")) {
             throw new Error('DOMINUSNODE_API_KEY must start with "dn_live_" or "dn_test_".');
         }
         const authHeaders = {
@@ -461,7 +534,9 @@ class DominusNodeToolkit {
                         parts.push(value);
                     }
                 }
-                catch { /* ignore */ }
+                catch {
+                    /* ignore */
+                }
                 reader.cancel().catch(() => { });
                 errorText = Buffer.concat(parts).toString("utf-8").slice(0, 500);
             }
@@ -473,7 +548,9 @@ class DominusNodeToolkit {
             throw new Error("Auth response too large");
         const data = JSON.parse(rawText);
         stripDangerousKeys(data);
-        if (!data.token || typeof data.token !== "string" || data.token.length > 4096) {
+        if (!data.token ||
+            typeof data.token !== "string" ||
+            data.token.length > 4096) {
             throw new Error("Invalid token in auth response");
         }
         this.token = data.token;
@@ -489,8 +566,13 @@ class DominusNodeToolkit {
             return;
         }
         this._authPromise = this._authenticate()
-            .then(() => { this._authPromise = null; })
-            .catch((e) => { this._authPromise = null; throw e; });
+            .then(() => {
+            this._authPromise = null;
+        })
+            .catch((e) => {
+            this._authPromise = null;
+            throw e;
+        });
         await this._authPromise;
     }
     async _apiRequest(method, path, body) {
@@ -505,9 +587,16 @@ class DominusNodeToolkit {
             headers["X-DominusNode-Agent"] = "mcp";
             headers["X-DominusNode-Agent-Secret"] = this.agentSecret;
         }
-        const init = { method, headers, signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS), redirect: "error" };
+        const init = {
+            method,
+            headers,
+            signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+            redirect: "error",
+        };
         // M-6: Drop body on safe HTTP methods
-        if (body && !["GET", "HEAD"].includes(method) && ["POST", "PUT", "PATCH", "DELETE"].includes(method)) {
+        if (body &&
+            !["GET", "HEAD"].includes(method) &&
+            ["POST", "PUT", "PATCH", "DELETE"].includes(method)) {
             headers["Content-Type"] = "application/json";
             init.body = JSON.stringify(body);
         }
@@ -617,11 +706,18 @@ class DominusNodeToolkit {
                     reject(new Error("Proxy request timed out"));
                 }, REQUEST_TIMEOUT_MS);
                 if (parsed.protocol === "https:") {
-                    const connectHost = parsed.hostname.includes(":") ? `[${parsed.hostname}]` : parsed.hostname;
+                    const connectHost = parsed.hostname.includes(":")
+                        ? `[${parsed.hostname}]`
+                        : parsed.hostname;
                     const connectReq = http.request({
-                        hostname: this.proxyHost, port: this.proxyPort, method: "CONNECT",
+                        hostname: this.proxyHost,
+                        port: this.proxyPort,
+                        method: "CONNECT",
                         path: `${connectHost}:${parsed.port || 443}`,
-                        headers: { "Proxy-Authorization": proxyAuth, Host: `${connectHost}:${parsed.port || 443}` },
+                        headers: {
+                            "Proxy-Authorization": proxyAuth,
+                            Host: `${connectHost}:${parsed.port || 443}`,
+                        },
                     });
                     cleanupFn = () => connectReq.destroy();
                     connectReq.on("connect", (_res, sock) => {
@@ -631,7 +727,12 @@ class DominusNodeToolkit {
                             reject(new Error(`CONNECT failed: ${_res.statusCode}`));
                             return;
                         }
-                        const tlsSock = tls.connect({ host: parsed.hostname, socket: sock, servername: parsed.hostname, minVersion: "TLSv1.2" }, () => {
+                        const tlsSock = tls.connect({
+                            host: parsed.hostname,
+                            socket: sock,
+                            servername: parsed.hostname,
+                            minVersion: "TLSv1.2",
+                        }, () => {
                             const reqLine = `${methodUpper} ${parsed.pathname + parsed.search} HTTP/1.1\r\nHost: ${parsed.host}\r\nUser-Agent: dominusnode-pi/1.0.0\r\nConnection: close\r\n\r\n`;
                             tlsSock.write(reqLine);
                             const chunks = [];
@@ -657,27 +758,47 @@ class DominusNodeToolkit {
                                     return;
                                 }
                                 const hdr = raw.substring(0, hEnd);
-                                const body = raw.substring(hEnd + 4).substring(0, MAX_PROXY_RESPONSE_BYTES);
-                                const sm = hdr.split("\r\n")[0].match(/^HTTP\/\d\.\d\s+(\d+)/);
+                                const body = raw
+                                    .substring(hEnd + 4)
+                                    .substring(0, MAX_PROXY_RESPONSE_BYTES);
+                                const sm = hdr
+                                    .split("\r\n")[0]
+                                    .match(/^HTTP\/\d\.\d\s+(\d+)/);
                                 resolve({ status: sm ? parseInt(sm[1], 10) : 0, body });
                             };
                             tlsSock.on("end", fin);
                             tlsSock.on("close", fin);
-                            tlsSock.on("error", (e) => { clearTimeout(timer); reject(e); });
+                            tlsSock.on("error", (e) => {
+                                clearTimeout(timer);
+                                reject(e);
+                            });
                         });
                         // M-1: Update cleanupFn to destroy tlsSock — covers the TLS handshake window
                         cleanupFn = () => tlsSock.destroy();
-                        tlsSock.on("error", (e) => { clearTimeout(timer); reject(e); });
+                        tlsSock.on("error", (e) => {
+                            clearTimeout(timer);
+                            reject(e);
+                        });
+                    });
+                    connectReq.on("error", (e) => {
+                        clearTimeout(timer);
+                        reject(e);
                     });
-                    connectReq.on("error", (e) => { clearTimeout(timer); reject(e); });
                     connectReq.end();
                 }
                 else {
                     const reqPath = parsed.pathname + parsed.search;
                     const proxyReq = http.request({
-                        hostname: this.proxyHost, port: this.proxyPort, method: methodUpper,
+                        hostname: this.proxyHost,
+                        port: this.proxyPort,
+                        method: methodUpper,
                         path: `http://${parsed.host}${reqPath}`,
-                        headers: { "Proxy-Authorization": proxyAuth, Host: parsed.host, "User-Agent": "dominusnode-pi/1.0.0", Connection: "close" },
+                        headers: {
+                            "Proxy-Authorization": proxyAuth,
+                            Host: parsed.host,
+                            "User-Agent": "dominusnode-pi/1.0.0",
+                            Connection: "close",
+                        },
                     });
                     cleanupFn = () => proxyReq.destroy(); // H-3: destroy on timeout
                     const chunks = [];
@@ -691,10 +812,22 @@ class DominusNodeToolkit {
                             } // H-4: destroy on oversize
                             chunks.push(c);
                         });
-                        r.on("end", () => { clearTimeout(timer); const body = Buffer.concat(chunks).toString("utf-8").substring(0, MAX_PROXY_RESPONSE_BYTES); resolve({ status: r.statusCode ?? 0, body }); });
-                        r.on("error", (e) => { clearTimeout(timer); reject(e); });
+                        r.on("end", () => {
+                            clearTimeout(timer);
+                            const body = Buffer.concat(chunks)
+                                .toString("utf-8")
+                                .substring(0, MAX_PROXY_RESPONSE_BYTES);
+                            resolve({ status: r.statusCode ?? 0, body });
+                        });
+                        r.on("error", (e) => {
+                            clearTimeout(timer);
+                            reject(e);
+                        });
+                    });
+                    proxyReq.on("error", (e) => {
+                        clearTimeout(timer);
+                        reject(e);
                     });
-                    proxyReq.on("error", (e) => { clearTimeout(timer); reject(e); });
                     proxyReq.end();
                 }
             });
@@ -888,7 +1021,10 @@ class DominusNodeToolkit {
             const max = Math.max(1, Math.min(100, Math.floor(Number(maxMembers))));
             if (isNaN(max))
                 return err("maxMembers must be a number between 1 and 100");
-            const data = await this._req("POST", "/api/teams", { name: name.trim(), maxMembers: max });
+            const data = await this._req("POST", "/api/teams", {
+                name: name.trim(),
+                maxMembers: max,
+            });
             return ok(JSON.stringify(data, null, 2));
         }
         catch (e) {
@@ -950,7 +1086,8 @@ class DominusNodeToolkit {
             if (labelErr)
                 return err(labelErr);
             const data = await this._req("POST", `/api/teams/${encodeURIComponent(id)}/keys`, { label: label.trim() });
-            return ok(JSON.stringify(data, null, 2) + "\n\nIMPORTANT: Store this API key securely — it will not be shown again.");
+            return ok(JSON.stringify(data, null, 2) +
+                "\n\nIMPORTANT: Store this API key securely — it will not be shown again.");
         }
         catch (e) {
             return err(e);
@@ -1027,7 +1164,9 @@ class DominusNodeToolkit {
             const amount = Math.floor(Number(amountCents));
             if (isNaN(amount) || amount < 500 || amount > 1000000)
                 return err("amountCents must be between 500 ($5.00) and 1,000,000 ($10,000.00)");
-            const data = await this._req("POST", "/api/wallet/topup/paypal", { amountCents: amount });
+            const data = await this._req("POST", "/api/wallet/topup/paypal", {
+                amountCents: amount,
+            });
             return ok(JSON.stringify(data, null, 2));
         }
         catch (e) {
@@ -1042,7 +1181,9 @@ class DominusNodeToolkit {
             const amount = Math.floor(Number(amountCents));
             if (isNaN(amount) || amount < 500 || amount > 1000000)
                 return err("amountCents must be between 500 ($5.00) and 1,000,000 ($10,000.00)");
-            const data = await this._req("POST", "/api/wallet/topup/stripe", { amountCents: amount });
+            const data = await this._req("POST", "/api/wallet/topup/stripe", {
+                amountCents: amount,
+            });
             return ok(JSON.stringify(data, null, 2));
         }
         catch (e) {
@@ -1059,11 +1200,26 @@ class DominusNodeToolkit {
             if (!Number.isInteger(rawAmount) || rawAmount < 5 || rawAmount > 10000)
                 return err("amountUsd must be a whole number between 5 and 10,000");
             const amount = rawAmount;
-            const VALID_CURRENCIES = ["BTC", "ETH", "LTC", "XMR", "ZEC", "USDC", "SOL", "USDT", "DAI", "BNB", "LINK"];
+            const VALID_CURRENCIES = [
+                "BTC",
+                "ETH",
+                "LTC",
+                "XMR",
+                "ZEC",
+                "USDC",
+                "SOL",
+                "USDT",
+                "DAI",
+                "BNB",
+                "LINK",
+            ];
             const cur = (currency || "").toUpperCase().trim();
             if (!VALID_CURRENCIES.includes(cur))
                 return err(`currency must be one of: ${VALID_CURRENCIES.join(", ")}`);
-            const data = await this._req("POST", "/api/wallet/topup/crypto", { amountUsd: amount, currency: cur });
+            const data = await this._req("POST", "/api/wallet/topup/crypto", {
+                amountUsd: amount,
+                currency: cur,
+            });
             return ok(JSON.stringify(data, null, 2));
         }
         catch (e) {
@@ -1132,7 +1288,12 @@ class DominusNodeToolkit {
             headers["X-DominusNode-Agent"] = "mcp";
             headers["X-DominusNode-Agent-Secret"] = this.agentSecret;
         }
-        const init = { method, headers, signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS), redirect: "error" };
+        const init = {
+            method,
+            headers,
+            signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+            redirect: "error",
+        };
         if (body && ["POST", "PUT", "PATCH", "DELETE"].includes(method)) {
             headers["Content-Type"] = "application/json";
             init.body = JSON.stringify(body);
@@ -1309,7 +1470,15 @@ class DominusNodeToolkit {
         try {
             const safeEmail = DominusNodeToolkit.validateEmail(email);
             const safePassword = DominusNodeToolkit.validatePassword(password);
-            const data = await this._rawRequest("POST", "/api/auth/register", { email: safeEmail, password: safePassword });
+            // Solve PoW for CAPTCHA-free registration
+            const pow = await this._solvePoW();
+            const regBody = {
+                email: safeEmail,
+                password: safePassword,
+            };
+            if (pow)
+                regBody.pow = pow;
+            const data = await this._rawRequest("POST", "/api/auth/register", regBody);
             return ok(JSON.stringify(data, null, 2));
         }
         catch (e) {
@@ -1323,7 +1492,10 @@ class DominusNodeToolkit {
         try {
             const safeEmail = DominusNodeToolkit.validateEmail(email);
             const safePassword = DominusNodeToolkit.validatePassword(password);
-            const data = await this._rawRequest("POST", "/api/auth/login", { email: safeEmail, password: safePassword });
+            const data = await this._rawRequest("POST", "/api/auth/login", {
+                email: safeEmail,
+                password: safePassword,
+            });
             return ok(JSON.stringify(data, null, 2));
         }
         catch (e) {
@@ -1353,7 +1525,9 @@ class DominusNodeToolkit {
             if (/[\x00-\x1f\x7f]/.test(token)) {
                 return err("Token contains invalid control characters.");
             }
-            const data = await this._rawRequest("POST", "/api/auth/verify-email", { token: token.trim() });
+            const data = await this._rawRequest("POST", "/api/auth/verify-email", {
+                token: token.trim(),
+            });
             return ok(JSON.stringify(data, null, 2));
         }
         catch (e) {
@@ -1379,7 +1553,10 @@ class DominusNodeToolkit {
         try {
             DominusNodeToolkit.validatePassword(currentPassword);
             DominusNodeToolkit.validatePassword(newPassword);
-            const data = await this._req("POST", "/api/auth/change-password", { currentPassword, newPassword });
+            const data = await this._req("POST", "/api/auth/change-password", {
+                currentPassword,
+                newPassword,
+            });
             return ok(JSON.stringify(data, null, 2));
         }
         catch (e) {
@@ -1406,8 +1583,11 @@ class DominusNodeToolkit {
             const labelErr = validateLabel(label);
             if (labelErr)
                 return err(labelErr);
-            const data = await this._req("POST", "/api/keys", { label: label.trim() });
-            return ok(JSON.stringify(data, null, 2) + "\n\nIMPORTANT: Store this API key securely — it will not be shown again.");
+            const data = await this._req("POST", "/api/keys", {
+                label: label.trim(),
+            });
+            return ok(JSON.stringify(data, null, 2) +
+                "\n\nIMPORTANT: Store this API key securely — it will not be shown again.");
         }
         catch (e) {
             return err(e);
@@ -1456,7 +1636,9 @@ class DominusNodeToolkit {
     async changePlan(planId) {
         try {
             const id = validateUuid(planId, "planId");
-            const data = await this._req("PUT", "/api/plans/user/plan", { planId: id });
+            const data = await this._req("PUT", "/api/plans/user/plan", {
+                planId: id,
+            });
             return ok(JSON.stringify(data, null, 2));
         }
         catch (e) {
@@ -1589,5 +1771,83 @@ class DominusNodeToolkit {
             return err(e);
         }
     }
+    // -----------------------------------------------------------------------
+    // Tool 54 (MPP): mppInfo
+    // -----------------------------------------------------------------------
+    async mppInfo() {
+        try {
+            const data = await this._req("GET", "/api/mpp/info");
+            return ok(JSON.stringify(data, null, 2));
+        }
+        catch (e) {
+            return err(e);
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Tool 55 (MPP): payMpp
+    // -----------------------------------------------------------------------
+    async payMpp(amountCents, method) {
+        if (!Number.isInteger(amountCents) ||
+            amountCents < 500 ||
+            amountCents > 100_000) {
+            return err("amount_cents must be an integer between 500 and 100,000");
+        }
+        if (!["tempo", "stripe_spt", "lightning"].includes(method)) {
+            return err("method must be one of: tempo, stripe_spt, lightning");
+        }
+        try {
+            const data = await this._req("POST", "/api/mpp/topup", {
+                amountCents,
+                method,
+            });
+            return ok(JSON.stringify(data, null, 2));
+        }
+        catch (e) {
+            return err(e);
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Tool 56 (MPP): mppSessionOpen
+    // -----------------------------------------------------------------------
+    async mppSessionOpen(maxDepositCents, method, poolType = "dc") {
+        if (!Number.isInteger(maxDepositCents) ||
+            maxDepositCents < 500 ||
+            maxDepositCents > 100_000) {
+            return err("max_deposit_cents must be an integer between 500 and 100,000");
+        }
+        if (!["tempo", "stripe_spt", "lightning"].includes(method)) {
+            return err("method must be one of: tempo, stripe_spt, lightning");
+        }
+        if (!["dc", "residential"].includes(poolType)) {
+            return err("pool_type must be dc or residential");
+        }
+        try {
+            const data = await this._req("POST", "/api/mpp/session/open", {
+                maxDepositCents,
+                method,
+                poolType,
+            });
+            return ok(JSON.stringify(data, null, 2));
+        }
+        catch (e) {
+            return err(e);
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Tool 57 (MPP): mppSessionClose
+    // -----------------------------------------------------------------------
+    async mppSessionClose(channelId) {
+        if (!channelId)
+            return err("channel_id is required");
+        try {
+            const data = await this._req("POST", "/api/mpp/session/close", {
+                channelId,
+            });
+            return ok(JSON.stringify(data, null, 2));
+        }
+        catch (e) {
+            return err(e);
+        }
+    }
 }
 exports.DominusNodeToolkit = DominusNodeToolkit;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dominusnode/pi-extension",
-  "version": "1.2.0",
+  "version": "1.5.2",
   "description": "Dominus Node pi-mono extension — 26 tools for rotating proxy, wallet, agentic wallets, teams, and payments",
   "keywords": [
     "pi-package",
@@ -29,11 +29,13 @@
   },
   "scripts": {
     "build": "tsc",
+    "prepare": "npm run build",
     "test": "vitest run",
     "lint": "tsc --noEmit"
   },
   "devDependencies": {
     "@sinclair/typebox": "^0.34.0",
+    "@types/node": "^22.0.0",
     "typescript": "^5.4.0",
     "vitest": "^1.6.0"
   },