@blanketbyte/wise-mcp 0.0.0-stage → 1.0.1

package/dist/config.js

@@ -0,0 +1,55 @@
+import { z } from "zod";
+/** Settings shared by both modes: local (stdio) and remote server. */
+const baseSchema = z.object({
+    // Write tools (transfers you pay in the Wise app, recipients, cancellations), always two-step. false = read-only.
+    WRITES_ENABLED: z
+        .enum(["true", "false"])
+        .default("true")
+        .transform((v) => v === "true"),
+    // Optional max amount per transfer, in the source currency. Empty = no limit.
+    MAX_TRANSFER_AMOUNT: z
+        .string()
+        .optional()
+        .transform((v) => (v && v.trim() ? Number(v) : undefined))
+        .refine((v) => v === undefined || (Number.isFinite(v) && v > 0), "MAX_TRANSFER_AMOUNT must be a positive number"),
+    // Where state lives; the audit log is written here in both modes.
+    DATA_DIR: z.string().default("./data"),
+    // Overridable only for the local e2e tests against a mock Wise.
+    WISE_API_URL: z.string().url().default("https://api.wise.com"),
+});
+/** Settings only the remote (HTTP) server needs. */
+const serverSchema = z.object({
+    // Public HTTPS URL of this server, e.g. https://wise.example.com (no trailing slash)
+    PUBLIC_URL: z.string().url(),
+    PORT: z.coerce.number().int().default(3000),
+    // Comma-separated Wise user ids allowed to log in. Empty = nobody (the login error shows your id).
+    ALLOWED_WISE_USERS: z.string().default(""),
+    // Encrypts stored Wise API tokens in DATA_DIR. openssl rand -base64 32
+    TOKEN_ENCRYPTION_KEY: z.string().min(32, "TOKEN_ENCRYPTION_KEY must be at least 32 characters"),
+    // Redirect hosts allowed during dynamic client registration
+    ALLOWED_REDIRECT_HOSTS: z.string().default("claude.ai,claude.com,chatgpt.com,localhost,127.0.0.1"),
+});
+function parse(schema) {
+    const parsed = schema.safeParse(process.env);
+    if (!parsed.success) {
+        console.error("❌ Invalid configuration:");
+        for (const issue of parsed.error.issues) {
+            console.error(`  - ${issue.path.join(".")}: ${issue.message}`);
+        }
+        process.exit(1);
+    }
+    return parsed.data;
+}
+const list = (s) => s.split(",").map((x) => x.trim()).filter(Boolean);
+const base = parse(baseSchema);
+export const config = { ...base, WISE_API_URL: base.WISE_API_URL.replace(/\/+$/, "") };
+export function loadServerConfig() {
+    const server = parse(serverSchema);
+    return {
+        ...config,
+        ...server,
+        PUBLIC_URL: server.PUBLIC_URL.replace(/\/+$/, ""),
+        allowedWiseUsers: list(server.ALLOWED_WISE_USERS).map(Number).filter(Number.isFinite),
+        allowedRedirectHosts: list(server.ALLOWED_REDIRECT_HOSTS),
+    };
+}

package/dist/crypto.js

@@ -0,0 +1,37 @@
+import { createCipheriv, createDecipheriv, createHash, createHmac, randomBytes, timingSafeEqual } from "node:crypto";
+/** AES-256-GCM for secrets at rest (Wise API tokens). */
+export class SecretBox {
+    key;
+    constructor(secret) {
+        this.key = createHash("sha256").update(secret).digest();
+    }
+    seal(plain) {
+        const iv = randomBytes(12);
+        const cipher = createCipheriv("aes-256-gcm", this.key, iv);
+        const data = Buffer.concat([cipher.update(plain, "utf8"), cipher.final()]);
+        return ["v1", iv.toString("base64"), cipher.getAuthTag().toString("base64"), data.toString("base64")].join(".");
+    }
+    open(sealed) {
+        const [version, iv, tag, data] = sealed.split(".");
+        if (version !== "v1" || !iv || !tag || !data)
+            throw new Error("Unsupported sealed value");
+        const decipher = createDecipheriv("aes-256-gcm", this.key, Buffer.from(iv, "base64"));
+        decipher.setAuthTag(Buffer.from(tag, "base64"));
+        return Buffer.concat([decipher.update(Buffer.from(data, "base64")), decipher.final()]).toString("utf8");
+    }
+    /** HMAC signature for short-lived browser cookies. */
+    sign(value) {
+        return `${value}.${createHmac("sha256", this.key).update(value).digest("base64url")}`;
+    }
+    unsign(signed) {
+        const i = signed.lastIndexOf(".");
+        if (i < 0)
+            return undefined;
+        const value = signed.slice(0, i);
+        const expected = Buffer.from(this.sign(value));
+        const given = Buffer.from(signed);
+        return expected.length === given.length && timingSafeEqual(expected, given) ? value : undefined;
+    }
+}
+export const randomToken = () => randomBytes(32).toString("hex");
+export const sha256 = (s) => createHash("sha256").update(s).digest("hex");

package/dist/fsutil.js

@@ -0,0 +1,16 @@
+import { chmodSync, renameSync, writeFileSync } from "node:fs";
+/**
+ * Writes JSON atomically and owner-only: a crash mid-write can't leave a half-written file
+ * (which would read as "no sessions" on restart), and the file is never briefly world-readable.
+ */
+export function writeJsonAtomic(file, data) {
+    const tmp = `${file}.${process.pid}.tmp`;
+    writeFileSync(tmp, JSON.stringify(data, null, 2), { mode: 0o600 });
+    renameSync(tmp, file);
+    try {
+        chmodSync(file, 0o600);
+    }
+    catch {
+        /* ignore on platforms without chmod */
+    }
+}

package/dist/index.js

@@ -0,0 +1,198 @@
+import path from "node:path";
+import express from "express";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { mcpAuthRouter, getOAuthProtectedResourceMetadataUrl } from "@modelcontextprotocol/sdk/server/auth/router.js";
+import { requireBearerAuth } from "@modelcontextprotocol/sdk/server/auth/middleware/bearerAuth.js";
+import { loadServerConfig } from "./config.js";
+import { PUBLIC_DIR, VERSION } from "./meta.js";
+import { SecretBox, sha256 } from "./crypto.js";
+import { ConnectionStore } from "./wise/connections.js";
+import { registerTools } from "./tools.js";
+import { AuthStore } from "./auth/store.js";
+import { WiseOAuthProvider, identify, page } from "./auth/provider.js";
+import { homePage, messagePage, sessionsLoginPage, sessionsPage } from "./auth/pages.js";
+const config = loadServerConfig();
+const publicUrl = new URL(config.PUBLIC_URL);
+const mcpUrl = new URL("/mcp", publicUrl);
+const iconUrl = new URL("/icon.png", publicUrl).href;
+const iconSvgUrl = new URL("/logo.svg", publicUrl).href;
+const box = new SecretBox(config.TOKEN_ENCRYPTION_KEY);
+const connections = new ConnectionStore(config.DATA_DIR, box);
+const store = new AuthStore(config.DATA_DIR);
+const provider = new WiseOAuthProvider(store, connections, mcpUrl, config.allowedRedirectHosts, config.allowedWiseUsers);
+/** Forget Wise tokens that no live session uses. */
+const pruneConnections = () => connections.prune(new Set(store.listSessions().map((s) => s.connectionId)));
+pruneConnections();
+setInterval(pruneConnections, 60 * 60 * 1000).unref();
+const app = express();
+app.set("trust proxy", 1); // behind one reverse proxy (Traefik, Caddy, nginx…) that sets X-Forwarded-For
+app.disable("x-powered-by");
+// --- Icons and logo ------------------------------------------------------------
+const asset = (file, type) => (req, res) => {
+    // Pages link assets with ?v=<content hash>, so those can be cached for good; bare URLs only briefly.
+    res.setHeader("Cache-Control", req.query.v ? "public, max-age=31536000, immutable" : "public, max-age=3600");
+    res.type(type).sendFile(path.join(PUBLIC_DIR, file));
+};
+app.get(["/icon.png", "/favicon.png"], asset("icon.png", "image/png"));
+app.get("/apple-touch-icon.png", asset("apple-touch-icon.png", "image/png"));
+app.get("/favicon.ico", asset("favicon.ico", "image/x-icon"));
+app.get("/logo.png", asset("logo.png", "image/png"));
+app.get("/logo.svg", asset("logo.svg", "image/svg+xml"));
+app.get("/", (_req, res) => page(res).send(homePage(mcpUrl.href)));
+// --- OAuth for MCP clients, login = pasted Wise API token ---------------------
+app.use(mcpAuthRouter({
+    provider,
+    issuerUrl: publicUrl,
+    resourceServerUrl: mcpUrl,
+    resourceName: "Wise",
+    scopesSupported: ["wise"],
+}));
+const form = express.urlencoded({ extended: false, limit: "8kb" });
+/** Small per-IP limiter for the token forms, so they can't be used to hammer Wise from this server. */
+function rateLimit(max, windowMs) {
+    const hits = new Map();
+    return (req, res, next) => {
+        const now = Date.now();
+        if (hits.size > 10_000)
+            for (const [k, v] of hits)
+                if (v.reset < now)
+                    hits.delete(k);
+        const key = req.ip ?? "unknown";
+        let h = hits.get(key);
+        if (!h || h.reset < now)
+            hits.set(key, (h = { n: 0, reset: now + windowMs }));
+        if (++h.n > max) {
+            res.setHeader("Retry-After", String(Math.ceil((h.reset - now) / 1000)));
+            page(res, 429).send(messagePage("Too many attempts", "Wait a few minutes, then try again."));
+            return;
+        }
+        next();
+    };
+}
+const LOGIN_LIMIT = { max: 20, windowMs: 15 * 60 * 1000 };
+app.post("/login", rateLimit(LOGIN_LIMIT.max, LOGIN_LIMIT.windowMs), form, async (req, res) => {
+    try {
+        await provider.handleLogin(req, res);
+    }
+    catch (err) {
+        console.error("login error", err);
+        if (!res.headersSent)
+            page(res, 500).send(messagePage("Login failed", "Something went wrong. Start connecting again from your app."));
+    }
+});
+// --- /sessions: see and revoke connected sessions (sign in with a Wise token) ---
+const ADMIN_COOKIE = "wise_mcp_admin";
+const ADMIN_TTL_MS = 15 * 60 * 1000;
+function adminUser(req) {
+    const raw = (req.headers.cookie ?? "").split(/;\s*/).find((c) => c.startsWith(ADMIN_COOKIE + "="));
+    const value = raw && box.unsign(decodeURIComponent(raw.slice(ADMIN_COOKIE.length + 1)));
+    if (!value)
+        return undefined;
+    const [userId, exp] = value.split(":").map(Number);
+    return exp > Date.now() && config.allowedWiseUsers.includes(userId) ? userId : undefined;
+}
+function sessionsFor(wiseUserId) {
+    return store.listSessions().filter((s) => connections.get(s.connectionId)?.wiseUserId === wiseUserId);
+}
+app.get("/sessions", (req, res) => {
+    const userId = adminUser(req);
+    if (!userId)
+        return page(res).send(sessionsLoginPage());
+    const flash = req.query.revoked ? `Revoked ${Number(req.query.revoked) || 0} session(s).` : undefined;
+    const sessions = sessionsFor(userId);
+    const label = sessions.map((s) => connections.get(s.connectionId)?.wiseUserLabel).find(Boolean) ?? `Wise user ${userId}`;
+    page(res).send(sessionsPage({ userName: label, sessions, flash }));
+});
+app.post("/sessions/login", rateLimit(LOGIN_LIMIT.max, LOGIN_LIMIT.windowMs), form, async (req, res) => {
+    const who = await identify(String(req.body?.token ?? "").trim(), config.allowedWiseUsers);
+    if (!who.ok) {
+        if (who.status === 403)
+            return page(res, 403).send(messagePage("Not allowed", who.message));
+        return page(res, who.status).send(sessionsLoginPage(who.message));
+    }
+    const cookie = box.sign(`${who.me.id}:${Date.now() + ADMIN_TTL_MS}`);
+    res.cookie(ADMIN_COOKIE, cookie, { httpOnly: true, secure: true, sameSite: "strict", maxAge: ADMIN_TTL_MS, path: "/sessions" });
+    res.redirect(303, "/sessions");
+});
+app.post("/sessions/revoke", form, (req, res) => {
+    const userId = adminUser(req);
+    if (!userId)
+        return page(res, 401).send(sessionsLoginPage("Session expired, sign in again."));
+    const id = String(req.body?.id ?? "");
+    const targets = sessionsFor(userId).filter((s) => id === "*" || s.id === id);
+    for (const s of targets)
+        store.deleteSession(s.id);
+    pruneConnections();
+    res.redirect(303, `/sessions?revoked=${targets.length}`);
+});
+// --- MCP (stateless Streamable HTTP) ----------------------------------------
+const auth = requireBearerAuth({
+    verifier: provider,
+    resourceMetadataUrl: getOAuthProtectedResourceMetadataUrl(mcpUrl),
+    expectedResource: mcpUrl,
+});
+app.post("/mcp", auth, express.json({ limit: "1mb" }), async (req, res) => {
+    const { connectionId, sessionId } = req.auth.extra;
+    const wise = connections.service(connectionId);
+    if (!wise) {
+        store.deleteSessionsForConnection(connectionId);
+        res.status(401).json({ jsonrpc: "2.0", error: { code: -32001, message: "Wise connection missing, reconnect" }, id: null });
+        return;
+    }
+    const server = new McpServer({
+        name: "wise",
+        title: "Wise",
+        version: VERSION,
+        websiteUrl: config.PUBLIC_URL,
+        icons: [
+            { src: iconUrl, mimeType: "image/png", sizes: ["256x256"] },
+            { src: iconSvgUrl, mimeType: "image/svg+xml", sizes: ["any"] },
+        ],
+    });
+    registerTools(server, wise, {
+        sessionKey: sessionId,
+        connectionId,
+        onRevoked: async () => {
+            console.warn(`Wise token rejected for connection ${connectionId}; removing it and its sessions`);
+            store.deleteSessionsForConnection(connectionId);
+            connections.remove(connectionId);
+        },
+    });
+    const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
+    res.on("close", () => {
+        transport.close();
+        server.close();
+    });
+    try {
+        await server.connect(transport);
+        await transport.handleRequest(req, res, req.body);
+    }
+    catch (err) {
+        console.error("MCP error", err);
+        if (!res.headersSent) {
+            res.status(500).json({ jsonrpc: "2.0", error: { code: -32603, message: "Internal server error" }, id: null });
+        }
+    }
+});
+const methodNotAllowed = (_req, res) => {
+    res.status(405).set("Allow", "POST").json({
+        jsonrpc: "2.0",
+        error: { code: -32000, message: "Method not allowed (stateless server)" },
+        id: null,
+    });
+};
+app.get("/mcp", auth, methodNotAllowed);
+app.delete("/mcp", auth, methodNotAllowed);
+app.get("/health", (_req, res) => {
+    res.json({ ok: true, version: VERSION });
+});
+app.listen(config.PORT, () => {
+    console.log(`✅ Wise MCP listening on :${config.PORT}`);
+    console.log(`   MCP endpoint:    ${mcpUrl.href}`);
+    console.log(`   Wise API:        ${config.WISE_API_URL}`);
+    console.log(`   allowed users:   ${config.allowedWiseUsers.join(", ") || "none (set ALLOWED_WISE_USERS)"}`);
+    console.log(`   encryption key:  sha256 ${sha256(config.TOKEN_ENCRYPTION_KEY).slice(0, 8)}`);
+    console.log(`   active sessions: ${store.listSessions().length}`);
+    console.log(`   writes:          ${config.WRITES_ENABLED ? `two-step, transfers paid in the Wise app${config.MAX_TRANSFER_AMOUNT ? ` (max ${config.MAX_TRANSFER_AMOUNT})` : ""}` : "disabled (read-only)"}`);
+});

package/dist/meta.js

@@ -0,0 +1,10 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+/** Package root (works from src/ under tsx and from dist/ when built or installed via npm). */
+export const ROOT = path.join(path.dirname(fileURLToPath(import.meta.url)), "..");
+export const PUBLIC_DIR = path.join(ROOT, "public");
+const pkg = JSON.parse(readFileSync(path.join(ROOT, "package.json"), "utf8"));
+export const VERSION = pkg.version;
+export const WEBSITE = "https://blanketbyte.com";
+export const REPO_URL = "https://github.com/BlanketByte/wise-mcp";

package/dist/pending.js

@@ -0,0 +1,34 @@
+import { randomBytes } from "node:crypto";
+const TTL_MS = 10 * 60 * 1000;
+const PREFIX = { transfer: "TX", recipient: "RCP", cancel_transfer: "CXL" };
+const pending = new Map();
+export function storePending(owner, action, summary) {
+    sweep();
+    const code = `${PREFIX[action.kind]}-${randomBytes(4).toString("hex").toUpperCase()}`;
+    const expiresAt = Date.now() + TTL_MS;
+    pending.set(code, { owner, action, summary, expiresAt });
+    return { code, expiresAt: new Date(expiresAt) };
+}
+/** Returns and removes the pending action (one-time use). */
+export function takePending(owner, code) {
+    sweep();
+    const key = code.trim().toUpperCase();
+    const p = pending.get(key);
+    if (!p || p.owner !== owner)
+        return undefined;
+    pending.delete(key);
+    return p;
+}
+export function discardPending(owner, code) {
+    const key = code.trim().toUpperCase();
+    const p = pending.get(key);
+    if (!p || p.owner !== owner)
+        return false;
+    return pending.delete(key);
+}
+function sweep() {
+    const now = Date.now();
+    for (const [k, v] of pending)
+        if (v.expiresAt < now)
+            pending.delete(k);
+}

package/dist/stdio.js

@@ -0,0 +1,63 @@
+import { mkdirSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { config } from "./config.js";
+import { PUBLIC_DIR, VERSION, WEBSITE } from "./meta.js";
+import { registerTools } from "./tools.js";
+import { WiseAccessRevokedError, WiseApiError, WiseClient } from "./wise/client.js";
+import { WiseService } from "./wise/service.js";
+/**
+ * Local mode: speaks MCP over stdin/stdout for Claude Desktop, Claude Code, Cursor, etc.
+ * No OAuth or sessions: the Wise token comes from WISE_API_TOKEN in the app's MCP config.
+ * stdout carries the protocol, so everything else goes to stderr.
+ *
+ * Without a token the server still starts and lists its tools (so directories like Glama can
+ * inspect it); every tool call then explains how to set WISE_API_TOKEN.
+ */
+const log = (msg) => process.stderr.write(`[wise-mcp] ${msg}\n`);
+const MISSING_TOKEN = "WISE_API_TOKEN is not set. Create a token in Wise → Settings → API tokens and add it to this server's env in your MCP client config.";
+/** Stand-in client used when no token is configured: every Wise call explains what to do. */
+class MissingTokenClient extends WiseClient {
+    async request() {
+        throw new Error(MISSING_TOKEN);
+    }
+}
+const token = process.env.WISE_API_TOKEN?.trim();
+let client;
+if (!token) {
+    log(`${MISSING_TOKEN} Starting anyway: tools are listed, but calls will fail until it's set.`);
+    client = new MissingTokenClient("", config.WISE_API_URL);
+}
+else {
+    client = new WiseClient(token, config.WISE_API_URL);
+    try {
+        const me = await client.me();
+        log(`connected as Wise user ${me.id}`);
+    }
+    catch (err) {
+        if (err instanceof WiseAccessRevokedError || (err instanceof WiseApiError && err.status === 403)) {
+            log("Wise rejected WISE_API_TOKEN. Check it's copied fully and not revoked.");
+            process.exit(1);
+        }
+        log(`couldn't reach Wise yet (${err instanceof Error ? err.message : err}); tools will retry`);
+    }
+}
+mkdirSync(config.DATA_DIR, { recursive: true });
+let icons = [];
+try {
+    icons = [{ src: `data:image/svg+xml;base64,${readFileSync(path.join(PUBLIC_DIR, "logo.svg")).toString("base64")}`, mimeType: "image/svg+xml", sizes: ["any"] }];
+}
+catch {
+    /* icon is optional */
+}
+const server = new McpServer({ name: "wise", title: "Wise", version: VERSION, websiteUrl: WEBSITE, icons });
+registerTools(server, new WiseService(client), {
+    sessionKey: "local",
+    connectionId: "local",
+    onRevoked: async () => {
+        log("Wise rejected the token (revoked or expired). Update WISE_API_TOKEN and restart.");
+    },
+});
+await server.connect(new StdioServerTransport());
+log(`ready (v${VERSION}, writes ${config.WRITES_ENABLED ? "enabled, two-step" : "disabled"}, audit log ${path.join(config.DATA_DIR, "audit.log")})`);