neozip-mcp 0.1.0-beta

package/dist/connection/legacy-profile-reader.js

@@ -0,0 +1,47 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { decryptJson } from "../account/profile-crypto.js";
+export const LEGACY_MCP_PROFILE_DIR = process.env.NEOZIP_MCP_PROFILE_DIR?.trim() ||
+    path.join(os.homedir(), ".neozip", "mcp");
+const PROFILES_PATH = () => path.join(LEGACY_MCP_PROFILE_DIR, "profiles.json");
+const ACTIVE_PATH = () => path.join(LEGACY_MCP_PROFILE_DIR, "active.json");
+const SECRETS_DIR = () => path.join(LEGACY_MCP_PROFILE_DIR, "secrets");
+function readProfilesFile() {
+    if (!fs.existsSync(PROFILES_PATH())) {
+        return { version: 1, profiles: [] };
+    }
+    return JSON.parse(fs.readFileSync(PROFILES_PATH(), "utf8"));
+}
+export function listLegacyProfiles() {
+    return readProfilesFile().profiles;
+}
+export function getLegacyActiveProfileId() {
+    if (!fs.existsSync(ACTIVE_PATH()))
+        return null;
+    const active = JSON.parse(fs.readFileSync(ACTIVE_PATH(), "utf8"));
+    return active.profileId;
+}
+export function readLegacySecrets(profileId) {
+    const sp = path.join(SECRETS_DIR(), `${profileId}.json.enc`);
+    if (!fs.existsSync(sp))
+        return null;
+    try {
+        return decryptJson(fs.readFileSync(sp, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function hasLegacyMcpProfiles() {
+    if (!fs.existsSync(PROFILES_PATH()))
+        return false;
+    try {
+        const data = readProfilesFile();
+        return data.profiles.length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=legacy-profile-reader.js.map

package/dist/connection/magic-link.js

@@ -0,0 +1,138 @@
+/**
+ * Parse user-pasted email verification input (aligned with neozip-desktop magicLinkToken.ts).
+ */
+const DIGIT_CODE_REGEX = /^\d{4,10}$/;
+function safeDecodeURIComponent(s) {
+    try {
+        if (/%[0-9A-Fa-f]{2}/.test(s))
+            return decodeURIComponent(s);
+    }
+    catch {
+        /* keep */
+    }
+    return s;
+}
+function extractEmailCodeFromHttpUrl(s) {
+    try {
+        const u = new URL(s);
+        const email = u.searchParams.get("email");
+        const code = u.searchParams.get("code");
+        if (email || code) {
+            return {
+                email: email ? safeDecodeURIComponent(email).trim().toLowerCase() : undefined,
+                code: code ? safeDecodeURIComponent(code).replace(/\D/g, "") : undefined,
+            };
+        }
+        if (u.hash && u.hash.length > 2) {
+            const h = u.hash.startsWith("#") ? u.hash.slice(1) : u.hash;
+            const hp = new URLSearchParams(h);
+            const he = hp.get("email");
+            const hc = hp.get("code");
+            if (he || hc) {
+                return {
+                    email: he ? safeDecodeURIComponent(he).trim().toLowerCase() : undefined,
+                    code: hc ? safeDecodeURIComponent(hc).replace(/\D/g, "") : undefined,
+                };
+            }
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+function extractFromHttpUrl(s) {
+    try {
+        const u = new URL(s);
+        const fromQuery = u.searchParams.get("token") ??
+            u.searchParams.get("t") ??
+            u.searchParams.get("code") ??
+            u.searchParams.get("verifyToken") ??
+            u.searchParams.get("verification") ??
+            u.searchParams.get("key");
+        if (fromQuery)
+            return safeDecodeURIComponent(fromQuery);
+        const pathParts = u.pathname.split("/").filter(Boolean);
+        const lastSeg = pathParts[pathParts.length - 1];
+        if (lastSeg &&
+            lastSeg.split(".").length === 3 &&
+            lastSeg.split(".").every((x) => x.length > 0)) {
+            return lastSeg;
+        }
+        if (u.hash && u.hash.length > 2) {
+            const h = u.hash.startsWith("#") ? u.hash.slice(1) : u.hash;
+            const hp = new URLSearchParams(h);
+            const fromHash = hp.get("token") ?? hp.get("t") ?? hp.get("code") ?? hp.get("access_token");
+            if (fromHash)
+                return safeDecodeURIComponent(fromHash);
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+/** Extract opaque token for POST /auth/exchange-token. */
+export function normalizeMagicLinkTokenInput(raw) {
+    let s = String(raw ?? "")
+        .trim()
+        .replace(/[\u00a0\u200b\uFEFF]/g, "")
+        .replace(/^["']|["']$/g, "");
+    if (!s)
+        return "";
+    if (/^https?:\/\//i.test(s)) {
+        s = s.replace(/[\n\r\t]+/g, "");
+    }
+    else {
+        s = s.replace(/\s/g, "");
+    }
+    if (/^https?:\/\//i.test(s)) {
+        const extracted = extractFromHttpUrl(s);
+        if (extracted)
+            return extracted;
+    }
+    const fromToken = s.match(/(?:^|[?&#])token=([^&\s#]+)/i);
+    if (fromToken?.[1]) {
+        return safeDecodeURIComponent(fromToken[1]);
+    }
+    const fromCode = s.match(/(?:^|[?&#])code=([^&\s#]+)/i);
+    if (fromCode?.[1] && !/^https?:\/\//i.test(s)) {
+        return safeDecodeURIComponent(fromCode[1]);
+    }
+    return safeDecodeURIComponent(s);
+}
+/** Extract { email, code } for POST /auth/verify-email-code. */
+export function extractEmailCodePair(raw) {
+    let s = String(raw ?? "")
+        .trim()
+        .replace(/[\u00a0\u200b\uFEFF]/g, "")
+        .replace(/^["']|["']$/g, "");
+    if (!s)
+        return {};
+    const isUrl = /^https?:\/\//i.test(s);
+    if (isUrl) {
+        s = s.replace(/[\n\r\t]+/g, "");
+        const fromUrl = extractEmailCodeFromHttpUrl(s);
+        if (fromUrl)
+            return fromUrl;
+        return {};
+    }
+    const emailMatch = s.match(/(?:^|[?&#])email=([^&\s#]+)/i);
+    const codeMatch = s.match(/(?:^|[?&#])code=([^&\s#]+)/i);
+    if (emailMatch || codeMatch) {
+        return {
+            email: emailMatch
+                ? safeDecodeURIComponent(emailMatch[1]).trim().toLowerCase()
+                : undefined,
+            code: codeMatch
+                ? safeDecodeURIComponent(codeMatch[1]).replace(/\D/g, "")
+                : undefined,
+        };
+    }
+    const digitsOnly = s.replace(/[\s-]/g, "");
+    if (DIGIT_CODE_REGEX.test(digitsOnly)) {
+        return { code: digitsOnly };
+    }
+    return {};
+}
+//# sourceMappingURL=magic-link.js.map

package/dist/connection/migrate.js

@@ -0,0 +1,76 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { encryptSecrets } from "./crypto.js";
+import { getLegacyActiveProfileId, hasLegacyMcpProfiles, listLegacyProfiles, readLegacySecrets, } from "./legacy-profile-reader.js";
+import { createConnection, getActiveConnectionId, getConnectionDir, listConnectionIds, selectConnection, updateConnection, } from "./store.js";
+export { hasLegacyMcpProfiles };
+export function migrateFromMcpProfileStore() {
+    if (listConnectionIds().length > 0) {
+        return {
+            migrated: 0,
+            skipped: listLegacyProfiles().length,
+            connectionDir: getConnectionDir(),
+            activeConnectionId: getActiveConnectionId(),
+        };
+    }
+    const profiles = listLegacyProfiles();
+    if (profiles.length === 0) {
+        return {
+            migrated: 0,
+            skipped: 0,
+            connectionDir: getConnectionDir(),
+            activeConnectionId: null,
+        };
+    }
+    const activeLegacyId = getLegacyActiveProfileId();
+    let activeConnectionId = null;
+    let migrated = 0;
+    for (const profile of profiles) {
+        const secrets = readLegacySecrets(profile.id);
+        const conn = createConnection({
+            label: profile.label,
+            tokenServiceUrl: profile.tokenServiceUrl,
+        });
+        const legacyExtras = profile;
+        updateConnection(conn.id, {
+            email: profile.email,
+            emailVerified: profile.emailVerified,
+            emailVerifiedAt: legacyExtras.emailVerifiedAt ??
+                (profile.emailVerified ? profile.updatedAt : null),
+            evmAddress: profile.evmAddress,
+            walletId: profile.walletId,
+            linkId: profile.linkId,
+            identityKeyId: profile.identityKeyId,
+            x25519PublicKeySpkiB64: legacyExtras.x25519PublicKeySpkiB64 ?? null,
+            x25519Fingerprint: profile.x25519Fingerprint,
+            onboardingCompleteAt: profile.identityKeyId != null ? profile.updatedAt : null,
+        });
+        if (secrets) {
+            const sp = path.join(getConnectionDir(), "connections", conn.id, "secrets.enc");
+            fs.writeFileSync(sp, encryptSecrets({
+                accessToken: secrets.accessToken,
+                accessTokenObtainedAt: secrets.accessTokenObtainedAt,
+                accessTokenExpiresAt: null,
+                evmPrivateKeyHex: secrets.evmPrivateKey?.replace(/^0x/i, "") ?? null,
+            }), { mode: 0o600 });
+        }
+        if (profile.id === activeLegacyId) {
+            selectConnection(conn.id);
+            activeConnectionId = conn.id;
+        }
+        else if (!activeConnectionId) {
+            activeConnectionId = conn.id;
+        }
+        migrated++;
+    }
+    if (activeLegacyId && activeConnectionId) {
+        selectConnection(activeConnectionId);
+    }
+    return {
+        migrated,
+        skipped: 0,
+        connectionDir: getConnectionDir(),
+        activeConnectionId: getActiveConnectionId(),
+    };
+}
+//# sourceMappingURL=migrate.js.map