@tolgee/cli 2.14.0 → 2.15.0-rc.1

package/dist/client/ExportClient.js

@@ -7,14 +7,31 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 export const createExportClient = ({ apiClient }) => {
     return {
         export(req) {
             return __awaiter(this, void 0, void 0, function* () {
-                const body = Object.assign(Object.assign({}, req), { zip: true });
+                const { ifNoneMatch } = req, exportReq = __rest(req, ["ifNoneMatch"]);
+                const body = Object.assign(Object.assign({}, exportReq), { zip: true });
+                const headers = {};
+                if (ifNoneMatch) {
+                    headers['If-None-Match'] = ifNoneMatch;
+                }
                 const loadable = yield apiClient.POST('/v2/projects/{projectId}/export', {
                     params: { path: { projectId: apiClient.getProjectId() } },
                     body: body,
+                    headers,
                     parseAs: 'blob',
                 });
                 return Object.assign(Object.assign({}, loadable), { data: loadable.data });

package/dist/client/TolgeeClient.js

@@ -1,4 +1,3 @@
-import { exitWithError } from './../utils/logger.js';
 import { createApiClient } from './ApiClient.js';
 import { createExportClient } from './ExportClient.js';
 import { createImportClient } from './ImportClient.js';
@@ -9,6 +8,12 @@ export function createTolgeeClient(props) {
 }
 export const handleLoadableError = (loadable) => {
     if (loadable.error) {
-        exitWithError(errorFromLoadable(loadable));
+        throw new LoadableError(loadable);
     }
 };
+export class LoadableError extends Error {
+    constructor(loadable) {
+        super(errorFromLoadable(loadable));
+        this.loadable = loadable;
+    }
+}

package/dist/client/WebsocketClient.js

@@ -0,0 +1,120 @@
+import { Stomp } from '@stomp/stompjs';
+import SockJS from 'sockjs-client';
+import { debug, error } from '../utils/logger.js';
+export const WebsocketClient = (options) => {
+    let client;
+    let deactivated = false;
+    let connected = false;
+    let connecting = false;
+    let subscriptions = [];
+    const resubscribe = () => {
+        if (deactivated) {
+            return;
+        }
+        if (client) {
+            subscriptions.forEach((subscription) => {
+                subscribeToStompChannel(subscription);
+            });
+        }
+    };
+    const subscribeToStompChannel = (subscription) => {
+        if (connected && client) {
+            debug(`Subscribing to ${subscription.channel}`);
+            const stompSubscription = client.subscribe(subscription.channel, function (message) {
+                try {
+                    const parsed = JSON.parse(message.body);
+                    subscription.callback(parsed);
+                }
+                catch (e) {
+                    error(`Error parsing message: ${e.message}`);
+                }
+            });
+            subscription.unsubscribe = stompSubscription.unsubscribe;
+            subscription.id = stompSubscription.id;
+        }
+    };
+    function initClient() {
+        client = Stomp.over(() => new SockJS(`${options.serverUrl}/websocket`));
+        client.configure({
+            reconnectDelay: 3000,
+            debug: (msg) => {
+                debug(msg);
+            },
+        });
+    }
+    function connectIfNotAlready() {
+        if (deactivated || connected || connecting) {
+            return;
+        }
+        connecting = true;
+        const client = getClient();
+        const onConnected = function (message) {
+            var _a;
+            connected = true;
+            connecting = false;
+            resubscribe();
+            (_a = options.onConnected) === null || _a === void 0 ? void 0 : _a.call(options, message);
+        };
+        const onDisconnect = function () {
+            var _a;
+            connected = false;
+            connecting = false;
+            (_a = options.onConnectionClose) === null || _a === void 0 ? void 0 : _a.call(options);
+        };
+        const onError = (error) => {
+            var _a;
+            connecting = false;
+            (_a = options.onError) === null || _a === void 0 ? void 0 : _a.call(options, error);
+        };
+        client.connect(getAuthentication(options), onConnected, onError, onDisconnect);
+    }
+    const getClient = () => {
+        if (client !== undefined) {
+            return client;
+        }
+        initClient();
+        return client;
+    };
+    /**
+     * Subscribes to channel
+     * @param channel Channel URI
+     * @param callback Callback function to be executed when event is triggered
+     * @return Function Function unsubscribing the event listening
+     */
+    function subscribe(channel, callback) {
+        if (deactivated) {
+            return () => { };
+        }
+        connectIfNotAlready();
+        const subscription = { channel, callback };
+        subscriptions.push(subscription);
+        subscribeToStompChannel(subscription);
+        return () => {
+            var _a;
+            (_a = subscription.unsubscribe) === null || _a === void 0 ? void 0 : _a.call(subscription);
+            removeSubscription(subscription);
+        };
+    }
+    function disconnect() {
+        if (client) {
+            client.disconnect();
+        }
+    }
+    function deactivate() {
+        deactivated = true;
+        disconnect();
+    }
+    function removeSubscription(subscription) {
+        subscriptions = subscriptions.filter((it) => it !== subscription);
+    }
+    return Object.freeze({ subscribe, deactivate, connectIfNotAlready });
+};
+function getAuthentication(options) {
+    if (options.authentication.jwtToken) {
+        return { jwtToken: options.authentication.jwtToken };
+    }
+    if (options.authentication.apiKey) {
+        return { 'x-api-key': options.authentication.apiKey };
+    }
+    return {};
+}

package/dist/commands/login.js

@@ -9,10 +9,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { Command } from 'commander';
 import ansi from 'ansi-colors';
-import { saveApiKey, removeApiKeys, clearAuthStore, } from '../config/credentials.js';
-import { exitWithError, success } from '../utils/logger.js';
+import { clearAuthStore, removeApiKeys, saveApiKey, } from '../config/credentials.js';
+import { debug, exitWithError, success } from '../utils/logger.js';
 import { createTolgeeClient } from '../client/TolgeeClient.js';
 import { printApiKeyLists } from '../utils/apiKeyList.js';
+import { getStackTrace } from '../utils/getStackTrace.js';
 function loginHandler(key) {
     return __awaiter(this, void 0, void 0, function* () {
         const opts = this.optsWithGlobals();
@@ -23,6 +24,7 @@ function loginHandler(key) {
         else if (!key) {
             exitWithError('Missing argument [API Key]');
         }
+        debug(`Logging in with API key ${key === null || key === void 0 ? void 0 : key.slice(0, 5)}...${key === null || key === void 0 ? void 0 : key.slice(-4)}.\n${getStackTrace()}`);
         const keyInfo = yield createTolgeeClient({
             baseUrl: opts.apiUrl.toString(),
             apiKey: key,

package/dist/commands/pull.js

@@ -10,45 +10,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { Command, Option } from 'commander';
 import { unzipBuffer } from '../utils/zip.js';
 import { prepareDir } from '../utils/prepareDir.js';
-import { exitWithError, loading, success } from '../utils/logger.js';
+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';
-function fetchZipBlob(opts) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        const exportFormat = mapExportFormat(opts.format);
-        const { format, messageFormat } = exportFormat;
-        const loadable = yield opts.client.export.export({
-            format,
-            messageFormat,
-            supportArrays: opts.supportArrays,
-            languages: opts.languages,
-            filterState: opts.states,
-            structureDelimiter: (_a = opts.delimiter) !== null && _a !== void 0 ? _a : '',
-            filterNamespace: opts.namespaces,
-            filterTagIn: opts.tags,
-            filterTagNotIn: opts.excludeTags,
-            fileStructureTemplate: opts.fileStructureTemplate,
-            escapeHtml: false,
-        });
-        handleLoadableError(loadable);
-        return loadable.data;
-    });
-}
-const pullHandler = () => function () {
-    return __awaiter(this, void 0, void 0, function* () {
-        const opts = this.optsWithGlobals();
-        if (!opts.path) {
-            exitWithError('Missing option --path <path> or `pull.path` in tolgee config');
-        }
-        yield checkPathNotAFile(opts.path);
-        const zipBlob = yield loading('Fetching strings from Tolgee...', fetchZipBlob(opts));
-        yield prepareDir(opts.path, opts.emptyDir);
-        yield loading('Extracting strings...', unzipBuffer(zipBlob, opts.path));
-        success('Done!');
-    });
-};
+import { startWatching } from '../utils/pullWatch/watchHandler.js';
+import { getETag } from '../utils/eTagStorage.js';
 export default (config) => {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
     return new Command()
@@ -67,5 +34,80 @@ export default (config) => {
         .addOption(new Option('--support-arrays', 'Export keys with array syntax (e.g. item[0]) as arrays.').default((_j = (_h = config.pull) === null || _h === void 0 ? void 0 : _h.supportArrays) !== null && _j !== void 0 ? _j : false))
         .addOption(new Option('--empty-dir', 'Empty target directory before inserting pulled files.').default((_k = config.pull) === null || _k === void 0 ? void 0 : _k.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((_l = config.pull) === null || _l === void 0 ? void 0 : _l.fileStructureTemplate))
+        .addOption(new Option('--watch', 'Watch for changes and re-pull automatically').default(false))
         .action(pullHandler());
 };
+const pullHandler = () => function () {
+    return __awaiter(this, void 0, void 0, function* () {
+        const opts = this.optsWithGlobals();
+        if (!opts.path) {
+            exitWithError('Missing option --path <path> or `pull.path` in tolgee config');
+        }
+        yield checkPathNotAFile(opts.path);
+        if (!opts.watch) {
+            yield doPull(opts);
+            success('Done!');
+            return;
+        }
+        // Start watching for changes
+        yield startWatching({
+            apiUrl: opts.apiUrl,
+            apiKey: opts.apiKey,
+            projectId: opts.projectId,
+            client: opts.client,
+            doPull: () => __awaiter(this, void 0, void 0, function* () {
+                yield doPull(opts);
+            }),
+        });
+    });
+};
+const doPull = (opts) => __awaiter(void 0, void 0, void 0, function* () {
+    const result = yield loading('Fetching strings from Tolgee...', fetchZipBlob(opts, getETag(opts.projectId)));
+    if (result.notModified) {
+        info('Exported data not changed.');
+        return;
+    }
+    yield prepareDir(opts.path, opts.emptyDir);
+    yield loading('Extracting strings...', unzipBuffer(result.data, opts.path));
+    // Store ETag after a successful pull
+    if (result.etag) {
+        const { setETag } = yield import('../utils/eTagStorage.js');
+        setETag(opts.projectId, result.etag);
+    }
+});
+function fetchZipBlob(opts, ifNoneMatch) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
+        const exportFormat = mapExportFormat(opts.format);
+        const { format, messageFormat } = exportFormat;
+        const loadable = yield opts.client.export.export({
+            format,
+            messageFormat,
+            supportArrays: opts.supportArrays,
+            languages: opts.languages,
+            filterState: opts.states,
+            structureDelimiter: (_a = opts.delimiter) !== null && _a !== void 0 ? _a : '',
+            filterNamespace: opts.namespaces,
+            filterTagIn: opts.tags,
+            filterTagNotIn: opts.excludeTags,
+            fileStructureTemplate: opts.fileStructureTemplate,
+            escapeHtml: false,
+            ifNoneMatch,
+        });
+        handleLoadableError(loadable);
+        const etag = loadable.response
+            ? extractETagFromResponse(loadable.response)
+            : undefined;
+        return {
+            data: loadable.data,
+            etag,
+            // 412 is not modified for POST request
+            // https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Status/412
+            // 304 is not modified for GET request
+            notModified: [412, 304].includes((_c = (_b = loadable.response) === null || _b === void 0 ? void 0 : _b.status) !== null && _c !== void 0 ? _c : 0),
+        };
+    });
+}
+function extractETagFromResponse(response) {
+    return response.headers.get('ETag') || undefined;
+}

package/dist/config/credentials.js

@@ -79,19 +79,20 @@ export function savePak(instance, project, pak) {
         return storePak(store, instance, project, pak);
     });
 }
-export function getApiKey(instance, projectId) {
+export function getApiKey(apiUrl, projectId) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a;
         const store = yield loadStore();
-        if (!store[instance.hostname]) {
+        const apiUrlObj = new URL(apiUrl);
+        if (!store[apiUrlObj.hostname]) {
             return null;
         }
-        const scopedStore = store[instance.hostname];
+        const scopedStore = store[apiUrlObj.hostname];
         if (scopedStore.user) {
             if (scopedStore.user.expires !== 0 &&
                 Date.now() > scopedStore.user.expires) {
-                warn(`Your personal access token for ${instance.hostname} expired.`);
-                yield storePat(store, instance, undefined);
+                warn(`Your personal access token for ${apiUrlObj.hostname} expired.`);
+                yield storePat(store, apiUrlObj, undefined);
                 return null;
             }
             return scopedStore.user.token;
@@ -102,8 +103,8 @@ export function getApiKey(instance, projectId) {
         const pak = (_a = scopedStore.projects) === null || _a === void 0 ? void 0 : _a[projectId.toString(10)];
         if (pak) {
             if (pak.expires !== 0 && Date.now() > pak.expires) {
-                warn(`Your project API key for project #${projectId} on ${instance.hostname} expired.`);
-                yield removePak(store, instance, projectId);
+                warn(`Your project API key for project #${projectId} on ${apiUrlObj.hostname} expired.`);
+                yield removePak(store, apiUrlObj, projectId);
                 return null;
             }
             return pak.token;

package/dist/utils/eTagStorage.js

@@ -0,0 +1,15 @@
+// In-memory storage for ETag data
+// In the future we can use filesystem to store it
+const etagStorage = new Map();
+export function getETag(projectId) {
+    const data = etagStorage.get(projectId);
+    if (!data) {
+        return undefined;
+    }
+    return data.etag;
+}
+export function setETag(projectId, etag) {
+    etagStorage.set(projectId, {
+        etag,
+    });
+}

package/dist/utils/isVersionAtLeast.js

@@ -0,0 +1,29 @@
+import { debug } from './logger.js';
+/**
+ Compares two semantic versions (e.g., "3.143.0" vs "3.142.0")
+ Returns true if version1 >= version2
+*/
+export function isVersionAtLeast(required, current) {
+    debug(`Checking that server version ${current} is at least ${required}`);
+    if (current === '??') {
+        // local build, lets assume it's supported
+        return true;
+    }
+    // Strip optional 'v' prefix from both versions
+    const cleanRequired = required.startsWith('v') ? required.slice(1) : required;
+    const cleanServerVersion = current.startsWith('v')
+        ? current.slice(1)
+        : current;
+    const requiredParts = cleanRequired.split('.').map(Number);
+    const currentParts = cleanServerVersion.split('.').map(Number);
+    const maxLength = Math.max(requiredParts.length, currentParts.length);
+    for (let i = 0; i < maxLength; i++) {
+        const requiredPart = requiredParts[i] || 0;
+        const currentPart = currentParts[i] || 0;
+        if (currentPart > requiredPart)
+            return true;
+        if (currentPart < requiredPart)
+            return false;
+    }
+    return true;
+}

package/dist/utils/logger.js

@@ -113,7 +113,7 @@ export function exitWithError(err) {
 export function loading(comment, promise) {
     if (!process.stdout.isTTY) {
         // Simple stdout without animations
-        process.stdout.write(comment);
+        process.stdout.write(comment + `\n`);
         promise.then(() => process.stdout.write(`   ✓ Success\n`), () => process.stdout.write(`   ✗ Failure\n`));
         return promise;
     }

package/dist/utils/pullWatch/AuthErrorHandler.js

@@ -0,0 +1,71 @@
+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 { debug, error } from '../logger.js';
+import { isVersionAtLeast } from '../isVersionAtLeast.js';
+export function AuthErrorHandler(client) {
+    function handleAuthErrors(err, shutdown) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if (((_a = err === null || err === void 0 ? void 0 : err.headers) === null || _a === void 0 ? void 0 : _a.message) == 'Unauthenticated') {
+                yield printUnauthenticatedError();
+                shutdown();
+                return;
+            }
+            if (((_b = err === null || err === void 0 ? void 0 : err.headers) === null || _b === void 0 ? void 0 : _b.message) == 'Forbidden') {
+                error("You're not authorized. Insufficient permissions?");
+                shutdown();
+                return;
+            }
+        });
+    }
+    function printUnauthenticatedError() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { isSupported, serverVersion } = yield isAppSupportedVersion(client);
+            if (isSupported) {
+                error("You're not authenticated. Invalid API key?");
+                return;
+            }
+            error(`Server version ${serverVersion} does not support CLI watch mode. Please update your Tolgee server to version ${REQUIRED_VERSION} or higher.`);
+            return;
+        });
+    }
+    function isAppSupportedVersion(client) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const serverVersion = yield getTolgeeServerVersion(client);
+            if (!serverVersion) {
+                debug('Could not determine server version');
+                return {
+                    isSupported: false,
+                    serverVersion: serverVersion,
+                };
+            }
+            return {
+                isSupported: isVersionAtLeast(REQUIRED_VERSION, serverVersion),
+                serverVersion: serverVersion,
+            };
+        });
+    }
+    function getTolgeeServerVersion(client) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const config = yield client.GET('/api/public/configuration');
+                const version = (_a = config.response) === null || _a === void 0 ? void 0 : _a.headers.get('x-tolgee-version');
+                return version || null;
+            }
+            catch (error) {
+                debug('Failed to get server version: ' + error);
+                return null;
+            }
+        });
+    }
+    return Object.freeze({ handleAuthErrors });
+}
+const REQUIRED_VERSION = '3.143.0';

package/dist/utils/pullWatch/watchHandler.js

@@ -0,0 +1,149 @@
+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 { WebsocketClient } from '../../client/WebsocketClient.js';
+import { debug, error, info, success } from '../logger.js';
+import { setETag } from '../eTagStorage.js';
+import { clearInterval } from 'node:timers';
+import { AuthErrorHandler } from './AuthErrorHandler.js';
+// Polling interval as backup when WebSocket is not available (in seconds)
+const POLLING_INTERVAL_SECONDS = 60;
+// Debounce delay for schedulePull in milliseconds
+const SCHEDULE_PULL_DEBOUNCE_MS = 500;
+export function startWatching(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { apiUrl, apiKey, projectId, doPull, client } = options;
+        // Watch mode using WebsocketClient on translation-data-modified
+        info('Watching for translation changes... Press Ctrl+C to stop.');
+        let pulling = false;
+        /**
+         * Pending handles the situation when changes are detected while the pull is
+         * already in progress.
+         */
+        let pending = false;
+        let pendingEtag;
+        let debounceTimer;
+        let pollingTimer;
+        let lastExecutionTime = 0;
+        const executePull = (etag) => __awaiter(this, void 0, void 0, function* () {
+            if (pulling) {
+                pending = true;
+                pendingEtag = etag;
+                return;
+            }
+            pulling = true;
+            lastExecutionTime = Date.now();
+            try {
+                yield doPull();
+                // Store ETag after successful pull
+                if (etag) {
+                    setETag(projectId, etag);
+                }
+            }
+            catch (e) {
+                error('Error during pull: ' + e.message);
+                debug(e);
+            }
+            finally {
+                pulling = false;
+                // If there was a pending pull (data changed when pulling), execute it now
+                if (pending) {
+                    pending = false;
+                    const capturedEtag = pendingEtag;
+                    pendingEtag = undefined;
+                    void executePull(capturedEtag);
+                }
+            }
+        });
+        const schedulePull = (etag) => __awaiter(this, void 0, void 0, function* () {
+            const now = Date.now();
+            const timeSinceLastExecution = now - lastExecutionTime;
+            // If last execution was more than 500ms ago, execute immediately
+            if (timeSinceLastExecution >= SCHEDULE_PULL_DEBOUNCE_MS) {
+                yield executePull(etag);
+            }
+            else {
+                // Otherwise, schedule the update with debounce
+                if (debounceTimer)
+                    clearTimeout(debounceTimer);
+                debounceTimer = setTimeout(() => executePull(etag), SCHEDULE_PULL_DEBOUNCE_MS);
+            }
+        });
+        // Polling mechanism as backup
+        const startPolling = () => {
+            if (pollingTimer) {
+                clearInterval(pollingTimer);
+            }
+            const poll = () => __awaiter(this, void 0, void 0, function* () {
+                if (pulling)
+                    return;
+                debug('Polling for changes...');
+                yield schedulePull();
+            });
+            // Set up periodic polling
+            pollingTimer = setInterval(poll, POLLING_INTERVAL_SECONDS * 1000);
+        };
+        const wsClient = WebsocketClient({
+            serverUrl: new URL(apiUrl).origin,
+            authentication: { apiKey: apiKey },
+            onConnected: () => {
+                debug('WebSocket connected and subscriptions active. Performing initial pull...');
+                schedulePull();
+            },
+            onError: (error) => {
+                AuthErrorHandler(client)
+                    .handleAuthErrors(error, shutdown)
+                    .catch((err) => {
+                    debug('Error in handleAuthErrors: ' + err);
+                });
+                // Non-fatal: just inform
+                info('Websocket error encountered. Reconnecting...');
+            },
+            onConnectionClose: () => {
+                info('Websocket connection closed. Attempting to reconnect...');
+            },
+        });
+        const channel = `/projects/${projectId}/translation-data-modified`;
+        let unsubscribe;
+        function subscribe() {
+            unsubscribe = wsClient.subscribe(channel, () => {
+                debug('Data change detected by websocket. Pulling now... ');
+                schedulePull();
+                startPolling();
+            });
+        }
+        const shutdown = () => {
+            try {
+                unsubscribe === null || unsubscribe === void 0 ? void 0 : unsubscribe();
+            }
+            catch (_a) {
+                // Ignore errors during shutdown cleanup
+            }
+            try {
+                wsClient.deactivate();
+            }
+            catch (_b) {
+                // Ignore errors during shutdown cleanup
+            }
+            if (pollingTimer) {
+                clearInterval(pollingTimer);
+            }
+            if (debounceTimer) {
+                clearTimeout(debounceTimer);
+            }
+            success('Stopped watching. Bye!');
+            process.exit(0);
+        };
+        process.on('SIGINT', shutdown);
+        process.on('SIGTERM', shutdown);
+        subscribe();
+        // Keep process alive
+        yield new Promise(() => { });
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tolgee/cli",
-  "version": "2.14.0",
+  "version": "2.15.0-rc.1",
   "type": "module",
   "description": "A tool to interact with the Tolgee Platform through CLI",
   "repository": {
@@ -30,6 +30,7 @@
   "author": "Jan Cizmar",
   "license": "MIT",
   "dependencies": {
+    "@stomp/stompjs": "^7.1.1",
     "ajv": "^8.17.1",
     "ansi-colors": "^4.1.3",
     "base32-decode": "^1.0.0",
@@ -38,21 +39,29 @@
     "json5": "^2.2.3",
     "jsonschema": "^1.5.0",
     "openapi-fetch": "0.13.1",
+    "sockjs-client": "^1.6.1",
     "tinyglobby": "^0.2.12",
     "unescape-js": "^1.1.4",
     "vscode-oniguruma": "^2.0.1",
     "vscode-textmate": "^9.1.0",
+    "ws": "^8.18.3",
     "yauzl": "^3.2.0"
   },
   "devDependencies": {
     "@eslint/js": "^9.16.0",
+    "semantic-release": "^25.0.2",
+    "@semantic-release/npm": "^13.1.3",
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^12.0.2",
+    "@semantic-release/commit-analyzer": "^13.0.1",
+    "@semantic-release/release-notes-generator": "^14.1.0",
     "@tsconfig/node18": "^18.2.4",
     "@tsconfig/recommended": "^1.0.8",
     "@types/eslint__js": "^8.42.3",
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^22.10.1",
+    "@types/sockjs-client": "^1.5.4",
     "@types/yauzl": "^2.10.3",
     "cross-env": "^7.0.3",
     "eslint": "^9.16.0",
@@ -64,7 +73,6 @@
     "openapi-typescript": "^7.4.4",
     "premove": "^4.0.0",
     "prettier": "^3.4.1",
-    "semantic-release": "^24.2.0",
     "tree-cli": "^0.6.7",
     "tsx": "^4.19.2",
     "typescript": "~5.6.3",