@apollo-annotation/cli 0.1.19 → 0.1.21

package/dist/commands/jbrowse/set-config.js

@@ -0,0 +1,51 @@
+import * as fs from 'node:fs';
+import { Args } from '@oclif/core';
+import { Agent, fetch } from 'undici';
+import { ConfigError } from '../../ApolloConf.js';
+import { BaseCommand } from '../../baseCommand.js';
+import { localhostToAddress, createFetchErrorMessage } from '../../utils.js';
+export default class SetConfig extends BaseCommand {
+    static summary = 'Set JBrowse configuration';
+    static description = 'Set JBrowse configuration in Apollo collaboration server';
+    static examples = [
+        {
+            description: 'Add JBrowse configuration:',
+            command: '<%= config.bin %> <%= command.id %> config.json',
+        },
+    ];
+    static args = {
+        inputFile: Args.string({
+            description: 'JBrowse configuration file',
+            required: true,
+        }),
+    };
+    async run() {
+        const { args } = await this.parse(SetConfig);
+        if (!fs.existsSync(args.inputFile)) {
+            this.error(`File ${args.inputFile} does not exist`);
+        }
+        const access = await this.getAccess();
+        const filehandle = await fs.promises.open(args.inputFile);
+        const fileContent = await filehandle.readFile({ encoding: 'utf8' });
+        await filehandle.close();
+        const change = {
+            typeName: 'ImportJBrowseConfigChange',
+            newJBrowseConfig: JSON.parse(fileContent),
+        };
+        const auth = {
+            method: 'POST',
+            body: JSON.stringify(change),
+            headers: {
+                Authorization: `Bearer ${access.accessToken}`,
+                'Content-Type': 'application/json',
+            },
+            dispatcher: new Agent({ headersTimeout: 60 * 60 * 1000 }),
+        };
+        const url = new URL(localhostToAddress(`${access.address}/changes`));
+        const response = await fetch(url, auth);
+        if (!response.ok) {
+            const errorMessage = await createFetchErrorMessage(response, 'Failed to add JBrowse configuration');
+            throw new ConfigError(errorMessage);
+        }
+    }
+}

package/dist/commands/login.js

@@ -8,21 +8,21 @@ import * as querystring from 'node:querystring';
 import { Errors, Flags, ux } from '@oclif/core';
 import open from 'open';
 import { fetch } from 'undici';
-import { ApolloConf } from '../ApolloConf.js';
+import { ApolloConf, KEYS } from '../ApolloConf.js';
 import { BaseCommand } from '../baseCommand.js';
-import { basicCheckConfig, createFetchErrorMessage, getUserCredentials, localhostToAddress, waitFor, wrapLines, } from '../utils.js';
+import { basicCheckConfig, createFetchErrorMessage, localhostToAddress, waitFor, } from '../utils.js';
 export default class Login extends BaseCommand {
     static summary = 'Login to Apollo';
-    static description = wrapLines('Use the provided credentials to obtain and save the token to access Apollo. Once the token for \
-    the given profile has been saved in the configuration file, users do not normally need to execute \
-    this command again unless the token has expired. To setup a new profile use "apollo config"');
+    static description = 'Use the provided credentials to obtain and save the token to access Apollo. \
+Once the token for the given profile has been saved in the configuration file, users do not normally \
+need to execute this command again unless the token has expired. To setup a new profile use "apollo config"';
     static examples = [
         {
-            description: wrapLines('The most basic and probably most typical usage is to login using the default profile in configuration file:'),
+            description: 'The most basic and probably most typical usage is to login using the default profile in configuration file:',
             command: '<%= config.bin %> <%= command.id %>',
         },
         {
-            description: wrapLines('Login with a different profile:'),
+            description: 'Login with a different profile:',
             command: '<%= config.bin %> <%= command.id %> --profile my-profile',
         },
     ];
@@ -71,7 +71,7 @@ export default class Login extends BaseCommand {
         let userCredentials = { accessToken: '' };
         try {
             if (!flags.force) {
-                await this.checkUserAlreadyLoggedIn();
+                await this.checkUserAlreadyLoggedIn(config, profileName);
             }
             if (accessType === 'root' || flags.username !== undefined) {
                 const username = flags.username ??
@@ -104,13 +104,9 @@ export default class Login extends BaseCommand {
         }
         config.set(`${profileName}.accessToken`, userCredentials.accessToken);
     }
-    async checkUserAlreadyLoggedIn() {
-        const userCredentials = getUserCredentials();
-        if (!userCredentials) {
-            return;
-        }
-        const alreadyLoggedIn = Object.keys(userCredentials).every((key) => Boolean(userCredentials[key]));
-        if (!alreadyLoggedIn) {
+    async checkUserAlreadyLoggedIn(userCredentials, profileName) {
+        const accessToken = userCredentials.get(`${profileName}.${KEYS.accessToken}`);
+        if (!accessToken) {
             return;
         }
         const reAuthenticate = await ux.confirm("You're already logged. Do you want to re-authenticate? (y/n)");

package/dist/commands/logout.js

@@ -1,10 +1,10 @@
 import path from 'node:path';
 import { ApolloConf, KEYS } from '../ApolloConf.js';
 import { BaseCommand } from '../baseCommand.js';
-import { basicCheckConfig, wrapLines } from '../utils.js';
+import { basicCheckConfig } from '../utils.js';
 export default class Logout extends BaseCommand {
     static summary = 'Logout of Apollo';
-    static description = wrapLines('Logout by removing the access token from the selected profile');
+    static description = 'Logout by removing the access token from the selected profile';
     static examples = [
         {
             description: 'Logout default profile:',

package/dist/commands/refseq/add-alias.d.ts

@@ -6,8 +6,10 @@ export default class AddRefNameAlias extends BaseCommand<typeof AddRefNameAlias>
         description: string;
         command: string;
     }[];
+    static args: {
+        'input-file': import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
     static flags: {
-        'input-file': import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
         assembly: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
     };
     run(): Promise<void>;

package/dist/commands/refseq/add-alias.js

@@ -1,24 +1,25 @@
 import * as fs from 'node:fs';
 import { Agent, fetch } from 'undici';
-import { Flags } from '@oclif/core';
+import { Args, Flags } from '@oclif/core';
 import { BaseCommand } from '../../baseCommand.js';
-import { createFetchErrorMessage, localhostToAddress, queryApollo, wrapLines, } from '../../utils.js';
+import { createFetchErrorMessage, localhostToAddress, queryApollo, } from '../../utils.js';
 import { ConfigError } from '../../ApolloConf.js';
 export default class AddRefNameAlias extends BaseCommand {
     static summary = 'Add reference name aliases from a file';
-    static description = wrapLines('Reference name aliasing is a process to make chromosomes that are named slightly differently but which refer to the same thing render properly. This command reads a file with reference name aliases and adds them to the database.');
+    static description = 'Reference name aliasing is a process to make chromosomes that are named slightly differently but which refer to the same thing render properly. This command reads a file with reference name aliases and adds them to the database.';
     static examples = [
         {
             description: 'Add reference name aliases:',
-            command: '<%= config.bin %> <%= command.id %> -i alias.txt -a myAssembly',
+            command: '<%= config.bin %> <%= command.id %> alias.txt -a myAssembly',
         },
     ];
-    static flags = {
-        'input-file': Flags.string({
-            char: 'i',
+    static args = {
+        'input-file': Args.string({
             description: 'Input refname alias file',
             required: true,
         }),
+    };
+    static flags = {
         assembly: Flags.string({
             char: 'a',
             description: 'Name for this assembly.',
@@ -26,12 +27,12 @@ export default class AddRefNameAlias extends BaseCommand {
         }),
     };
     async run() {
-        const { flags } = await this.parse(AddRefNameAlias);
-        if (!fs.existsSync(flags['input-file'])) {
-            this.error(`File ${flags['input-file']} does not exist`);
+        const { args, flags } = await this.parse(AddRefNameAlias);
+        if (!fs.existsSync(args['input-file'])) {
+            this.error(`File ${args['input-file']} does not exist`);
         }
-        const access = await this.getAccess(flags['config-file'], flags.profile);
-        const filehandle = await fs.promises.open(flags['input-file']);
+        const access = await this.getAccess();
+        const filehandle = await fs.promises.open(args['input-file']);
         const fileContent = await filehandle.readFile({ encoding: 'utf8' });
         await filehandle.close();
         const lines = fileContent.split('\n');

package/dist/commands/refseq/get.js

@@ -1,18 +1,18 @@
 import { Flags } from '@oclif/core';
 import { BaseCommand } from '../../baseCommand.js';
-import { convertAssemblyNameToId, idReader, queryApollo, wrapLines, } from '../../utils.js';
+import { convertAssemblyNameToId, idReader, queryApollo } from '../../utils.js';
 export default class Get extends BaseCommand {
     static summary = 'Get reference sequences';
-    static description = wrapLines('Output the reference sequences in one or more assemblies in json format. \
-    This command returns the sequence characteristics (e.g., name, ID, etc), not the DNA sequences. \
-    Use `assembly sequence` for that.');
+    static description = 'Output the reference sequences in one or more assemblies in json format. \
+This command returns the sequence characteristics (e.g., name, ID, etc), not the DNA sequences. \
+Use `assembly sequence` for that.';
     static examples = [
         {
-            description: wrapLines('All sequences in the database:'),
+            description: 'All sequences in the database:',
             command: '<%= config.bin %> <%= command.id %>',
         },
         {
-            description: wrapLines('Only sequences for these assemblies:'),
+            description: 'Only sequences for these assemblies:',
             command: '<%= config.bin %> <%= command.id %> -a mm9 mm10',
         },
     ];
@@ -25,13 +25,13 @@ export default class Get extends BaseCommand {
     };
     async run() {
         const { flags } = await this.parse(Get);
-        const access = await this.getAccess(flags['config-file'], flags.profile);
+        const access = await this.getAccess();
         const refSeqs = await queryApollo(access.address, access.accessToken, 'refSeqs');
         const json = (await refSeqs.json());
         let keep = json;
         if (flags.assembly !== undefined) {
             keep = [];
-            const assembly = idReader(flags.assembly);
+            const assembly = await idReader(flags.assembly);
             const assemblyIds = await convertAssemblyNameToId(access.address, access.accessToken, assembly);
             for (const x of json) {
                 if (assemblyIds.includes(x['assembly'])) {

package/dist/commands/status.js

@@ -2,11 +2,12 @@
 import path from 'node:path';
 import { ApolloConf, KEYS } from '../ApolloConf.js';
 import { BaseCommand } from '../baseCommand.js';
-import { basicCheckConfig, wrapLines } from '../utils.js';
+import { basicCheckConfig } from '../utils.js';
 export default class Status extends BaseCommand {
     static summary = 'View authentication status';
-    static description = wrapLines('This command returns "<profile>: Logged in" if the selected profile has an access token and "<profile>: Logged out" otherwise.\
-    Note that this command does not check the validity of the access token.');
+    static description = 'This command returns "<profile>: Logged in" if the selected profile \
+has an access token and "<profile>: Logged out" otherwise.\
+Note that this command does not check the validity of the access token.';
     async run() {
         const { flags } = await this.parse(Status);
         let profileName = flags.profile;

package/dist/commands/user/get.js

@@ -1,9 +1,9 @@
 import { Flags } from '@oclif/core';
 import { BaseCommand } from '../../baseCommand.js';
-import { queryApollo, wrapLines } from '../../utils.js';
+import { queryApollo } from '../../utils.js';
 export default class Get extends BaseCommand {
     static summary = 'Get list of users';
-    static description = wrapLines('If set, filters username and role must be both satisfied to return an entry');
+    static description = 'If set, filters username and role must be both satisfied to return an entry';
     static examples = [
         {
             description: 'By username:',
@@ -30,7 +30,7 @@ export default class Get extends BaseCommand {
     };
     async run() {
         const { flags } = await this.parse(Get);
-        const access = await this.getAccess(flags['config-file'], flags.profile);
+        const access = await this.getAccess();
         const users = await queryApollo(access.address, access.accessToken, 'users');
         const json = (await users.json());
         const out = [];

package/dist/fileCommand.d.ts

@@ -0,0 +1,5 @@
+import { BaseCommand } from './baseCommand.js';
+export declare abstract class FileCommand extends BaseCommand<typeof FileCommand> {
+    init(): Promise<void>;
+    uploadFile(address: string, accessToken: string, file: string, type: string, isGzip: boolean): Promise<string>;
+}

package/dist/fileCommand.js

@@ -0,0 +1,76 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { Transform, pipeline, } from 'node:stream';
+import { SingleBar } from 'cli-progress';
+import { Agent, fetch } from 'undici';
+import { ConfigError } from './ApolloConf.js';
+import { BaseCommand } from './baseCommand.js';
+import { createFetchErrorMessage, localhostToAddress } from './utils.js';
+class ProgressTransform extends Transform {
+    size = 0;
+    progressBar;
+    constructor(opts) {
+        super(opts);
+        this.progressBar = opts.progressBar;
+    }
+    _transform(chunk, _encoding, callback) {
+        this.size += chunk.length;
+        this.progressBar.update(this.size);
+        callback(null, chunk);
+    }
+}
+export class FileCommand extends BaseCommand {
+    async init() {
+        await super.init();
+    }
+    async uploadFile(address, accessToken, file, type, isGzip) {
+        const filehandle = await fs.promises.open(file);
+        const { size } = await filehandle.stat();
+        const stream = filehandle.createReadStream();
+        const progressBar = new SingleBar({ etaBuffer: 100_000_000 });
+        const progressTransform = new ProgressTransform({ progressBar });
+        const body = pipeline(stream, progressTransform, (error) => {
+            if (error) {
+                progressBar.stop();
+                console.error('Error processing file.', error);
+                throw error;
+            }
+        });
+        const headers = new Headers({
+            Authorization: `Bearer ${accessToken}`,
+            'Content-Type': type,
+            'Content-Length': String(size),
+        });
+        if (isGzip) {
+            headers.append('Content-Encoding', 'gzip');
+        }
+        const init = {
+            method: 'POST',
+            body,
+            duplex: 'half',
+            dispatcher: new Agent({ headersTimeout: 60 * 60 * 1000 }),
+            headers,
+        };
+        const fileName = path.basename(file);
+        const url = new URL(localhostToAddress(`${address}/files`));
+        url.searchParams.set('name', fileName);
+        url.searchParams.set('type', type);
+        progressBar.start(size, 0);
+        try {
+            const response = await fetch(url, init);
+            if (!response.ok) {
+                const errorMessage = await createFetchErrorMessage(response, 'uploadFile failed');
+                throw new ConfigError(errorMessage);
+            }
+            const json = (await response.json());
+            return json['_id'];
+        }
+        catch (error) {
+            console.error(error);
+            throw error;
+        }
+        finally {
+            progressBar.stop();
+        }
+    }
+}

package/dist/utils.d.ts

@@ -1,6 +1,8 @@
 import EventEmitter from 'node:events';
+import type { SerializedAddAssemblyAndFeaturesFromFileChange, SerializedAddAssemblyFromExternalChange, SerializedAddAssemblyFromFileChange } from '@apollo-annotation/shared';
 import { Response } from 'undici';
 import { ApolloConf } from './ApolloConf.js';
+import { ApolloAssemblySnapshot } from '@apollo-annotation/mst';
 export declare const CLI_SERVER_ADDRESS = "http://127.0.0.1:5657";
 export declare const CLI_SERVER_ADDRESS_CALLBACK = "http://127.0.0.1:5657/auth/callback";
 export declare class CheckError extends Error {
@@ -17,38 +19,22 @@ export declare function basicCheckConfig(configFile: string, profileName: string
  */
 export declare function localhostToAddress(url: string): string;
 export declare function deleteAssembly(address: string, accessToken: string, assemblyId: string): Promise<void>;
-export declare function getAssembly(address: string, accessToken: string, assemblyNameOrId: string): Promise<object>;
+export declare function getAssembly(address: string, accessToken: string, assemblyNameOrId: string): Promise<ApolloAssemblySnapshot>;
 export declare function getRefseqId(address: string, accessToken: string, refseqNameOrId?: string, inAssemblyNameOrId?: string): Promise<string[]>;
 export declare function convertCheckNameToId(address: string, accessToken: string, namesOrIds: string[]): Promise<string[]>;
-export declare function assemblyNameToIdDict(address: string, accessToken: string): Promise<Record<string, string>>;
+export declare function assemblyNameToIdDict(address: string, accessToken: string): Promise<Record<string, string | undefined>>;
 /** In input array namesOrIds, substitute common names with internal IDs */
 export declare function convertAssemblyNameToId(address: string, accessToken: string, namesOrIds: string[], verbose?: boolean, removeDuplicates?: boolean): Promise<string[]>;
 export declare function getFeatureById(address: string, accessToken: string, id: string): Promise<Response>;
 export declare function getAssemblyFromRefseq(address: string, accessToken: string, refSeq: string): Promise<string>;
 export declare function queryApollo(address: string, accessToken: string, endpoint: string): Promise<Response>;
 export declare function filterJsonList(json: object[], keep: string[], key: string): object[];
-export declare const getUserCredentials: () => UserCredentials | null;
 export declare const generatePkceChallenge: () => {
     state: string;
     codeVerifier: string;
     codeChallenge: string;
 };
 export declare const waitFor: <T>(eventName: string, emitter: EventEmitter) => Promise<T>;
-interface bodyLocalFile {
-    assemblyName: string;
-    typeName: string;
-    fileId: string;
-}
-interface bodyExternalFile {
-    assemblyName: string;
-    typeName: string;
-    externalLocation: {
-        fa: string;
-        fai: string;
-    };
-}
-export declare function submitAssembly(address: string, accessToken: string, body: bodyLocalFile | bodyExternalFile, force: boolean): Promise<Response>;
-export declare function uploadFile(address: string, accessToken: string, file: string, type: string): Promise<never>;
-export declare function wrapLines(s: string, length?: number): string;
-export declare function idReader(input: string[], removeDuplicates?: boolean): string[];
-export {};
+export declare function submitAssembly(address: string, accessToken: string, body: SerializedAddAssemblyFromFileChange | SerializedAddAssemblyFromExternalChange | SerializedAddAssemblyAndFeaturesFromFileChange, force: boolean): Promise<object>;
+export declare function readStdin(): Promise<string>;
+export declare function idReader(input: string[], removeDuplicates?: boolean): Promise<string[]>;

package/dist/utils.js

@@ -1,17 +1,8 @@
-/* eslint-disable @typescript-eslint/no-unnecessary-condition */
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-return */
 import * as crypto from 'node:crypto';
 import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { Transform, pipeline, } from 'node:stream';
-import { SingleBar } from 'cli-progress';
+import { stdin, stderr } from 'node:process';
 import { Agent, fetch } from 'undici';
 import { ApolloConf, ConfigError } from './ApolloConf.js';
-const CONFIG_PATH = path.resolve(os.homedir(), '.clirc');
 export const CLI_SERVER_ADDRESS = 'http://127.0.0.1:5657';
 export const CLI_SERVER_ADDRESS_CALLBACK = `${CLI_SERVER_ADDRESS}/auth/callback`;
 export class CheckError extends Error {
@@ -75,18 +66,16 @@ export async function deleteAssembly(address, accessToken, assemblyId) {
 export async function getAssembly(address, accessToken, assemblyNameOrId) {
     const assemblyId = await convertAssemblyNameToId(address, accessToken, [assemblyNameOrId]);
     if (assemblyId.length === 0) {
-        return {};
+        throw new Error(`Assembly "${assemblyNameOrId}" not found`);
     }
     const res = await queryApollo(address, accessToken, 'assemblies');
     const assemblies = (await res.json());
-    let assemblyObj = {};
     for (const x of assemblies) {
         if (x._id === assemblyId[0]) {
-            assemblyObj = JSON.parse(JSON.stringify(x));
-            break;
+            return JSON.parse(JSON.stringify(x));
         }
     }
-    return assemblyObj;
+    throw new Error(`Assembly "${assemblyNameOrId}" not found`);
 }
 export async function getRefseqId(address, accessToken, refseqNameOrId, inAssemblyNameOrId) {
     if (refseqNameOrId === undefined && inAssemblyNameOrId === undefined) {
@@ -176,7 +165,7 @@ export async function convertAssemblyNameToId(address, accessToken, namesOrIds,
             ids.push(x);
         }
         else if (verbose) {
-            process.stderr.write(`Warning: Omitting unknown assembly: "${x}"\n`);
+            stderr.write(`Warning: Omitting unknown assembly: "${x}"\n`);
         }
     }
     if (removeDuplicates) {
@@ -224,15 +213,6 @@ export function filterJsonList(json, keep, key) {
     }
     return results;
 }
-export const getUserCredentials = () => {
-    try {
-        const content = fs.readFileSync(CONFIG_PATH, { encoding: 'utf8' });
-        return JSON.parse(content);
-    }
-    catch {
-        return null;
-    }
-};
 export const generatePkceChallenge = () => {
     const codeVerifier = crypto.randomBytes(64).toString('hex');
     const codeChallenge = crypto
@@ -259,14 +239,17 @@ export const waitFor = (eventName, emitter) => {
     return promise;
 };
 export async function submitAssembly(address, accessToken, body, force) {
-    const assemblies = await queryApollo(address, accessToken, 'assemblies');
+    let assemblies = await queryApollo(address, accessToken, 'assemblies');
     for (const x of (await assemblies.json())) {
-        if (x['name'] === body.assemblyName) {
-            if (force) {
-                await deleteAssembly(address, accessToken, x['_id']);
-            }
-            else {
-                throw new Error(`Error: Assembly "${body.assemblyName}" already exists`);
+        const addedAssemblies = 'changes' in body ? body.changes : [body];
+        for (const addedAssembly of addedAssemblies) {
+            if (x.name === addedAssembly.assemblyName) {
+                if (force) {
+                    await deleteAssembly(address, accessToken, x._id);
+                }
+                else {
+                    throw new Error(`Error: Assembly "${addedAssembly.assemblyName}" already exists`);
+                }
             }
         }
     }
@@ -283,86 +266,32 @@ export async function submitAssembly(address, accessToken, body, force) {
     const response = await fetch(url, auth);
     if (!response.ok) {
         const errorMessage = await createFetchErrorMessage(response, 'submitAssembly failed');
-        throw new ConfigError(errorMessage);
-    }
-    return response;
-}
-class ProgressTransform extends Transform {
-    size = 0;
-    progressBar;
-    constructor(opts) {
-        super(opts);
-        this.progressBar = opts.progressBar;
-    }
-    _transform(chunk, _encoding, callback) {
-        this.size += chunk.length;
-        this.progressBar.update(this.size);
-        callback(null, chunk);
+        throw new Error(errorMessage);
     }
-}
-export async function uploadFile(address, accessToken, file, type) {
-    const filehandle = await fs.promises.open(file);
-    const { size } = await filehandle.stat();
-    const stream = filehandle.createReadStream();
-    const progressBar = new SingleBar({ etaBuffer: 100_000_000 });
-    const progressTransform = new ProgressTransform({ progressBar });
-    const body = pipeline(stream, progressTransform, (error) => {
-        if (error) {
-            progressBar.stop();
-            console.error('Error processing file.', error);
-            throw error;
-        }
-    });
-    const init = {
-        method: 'POST',
-        body,
-        duplex: 'half',
-        headers: {
-            Authorization: `Bearer ${accessToken}`,
-            'Content-Type': type,
-            'Content-Length': String(size),
-        },
-        dispatcher: new Agent({ headersTimeout: 60 * 60 * 1000 }),
-    };
-    const fileName = path.basename(file);
-    const url = new URL(localhostToAddress(`${address}/files`));
-    url.searchParams.set('name', fileName);
-    url.searchParams.set('type', type);
-    progressBar.start(size, 0);
-    try {
-        const response = await fetch(url, init);
-        if (!response.ok) {
-            const errorMessage = await createFetchErrorMessage(response, 'uploadFile failed');
-            throw new ConfigError(errorMessage);
+    assemblies = await queryApollo(address, accessToken, 'assemblies');
+    for (const x of (await assemblies.json())) {
+        const addedAssemblies = 'changes' in body ? body.changes : [body];
+        for (const addedAssembly of addedAssemblies) {
+            if (x.name === addedAssembly.assemblyName) {
+                return x;
+            }
         }
-        const json = (await response.json());
-        return json['_id'];
-    }
-    catch (error) {
-        console.error(error);
-        throw error;
-    }
-    finally {
-        progressBar.stop();
     }
+    throw new Error(`Failed to retrieve assembly from ${body.assembly}`);
 }
-/* Wrap text to max `length` per line */
-export function wrapLines(s, length) {
-    if (length === undefined) {
-        length = 80;
+export async function readStdin() {
+    const chunks = [];
+    for await (const chunk of stdin) {
+        chunks.push(Buffer.from(chunk));
     }
-    // Credit: https://stackoverflow.com/questions/14484787/wrap-text-in-javascript
-    const re = new RegExp(`(?![^\\n]{1,${length}}$)([^\\n]{1,${length}})\\s`, 'g');
-    s = s.replaceAll(/ +/g, ' ');
-    const wr = s.replace(re, '$1\n');
-    return wr;
+    return Buffer.concat(chunks).toString('utf8');
 }
-export function idReader(input, removeDuplicates = true) {
+export async function idReader(input, removeDuplicates = true) {
     let ids = [];
     for (const xin of input) {
         let data;
         if (xin == '-') {
-            data = fs.readFileSync('/dev/stdin').toString();
+            data = await readStdin();
         }
         else if (fs.existsSync(xin)) {
             data = fs.readFileSync(xin).toString();
@@ -371,14 +300,13 @@ export function idReader(input, removeDuplicates = true) {
             data = xin;
         }
         try {
-            data = JSON.parse(data);
-            if (data.length === undefined) {
-                data = [data];
+            let parsedData = JSON.parse(data);
+            if (!Array.isArray(parsedData)) {
+                parsedData = [parsedData];
             }
-            for (const x of data) {
-                const id = x['_id'];
-                if (id !== undefined) {
-                    ids.push(id);
+            for (const x of parsedData) {
+                if ('_id' in x && typeof x._id === 'string') {
+                    ids.push(x._id);
                 }
             }
         }