sliftutils 1.0.2 → 1.1.0

package/misc/https/dist/dns.ts.cache

@@ -0,0 +1,166 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule && mod.default) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.addRecord = exports.setRecord = exports.deleteRecord = exports.getRecords = exports.getRecordsRaw = void 0;
+const https_1 = require("socket-function/src/https");
+const caching_1 = require("socket-function/src/caching");
+const fs_1 = __importDefault(require("fs"));
+const batching_1 = require("socket-function/src/batching");
+const SocketFunction_1 = require("socket-function/SocketFunction");
+const DNS_TTLSeconds = {
+    "TXT": 60,
+    "A": 60,
+};
+const getZoneId = (0, caching_1.cache)(async (rootDomain) => {
+    let zones = await cloudflareGETCall("/zones", {});
+    let selected = zones.find(x => x.name === rootDomain);
+    if (!selected) {
+        throw new Error(`Could not find zone for ${rootDomain}. Found ${zones.map(x => x.name).join(", ")}`);
+    }
+    return selected.id;
+});
+function getRootDomain(key) {
+    if (key.endsWith(".")) {
+        key = key.slice(0, -1);
+    }
+    return key.split(".").slice(-2).join(".");
+}
+async function getRecordsRaw(type, key) {
+    if (key.endsWith("."))
+        key = key.slice(0, -1);
+    let zoneId = await getZoneId(getRootDomain(key));
+    let results = await cloudflareGETCall(`/zones/${zoneId}/dns_records`);
+    return results.filter(x => x.type === type && x.name === key);
+}
+exports.getRecordsRaw = getRecordsRaw;
+async function getRecords(type, key) {
+    if (key.endsWith("."))
+        key = key.slice(0, -1);
+    let raw = await getRecordsRaw(type, key);
+    return raw.map(x => x.content);
+}
+exports.getRecords = getRecords;
+async function deleteRecord(type, key, value) {
+    if (key.endsWith("."))
+        key = key.slice(0, -1);
+    let zoneId = await getZoneId(getRootDomain(key));
+    let prevValues = await getRecordsRaw(type, key);
+    prevValues = prevValues.filter(x => x.content === value);
+    if (prevValues.length === 0) {
+        if (!SocketFunction_1.SocketFunction.silent) {
+            console.log(`No need to delete record, it was not found. ${JSON.stringify(value)} value was not in ${type} for ${key}, values ${JSON.stringify(prevValues.map(x => x.content))}`);
+        }
+        return;
+    }
+    console.log(`Removing records of ${type} for ${key}, values ${JSON.stringify(prevValues.map(x => x.content))}`);
+    for (let value of prevValues) {
+        await cloudflareCall(`/zones/${zoneId}/dns_records/${value.id}`, Buffer.from([]), "DELETE");
+    }
+}
+exports.deleteRecord = deleteRecord;
+/** Removes all existing records (unless the record is already present) */
+async function setRecord(type, key, value, proxied) {
+    let stack = new Error();
+    if (key.endsWith("."))
+        key = key.slice(0, -1);
+    let zoneId = await getZoneId(getRootDomain(key));
+    let prevValues = await getRecordsRaw(type, key);
+    // NOTE: Apparently if we try to update by just changing proxied, cloudflare complains and
+    //  says "an identical record already exists", even though it doesn't, we changed the proxied value...
+    if (prevValues.some(x => x.content === value))
+        return;
+    console.log(`Removing previous records of ${type} for ${key} ${JSON.stringify(prevValues.map(x => x.content))}`);
+    let didDeletions = false;
+    for (let value of prevValues) {
+        didDeletions = true;
+        await cloudflareCall(`/zones/${zoneId}/dns_records/${value.id}`, Buffer.from([]), "DELETE");
+    }
+    console.log(`Setting ${type} record for ${key} to ${value} (previously had ${JSON.stringify(prevValues.map(x => x.content))})`);
+    const ttl = DNS_TTLSeconds[type] || 60;
+    await cloudflarePOSTCall(`/zones/${zoneId}/dns_records`, {
+        type: type,
+        name: key,
+        content: value,
+        ttl,
+        proxied: proxied === "proxied",
+    });
+    // NOTE: Apparently... even if the record didn't exist, we still have to wait...
+    console.log(`Waiting ${ttl} seconds for DNS to propagate...`);
+    await (0, batching_1.delay)(ttl * 1000);
+    console.log(`Done waiting for DNS to update.`);
+}
+exports.setRecord = setRecord;
+/** Keeps existing records */
+async function addRecord(type, key, value, proxied) {
+    if (key.endsWith("."))
+        key = key.slice(0, -1);
+    let zoneId = await getZoneId(getRootDomain(key));
+    let prevValues = await getRecordsRaw(type, key);
+    // NOTE: Apparently if we try to update by just changing proxied, cloudflare complains and
+    //  says "an identical record already exists", even though it doesn't, we changed the proxied value...
+    if (prevValues.some(x => x.content === value))
+        return;
+    console.log(`Adding ${type} record for ${key} to ${value} (previously had ${JSON.stringify(prevValues.map(x => x.content))})`);
+    const ttl = DNS_TTLSeconds[type] || 60;
+    await cloudflarePOSTCall(`/zones/${zoneId}/dns_records`, {
+        type: type,
+        name: key,
+        content: value,
+        ttl,
+        proxied: proxied === "proxied",
+    });
+    console.log(`Waiting ${ttl} seconds for DNS to propagate...`);
+    await (0, batching_1.delay)(ttl * 1000);
+    console.log(`Done waiting for DNS to update.`);
+}
+exports.addRecord = addRecord;
+const getCloudflareCreds = (0, caching_1.lazy)(async () => {
+    const path = "cloudflare.json";
+    if (!fs_1.default.existsSync(path)) {
+        throw new Error(`Must add cloudflare.json file to root of project.`);
+    }
+    let creds = JSON.parse(fs_1.default.readFileSync(path, "utf8"));
+    return {
+        key: creds.key,
+    };
+});
+async function cloudflareGETCall(path, params) {
+    let url = new URL(`https://api.cloudflare.com/client/v4` + path);
+    for (let key in params) {
+        url.searchParams.set(key, params[key]);
+    }
+    let creds = await getCloudflareCreds();
+    let result = await (0, https_1.httpsRequest)(url.toString(), [], "GET", undefined, {
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${creds.key}`,
+        }
+    });
+    let result2 = JSON.parse(result.toString());
+    if (!result2.success) {
+        throw new Error(`Cloudflare call failed: ${result2.errors.map(x => x.message).join(", ")}`);
+    }
+    return result2.result;
+}
+async function cloudflarePOSTCall(path, params) {
+    return await cloudflareCall(path, Buffer.from(JSON.stringify(params)), "POST");
+}
+async function cloudflareCall(path, payload, method) {
+    let url = new URL(`https://api.cloudflare.com/client/v4` + path);
+    let creds = await getCloudflareCreds();
+    let result = await (0, https_1.httpsRequest)(url.toString(), payload, method, undefined, {
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${creds.key}`,
+        }
+    });
+    let result2 = JSON.parse(result.toString());
+    if (!result2.success) {
+        throw new Error(`Cloudflare call failed: ${result2.errors.map(x => x.message).join(", ")}`);
+    }
+    return result2.result;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dns.js","sourceRoot":"","sources":["dns.ts"],"names":[],"mappings":";;;;;;AAAA,qDAAyD;AACzD,yDAA0D;AAC1D,4CAAoB;AACpB,2DAAqD;AACrD,mEAAgE;AAEhE,MAAM,cAAc,GAAG;IACnB,KAAK,EAAE,EAAE;IACT,GAAG,EAAE,EAAE;CACV,CAAC;AAEF,MAAM,SAAS,GAAG,IAAA,eAAK,EAAC,KAAK,EAAE,UAAkB,EAAmB,EAAE;IAClE,IAAI,KAAK,GAAG,MAAM,iBAAiB,CAAiC,QAAQ,EAAE,EAAE,CAAC,CAAC;IAClF,IAAI,QAAQ,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,UAAU,CAAC,CAAC;IACtD,IAAI,CAAC,QAAQ,EAAE,CAAC;QACZ,MAAM,IAAI,KAAK,CAAC,2BAA2B,UAAU,WAAW,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACzG,CAAC;IACD,OAAO,QAAQ,CAAC,EAAE,CAAC;AACvB,CAAC,CAAC,CAAC;AAEH,SAAS,aAAa,CAAC,GAAW;IAC9B,IAAI,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;QACpB,GAAG,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAC3B,CAAC;IACD,OAAO,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAC9C,CAAC;AAEM,KAAK,UAAU,aAAa,CAAC,IAAY,EAAE,GAAW;IACzD,IAAI,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC;QAAE,GAAG,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAC9C,IAAI,MAAM,GAAG,MAAM,SAAS,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC;IACjD,IAAI,OAAO,GAAG,MAAM,iBAAiB,CAMhC,UAAU,MAAM,cAAc,CAAC,CAAC;IACrC,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,IAAI,CAAC,CAAC,IAAI,KAAK,GAAG,CAAC,CAAC;AAClE,CAAC;AAXD,sCAWC;AACM,KAAK,UAAU,UAAU,CAAC,IAAY,EAAE,GAAW;IACtD,IAAI,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC;QAAE,GAAG,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAC9C,IAAI,GAAG,GAAG,MAAM,aAAa,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;IACzC,OAAO,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;AACnC,CAAC;AAJD,gCAIC;AACM,KAAK,UAAU,YAAY,CAAC,IAAY,EAAE,GAAW,EAAE,KAAa;IACvE,IAAI,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC;QAAE,GAAG,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAC9C,IAAI,MAAM,GAAG,MAAM,SAAS,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC;IACjD,IAAI,UAAU,GAAG,MAAM,aAAa,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;IAChD,UAAU,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,KAAK,CAAC,CAAC;IACzD,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC1B,IAAI,CAAC,+BAAc,CAAC,MAAM,EAAE,CAAC;YACzB,OAAO,CAAC,GAAG,CAAC,+CAA+C,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,qBAAqB,IAAI,QAAQ,GAAG,YAAY,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC;QACtL,CAAC;QACD,OAAO;IACX,CAAC;IAED,OAAO,CAAC,GAAG,CAAC,uBAAuB,IAAI,QAAQ,GAAG,YAAY,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC;IAChH,KAAK,IAAI,KAAK,IAAI,UAAU,EAAE,CAAC;QAC3B,MAAM,cAAc,CAAC,UAAU,MAAM,gBAAgB,KAAK,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,CAAC;IAChG,CAAC;AACL,CAAC;AAhBD,oCAgBC;AACD,0EAA0E;AACnE,KAAK,UAAU,SAAS,CAAC,IAAY,EAAE,GAAW,EAAE,KAAa,EAAE,OAAmB;IACzF,IAAI,KAAK,GAAG,IAAI,KAAK,EAAE,CAAC;IACxB,IAAI,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC;QAAE,GAAG,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAC9C,IAAI,MAAM,GAAG,MAAM,SAAS,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC;IACjD,IAAI,UAAU,GAAG,MAAM,aAAa,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;IAChD,0FAA0F;IAC1F,sGAAsG;IACtG,IAAI,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,KAAK,CAAC;QAAE,OAAO;IAEtD,OAAO,CAAC,GAAG,CAAC,gCAAgC,IAAI,QAAQ,GAAG,IAAI,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC;IACjH,IAAI,YAAY,GAAG,KAAK,CAAC;IACzB,KAAK,IAAI,KAAK,IAAI,UAAU,EAAE,CAAC;QAC3B,YAAY,GAAG,IAAI,CAAC;QACpB,MAAM,cAAc,CAAC,UAAU,MAAM,gBAAgB,KAAK,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,CAAC;IAChG,CAAC;IAED,OAAO,CAAC,GAAG,CAAC,WAAW,IAAI,eAAe,GAAG,OAAO,KAAK,oBAAoB,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC;IAChI,MAAM,GAAG,GAAG,cAAc,CAAC,IAAW,CAAC,IAAI,EAAE,CAAC;IAC9C,MAAM,kBAAkB,CAAC,UAAU,MAAM,cAAc,EAAE;QACrD,IAAI,EAAE,IAAI;QACV,IAAI,EAAE,GAAG;QACT,OAAO,EAAE,KAAK;QACd,GAAG;QACH,OAAO,EAAE,OAAO,KAAK,SAAS;KACjC,CAAC,CAAC;IACH,gFAAgF;IAChF,OAAO,CAAC,GAAG,CAAC,WAAW,GAAG,kCAAkC,CAAC,CAAC;IAC9D,MAAM,IAAA,gBAAK,EAAC,GAAG,GAAG,IAAI,CAAC,CAAC;IACxB,OAAO,CAAC,GAAG,CAAC,iCAAiC,CAAC,CAAC;AAEnD,CAAC;AA9BD,8BA8BC;AACD,6BAA6B;AACtB,KAAK,UAAU,SAAS,CAAC,IAAY,EAAE,GAAW,EAAE,KAAa,EAAE,OAAmB;IACzF,IAAI,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC;QAAE,GAAG,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAC9C,IAAI,MAAM,GAAG,MAAM,SAAS,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC;IACjD,IAAI,UAAU,GAAG,MAAM,aAAa,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;IAChD,0FAA0F;IAC1F,sGAAsG;IACtG,IAAI,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,KAAK,CAAC;QAAE,OAAO;IACtD,OAAO,CAAC,GAAG,CAAC,UAAU,IAAI,eAAe,GAAG,OAAO,KAAK,oBAAoB,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC;IAC/H,MAAM,GAAG,GAAG,cAAc,CAAC,IAAW,CAAC,IAAI,EAAE,CAAC;IAC9C,MAAM,kBAAkB,CAAC,UAAU,MAAM,cAAc,EAAE;QACrD,IAAI,EAAE,IAAI;QACV,IAAI,EAAE,GAAG;QACT,OAAO,EAAE,KAAK;QACd,GAAG;QACH,OAAO,EAAE,OAAO,KAAK,SAAS;KACjC,CAAC,CAAC;IACH,OAAO,CAAC,GAAG,CAAC,WAAW,GAAG,kCAAkC,CAAC,CAAC;IAC9D,MAAM,IAAA,gBAAK,EAAC,GAAG,GAAG,IAAI,CAAC,CAAC;IACxB,OAAO,CAAC,GAAG,CAAC,iCAAiC,CAAC,CAAC;AACnD,CAAC;AAnBD,8BAmBC;AAGD,MAAM,kBAAkB,GAAG,IAAA,cAAI,EAAC,KAAK,IAA+B,EAAE;IAClE,MAAM,IAAI,GAAG,iBAAiB,CAAC;IAC/B,IAAI,CAAC,YAAE,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;QACvB,MAAM,IAAI,KAAK,CAAC,mDAAmD,CAAC,CAAC;IACzE,CAAC;IACD,IAAI,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,YAAE,CAAC,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,CAAqB,CAAC;IAC1E,OAAO;QACH,GAAG,EAAE,KAAK,CAAC,GAAG;KACjB,CAAC;AACN,CAAC,CAAC,CAAC;AAEH,KAAK,UAAU,iBAAiB,CAAI,IAAY,EAAE,MAAkC;IAChF,IAAI,GAAG,GAAG,IAAI,GAAG,CAAC,sCAAsC,GAAG,IAAI,CAAC,CAAC;IACjE,KAAK,IAAI,GAAG,IAAI,MAAM,EAAE,CAAC;QACrB,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;IAC3C,CAAC;IACD,IAAI,KAAK,GAAG,MAAM,kBAAkB,EAAE,CAAC;IACvC,IAAI,MAAM,GAAG,MAAM,IAAA,oBAAY,EAAC,GAAG,CAAC,QAAQ,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE;QAClE,OAAO,EAAE;YACL,cAAc,EAAE,kBAAkB;YAClC,eAAe,EAAE,UAAU,KAAK,CAAC,GAAG,EAAE;SACzC;KACJ,CAAC,CAAC;IACH,IAAI,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAuF,CAAC;IAClI,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;QACnB,MAAM,IAAI,KAAK,CAAC,2BAA2B,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAChG,CAAC;IACD,OAAO,OAAO,CAAC,MAAW,CAAC;AAC/B,CAAC;AACD,KAAK,UAAU,kBAAkB,CAAI,IAAY,EAAE,MAAkC;IACjF,OAAO,MAAM,cAAc,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;AACnF,CAAC;AACD,KAAK,UAAU,cAAc,CAAI,IAAY,EAAE,OAAe,EAAE,MAAc;IAC1E,IAAI,GAAG,GAAG,IAAI,GAAG,CAAC,sCAAsC,GAAG,IAAI,CAAC,CAAC;IACjE,IAAI,KAAK,GAAG,MAAM,kBAAkB,EAAE,CAAC;IACvC,IAAI,MAAM,GAAG,MAAM,IAAA,oBAAY,EAAC,GAAG,CAAC,QAAQ,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE;QACxE,OAAO,EAAE;YACL,cAAc,EAAE,kBAAkB;YAClC,eAAe,EAAE,UAAU,KAAK,CAAC,GAAG,EAAE;SACzC;KACJ,CAAC,CAAC;IACH,IAAI,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAuF,CAAC;IAClI,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;QACnB,MAAM,IAAI,KAAK,CAAC,2BAA2B,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAChG,CAAC;IACD,OAAO,OAAO,CAAC,MAAW,CAAC;AAC/B,CAAC","sourcesContent":["import { httpsRequest } from \"socket-function/src/https\";\nimport { cache, lazy } from \"socket-function/src/caching\";\nimport fs from \"fs\";\nimport { delay } from \"socket-function/src/batching\";\nimport { SocketFunction } from \"socket-function/SocketFunction\";\n\nconst DNS_TTLSeconds = {\n    \"TXT\": 60,\n    \"A\": 60,\n};\n\nconst getZoneId = cache(async (rootDomain: string): Promise<string> => {\n    let zones = await cloudflareGETCall<{ id: string; name: string }[]>(\"/zones\", {});\n    let selected = zones.find(x => x.name === rootDomain);\n    if (!selected) {\n        throw new Error(`Could not find zone for ${rootDomain}. Found ${zones.map(x => x.name).join(\", \")}`);\n    }\n    return selected.id;\n});\n\nfunction getRootDomain(key: string) {\n    if (key.endsWith(\".\")) {\n        key = key.slice(0, -1);\n    }\n    return key.split(\".\").slice(-2).join(\".\");\n}\n\nexport async function getRecordsRaw(type: string, key: string) {\n    if (key.endsWith(\".\")) key = key.slice(0, -1);\n    let zoneId = await getZoneId(getRootDomain(key));\n    let results = await cloudflareGETCall<{\n        id: string;\n        type: string;\n        name: string;\n        content: string;\n        proxied: boolean;\n    }[]>(`/zones/${zoneId}/dns_records`);\n    return results.filter(x => x.type === type && x.name === key);\n}\nexport async function getRecords(type: string, key: string) {\n    if (key.endsWith(\".\")) key = key.slice(0, -1);\n    let raw = await getRecordsRaw(type, key);\n    return raw.map(x => x.content);\n}\nexport async function deleteRecord(type: string, key: string, value: string) {\n    if (key.endsWith(\".\")) key = key.slice(0, -1);\n    let zoneId = await getZoneId(getRootDomain(key));\n    let prevValues = await getRecordsRaw(type, key);\n    prevValues = prevValues.filter(x => x.content === value);\n    if (prevValues.length === 0) {\n        if (!SocketFunction.silent) {\n            console.log(`No need to delete record, it was not found. ${JSON.stringify(value)} value was not in ${type} for ${key}, values ${JSON.stringify(prevValues.map(x => x.content))}`);\n        }\n        return;\n    }\n\n    console.log(`Removing records of ${type} for ${key}, values ${JSON.stringify(prevValues.map(x => x.content))}`);\n    for (let value of prevValues) {\n        await cloudflareCall(`/zones/${zoneId}/dns_records/${value.id}`, Buffer.from([]), \"DELETE\");\n    }\n}\n/** Removes all existing records (unless the record is already present) */\nexport async function setRecord(type: string, key: string, value: string, proxied?: \"proxied\") {\n    let stack = new Error();\n    if (key.endsWith(\".\")) key = key.slice(0, -1);\n    let zoneId = await getZoneId(getRootDomain(key));\n    let prevValues = await getRecordsRaw(type, key);\n    // NOTE: Apparently if we try to update by just changing proxied, cloudflare complains and\n    //  says \"an identical record already exists\", even though it doesn't, we changed the proxied value...\n    if (prevValues.some(x => x.content === value)) return;\n\n    console.log(`Removing previous records of ${type} for ${key} ${JSON.stringify(prevValues.map(x => x.content))}`);\n    let didDeletions = false;\n    for (let value of prevValues) {\n        didDeletions = true;\n        await cloudflareCall(`/zones/${zoneId}/dns_records/${value.id}`, Buffer.from([]), \"DELETE\");\n    }\n\n    console.log(`Setting ${type} record for ${key} to ${value} (previously had ${JSON.stringify(prevValues.map(x => x.content))})`);\n    const ttl = DNS_TTLSeconds[type as \"A\"] || 60;\n    await cloudflarePOSTCall(`/zones/${zoneId}/dns_records`, {\n        type: type,\n        name: key,\n        content: value,\n        ttl,\n        proxied: proxied === \"proxied\",\n    });\n    // NOTE: Apparently... even if the record didn't exist, we still have to wait...\n    console.log(`Waiting ${ttl} seconds for DNS to propagate...`);\n    await delay(ttl * 1000);\n    console.log(`Done waiting for DNS to update.`);\n\n}\n/** Keeps existing records */\nexport async function addRecord(type: string, key: string, value: string, proxied?: \"proxied\") {\n    if (key.endsWith(\".\")) key = key.slice(0, -1);\n    let zoneId = await getZoneId(getRootDomain(key));\n    let prevValues = await getRecordsRaw(type, key);\n    // NOTE: Apparently if we try to update by just changing proxied, cloudflare complains and\n    //  says \"an identical record already exists\", even though it doesn't, we changed the proxied value...\n    if (prevValues.some(x => x.content === value)) return;\n    console.log(`Adding ${type} record for ${key} to ${value} (previously had ${JSON.stringify(prevValues.map(x => x.content))})`);\n    const ttl = DNS_TTLSeconds[type as \"A\"] || 60;\n    await cloudflarePOSTCall(`/zones/${zoneId}/dns_records`, {\n        type: type,\n        name: key,\n        content: value,\n        ttl,\n        proxied: proxied === \"proxied\",\n    });\n    console.log(`Waiting ${ttl} seconds for DNS to propagate...`);\n    await delay(ttl * 1000);\n    console.log(`Done waiting for DNS to update.`);\n}\n\n\nconst getCloudflareCreds = lazy(async (): Promise<{ key: string; }> => {\n    const path = \"cloudflare.json\";\n    if (!fs.existsSync(path)) {\n        throw new Error(`Must add cloudflare.json file to root of project.`);\n    }\n    let creds = JSON.parse(fs.readFileSync(path, \"utf8\")) as { key: string; };\n    return {\n        key: creds.key,\n    };\n});\n\nasync function cloudflareGETCall<T>(path: string, params?: { [key: string]: string }): Promise<T> {\n    let url = new URL(`https://api.cloudflare.com/client/v4` + path);\n    for (let key in params) {\n        url.searchParams.set(key, params[key]);\n    }\n    let creds = await getCloudflareCreds();\n    let result = await httpsRequest(url.toString(), [], \"GET\", undefined, {\n        headers: {\n            \"Content-Type\": \"application/json\",\n            \"Authorization\": `Bearer ${creds.key}`,\n        }\n    });\n    let result2 = JSON.parse(result.toString()) as { result: unknown; success: boolean; errors: { code: number; message: string }[] };\n    if (!result2.success) {\n        throw new Error(`Cloudflare call failed: ${result2.errors.map(x => x.message).join(\", \")}`);\n    }\n    return result2.result as T;\n}\nasync function cloudflarePOSTCall<T>(path: string, params: { [key: string]: unknown }): Promise<T> {\n    return await cloudflareCall(path, Buffer.from(JSON.stringify(params)), \"POST\");\n}\nasync function cloudflareCall<T>(path: string, payload: Buffer, method: string): Promise<T> {\n    let url = new URL(`https://api.cloudflare.com/client/v4` + path);\n    let creds = await getCloudflareCreds();\n    let result = await httpsRequest(url.toString(), payload, method, undefined, {\n        headers: {\n            \"Content-Type\": \"application/json\",\n            \"Authorization\": `Bearer ${creds.key}`,\n        }\n    });\n    let result2 = JSON.parse(result.toString()) as { result: unknown; success: boolean; errors: { code: number; message: string }[] };\n    if (!result2.success) {\n        throw new Error(`Cloudflare call failed: ${result2.errors.map(x => x.message).join(\", \")}`);\n    }\n    return result2.result as T;\n}"]}
+ /* _JS_SOURCE_HASH = "23ba5542e3de4342e75c1b8db86679523e53f9535c85e9f1b8abd80af92a917c"; */

package/misc/https/dist/httpsCerts.ts.cache

@@ -0,0 +1,181 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule && mod.default) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+exports.getHTTPSCert = void 0;
+const dns_1 = require("./dns");
+const caching_1 = require("socket-function/src/caching");
+const forge = __importStar(require("node-forge"));
+const acme_client_1 = __importDefault(require("acme-client"));
+const logColors_1 = require("socket-function/src/formatting/logColors");
+const format_1 = require("socket-function/src/formatting/format");
+const misc_1 = require("socket-function/src/misc");
+const batching_1 = require("socket-function/src/batching");
+const fs_1 = __importDefault(require("fs"));
+const persistentLocalStorage_1 = require("./persistentLocalStorage");
+// Expire EXPIRATION_THRESHOLD% of the way through the certificate's lifetime
+const EXPIRATION_THRESHOLD = 0.4;
+/** NOTE: We also generate the domain *.domain */
+exports.getHTTPSCert = (0, caching_1.cache)(async (domain) => {
+    if (!domain.endsWith(".")) {
+        domain = domain + ".";
+    }
+    let keyCert;
+    let path = domain + ".cert";
+    try {
+        keyCert = JSON.parse(fs_1.default.readFileSync(path, "utf8"));
+    }
+    catch (_a) { }
+    if (keyCert) {
+        // If 40% of the lifetime has passed, renew it (has to be < the threshold
+        //  in EdgeCertController).
+        let certObj = parseCert(keyCert.cert);
+        let expirationTime = +new Date(certObj.validity.notAfter);
+        let createTime = +new Date(certObj.validity.notBefore);
+        let renewDate = createTime + (expirationTime - createTime) * EXPIRATION_THRESHOLD;
+        if (renewDate < Date.now()) {
+            console.log((0, logColors_1.magenta)(`Renewing domain ${domain} (renew target is ${(0, format_1.formatDateTime)(renewDate)}).`));
+            keyCert = undefined;
+        }
+    }
+    else {
+        console.log((0, logColors_1.magenta)(`No cert found for domain ${domain}, generating shortly.`));
+    }
+    if (keyCert) {
+        return keyCert;
+    }
+    const accountKey = await getAccountKey(domain);
+    let altDomains = [];
+    // altDomains.push("noproxy." + domain);
+    // // NOTE: Allowing local access is just an optimization, not to avoid having to forward ports
+    // //  (unless you type 127-0-0-1.domain into the browser... then I guess you don't have to forward ports?)
+    // altDomains.push("127-0-0-1." + domain);
+    // NOTE: I forget why we were not allowing wildcard domains. I think it was to prevent
+    //  any HTTPS domains from impersonating servers. But... servers have two levels, so that isn't
+    //  an issue. And even if they didn't they store their public key in their domain, so you
+    //  can't really impersonate them anyways...
+    //  - AND, we need this for IP type A records, which... we need to pick the server we want
+    //      to connect to.
+    altDomains.push("*." + domain);
+    try {
+        keyCert = await generateCert({ accountKey, domain, altDomains });
+    }
+    catch (e) {
+        if (String(e).includes("authorization must be pending")) {
+            console.log(`Authorization appears to be pending, waiting 2 minutes for other process to create certificate`);
+            await (0, batching_1.delay)(misc_1.timeInMinute * 2);
+            return await (0, exports.getHTTPSCert)(domain);
+        }
+        throw e;
+    }
+    await fs_1.default.promises.writeFile(path, JSON.stringify(keyCert));
+    return keyCert;
+});
+const getAccountKey = async function getAccountKey(domain) {
+    let accountKey = (0, persistentLocalStorage_1.getKeyStore)(domain, "letsEncryptAccountKey");
+    let secret = await accountKey.get();
+    if (!secret) {
+        // Should only HAPPEN ONCE, EVER!
+        console.error((0, logColors_1.red)(`Generating new letsencrypt account key`));
+        const keyPair = forge.pki.rsa.generateKeyPair();
+        secret = forge.pki.privateKeyToPem(keyPair.privateKey);
+        await accountKey.set(secret);
+    }
+    return secret;
+};
+function parseCert(PEMorDER) {
+    return forge.pki.certificateFromPem(normalizeCertToPEM(PEMorDER));
+}
+function normalizeCertToPEM(PEMorDER) {
+    if (PEMorDER.toString().startsWith("-----BEGIN CERTIFICATE-----")) {
+        return PEMorDER.toString();
+    }
+    PEMorDER = PEMorDER.toString("base64");
+    return "-----BEGIN CERTIFICATE-----\n" + PEMorDER + "\n-----END CERTIFICATE-----";
+}
+async function generateCert(config) {
+    let { accountKey, domain } = config;
+    console.log((0, logColors_1.magenta)(`Generating new cert for ${domain}`));
+    let domainList = [domain, ...config.altDomains || []];
+    // Strip trailing "."
+    domainList = domainList.map(x => x.endsWith(".") ? x.slice(0, -1) : x);
+    const [certificateKey, certificateCsr] = await acme_client_1.default.forge.createCsr({
+        commonName: domainList[0],
+        altNames: domainList.slice(1),
+    });
+    // So... acme-client is fine. Just re-implement the "auto" mode ourselves, to have more control over it.
+    const client = new acme_client_1.default.Client({
+        directoryUrl: acme_client_1.default.directory.letsencrypt.production,
+        accountKey: accountKey,
+    });
+    const accountPayload = {
+        termsOfServiceAgreed: true,
+        contact: [`mailto:devops@perspectanalytics.com`],
+    };
+    try {
+        await client.getAccountUrl();
+    }
+    catch (_a) {
+        await client.createAccount(accountPayload);
+    }
+    const orderPayload = {
+        identifiers: domainList.map(domain => ({ type: "dns", value: domain })),
+    };
+    const order = await client.createOrder(orderPayload);
+    const authorizations = await client.getAuthorizations(order);
+    console.log(`Starting authorizations: ${JSON.stringify(authorizations)}`);
+    for (let auth of authorizations) {
+        if (auth.status === "valid") {
+            console.log(`Authorization already valid for ${auth.identifier.value}`);
+            continue;
+        }
+        console.log(`Starting authorization for ${JSON.stringify(auth)}`);
+        // Only use DNS authorization
+        let challenge = auth.challenges.find(x => x.type === "dns-01");
+        if (!challenge) {
+            throw new Error("No DNS challenge found");
+        }
+        const keyAuthorization = await client.getChallengeKeyAuthorization(challenge);
+        let hostname = auth.identifier.value;
+        let challengeRecordName = "_acme-challenge." + hostname + ".";
+        await (0, dns_1.setRecord)("TXT", challengeRecordName, keyAuthorization);
+        await client.completeChallenge(challenge);
+        console.log(`Challenge completed`);
+        await client.waitForValidStatus(challenge);
+        console.log(`Status of order is valid`);
+    }
+    const finalized = await client.finalizeOrder(order, certificateCsr);
+    console.log(`Order finalized`);
+    let cert = await client.getCertificate(finalized);
+    return {
+        domains: domainList,
+        key: certificateKey.toString(),
+        cert: cert,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"httpsCerts.js","sourceRoot":"","sources":["httpsCerts.ts"],"names":[],"mappings":"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","sourcesContent":["\nimport { addRecord, deleteRecord, getRecords, setRecord } from \"./dns\";\nimport { cache, lazy } from \"socket-function/src/caching\";\nimport * as forge from \"node-forge\";\nimport acme from \"acme-client\";\nimport { magenta, red } from \"socket-function/src/formatting/logColors\";\nimport { formatDateTime, formatTime } from \"socket-function/src/formatting/format\";\nimport { timeInMinute } from \"socket-function/src/misc\";\nimport { delay } from \"socket-function/src/batching\";\nimport fs from \"fs\";\nimport { getKeyStore } from \"./persistentLocalStorage\";\n\n\n// Expire EXPIRATION_THRESHOLD% of the way through the certificate's lifetime\nconst EXPIRATION_THRESHOLD = 0.4;\n\n/** NOTE: We also generate the domain *.domain */\nexport const getHTTPSCert = cache(async (domain: string): Promise<{ key: string; cert: string }> => {\n    if (!domain.endsWith(\".\")) {\n        domain = domain + \".\";\n    }\n    let keyCert: { key: string; cert: string } | undefined;\n    let path = domain + \".cert\";\n\n    try {\n        keyCert = JSON.parse(fs.readFileSync(path, \"utf8\")) as { key: string; cert: string };\n    } catch { }\n    if (keyCert) {\n        // If 40% of the lifetime has passed, renew it (has to be < the threshold\n        //  in EdgeCertController).\n        let certObj = parseCert(keyCert.cert);\n        let expirationTime = +new Date(certObj.validity.notAfter);\n        let createTime = +new Date(certObj.validity.notBefore);\n        let renewDate = createTime + (expirationTime - createTime) * EXPIRATION_THRESHOLD;\n        if (renewDate < Date.now()) {\n            console.log(magenta(`Renewing domain ${domain} (renew target is ${formatDateTime(renewDate)}).`));\n            keyCert = undefined;\n        }\n    } else {\n        console.log(magenta(`No cert found for domain ${domain}, generating shortly.`));\n    }\n    if (keyCert) {\n        return keyCert;\n    }\n\n    const accountKey = await getAccountKey(domain);\n    let altDomains: string[] = [];\n\n    // altDomains.push(\"noproxy.\" + domain);\n    // // NOTE: Allowing local access is just an optimization, not to avoid having to forward ports\n    // //  (unless you type 127-0-0-1.domain into the browser... then I guess you don't have to forward ports?)\n    // altDomains.push(\"127-0-0-1.\" + domain);\n\n    // NOTE: I forget why we were not allowing wildcard domains. I think it was to prevent\n    //  any HTTPS domains from impersonating servers. But... servers have two levels, so that isn't\n    //  an issue. And even if they didn't they store their public key in their domain, so you\n    //  can't really impersonate them anyways...\n    //  - AND, we need this for IP type A records, which... we need to pick the server we want\n    //      to connect to.\n    altDomains.push(\"*.\" + domain);\n\n    try {\n        keyCert = await generateCert({ accountKey, domain, altDomains });\n    } catch (e) {\n        if (String(e).includes(\"authorization must be pending\")) {\n            console.log(`Authorization appears to be pending, waiting 2 minutes for other process to create certificate`);\n            await delay(timeInMinute * 2);\n            return await getHTTPSCert(domain);\n        }\n        throw e;\n    }\n    await fs.promises.writeFile(path, JSON.stringify(keyCert));\n    return keyCert;\n});\n\n\nconst getAccountKey = async function getAccountKey(domain: string) {\n    let accountKey = getKeyStore<string>(domain, \"letsEncryptAccountKey\");\n    let secret = await accountKey.get();\n    if (!secret) {\n        // Should only HAPPEN ONCE, EVER!\n        console.error(red(`Generating new letsencrypt account key`));\n        const keyPair = forge.pki.rsa.generateKeyPair();\n        secret = forge.pki.privateKeyToPem(keyPair.privateKey);\n        await accountKey.set(secret);\n    }\n    return secret;\n};\n\n\nfunction parseCert(PEMorDER: string | Buffer) {\n    return forge.pki.certificateFromPem(normalizeCertToPEM(PEMorDER));\n}\n\nfunction normalizeCertToPEM(PEMorDER: string | Buffer): string {\n    if (PEMorDER.toString().startsWith(\"-----BEGIN CERTIFICATE-----\")) {\n        return PEMorDER.toString();\n    }\n    PEMorDER = PEMorDER.toString(\"base64\");\n    return \"-----BEGIN CERTIFICATE-----\\n\" + PEMorDER + \"\\n-----END CERTIFICATE-----\";\n}\n\n\nasync function generateCert(config: {\n    accountKey: string;\n    domain: string;\n    altDomains?: string[];\n}): Promise<{\n    domains: string[];\n    key: string;\n    cert: string;\n}> {\n    let { accountKey, domain } = config;\n\n    console.log(magenta(`Generating new cert for ${domain}`));\n\n    let domainList = [domain, ...config.altDomains || []];\n    // Strip trailing \".\"\n    domainList = domainList.map(x => x.endsWith(\".\") ? x.slice(0, -1) : x);\n\n    const [certificateKey, certificateCsr] = await acme.forge.createCsr({\n        commonName: domainList[0],\n        altNames: domainList.slice(1),\n    });\n\n    // So... acme-client is fine. Just re-implement the \"auto\" mode ourselves, to have more control over it.\n    const client = new acme.Client({\n        directoryUrl: acme.directory.letsencrypt.production,\n        accountKey: accountKey,\n    });\n\n    const accountPayload = {\n        termsOfServiceAgreed: true,\n        contact: [`mailto:devops@perspectanalytics.com`],\n    };\n\n    try {\n        await client.getAccountUrl();\n    } catch {\n        await client.createAccount(accountPayload);\n    }\n\n    const orderPayload = {\n        identifiers: domainList.map(domain => ({ type: \"dns\", value: domain })),\n    };\n    const order = await client.createOrder(orderPayload);\n    const authorizations = await client.getAuthorizations(order);\n    console.log(`Starting authorizations: ${JSON.stringify(authorizations)}`);\n\n    for (let auth of authorizations) {\n        if (auth.status === \"valid\") {\n            console.log(`Authorization already valid for ${auth.identifier.value}`);\n            continue;\n        }\n        console.log(`Starting authorization for ${JSON.stringify(auth)}`);\n\n        // Only use DNS authorization\n        let challenge = auth.challenges.find(x => x.type === \"dns-01\");\n        if (!challenge) {\n            throw new Error(\"No DNS challenge found\");\n        }\n        const keyAuthorization = await client.getChallengeKeyAuthorization(challenge);\n\n        let hostname = auth.identifier.value;\n        let challengeRecordName = \"_acme-challenge.\" + hostname + \".\";\n        await setRecord(\"TXT\", challengeRecordName, keyAuthorization);\n\n        await client.completeChallenge(challenge);\n        console.log(`Challenge completed`);\n\n        await client.waitForValidStatus(challenge);\n        console.log(`Status of order is valid`);\n    }\n\n    const finalized = await client.finalizeOrder(order, certificateCsr);\n    console.log(`Order finalized`);\n\n    let cert = await client.getCertificate(finalized);\n    return {\n        domains: domainList,\n        key: certificateKey.toString(),\n        cert: cert,\n    };\n}\n"]}
+ /* _JS_SOURCE_HASH = "4d56068f29ee3700832b43eb0cee884139d4fe1f48558129ee9da54ea1825056"; */

package/misc/https/dist/persistentLocalStorage.ts.cache

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule && mod.default) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.getKeyStore = void 0;
+const misc_1 = require("socket-function/src/misc");
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+function getKeyStore(appName, key) {
+    if ((0, misc_1.isNode)()) {
+        let path = os_1.default.homedir() + `/keystore_${appName}_` + key + ".json";
+        return {
+            get() {
+                let contents = undefined;
+                try {
+                    contents = fs_1.default.readFileSync(path, "utf8");
+                }
+                catch (_a) { }
+                if (!contents)
+                    return undefined;
+                return JSON.parse(contents);
+            },
+            set(value) {
+                fs_1.default.writeFileSync(path, JSON.stringify(value));
+            }
+        };
+    }
+    else {
+        return {
+            get() {
+                let json = localStorage.getItem(key);
+                if (!json)
+                    return undefined;
+                return JSON.parse(json);
+            },
+            set(value) {
+                localStorage.setItem(key, JSON.stringify(value));
+            }
+        };
+    }
+}
+exports.getKeyStore = getKeyStore;
+//# sourceMappingURL=data:application/json;base64,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
+ /* _JS_SOURCE_HASH = "fab658bfd6afe5a0e23dd617216d46662e36d867c7ac2a1d0b56d0ac77e47290"; */

package/misc/https/dns.d.ts

@@ -0,0 +1,13 @@
+export declare function getRecordsRaw(type: string, key: string): Promise<{
+    id: string;
+    type: string;
+    name: string;
+    content: string;
+    proxied: boolean;
+}[]>;
+export declare function getRecords(type: string, key: string): Promise<string[]>;
+export declare function deleteRecord(type: string, key: string, value: string): Promise<void>;
+/** Removes all existing records (unless the record is already present) */
+export declare function setRecord(type: string, key: string, value: string, proxied?: "proxied"): Promise<void>;
+/** Keeps existing records */
+export declare function addRecord(type: string, key: string, value: string, proxied?: "proxied"): Promise<void>;

package/misc/https/dns.ts

@@ -0,0 +1,163 @@
+import { httpsRequest } from "socket-function/src/https";
+import { cache, lazy } from "socket-function/src/caching";
+import fs from "fs";
+import { delay } from "socket-function/src/batching";
+import { SocketFunction } from "socket-function/SocketFunction";
+
+const DNS_TTLSeconds = {
+    "TXT": 60,
+    "A": 60,
+};
+
+const getZoneId = cache(async (rootDomain: string): Promise<string> => {
+    let zones = await cloudflareGETCall<{ id: string; name: string }[]>("/zones", {});
+    let selected = zones.find(x => x.name === rootDomain);
+    if (!selected) {
+        throw new Error(`Could not find zone for ${rootDomain}. Found ${zones.map(x => x.name).join(", ")}`);
+    }
+    return selected.id;
+});
+
+function getRootDomain(key: string) {
+    if (key.endsWith(".")) {
+        key = key.slice(0, -1);
+    }
+    return key.split(".").slice(-2).join(".");
+}
+
+export async function getRecordsRaw(type: string, key: string) {
+    if (key.endsWith(".")) key = key.slice(0, -1);
+    let zoneId = await getZoneId(getRootDomain(key));
+    let results = await cloudflareGETCall<{
+        id: string;
+        type: string;
+        name: string;
+        content: string;
+        proxied: boolean;
+    }[]>(`/zones/${zoneId}/dns_records`);
+    return results.filter(x => x.type === type && x.name === key);
+}
+export async function getRecords(type: string, key: string) {
+    if (key.endsWith(".")) key = key.slice(0, -1);
+    let raw = await getRecordsRaw(type, key);
+    return raw.map(x => x.content);
+}
+export async function deleteRecord(type: string, key: string, value: string) {
+    if (key.endsWith(".")) key = key.slice(0, -1);
+    let zoneId = await getZoneId(getRootDomain(key));
+    let prevValues = await getRecordsRaw(type, key);
+    prevValues = prevValues.filter(x => x.content === value);
+    if (prevValues.length === 0) {
+        if (!SocketFunction.silent) {
+            console.log(`No need to delete record, it was not found. ${JSON.stringify(value)} value was not in ${type} for ${key}, values ${JSON.stringify(prevValues.map(x => x.content))}`);
+        }
+        return;
+    }
+
+    console.log(`Removing records of ${type} for ${key}, values ${JSON.stringify(prevValues.map(x => x.content))}`);
+    for (let value of prevValues) {
+        await cloudflareCall(`/zones/${zoneId}/dns_records/${value.id}`, Buffer.from([]), "DELETE");
+    }
+}
+/** Removes all existing records (unless the record is already present) */
+export async function setRecord(type: string, key: string, value: string, proxied?: "proxied") {
+    let stack = new Error();
+    if (key.endsWith(".")) key = key.slice(0, -1);
+    let zoneId = await getZoneId(getRootDomain(key));
+    let prevValues = await getRecordsRaw(type, key);
+    // NOTE: Apparently if we try to update by just changing proxied, cloudflare complains and
+    //  says "an identical record already exists", even though it doesn't, we changed the proxied value...
+    if (prevValues.some(x => x.content === value)) return;
+
+    console.log(`Removing previous records of ${type} for ${key} ${JSON.stringify(prevValues.map(x => x.content))}`);
+    let didDeletions = false;
+    for (let value of prevValues) {
+        didDeletions = true;
+        await cloudflareCall(`/zones/${zoneId}/dns_records/${value.id}`, Buffer.from([]), "DELETE");
+    }
+
+    console.log(`Setting ${type} record for ${key} to ${value} (previously had ${JSON.stringify(prevValues.map(x => x.content))})`);
+    const ttl = DNS_TTLSeconds[type as "A"] || 60;
+    await cloudflarePOSTCall(`/zones/${zoneId}/dns_records`, {
+        type: type,
+        name: key,
+        content: value,
+        ttl,
+        proxied: proxied === "proxied",
+    });
+    // NOTE: Apparently... even if the record didn't exist, we still have to wait...
+    console.log(`Waiting ${ttl} seconds for DNS to propagate...`);
+    await delay(ttl * 1000);
+    console.log(`Done waiting for DNS to update.`);
+
+}
+/** Keeps existing records */
+export async function addRecord(type: string, key: string, value: string, proxied?: "proxied") {
+    if (key.endsWith(".")) key = key.slice(0, -1);
+    let zoneId = await getZoneId(getRootDomain(key));
+    let prevValues = await getRecordsRaw(type, key);
+    // NOTE: Apparently if we try to update by just changing proxied, cloudflare complains and
+    //  says "an identical record already exists", even though it doesn't, we changed the proxied value...
+    if (prevValues.some(x => x.content === value)) return;
+    console.log(`Adding ${type} record for ${key} to ${value} (previously had ${JSON.stringify(prevValues.map(x => x.content))})`);
+    const ttl = DNS_TTLSeconds[type as "A"] || 60;
+    await cloudflarePOSTCall(`/zones/${zoneId}/dns_records`, {
+        type: type,
+        name: key,
+        content: value,
+        ttl,
+        proxied: proxied === "proxied",
+    });
+    console.log(`Waiting ${ttl} seconds for DNS to propagate...`);
+    await delay(ttl * 1000);
+    console.log(`Done waiting for DNS to update.`);
+}
+
+
+const getCloudflareCreds = lazy(async (): Promise<{ key: string; }> => {
+    const path = "cloudflare.json";
+    if (!fs.existsSync(path)) {
+        throw new Error(`Must add cloudflare.json file to root of project.`);
+    }
+    let creds = JSON.parse(fs.readFileSync(path, "utf8")) as { key: string; };
+    return {
+        key: creds.key,
+    };
+});
+
+async function cloudflareGETCall<T>(path: string, params?: { [key: string]: string }): Promise<T> {
+    let url = new URL(`https://api.cloudflare.com/client/v4` + path);
+    for (let key in params) {
+        url.searchParams.set(key, params[key]);
+    }
+    let creds = await getCloudflareCreds();
+    let result = await httpsRequest(url.toString(), [], "GET", undefined, {
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${creds.key}`,
+        }
+    });
+    let result2 = JSON.parse(result.toString()) as { result: unknown; success: boolean; errors: { code: number; message: string }[] };
+    if (!result2.success) {
+        throw new Error(`Cloudflare call failed: ${result2.errors.map(x => x.message).join(", ")}`);
+    }
+    return result2.result as T;
+}
+async function cloudflarePOSTCall<T>(path: string, params: { [key: string]: unknown }): Promise<T> {
+    return await cloudflareCall(path, Buffer.from(JSON.stringify(params)), "POST");
+}
+async function cloudflareCall<T>(path: string, payload: Buffer, method: string): Promise<T> {
+    let url = new URL(`https://api.cloudflare.com/client/v4` + path);
+    let creds = await getCloudflareCreds();
+    let result = await httpsRequest(url.toString(), payload, method, undefined, {
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${creds.key}`,
+        }
+    });
+    let result2 = JSON.parse(result.toString()) as { result: unknown; success: boolean; errors: { code: number; message: string }[] };
+    if (!result2.success) {
+        throw new Error(`Cloudflare call failed: ${result2.errors.map(x => x.message).join(", ")}`);
+    }
+    return result2.result as T;
+}