@apollo-annotation/cli 0.1.10

package/dist/commands/feature/get-id.js

@@ -0,0 +1,56 @@
+import { Flags } from '@oclif/core';
+import { fetch } from 'undici';
+import { BaseCommand } from '../../baseCommand.js';
+import { createFetchErrorMessage, idReader, localhostToAddress, wrapLines, } from '../../utils.js';
+export default class Get extends BaseCommand {
+    static summary = 'Get features given their identifiers';
+    static description = wrapLines('Invalid identifiers or identifiers not found in the database will be silently ignored');
+    static examples = [
+        {
+            description: 'Get features for these identifiers:',
+            command: '<%= config.bin %> <%= command.id %> -i abc...zyz def...foo',
+        },
+    ];
+    static flags = {
+        'feature-id': Flags.string({
+            char: 'i',
+            description: wrapLines('Retrieves feature with these IDs. Use "-" to read IDs from stdin (one per line)', 40),
+            multiple: true,
+            default: ['-'],
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Get);
+        const access = await this.getAccess(flags['config-file'], flags.profile);
+        let ids = idReader(flags['feature-id']);
+        ids = [...new Set(ids)];
+        const results = [];
+        for (const id of ids) {
+            const res = await this.getFeatureId(access.address, access.accessToken, id);
+            if (Object.keys(res).length === 0) {
+                continue;
+            }
+            results.push(res);
+        }
+        this.log(JSON.stringify(results, null, 2));
+        this.exit(0);
+    }
+    async getFeatureId(address, token, featureId) {
+        const url = new URL(localhostToAddress(`${address}/features/${featureId}`));
+        const auth = {
+            headers: {
+                authorization: `Bearer ${token}`,
+                'Content-Type': 'application/json',
+            },
+        };
+        const response = await fetch(url, auth);
+        if (!response.ok) {
+            if (response.status === 404) {
+                return {};
+            }
+            const errorMessage = await createFetchErrorMessage(response, 'Failed to access Apollo with the current address and/or access token\nThe server returned:\n');
+            throw new Error(errorMessage);
+        }
+        return (await response.json());
+    }
+}

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

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

package/dist/commands/feature/get.js

@@ -0,0 +1,87 @@
+import { Flags } from '@oclif/core';
+import { fetch } from 'undici';
+import { BaseCommand } from '../../baseCommand.js';
+import { createFetchErrorMessage, getRefseqId, localhostToAddress, wrapLines, } from '../../utils.js';
+export default class Get extends BaseCommand {
+    static description = 'Get features in assembly, reference sequence or genomic window';
+    static examples = [
+        {
+            description: 'Get all features in myAssembly:',
+            command: '<%= config.bin %> <%= command.id %> -a myAssembly',
+        },
+        {
+            description: wrapLines('Get features intersecting chr1:1..1000. You can omit the assembly name if there are no other reference sequences named chr1:'),
+            command: '<%= config.bin %> <%= command.id %> -a myAssembly -r chr1 -s 1 -e 1000',
+        },
+    ];
+    static flags = {
+        assembly: Flags.string({
+            char: 'a',
+            description: 'Find input reference sequence in this assembly',
+        }),
+        refseq: Flags.string({
+            char: 'r',
+            description: 'Reference sequence. If unset, query all sequences',
+        }),
+        start: Flags.integer({
+            char: 's',
+            description: 'Start coordinate (1-based)',
+            default: 1,
+        }),
+        end: Flags.integer({
+            char: 'e',
+            description: 'End coordinate',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Get);
+        const endCoord = flags.end ?? Number.MAX_SAFE_INTEGER;
+        if (flags.start <= 0 || endCoord <= 0) {
+            this.logToStderr('Start and end coordinates must be greater than 0.');
+            this.exit(1);
+        }
+        const access = await this.getAccess(flags['config-file'], flags.profile);
+        let refseqIds = [];
+        try {
+            refseqIds = await getRefseqId(access.address, access.accessToken, flags.refseq, flags.assembly);
+        }
+        catch (error) {
+            this.logToStderr(error.message);
+            this.exit(1);
+        }
+        if (refseqIds.length === 0) {
+            this.logToStderr('No reference sequence found');
+        }
+        const results = [];
+        for (const refseq of refseqIds) {
+            const features = await this.getFeatures(access.address, access.accessToken, refseq, flags.start, endCoord);
+            const json = (await features.json());
+            for (const x of json[0]) {
+                results.push(x);
+            }
+        }
+        this.log(JSON.stringify(results, null, 2));
+        this.exit(0);
+    }
+    async getFeatures(address, token, refSeq, start, end) {
+        const url = new URL(localhostToAddress(`${address}/features/getFeatures`));
+        const searchParams = new URLSearchParams({
+            refSeq,
+            start: start.toString(),
+            end: end.toString(),
+        });
+        url.search = searchParams.toString();
+        const auth = {
+            headers: {
+                authorization: `Bearer ${token}`,
+                'Content-Type': 'application/json',
+            },
+        };
+        const response = await fetch(url, auth);
+        if (!response.ok) {
+            const errorMessage = await createFetchErrorMessage(response, 'Failed to access Apollo with the current address and/or access token\nThe server returned:\n');
+            throw new Error(errorMessage);
+        }
+        return response;
+    }
+}

package/dist/commands/feature/import.d.ts

@@ -0,0 +1,15 @@
+import { BaseCommand } from '../../baseCommand.js';
+export default class Import extends BaseCommand<typeof Import> {
+    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>;
+        assembly: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        'delete-existing': import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/feature/import.js

@@ -0,0 +1,83 @@
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+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 {
+    static summary = 'Import features from local gff file';
+    static description = 'By default, features are added to the existing ones.';
+    static examples = [
+        {
+            description: 'Delete features in myAssembly and then import features.gff3:',
+            command: '<%= config.bin %> <%= command.id %> -d -i features.gff3 -a myAssembly',
+        },
+    ];
+    static flags = {
+        'input-file': Flags.string({
+            char: 'i',
+            description: 'Input gff or gtf file',
+            required: true,
+        }),
+        assembly: Flags.string({
+            char: 'a',
+            description: 'Import into this assembly name or assembly ID',
+            required: true,
+        }),
+        'delete-existing': Flags.boolean({
+            char: 'd',
+            description: 'Delete existing features before importing',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Import);
+        if (!fs.existsSync(flags['input-file'])) {
+            this.logToStderr(`File "${flags['input-file']}" does not exist`);
+            this.exit(1);
+        }
+        const access = await this.getAccess(flags['config-file'], flags.profile);
+        const assembly = await convertAssemblyNameToId(access.address, access.accessToken, [flags.assembly]);
+        if (assembly.length === 0) {
+            this.logToStderr(`Assembly "${flags.assembly}" does not exist. Perhaps you want to create this assembly first`);
+            this.exit(1);
+        }
+        const uploadId = await uploadFile(access.address, access.accessToken, flags['input-file'], 'text/x-gff3');
+        const response = await importFeatures(access.address, access.accessToken, assembly[0], uploadId, flags['delete-existing']);
+        if (!response.ok) {
+            const json = JSON.parse(await response.text());
+            const message = json['message'];
+            this.logToStderr(message);
+            this.exit(1);
+        }
+        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.d.ts

@@ -0,0 +1,14 @@
+import { BaseCommand } from '../../baseCommand.js';
+export default class Search extends BaseCommand<typeof Search> {
+    static summary: string;
+    static description: string;
+    static examples: {
+        description: string;
+        command: string;
+    }[];
+    static flags: {
+        text: 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>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/feature/search.js

@@ -0,0 +1,91 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+import { Flags } from '@oclif/core';
+import { fetch } from 'undici';
+import { BaseCommand } from '../../baseCommand.js';
+import { convertAssemblyNameToId, createFetchErrorMessage, idReader, localhostToAddress, queryApollo, wrapLines, } from '../../utils.js';
+async function searchFeatures(address, accessToken, assemblies, term) {
+    const url = new URL(localhostToAddress(`${address}/features/searchFeatures`));
+    const searchParams = new URLSearchParams({
+        assemblies: assemblies.join(','),
+        term,
+    });
+    url.search = searchParams.toString();
+    const uri = url.toString();
+    const auth = {
+        headers: {
+            authorization: `Bearer ${accessToken}`,
+        },
+    };
+    const response = await fetch(uri, auth);
+    if (!response.ok) {
+        const errorMessage = await createFetchErrorMessage(response, 'searchFeatures failed');
+        throw new Error(errorMessage);
+    }
+    return response;
+}
+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:
+
+    - Attribute *values* (not attribute names)
+    - Source field (which in fact is stored as an attribute)
+    - Feature type
+
+    The search mode is:
+
+    - Case insensitive
+    - Match only full words, but not necessarily the full value
+    - Common words are ignored. E.g. "the", "with"
+
+    For example, given this feature:
+
+    chr1 example SNP 10 30 0.987 . . "someKey=Fingerprint BAC with reads"
+
+    Queries "bac" or "mRNA" return the feature. Instead these queries will NOT match:
+
+    - "someKey"
+    - "with"
+    - "Finger"
+    - "chr1"
+    - "0.987"`);
+    static examples = [
+        {
+            description: 'Search "bac" in these assemblies:',
+            command: '<%= config.bin %> <%= command.id %> -a mm9 mm10 -t bac',
+        },
+    ];
+    static flags = {
+        text: Flags.string({
+            char: 't',
+            required: true,
+            description: 'Search for this text query',
+        }),
+        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'),
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Search);
+        const access = await this.getAccess(flags['config-file'], flags.profile);
+        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']);
+            }
+        }
+        else {
+            const assembly = idReader(flags.assembly);
+            assemblyIds = await convertAssemblyNameToId(access.address, access.accessToken, assembly);
+        }
+        if (assemblyIds.length === 0) {
+            this.log(JSON.stringify([], null, 2));
+            this.exit(0);
+        }
+        const response = await searchFeatures(access.address, access.accessToken, assemblyIds, flags.text);
+        const results = JSON.parse(await response.text());
+        this.log(JSON.stringify(results, null, 2));
+    }
+}

package/dist/commands/login.d.ts

@@ -0,0 +1,21 @@
+import { BaseCommand } from '../baseCommand.js';
+export default class Login extends BaseCommand<typeof Login> {
+    static summary: string;
+    static description: string;
+    static examples: {
+        description: string;
+        command: string;
+    }[];
+    static flags: {
+        address: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        username: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        password: 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>;
+        port: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<number, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    run(): Promise<void>;
+    private checkUserAlreadyLoggedIn;
+    private startRootLogin;
+    private startGuestLogin;
+    private startAuthorizationCodeFlow;
+}

package/dist/commands/login.js

@@ -0,0 +1,206 @@
+/* eslint-disable @typescript-eslint/require-await */
+/* eslint-disable @typescript-eslint/no-misused-promises */
+/* eslint-disable @typescript-eslint/no-unnecessary-condition */
+import EventEmitter from 'node:events';
+import * as http from 'node:http';
+import path from 'node:path';
+import * as querystring from 'node:querystring';
+import { Errors, Flags, ux } from '@oclif/core';
+import open from 'open';
+import { fetch } from 'undici';
+import { BaseCommand } from '../baseCommand.js';
+import { Config, ConfigError } from '../Config.js';
+import { basicCheckConfig, createFetchErrorMessage, getUserCredentials, localhostToAddress, waitFor, wrapLines, } 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 examples = [
+        {
+            description: wrapLines('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:'),
+            command: '<%= config.bin %> <%= command.id %> --profile my-profile',
+        },
+    ];
+    static flags = {
+        address: Flags.string({
+            char: 'a',
+            description: 'Address of Apollo server',
+            required: false,
+        }),
+        username: Flags.string({
+            char: 'u',
+            description: 'Username for root login',
+            required: false,
+        }),
+        password: Flags.string({
+            char: 'p',
+            description: 'Password for <username>',
+            required: false,
+        }),
+        force: Flags.boolean({
+            char: 'f',
+            description: 'Force re-authentication even if user is already logged in',
+        }),
+        port: Flags.integer({
+            description: 'Get token by listening to this port number (usually this is >= 1024 and < 65536)',
+            default: 3000,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Login);
+        let configFile = flags['config-file'];
+        if (configFile === undefined) {
+            configFile = path.join(this.config.configDir, 'config.yaml');
+        }
+        let profileName = flags.profile;
+        if (profileName === undefined) {
+            profileName = process.env.APOLLO_PROFILE ?? 'default';
+        }
+        try {
+            basicCheckConfig(configFile, profileName);
+        }
+        catch (error) {
+            if (error instanceof ConfigError) {
+                this.logToStderr(error.message);
+                this.exit(1);
+            }
+        }
+        const config = new Config(configFile);
+        const accessType = config.get('accessType', profileName);
+        const address = flags.address ?? config.get('address', profileName);
+        if (address === undefined) {
+            this.logToStderr('Address to apollo must be set');
+            this.exit(1);
+        }
+        let userCredentials = { accessToken: '' };
+        try {
+            if (!flags.force) {
+                await this.checkUserAlreadyLoggedIn();
+            }
+            if (accessType === 'root' || flags.username !== undefined) {
+                const username = flags.username ?? config.get('rootCredentials.username', profileName);
+                const password = flags.password ?? config.get('rootCredentials.password', profileName);
+                if (username === undefined || password === undefined) {
+                    this.logToStderr('Username and password must be set');
+                    this.exit(1);
+                }
+                userCredentials = await this.startRootLogin(address, username, password);
+            }
+            else if (accessType === 'guest') {
+                userCredentials = await this.startGuestLogin(address);
+            }
+            else if (accessType === undefined) {
+                this.logToStderr('Undefined access type');
+                this.exit(1);
+            }
+            else {
+                userCredentials = await this.startAuthorizationCodeFlow(address, accessType, flags.port);
+            }
+        }
+        catch (error) {
+            if ((error instanceof Errors.CLIError && error.message === 'ctrl-c') ||
+                error instanceof Errors.ExitError) {
+                this.exit(0);
+            }
+            else if (error instanceof Error) {
+                this.logToStderr(error.stack);
+                ux.action.stop(error.message);
+                this.exit(1);
+            }
+        }
+        config.set('accessToken', userCredentials.accessToken, profileName);
+        config.writeConfigFile();
+    }
+    async checkUserAlreadyLoggedIn() {
+        const userCredentials = getUserCredentials();
+        if (!userCredentials) {
+            return;
+        }
+        const alreadyLoggedIn = Object.keys(userCredentials).every((key) => Boolean(userCredentials[key]));
+        if (!alreadyLoggedIn) {
+            return;
+        }
+        const reAuthenticate = await ux.confirm("You're already logged. Do you want to re-authenticate? (y/n)");
+        if (!reAuthenticate) {
+            this.exit(0);
+        }
+    }
+    async startRootLogin(address, username, password) {
+        const url = localhostToAddress(`${address}/auth/root`);
+        const response = await fetch(url, {
+            headers: { 'Content-Type': 'application/json' },
+            method: 'POST',
+            body: JSON.stringify({ username, password }),
+        });
+        if (!response.ok) {
+            const errorMessage = await createFetchErrorMessage(response, 'startRootLogin failed');
+            throw new Error(errorMessage);
+        }
+        const dat = await response.json();
+        if (typeof dat === 'object' && dat !== null && 'token' in dat) {
+            return { accessToken: dat.token };
+        }
+        throw new Error(`Unexpected response: ${JSON.stringify(dat)}`);
+    }
+    async startGuestLogin(address) {
+        const url = localhostToAddress(`${address}/auth/login?type=guest`);
+        const response = await fetch(url, {
+            headers: { 'Content-Type': 'application/json' },
+        });
+        if (!response.ok) {
+            const errorMessage = await createFetchErrorMessage(response, 'startGuestLogin failed');
+            throw new Error(errorMessage);
+        }
+        const dat = await response.json();
+        if (typeof dat === 'object' && dat !== null && 'token' in dat) {
+            return { accessToken: dat.token };
+        }
+        throw new Error(`Unexpected response: ${JSON.stringify(dat)}`);
+    }
+    async startAuthorizationCodeFlow(address, accessType, port) {
+        const callbackPath = '/';
+        // eslint-disable-next-line unicorn/prefer-event-target
+        const emitter = new EventEmitter();
+        const eventName = 'authorication_code_callback_params';
+        const server = http
+            .createServer((req, res) => {
+            if (req?.url?.startsWith(callbackPath)) {
+                const params = querystring.decode(req?.url.replace(`${callbackPath}?`, ''));
+                emitter.emit(eventName, params);
+                res.end('This browser window was opened by `apollo login`, you can close it now.');
+                res.socket?.end();
+                res.socket?.destroy();
+                server.close();
+            }
+            else {
+                // TODO: handle an invalid URL address
+                res.end('Unsupported');
+                emitter.emit(eventName, new Error('Invalid URL address'));
+            }
+        })
+            .listen(port);
+        server.on('error', async (e) => {
+            if (e.message.includes('EADDRINUSE')) {
+                this.logToStderr(`It appears that port ${port} is in use. Perhaps you have JBrowse running?\nTry using a different port using the --port option or temporarily stop JBrowse`);
+                // eslint-disable-next-line unicorn/no-process-exit
+                process.exit(1);
+            }
+            else {
+                this.logToStderr(e.message);
+                // eslint-disable-next-line unicorn/no-process-exit
+                process.exit(1);
+            }
+        });
+        // await ux.anykey('Press any key to open your browser') // Do we need this?
+        const authorizationCodeURL = `${address}/auth/login?type=${accessType}&redirect_uri=http://localhost:${port}${callbackPath}`;
+        await open(authorizationCodeURL);
+        ux.action.start('Waiting for authentication');
+        const { access_token } = await waitFor(eventName, emitter);
+        return { accessToken: access_token };
+    }
+}

package/dist/commands/login.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/login.test.js

@@ -0,0 +1,52 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+import fs from 'node:fs';
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { expect, test } from '@oclif/test';
+import YAML from 'yaml';
+import { CONFIG_FILE, TEST_DATA_DIR, VERBOSE, copyFile, } from '../test/fixtures.js';
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+describe('apollo login: Config file does not exist', () => {
+    const cmd = ['login', '--config-file', '_tmp.yaml'];
+    test
+        .stderr()
+        .command(cmd, { root: dirname(dirname(__dirname)) })
+        .exit(1)
+        .do((output) => expect(output.stderr).to.contain('apollo config'))
+        .it(cmd.join(' '));
+});
+describe('apollo login: Profile does not exist', () => {
+    const cmd = [
+        'login',
+        '--config-file',
+        'test_data/complete_config.yaml',
+        '--profile',
+        'notavailable',
+    ];
+    test
+        .stderr()
+        .command(cmd, { root: dirname(dirname(__dirname)) })
+        .exit(1)
+        .do((output) => expect(output.stderr).to.contain('apollo config'))
+        .do((output) => expect(output.stderr).to.contain('Profile'))
+        .do((output) => expect(output.stderr).to.contain('notavailable'))
+        .it(cmd.join(' '));
+});
+// TODO: Mock server
+describe.skip('apollo login: Add token for guest', () => {
+    before(() => {
+        copyFile(`${TEST_DATA_DIR}/guest.yaml`, CONFIG_FILE, VERBOSE);
+    });
+    after(() => {
+        fs.rmSync(CONFIG_FILE);
+    });
+    const cmd = ['login'];
+    test
+        .stdout()
+        .command(cmd, { root: dirname(dirname(__dirname)) })
+        .it(cmd.join(' '), () => {
+        const cfg = YAML.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+        expect(cfg.default.accessToken).not.empty;
+    });
+});

package/dist/commands/logout.d.ts

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