@jbrowse/cli 3.6.0 → 3.6.1

package/dist/commands/admin-server-utils.js

@@ -0,0 +1,238 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidPort = isValidPort;
+exports.parsePort = parsePort;
+exports.generateKey = generateKey;
+exports.setupConfigFile = setupConfigFile;
+exports.setupRoutes = setupRoutes;
+exports.setupServer = setupServer;
+exports.startServer = startServer;
+const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const cors_1 = __importDefault(require("cors"));
+const express_1 = __importDefault(require("express"));
+const utils_1 = require("../utils");
+/**
+ * Validates if a port number is in the valid range
+ */
+function isValidPort(port) {
+    return port > 0 && port < 65535;
+}
+/**
+ * Parses and validates a port string
+ */
+function parsePort({ portStr, defaultPort = 9090, }) {
+    if (!portStr) {
+        return defaultPort;
+    }
+    const parsedPort = Number.parseInt(portStr, 10);
+    if (!isValidPort(parsedPort)) {
+        throw new Error(`${portStr} is not a valid port`);
+    }
+    return parsedPort;
+}
+/**
+ * Generates a random alphanumeric string to serve as admin key
+ */
+function generateKey() {
+    return crypto_1.default.randomBytes(5).toString('hex');
+}
+/**
+ * Sets up the configuration file
+ */
+async function setupConfigFile({ root = '.', } = {}) {
+    const output = root;
+    const isDir = fs_1.default.lstatSync(output).isDirectory();
+    const outFile = isDir ? `${output}/config.json` : output;
+    const baseDir = path_1.default.dirname(outFile);
+    if (fs_1.default.existsSync(outFile)) {
+        (0, utils_1.debug)(`Found existing config file ${outFile}`);
+    }
+    else {
+        (0, utils_1.debug)(`Creating config file ${outFile}`);
+        await (0, utils_1.writeJsonFile)(outFile, {
+            assemblies: [],
+            configuration: {},
+            connections: [],
+            defaultSession: {
+                name: 'New Session',
+            },
+            tracks: [],
+        });
+    }
+    return { outFile, baseDir };
+}
+/**
+ * Validates admin key and extracts config path from request
+ */
+function validateAndExtractParams({ req, key, baseDir, outFile, }) {
+    const { body } = req;
+    // Check for adminKey in both query parameters and request body for backward compatibility
+    const adminKeyFromQuery = req.query.adminKey;
+    const adminKeyFromBody = body?.adminKey;
+    const adminKey = adminKeyFromBody || adminKeyFromQuery;
+    if (adminKey !== key) {
+        return { isValid: false, error: 'Invalid admin key' };
+    }
+    // Get configPath from either body or query parameters
+    const configPathParam = body?.configPath || req.query.config;
+    try {
+        // Normalize the config path
+        const configPath = configPathParam
+            ? path_1.default.normalize(path_1.default.join(baseDir, configPathParam))
+            : outFile;
+        // Check for directory traversal attempts
+        const normalizedBaseDir = path_1.default.normalize(baseDir);
+        const relPath = path_1.default.relative(normalizedBaseDir, configPath);
+        // Ensure the config path is within the base directory and doesn't contain path traversal
+        if (relPath.startsWith('..') || path_1.default.isAbsolute(relPath)) {
+            return { isValid: false, error: 'Cannot perform directory traversal' };
+        }
+        return { isValid: true, configPath };
+    }
+    catch (error) {
+        return { isValid: false, error: 'Failed to validate config path' };
+    }
+}
+/**
+ * Sets up the API routes for the server
+ */
+function setupRoutes({ app, baseDir, outFile, key, }) {
+    // Root route
+    app.get('/', (_req, res) => {
+        res.setHeader('Content-Type', 'text/plain');
+        res.send('JBrowse Admin Server');
+    });
+    // Update config route
+    app.post('/updateConfig', (req, res) => {
+        const { body } = req;
+        const config = body.config;
+        const validation = validateAndExtractParams({ req, key, baseDir, outFile });
+        if (!validation.isValid) {
+            res.status(401).setHeader('Content-Type', 'text/plain');
+            res.send(`Error: ${validation.error}`);
+            return;
+        }
+        // Remove adminKey from body before saving to config
+        if (body.adminKey) {
+            delete body.adminKey;
+        }
+        try {
+            fs_1.default.writeFileSync(validation.configPath, JSON.stringify(config, null, 2));
+            res.setHeader('Content-Type', 'text/plain');
+            res.send('Config updated successfully');
+        }
+        catch (error) {
+            res.status(500).setHeader('Content-Type', 'text/plain');
+            res.send('Error: Failed to update config');
+        }
+    });
+    // Get config route
+    app.get('/config', (req, res) => {
+        const validation = validateAndExtractParams({ req, key, baseDir, outFile });
+        if (!validation.isValid) {
+            res.status(401).setHeader('Content-Type', 'text/plain');
+            res.send(`Error: ${validation.error}`);
+            return;
+        }
+        try {
+            if (fs_1.default.existsSync(validation.configPath)) {
+                const config = fs_1.default.readFileSync(validation.configPath, 'utf8');
+                res.setHeader('Content-Type', 'text/plain');
+                res.send(config);
+            }
+            else {
+                res.status(404).setHeader('Content-Type', 'text/plain');
+                res.send('Error: Config file not found');
+            }
+        }
+        catch (error) {
+            console.error('Error reading config:', error);
+            res.status(500).setHeader('Content-Type', 'text/plain');
+            res.send('Error: Failed to read config');
+        }
+    });
+}
+/**
+ * Sets up the Express server with routes
+ */
+function setupServer({ baseDir, outFile, bodySizeLimit, }) {
+    // Create Express application
+    const app = (0, express_1.default)();
+    // Configure middleware
+    app.use(express_1.default.static(baseDir));
+    app.use((0, cors_1.default)());
+    app.use(express_1.default.json({ limit: bodySizeLimit }));
+    // Add error handling middleware
+    app.use((err, _req, res, next) => {
+        if (err) {
+            console.error('Server error:', err);
+            res.status(500).setHeader('Content-Type', 'text/plain');
+            res.send('Internal Server Error');
+        }
+        else {
+            next();
+        }
+    });
+    // Generate admin key and store it
+    const key = generateKey();
+    const keyPath = path_1.default.join(os_1.default.tmpdir(), `jbrowse-admin-${key}`);
+    try {
+        fs_1.default.writeFileSync(keyPath, key);
+        (0, utils_1.debug)(`Admin key stored at ${keyPath}`);
+    }
+    catch (error) {
+        console.error(`Failed to write admin key to ${keyPath}:`, error.message);
+        // Continue anyway, as this is not critical
+    }
+    // Set up routes
+    setupRoutes({ app, baseDir, outFile, key });
+    return { app, key, keyPath };
+}
+/**
+ * Starts the server and sets up shutdown handlers
+ */
+function startServer({ app, port, key, outFile, keyPath, }) {
+    // Start the server
+    const server = app.listen(port, () => {
+        console.log(`Admin server started on port ${port}\n\n` +
+            `To access the admin interface, open your browser to:\n` +
+            `http://localhost:${port}?adminKey=${key}\n\n` +
+            `Admin key: ${key}\n` +
+            `Config file: ${outFile}\n\n` +
+            `To stop the server, press Ctrl+C`);
+    });
+    // Handle server errors
+    server.on('error', (error) => {
+        if (error.code === 'EADDRINUSE') {
+            console.error(`Error: Port ${port} is already in use`);
+        }
+        else {
+            console.error('Server error:', error.message);
+        }
+        process.exit(1);
+    });
+    // Common shutdown handler
+    const shutdownHandler = () => {
+        console.log('\nShutting down admin server...');
+        server.close(() => {
+            // Clean up admin key file
+            try {
+                fs_1.default.unlinkSync(keyPath);
+                (0, utils_1.debug)(`Removed admin key file: ${keyPath}`);
+            }
+            catch (error) {
+                // Ignore errors when cleaning up
+            }
+            process.exit(0);
+        });
+    };
+    // Handle server shutdown
+    process.on('SIGINT', shutdownHandler);
+    process.on('SIGTERM', shutdownHandler);
+}

package/dist/commands/admin-server.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const util_1 = require("util");
+const utils_1 = require("../utils");
+const admin_server_utils_1 = require("./admin-server-utils");
+async function run(args) {
+    const options = {
+        help: {
+            type: 'boolean',
+            short: 'h',
+        },
+        port: {
+            type: 'string',
+            short: 'p',
+            description: 'Specified port to start the server on (default: 9090)',
+        },
+        root: {
+            type: 'string',
+            description: 'Path to the root of the JB2 installation',
+        },
+        bodySizeLimit: {
+            type: 'string',
+            description: 'Size limit of the update message (default: 25mb)',
+        },
+    };
+    const { values: flags } = (0, util_1.parseArgs)({
+        args,
+        options,
+        allowPositionals: true,
+    });
+    const description = 'Start up a small admin server for JBrowse configuration';
+    const examples = ['$ jbrowse admin-server', '$ jbrowse admin-server -p 8888'];
+    if (flags.help) {
+        (0, utils_1.printHelp)({
+            description,
+            examples,
+            usage: 'jbrowse admin-server [options]',
+            options,
+        });
+        return;
+    }
+    const { root, bodySizeLimit = '25mb' } = flags;
+    const { outFile, baseDir } = await (0, admin_server_utils_1.setupConfigFile)({ root });
+    // Parse and validate port
+    const port = (0, admin_server_utils_1.parsePort)({ portStr: flags.port });
+    // Set up the Express server
+    const { app, key, keyPath } = (0, admin_server_utils_1.setupServer)({ baseDir, outFile, bodySizeLimit });
+    // Start the server and set up shutdown handlers
+    (0, admin_server_utils_1.startServer)({ app, port, key, outFile, keyPath });
+}

package/dist/commands/assembly-utils.js

@@ -0,0 +1,410 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidJSON = isValidJSON;
+exports.guessSequenceType = guessSequenceType;
+exports.needLoadData = needLoadData;
+exports.loadData = loadData;
+exports.getAssembly = getAssembly;
+exports.exists = exists;
+exports.resolveTargetPath = resolveTargetPath;
+exports.enhanceAssembly = enhanceAssembly;
+exports.createDefaultConfig = createDefaultConfig;
+exports.loadOrCreateConfig = loadOrCreateConfig;
+exports.addAssemblyToConfig = addAssemblyToConfig;
+exports.saveConfigAndReport = saveConfigAndReport;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("../utils");
+const { rename, copyFile, symlink } = fs_1.default.promises;
+function isValidJSON(string) {
+    try {
+        JSON.parse(string);
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+function guessSequenceType(sequence) {
+    if (sequence.endsWith('.fa') ||
+        sequence.endsWith('.fna') ||
+        sequence.endsWith('.fasta')) {
+        return 'indexedFasta';
+    }
+    if (sequence.endsWith('.fa.gz') ||
+        sequence.endsWith('.fna.gz') ||
+        sequence.endsWith('.fasta.gz')) {
+        return 'bgzipFasta';
+    }
+    if (sequence.endsWith('.2bit')) {
+        return 'twoBit';
+    }
+    if (sequence.endsWith('.chrom.sizes')) {
+        return 'chromSizes';
+    }
+    if (sequence.endsWith('.json')) {
+        return 'custom';
+    }
+    if (isValidJSON(sequence)) {
+        return 'custom';
+    }
+    throw new Error('Could not determine sequence type automatically, add --type to specify it');
+}
+function needLoadData(location) {
+    let locationUrl;
+    try {
+        locationUrl = new URL(location);
+    }
+    catch (error) {
+        // ignore
+    }
+    if (locationUrl) {
+        return false;
+    }
+    return true;
+}
+async function loadData({ load, filePaths, destination, }) {
+    let locationUrl;
+    try {
+        locationUrl = new URL(filePaths[0]);
+    }
+    catch (error) {
+        // ignore
+    }
+    if (locationUrl) {
+        return false;
+    }
+    switch (load) {
+        case 'copy': {
+            await Promise.all(filePaths.map(async (filePath) => {
+                if (!filePath) {
+                    return undefined;
+                }
+                return copyFile(filePath, path_1.default.join(path_1.default.dirname(destination), path_1.default.basename(filePath)));
+            }));
+            return true;
+        }
+        case 'symlink': {
+            await Promise.all(filePaths.map(async (filePath) => {
+                if (!filePath) {
+                    return undefined;
+                }
+                return symlink(path_1.default.resolve(filePath), path_1.default.join(path_1.default.dirname(destination), path_1.default.basename(filePath)));
+            }));
+            return true;
+        }
+        case 'move': {
+            await Promise.all(filePaths.map(async (filePath) => {
+                if (!filePath) {
+                    return undefined;
+                }
+                return rename(filePath, path_1.default.join(path_1.default.dirname(destination), path_1.default.basename(filePath)));
+            }));
+            return true;
+        }
+        case 'inPlace': {
+            return false;
+        }
+    }
+    return false;
+}
+async function getAssembly({ runFlags, argsSequence, target, }) {
+    let sequence;
+    if (needLoadData(argsSequence) && !runFlags.load) {
+        throw new Error('Please specify the loading operation for this file with --load copy|symlink|move|inPlace');
+    }
+    else if (!needLoadData(argsSequence) && runFlags.load) {
+        throw new Error('URL detected with --load flag. Please rerun the function without the --load flag');
+    }
+    let { name } = runFlags;
+    let { type } = runFlags;
+    if (type) {
+        (0, utils_1.debug)(`Type is: ${type}`);
+    }
+    else {
+        type = guessSequenceType(argsSequence);
+        (0, utils_1.debug)(`No type specified, guessing type: ${type}`);
+    }
+    if (name) {
+        (0, utils_1.debug)(`Name is: ${name}`);
+    }
+    switch (type) {
+        case 'indexedFasta': {
+            const { skipCheck, force, load, faiLocation } = runFlags;
+            let sequenceLocation = await (0, utils_1.resolveFileLocation)(argsSequence, !(skipCheck || force), load === 'inPlace');
+            (0, utils_1.debug)(`FASTA location resolved to: ${sequenceLocation}`);
+            let indexLocation = await (0, utils_1.resolveFileLocation)(faiLocation || `${argsSequence}.fai`, !(skipCheck || force), load === 'inPlace');
+            (0, utils_1.debug)(`FASTA index location resolved to: ${indexLocation}`);
+            if (!name) {
+                name = path_1.default.basename(sequenceLocation, sequenceLocation.endsWith('.fasta') ? '.fasta' : '.fa');
+                (0, utils_1.debug)(`Guessing name: ${name}`);
+            }
+            const loaded = load
+                ? await loadData({
+                    load,
+                    filePaths: [sequenceLocation, indexLocation],
+                    destination: target,
+                })
+                : false;
+            if (loaded) {
+                sequenceLocation = path_1.default.basename(sequenceLocation);
+                indexLocation = path_1.default.basename(indexLocation);
+            }
+            sequence = {
+                type: 'ReferenceSequenceTrack',
+                trackId: `${name}-ReferenceSequenceTrack`,
+                adapter: {
+                    type: 'IndexedFastaAdapter',
+                    fastaLocation: {
+                        uri: sequenceLocation,
+                        locationType: 'UriLocation',
+                    },
+                    faiLocation: { uri: indexLocation, locationType: 'UriLocation' },
+                },
+            };
+            break;
+        }
+        case 'bgzipFasta': {
+            let sequenceLocation = await (0, utils_1.resolveFileLocation)(argsSequence, !(runFlags.skipCheck || runFlags.force), runFlags.load === 'inPlace');
+            (0, utils_1.debug)(`compressed FASTA location resolved to: ${sequenceLocation}`);
+            let indexLocation = await (0, utils_1.resolveFileLocation)(runFlags.faiLocation || `${sequenceLocation}.fai`, !(runFlags.skipCheck || runFlags.force), runFlags.load === 'inPlace');
+            (0, utils_1.debug)(`compressed FASTA index location resolved to: ${indexLocation}`);
+            let bgzipIndexLocation = await (0, utils_1.resolveFileLocation)(runFlags.gziLocation || `${sequenceLocation}.gzi`, !(runFlags.skipCheck || runFlags.force), runFlags.load === 'inPlace');
+            (0, utils_1.debug)(`bgzip index location resolved to: ${bgzipIndexLocation}`);
+            if (!name) {
+                name = path_1.default.basename(sequenceLocation, sequenceLocation.endsWith('.fasta.gz') ? '.fasta.gz' : '.fa.gz');
+                (0, utils_1.debug)(`Guessing name: ${name}`);
+            }
+            const loaded = runFlags.load
+                ? await loadData({
+                    load: runFlags.load,
+                    filePaths: [sequenceLocation, indexLocation, bgzipIndexLocation],
+                    destination: target,
+                })
+                : false;
+            if (loaded) {
+                sequenceLocation = path_1.default.basename(sequenceLocation);
+                indexLocation = path_1.default.basename(indexLocation);
+                bgzipIndexLocation = path_1.default.basename(bgzipIndexLocation);
+            }
+            sequence = {
+                type: 'ReferenceSequenceTrack',
+                trackId: `${name}-ReferenceSequenceTrack`,
+                adapter: {
+                    type: 'BgzipFastaAdapter',
+                    fastaLocation: {
+                        uri: sequenceLocation,
+                        locationType: 'UriLocation',
+                    },
+                    faiLocation: { uri: indexLocation, locationType: 'UriLocation' },
+                    gziLocation: {
+                        uri: bgzipIndexLocation,
+                        locationType: 'UriLocation',
+                    },
+                },
+            };
+            break;
+        }
+        case 'twoBit': {
+            let sequenceLocation = await (0, utils_1.resolveFileLocation)(argsSequence, !(runFlags.skipCheck || runFlags.force), runFlags.load === 'inPlace');
+            (0, utils_1.debug)(`2bit location resolved to: ${sequenceLocation}`);
+            if (!name) {
+                name = path_1.default.basename(sequenceLocation, '.2bit');
+                (0, utils_1.debug)(`Guessing name: ${name}`);
+            }
+            const loaded = runFlags.load
+                ? await loadData({
+                    load: runFlags.load,
+                    filePaths: [sequenceLocation],
+                    destination: target,
+                })
+                : false;
+            if (loaded) {
+                sequenceLocation = path_1.default.basename(sequenceLocation);
+            }
+            sequence = {
+                type: 'ReferenceSequenceTrack',
+                trackId: `${name}-ReferenceSequenceTrack`,
+                adapter: {
+                    type: 'TwoBitAdapter',
+                    twoBitLocation: {
+                        uri: sequenceLocation,
+                        locationType: 'UriLocation',
+                    },
+                },
+            };
+            break;
+        }
+        case 'chromSizes': {
+            let sequenceLocation = await (0, utils_1.resolveFileLocation)(argsSequence, !(runFlags.skipCheck || runFlags.force), runFlags.load === 'inPlace');
+            (0, utils_1.debug)(`chrom.sizes location resolved to: ${sequenceLocation}`);
+            if (!name) {
+                name = path_1.default.basename(sequenceLocation, '.chrom.sizes');
+                (0, utils_1.debug)(`Guessing name: ${name}`);
+            }
+            const loaded = runFlags.load
+                ? await loadData({
+                    load: runFlags.load,
+                    filePaths: [sequenceLocation],
+                    destination: target,
+                })
+                : false;
+            if (loaded) {
+                sequenceLocation = path_1.default.basename(sequenceLocation);
+            }
+            sequence = {
+                type: 'ReferenceSequenceTrack',
+                trackId: `${name}-ReferenceSequenceTrack`,
+                adapter: {
+                    type: 'ChromSizesAdapter',
+                    chromSizesLocation: {
+                        uri: sequenceLocation,
+                        locationType: 'UriLocation',
+                    },
+                },
+            };
+            break;
+        }
+        case 'custom': {
+            const adapter = await (0, utils_1.readInlineOrFileJson)(argsSequence);
+            (0, utils_1.debug)(`Custom adapter: ${JSON.stringify(adapter)}`);
+            if (!name) {
+                if (isValidJSON(argsSequence)) {
+                    throw new Error('Must provide --name when using custom inline JSON sequence');
+                }
+                else {
+                    name = path_1.default.basename(argsSequence, '.json');
+                }
+                (0, utils_1.debug)(`Guessing name: ${name}`);
+            }
+            if (!('type' in adapter)) {
+                throw new Error(`No "type" specified in sequence adapter "${JSON.stringify(adapter)}"`);
+            }
+            sequence = {
+                type: 'ReferenceSequenceTrack',
+                trackId: `${name}-ReferenceSequenceTrack`,
+                adapter,
+            };
+            break;
+        }
+    }
+    return { name, sequence };
+}
+async function exists(s) {
+    try {
+        await fs_1.default.promises.access(s, fs_1.default.constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function resolveTargetPath(output) {
+    if (!(await exists(output))) {
+        const dir = output.endsWith('.json') ? path_1.default.dirname(output) : output;
+        await fs_1.default.promises.mkdir(dir, { recursive: true });
+    }
+    let isDir = false;
+    try {
+        isDir = fs_1.default.statSync(output).isDirectory();
+    }
+    catch (e) { }
+    return isDir ? path_1.default.join(output, 'config.json') : output;
+}
+async function enhanceAssembly(assembly, runFlags) {
+    const enhancedAssembly = { ...assembly };
+    if (runFlags.alias?.length) {
+        (0, utils_1.debug)(`Adding assembly aliases: ${runFlags.alias}`);
+        enhancedAssembly.aliases = runFlags.alias;
+    }
+    if (runFlags.refNameColors) {
+        enhancedAssembly.refNameColors = runFlags.refNameColors
+            .split(',')
+            .map((color) => color.trim());
+    }
+    if (runFlags.refNameAliases) {
+        if (runFlags.refNameAliasesType &&
+            runFlags.refNameAliasesType === 'custom') {
+            const refNameAliasesConfig = await (0, utils_1.readInlineOrFileJson)(runFlags.refNameAliases);
+            if (!refNameAliasesConfig.type) {
+                throw new Error(`No "type" specified in refNameAliases adapter "${JSON.stringify(refNameAliasesConfig)}"`);
+            }
+            (0, utils_1.debug)(`Adding custom refNameAliases config: ${JSON.stringify(refNameAliasesConfig)}`);
+            enhancedAssembly.refNameAliases = {
+                adapter: refNameAliasesConfig,
+            };
+        }
+        else {
+            const refNameAliasesLocation = await (0, utils_1.resolveFileLocation)(runFlags.refNameAliases, !(runFlags.skipCheck || runFlags.force), runFlags.load === 'inPlace');
+            (0, utils_1.debug)(`refName aliases file location resolved to: ${refNameAliasesLocation}`);
+            enhancedAssembly.refNameAliases = {
+                adapter: {
+                    type: 'RefNameAliasAdapter',
+                    location: {
+                        uri: refNameAliasesLocation,
+                        locationType: 'UriLocation',
+                    },
+                },
+            };
+        }
+    }
+    if (runFlags.displayName) {
+        enhancedAssembly.displayName = runFlags.displayName;
+    }
+    return enhancedAssembly;
+}
+function createDefaultConfig() {
+    return {
+        assemblies: [],
+        configuration: {},
+        connections: [],
+        defaultSession: {
+            name: 'New Session',
+        },
+        tracks: [],
+    };
+}
+async function loadOrCreateConfig(target) {
+    const defaultConfig = createDefaultConfig();
+    if (fs_1.default.existsSync(target)) {
+        (0, utils_1.debug)(`Found existing config file ${target}`);
+        return {
+            ...defaultConfig,
+            ...(await (0, utils_1.readJsonFile)(target)),
+        };
+    }
+    else {
+        (0, utils_1.debug)(`Creating config file ${target}`);
+        return { ...defaultConfig };
+    }
+}
+async function addAssemblyToConfig({ config, assembly, runFlags, }) {
+    const updatedConfig = { ...config };
+    if (!updatedConfig.assemblies) {
+        updatedConfig.assemblies = [];
+    }
+    const idx = updatedConfig.assemblies.findIndex(configAssembly => configAssembly.name === assembly.name);
+    if (idx !== -1) {
+        (0, utils_1.debug)(`Found existing assembly ${assembly.name} in configuration`);
+        if (runFlags.overwrite || runFlags.force) {
+            (0, utils_1.debug)(`Overwriting assembly ${assembly.name} in configuration`);
+            updatedConfig.assemblies[idx] = assembly;
+            return { config: updatedConfig, wasOverwritten: true };
+        }
+        else {
+            throw new Error(`Cannot add assembly with name ${assembly.name}, an assembly with that name already exists`);
+        }
+    }
+    else {
+        updatedConfig.assemblies.push(assembly);
+        return { config: updatedConfig, wasOverwritten: false };
+    }
+}
+async function saveConfigAndReport({ config, target, assembly, wasOverwritten, }) {
+    (0, utils_1.debug)(`Writing configuration to file ${target}`);
+    await (0, utils_1.writeJsonFile)(target, config);
+    console.log(`${wasOverwritten ? 'Overwrote' : 'Added'} assembly "${assembly.name}" ${wasOverwritten ? 'in' : 'to'} ${target}`);
+}