@tolgee/cli 2.15.1 → 2.16.0

package/dist/cli.js

@@ -13,7 +13,7 @@ import ansi from 'ansi-colors';
 import { getApiKey, savePak, savePat } from './config/credentials.js';
 import loadTolgeeRc from './config/tolgeerc.js';
 import { setDebug, info, error, exitWithError } from './utils/logger.js';
-import { API_KEY_OPT, API_URL_OPT, CONFIG_OPT, DEFAULT_NAMESPACE, EXTRACTOR, FILE_PATTERNS, FORMAT_OPT, STRICT_NAMESPACE, PARSER, PROJECT_ID_OPT, STRICT_NAMESPACE_NEGATION, VERBOSE, } from './options.js';
+import { API_KEY_OPT, API_URL_OPT, CONFIG_OPT, DEFAULT_NAMESPACE, EXTRACTOR, FILE_PATTERNS, FORMAT_OPT, STRICT_NAMESPACE, PARSER, PROJECT_ID_OPT, PROJECT_BRANCH, STRICT_NAMESPACE_NEGATION, VERBOSE, } 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';
@@ -22,6 +22,8 @@ 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 BranchCommand from './commands/branch.js';
+import MergeCommand from './commands/merge.js';
 import { getSingleOption } from './utils/getSingleOption.js';
 import { createTolgeeClient } from './client/TolgeeClient.js';
 import { projectIdFromKey } from './client/ApiClient.js';
@@ -136,6 +138,7 @@ function run() {
             program.addOption(API_URL_OPT.default((_a = config.apiUrl) !== null && _a !== void 0 ? _a : DEFAULT_API_URL));
             program.addOption(API_KEY_OPT.default(config.apiKey));
             program.addOption(PROJECT_ID_OPT.default((_b = config.projectId) !== null && _b !== void 0 ? _b : -1));
+            program.addOption(PROJECT_BRANCH.default(config.branch));
             program.addOption(FORMAT_OPT.default((_c = config.format) !== null && _c !== void 0 ? _c : 'JSON_TOLGEE'));
             program.addOption(EXTRACTOR.default(config.extractor));
             program.addOption(FILE_PATTERNS.default(config.patterns));
@@ -152,6 +155,8 @@ function run() {
             program.addCommand(CompareCommand(config).configureHelp({ showGlobalOptions: true }));
             program.addCommand(SyncCommand(config).configureHelp({ showGlobalOptions: true }));
             program.addCommand(TagCommand(config).configureHelp({ showGlobalOptions: true }));
+            program.addCommand(BranchCommand(config).configureHelp({ showGlobalOptions: true }));
+            program.addCommand(MergeCommand(config).configureHelp({ showGlobalOptions: true }));
             yield program.parseAsync();
         }
         catch (e) {

package/dist/client/errorFromLoadable.js

@@ -27,6 +27,9 @@ export const errorFromLoadable = (loadable) => {
         // Forbidden
         case 403:
             return `You are not allowed to perform this operation ${addErrorDetails(loadable)}`;
+        // Not found (e.g. branch in project)
+        case 404:
+            return `Requested data not found. Please check your inputs ${addErrorDetails(loadable)}`;
         // Rate limited
         case 429:
             return `You've been rate limited. Please try again later ${addErrorDetails(loadable)}`;

package/dist/commands/branch.js

@@ -0,0 +1,94 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Command, Option } from 'commander';
+import { handleLoadableError } from '../client/TolgeeClient.js';
+import { fetchBranches, listBranches } from '../utils/branch.js';
+import { error, exitWithError, loading, success } from '../utils/logger.js';
+function resolveTargetNames(opts, createArg) {
+    var _a;
+    const createName = (_a = opts.create) !== null && _a !== void 0 ? _a : createArg;
+    const deleteName = opts.delete;
+    if (opts.create && createArg) {
+        exitWithError("error: use either the '[branch]' arg to create branch or the option '-c, --create <branch>'");
+    }
+    if (createArg && deleteName) {
+        exitWithError("error: '[branch]' arg to create branch cannot be used together with option '-d, --delete <branch>'");
+    }
+    // opts.create && opts.delete use is already sanitized by commander
+    return { createName, deleteName };
+}
+function resolveOriginId(opts, branches) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const originName = opts.origin;
+        if (originName) {
+            const origin = branches.find((b) => b.name === originName);
+            if (!origin) {
+                error(`Origin branch "${originName}" was not found.`);
+                listBranches(branches);
+                exitWithError('Use --origin <branch> to specify an existing base branch.');
+            }
+            return origin.id;
+        }
+        const defaultBranch = branches.find((b) => b.isDefault);
+        if (!defaultBranch) {
+            error('Cannot determine default branch for the project.');
+            listBranches(branches);
+            exitWithError('Specify --origin <branch>.');
+        }
+        return defaultBranch.id;
+    });
+}
+const branchHandler = (config) => function () {
+    return __awaiter(this, void 0, void 0, function* () {
+        const opts = this.optsWithGlobals();
+        const createArg = this.processedArgs[0];
+        const { createName, deleteName } = resolveTargetNames(opts, createArg);
+        const branches = yield loading('Fetching project branches...', fetchBranches(opts));
+        if (!createName && !deleteName) {
+            listBranches(branches);
+            return;
+        }
+        if (createName) {
+            const originId = yield resolveOriginId(opts, branches);
+            const loadable = yield loading(`Creating branch "${createName}"...`, opts.client.POST('/v2/projects/{projectId}/branches', {
+                params: { path: { projectId: opts.client.getProjectId() } },
+                body: { name: createName, originBranchId: originId },
+            }));
+            handleLoadableError(loadable);
+            success(`Branch "${createName}" created.`);
+            return;
+        }
+        if (deleteName) {
+            const target = branches.find((b) => b.name === deleteName);
+            if (!target) {
+                error(`Branch "${deleteName}" was not found.`);
+                listBranches(branches);
+                exitWithError('Specify an existing branch.');
+            }
+            const loadable = yield loading(`Deleting branch "${deleteName}"...`, opts.client.DELETE('/v2/projects/{projectId}/branches/{branchId}', {
+                params: {
+                    path: {
+                        projectId: opts.client.getProjectId(),
+                        branchId: target.id,
+                    },
+                },
+            }));
+            handleLoadableError(loadable);
+            success(`Branch "${deleteName}" deleted.`);
+        }
+    });
+};
+export default (config) => new Command('branch')
+    .description('Create or delete project branches')
+    .argument('[branch]', 'Branch name to create')
+    .addOption(new Option('--create <branch>', 'create a new branch').conflicts('delete'))
+    .addOption(new Option('-d, --delete <branch>', 'delete an existing branch').conflicts('create'))
+    .addOption(new Option('-o, --origin <branch>', 'origin branch to fork from (defaults to project default branch)'))
+    .action(branchHandler(config));

package/dist/commands/merge.js

@@ -0,0 +1,118 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Command } from 'commander';
+import { handleLoadableError } from '../client/TolgeeClient.js';
+import { fetchBranches, listBranches } from '../utils/branch.js';
+import { error, exitWithError, info, loading, success, } from '../utils/logger.js';
+function resolveBranchName(opts, branchArg, branchExplicit) {
+    if (branchArg && branchExplicit) {
+        exitWithError("error: use either the '[branch]' arg or the option '--branch <branch>'");
+    }
+    const branchName = branchArg !== null && branchArg !== void 0 ? branchArg : (branchExplicit ? opts.branch : undefined);
+    if (!branchName) {
+        exitWithError('Specify a branch to merge.');
+    }
+    return branchName;
+}
+function renderChangeType(change) {
+    switch (change.type) {
+        case 'ADD':
+            return '+';
+        case 'UPDATE':
+            return '~';
+        case 'DELETE':
+            return '-';
+        case 'CONFLICT':
+            return 'x';
+    }
+}
+function renderChange(change) {
+    var _a, _b, _c, _d, _e;
+    const keyName = (_d = (_b = (_a = change.sourceKey) === null || _a === void 0 ? void 0 : _a.keyName) !== null && _b !== void 0 ? _b : (_c = change.targetKey) === null || _c === void 0 ? void 0 : _c.keyName) !== null && _d !== void 0 ? _d : 'unknown';
+    const languages = ((_e = change.changedTranslations) === null || _e === void 0 ? void 0 : _e.length)
+        ? ` (${change.changedTranslations.join(', ')})`
+        : '';
+    return `${renderChangeType(change)} ${keyName}${languages}`;
+}
+function buildMergeUrl(opts, mergeId) {
+    return new URL(`/projects/${opts.projectId}/branches/merge/${mergeId}`, opts.apiUrl // API and frontend URLs may differ, but commonly they are the same
+    ).toString();
+}
+const mergeHandler = (config) => function () {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        const opts = this.optsWithGlobals();
+        const branchArg = this.processedArgs[0];
+        const branchExplicit = ((_a = this.parent) === null || _a === void 0 ? void 0 : _a.getOptionValueSource('branch')) === 'cli';
+        const branchName = resolveBranchName(opts, branchArg, branchExplicit);
+        const branches = yield loading('Fetching project branches...', fetchBranches(opts));
+        const mergedBranch = branches.find((branch) => branch.name === branchName);
+        if (!mergedBranch) {
+            error(`Branch "${branchName}" was not found.`);
+            listBranches(branches);
+            exitWithError('Specify an existing branch to merge.');
+        }
+        if (mergedBranch.isDefault) {
+            exitWithError('Cannot merge the default branch.');
+        }
+        const previewLoadable = yield loading(`Preparing merge of "${branchName}"...`, opts.client.POST('/v2/projects/{projectId}/branches/merge/preview', {
+            params: { path: { projectId: opts.client.getProjectId() } },
+            body: { sourceBranchId: mergedBranch.id },
+        }));
+        handleLoadableError(previewLoadable);
+        const mergeRef = previewLoadable.data;
+        const refreshLoadable = yield loading(`Refreshing merge changes...`, opts.client.POST('/v2/projects/{projectId}/branches/merge/{mergeId}/refresh', {
+            params: {
+                path: {
+                    projectId: opts.client.getProjectId(),
+                    mergeId: mergeRef.id,
+                },
+            },
+        }));
+        handleLoadableError(refreshLoadable);
+        const changesLoadable = yield loading(`Checking merge changes...`, opts.client.GET('/v2/projects/{projectId}/branches/merge/{mergeId}/changes', {
+            params: {
+                path: {
+                    projectId: opts.client.getProjectId(),
+                    mergeId: mergeRef.id,
+                },
+            },
+        }));
+        handleLoadableError(changesLoadable);
+        const changes = (_d = (_c = (_b = changesLoadable.data) === null || _b === void 0 ? void 0 : _b._embedded) === null || _c === void 0 ? void 0 : _c.branchMergeChanges) !== null && _d !== void 0 ? _d : [];
+        const totalChanges = (_g = (_f = (_e = changesLoadable.data) === null || _e === void 0 ? void 0 : _e.page) === null || _f === void 0 ? void 0 : _f.totalElements) !== null && _g !== void 0 ? _g : changes.length;
+        console.log('Changed keys:');
+        changes.forEach((change) => {
+            console.log(renderChange(change));
+        });
+        if (totalChanges > changes.length) {
+            console.log(`...and ${totalChanges - changes.length} more`);
+        }
+        if (((_j = (_h = refreshLoadable.data) === null || _h === void 0 ? void 0 : _h.keyUnresolvedConflictsCount) !== null && _j !== void 0 ? _j : changes.filter((change) => change.type === 'CONFLICT' && !change.resolution).length) > 0) {
+            error(`Unresolved merge conflicts detected between "${branchName}" and "${mergeRef.targetBranchName}".`);
+            info(`Finish merge in web app: ${buildMergeUrl(opts, mergeRef.id)}`);
+            exitWithError('Resolve changes before merging.');
+        }
+        const applyLoadable = yield loading(`Merging branch "${branchName}"...`, opts.client.POST('/v2/projects/{projectId}/branches/merge/{mergeId}/apply', {
+            params: {
+                path: {
+                    projectId: opts.client.getProjectId(),
+                    mergeId: mergeRef.id,
+                },
+            },
+        }));
+        handleLoadableError(applyLoadable);
+        success(`Branch "${branchName}" merged into "${mergeRef.targetBranchName}".`);
+    });
+};
+export default (config) => new Command('merge')
+    .description('Merge a branch into its origin branch')
+    .argument('[branch]', 'Branch name to merge')
+    .action(mergeHandler(config));

package/dist/commands/pull.js

@@ -14,6 +14,7 @@ import { exitWithError, info, loading, success } from '../utils/logger.js';
 import { checkPathNotAFile } from '../utils/checkPathNotAFile.js';
 import { mapExportFormat } from '../utils/mapExportFormat.js';
 import { handleLoadableError } from '../client/TolgeeClient.js';
+import { printBranchInfo } from '../utils/branch.js';
 import { startWatching } from '../utils/pullWatch/watchHandler.js';
 import { getETag } from '../utils/eTagStorage.js';
 export default (config) => {
@@ -44,6 +45,7 @@ const pullHandler = () => function () {
             exitWithError('Missing option --path <path> or `pull.path` in tolgee config');
         }
         yield checkPathNotAFile(opts.path);
+        printBranchInfo(opts.branch);
         if (!opts.watch) {
             yield doPull(opts);
             success('Done!');
@@ -93,6 +95,7 @@ function fetchZipBlob(opts, ifNoneMatch) {
             fileStructureTemplate: opts.fileStructureTemplate,
             escapeHtml: false,
             ifNoneMatch,
+            filterBranch: opts.branch,
         });
         handleLoadableError(loadable);
         const etag = loadable.response

package/dist/commands/push.js

@@ -19,6 +19,7 @@ import { handleLoadableError } from '../client/TolgeeClient.js';
 import { findFilesByTemplate } from '../utils/filesTemplate.js';
 import { valueToArray } from '../utils/valueToArray.js';
 import { printUnresolvedConflicts } from '../utils/printFailedKeys.js';
+import { printBranchInfo } from '../utils/branch.js';
 function allInPattern(pattern) {
     return __awaiter(this, void 0, void 0, function* () {
         const files = [];
@@ -126,6 +127,7 @@ const pushHandler = (config) => function () {
             }
             return true;
         });
+        printBranchInfo(opts.branch);
         const files = yield loading('Reading files...', readRecords(filteredMatchers));
         if (files.length === 0) {
             error('Nothing to import.');
@@ -149,6 +151,7 @@ const pushHandler = (config) => function () {
             overrideKeyDescriptions: opts.overrideKeyDescriptions,
             convertPlaceholdersToIcu: opts.convertPlaceholdersToIcu,
             tagNewKeys: (_d = opts.tagNewKeys) !== null && _d !== void 0 ? _d : [],
+            branch: opts.branch,
             overrideMode: (_e = opts.overrideMode) !== null && _e !== void 0 ? _e : 'RECOMMENDED',
             fileMappings: files.map((f) => {
                 var _a;

package/dist/commands/sync/compare.js

@@ -14,14 +14,18 @@ import { extractKeysOfFiles, filterExtractionResult, } from '../../extractor/run
 import { dumpWarnings } from '../../extractor/warnings.js';
 import { loading } from '../../utils/logger.js';
 import { handleLoadableError } from '../../client/TolgeeClient.js';
+import { printBranchInfo } from '../../utils/branch.js';
 const asyncHandler = (config) => function () {
     return __awaiter(this, void 0, void 0, function* () {
         var _a;
         const opts = this.optsWithGlobals();
+        printBranchInfo(opts.branch);
         const rawKeys = yield loading('Analyzing code...', extractKeysOfFiles(opts));
         dumpWarnings(rawKeys);
         const localKeys = filterExtractionResult(rawKeys);
-        const loadable = yield opts.client.GET('/v2/projects/{projectId}/all-keys', { params: { path: { projectId: opts.client.getProjectId() } } });
+        const loadable = yield loading('Fetching Tolgee keys...', opts.client.GET('/v2/projects/{projectId}/all-keys', {
+            params: Object.assign({ path: { projectId: opts.client.getProjectId() } }, (!!opts.branch && { query: { branch: opts.branch } })),
+        }));
         handleLoadableError(loadable);
         const remoteKeys = (_a = loadable.data._embedded.keys) !== null && _a !== void 0 ? _a : [];
         const diff = compareKeys(localKeys, remoteKeys);

package/dist/commands/sync/sync.js

@@ -17,7 +17,8 @@ import { unzipBuffer } from '../../utils/zip.js';
 import { askBoolean } from '../../utils/ask.js';
 import { loading, exitWithError } from '../../utils/logger.js';
 import { handleLoadableError, } from '../../client/TolgeeClient.js';
-function backup(client, dest) {
+import { printBranchInfo } from '../../utils/branch.js';
+function backup(client, dest, branch) {
     return __awaiter(this, void 0, void 0, function* () {
         const loadable = yield client.export.export({
             format: 'JSON',
@@ -25,6 +26,7 @@ function backup(client, dest) {
             filterState: ['UNTRANSLATED', 'TRANSLATED', 'REVIEWED'],
             structureDelimiter: '',
             escapeHtml: false,
+            filterBranch: branch,
         });
         handleLoadableError(loadable);
         const blob = loadable.data;
@@ -49,6 +51,7 @@ const syncHandler = (config) => function () {
     return __awaiter(this, void 0, void 0, function* () {
         var _a, _b, _c, _d, _e, _f;
         const opts = this.optsWithGlobals();
+        printBranchInfo(opts.branch);
         const rawKeys = yield loading('Analyzing code...', extractKeysOfFiles(opts));
         const warnCount = dumpWarnings(rawKeys);
         if (!opts.continueOnWarning && warnCount) {
@@ -63,9 +66,9 @@ const syncHandler = (config) => function () {
                 }
             }
         }
-        const allKeysLoadable = yield opts.client.GET('/v2/projects/{projectId}/all-keys', {
-            params: { path: { projectId: opts.client.getProjectId() } },
-        });
+        const allKeysLoadable = yield loading('Fetching Tolgee keys...', opts.client.GET('/v2/projects/{projectId}/all-keys', {
+            params: Object.assign({ path: { projectId: opts.client.getProjectId() } }, (!!opts.branch && { query: { branch: opts.branch } })),
+        }));
         handleLoadableError(allKeysLoadable);
         let remoteKeys = (_e = (_d = (_c = allKeysLoadable.data) === null || _c === void 0 ? void 0 : _c._embedded) === null || _d === void 0 ? void 0 : _d.keys) !== null && _e !== void 0 ? _e : [];
         if ((_f = opts.namespaces) === null || _f === void 0 ? void 0 : _f.length) {
@@ -92,7 +95,7 @@ const syncHandler = (config) => function () {
         // Prepare backup
         if (opts.backup) {
             yield prepareDir(opts.backup, opts.yes);
-            yield loading('Backing up Tolgee project', backup(opts.client, opts.backup));
+            yield loading('Backing up Tolgee project...', backup(opts.client, opts.backup, opts.branch));
         }
         // Create new keys
         if (diff.added.length) {
@@ -108,7 +111,7 @@ const syncHandler = (config) => function () {
                 tags: opts.tagNewKeys,
             }));
             const loadable = yield loading('Creating missing keys...', opts.client.POST('/v2/projects/{projectId}/keys/import', {
-                params: { path: { projectId: opts.client.getProjectId() } },
+                params: Object.assign({ path: { projectId: opts.client.getProjectId() } }, (!!opts.branch && { query: { branch: opts.branch } })),
                 body: { keys },
             }));
             handleLoadableError(loadable);

package/dist/commands/tag.js

@@ -11,9 +11,11 @@ import { Command, Option } from 'commander';
 import { handleLoadableError } from '../client/TolgeeClient.js';
 import { exitWithError, loading, success } from '../utils/logger.js';
 import { extractKeysOfFiles } from '../extractor/runner.js';
+import { printBranchInfo } from '../utils/branch.js';
 const tagHandler = (config) => function () {
     return __awaiter(this, void 0, void 0, function* () {
         const opts = this.optsWithGlobals();
+        printBranchInfo(opts.branch);
         let extractedKeys;
         if (opts.filterExtracted || opts.filterNotExtracted) {
             if (opts.filterExtracted && opts.filterNotExtracted) {
@@ -27,7 +29,7 @@ const tagHandler = (config) => function () {
             }));
         }
         const loadable = yield loading('Tagging...', opts.client.PUT('/v2/projects/{projectId}/tag-complex', {
-            params: { path: { projectId: opts.client.getProjectId() } },
+            params: Object.assign({ path: { projectId: opts.client.getProjectId() } }, (!!opts.branch && { query: { branch: opts.branch } })),
             body: {
                 filterTag: opts.filterTag,
                 filterTagNot: opts.filterNoTag,

package/dist/config/tolgeerc.js

@@ -7,12 +7,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { cosmiconfig, defaultLoaders } from 'cosmiconfig';
-import { readFile } from 'fs/promises';
-import { fileURLToPath } from 'url';
-import { dirname, join, resolve } from 'path';
+import { cosmiconfig, defaultLoaders, } from 'cosmiconfig';
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { dirname, join, resolve } from 'node:path';
 import { error, exitWithError } from '../utils/logger.js';
-import { existsSync } from 'fs';
 import { valueToArray } from '../utils/valueToArray.js';
 import { Ajv } from 'ajv';
 const explorer = cosmiconfig('tolgee', {
@@ -37,6 +37,12 @@ function parseConfig(input, configDir) {
             throw new Error("Invalid config: 'projectId' should be an integer representing your project Id");
         }
     }
+    if (rc.branch !== undefined) {
+        if (typeof rc.branch !== 'string' || !rc.branch.trim().length) {
+            throw new Error("Invalid config: 'branch' should be a non-empty string representing your project branch");
+        }
+        rc.branch = rc.branch.trim();
+    }
     // convert relative paths in config to absolute
     if (rc.extractor !== undefined) {
         rc.extractor = resolve(configDir, rc.extractor).replace(/\\/g, '/');

package/dist/options.js

@@ -26,6 +26,7 @@ function parsePath(v) {
 export const API_KEY_OPT = new Option('-ak, --api-key <key>', 'Tolgee API Key. Can be a Project API Key or a Personal Access Token.').env('TOLGEE_API_KEY');
 export const PROJECT_ID_OPT = new Option('-p, --project-id <id>', 'Project ID. Only required when using a Personal Access Token.').argParser(parseProjectId);
 export const API_URL_OPT = new Option('-au, --api-url <url>', 'The url of Tolgee API.').argParser(parseUrlArgument);
+export const PROJECT_BRANCH = new Option('-b, --branch <name>', 'Project branch. Use when branching enabled for the project.').env('TOLGEE_BRANCH');
 export const EXTRACTOR = new Option('-e, --extractor <extractor>', `A path to a custom extractor to use instead of the default one.`).argParser(parsePath);
 export const CONFIG_OPT = new Option('-c, --config [config]', 'A path to tolgeerc config file.').argParser(parsePath);
 export const FORMAT_OPT = new Option('--format <format>', 'Localization files format.').choices([

package/dist/utils/branch.js

@@ -0,0 +1,50 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { handleLoadableError } from '../client/TolgeeClient.js';
+import { info, success } from './logger.js';
+export function printBranchInfo(branch) {
+    if (branch) {
+        info(`Using branch "${branch}"`);
+    }
+}
+export function fetchBranches(cmd) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
+        const loadable = yield cmd.client.GET('/v2/projects/{projectId}/branches', {
+            params: {
+                path: { projectId: cmd.client.getProjectId() },
+                query: { size: 10000, activeOnly: true },
+            },
+        });
+        handleLoadableError(loadable);
+        return (_c = (_b = (_a = loadable.data) === null || _a === void 0 ? void 0 : _a._embedded) === null || _b === void 0 ? void 0 : _b.branches) !== null && _c !== void 0 ? _c : [];
+    });
+}
+export function listBranches(branches) {
+    branches = branches.filter((b) => !b.merge || !b.merge.mergedAt);
+    if (!branches.length) {
+        success('No branches found.');
+        return;
+    }
+    console.log('Branches:');
+    branches.forEach((b) => {
+        const markers = [];
+        if (b.isDefault)
+            markers.push('default');
+        if (b.isProtected)
+            markers.push('protected');
+        if (b.active === false)
+            markers.push('inactive');
+        if (b.merge)
+            markers.push('ongoing merge');
+        const suffix = markers.length ? ` (${markers.join(', ')})` : '';
+        console.log(`- ${b.name}${suffix}`);
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tolgee/cli",
-  "version": "2.15.1",
+  "version": "2.16.0",
   "type": "module",
   "description": "A tool to interact with the Tolgee Platform through CLI",
   "repository": {

package/schema.json

@@ -5,6 +5,11 @@
       "description": "Project ID. Only required when using a Personal Access Token.",
       "type": ["number", "string"]
     },
+    "branch": {
+      "description": "Project branch. Use when branching enabled for the project.",
+      "type": "string",
+      "minLength": 1
+    },
     "apiUrl": {
       "description": "The url of Tolgee API.",
       "type": "string"