cob-cli 2.50.0 → 2.51.0

package/lib/task_lists/updateFromServer_validate.js

@@ -8,7 +8,7 @@ function validateUpdateFromServerConditions(cmdEnv) {
     return new Listr([
         {   title: "Check connectivity and permissions".bold,      task: () => checkConnectivity(cmdEnv.server) },
         {   title: "Check there's no cob-cli test' running".bold,  task: () => checkNoTestsRunningOnServer(cmdEnv.server) },
-        {   title: "Check git status".bold,                        task: () => checkWorkingCopyCleanliness() },
-    ])
+        {   title: "Check git status".bold,                        task: () => checkWorkingCopyCleanliness() }, 
+   ])
 }
-exports.validateUpdateFromServerConditions = validateUpdateFromServerConditions
+exports.validateUpdateFromServerConditions = validateUpdateFromServerConditions

package/lib/webpack/webpack.config.js

@@ -36,7 +36,7 @@ module.exports = env => {
       },
       proxy: {
         [ "**/" + process.env.dash_dir + "/**"]: {
-          target: "http://localhost:" + (process.env.dash_port || 8041),
+          target: "http://localhost:8041",
           secure: false
         },
         [ "/docs/**"]: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cob-cli",
-  "version": "2.50.0",
+  "version": "2.51.0",
   "description": "A command line utility to help Cult of Bits partners develop with higher speed and reusing common code and best practices.",
   "preferGlobal": true,
   "repository": {
@@ -18,7 +18,6 @@
   "dependencies": {
     "@webpack-cli/serve": "^2.0.1",
     "axios": "^0.21.1",
-    "axios-cookiejar-support": "^5.0.5",
     "chokidar": "^3.5.3",
     "cmd-line-importer": "^1.0.0",
     "colors": "^1.4.0",
@@ -29,14 +28,11 @@
     "file-cookie-store": "^0.2.1",
     "fs-extra": "^9.0.1",
     "inquirer": "^7.3.3",
-    "js-yaml": "^4.1.0",
     "listr": "^0.14.3",
     "ncp": "^2.0.0",
     "omelette": "^0.4.15-1",
     "open": "^8.4.0",
     "simple-git": "^3.15.1",
-    "tar": "^7.4.3",
-    "tough-cookie": "^5.1.2",
     "webpack": "^5.75.0",
     "webpack-cli": "^5.0.1",
     "webpack-dev-server": "^4.11.1",

package/lib/commands/cleanup.js

@@ -1,106 +0,0 @@
-require('colors');
-const git = require('simple-git');
-const fs = require('fs-extra');
-const fg = require('fast-glob');
-const execa = require('execa');
-const Listr = require('listr');
-const UpdaterRenderer = require('listr-update-renderer');
-const verboseRenderer = require('listr-verbose-renderer');
-const { getCurrentCommandEnviroment } = require("../task_lists/common_enviromentHandler");
-const { SERVER_COB_CLI_DIRECTORY } = require("../task_lists/common_helpers");
-const { restoreServerFilesToLastDeployed } = require("../task_lists/test_otherFilesContiousReload");
-const { loadOperationState, clearOperationState } = require("../task_lists/common_operationState");
-const { checkRepoVersion } = require("../commands/upgradeRepo");
-
-const LOCAL_TEST_LOCK_FILE = ".test.in.execution";
-const SERVER_TEST_LOCK_FILE = SERVER_COB_CLI_DIRECTORY + "test.in.execution";
-
-async function cleanup(args) {
-    try {
-        checkRepoVersion()
-
-        const savedState = loadOperationState();
-        if (savedState) {
-            if (!args.environment) args.environment = savedState.environment;
-            if (!args.servername)  args.servername  = savedState.servername;
-        }
-
-        console.log("Cleaning up interrupted test/deploy state...".bold)
-
-        const cmdEnv = await getCurrentCommandEnviroment(args)
-        console.log(`  environment: ${cmdEnv.name.bold}  server: ${cmdEnv.serverStr}`)
-
-        await new Listr([
-            {
-                title: "Undo environment-specific file changes".bold,
-                skip: async () => {
-                    const backupFiles = await fg(
-                        ['**/*.ENV__ORIGINAL_BACKUP__.*', '**/*.ENV__DELETE__.*'],
-                        { onlyFiles: false, dot: true }
-                    );
-                    return backupFiles.length === 0 ? "No environment-specific changes found" : false;
-                },
-                task: () => cmdEnv.unApplyCurrentCommandEnvironmentChanges()
-            },
-            {
-                // Runs after the local env undo so the working tree is clean before
-                // stashing and checking out the last-deployed SHA.
-                title: "Restore server files to last deployed version".bold,
-                skip: () => args.localOnly ? "Skipping server restore (--localOnly)" : false,
-                task: async () => {
-                    let changedFiles = [];
-                    try {
-                        const result = await execa('ssh', [cmdEnv.server, "cat " + SERVER_TEST_LOCK_FILE]);
-                        changedFiles = result.stdout.split("\n")
-                            .map(l => l.split(" ")[0].trim())
-                            .filter(f => f);
-                    } catch { /* no test.in.execution on server = nothing to restore */ }
-
-                    if (changedFiles.length === 0) return;
-
-                    await restoreServerFilesToLastDeployed(cmdEnv, changedFiles);
-                }
-            },
-            {
-                title: "Restore git branch from detached HEAD".bold,
-                skip: async () => {
-                    const branch = await git().revparse(["--abbrev-ref", "HEAD"]);
-                    return branch.trim() !== "HEAD" ? "Not in detached HEAD state" : false;
-                },
-                task: () => git().checkout("-")
-            },
-            {
-                title: "Remove local test lock file".bold,
-                skip: () => !fs.existsSync(LOCAL_TEST_LOCK_FILE) ? "No local test lock file found" : false,
-                task: () => fs.unlinkSync(LOCAL_TEST_LOCK_FILE)
-            },
-            {
-                title: "Remove server test lock file".bold,
-                skip: () => args.localOnly ? "Skipping server cleanup (--localOnly)" : false,
-                task: () => execa('ssh', [cmdEnv.server, "rm -f " + SERVER_TEST_LOCK_FILE])
-                    .catch(() => {}) // non-critical if server unreachable
-            },
-        ], {
-            renderer: args.verbose ? verboseRenderer : UpdaterRenderer,
-            collapse: false
-        }).run()
-
-        clearOperationState()
-
-        // Inform about stashes — don't auto-pop since user may have unrelated stashes
-        const stashList = await git().stash(["list"]);
-        if (stashList) {
-            console.log("\n" + "Note:".yellow.bold
-                + " Stashed changes detected (may be from the interrupted operation):")
-            console.log(stashList.split("\n").slice(0, 3).map(l => "  " + l).join("\n"))
-            console.log("Run " + "git stash pop".yellow + " if you want to restore your uncommitted changes.\n")
-        }
-
-        console.log("\nDone!".green, "\nYou can now run 'cob-cli test' or 'cob-cli deploy' again.\n")
-
-    } catch(err) {
-        console.error("\n", err.message)
-    }
-}
-
-module.exports = cleanup;

package/lib/commands/package.js

@@ -1,20 +0,0 @@
-require('colors');
-const { checkRepoVersion } = require("../commands/upgradeRepo");
-const { getCurrentCommandEnviroment } = require("../task_lists/common_enviromentHandler");
-const { executeTasks } = require("../task_lists/package_execute");
-
-async function package(args) {
-    try {
-        checkRepoVersion()
-        const cmdEnv = await getCurrentCommandEnviroment(args)
-        if(args.resync) args.force = true;
-
-        await executeTasks(cmdEnv, args).run();
-
-        console.log("\nDone!".green, "\nEnjoy!")
-
-    } catch(err) {
-        console.error("\n",err.message);
-    }
-}
-module.exports = package;

package/lib/commands/tagDefs.js

@@ -1,67 +0,0 @@
-require('colors');
-const { getCurrentCommandEnviroment } = require("../task_lists/common_enviromentHandler");
-const { promptCredentials, readYamlFile } = require("../task_lists/common_helpers.js");
-const { tagDefinitions } = require("../task_lists/tagDefs_execute.js");
-const { checkRepoVersion } = require("../commands/upgradeRepo");
-const axios = require('axios');
-const tough = require('tough-cookie');
-const axiosCookieJarSupport = require('axios-cookiejar-support')
-const path = require('path')
-const FileCookieStore = require('file-cookie-store');
-
-async function tagDefs(args) {
-    try {
-        checkRepoVersion()
-        const cmdEnv = await getCurrentCommandEnviroment(args)
-
-        axiosCookieJarSupport.wrapper(axios)
-        axios.defaults.ignoreCookieErrors = true
-        axios.defaults.withCredentials = true
-        const cookieJar = new tough.CookieJar()
-        axios.defaults.jar = cookieJar
-
-        if( args.cookie ) {
-            const p = path.resolve(args.cookie);
-            const cookieFile = new FileCookieStore(p, {auto_sync: false, force_parse: true});
-            try{
-                let c = await new Promise((resolve, reject) => {
-                    cookieFile.findCookie(`${cmdEnv.servername}.cultofbits.com`, '/', 'cobtoken', (err, result) => {
-                        if(err != null) reject(err);
-                        else resolve(result)
-                    })
-                });
-                if(!c){
-                    throw Error( `couldn't find a cookie for ${cmdEnv.servername} in ${p}`)
-                }
-                cookieJar.setCookie(c.toString(), `https://${cmdEnv.servername}.cultofbits.com`)
-            } catch(e){
-                console.error(e)
-                return
-            }
-
-        } else {
-
-            const credentials = await promptCredentials()
-
-            await axios.post(`https://${cmdEnv.servername}.cultofbits.com/recordm/security/auth`, credentials, {
-                headers: {
-                    "Content-Type": "application/json",
-                },
-            })
-        }
-
-        const solutions = await readYamlFile("solutions.yml")
-
-        for (const solution of solutions) {
-            console.log("\nStarting to tag Defs of solution " + solution.name, solution.definitions)
-            if (solution.definitions) {
-                await tagDefinitions(cmdEnv.servername, solution.name, solution.definitions, args)
-            }
-        }
-
-    } catch (err) {
-        console.error("\n", err.message);
-    }
-}
-
-module.exports = tagDefs;

package/lib/task_lists/common_definitions.js

@@ -1,26 +0,0 @@
-const axios = require("axios");
-
-async function getFilteredDefinitions(servername, defConfigs) {
-    const uri = `https://${servername}.cultofbits.com/recordm/recordm/definitions`
-    const response = await axios.get( uri );
-
-    if(response.status != 200){
-        throw new Error(`HTTP Error Response: ${response.status} ${response.statusText}`);
-    }
-
-    let result = defConfigs.flatMap(c => {
-        return response.data.filter(def => match(c.filter, def))
-            .map(m => ({...m, ...c}))
-    });
-
-    return result
-}
-
-function match(query, definition) {
-    // simple matching for now
-    return definition.name.includes(query) || definition.description?.includes(query)
-}
-
-module.exports = {
-    getFilteredDefinitions: getFilteredDefinitions
-}

package/lib/task_lists/common_operationState.js

@@ -1,28 +0,0 @@
-const fs = require('fs-extra');
-const fg = require('fast-glob');
-const STATE_FILE = ".git/cob-cli-state";
-
-function saveOperationState(environment, servername) {
-    try { fs.writeJsonSync(STATE_FILE, { environment, servername }); } catch {}
-}
-
-function loadOperationState() {
-    try { return fs.readJsonSync(STATE_FILE); } catch { return null; }
-}
-
-function clearOperationState() {
-    try { fs.unlinkSync(STATE_FILE); } catch {}
-}
-
-async function checkNoInterruptedRun() {
-    const stateExists = !!loadOperationState();
-    const envBackupFiles = await fg(['**/*.ENV__ORIGINAL_BACKUP__.*', '**/*.ENV__DELETE__.*'], { onlyFiles: false, dot: true });
-    if (stateExists || envBackupFiles.length > 0) {
-        throw new Error(
-            "\nAborted:".red + " found traces of a previous interrupted test/deploy.\n"
-            + "Run " + "cob-cli cleanup".yellow + " to restore the repo to a clean state first.\n"
-        );
-    }
-}
-
-module.exports = { saveOperationState, loadOperationState, clearOperationState, checkNoInterruptedRun };

package/lib/task_lists/package_execute.js

@@ -1,45 +0,0 @@
-const Listr = require('listr');
-const UpdaterRenderer = require('listr-update-renderer');
-const verboseRenderer = require('listr-verbose-renderer');
-const { copyFiles } = require("./common_syncFiles");
-const fs = require("fs");
-const tar = require('tar');
-const { format } = require('date-fns');
-
-
-function executeTasks(cmdEnv, args) {
-    console.log("\nPackaging ...");
-
-    return new Listr([
-        {title: "Apply new enviroment specifics", task: () => cmdEnv.applyCurrentCommandEnvironmentChanges() },
-        {title: "Create staging dir",             task: () => fs.existsSync('.staging') || fs.mkdirSync('.staging') },
-        {title: "Copy files to staging dir",      task: () => copyFiles(cmdEnv, "localCopy", "staging")},
-        {title: "Create package",                 task: async () => { const filename = await createPackage(cmdEnv, args); console.log("created " + filename) }},
-        {title: "Sign package",                   task: () => console.log("lololo")},
-        {title: "Delete staging dir",             task: () => fs.rmSync('.staging', {recursive: true, force: true})},
-        {title: "Undo new enviroment specifics",  task: () => cmdEnv.unApplyCurrentCommandEnvironmentChanges() },
-    ], {
-        renderer: args.verbose ? verboseRenderer : UpdaterRenderer,
-        collapse: false
-    });
-}
-exports.executeTasks = executeTasks;
-
-const createPackage = async function(cmdEnv, args){
-   const filename = `${cmdEnv.servername}-${cmdEnv.name}-${format(new Date(), 'yyyy-MM-dd_HH_mm')}.tar.gz`; 
-   const files = fs.readdirSync('.staging')
-   if (args.verbose > 0){
-      console.log("packaging " + files)
-   }
-
-    await tar.create({
-        gzip: true,
-        file: filename,
-        cwd: '.staging',
-        onWriteEntry(entry) {
-            if (args.verbose > 2) console.log('adding', entry.path, entry.stat.mode.toString(8))
-        }
-    }, files)
-
-   return filename;
-}

package/lib/task_lists/tagDefs_execute.js

@@ -1,121 +0,0 @@
-require('colors');
-const Listr = require('listr');
-const UpdaterRenderer = require('listr-update-renderer');
-const VerboseRenderer = require('listr-verbose-renderer');
-const { getFilteredDefinitions } = require('./common_definitions.js')
-const axios = require("axios");
-const inquirer = require("inquirer")
-
-async function getUntaggedChanges(servername, defId) {
-    const uri = `https://${servername}.cultofbits.com/recordm/recordm/definitions/${defId}/changes?tagged=false`
-
-    const response = await axios.get(uri, {params: {tagged: false}});
-
-    if(response.status % 200 > 100){
-        throw new Error(`HTTP Error Response: ${response.status} ${response.statusText}`);
-    }
-
-    return ( response.data || []).filter(c => !c.tag)
-}
-
-async function tagDefinition(servername, defId, until) {
-    const uri = `https://${servername}.cultofbits.com/recordm/recordm/definitions/${defId}/tag`
-
-    const params = {}
-    if(until) {
-        params.until = until
-    }
-   
-    const response = await axios.put(uri, "", {headers: {'Content-Type': 'application/json'}, params: params});
-
-    if(response.status != 200){
-        throw new Error(`HTTP Error Response: ${response.status} ${response.statusText}`);
-    }
-
-    return response.data
-}
-
-async function tagDefinitions(servername, customization, defs, args) {
-    return new Listr([
-        {
-            title: `(${customization}) Definitions: `.bold + "searching for definitions matching queries",
-            task: async ctx => ctx.defs = (await getFilteredDefinitions(servername, defs))
-            .map(d => ({id: d.id, name: d.name}))
-        },
-        {
-            title: `(${customization}) Definitions: `.bold + "enriching metadata",
-            task: async ctx => {
-                for (const def of ctx.defs){
-                    def.changes = await getUntaggedChanges(servername, def.id)
-                    if(args.verbose) console.log(`definition ${def.name}: ${def.changes.length} untagged changes`)
-                }
-            }
-        },
-        {
-            title: `(${customization}) Definitions: `.bold + "tagging un-tagged changes",
-            task: async ctx => {
-                const subtasks = ctx.defs.map(d => ({
-                    title: "Tagging changes to " + d.name.bold,
-                    task: async (_, task) => {
-                        if (d.changes.length == 0) {
-                            task.skip("no untagged changes")
-                            return
-                        }
-
-                        if(args.all) {
-                            await tagDefinition(servername, d.id)
-                            task.output = 'Tagged by all'
-                            return
-                        }
-
-                        d.changes.forEach(c => console.log(JSON.stringify(c)))
-
-                        const answer = await inquirer.prompt([
-                            {
-                                type: 'rawlist',
-                                name: 'action',
-                                message: `Do you wish to tag the ${d.changes.length} changes? (^c to abort)`,
-                                choices: [
-                                    'Tag Changes',
-                                    'Choose Changes',
-                                    'Skip',
-                                ]
-                            }
-                        ])
-                        if (answer.action == 'Skip') {
-                            task.skip()
-
-                        } else if (answer.action == 'Tag Changes') {
-                            await tagDefinition(servername, d.id)
-                            task.output = 'Tagged'
-
-                        } else if (answer.action == 'Choose Changes') {
-                           const dates = d.changes.reduce((acc, cur) => {
-                              if(!acc.includes(cur.date)) acc.push(cur.date)
-                              return acc
-                           }, [])
-                           const answerDate = await inquirer.prompt([
-                              {
-                                type: 'rawlist',
-                                name: 'date',
-                                message: `Choose the oldest date to tag`,
-                                choices: dates
-                              }
-                           ])
-                           await tagDefinition(servername, d.id, answerDate.date)
-                           task.output = 'Tagged until ' + answerDate.date
-                        }
-                    }
-                }))
-                return new Listr(subtasks)
-            }
-        },
-    ],{
-        // we need to list changes and read user input, the VerboseRenderer is needed
-        renderer: VerboseRenderer,
-        collapse: false
-    }).run()
-}
-
-
-exports.tagDefinitions = tagDefinitions

package/lib/task_lists/updateFromServer_definitions.js

@@ -1,135 +0,0 @@
-require('colors');
-const Listr = require('listr');
-const UpdaterRenderer = require('listr-update-renderer');
-const VerboseRenderer = require('listr-verbose-renderer');
-const { getFilteredDefinitions } = require('./common_definitions.js')
-const axios = require("axios");
-const fs = require("fs/promises");
-
-async function getRefs(servername, def) {
-    const uri = `https://${servername}.cultofbits.com/recordm/recordm/definitions/${def.id}`
-    const response = await axios.get(uri);
-
-    if(response.status != 200){
-        throw new Error(`HTTP Error Response: ${response.status} ${response.statusText}`);
-    }
-
-    const fields = response.data.fieldDefinitions;
-    return [...new Set(get$Refs(fields))];
-}
-function get$Refs(fields){
-    let refs = [];
-    for(f of fields){
-        if(f.configuration.keys.Reference){
-            refs.push(f.configuration.keys.Reference.args.definition);
-        }
-        if(f.fields) {
-            const childRefs = get$Refs(f.fields);
-            if(childRefs.length > 0) refs.push(...childRefs)
-        }
-    }
-    return refs
-}
-
-async function exportDefinitionChanges(servername, def, dataPath) {
-
-    const uri = `https://${servername}.cultofbits.com/recordm/recordm/definitions/${def.id}/changes`
-    const response = await axios.get(uri);
-
-    if(response.status == 204){
-        // this is probably an error
-        throw new Error(`Definition "${def.name}" [${def.id}] has no tagged Changes.`);
-
-    } else if(response.status != 200){
-        throw new Error(`HTTP Error Response: ${response.status} ${response.statusText}`);
-    }
-
-    // write every change on a single line
-    const stringified = "[\n" + response.data.map(change => "  " + JSON.stringify(change)).join(',\n') + "\n]\n";
-
-    await fs.writeFile(dataPath, stringified, 'utf-8');
-}
-
-async function exportDefinitionIdx(defs, dataPath) {
-   await fs.writeFile(dataPath, defs.map(d => d.name).join('\n'), 'utf-8')
-}
-
-async function getViewsForDef(servername, definition, dataPath) {
-    const definitionId = definition.id
-    const uri = `https://${servername}.cultofbits.com/recordm/user/settings/${definition.views}/definitions-${definitionId}/views?`
-
-    const response = await axios.get(uri);
-
-    if(response.status != 200){
-        throw new Error(`HTTP Error Response: ${response.status} ${response.statusText}`);
-    }
-
-    let userViews = response.data.filter(v => v.isShared)
-
-    if(response.data.length == 0)
-        return
-
-    userViews = response.data.map(v => {
-        v.value = JSON.stringify( JSON.parse(v.value).filter(f => f.visible == true) )
-        return v
-    })
-
-    const jsonLines = userViews.map(v => JSON.stringify({
-        key: v.key,
-        value: v.value,
-        user: v.user,
-    })) .join('\n');
-
-    await fs.writeFile(dataPath, jsonLines)
-}
-
-function getDefinitionsFromServer(servername, defs, definitionsPath, viewsPath, customization, args) {
-
-    return new Listr(
-        [
-            {
-                title: `(${customization}) Definitions: `.bold + "searching for definitions matching queries",
-                task: async ctx =>  ctx.defs = await getFilteredDefinitions(servername, defs)
-            },
-            {
-                title: `(${customization}) Definitions: `.bold + "enriching metadata",
-                task: async ctx => {
-                    const definitions = await Promise.all(ctx.defs
-                        .map(async d => ({id: d.id, name: d.name, views: d.views, refs: await getRefs(servername, d)}))
-                    )
-
-                    // we'll sort by refs, Defs that reference others must come after them
-                    definitions.sort((a, b) => {
-                        if (a.refs.includes(b.name)){
-                            return 1;
-                        }
-
-                        if(b.refs.includes(a.name)){
-                            return -1;
-                        }
-
-                        return a.refs.length - b.refs.length;
-                    })
-
-                    ctx.defs = definitions
-                }
-            },
-            {
-                title: `(${customization}) Definitions: `.bold + "exporting changes",
-                task: async ctx => {
-                    for( d of ctx.defs ){ await exportDefinitionChanges(servername, d, definitionsPath + `${d.name}.json`)}
-                    await exportDefinitionIdx(ctx.defs, definitionsPath + "_index")
-                }
-            },
-            {
-                title: `(${customization}) Definitions: `.bold + "exporting views",
-                task: async ctx => { for (d of ctx.defs.filter(d => d.views )){ await getViewsForDef(servername, d, viewsPath + `${d.name}.jsonl`)} }
-            },
-        ],{
-            renderer: args.verbose ? VerboseRenderer : UpdaterRenderer,
-            collapse: false
-        })
-}
-
-
-exports.getDefinitionsFromServer = getDefinitionsFromServer

package/lib/task_lists/updateFromServer_domains.js

@@ -1,50 +0,0 @@
-require('colors');
-const Listr = require('listr');
-const UpdaterRenderer = require('listr-update-renderer');
-const VerboseRenderer = require('listr-verbose-renderer');
-const axios = require("axios");
-const fs = require("fs/promises");
-
-async function domainsFromServer(servername, domainsFilter, exportPath, customization, args) {
-    await new Listr(
-        [
-            { title: `(${customization}) Domains: `.bold + "searching for domains matching the queries" ,
-                task: async ctx => ctx.domains = await getDomains(servername, domainsFilter, exportPath) },
-            { title: `(${customization}) Domains: `.bold + "exporting domains " ,
-                task: ctx => ctx.domains.forEach( d => exportDomain(d, exportPath))  }
-        ],{
-            renderer: args.verbose ? VerboseRenderer : UpdaterRenderer,
-            collapse: false
-        })
-        .run()
-}
-
-function match(query, domain) {
-    // simple matching for now
-    return (domain.name && domain.name.includes(query)) ||
-        (domain.description && domain.description.includes(query) )
-}
-
-async function getDomains(servername, filters, exportPath) {
-
-    const uri = `https://${servername}.cultofbits.com/recordm/recordm/domains`
-    const response = await axios.get( uri );
-
-    if(response.status != 200){
-        throw new Error(`HTTP Error Response: ${response.status} ${response.statusText}`);
-    }
-
-    const matchesAny = (domain) => filters.filter(q => match(q, domain)).length > 0;
-
-    return response.data.filter( matchesAny )
-}
-
-async function exportDomain(domain, rootPath) {
-    const d = {
-        name: domain.name,
-        definitions: domain.definitions.map(d => d.name).sort()
-    }
-    await fs.writeFile(rootPath + domain.name + ".json", JSON.stringify(d, null, 2) )
-}
-
-exports.getDomainsFromServer = domainsFromServer