@apollo-annotation/cli 0.1.18 → 0.1.20

package/dist/commands/feature/import.js

@@ -1,9 +1,9 @@
 import * as fs from 'node:fs';
 import { Flags } from '@oclif/core';
-import { fetch } from 'undici';
-import { BaseCommand } from '../../baseCommand.js';
-import { convertAssemblyNameToId, createFetchErrorMessage, localhostToAddress, uploadFile, } from '../../utils.js';
-export default class Import extends BaseCommand {
+import { Agent, fetch } from 'undici';
+import { FileCommand } from '../../fileCommand.js';
+import { convertAssemblyNameToId, createFetchErrorMessage, localhostToAddress, } from '../../utils.js';
+export default class Import extends FileCommand {
     static summary = 'Import features from local gff file';
     static description = 'By default, features are added to the existing ones.';
     static examples = [
@@ -15,7 +15,7 @@ export default class Import extends BaseCommand {
     static flags = {
         'input-file': Flags.string({
             char: 'i',
-            description: 'Input gff or gtf file',
+            description: 'Input gff file',
             required: true,
         }),
         assembly: Flags.string({
@@ -33,45 +33,32 @@ export default class Import extends BaseCommand {
         if (!fs.existsSync(flags['input-file'])) {
             this.error(`File "${flags['input-file']}" does not exist`);
         }
-        const access = await this.getAccess(flags['config-file'], flags.profile);
+        const access = await this.getAccess();
         const assembly = await convertAssemblyNameToId(access.address, access.accessToken, [flags.assembly]);
         if (assembly.length === 0) {
             this.error(`Assembly "${flags.assembly}" does not exist. Perhaps you want to create this assembly first`);
         }
-        const uploadId = await uploadFile(access.address, access.accessToken, flags['input-file'], 'text/x-gff3');
-        const res = await importFeatures(access.address, access.accessToken, assembly[0], uploadId, flags['delete-existing']);
-        if (!res.ok) {
-            const errorMessage = await createFetchErrorMessage(res, 'Import features failed');
+        const uploadId = await this.uploadFile(access.address, access.accessToken, flags['input-file'], 'text/x-gff3', false);
+        const body = {
+            typeName: 'AddFeaturesFromFileChange',
+            assembly: assembly[0],
+            fileId: uploadId,
+            deleteExistingFeatures: flags['delete-existing'],
+        };
+        const auth = {
+            method: 'POST',
+            body: JSON.stringify(body),
+            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, 'importFeatures failed');
             throw new Error(errorMessage);
         }
-        this.exit(0);
     }
 }
-async function importFeatures(address, accessToken, assembly, fileId, deleteExistingFeatures) {
-    const body = {
-        typeName: 'AddFeaturesFromFileChange',
-        assembly,
-        fileId,
-        deleteExistingFeatures,
-    };
-    const controller = new AbortController();
-    setTimeout(() => {
-        controller.abort();
-    }, 24 * 60 * 60 * 1000);
-    const auth = {
-        method: 'POST',
-        body: JSON.stringify(body),
-        headers: {
-            Authorization: `Bearer ${accessToken}`,
-            'Content-Type': 'application/json',
-        },
-        signal: controller.signal,
-    };
-    const url = new URL(localhostToAddress(`${address}/changes`));
-    const response = await fetch(url, auth);
-    if (!response.ok) {
-        const errorMessage = await createFetchErrorMessage(response, 'importFeatures failed');
-        throw new Error(errorMessage);
-    }
-    return response;
-}

package/dist/commands/feature/search.js

@@ -2,7 +2,7 @@
 import { Flags } from '@oclif/core';
 import { fetch } from 'undici';
 import { BaseCommand } from '../../baseCommand.js';
-import { convertAssemblyNameToId, createFetchErrorMessage, idReader, localhostToAddress, queryApollo, wrapLines, } from '../../utils.js';
+import { convertAssemblyNameToId, createFetchErrorMessage, idReader, localhostToAddress, queryApollo, } from '../../utils.js';
 async function searchFeatures(address, accessToken, assemblies, term) {
     const url = new URL(localhostToAddress(`${address}/features/searchFeatures`));
     const searchParams = new URLSearchParams({
@@ -25,7 +25,7 @@ async function searchFeatures(address, accessToken, assemblies, term) {
 }
 export default class Search extends BaseCommand {
     static summary = 'Free text search for feature in one or more assemblies';
-    static description = wrapLines(`Return features matching a query string. This command searches only in:
+    static description = `Return features matching a query string. This command searches only in:
 
     - Attribute *values* (not attribute names)
     - Source field (which in fact is stored as an attribute)
@@ -47,7 +47,7 @@ export default class Search extends BaseCommand {
     - "with"
     - "Finger"
     - "chr1"
-    - "0.987"`);
+    - "0.987"`;
     static examples = [
         {
             description: 'Search "bac" in these assemblies:',
@@ -63,21 +63,21 @@ export default class Search extends BaseCommand {
         assembly: Flags.string({
             char: 'a',
             multiple: true,
-            description: wrapLines('Assembly names or IDs to search; use "-" to read it from stdin. If omitted search all assemblies'),
+            description: 'Assembly names or IDs to search; use "-" to read it from stdin. If omitted search all assemblies',
         }),
     };
     async run() {
         const { flags } = await this.parse(Search);
-        const access = await this.getAccess(flags['config-file'], flags.profile);
+        const access = await this.getAccess();
         let assemblyIds = [];
         if (flags.assembly === undefined) {
             const asm = await queryApollo(access.address, access.accessToken, 'assemblies');
             for (const x of (await asm.json())) {
-                assemblyIds.push(x['_id']);
+                assemblyIds.push(x._id);
             }
         }
         else {
-            const assembly = idReader(flags.assembly);
+            const assembly = await idReader(flags.assembly);
             assemblyIds = await convertAssemblyNameToId(access.address, access.accessToken, assembly);
         }
         if (assemblyIds.length === 0) {

package/dist/commands/file/delete.d.ts

@@ -0,0 +1,13 @@
+import { BaseCommand } from '../../baseCommand.js';
+export default class Delete extends BaseCommand<typeof Delete> {
+    static summary: string;
+    static description: string;
+    static examples: {
+        description: string;
+        command: string;
+    }[];
+    static flags: {
+        'file-id': import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[], import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/file/delete.js

@@ -0,0 +1,58 @@
+import { Flags } from '@oclif/core';
+import { fetch } from 'undici';
+import { BaseCommand } from '../../baseCommand.js';
+import { createFetchErrorMessage, filterJsonList, idReader, localhostToAddress, queryApollo, } from '../../utils.js';
+export default class Delete extends BaseCommand {
+    static summary = 'Delete files from the Apollo server';
+    static description = 'Deleted files are printed to stdout. See also `apollo file get` to list the files on the server';
+    static examples = [
+        {
+            description: 'Delete file multiple files:',
+            command: '<%= config.bin %> <%= command.id %> -i 123...abc xyz...789',
+        },
+    ];
+    static flags = {
+        'file-id': Flags.string({
+            char: 'i',
+            description: 'IDs of the files to delete',
+            default: ['-'],
+            multiple: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Delete);
+        const access = await this.getAccess();
+        const files = await queryApollo(access.address, access.accessToken, 'files');
+        const json = (await files.json());
+        const ff = await idReader(flags['file-id']);
+        let deleted = [];
+        for (const id of ff) {
+            const res = await deleteFile(access.address, access.accessToken, id);
+            if (res.status === 404) {
+                this.logToStderr(`File id "${id}" not found`);
+            }
+            else {
+                const fid = filterJsonList(json, [id], '_id');
+                deleted = [...deleted, ...fid];
+            }
+        }
+        this.log(JSON.stringify(deleted, null, 2));
+        this.logToStderr(`${deleted.length.toString()} file(s) deleted.`);
+    }
+}
+async function deleteFile(address, accessToken, fileId) {
+    const auth = {
+        method: 'DELETE',
+        headers: {
+            Authorization: `Bearer ${accessToken}`,
+            'Content-Type': 'application/json',
+        },
+    };
+    const url = new URL(localhostToAddress(`${address}/files/${fileId}`));
+    const response = await fetch(url, auth);
+    if (!response.ok && response.status != 404) {
+        const errorMessage = await createFetchErrorMessage(response, 'deleteFile failed');
+        throw new Error(errorMessage);
+    }
+    return response;
+}

package/dist/commands/file/download.d.ts

@@ -0,0 +1,14 @@
+import { BaseCommand } from '../../baseCommand.js';
+export default class Download extends BaseCommand<typeof Download> {
+    static summary: string;
+    static description: string;
+    static examples: {
+        description: string;
+        command: string;
+    }[];
+    static flags: {
+        'file-id': import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        output: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/file/download.js

@@ -0,0 +1,45 @@
+import { createWriteStream } from 'node:fs';
+import { Writable } from 'node:stream';
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../baseCommand.js';
+import { filterJsonList, idReader, queryApollo } from '../../utils.js';
+export default class Download extends BaseCommand {
+    static summary = 'Download a file from the Apollo server';
+    static description = 'See also `apollo file get` to list the files on the server';
+    static examples = [
+        {
+            description: 'Download file with id xyz',
+            command: '<%= config.bin %> <%= command.id %> -i xyz -o genome.fa',
+        },
+    ];
+    static flags = {
+        'file-id': Flags.string({
+            char: 'i',
+            description: 'ID of the file to download',
+            default: '-',
+        }),
+        output: Flags.string({
+            char: 'o',
+            description: 'Write output to this file or "-" for stdout. Default to the name of the uploaded file.',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Download);
+        const access = await this.getAccess();
+        const ff = await idReader([flags['file-id']]);
+        let res = await queryApollo(access.address, access.accessToken, 'files');
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const json = JSON.parse(await res.text());
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        const [fileRec] = filterJsonList(json, ff, '_id');
+        const fileId = fileRec['_id'];
+        res = await queryApollo(access.address, access.accessToken, `files/${fileId}`);
+        let { output } = flags;
+        if (output === undefined) {
+            output = fileRec['basename'];
+        }
+        const fileWriteStream = createWriteStream(output);
+        await res.body?.pipeTo(Writable.toWeb(output === '-' ? process.stdout : fileWriteStream));
+        fileWriteStream.close();
+    }
+}

package/dist/commands/file/get.d.ts

@@ -0,0 +1,13 @@
+import { BaseCommand } from '../../baseCommand.js';
+export default class Get extends BaseCommand<typeof Get> {
+    static summary: string;
+    static description: string;
+    static examples: {
+        description: string;
+        command: string;
+    }[];
+    static flags: {
+        'file-id': import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/file/get.js

@@ -0,0 +1,38 @@
+import { Flags } from '@oclif/core';
+import { BaseCommand } from '../../baseCommand.js';
+import { idReader, queryApollo } from '../../utils.js';
+export default class Get extends BaseCommand {
+    static summary = 'Get list of files uploaded to the Apollo server';
+    static description = 'Print to stdout the list of files in json format';
+    static examples = [
+        {
+            description: 'Get files by id:',
+            command: '<%= config.bin %> <%= command.id %> -i xyz abc',
+        },
+    ];
+    static flags = {
+        'file-id': Flags.string({
+            char: 'i',
+            description: 'Get files matching this IDs',
+            multiple: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Get);
+        const access = await this.getAccess();
+        const files = await queryApollo(access.address, access.accessToken, 'files');
+        const json = (await files.json());
+        let fileIds = [];
+        if (flags['file-id'] !== undefined) {
+            fileIds = await idReader(flags['file-id']);
+        }
+        const keep = [];
+        for (const x of json) {
+            if (flags['file-id'] === undefined ||
+                fileIds.includes(x['_id'])) {
+                keep.push(x);
+            }
+        }
+        this.log(JSON.stringify(keep, null, 2));
+    }
+}

package/dist/commands/file/upload.d.ts

@@ -0,0 +1,16 @@
+import { FileCommand } from '../../fileCommand.js';
+export default class Upload extends FileCommand {
+    static summary: string;
+    static description: string;
+    static examples: {
+        description: string;
+        command: string;
+    }[];
+    static flags: {
+        'input-file': import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        type: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        gzip: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        decompressed: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/file/upload.js

@@ -0,0 +1,88 @@
+import { Flags } from '@oclif/core';
+import { FileCommand } from '../../fileCommand.js';
+import { filterJsonList, queryApollo } from '../../utils.js';
+export default class Upload extends FileCommand {
+    static summary = 'Upload a local file to the Apollo server';
+    static description = `This command only uploads a file and returns the corresponding file id.
+  To add an assembly based on this file or to upload & add an assembly in a single pass \
+  see \`apollo assembly add-from-fasta\` and \`add-from-gff\``;
+    static examples = [
+        {
+            description: 'Upload local file, type auto-detected:',
+            command: '<%= config.bin %> <%= command.id %> -i genome.fa > file.json',
+        },
+    ];
+    static flags = {
+        'input-file': Flags.string({
+            char: 'i',
+            description: 'Local file to upload',
+            required: true,
+        }),
+        type: Flags.string({
+            char: 't',
+            description: 'Set file type or autodetected it if not set.\n\
+        NB: There is no check for whether the file complies to this type',
+            options: [
+                'text/x-fasta',
+                'text/x-gff3',
+                'application/x-bgzip-fasta',
+                'text/x-fai',
+                'application/x-gzi',
+            ],
+        }),
+        gzip: Flags.boolean({
+            char: 'z',
+            description: 'Override autodetection and instruct that input is gzip compressed',
+            exclusive: ['decompressed'],
+        }),
+        decompressed: Flags.boolean({
+            char: 'd',
+            description: 'Override autodetection and instruct that input is decompressed',
+            exclusive: ['gzip'],
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Upload);
+        const access = await this.getAccess();
+        let { type } = flags;
+        if (type === undefined) {
+            const hasGzipExt = flags['input-file'].endsWith('.gz');
+            const infile = flags['input-file'].replace(/\.gz$/, '');
+            if (/\.fasta$|\.fas$|\.fa$|\.fna$/.test(infile) && hasGzipExt) {
+                this.error(`Unable to auto-detect file type for "${flags['input-file']}" since it may be gzip or bgzip compressed. Please set the -t/--type option`);
+            }
+            else if (/\.fasta$|\.fas$|\.fa$|\.fna$/.test(infile)) {
+                type = 'text/x-fasta';
+            }
+            else if (/\.gff$|\.gff3/.test(infile)) {
+                type = 'text/x-gff3';
+            }
+            else if (infile.endsWith('.fai')) {
+                type = 'text/x-fai';
+            }
+            else if (infile.endsWith('.gzi')) {
+                type = 'application/x-gzi';
+            }
+            else {
+                this.error(`Unable to auto-detect the type of file "${flags['input-file']}". Please set the --type/-t option.`);
+            }
+        }
+        let isGzip = flags['input-file'].endsWith('.gz');
+        // eslint-disable-next-line unicorn/consistent-destructuring
+        if (flags.gzip) {
+            isGzip = true;
+        }
+        // eslint-disable-next-line unicorn/consistent-destructuring
+        if (flags.decompressed) {
+            isGzip = false;
+        }
+        this.logToStderr(`Input is gzip'd: ${isGzip}`);
+        const fileId = await this.uploadFile(access.address, access.accessToken, flags['input-file'], type, isGzip);
+        const res = await queryApollo(access.address, access.accessToken, 'files');
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const json = JSON.parse(await res.text());
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        const [rec] = filterJsonList(json, [fileId], '_id');
+        this.log(JSON.stringify(rec, null, 2));
+    }
+}

package/dist/commands/jbrowse/get-config.d.ts

@@ -0,0 +1,10 @@
+import { BaseCommand } from '../../baseCommand.js';
+export default class GetConfig extends BaseCommand<typeof GetConfig> {
+    static summary: string;
+    static description: string;
+    static examples: {
+        description: string;
+        command: string;
+    }[];
+    run(): Promise<void>;
+}

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

@@ -0,0 +1,21 @@
+import { BaseCommand } from '../../baseCommand.js';
+import { queryApollo } from '../../utils.js';
+export default class GetConfig extends BaseCommand {
+    static summary = 'Get JBrowse configuration from Apollo';
+    static description = 'Print to stdout the JBrowse configuration from Apollo in JSON format';
+    static examples = [
+        {
+            description: 'Get JBrowse configuration:',
+            command: '<%= config.bin %> <%= command.id %> > config.json',
+        },
+    ];
+    async run() {
+        const access = await this.getAccess();
+        const response = await queryApollo(access.address, access.accessToken, 'jbrowse/config.json');
+        if (!response.ok) {
+            throw new Error('Failed to fetch JBrowse configuration');
+        }
+        const json = (await response.json());
+        this.log(JSON.stringify(json, null, 2));
+    }
+}

package/dist/commands/jbrowse/set-config.d.ts

@@ -0,0 +1,13 @@
+import { BaseCommand } from '../../baseCommand.js';
+export default class SetConfig extends BaseCommand<typeof SetConfig> {
+    static summary: string;
+    static description: string;
+    static examples: {
+        description: string;
+        command: string;
+    }[];
+    static args: {
+        inputFile: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

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',
         },
     ];
@@ -55,7 +55,7 @@ export default class Login extends BaseCommand {
         const { flags } = await this.parse(Login);
         let configFile = flags['config-file'];
         if (configFile === undefined) {
-            configFile = path.join(this.config.configDir, 'config.yaml');
+            configFile = path.join(this.config.configDir, 'config.yml');
         }
         let profileName = flags.profile;
         if (profileName === undefined) {
@@ -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:',
@@ -23,7 +23,7 @@ export default class Logout extends BaseCommand {
         }
         let configFile = flags['config-file'];
         if (configFile === undefined) {
-            configFile = path.join(this.config.configDir, 'config.yaml');
+            configFile = path.join(this.config.configDir, 'config.yml');
         }
         basicCheckConfig(configFile, profileName);
         const config = new ApolloConf(configFile);

package/dist/commands/{assembly/add-fasta.d.ts → refseq/add-alias.d.ts}

@@ -1,5 +1,6 @@
 import { BaseCommand } from '../../baseCommand.js';
-export default class Get extends BaseCommand<typeof Get> {
+export default class AddRefNameAlias extends BaseCommand<typeof AddRefNameAlias> {
+    static summary: string;
     static description: string;
     static examples: {
         description: string;
@@ -7,9 +8,7 @@ export default class Get extends BaseCommand<typeof Get> {
     }[];
     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 | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
-        index: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
-        force: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        assembly: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
     };
     run(): Promise<void>;
 }