@tolgee/cli 1.3.2 → 2.0.0

package/dist/{index.js → cli.js}

@@ -3,17 +3,19 @@ import { Command } from 'commander';
 import ansi from 'ansi-colors';
 import { getApiKey, savePak, savePat } from './config/credentials.js';
 import loadTolgeeRc from './config/tolgeerc.js';
-import RestClient from './client/index.js';
-import { HttpError } from './client/errors.js';
-import { setDebug, isDebugEnabled, debug, info, error, } from './utils/logger.js';
-import { API_KEY_OPT, API_URL_OPT, PROJECT_ID_OPT } from './options.js';
-import { API_KEY_PAK_PREFIX, API_KEY_PAT_PREFIX, VERSION, } from './constants.js';
+import { setDebug, info, error, exitWithError } from './utils/logger.js';
+import { API_KEY_OPT, API_URL_OPT, CONFIG_OPT, EXTRACTOR, FILE_PATTERNS, FORMAT_OPT, PROJECT_ID_OPT, } from './options.js';
+import { API_KEY_PAK_PREFIX, API_KEY_PAT_PREFIX, DEFAULT_API_URL, VERSION, } from './constants.js';
 import { Login, Logout } from './commands/login.js';
 import PushCommand from './commands/push.js';
 import PullCommand from './commands/pull.js';
 import ExtractCommand from './commands/extract.js';
 import CompareCommand from './commands/sync/compare.js';
 import SyncCommand from './commands/sync/sync.js';
+import TagCommand from './commands/tag.js';
+import { getSingleOption } from './utils/getSingleOption.js';
+import { createTolgeeClient } from './client/TolgeeClient.js';
+import { projectIdFromKey } from './client/ApiClient.js';
 const NO_KEY_COMMANDS = ['login', 'logout', 'extract'];
 ansi.enabled = process.stdout.isTTY;
 function topLevelName(command) {
@@ -46,7 +48,7 @@ function loadProjectId(cmd) {
     const opts = cmd.optsWithGlobals();
     if (opts.apiKey?.startsWith(API_KEY_PAK_PREFIX)) {
         // Parse the key and ensure we can access the specified Project ID
-        const projectId = RestClient.projectIdFromKey(opts.apiKey);
+        const projectId = projectIdFromKey(opts.apiKey);
         program.setOptionValue('projectId', projectId);
         if (opts.projectId !== -1 && opts.projectId !== projectId) {
             error('The specified API key cannot be used to perform operations on the specified project.');
@@ -64,93 +66,82 @@ function validateOptions(cmd) {
         process.exit(1);
     }
     if (!opts.apiKey) {
-        error('No API key has been provided. You must either provide one via --api-key, or login via `tolgee login`.');
-        process.exit(1);
+        exitWithError('No API key has been provided. You must either provide one via --api-key, or login via `tolgee login`.');
     }
 }
-async function preHandler(prog, cmd) {
+const preHandler = (config) => async function (prog, cmd) {
     if (!NO_KEY_COMMANDS.includes(topLevelName(cmd))) {
         await loadApiKey(cmd);
         loadProjectId(cmd);
         validateOptions(cmd);
         const opts = cmd.optsWithGlobals();
-        const client = new RestClient({
-            apiUrl: opts.apiUrl,
+        const client = createTolgeeClient({
+            baseUrl: opts.apiUrl?.toString() ?? config.apiUrl?.toString(),
             apiKey: opts.apiKey,
-            projectId: opts.projectId,
+            projectId: opts.projectId !== undefined
+                ? Number(opts.projectId)
+                : config.projectId !== undefined
+                    ? Number(config.projectId)
+                    : undefined,
         });
         cmd.setOptionValue('client', client);
     }
     // Apply verbosity
     setDebug(prog.opts().verbose);
-}
+};
 const program = new Command('tolgee')
     .version(VERSION)
     .configureOutput({ writeErr: error })
     .description('Command Line Interface to interact with the Tolgee Platform')
-    .option('-v, --verbose', 'Enable verbose logging.')
-    .hook('preAction', preHandler);
-// Global options
-program.addOption(API_URL_OPT);
-program.addOption(API_KEY_OPT);
-program.addOption(PROJECT_ID_OPT);
-// Register commands
-program.addCommand(Login);
-program.addCommand(Logout);
-program.addCommand(PushCommand);
-program.addCommand(PullCommand);
-program.addCommand(ExtractCommand);
-program.addCommand(CompareCommand);
-program.addCommand(SyncCommand);
-async function loadConfig() {
-    const tgConfig = await loadTolgeeRc();
+    .option('-v, --verbose', 'Enable verbose logging.');
+// get config path to update defaults
+const configPath = getSingleOption(CONFIG_OPT, process.argv);
+async function loadConfig(program) {
+    const tgConfig = await loadTolgeeRc(configPath);
     if (tgConfig) {
-        for (const [key, value] of Object.entries(tgConfig)) {
-            program.setOptionValue(key, value);
-        }
-    }
-}
-async function handleHttpError(e) {
-    error('An error occurred while requesting the API.');
-    error(`${e.request.method} ${e.request.path}`);
-    error(e.getErrorText());
-    // Remove token from store if necessary
-    if (e.response.statusCode === 401) {
-        const removeFn = program.getOptionValue('_removeApiKeyFromStore');
-        if (removeFn) {
-            info('Removing the API key from the authentication store.');
-            removeFn();
-        }
-    }
-    // Print server output for server errors
-    if (isDebugEnabled()) {
-        // We cannot parse the response as JSON and pull error codes here as we may be here due to a 5xx error:
-        // by nature 5xx class errors can happen for a lot of reasons (e.g. upstream issues, server issues,
-        // catastrophic failure) which means the output is completely unpredictable. While some errors are
-        // formatted by the Tolgee server, reality is there's a huge chance the 5xx error hasn't been raised
-        // by Tolgee's error handler.
-        const res = await e.response.body.text();
-        debug(`Server response:\n\n---\n${res}\n---`);
+        [program, ...program.commands].forEach((cmd) => cmd.options.forEach((opt) => {
+            const key = opt.attributeName();
+            const value = tgConfig[key];
+            if (value) {
+                const parsedValue = opt.parseArg
+                    ? opt.parseArg(value, undefined)
+                    : value;
+                cmd.setOptionValueWithSource(key, parsedValue, 'config');
+            }
+        }));
     }
+    return tgConfig ?? {};
 }
 async function run() {
     try {
-        await loadConfig();
+        // Global options
+        program.addOption(CONFIG_OPT);
+        program.addOption(API_URL_OPT.default(DEFAULT_API_URL));
+        program.addOption(API_KEY_OPT);
+        program.addOption(PROJECT_ID_OPT.default(-1));
+        program.addOption(FORMAT_OPT.default('JSON_TOLGEE'));
+        program.addOption(EXTRACTOR);
+        program.addOption(FILE_PATTERNS);
+        const config = await loadConfig(program);
+        program.hook('preAction', preHandler(config));
+        // Register commands
+        program.addCommand(Login);
+        program.addCommand(Logout);
+        program.addCommand(PushCommand(config).configureHelp({ showGlobalOptions: true }));
+        program.addCommand(PullCommand(config).configureHelp({ showGlobalOptions: true }));
+        program.addCommand(ExtractCommand(config).configureHelp({ showGlobalOptions: true }));
+        program.addCommand(CompareCommand(config).configureHelp({ showGlobalOptions: true }));
+        program.addCommand(SyncCommand(config).configureHelp({ showGlobalOptions: true }));
+        program.addCommand(TagCommand(config).configureHelp({ showGlobalOptions: true }));
         await program.parseAsync();
     }
     catch (e) {
-        if (e instanceof HttpError) {
-            await handleHttpError(e);
-            process.exit(1);
-        }
         // If the error is uncaught, huge chance that either:
         //  - The error should be handled here but isn't
         //  - The error should be handled in the command but isn't
         //  - Something went wrong with the code
         error('An unexpected error occurred while running the command.');
-        error('Please report this to our issue tracker: https://github.com/tolgee/tolgee-cli/issues');
-        console.log(e.stack);
-        process.exit(1);
+        exitWithError('Please report this to our issue tracker: https://github.com/tolgee/tolgee-cli/issues');
     }
 }
 run();

package/dist/client/ApiClient.js

@@ -0,0 +1,72 @@
+import createClient from 'openapi-fetch';
+import base32Decode from 'base32-decode';
+import { API_KEY_PAK_PREFIX, USER_AGENT } from '../constants.js';
+import { getApiKeyInformation } from './getApiKeyInformation.js';
+import { debug } from '../utils/logger.js';
+import { errorFromLoadable } from './errorFromLoadable.js';
+async function parseResponse(response, parseAs) {
+    // handle empty content
+    // note: we return `{}` because we want user truthy checks for `.data` or `.error` to succeed
+    if (response.status === 204 ||
+        response.headers.get('Content-Length') === '0') {
+        return response.ok ? { data: {}, response } : { error: {}, response };
+    }
+    // parse response (falling back to .text() when necessary)
+    if (response.ok) {
+        // if "stream", skip parsing entirely
+        if (parseAs === 'stream') {
+            return { data: response.body, response };
+        }
+        return { data: await response[parseAs](), response };
+    }
+    // handle errors
+    let error = await response.text();
+    try {
+        error = JSON.parse(error); // attempt to parse as JSON
+    }
+    catch {
+        // noop
+    }
+    return { error, response };
+}
+export function projectIdFromKey(key) {
+    if (!key.startsWith(API_KEY_PAK_PREFIX)) {
+        return undefined;
+    }
+    const keyBuffer = base32Decode(key.slice(API_KEY_PAK_PREFIX.length).toUpperCase(), 'RFC4648');
+    const decoded = Buffer.from(keyBuffer).toString('utf8');
+    return Number(decoded.split('_')[0]);
+}
+export function createApiClient({ baseUrl, apiKey, projectId, autoThrow = false, }) {
+    const computedProjectId = projectId ?? (apiKey ? projectIdFromKey(apiKey) : undefined);
+    const apiClient = createClient({
+        baseUrl,
+        headers: {
+            'user-agent': USER_AGENT,
+            'x-api-key': apiKey,
+        },
+    });
+    apiClient.use({
+        onRequest: (req, options) => {
+            debug(`[HTTP] Requesting: ${req.method} ${req.url}`);
+            return undefined;
+        },
+        onResponse: async (res, options) => {
+            debug(`[HTTP] Response: ${res.url} [${res.status}]`);
+            if (autoThrow && !res.ok) {
+                const loadable = await parseResponse(res, options.parseAs);
+                throw new Error(`Tolgee request error ${res.url} ${errorFromLoadable(loadable)}`);
+            }
+            return undefined;
+        },
+    });
+    return {
+        ...apiClient,
+        getProjectId() {
+            return computedProjectId;
+        },
+        getApiKeyInfo() {
+            return getApiKeyInformation(apiClient, apiKey);
+        },
+    };
+}

package/dist/client/ExportClient.js

@@ -0,0 +1,19 @@
+export const createExportClient = ({ apiClient }) => {
+    return {
+        async export(req) {
+            const body = { ...req, zip: true };
+            const loadable = await apiClient.POST('/v2/projects/{projectId}/export', {
+                params: { path: { projectId: apiClient.getProjectId() } },
+                body: body,
+                parseAs: 'blob',
+            });
+            return { ...loadable, data: loadable.data };
+        },
+        async exportSingle(req) {
+            return apiClient.POST('/v2/projects/{projectId}/export', {
+                params: { path: { projectId: apiClient.getProjectId() } },
+                body: { ...req, zip: false },
+            });
+        },
+    };
+};

package/dist/client/ImportClient.js

@@ -0,0 +1,22 @@
+import FormData from 'form-data';
+export const createImportClient = ({ apiClient }) => {
+    return {
+        async import(data) {
+            const body = new FormData();
+            for (const file of data.files) {
+                body.append('files', file.data, { filepath: file.name });
+            }
+            body.append('params', JSON.stringify(data.params));
+            return apiClient.POST('/v2/projects/{projectId}/single-step-import', {
+                params: { path: { projectId: apiClient.getProjectId() } },
+                body: body,
+                bodySerializer: (r) => {
+                    return r.getBuffer();
+                },
+                headers: {
+                    'content-type': `multipart/form-data; boundary=${body.getBoundary()}`,
+                },
+            });
+        },
+    };
+};

package/dist/client/TolgeeClient.js

@@ -0,0 +1,18 @@
+import { exitWithError } from './../utils/logger.js';
+import { createApiClient } from './ApiClient.js';
+import { createExportClient } from './ExportClient.js';
+import { createImportClient } from './ImportClient.js';
+import { errorFromLoadable } from './errorFromLoadable.js';
+export function createTolgeeClient(props) {
+    const apiClient = createApiClient(props);
+    return {
+        ...apiClient,
+        import: createImportClient({ apiClient }),
+        export: createExportClient({ apiClient }),
+    };
+}
+export const handleLoadableError = (loadable) => {
+    if (loadable.error) {
+        exitWithError(errorFromLoadable(loadable));
+    }
+};

package/dist/client/errorFromLoadable.js

@@ -0,0 +1,35 @@
+export const addErrorDetails = (loadable, showBeError = true) => {
+    const items = [];
+    items.push(`status: ${loadable.response.status}`);
+    if (showBeError && loadable.error?.code) {
+        items.push(`code: ${loadable.error.code}`);
+    }
+    if (loadable.response.status === 403 && loadable.error?.params?.[0]) {
+        items.push(`missing scope: ${loadable.error.params[0]}`);
+    }
+    return `[${items.join(', ')}]`;
+};
+export const errorFromLoadable = (loadable) => {
+    switch (loadable.response.status) {
+        // Unauthorized
+        case 400:
+            return `Invalid request data ${addErrorDetails(loadable)}`;
+        // Unauthorized
+        case 401:
+            return `Missing or invalid authentication token ${addErrorDetails(loadable)}`;
+        // Forbidden
+        case 403:
+            return `You are not allowed to perform this operation ${addErrorDetails(loadable)}`;
+        // Rate limited
+        case 429:
+            return `You've been rate limited. Please try again later ${addErrorDetails(loadable)}`;
+        // Service Unavailable
+        case 503:
+            return `API is temporarily unavailable. Please try again later ${addErrorDetails(loadable)}`;
+        // Server error
+        case 500:
+            return `API reported a server error. Please try again later ${addErrorDetails(loadable)}`;
+        default:
+            return `Unknown error ${addErrorDetails(loadable)}`;
+    }
+};

package/dist/client/getApiKeyInformation.js

@@ -0,0 +1,39 @@
+import { API_KEY_PAK_PREFIX } from './../constants.js';
+import { handleLoadableError } from './TolgeeClient.js';
+import { exitWithError } from './../utils/logger.js';
+export const getApiKeyInformation = async (client, key) => {
+    if (key.startsWith(API_KEY_PAK_PREFIX)) {
+        const loadable = await client.GET('/v2/api-keys/current');
+        if (loadable.response.status === 401) {
+            exitWithError("Couldn't log in: the API key you provided is invalid.");
+        }
+        handleLoadableError(loadable);
+        const info = loadable.data;
+        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,
+        };
+    }
+    else {
+        const loadable = await client.GET('/v2/pats/current');
+        if (loadable.response.status === 401) {
+            exitWithError("Couldn't log in: the API key you provided is invalid.");
+        }
+        handleLoadableError(loadable);
+        const info = loadable.data;
+        const username = info.user.name || info.user.username;
+        return {
+            type: 'PAT',
+            key: key,
+            username: username,
+            expires: info.expiresAt ?? 0,
+        };
+    }
+};

package/dist/client/internal/requester.js

@@ -1,7 +1,6 @@
 import { STATUS_CODES } from 'http';
 import { request } from 'undici';
 import FormData from 'form-data';
-import { HttpError } from '../errors.js';
 import { debug } from '../../utils/logger.js';
 import { USER_AGENT } from '../../constants.js';
 export default class Requester {
@@ -59,12 +58,10 @@ export default class Requester {
             method: req.method,
             headers: headers,
             body: body,
-            headersTimeout: req.headersTimeout ?? 300000,
-            bodyTimeout: req.bodyTimeout ?? 300000,
+            headersTimeout: req.headersTimeout ?? 300_000,
+            bodyTimeout: req.bodyTimeout ?? 300_000,
         });
         debug(`[HTTP] ${req.method} ${url} -> ${response.statusCode} ${STATUS_CODES[response.statusCode]}`);
-        if (response.statusCode >= 400)
-            throw new HttpError(req, response);
         return response;
     }
     /**

package/dist/commands/extract/check.js

@@ -2,10 +2,14 @@ import { relative } from 'path';
 import { Command } from 'commander';
 import { extractKeysOfFiles } from '../../extractor/runner.js';
 import { WarningMessages, emitGitHubWarning, } from '../../extractor/warnings.js';
-import { loading } from '../../utils/logger.js';
-async function lintHandler(filesPattern) {
+import { exitWithError, loading } from '../../utils/logger.js';
+const lintHandler = (config) => async function () {
     const opts = this.optsWithGlobals();
-    const extracted = await loading('Analyzing code...', extractKeysOfFiles(filesPattern, opts.extractor));
+    const patterns = opts.patterns;
+    if (!patterns?.length) {
+        exitWithError('Missing option --patterns or config.patterns option');
+    }
+    const extracted = await loading('Analyzing code...', extractKeysOfFiles(patterns, opts.extractor));
     let warningCount = 0;
     let filesCount = 0;
     for (const [file, { warnings }] of extracted) {
@@ -32,8 +36,7 @@ async function lintHandler(filesPattern) {
         process.exit(1);
     }
     console.log('No issues found.');
-}
-export default new Command('check')
+};
+export default (config) => new 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);
+    .action(lintHandler(config));

package/dist/commands/extract/print.js

@@ -2,10 +2,14 @@ import { relative } from 'path';
 import { Command } from 'commander';
 import { extractKeysOfFiles } from '../../extractor/runner.js';
 import { WarningMessages } from '../../extractor/warnings.js';
-import { loading } from '../../utils/logger.js';
-async function printHandler(filesPattern) {
+import { exitWithError, loading } from '../../utils/logger.js';
+const printHandler = (config) => async function () {
     const opts = this.optsWithGlobals();
-    const extracted = await loading('Analyzing code...', extractKeysOfFiles(filesPattern, opts.extractor));
+    const patterns = opts.patterns;
+    if (!patterns?.length) {
+        exitWithError('Missing option --patterns or config.patterns option');
+    }
+    const extracted = await loading('Analyzing code...', extractKeysOfFiles(patterns, opts.extractor));
     let warningCount = 0;
     const keySet = new Set();
     for (const [file, { keys, warnings }] of extracted) {
@@ -42,8 +46,7 @@ async function printHandler(filesPattern) {
     }
     console.log('Total unique keys found: %d', keySet.size);
     console.log('Total warnings: %d', warningCount);
-}
-export default new Command('print')
+};
+export default (config) => new 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);
+    .action(printHandler(config));

package/dist/commands/extract.js

@@ -1,9 +1,7 @@
 import { Command } from 'commander';
 import extractPrint from './extract/print.js';
 import extractCheck from './extract/check.js';
-import { EXTRACTOR } from '../options.js';
-export default new Command('extract')
+export default (config) => new Command('extract')
     .description('Extracts strings from your projects')
-    .addOption(EXTRACTOR)
-    .addCommand(extractPrint)
-    .addCommand(extractCheck);
+    .addCommand(extractPrint(config))
+    .addCommand(extractCheck(config));

package/dist/commands/login.js

@@ -1,21 +1,13 @@
 import { Command } from 'commander';
-import RestClient from '../client/index.js';
-import { HttpError } from '../client/errors.js';
 import { saveApiKey, removeApiKeys, clearAuthStore, } from '../config/credentials.js';
-import { success, error } from '../utils/logger.js';
+import { success } from '../utils/logger.js';
+import { createTolgeeClient } from '../client/TolgeeClient.js';
 async function loginHandler(key) {
     const opts = this.optsWithGlobals();
-    let keyInfo;
-    try {
-        keyInfo = await RestClient.getApiKeyInformation(opts.apiUrl, key);
-    }
-    catch (e) {
-        if (e instanceof HttpError && e.response.statusCode === 401) {
-            error("Couldn't log in: the API key you provided is invalid.");
-            process.exit(1);
-        }
-        throw e;
-    }
+    const keyInfo = await createTolgeeClient({
+        baseUrl: opts.apiUrl.toString(),
+        apiKey: key,
+    }).getApiKeyInfo();
     await saveApiKey(opts.apiUrl, keyInfo);
     success(keyInfo.type === 'PAK'
         ? `Logged in as ${keyInfo.username} on ${opts.apiUrl.hostname} for project ${keyInfo.project.name} (#${keyInfo.project.id}). Welcome back!`

package/dist/commands/pull.js

@@ -1,49 +1,55 @@
 import { Command, Option } from 'commander';
 import { unzipBuffer } from '../utils/zip.js';
-import { overwriteDir } from '../utils/overwriteDir.js';
-import { error, loading, success } from '../utils/logger.js';
-import { HttpError } from '../client/errors.js';
+import { prepareDir } from '../utils/prepareDir.js';
+import { loading, success } from '../utils/logger.js';
+import { checkPathNotAFile } from '../utils/checkPathNotAFile.js';
+import { mapExportFormat } from '../utils/mapExportFormat.js';
+import { handleLoadableError } from '../client/TolgeeClient.js';
 async function fetchZipBlob(opts) {
-    return opts.client.export.export({
-        format: opts.format,
+    const exportFormat = mapExportFormat(opts.format);
+    const { format, messageFormat } = exportFormat;
+    const loadable = await opts.client.export.export({
+        format,
+        messageFormat,
+        supportArrays: opts.supportArrays,
         languages: opts.languages,
         filterState: opts.states,
         structureDelimiter: opts.delimiter,
         filterNamespace: opts.namespaces,
+        filterTagIn: opts.tags,
+        filterTagNotIn: opts.excludeTags,
+        fileStructureTemplate: opts.fileStructureTemplate,
     });
+    handleLoadableError(loadable);
+    return loadable.data;
 }
-async function pullHandler(path) {
+const pullHandler = () => async function () {
     const opts = this.optsWithGlobals();
-    await overwriteDir(path, opts.overwrite);
-    try {
-        const zipBlob = await loading('Fetching strings from Tolgee...', fetchZipBlob(opts));
-        await loading('Extracting strings...', unzipBuffer(zipBlob, path));
-        success('Done!');
+    if (!opts.path) {
+        throw new Error('Missing or option --path <path>');
     }
-    catch (e) {
-        if (e instanceof HttpError && e.response.statusCode === 400) {
-            const res = await e.response.body.json();
-            error(`Please check if your parameters, including namespaces, are configured correctly. Tolgee responded with: ${res.code}`);
-            return;
-        }
-        throw e;
-    }
-}
-export default new Command()
+    await checkPathNotAFile(opts.path);
+    const zipBlob = await loading('Fetching strings from Tolgee...', fetchZipBlob(opts));
+    await prepareDir(opts.path, opts.emptyDir);
+    await loading('Extracting strings...', unzipBuffer(zipBlob, opts.path));
+    success('Done!');
+};
+export default (config) => new Command()
     .name('pull')
-    .description('Pulls translations to Tolgee')
-    .argument('<path>', 'Destination path where translation files will be stored in')
-    .addOption(new 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')
+    .description('Pulls translations from Tolgee')
+    .addOption(new Option('-p, --path <path>', 'Destination of a folder where translation files will be stored in').default(config.pull?.path))
+    .addOption(new Option('-l, --languages <languages...>', 'List of languages to pull. Leave unspecified to export them all').default(config.pull?.languagess))
     .addOption(new Option('-s, --states <states...>', 'List of translation states to include. Defaults all except untranslated')
     .choices(['UNTRANSLATED', 'TRANSLATED', 'REVIEWED'])
+    .default(config.pull?.states)
     .argParser((v, a) => [v.toUpperCase(), ...(a || [])]))
     .addOption(new 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('.')
+    .default(config.pull?.delimiter ?? '.')
     .argParser((v) => v || ''))
-    .addOption(new Option('-n, --namespaces <namespaces...>', 'List of namespaces to pull. Defaults to all namespaces'))
-    .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);
+    .addOption(new Option('-n, --namespaces <namespaces...>', 'List of namespaces to pull. Defaults to all namespaces').default(config.pull?.namespaces))
+    .addOption(new Option('-t, --tags <tags...>', 'List of tags which to include. Keys tagged by at least one of these tags will be included.').default(config.pull?.tags))
+    .addOption(new Option('--exclude-tags <tags...>', 'List of tags which to exclude. Keys tagged by at least one of these tags will be excluded.').default(config.pull?.excludeTags))
+    .addOption(new Option('--support-arrays', 'Export keys with array syntax (e.g. item[0]) as arrays.').default(config.pull?.supportArrays ?? false))
+    .addOption(new Option('--empty-dir', 'Empty target directory before inserting pulled files.').default(config.pull?.emptyDir))
+    .addOption(new Option('--file-structure-template <template>', 'Defines exported file structure: https://tolgee.io/tolgee-cli/push-pull-strings#file-structure-template-format').default(config.pull?.fileStructureTemplate))
+    .action(pullHandler());