@tolgee/cli 1.0.0-prerelease.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022-Present Tolgee s.r.o.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,34 @@
+# Tolgee CLI 🐁
+
+An experimental 🧪 command line tool to interact with Tolgee directly from your terminal.
+
+The CLI lets you pull strings from the Tolgee platform into your projects, push local strings to the Tolgee platform,
+extract strings from your code, and much more!
+
+- Pull requests welcome! 🤩
+
+## Installation
+The Tolgee CLI is published as a NPM package. You simply need to install it, and you're good to go!
+```sh
+npm i --global @tolgee/cli
+```
+
+> **Warning**: The Tolgee CLI is currently experimental and subject to bugs. Breaking changes may happen before stable release!
+>
+> Help us reach stable version faster by reporting any bug you encounter on the [issue tracker](https://github.com/tolgee/tolgee-cli/issues/new?labels=bug).
+> Feedback is also greatly appreciated!
+
+See our [documentation](https://tolgee.io/tolgee-cli/installation) for more information.
+
+## Usage
+Once installed, you'll have access to the `tolgee` command. Run `tolgee help` to see all the supported commands, their
+options and arguments.
+
+Make sure to give the [docs](https://tolgee.io/tolgee-cli/usage) a look!
+
+## Contributing
+Contributions are welcome! Check out [HACKING.md](HACKING.md) for some information about the project internals and
+information about the workflow.
+
+----
+🧀

package/dist/client/errors.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpError = void 0;
+class HttpError extends Error {
+    request;
+    response;
+    constructor(request, response, options) {
+        super(response.statusText, options);
+        this.request = request;
+        this.response = response;
+    }
+    getErrorText() {
+        // Unauthorized
+        if (this.response.status === 400) {
+            return 'Invalid request data.';
+        }
+        // Unauthorized
+        if (this.response.status === 401) {
+            return 'Missing or invalid authentication token.';
+        }
+        // Forbidden
+        if (this.response.status === 403) {
+            return 'You are not allowed to perform this operation.';
+        }
+        // Service Unavailable
+        if (this.response.status === 503) {
+            return 'API is temporarily unavailable. Please try again later.';
+        }
+        // Server error
+        if (this.response.status >= 500) {
+            return `API reported a server error (${this.response.status}). Please try again later.`;
+        }
+        return `Unknown error (HTTP ${this.response.status})`;
+    }
+}
+exports.HttpError = HttpError;

package/dist/client/export.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ExportClient {
+    requester;
+    constructor(requester) {
+        this.requester = requester;
+    }
+    async export(req) {
+        return this.requester.requestBlob({
+            method: 'POST',
+            path: `${this.requester.projectUrl}/export`,
+            body: { ...req, zip: true },
+        });
+    }
+    async exportSingle(req) {
+        return this.requester.requestJson({
+            method: 'POST',
+            path: `${this.requester.projectUrl}/export`,
+            body: { ...req, zip: false },
+        });
+    }
+}
+exports.default = ExportClient;

package/dist/client/import.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const form_data_1 = __importDefault(require("form-data"));
+const errors_1 = require("./errors");
+class ImportClient {
+    requester;
+    constructor(requester) {
+        this.requester = requester;
+    }
+    async addFiles(req) {
+        const body = new form_data_1.default();
+        for (const file of req.files) {
+            body.append('files', file.data, { filepath: file.name });
+        }
+        return this.requester.requestJson({
+            method: 'POST',
+            path: `${this.requester.projectUrl}/import`,
+            body: body,
+        });
+    }
+    async conflictsOverrideAll(languageId) {
+        await this.requester.requestVoid({
+            method: 'PUT',
+            path: `${this.requester.projectUrl}/import/result/languages/${languageId}/resolve-all/set-override`,
+        });
+    }
+    async conflictsKeepExistingAll(languageId) {
+        await this.requester.requestVoid({
+            method: 'PUT',
+            path: `${this.requester.projectUrl}/import/result/languages/${languageId}/resolve-all/set-keep-existing`,
+        });
+    }
+    async applyImport(req) {
+        await this.requester.requestVoid({
+            method: 'PUT',
+            path: `${this.requester.projectUrl}/import/apply`,
+            query: { forceMode: req?.forceMode },
+        });
+    }
+    async deleteImport() {
+        await this.requester.requestVoid({
+            method: 'DELETE',
+            path: `${this.requester.projectUrl}/import`,
+        });
+    }
+    /* Helper functions */
+    async deleteImportIfExists() {
+        try {
+            await this.deleteImport();
+        }
+        catch (e) {
+            if (e instanceof errors_1.HttpError && e.response.status === 404)
+                return;
+            throw e;
+        }
+    }
+}
+exports.default = ImportClient;

package/dist/client/index.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const base32_decode_1 = __importDefault(require("base32-decode"));
+const requester_1 = __importDefault(require("./internal/requester"));
+const project_1 = __importDefault(require("./project"));
+const languages_1 = __importDefault(require("./languages"));
+const import_1 = __importDefault(require("./import"));
+const export_1 = __importDefault(require("./export"));
+const constants_1 = require("../constants");
+class RestClient {
+    params;
+    requester;
+    project;
+    languages;
+    import;
+    export;
+    constructor(params) {
+        this.params = params;
+        this.requester = new requester_1.default(params);
+        this.project = new project_1.default(this.requester);
+        this.languages = new languages_1.default(this.requester);
+        this.import = new import_1.default(this.requester);
+        this.export = new export_1.default(this.requester);
+    }
+    async getProjectApiKeyInformation() {
+        return this.requester.requestJson({
+            path: '/v2/api-keys/current',
+            method: 'GET',
+        });
+    }
+    getProjectId() {
+        return this.params.projectId;
+    }
+    static projectIdFromKey(key) {
+        const keyBuffer = (0, base32_decode_1.default)(key.slice(constants_1.API_KEY_PAK_PREFIX.length).toUpperCase(), 'RFC4648');
+        const decoded = Buffer.from(keyBuffer).toString('utf8');
+        return Number(decoded.split('_')[0]);
+    }
+    static getProjectApiKeyInformation(api, key) {
+        return new requester_1.default({ apiUrl: api, apiKey: key }).requestJson({
+            path: '/v2/api-keys/current',
+            method: 'GET',
+        });
+    }
+    static getPersonalAccessTokenInformation(api, key) {
+        return new requester_1.default({ apiUrl: api, apiKey: key }).requestJson({
+            path: '/v2/pats/current',
+            method: 'GET',
+        });
+    }
+    static async getApiKeyInformation(api, key) {
+        if (key.startsWith(constants_1.API_KEY_PAK_PREFIX)) {
+            const info = await RestClient.getProjectApiKeyInformation(api, key);
+            const username = info.userFullName || info.username || '<unknown user>';
+            return {
+                type: 'PAK',
+                key: key,
+                username: username,
+                project: {
+                    id: info.projectId,
+                    name: info.projectName,
+                },
+                expires: info.expiresAt ?? 0,
+            };
+        }
+        const info = await RestClient.getPersonalAccessTokenInformation(api, key);
+        const username = info.user.name || info.user.username;
+        return {
+            type: 'PAT',
+            key: key,
+            username: username,
+            expires: info.expiresAt ?? 0,
+        };
+    }
+}
+exports.default = RestClient;

package/dist/client/internal/requester.js

@@ -0,0 +1,145 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const undici_1 = require("undici");
+const undici_2 = require("undici");
+const form_data_1 = __importDefault(require("form-data"));
+const errors_1 = require("../errors");
+const logger_1 = require("../../utils/logger");
+const constants_1 = require("../../constants");
+class Requester {
+    params;
+    constructor(params) {
+        this.params = params;
+    }
+    get projectUrl() {
+        return `/v2/projects/${this.params.projectId}`;
+    }
+    /**
+     * Performs an HTTP request to the API
+     *
+     * @param req Request data
+     * @returns The response
+     */
+    async request(req) {
+        const url = new URL(req.path, this.params.apiUrl);
+        if (req.query) {
+            for (const param in req.query) {
+                if (param in req.query) {
+                    const val = req.query[param];
+                    if (val !== undefined) {
+                        if (Array.isArray(val)) {
+                            for (const v of val) {
+                                url.searchParams.append(param, String(v));
+                            }
+                        }
+                        else {
+                            url.searchParams.set(param, String(val));
+                        }
+                    }
+                }
+            }
+        }
+        const headers = {
+            ...(req.headers || {}),
+            'user-agent': constants_1.USER_AGENT,
+            'x-api-key': this.params.apiKey,
+        };
+        let body = undefined;
+        if (req.body) {
+            if (req.body instanceof form_data_1.default) {
+                const header = `multipart/form-data; boundary=${req.body.getBoundary()}`;
+                headers['content-type'] = header;
+                body = req.body.getBuffer();
+            }
+            else {
+                headers['content-type'] = 'application/json';
+                body = JSON.stringify(req.body);
+            }
+        }
+        const request = new undici_1.Request(url, {
+            method: req.method,
+            headers: headers,
+            body: body,
+        });
+        (0, logger_1.debug)(`[HTTP] Requesting: ${request.method} ${request.url}`);
+        const response = await (0, undici_2.fetch)(request);
+        (0, logger_1.debug)(`[HTTP] ${request.method} ${request.url} -> ${response.status} ${response.statusText}`);
+        if (!response.ok)
+            throw new errors_1.HttpError(request, response);
+        return response;
+    }
+    /**
+     * Performs an HTTP request to the API and returns the result as a JSON object
+     *
+     * @param req Request data
+     * @returns The response data
+     */
+    async requestJson(req) {
+        return this.request(req).then((r) => r.json());
+    }
+    /**
+     * Performs an HTTP request to the API and returns the result as a Blob
+     *
+     * @param req Request data
+     * @returns The response blob
+     */
+    async requestBlob(req) {
+        return this.request(req).then((r) => r.blob());
+    }
+    /**
+     * Performs an HTTP request to the API and forces the consumption of the body, according to recommendations by Undici
+     *
+     * @see https://github.com/nodejs/undici#garbage-collection
+     * @param req Request data
+     */
+    async requestVoid(req) {
+        const res = await this.request(req);
+        if (res.body) {
+            for await (const _chunk of res.body)
+                ;
+        }
+    }
+    /**
+     * Performs an HTTP request to the API to a resource which is paginated.
+     * The returned result is a view with helpers to get next (or previous) data.
+     *
+     * @param req Request data
+     */
+    async requestPaginatedResource(req) {
+        const res = await this.requestJson(req);
+        const _this = this;
+        const view = {
+            data: res._embedded,
+            page: res.page,
+            hasNext() {
+                return !!res._links.next?.href;
+            },
+            hasPrevious() {
+                return !!res._links.prev?.href;
+            },
+            async next() {
+                if (!this.hasNext())
+                    return null;
+                return _this.requestPaginatedResource({
+                    ...req,
+                    path: res._links.next.href,
+                    query: undefined,
+                });
+            },
+            async previous() {
+                if (!this.hasPrevious())
+                    return null;
+                return _this.requestPaginatedResource({
+                    ...req,
+                    path: res._links.prev.href,
+                    query: undefined,
+                });
+            },
+        };
+        return view;
+    }
+}
+exports.default = Requester;

package/dist/client/internal/schema.generated.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/client/internal/schema.utils.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/client/languages.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class LanguagesClient {
+    requester;
+    constructor(requester) {
+        this.requester = requester;
+    }
+    async getLanguages(req) {
+        return this.requester.requestPaginatedResource({
+            method: 'GET',
+            path: `${this.requester.projectUrl}/languages`,
+            query: req,
+        });
+    }
+}
+exports.default = LanguagesClient;

package/dist/client/project.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ProjectClient {
+    requester;
+    constructor(requester) {
+        this.requester = requester;
+    }
+    async fetchProjectInformation() {
+        return this.requester.requestJson({
+            method: 'GET',
+            path: this.requester.projectUrl,
+        });
+    }
+    async fetchAllKeys() {
+        return this.requester
+            .requestJson({
+            method: 'GET',
+            path: `${this.requester.projectUrl}/all-keys`,
+        })
+            .then((r) => r._embedded?.keys || []);
+    }
+    async createKey(key) {
+        return this.requester.requestJson({
+            method: 'POST',
+            path: `${this.requester.projectUrl}/keys`,
+            body: key,
+        });
+    }
+    async createBulkKey(keys) {
+        return this.requester.requestVoid({
+            method: 'POST',
+            path: `${this.requester.projectUrl}/keys/import`,
+            body: { keys },
+        });
+    }
+    async deleteBulkKeys(keyIds) {
+        return this.requester.requestVoid({
+            method: 'DELETE',
+            path: `${this.requester.projectUrl}/keys`,
+            body: { ids: keyIds },
+        });
+    }
+}
+exports.default = ProjectClient;

package/dist/commands/extract/check.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const commander_1 = require("commander");
+const runner_1 = require("../../extractor/runner");
+const warnings_1 = require("../../extractor/warnings");
+const logger_1 = require("../../utils/logger");
+async function lintHandler(filesPattern) {
+    const opts = this.optsWithGlobals();
+    const extracted = await (0, logger_1.loading)('Analyzing code...', (0, runner_1.extractKeysOfFiles)(filesPattern, opts.extractor));
+    let warningCount = 0;
+    let filesCount = 0;
+    for (const [file, { warnings }] of extracted) {
+        if (warnings.length) {
+            warningCount += warnings.length;
+            filesCount++;
+            const relFile = (0, path_1.relative)(process.cwd(), file);
+            console.log('%s:', relFile);
+            for (const warning of warnings) {
+                if (warning.warning in warnings_1.WarningMessages) {
+                    const { name } = warnings_1.WarningMessages[warning.warning];
+                    console.log('\tline %d: %s', warning.line, name);
+                }
+                else {
+                    console.log('\tline %d: %s', warning.line, warning.warning);
+                }
+                (0, warnings_1.emitGitHubWarning)(warning.warning, file, warning.line);
+            }
+        }
+    }
+    if (warningCount !== 0) {
+        console.log();
+        console.log('Total: %d warning%s in %d file%s', warningCount, warningCount !== 1 ? 's' : '', filesCount, filesCount !== 1 ? 's' : '');
+        process.exit(1);
+    }
+    console.log('No issues found.');
+}
+exports.default = new commander_1.Command('check')
+    .description('Checks if the keys can be extracted automatically, and reports problems if any')
+    .argument('<pattern>', 'File pattern to include (hint: make sure to escape it in quotes, or your shell might attempt to unroll some tokens like *)')
+    .action(lintHandler);

package/dist/commands/extract/print.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const commander_1 = require("commander");
+const runner_1 = require("../../extractor/runner");
+const warnings_1 = require("../../extractor/warnings");
+const logger_1 = require("../../utils/logger");
+async function printHandler(filesPattern) {
+    const opts = this.optsWithGlobals();
+    const extracted = await (0, logger_1.loading)('Analyzing code...', (0, runner_1.extractKeysOfFiles)(filesPattern, opts.extractor));
+    let warningCount = 0;
+    const keySet = new Set();
+    for (const [file, { keys, warnings }] of extracted) {
+        if (keys.length) {
+            const relFile = (0, path_1.relative)(process.cwd(), file);
+            console.log('%d key%s found in %s:', keys.length, keys.length !== 1 ? 's' : '', relFile);
+            for (const key of keys) {
+                keySet.add(key);
+                console.log('\tline %d: %s', key.line, key.keyName);
+                if (key.namespace) {
+                    console.log('\t\tnamespace: %s', key.namespace);
+                }
+                if (key.defaultValue) {
+                    console.log('\t\tdefault: %s', key.defaultValue);
+                }
+            }
+        }
+        if (warnings.length) {
+            warningCount += warnings.length;
+            console.log('%d warning%s %s emitted during extraction:', warnings.length, warnings.length !== 1 ? 's' : '', warnings.length !== 1 ? 'were' : 'was');
+            for (const warning of warnings) {
+                if (warning.warning in warnings_1.WarningMessages) {
+                    const { name } = warnings_1.WarningMessages[warning.warning];
+                    console.log('\tline %d: %s', warning.line, name);
+                }
+                else {
+                    console.log('\tline %d: %s', warning.line, warning.warning);
+                }
+            }
+        }
+        if (keys.length || warnings.length) {
+            console.log();
+        }
+    }
+    console.log('Total unique keys found: %d', keySet.size);
+    console.log('Total warnings: %d', warningCount);
+}
+exports.default = new commander_1.Command('print')
+    .description('Prints extracted data to the console')
+    .argument('<pattern>', 'File glob pattern to include (hint: make sure to escape it in quotes, or your shell might attempt to unroll some tokens like *)')
+    .action(printHandler);

package/dist/commands/extract.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const print_1 = __importDefault(require("./extract/print"));
+const check_1 = __importDefault(require("./extract/check"));
+const options_1 = require("../options");
+exports.default = new commander_1.Command('extract')
+    .description('Extracts strings from your projects')
+    .addOption(options_1.EXTRACTOR)
+    .addCommand(print_1.default)
+    .addCommand(check_1.default);

package/dist/commands/login.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logout = exports.Login = void 0;
+const commander_1 = require("commander");
+const client_1 = __importDefault(require("../client"));
+const errors_1 = require("../client/errors");
+const credentials_1 = require("../config/credentials");
+const logger_1 = require("../utils/logger");
+async function loginHandler(key) {
+    const opts = this.optsWithGlobals();
+    let keyInfo;
+    try {
+        keyInfo = await client_1.default.getApiKeyInformation(opts.apiUrl, key);
+    }
+    catch (e) {
+        if (e instanceof errors_1.HttpError && e.response.status === 403) {
+            (0, logger_1.error)("Couldn't log in: the API key you provided is invalid.");
+            process.exit(1);
+        }
+        throw e;
+    }
+    await (0, credentials_1.saveApiKey)(opts.apiUrl, keyInfo);
+    (0, logger_1.success)(keyInfo.type === 'PAK'
+        ? `Logged in as ${keyInfo.username} on ${opts.apiUrl.hostname} for project ${keyInfo.project.name} (#${keyInfo.project.id}). Welcome back!`
+        : `Logged in as ${keyInfo.username} on ${opts.apiUrl.hostname}. Welcome back!`);
+}
+async function logoutHandler() {
+    const opts = this.optsWithGlobals();
+    if (opts.all) {
+        await (0, credentials_1.clearAuthStore)();
+        (0, logger_1.success)("You've been logged out of all Tolgee instances you were logged in.");
+        return;
+    }
+    await (0, credentials_1.removeApiKeys)(opts.apiUrl);
+    (0, logger_1.success)(`You're now logged out of ${opts.apiUrl.hostname}.`);
+}
+exports.Login = new commander_1.Command()
+    .name('login')
+    .description('Login to Tolgee with an API key. You can be logged into multiple Tolgee instances at the same time by using --api-url')
+    .argument('<API Key>', 'The API key. Can be either a personal access token, or a project key')
+    .action(loginHandler);
+exports.Logout = new commander_1.Command()
+    .name('logout')
+    .description('Logs out of Tolgee')
+    .option('--all', "Log out of *ALL* Tolgee instances you're logged into")
+    .action(logoutHandler);

package/dist/commands/pull.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const zip_1 = require("../utils/zip");
+const overwriteDir_1 = require("../utils/overwriteDir");
+const logger_1 = require("../utils/logger");
+async function fetchZipBlob(opts) {
+    return opts.client.export.export({
+        format: opts.format,
+        languages: opts.languages,
+        filterState: opts.states,
+        structureDelimiter: opts.delimiter,
+    });
+}
+async function pullHandler(path) {
+    const opts = this.optsWithGlobals();
+    await (0, overwriteDir_1.overwriteDir)(path, opts.overwrite);
+    const zipBlob = await (0, logger_1.loading)('Fetching strings from Tolgee...', fetchZipBlob(opts));
+    await (0, logger_1.loading)('Extracting strings...', (0, zip_1.unzipBuffer)(zipBlob, path));
+    (0, logger_1.success)('Done!');
+}
+exports.default = new commander_1.Command()
+    .name('pull')
+    .description('Pulls translations to Tolgee')
+    .argument('<path>', 'Destination path where translation files will be stored in')
+    .addOption(new commander_1.Option('-f, --format <format>', 'Format of the exported files')
+    .choices(['JSON', 'XLIFF'])
+    .default('JSON')
+    .argParser((v) => v.toUpperCase()))
+    .option('-l, --languages <languages...>', 'List of languages to pull. Leave unspecified to export them all')
+    .addOption(new commander_1.Option('-s, --states <states...>', 'List of translation states to include. Defaults all except untranslated')
+    .choices(['UNTRANSLATED', 'TRANSLATED', 'REVIEWED'])
+    .argParser((v, a) => [v.toUpperCase(), ...(a || [])]))
+    .addOption(new commander_1.Option('-d, --delimiter', 'Structure delimiter to use. By default, Tolgee interprets `.` as a nested structure. You can change the delimiter, or disable structure formatting by not specifying any value to the option')
+    .default('.')
+    .argParser((v) => v || ''))
+    .option('-o, --overwrite', 'Whether to automatically overwrite existing files. BE CAREFUL, THIS WILL WIPE *ALL* THE CONTENTS OF THE TARGET FOLDER. If unspecified, the user will be prompted interactively, or the command will fail when in non-interactive')
+    .action(pullHandler);