@aiti-ai/ddns-mocks 0.0.0-stage → 0.1.0

package/dist/aliyun.d.ts

@@ -0,0 +1,36 @@
+/** aliyun mock — in-memory alidns.aliyuncs.com RPC endpoint. Verifies the
+ *  HMAC-SHA1 signature (when a secret is given) exactly like the real API,
+ *  so signature bugs surface in tests. */
+export interface AliyunMockOptions {
+    accessKeyId?: string;
+    /** Fixed listen port (default: kernel-assigned free port). */
+    port?: number;
+    accessKeySecret?: string;
+    records?: Array<{
+        rr: string;
+        type: string;
+        value: string;
+        ttl?: number;
+    }>;
+    zone: string;
+}
+export interface AliyunMockState {
+    records: Array<{
+        recordId: string;
+        rr: string;
+        type: string;
+        value: string;
+        ttl: number;
+    }>;
+    requests: Array<{
+        action: string;
+        params: URLSearchParams;
+        signatureValid: boolean | null;
+    }>;
+}
+export interface AliyunMockHandle {
+    url: string;
+    state: AliyunMockState;
+    stop(): Promise<void>;
+}
+export declare function startAliyunMock(opts: AliyunMockOptions): Promise<AliyunMockHandle>;

package/dist/aliyun.js

@@ -0,0 +1,103 @@
+/** aliyun mock — in-memory alidns.aliyuncs.com RPC endpoint. Verifies the
+ *  HMAC-SHA1 signature (when a secret is given) exactly like the real API,
+ *  so signature bugs surface in tests. */
+import { createServer } from "node:http";
+import { randomUUID, createHmac } from "node:crypto";
+// ── aliyun 签名链（内联自 ddns core，mock 钉死真实 wire 行为）──
+function aliyunPercent(s) {
+    return encodeURIComponent(s).replace(/[!'()*]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
+}
+function aliyunCanonicalQuery(params) {
+    return Object.entries(params)
+        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+        .map(([k, v]) => `${aliyunPercent(k)}=${aliyunPercent(v)}`)
+        .join("&");
+}
+function aliyunStringToSign(params) {
+    return `GET&%2F&${aliyunPercent(aliyunCanonicalQuery(params))}`;
+}
+function aliyunSign(accessKeySecret, params) {
+    return createHmac("sha1", `${accessKeySecret}&`).update(aliyunStringToSign(params)).digest("base64");
+}
+export async function startAliyunMock(opts) {
+    const keyId = opts.accessKeyId ?? "AKID";
+    const keySecret = opts.accessKeySecret;
+    const state = {
+        records: (opts.records ?? []).map((r) => ({ recordId: randomUUID(), ttl: r.ttl ?? 600, ...r })),
+        requests: [],
+    };
+    const json = (res, status, body) => {
+        res.writeHead(status, { "content-type": "application/json" });
+        res.end(JSON.stringify(body));
+    };
+    const fail = (res, code, message) => json(res, 400, { Code: code, Message: message, RequestId: randomUUID() });
+    const server = createServer((req, res) => {
+        const url = new URL(req.url ?? "/", "http://localhost");
+        const params = new URLSearchParams(url.search);
+        const action = params.get("Action") ?? "";
+        const signature = params.get("Signature") ?? "";
+        // signature verification (mirrors the real gateway): recompute over the
+        // canonical query of every param EXCEPT Signature
+        let signatureValid = null;
+        if (keySecret && signature) {
+            const rest = Object.fromEntries([...params.entries()].filter(([k]) => k !== "Signature"));
+            signatureValid = aliyunSign(keySecret, rest) === signature;
+            if (!signatureValid)
+                return fail(res, "SignatureDoesNotMatch", "Specified signature is not matched with our calculation.");
+        }
+        state.requests.push({ action, params, signatureValid });
+        switch (action) {
+            case "DescribeDomainRecords": {
+                const domain = params.get("DomainName") ?? opts.zone;
+                if (domain !== opts.zone)
+                    return fail(res, "InvalidDomainName.NoExist", "The specified domain name does not exist.");
+                const records = state.records.map((r) => ({
+                    RecordId: r.recordId,
+                    RR: r.rr,
+                    Type: r.type,
+                    Value: r.value,
+                    TTL: String(r.ttl),
+                }));
+                return json(res, 200, { RequestId: randomUUID(), TotalCount: records.length, DomainRecords: { Record: records } });
+            }
+            case "AddDomainRecord": {
+                const rec = {
+                    recordId: randomUUID(),
+                    rr: params.get("RR") ?? "@",
+                    type: params.get("Type") ?? "A",
+                    value: params.get("Value") ?? "",
+                    ttl: Number(params.get("TTL") ?? 600),
+                };
+                state.records.push(rec);
+                return json(res, 200, { RequestId: randomUUID(), RecordId: rec.recordId });
+            }
+            case "UpdateDomainRecord": {
+                const rec = state.records.find((r) => r.recordId === params.get("RecordId"));
+                if (!rec)
+                    return fail(res, "RecordNotExist", "The specified record does not exist.");
+                rec.rr = params.get("RR") ?? rec.rr;
+                rec.type = params.get("Type") ?? rec.type;
+                rec.value = params.get("Value") ?? rec.value;
+                rec.ttl = Number(params.get("TTL") ?? rec.ttl);
+                return json(res, 200, { RequestId: randomUUID(), RecordId: rec.recordId });
+            }
+            case "DeleteDomainRecord": {
+                const idx = state.records.findIndex((r) => r.recordId === params.get("RecordId"));
+                if (idx < 0)
+                    return fail(res, "RecordNotExist", "The specified record does not exist.");
+                state.records.splice(idx, 1);
+                return json(res, 200, { RequestId: randomUUID(), RecordId: params.get("RecordId") });
+            }
+            default:
+                return fail(res, "InvalidAction", `Specified action is not supported: ${action}`);
+        }
+    });
+    await new Promise((resolve) => server.listen(opts.port ?? 0, "127.0.0.1", resolve));
+    const addr = server.address();
+    const port = typeof addr === "object" && addr ? addr.port : 0;
+    return {
+        url: `http://127.0.0.1:${port}`,
+        state,
+        stop: () => new Promise((resolve) => server.close(() => resolve())),
+    };
+}

package/dist/assets/mock-ca.key

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCZNofmGlwQLAVn
+Z9jxTTz3o32KhoWXtUNqrsIr46Nu78zuCaNZr+9B0tMXGFpIqjmxcaovei+9fY9H
+AUBg/3tbW3ku8efQTPkD/EatXTEFrBM07T8UBATLhLfaN2xvzAskKp27jTnpjsvV
+G3/9trCaO2OlUONXtvoQEnyn4jyCLnG9CLPhxoinNdJBUZsuZvYcNIKF1A4IRcW1
+5zVU5zduhZ7s+8yLs6uYEp5gE6jH6kmKL6Bo5ZKO4lTpbc6Xbl+/TUMPaqXP1ApN
+UKzTDDRiMKqK4EiDyUl4uHSotHYx26c37gJAk4pbu0tSOQQXntKRR/3BknCOIURR
+/fpjc8/NAgMBAAECggEACvd3RMYwPswX2u34/lSr/4HJU6gLWe+UksdNiLyzjxZF
+EejIs3u/YXPIvkd09uyQUp4zM1DIqASbw9ZYGFlRKBnlE7InCKbp0Bo3qOMZxjEp
+8sjkkfczrKmkS09aSKpPRdhzD+Cs+4XIG0nroGp6O5/yovumOjoTriDUoWO1NxAl
+kWzPnQfGzfeve/EwmuqYxFyLjMXcHFm2J2swQvp7m1nPA1rwea0LV4YXLWXsCQNI
+tg9OyxO5qyN8jtGGNFVcbwswU3eIsHIoOXTxyMPqvOsnrrLinT5jkb8NJXJrwEvy
+vgdLXMC8GRfxejExNDT69/os9zBw/CVgR9Gx+HiGtQKBgQDUsmguhVS9iWODlxyY
+iaaJuxYDRwSo4ed0zqQ3KfqVHYAACr4ivpnqH/N/pbroGQAUEnA5DSURn9EfqT/8
+XyjP2xPEpHNAQCsIH+a8fOo+BM7Zj0b6S7Ed9Tob1NF7rREV6E0mCshBaYEbZqlN
+dj7OThKurVxBPFRqeZ3nRxAhlwKBgQC4Z97zK3i7r7jMF85+PqKk3UE1xfbNiSeN
+XNjP4YnFam4bdspAY0+CPkBDC+1ifpnIr5MLU/lvzjTAVu5oFXpmqse+jzXRuaKI
+SIb1UYKjNINYfpi+I/T7GbKwHdsp9SwyI0JDu1PxXdeZEvsXM7qLASrjfxjerwuI
+FbdZAmK+OwKBgHde7WN2hvmc2tHmhDEDyAiyjAco22+g4VLICpe/Iph/pu/fF5jO
+WflxFyrDq6NJLKcXNg5+1xgOFsLrLTMJgREuxeht1xTvLndv2AJfJOPLtP+bDt24
+j13d3E/0X+FGXzlpV6sLEBrOCJyFQG1t+I+2d3u7ZfRi1ImxWbKMSnxfAoGAPJGx
+g0GmGE+xbSfspT7BgVFDF/x8AiqomSAD/tPfwr4giFjOObPk66yywtLqF83piSdS
+LwhYB8c9QGfNStazK4GwtgCn9sj4f7cCzRUGycB329tJJDr/PnLEZGCKGg/zgkxe
+eYzQF5lxNVAstQRCo2GwyqR2cL4iFYK8hDnqYP0CgYEAucMoDpX96KjWuxJU52NG
+kfpMI1Jaq1ViyXfQ4J6Ag037ySB40X4nkjuEuNPGPWcIcL4cKaLI8hXQCkXxXuuO
+9xrsqHztA1vCki5HRmhi/l4fGbP3tGxH6EsCiR4Hp5hODTlnEbVBo2z19OqHLQks
+eeBTcR46lJU6yDbRDQfiqLw=
+-----END PRIVATE KEY-----

package/dist/assets/mock-ca.pem

@@ -0,0 +1,19 @@
+-----BEGIN CERTIFICATE-----
+MIIDHzCCAgegAwIBAgIUa0F8AroOLrX2jEHC3B66CFkSB30wDQYJKoZIhvcNAQEL
+BQAwFzEVMBMGA1UEAwwMZGRucyBtb2NrIENBMB4XDTI2MDgzMDA3NTAwNFoXDTM2
+MDgyNzA3NTAwNFowFzEVMBMGA1UEAwwMZGRucyBtb2NrIENBMIIBIjANBgkqhkiG
+9w0BAQEFAAOCAQ8AMIIBCgKCAQEAmTaH5hpcECwFZ2fY8U0896N9ioaFl7VDaq7C
+K+Ojbu/M7gmjWa/vQdLTFxhaSKo5sXGqL3ovvX2PRwFAYP97W1t5LvHn0Ez5A/xG
+rV0xBawTNO0/FAQEy4S32jdsb8wLJCqdu4056Y7L1Rt//bawmjtjpVDjV7b6EBJ8
+p+I8gi5xvQiz4caIpzXSQVGbLmb2HDSChdQOCEXFtec1VOc3boWe7PvMi7OrmBKe
+YBOox+pJii+gaOWSjuJU6W3Ol25fv01DD2qlz9QKTVCs0ww0YjCqiuBIg8lJeLh0
+qLR2MdunN+4CQJOKW7tLUjkEF57SkUf9wZJwjiFEUf36Y3PPzQIDAQABo2MwYTAd
+BgNVHQ4EFgQUqhYXNe0bvTC3Pl7Lcw2dwJf0C54wHwYDVR0jBBgwFoAUqhYXNe0b
+vTC3Pl7Lcw2dwJf0C54wDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYw
+DQYJKoZIhvcNAQELBQADggEBAFBHsTniggP0c3TbXattz518eXggQmCgSCpU3Rw9
+BQvgjxAhO9fSmunutrjRRHo4etX/w0wCnsUXVDLberyBZKgOFfK7PIuYcNKxpKbU
+6goiU914diRDIKdLmRl7bjwWoI65FWZZgLqvEbzByWsY9qLceChENDNRCdzakctU
+qXi3tiYFPrQ2EJdZRU3vigQkxDS8uqrv2IAMmiM9UDAAqdYX92VOXnqzWWpkG2Ek
+fg680qFmY5niT3Av7dBtvA93VZpfVmzFv/ls/M8oSkfqhffSpMUfjCFYqBv3XZsD
+9e20JpqkOELlUGNok20fhCe59ZA8bdMyn9XkAiyKEoM4NLE=
+-----END CERTIFICATE-----

package/dist/assets/mock-server.key

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCsVCMXqgAl3ro0
+QEg8d3u9cdb/wxwDNm5rnOhdD9jd+FVdIRfEjfABbVbW7nDHJ0wA/Fvvs0fPKNoz
+Yf8ts78EpAJhhIXscieUCFnuTTJvlW8R23HwHaZt+iF5/SH/eUHlg2Zmq3GGDq5U
+0REUAYPGHPOzrfY/hLXd3Qk/SCNTfboU3Kg8AU1eb0SucmJIax7+IXh4wT8SGJdB
+8cUhRq1frfNF0MZHeX4wcidRD+aW3I5pDNUKh7h4Ncmvc9boc4XMYzt9hIUB5ljS
+yWfgrCSXE1iTARhhDb90czJq+HtwWw32BAkfAzkxDxtmiC8hI26m8YKsDauaObC2
+qHpg3xgPAgMBAAECggEAN1YTKLOltYNmToX/zC7f9K7cB6fq1FtDrNmnQc7naCuo
+ma2ZOLwNQCAQnRbW7xR+0ug2S2vJ2Ms4+fvzWYUZBw/1VcQczxa+/8mIuz1dvzgA
+gP7zANQ8j58c5dOzeZpB30XI+Zn+67nGICU8MyzjWBgO53kqlC30ymgCYqgy88lp
+9bxElMlXaZqecjcS62dBev/xyA7bGCz7tfMv9+/7LAR5VOHIdXajEoIIRbj8cLRD
+xWkwSGW1nPiuLPEgHHTztJulMUM8gpGmR9h8Uw3nCDDldSzlynMX2nQtzx2TPzdC
+FOTCV3pOBmUJbaAuJlDhGKtWH3GdLTCmUUQhw3KpeQKBgQDfMbTmR2uE9B8MyGxP
+wwpHcC791UFaxH+IxPj+eBANvLZBa6wfBj7eMqCQlXRJFo98NqbveHp1AjGjMYeA
+UaDg7TiCBVmRBEJOjaIoGQ29orh+w/cbI4XZhENrXbq1TAzzrQBC10Pslo+AJHNx
+C+OYXwY+8auc2tj/ytTVXYJT9wKBgQDFqHniPWdnDLlO/sdUzoXB1+1+g1pJ83HA
++0qPboaAckIh4nl/erS+9gakR/3OhDpOrXgB9K7riddSWBl399RWyrnWqONlosGh
+8Iz5b9kCuOtGPnadQ0MHuBILOBfF7Oah2MXjzRUula40nETO1wU/ME7iQUfUPN1h
+ESq5p9kmqQKBgHRP6g7rfzutIJU/yToT0UKDUunS/Zj4t+GljIDIPs1535zeKLeO
+QKr4xTYzvILuL94yePJo3aAmgYmjIRMc9vLgjMctVIy/JHLdWnj8/W0q5GyjYR4S
+eAlv5NaJ5Off9wvxxyYOGoaru6Ky3Do4UOYx9wZMWPuIDPfYUuvSLD3nAoGBAK6O
+Q9115tyN0xUdUcHmhR+UZsvEircmRD5ubgFPVX8X6KluDWh0YC0IrwLkBRQdmDSl
+Y4cupE+kssCoxw04k5B2hjo5emDmpGQ0QPuEODz8O+MUBMKLhSXK/DxmNDB6L4+d
+Fd5A3kT+sRMLMoUMRTjxm6iaiCm5+rPfakD9J3vJAoGAM1/JgP3RYr7nvk2BcbD+
+O6/893QlsMcZvkikSWp6Qexum3qa8+MFMoPpQkWhfSkjIAOudsS0Y/jzG8vJXnNq
+mVNg9CelAtIvse83lOe9taRDyAkzdcHXAorbIB1ZyoeobkDj5DMqXx/3JAIAyFeh
+uaOVmtghx31mNCe5GUS0H1o=
+-----END PRIVATE KEY-----

package/dist/assets/mock-server.pem

@@ -0,0 +1,21 @@
+-----BEGIN CERTIFICATE-----
+MIIDZzCCAk+gAwIBAgIUWoGE9BH89lxIwuU9xy6AZFY/YfUwDQYJKoZIhvcNAQEL
+BQAwFzEVMBMGA1UEAwwMZGRucyBtb2NrIENBMB4XDTI2MDgzMDA3NTAwNVoXDTM2
+MDgyNzA3NTAwNVowHTEbMBkGA1UEAwwSYXBpLmNsb3VkZmxhcmUuY29tMIIBIjAN
+BgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArFQjF6oAJd66NEBIPHd7vXHW/8Mc
+AzZua5zoXQ/Y3fhVXSEXxI3wAW1W1u5wxydMAPxb77NHzyjaM2H/LbO/BKQCYYSF
+7HInlAhZ7k0yb5VvEdtx8B2mbfohef0h/3lB5YNmZqtxhg6uVNERFAGDxhzzs632
+P4S13d0JP0gjU326FNyoPAFNXm9ErnJiSGse/iF4eME/EhiXQfHFIUatX63zRdDG
+R3l+MHInUQ/mltyOaQzVCoe4eDXJr3PW6HOFzGM7fYSFAeZY0sln4KwklxNYkwEY
+YQ2/dHMyavh7cFsN9gQJHwM5MQ8bZogvISNupvGCrA2rmjmwtqh6YN8YDwIDAQAB
+o4GkMIGhMF8GA1UdEQRYMFaCEmFwaS5jbG91ZGZsYXJlLmNvbYIJZG5zYXBpLmNu
+ghNhbGlkbnMuYWxpeXVuY3MuY29tgg93d3cuZHVja2Rucy5vcmeCCWxvY2FsaG9z
+dIcEfwAAATAdBgNVHQ4EFgQUxCD4eRMWklwxHlxJGmb9GMFq4pcwHwYDVR0jBBgw
+FoAUqhYXNe0bvTC3Pl7Lcw2dwJf0C54wDQYJKoZIhvcNAQELBQADggEBAIrb+5KS
+oaUsImjHYNu2fMBbiLF+WgJSGqhWAmudsV+msis56F7r/H2c5KTZb6Sk5y80DDdX
+4To/+e5TyJeX/jVnQ0A+lqmFdmbnibNCHPAVmuQKc2QFi0m0XBgGyGMRiR9TqzkB
+ngv1hqm0ALDKgU1z8vcZl4vbWXtgrOllxWFcvVrzFgdZACNSds7twMuCX0A47hiy
+8GvhRvV7gdrS4CAAoA62XvZZ17UCsYTKFO26LZ8fTasJTnFZfdg+/8QcAMABLzgi
+slq9VZkvsAiEDOajS42wJ6jk4uMzDs4d0zn2tqWqvk+Wfcrz61JvG1Ve3lYK1EyX
+8iYT42RsR236Ly0=
+-----END CERTIFICATE-----

package/dist/cloudflare.d.ts

@@ -0,0 +1,38 @@
+/** cloudflare mock — an in-memory implementation of the Cloudflare REST v4
+ *  DNS API, so the real provider can be exercised end-to-end with no network
+ *  (mirrors ddns-updater/lexicon tests, which stub the same endpoints). */
+export interface CloudflareMockOptions {
+    /** Token the mock accepts in Authorization: Bearer. Default "test-token". */
+    token?: string;
+    /** Fixed listen port (default: kernel-assigned free port). */
+    port?: number;
+    /** Pre-seeded zones: name → records. */
+    zones?: Record<string, Array<{
+        type: string;
+        name: string;
+        content: string;
+        ttl?: number;
+        proxied?: boolean;
+    }>>;
+}
+export interface CloudflareMockState {
+    zones: Map<string, {
+        id: string;
+        records: Array<Record<string, unknown>>;
+    }>;
+    /** Every request the mock served (method, url, body). */
+    requests: Array<{
+        method: string;
+        url: string;
+        body?: unknown;
+    }>;
+}
+export interface CloudflareMockHandle {
+    /** Base URL to inject into the provider (cfg.baseUrl). */
+    url: string;
+    state: CloudflareMockState;
+    /** Wait until the mock is listening. */
+    ready: Promise<void>;
+    stop(): Promise<void>;
+}
+export declare function startCloudflareMock(opts?: CloudflareMockOptions): Promise<CloudflareMockHandle>;

package/dist/cloudflare.js

@@ -0,0 +1,105 @@
+/** cloudflare mock — an in-memory implementation of the Cloudflare REST v4
+ *  DNS API, so the real provider can be exercised end-to-end with no network
+ *  (mirrors ddns-updater/lexicon tests, which stub the same endpoints). */
+import { createServer } from "node:http";
+import { randomUUID } from "node:crypto";
+export async function startCloudflareMock(opts = {}) {
+    const token = opts.token ?? "test-token";
+    const state = { zones: new Map(), requests: [] };
+    for (const [name, records] of Object.entries(opts.zones ?? {})) {
+        state.zones.set(name, {
+            id: randomUUID(),
+            records: records.map((r) => ({ id: randomUUID(), ...r })),
+        });
+    }
+    const authOk = (req) => req.headers.authorization === `Bearer ${token}`;
+    const json = (res, status, body) => {
+        res.writeHead(status, { "content-type": "application/json" });
+        res.end(JSON.stringify(body));
+    };
+    const fail = (res, status, code, message) => json(res, status, { success: false, errors: [{ code, message }] });
+    const server = createServer((req, res) => {
+        const url = new URL(req.url ?? "/", "http://localhost");
+        // Real Cloudflare API paths are /client/v4/zones... — the mock serves at
+        // <baseUrl>/client/v4 (provider baseUrl = API root), so strip the prefix.
+        const pathname = url.pathname.replace(/^\/client\/v4/, "") || "/";
+        const parts = pathname.split("/").filter(Boolean); // zones, :id, dns_records, :rid
+        let body = "";
+        req.on("data", (c) => (body += c));
+        req.on("end", () => {
+            const parsed = body ? JSON.parse(body) : undefined;
+            state.requests.push({ method: req.method ?? "GET", url: url.pathname + url.search, body: parsed });
+            if (!authOk(req))
+                return fail(res, 403, 9109, "Invalid Token");
+            // GET /zones?name=  — result_info is required by lexicon's
+            // authenticate() (it paginates on result_info.total_pages).
+            if (parts[0] === "zones" && parts.length === 1 && req.method === "GET") {
+                const name = url.searchParams.get("name");
+                const zones = [...state.zones.entries()]
+                    .filter(([n]) => !name || n === name)
+                    .map(([n, z]) => ({ id: z.id, name: n }));
+                return json(res, 200, {
+                    success: true,
+                    result: zones,
+                    result_info: { page: 1, per_page: 100, count: zones.length, total_count: zones.length, total_pages: 1 },
+                });
+            }
+            // GET /zones/:id/dns_records[?type&name]
+            if (parts[0] === "zones" && parts[2] === "dns_records" && parts.length === 3 && req.method === "GET") {
+                const zone = [...state.zones.values()].find((z) => z.id === parts[1]);
+                if (!zone)
+                    return fail(res, 404, 6003, "Zone not found");
+                let records = zone.records;
+                const type = url.searchParams.get("type");
+                const name = url.searchParams.get("name");
+                if (type)
+                    records = records.filter((r) => r.type === type);
+                if (name)
+                    records = records.filter((r) => r.name === name);
+                // lexicon 的 list_records 读取 result_info 分页（total_pages/page）
+                return json(res, 200, {
+                    success: true,
+                    result: records,
+                    result_info: { page: 1, per_page: 100, count: records.length, total_count: records.length, total_pages: 1 },
+                });
+            }
+            // POST /zones/:id/dns_records
+            if (parts[0] === "zones" && parts[2] === "dns_records" && parts.length === 3 && req.method === "POST") {
+                const zone = [...state.zones.values()].find((z) => z.id === parts[1]);
+                if (!zone)
+                    return fail(res, 404, 6003, "Zone not found");
+                const rec = { id: randomUUID(), ...parsed };
+                zone.records.push(rec);
+                return json(res, 200, { success: true, result: rec });
+            }
+            // PUT /zones/:id/dns_records/:rid
+            if (parts[0] === "zones" && parts[2] === "dns_records" && parts.length === 4 && req.method === "PUT") {
+                const zone = [...state.zones.values()].find((z) => z.id === parts[1]);
+                const rec = zone?.records.find((r) => r.id === parts[3]);
+                if (!zone || !rec)
+                    return fail(res, 404, 81044, "Record not found");
+                Object.assign(rec, parsed);
+                return json(res, 200, { success: true, result: rec });
+            }
+            // DELETE /zones/:id/dns_records/:rid
+            if (parts[0] === "zones" && parts[2] === "dns_records" && parts.length === 4 && req.method === "DELETE") {
+                const zone = [...state.zones.values()].find((z) => z.id === parts[1]);
+                const idx = zone?.records.findIndex((r) => r.id === parts[3]) ?? -1;
+                if (!zone || idx < 0)
+                    return fail(res, 404, 81044, "Record not found");
+                zone.records.splice(idx, 1);
+                return json(res, 200, { success: true, result: { id: parts[3] } });
+            }
+            return fail(res, 404, 7000, `Unknown endpoint ${url.pathname}`);
+        });
+    });
+    await new Promise((resolve) => server.listen(opts.port ?? 0, "127.0.0.1", resolve));
+    const addr = server.address();
+    const port = typeof addr === "object" && addr ? addr.port : 0;
+    return {
+        url: `http://127.0.0.1:${port}/client/v4`,
+        state,
+        ready: Promise.resolve(),
+        stop: () => new Promise((resolve) => server.close(() => resolve())),
+    };
+}

package/dist/custom.d.ts

@@ -0,0 +1,24 @@
+/** custom mock — a generic webhook endpoint for the custom provider (Go
+ *  ddns-updater custom semantics): records every request's query params and
+ *  returns a configurable response body so success_regex matching can be
+ *  tested both ways. */
+export interface CustomMockOptions {
+    /** Fixed listen port (default: kernel-assigned free port). */
+    port?: number;
+    /** Response body for every request (default "good"). */
+    responseText?: string;
+    /** HTTP status for every request (default 200). */
+    status?: number;
+}
+export interface CustomMockState {
+    requests: Array<{
+        url: string;
+        query: URLSearchParams;
+    }>;
+}
+export interface CustomMockHandle {
+    url: string;
+    state: CustomMockState;
+    stop(): Promise<void>;
+}
+export declare function startCustomMock(opts?: CustomMockOptions): Promise<CustomMockHandle>;

package/dist/custom.js

@@ -0,0 +1,22 @@
+/** custom mock — a generic webhook endpoint for the custom provider (Go
+ *  ddns-updater custom semantics): records every request's query params and
+ *  returns a configurable response body so success_regex matching can be
+ *  tested both ways. */
+import { createServer } from "node:http";
+export async function startCustomMock(opts = {}) {
+    const state = { requests: [] };
+    const server = createServer((req, res) => {
+        const url = new URL(req.url ?? "/", "http://localhost");
+        state.requests.push({ url: url.pathname + url.search, query: url.searchParams });
+        res.writeHead(opts.status ?? 200, { "content-type": "text/plain" });
+        res.end(opts.responseText ?? "good");
+    });
+    await new Promise((resolve) => server.listen(opts.port ?? 0, "127.0.0.1", resolve));
+    const addr = server.address();
+    const port = typeof addr === "object" && addr ? addr.port : 0;
+    return {
+        url: `http://127.0.0.1:${port}/update`,
+        state,
+        stop: () => new Promise((resolve) => server.close(() => resolve())),
+    };
+}

package/dist/dnspod.d.ts

@@ -0,0 +1,33 @@
+/** dnspod mock — in-memory dnsapi.cn (Record.List/Create/Modify/Remove),
+ *  form-encoded POST like the real service. */
+export interface DnspodMockOptions {
+    token?: string;
+    /** Fixed listen port (default: kernel-assigned free port). */
+    port?: number;
+    records?: Array<{
+        name: string;
+        type: string;
+        value: string;
+        ttl?: number;
+    }>;
+}
+export interface DnspodMockState {
+    records: Array<{
+        id: string;
+        name: string;
+        type: string;
+        value: string;
+        ttl: number;
+        line: string;
+    }>;
+    requests: Array<{
+        action: string;
+        params: URLSearchParams;
+    }>;
+}
+export interface DnspodMockHandle {
+    url: string;
+    state: DnspodMockState;
+    stop(): Promise<void>;
+}
+export declare function startDnspodMock(opts?: DnspodMockOptions): Promise<DnspodMockHandle>;

package/dist/dnspod.js

@@ -0,0 +1,104 @@
+/** dnspod mock — in-memory dnsapi.cn (Record.List/Create/Modify/Remove),
+ *  form-encoded POST like the real service. */
+import { createServer } from "node:http";
+import { randomUUID } from "node:crypto";
+export async function startDnspodMock(opts = {}) {
+    const token = opts.token ?? "1,test-token";
+    const state = {
+        records: (opts.records ?? []).map((r) => ({ id: randomUUID(), line: "默认", ttl: r.ttl ?? 600, ...r })),
+        requests: [],
+    };
+    const json = (res, body) => {
+        res.writeHead(200, { "content-type": "application/json" });
+        res.end(JSON.stringify(body));
+    };
+    const ok = (res, data = {}) => json(res, { status: { code: "1", message: "Action completed successful" }, data });
+    // 真实 DNSPod 的 Record.* 响应字段在 TOP level（{status, records/record/id}）
+    // 而非 data 包裹 —— 用 okTop 模拟真实形状
+    const okTop = (res, body = {}) => json(res, { status: { code: "1", message: "Action completed successful" }, ...body });
+    const fail = (res, code, message) => json(res, { status: { code, message } });
+    const server = createServer((req, res) => {
+        let body = "";
+        req.on("data", (c) => (body += c));
+        req.on("end", () => {
+            const params = new URLSearchParams(body);
+            const action = (req.url ?? "").replace(/^\//, "").split("?")[0] ?? "";
+            state.requests.push({ action, params });
+            if (params.get("login_token") !== token)
+                return fail(res, "6", "Invalid Token");
+            switch (action) {
+                case "Domain.Info": {
+                    // lexicon's dnspod authenticate() calls this first — domain.id is
+                    // required, status.code must be "1".
+                    const domain = params.get("domain");
+                    const exists = state.records.some((r) => r.name.endsWith(`.${domain}`) || r.name === domain);
+                    if (!exists)
+                        return fail(res, "8", "Domain not found");
+                    return okTop(res, { id: randomUUID(), name: domain });
+                }
+                case "Record.List": {
+                    const domain = params.get("domain");
+                    const sub = params.get("sub_domain");
+                    const type = params.get("record_type");
+                    let records = state.records;
+                    if (domain)
+                        records = records.filter((r) => r.name.endsWith(`.${domain}`) || r.name === domain);
+                    if (sub && sub !== "@")
+                        records = records.filter((r) => r.name.split(".")[0] === sub);
+                    if (type)
+                        records = records.filter((r) => r.type === type);
+                    // real DNSPod returns the SHORT label as "name" (not the FQDN)
+                    const shaped = records.map((r) => ({
+                        ...r,
+                        name: r.name === domain ? "@" : r.name.replace(`.${domain}`, ""),
+                    }));
+                    return okTop(res, { records: shaped });
+                }
+                case "Record.Create": {
+                    const domain = params.get("domain") ?? "";
+                    const sub = params.get("sub_domain") ?? "";
+                    const owner = sub === "@" ? "" : `${sub}.`;
+                    const rec = {
+                        id: randomUUID(),
+                        name: `${owner}${domain}`,
+                        type: params.get("record_type") ?? "A",
+                        value: params.get("value") ?? "",
+                        ttl: Number(params.get("ttl") ?? 600),
+                        line: params.get("record_line") ?? "默认",
+                    };
+                    state.records.push(rec);
+                    // 真实 DNSPod 返回 {record: {id, name, status, ...}} —— 模拟真实形状
+                    return okTop(res, { record: { id: rec.id, name: rec.name, status: "enabled" } });
+                }
+                case "Record.Modify": {
+                    const id = params.get("record_id");
+                    const rec = state.records.find((r) => r.id === id);
+                    if (!rec)
+                        return fail(res, "8", "Record not found");
+                    rec.type = params.get("record_type") ?? rec.type;
+                    rec.value = params.get("value") ?? rec.value;
+                    rec.ttl = Number(params.get("ttl") ?? rec.ttl);
+                    return okTop(res, { id });
+                }
+                case "Record.Remove": {
+                    const id = params.get("record_id");
+                    const idx = state.records.findIndex((r) => r.id === id);
+                    if (idx < 0)
+                        return fail(res, "8", "Record not found");
+                    state.records.splice(idx, 1);
+                    return okTop(res, { id });
+                }
+                default:
+                    return fail(res, "15", `Unknown action ${action}`);
+            }
+        });
+    });
+    await new Promise((resolve) => server.listen(opts.port ?? 0, "127.0.0.1", resolve));
+    const addr = server.address();
+    const port = typeof addr === "object" && addr ? addr.port : 0;
+    return {
+        url: `http://127.0.0.1:${port}`,
+        state,
+        stop: () => new Promise((resolve) => server.close(() => resolve())),
+    };
+}

package/dist/duckdns.d.ts

@@ -0,0 +1,24 @@
+/** duckdns mock — in-memory /v3/update endpoint (GET form like the real
+ *  service; "OK"/"KO" responses exactly as duckdns returns them, so Go
+ *  ddns-updater and Python lexicon duckdns implementations both work). */
+export interface DuckdnsMockOptions {
+    token?: string;
+    /** Fixed listen port (default: kernel-assigned free port). */
+    port?: number;
+}
+export interface DuckdnsMockState {
+    /** label → { ipv4?, ipv6? } as last pushed. */
+    ips: Map<string, {
+        ipv4?: string;
+        ipv6?: string;
+    }>;
+    requests: Array<{
+        url: string;
+    }>;
+}
+export interface DuckdnsMockHandle {
+    url: string;
+    state: DuckdnsMockState;
+    stop(): Promise<void>;
+}
+export declare function startDuckdnsMock(opts?: DuckdnsMockOptions): Promise<DuckdnsMockHandle>;

package/dist/duckdns.js

@@ -0,0 +1,41 @@
+/** duckdns mock — in-memory /v3/update endpoint (GET form like the real
+ *  service; "OK"/"KO" responses exactly as duckdns returns them, so Go
+ *  ddns-updater and Python lexicon duckdns implementations both work). */
+import { createServer } from "node:http";
+export async function startDuckdnsMock(opts = {}) {
+    const token = opts.token ?? "test-token";
+    const state = { ips: new Map(), requests: [] };
+    const server = createServer((req, res) => {
+        const url = new URL(req.url ?? "/", "http://localhost");
+        state.requests.push({ url: url.pathname + url.search });
+        // The real duckdns service keys everything on the token — Go ddns-updater
+        // hits /update, lexicon hits /, our client hits /v3/update. Answer every
+        // path identically so all three implementations work against the mock.
+        const domains = url.searchParams.get("domains") ?? "";
+        const tok = url.searchParams.get("token") ?? "";
+        const ip = url.searchParams.get("ip");
+        const ipv6 = url.searchParams.get("ipv6");
+        res.writeHead(200, { "content-type": "text/plain" });
+        if (tok !== token)
+            return res.end("KO");
+        if (!domains)
+            return res.end("KO");
+        for (const label of domains.split(",")) {
+            const entry = state.ips.get(label) ?? {};
+            if (ip !== null)
+                entry.ipv4 = ip;
+            if (ipv6 !== null)
+                entry.ipv6 = ipv6;
+            state.ips.set(label, entry);
+        }
+        res.end("OK");
+    });
+    await new Promise((resolve) => server.listen(opts.port ?? 0, "127.0.0.1", resolve));
+    const addr = server.address();
+    const port = typeof addr === "object" && addr ? addr.port : 0;
+    return {
+        url: `http://127.0.0.1:${port}`,
+        state,
+        stop: () => new Promise((resolve) => server.close(() => resolve())),
+    };
+}