@crowdin/app-project-module 0.69.0 → 0.70.1

package/out/index.js

@@ -74,12 +74,15 @@ const fileProcessingApps = __importStar(require("./modules/file-processing"));
 const integrationApp = __importStar(require("./modules/integration"));
 const modalApp = __importStar(require("./modules/modal"));
 const organizationMenuApp = __importStar(require("./modules/organization-menu"));
+const organizationSettingsMenuApp = __importStar(require("./modules/organization-settings-menu"));
 const profileResourcesMenuApp = __importStar(require("./modules/profile-resources-menu"));
+const profileSettingsMenuApp = __importStar(require("./modules/profile-settings-menu"));
 const projectMenuApp = __importStar(require("./modules/project-menu"));
 const projectMenuCrowdsourceApp = __importStar(require("./modules/project-menu-crowdsource"));
 const projectReportsApp = __importStar(require("./modules/project-reports"));
 const projectToolsApp = __importStar(require("./modules/project-tools"));
 const webhooks = __importStar(require("./modules/webhooks"));
+const workflowStepType = __importStar(require("./modules/workflow-step-type"));
 const subscription_1 = require("./util/subscription");
 var types_2 = require("./types");
 Object.defineProperty(exports, "ProjectPermissions", { enumerable: true, get: function () { return types_2.ProjectPermissions; } });
@@ -123,7 +126,14 @@ function addCrowdinEndpoints(app, clientConfig) {
     }
     storage.initialize(config);
     logger.initialize(config);
-    app.use(terminus_express_1.default.json({ limit: '50mb' }));
+    app.use((req, res, next) => {
+        if (config.webhooks && req.path === '/webhooks') {
+            return terminus_express_1.default.raw({ type: '*/*', limit: '50mb' })(req, res, next);
+        }
+        else {
+            return terminus_express_1.default.json({ limit: '50mb' })(req, res, next);
+        }
+    });
     if (!config.disableLogsFormatter) {
         logsFormatter.setup();
         app.use(logsFormatter.contextResolverMiddleware());
@@ -142,7 +152,9 @@ function addCrowdinEndpoints(app, clientConfig) {
     editorRightPanelApp.register({ config, app });
     projectMenuApp.register({ config, app });
     profileResourcesMenuApp.register({ config, app });
+    profileSettingsMenuApp.register({ config, app });
     organizationMenuApp.register({ config, app });
+    organizationSettingsMenuApp.register({ config, app });
     projectMenuCrowdsourceApp.register({ config, app });
     projectToolsApp.register({ config, app });
     projectReportsApp.register({ config, app });
@@ -177,6 +189,7 @@ function addCrowdinEndpoints(app, clientConfig) {
     aiTools.registerAiToolWidgets({ config, app });
     externalQaCheck.register({ config, app });
     webhooks.register({ config, app });
+    workflowStepType.register({ config, app });
     addFormSchema({ config, app });
     return Object.assign(Object.assign({}, exports.metadataStore), { establishCrowdinConnection: (authRequest, moduleKey) => {
             let jwtToken = '';
@@ -193,13 +206,13 @@ function addCrowdinEndpoints(app, clientConfig) {
                 checkSubscriptionExpiration: false,
                 moduleKey,
             });
-        }, encryptCrowdinConnection: (data) => (0, util_1.encryptData)(config, JSON.stringify(data)), dencryptCrowdinConnection: (hash) => __awaiter(this, void 0, void 0, function* () {
+        }, encryptCrowdinConnection: (data) => (0, util_1.encryptData)(config, JSON.stringify(data)), dencryptCrowdinConnection: (hash, autoRenew) => __awaiter(this, void 0, void 0, function* () {
             const { crowdinId, extra } = JSON.parse((0, util_1.decryptData)(config, hash));
             const credentials = yield storage.getStorage().getCrowdinCredentials(crowdinId);
             if (!credentials) {
                 throw new Error('Failed to find Crowdin credentials');
             }
-            const { client } = yield (0, connection_1.prepareCrowdinClient)({ config, credentials });
+            const { client } = yield (0, connection_1.prepareCrowdinClient)({ config, credentials, autoRenew });
             return { client, extra };
         }) });
 }

package/out/modules/ai-provider/handlers/chat-completions.js

@@ -13,12 +13,7 @@ const util_1 = require("../../../util");
 const logger_1 = require("../../../util/logger");
 const files_1 = require("../../integration/util/files");
 const util_2 = require("../util");
-// more about roles in AI messages https://platform.openai.com/docs/api-reference/chat/create#chat-create-messages
-// Crowdin documentation https://support.crowdin.com/developer/crowdin-apps-module-custom-ai/#expected-response-from-the-app
-const ROLES = {
-    assistant: 'assistant',
-};
-const DEFAULT_ROLE = ROLES.assistant;
+const DEFAULT_ROLE = 'assistant';
 const getErrorStatus = (e) => {
     if (typeof e === 'object' && 'status' in e && typeof e.status === 'number') {
         return e.status;
@@ -39,7 +34,7 @@ function handle(aiProvider) {
             let message;
             let data;
             const chunks = [];
-            const { crowdinApiClient: client, crowdinContext: context, body: { messages, model, action, stream, responseFormat: { type: responseFormatType } = { type: undefined }, }, } = req;
+            const { crowdinApiClient: client, crowdinContext: context, body: { messages, model, action, stream, tools, tool_choice: toolChoice, responseFormat: { type: responseFormatType } = { type: undefined }, }, } = req;
             isStream = !!stream;
             const startStream = () => {
                 if (!res.headersSent) {
@@ -47,11 +42,12 @@ function handle(aiProvider) {
                         Connection: 'keep-alive',
                         'Cache-Control': 'no-cache',
                         'Content-Type': 'text/event-stream',
+                        'X-Accel-Buffering': 'no',
                     });
                 }
             };
             const result = yield aiProvider.chatCompletions({
-                messages,
+                messages: messages.map(util_2.inputMessageToChatCompletionMessage),
                 model,
                 action,
                 responseFormat: responseFormatType,
@@ -59,19 +55,26 @@ function handle(aiProvider) {
                 context,
                 req,
                 isStream,
-                sendEvent: ({ content, role }) => __awaiter(this, void 0, void 0, function* () {
+                tools,
+                toolChoice,
+                /* eslint-disable @typescript-eslint/camelcase */
+                sendEvent: ({ content, role, tool_calls }) => __awaiter(this, void 0, void 0, function* () {
                     if (!isStream) {
-                        chunks.push({ content, role });
+                        chunks.push({ content, role, tool_calls });
                         return;
                     }
                     startStream();
+                    const delta = {
+                        role: role || DEFAULT_ROLE,
+                        content: content || null,
+                    };
+                    if (!!tool_calls) {
+                        delta.tool_calls = tool_calls;
+                    }
                     const message = {
                         choices: [
                             {
-                                delta: {
-                                    role: role || DEFAULT_ROLE,
-                                    content,
-                                },
+                                delta,
                             },
                         ],
                     };
@@ -92,18 +95,14 @@ function handle(aiProvider) {
                 data = result;
             }
             if (chunks.length) {
-                data = [
-                    {
-                        role: chunks[0].role || DEFAULT_ROLE,
-                        content: chunks.map((chunk) => chunk.content).join(''),
-                    },
-                ];
+                data = (0, util_2.mergeChatCompletionChunks)(chunks);
             }
             if (data && data.length > 0) {
                 choices = data.map((message) => ({
                     message: {
                         role: message.role || DEFAULT_ROLE,
-                        content: message.content,
+                        content: message.content || null,
+                        tool_calls: message.tool_calls,
                     },
                 }));
             }

package/out/modules/ai-provider/handlers/get-model-list.js

@@ -22,13 +22,14 @@ function handle(aiProvider) {
                 context: req.crowdinContext,
             });
             const data = modelList.map((model) => {
-                var _a, _b, _c, _d;
+                var _a, _b, _c, _d, _e;
                 return ({
                     id: model.id,
                     supportsJsonMode: (_a = model.supportsJsonMode) !== null && _a !== void 0 ? _a : false,
                     supportsFunctionCalling: (_b = model.supportsFunctionCalling) !== null && _b !== void 0 ? _b : false,
                     supportsStreaming: (_c = model.supportsStreaming) !== null && _c !== void 0 ? _c : false,
-                    contextWindowLimit: (_d = model.contextWindowLimit) !== null && _d !== void 0 ? _d : exports.CONTEXT_WINDOW_LIMIT,
+                    supportsVision: (_d = model.supportsVision) !== null && _d !== void 0 ? _d : false,
+                    contextWindowLimit: (_e = model.contextWindowLimit) !== null && _e !== void 0 ? _e : exports.CONTEXT_WINDOW_LIMIT,
                 });
             });
             res.send({ data });

package/out/modules/ai-provider/types.d.ts

@@ -17,8 +17,8 @@ export interface AiProviderModule extends Environments, ModuleKey {
     /**
      * processes a sequence of conversation messages and generates responses from the assistant
      */
-    chatCompletions: ({ messages, model, action, responseFormat, client, context, req, }: {
-        messages: Message[];
+    chatCompletions: ({ messages, model, action, responseFormat, client, context, req, isStream, sendEvent, tools, toolChoice, }: {
+        messages: ChatCompletionMessage[];
         model: string;
         action: string;
         responseFormat: string;
@@ -26,8 +26,10 @@ export interface AiProviderModule extends Environments, ModuleKey {
         context: CrowdinContextInfo;
         req: CrowdinClientRequest;
         isStream: boolean;
-        sendEvent: (chunk: Message) => Promise<void>;
-    }) => Promise<Message[] | ExtendedResult<Message[]>>;
+        sendEvent: (chunk: ChatCompletionChunkMessage) => Promise<void>;
+        tools?: ChatCompletionTool[];
+        toolChoice?: string | AiToolChoice;
+    }) => Promise<ChatCompletionResponseMessage[] | ExtendedResult<ChatCompletionResponseMessage[]> | void>;
     /**
      * provides a list of available model
      */
@@ -41,9 +43,112 @@ export interface SupportedModels {
     supportsJsonMode?: boolean;
     supportsFunctionCalling?: boolean;
     supportsStreaming?: boolean;
+    supportsVision?: boolean;
     contextWindowLimit?: number;
 }
-export interface Message {
-    role?: string;
-    content: string;
+export interface ChatCompletionTool {
+    type: 'function';
+    function: ChatCompletionToolFunctionDeclaration;
 }
+export interface ChatCompletionToolFunctionDeclaration {
+    /**
+     * The name of the function to be called. Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length of 64.
+     */
+    name: string;
+    /**
+     * A description of what the function does, used by the model to choose when and how to call the function.
+     */
+    description?: string;
+    /**
+     * The parameters the functions accepts, described as a JSON Schema object.
+     * https://json-schema.org/understanding-json-schema/
+     */
+    parameters?: object;
+}
+export interface AiToolChoice {
+    type: 'function';
+    function: {
+        /**
+         * The name of the function to call.
+         */
+        name: string;
+    };
+}
+export type ChatCompletionMessage = ChatCompletionSystemMessage | ChatCompletionUserMessage | ChatCompletionAssistantMessage | ChatCompletionToolMessage;
+export interface ChatCompletionSystemMessage {
+    role: 'system';
+    content: string | ChatCompletionContentPartText[];
+}
+export interface ChatCompletionUserMessage {
+    role?: 'user';
+    content: string | ChatCompletionContentPart[];
+}
+export type ChatCompletionResponseMessage = ChatCompletionAssistantMessage;
+export interface ChatCompletionAssistantMessage {
+    role?: 'assistant';
+    content?: string | ChatCompletionContentPartText[] | null;
+    tool_calls?: ChatCompletionMessageToolCall[] | null;
+}
+export interface ChatCompletionChunkMessage {
+    role?: ROLES;
+    content?: string | null;
+    tool_calls?: ChatCompletionDeltaMessageToolCall[];
+}
+export interface ChatCompletionToolMessage {
+    content: string | ChatCompletionContentPartText[];
+    role: 'tool';
+    /**
+     * Tool call that this message is responding to.
+     */
+    tool_call_id: string;
+}
+export type ROLES = 'user' | 'assistant' | 'system' | 'tool';
+export type ChatCompletionContentPart = ChatCompletionContentPartText | ChatCompletionContentPartImage;
+export type ChatCompletionContentPartText = {
+    type: 'text';
+    text: string;
+};
+export type ChatCompletionContentPartImage = {
+    type: 'image_url';
+    image_url: {
+        /**
+         * Either a URL of the image or the base64 encoded image data.
+         */
+        url: string;
+    };
+};
+export interface ChatCompletionMessageToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        /**
+         * The arguments to call the function with, as generated by the model in JSON format.
+         * Note that the model does not always generate valid JSON.
+         */
+        arguments?: string;
+        name: string;
+    };
+}
+export interface ChatCompletionDeltaMessageToolCall {
+    index: number;
+    id?: string;
+    type?: 'function';
+    function?: {
+        /**
+         * The arguments to call the function with, as generated by the model in JSON format.
+         * Note that the model does not always generate valid JSON.
+         */
+        arguments?: string;
+        name?: string;
+    };
+}
+export interface InputMessage {
+    role?: ROLES;
+    content: string | InputContentPart[];
+}
+export type InputContentPart = ChatCompletionContentPartText | InputChatCompletionContentPartImage;
+export type InputChatCompletionContentPartImage = {
+    type: 'image';
+    mimeType: string;
+    url: string;
+};

package/out/modules/ai-provider/util/index.d.ts

@@ -1,4 +1,5 @@
 import { AppModuleAggregateError } from '../../../util/logger';
+import { ChatCompletionChunkMessage, ChatCompletionContentPart, ChatCompletionMessage, ChatCompletionMessageToolCall, ChatCompletionResponseMessage, InputContentPart, InputMessage } from '../types';
 interface RateLimitErrorOptions {
     error?: Error;
     message?: string;
@@ -8,4 +9,8 @@ export declare class RateLimitError extends AppModuleAggregateError {
     readonly status = 429;
     constructor({ error, message }?: RateLimitErrorOptions);
 }
+export declare function normalizeContentParts(content: string | InputContentPart[]): string | ChatCompletionContentPart[];
+export declare function inputMessageToChatCompletionMessage(message: InputMessage): ChatCompletionMessage;
+export declare function mergeToolCalls(chunks: ChatCompletionChunkMessage[]): ChatCompletionMessageToolCall[] | null;
+export declare function mergeChatCompletionChunks(chunks: ChatCompletionChunkMessage[]): ChatCompletionResponseMessage[];
 export {};

package/out/modules/ai-provider/util/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RateLimitError = exports.isRateLimitError = void 0;
+exports.mergeChatCompletionChunks = exports.mergeToolCalls = exports.inputMessageToChatCompletionMessage = exports.normalizeContentParts = exports.RateLimitError = exports.isRateLimitError = void 0;
 const logger_1 = require("../../../util/logger");
 const HTTP_RATE_LIMIT = 429;
 function isRateLimitError(e) {
@@ -19,3 +19,74 @@ class RateLimitError extends logger_1.AppModuleAggregateError {
     }
 }
 exports.RateLimitError = RateLimitError;
+function normalizeContentParts(content) {
+    return Array.isArray(content)
+        ? content.map((part) => part.type === 'image'
+            ? {
+                type: 'image_url',
+                // eslint-disable-next-line @typescript-eslint/camelcase
+                image_url: {
+                    url: part.url,
+                },
+            }
+            : part)
+        : content;
+}
+exports.normalizeContentParts = normalizeContentParts;
+function inputMessageToChatCompletionMessage(message) {
+    switch (message.role) {
+        case undefined:
+        case 'user':
+            return {
+                role: 'user',
+                content: normalizeContentParts(message.content),
+            };
+        default:
+            return message;
+    }
+}
+exports.inputMessageToChatCompletionMessage = inputMessageToChatCompletionMessage;
+function mergeToolCalls(chunks) {
+    const toolCalls = [];
+    chunks.forEach((chunk) => {
+        if (!chunk.tool_calls) {
+            return;
+        }
+        chunk.tool_calls.forEach((toolCallChunk) => {
+            const delta = toolCalls.find((toolCall) => toolCall.index === toolCallChunk.index);
+            if (!delta) {
+                toolCalls.push(toolCallChunk);
+            }
+            else if (!!toolCallChunk.function && 'arguments' in toolCallChunk.function) {
+                if (!delta.function) {
+                    delta.function = toolCallChunk.function;
+                }
+                else if (!delta.function.arguments) {
+                    delta.function.arguments = toolCallChunk.function.arguments;
+                }
+                else {
+                    delta.function.arguments += toolCallChunk.function.arguments;
+                }
+            }
+        });
+    });
+    toolCalls.map((tool) => {
+        if ('index' in tool) {
+            delete tool.index;
+        }
+    });
+    return !toolCalls.length ? null : toolCalls;
+}
+exports.mergeToolCalls = mergeToolCalls;
+function mergeChatCompletionChunks(chunks) {
+    /* eslint-disable @typescript-eslint/camelcase */
+    const tool_calls = mergeToolCalls(chunks);
+    return [
+        {
+            role: chunks[0].role || 'assistant',
+            content: tool_calls ? null : chunks.map((chunk) => chunk.content).join(''),
+            tool_calls,
+        },
+    ];
+}
+exports.mergeChatCompletionChunks = mergeChatCompletionChunks;

package/out/modules/file-processing/handlers/pre-post-process.js

@@ -23,9 +23,15 @@ function handle(baseConfig, config, folderName) {
         fs_1.default.mkdirSync(path_1.default.join(folderPath, folderName), { recursive: true });
     }
     return (0, util_1.runAsyncWrapper)((req, res) => __awaiter(this, void 0, void 0, function* () {
+        var _a;
         const response = {};
         const baseFilesUrl = `${baseConfig.baseUrl}/file/download/${folderName}`;
         const body = req.body;
+        // Skip assets (e.g., images, videos, or other media files) as they typically don't need to be processed
+        if (((_a = body === null || body === void 0 ? void 0 : body.file) === null || _a === void 0 ? void 0 : _a.type) === 'assets' && !('processAssets' in config && config.processAssets)) {
+            res.sendStatus(304);
+            return;
+        }
         let processingError;
         let fileContent;
         let rawContent;

package/out/modules/file-processing/types.d.ts

@@ -60,17 +60,24 @@ export interface CustomFileFormatLogic extends FileProcessLogic {
 }
 export type FileImportExportLogic = FilePreImportLogic | FilePostImportLogic | FilePreExportLogic | FilePostExportLogic;
 export type FileImportExportContent = ProcessFileString[] | Buffer | undefined;
-export interface FilePreImportLogic extends FileProcessLogic {
-    fileProcess: (req: ProcessFileRequest, content: FileImportExportContent, client: Crowdin, context: CrowdinContextInfo, projectId: number) => Promise<ContentFileResponse>;
+export interface BaseFileProcessLogic<T> {
+    fileProcess: (req: ProcessFileRequest, content: FileImportExportContent, client: Crowdin, context: CrowdinContextInfo, projectId: number) => Promise<T>;
 }
-export interface FilePostImportLogic extends FileProcessLogic {
-    fileProcess: (req: ProcessFileRequest, content: FileImportExportContent, client: Crowdin, context: CrowdinContextInfo, projectId: number) => Promise<StringsFileResponse>;
+export interface FilePreImportLogic extends FileProcessLogic, BaseFileProcessLogic<ContentFileResponse> {
+    /**
+     * Set to `true` to enable asset processing in the application.
+     */
+    processAssets?: boolean;
+}
+export interface FilePostImportLogic extends FileProcessLogic, BaseFileProcessLogic<StringsFileResponse> {
 }
-export interface FilePreExportLogic extends FileProcessLogic {
-    fileProcess: (req: ProcessFileRequest, content: FileImportExportContent, client: Crowdin, context: CrowdinContextInfo, projectId: number) => Promise<StringsFileResponse>;
+export interface FilePreExportLogic extends FileProcessLogic, BaseFileProcessLogic<StringsFileResponse> {
 }
-export interface FilePostExportLogic extends FileProcessLogic {
-    fileProcess: (req: ProcessFileRequest, content: FileImportExportContent, client: Crowdin, context: CrowdinContextInfo, projectId: number) => Promise<ContentFileResponse>;
+export interface FilePostExportLogic extends FileProcessLogic, BaseFileProcessLogic<ContentFileResponse> {
+    /**
+     * Set to `true` to enable asset processing in the application.
+     */
+    processAssets?: boolean;
 }
 export interface ProcessFileRequest {
     jobType: ProcessFileJobType;
@@ -87,6 +94,7 @@ export interface ProcessFileRecord {
     path?: string;
     id?: number;
     name?: string;
+    type?: string;
 }
 export declare enum ProcessFileJobType {
     PARSE_FILE = "parse-file",

package/out/modules/manifest.js

@@ -5,6 +5,7 @@ const util_1 = require("../util");
 const subscription_1 = require("../util/subscription");
 const api_1 = require("./api/api");
 const util_2 = require("./ai-tools/util");
+const util_3 = require("./workflow-step-type/util");
 function normalizeEnvironments(environments) {
     if (Array.isArray(environments)) {
         return environments;
@@ -12,6 +13,7 @@ function normalizeEnvironments(environments) {
     return [environments];
 }
 function handle(config) {
+    var _a, _b;
     const modules = {};
     if (config.projectIntegration) {
         config.projectIntegration.key = config.identifier + '-int';
@@ -100,6 +102,17 @@ function handle(config) {
             },
         ];
     }
+    if (config.organizationSettingsMenu) {
+        config.organizationSettingsMenu.key = config.identifier + '-organization-settings-menu';
+        modules['organization-settings-menu'] = [
+            {
+                key: config.organizationSettingsMenu.key,
+                name: config.organizationSettingsMenu.name || config.name,
+                url: '/settings/' + (config.organizationSettingsMenu.fileName || 'index.html'),
+                icon: (0, util_1.getLogoUrl)(config.organizationSettingsMenu, '/settings'),
+            },
+        ];
+    }
     if (config.profileResourcesMenu) {
         config.profileResourcesMenu.key = config.identifier + '-profile-resources-menu';
         modules['profile-resources-menu'] = [
@@ -108,6 +121,14 @@ function handle(config) {
             })),
         ];
     }
+    if (config.profileSettingsMenu) {
+        config.profileSettingsMenu.key = config.identifier + '-profile-settings-menu';
+        modules['profile-settings-menu'] = [
+            Object.assign({ key: config.profileSettingsMenu.key, name: config.profileSettingsMenu.name || config.name, url: '/settings/' + (config.profileSettingsMenu.fileName || 'index.html'), icon: (0, util_1.getLogoUrl)(config.profileSettingsMenu, '/settings') }, (!!config.profileSettingsMenu.environments && {
+                environments: normalizeEnvironments(config.profileSettingsMenu.environments),
+            })),
+        ];
+    }
     if (config.editorRightPanel) {
         config.editorRightPanel.key = config.identifier + '-editor-panels';
         modules['editor-right-panel'] = [
@@ -244,6 +265,19 @@ function handle(config) {
             Object.assign(Object.assign({ key: config.externalQaCheck.key, name: config.externalQaCheck.name || config.name, description: config.externalQaCheck.description || config.description, runQaCheckUrl: '/validate' }, (config.externalQaCheck.batchSize ? { getBatchSizeUrl: '/batch-size' } : {})), (uiModule ? { url: '/settings/' + (uiModule.fileName || 'index.html') } : {})),
         ];
     }
+    if (config.workflowStepType) {
+        const workflowSteps = Array.isArray(config.workflowStepType)
+            ? config.workflowStepType
+            : [config.workflowStepType];
+        modules['workflow-step-type'] = [];
+        for (const workflowStep of workflowSteps) {
+            if (!workflowStep.key) {
+                workflowStep.key = config.identifier + '-' + (0, util_3.getWorkflowStepKey)(workflowStep);
+            }
+            const uiModule = ((_a = workflowStep === null || workflowStep === void 0 ? void 0 : workflowStep.settingsUiModule) === null || _a === void 0 ? void 0 : _a.formSchema) || ((_b = workflowStep === null || workflowStep === void 0 ? void 0 : workflowStep.settingsUiModule) === null || _b === void 0 ? void 0 : _b.fileName);
+            modules['workflow-step-type'].push(Object.assign({ key: workflowStep.key, name: workflowStep.name || config.name, description: workflowStep.description || config.description, boundaries: workflowStep.boundaries, updateSettingsUrl: (0, util_3.getWorkflowStepUrl)('/settings', workflowStep), deleteSettingsUrl: (0, util_3.getWorkflowStepUrl)('/delete', workflowStep) }, (uiModule ? { url: (0, util_3.getWorkflowStepUrl)('/workflow-step', workflowStep) } : {})));
+        }
+    }
     const events = {
         installed: '/installed',
         uninstall: '/uninstall',

package/out/modules/organization-settings-menu/index.d.ts

@@ -0,0 +1,6 @@
+import { Express } from 'express';
+import { Config, UnauthorizedConfig } from '../../types';
+export declare function register({ config, app }: {
+    config: Config | UnauthorizedConfig;
+    app: Express;
+}): void;

package/out/modules/organization-settings-menu/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = void 0;
+const render_ui_module_1 = __importDefault(require("../../middlewares/render-ui-module"));
+const ui_module_1 = __importDefault(require("../../middlewares/ui-module"));
+const util_1 = require("../../util");
+function register({ config, app }) {
+    if (!config.organizationSettingsMenu) {
+        return;
+    }
+    const allowUnauthorized = !(0, util_1.isAuthorizedConfig)(config);
+    app.get((0, util_1.getLogoUrl)(config.organizationSettingsMenu, '/settings'), (req, res) => { var _a; return res.sendFile(((_a = config.organizationSettingsMenu) === null || _a === void 0 ? void 0 : _a.imagePath) || config.imagePath); });
+    app.use('/settings', (0, ui_module_1.default)({ config, allowUnauthorized, moduleType: config.organizationSettingsMenu.key }), (0, render_ui_module_1.default)(config.organizationSettingsMenu));
+}
+exports.register = register;

package/out/modules/profile-settings-menu/index.d.ts

@@ -0,0 +1,6 @@
+import { Express } from 'express';
+import { Config, UnauthorizedConfig } from '../../types';
+export declare function register({ config, app }: {
+    config: Config | UnauthorizedConfig;
+    app: Express;
+}): void;

package/out/modules/profile-settings-menu/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = void 0;
+const render_ui_module_1 = __importDefault(require("../../middlewares/render-ui-module"));
+const ui_module_1 = __importDefault(require("../../middlewares/ui-module"));
+const util_1 = require("../../util");
+function register({ config, app }) {
+    if (!config.profileSettingsMenu) {
+        return;
+    }
+    app.get((0, util_1.getLogoUrl)(config.profileSettingsMenu, '/settings'), (req, res) => { var _a; return res.sendFile(((_a = config.profileSettingsMenu) === null || _a === void 0 ? void 0 : _a.imagePath) || config.imagePath); });
+    const allowUnauthorized = !(0, util_1.isAuthorizedConfig)(config);
+    app.use('/settings', (0, ui_module_1.default)({ config, allowUnauthorized, moduleType: config.profileSettingsMenu.key }), (0, render_ui_module_1.default)(config.profileSettingsMenu));
+}
+exports.register = register;

package/out/modules/webhooks/handlers/webhook-handler.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="qs" />
-import { CrowdinClientRequest } from '../../../types';
+import { Config, CrowdinClientRequest } from '../../../types';
 import { Response } from 'express';
 import { Webhook } from '../types';
-export declare function webhookHandler(webhooks: Webhook[]): (req: CrowdinClientRequest | import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: Response<any, Record<string, any>>, next: Function) => void;
+export declare function webhookHandler(config: Config, webhooks: Webhook[]): (req: CrowdinClientRequest | import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: Response<any, Record<string, any>>, next: Function) => void;

package/out/modules/webhooks/handlers/webhook-handler.js

@@ -40,12 +40,13 @@ const util_1 = require("../../../util");
 const lodash_isstring_1 = __importDefault(require("lodash.isstring"));
 const crypto = __importStar(require("node:crypto"));
 const storage = __importStar(require("../../../storage"));
-function webhookHandler(webhooks) {
+const connection_1 = require("../../../util/connection");
+function webhookHandler(config, webhooks) {
     return (0, util_1.runAsyncWrapper)((req, res) => __awaiter(this, void 0, void 0, function* () {
         const domain = req.headers['x-crowdin-domain'];
-        const organizationId = req.headers['x-crowdin-organization-id'];
+        const organizationId = req.headers['x-crowdin-id'];
         const signature = req.headers['x-crowdin-signature'];
-        const moduleKey = req.headers['x-application-webhook-key'];
+        const moduleKey = req.headers['x-module-key'];
         if (!(0, lodash_isstring_1.default)(domain) || !(0, lodash_isstring_1.default)(organizationId) || !(0, lodash_isstring_1.default)(signature) || !(0, lodash_isstring_1.default)(moduleKey)) {
             res.status(400).send({ error: 'Invalid request' });
             return;
@@ -56,17 +57,19 @@ function webhookHandler(webhooks) {
             throw new Error('Failed to find Crowdin credentials');
         }
         const hmac = crypto.createHmac('sha256', credentials.appSecret);
-        hmac.update(JSON.stringify(req.body).replace(/\//g, '\\/'));
+        hmac.update(req.body.toString());
         const generatedSignature = hmac.digest('hex');
         if (generatedSignature !== signature.replace('sha256=', '')) {
             res.status(403).send({ error: 'Invalid signature' });
             return;
         }
         res.status(200).send();
+        const { client } = yield (0, connection_1.prepareCrowdinClient)({ config, credentials, autoRenew: true });
+        const json = JSON.parse(req.body.toString());
         for (const webhook of webhooks) {
             if (webhook.key === moduleKey) {
-                for (const event of req.body.payload.events) {
-                    yield webhook.callback({ credentials, event });
+                for (const event of json.events) {
+                    yield webhook.callback({ credentials, event, client });
                 }
             }
         }

package/out/modules/webhooks/index.js

@@ -12,7 +12,7 @@ function register({ config, app }) {
     }
     const webhooks = Array.isArray(config.webhooks) ? config.webhooks : [config.webhooks];
     if (webhooks.length) {
-        app.post('/webhooks', json_response_1.default, (0, webhook_handler_1.webhookHandler)(webhooks));
+        app.post('/webhooks', json_response_1.default, (0, webhook_handler_1.webhookHandler)(config, webhooks));
     }
 }
 exports.register = register;