kourou 0.21.1 → 0.24.0

package/README.md

@@ -26,7 +26,7 @@ $ npm install -g kourou
 $ kourou COMMAND
 running command...
 $ kourou (-v|--version|version)
-kourou/0.21.1 linux-x64 node-v16.13.2
+kourou/0.24.0 darwin-x64 node-v14.18.2
 $ kourou --help [COMMAND]
 USAGE
   $ kourou COMMAND
@@ -129,6 +129,7 @@ All other arguments and options will be passed as-is to the `sdk:query` method.
 * [`kourou api-key:create USER`](#kourou-api-keycreate-user)
 * [`kourou api-key:delete USER ID`](#kourou-api-keydelete-user-id)
 * [`kourou api-key:search USER`](#kourou-api-keysearch-user)
+* [`kourou app:debug-proxy`](#kourou-appdebug-proxy)
 * [`kourou app:scaffold DESTINATION`](#kourou-appscaffold-destination)
 * [`kourou app:start-services`](#kourou-appstart-services)
 * [`kourou autocomplete [SHELL]`](#kourou-autocomplete-shell)
@@ -155,9 +156,10 @@ All other arguments and options will be passed as-is to the `sdk:query` method.
 * [`kourou instance:list`](#kourou-instancelist)
 * [`kourou instance:logs`](#kourou-instancelogs)
 * [`kourou instance:spawn`](#kourou-instancespawn)
-* [`kourou paas:init USERNAME NAMESPACE`](#kourou-paasinit-username-namespace)
+* [`kourou paas:deploy ENVIRONMENT APPLICATIONID IMAGE`](#kourou-paasdeploy-environment-applicationid-image)
+* [`kourou paas:init PROJECT`](#kourou-paasinit-project)
 * [`kourou paas:login`](#kourou-paaslogin)
-* [`kourou paas:publish PROJECT IMAGE`](#kourou-paaspublish-project-image)
+* [`kourou paas:logs ENVIRONMENT APPLICATION`](#kourou-paaslogs-environment-application)
 * [`kourou profile:export`](#kourou-profileexport)
 * [`kourou profile:import PATH`](#kourou-profileimport-path)
 * [`kourou realtime:subscribe INDEX COLLECTION [FILTERS]`](#kourou-realtimesubscribe-index-collection-filters)
@@ -196,6 +198,7 @@ OPTIONS
   --port=port          [default: 7512] Kuzzle server port
   --protocol=protocol  [default: ws] Kuzzle protocol (http or ws)
   --ssl                Use SSL to connect to Kuzzle
+  --ttl=ttl            [default: 90] Kuzzle login TTL (in seconds)
   --username=username  [default: anonymous] Kuzzle username (local strategy)
 
 EXAMPLE
@@ -227,6 +230,7 @@ OPTIONS
   --port=port                    [default: 7512] Kuzzle server port
   --protocol=protocol            [default: ws] Kuzzle protocol (http or ws)
   --ssl                          Use SSL to connect to Kuzzle
+  --ttl=ttl                      [default: 90] Kuzzle login TTL (in seconds)
   --username=username            [default: anonymous] Kuzzle username (local strategy)
 ```
 
@@ -253,6 +257,7 @@ OPTIONS
   --port=port          [default: 7512] Kuzzle server port
   --protocol=protocol  [default: ws] Kuzzle protocol (http or ws)
   --ssl                Use SSL to connect to Kuzzle
+  --ttl=ttl            [default: 90] Kuzzle login TTL (in seconds)
   --username=username  [default: anonymous] Kuzzle username (local strategy)
 
 EXAMPLE
@@ -282,11 +287,50 @@ OPTIONS
   --port=port          [default: 7512] Kuzzle server port
   --protocol=protocol  [default: ws] Kuzzle protocol (http or ws)
   --ssl                Use SSL to connect to Kuzzle
+  --ttl=ttl            [default: 90] Kuzzle login TTL (in seconds)
   --username=username  [default: anonymous] Kuzzle username (local strategy)
 ```
 
 _See code: [src/commands/api-key/search.ts](src/commands/api-key/search.ts)_
 
+## `kourou app:debug-proxy`
+
+Create a Proxy Server that allows Chrome to debug Kuzzle remotely using the DebugController
+
+```
+USAGE
+  $ kourou app:debug-proxy
+
+OPTIONS
+  --api-key=api-key          Kuzzle user api-key
+  --as=as                    Impersonate a user
+  --forwardPort=forwardPort  [default: 9222] Port of the forwarding server
+  --help                     show CLI help
+  --host=host                [default: localhost] Kuzzle server host
+  --keepAuth                 Keep the user authenticated
+
+  --noAutoEnableDebugger     True if Kourou should not enable and disable the Debugger automatically before and after
+                             usage
+
+  --password=password        Kuzzle user password
+
+  --port=port                [default: 7512] Kuzzle server port
+
+  --protocol=protocol        [default: ws] Kuzzle protocol (http or ws)
+
+  --showDebuggerEvents       Verbose mode to display events sent to the Chrome Debugger
+
+  --showDebuggerPayloads     Verbose mode to display payloads sent by and to the Chrome Debugger
+
+  --ssl                      Use SSL to connect to Kuzzle
+
+  --ttl=ttl                  [default: 1h] Kuzzle login TTL
+
+  --username=username        [default: anonymous] Kuzzle username (local strategy)
+```
+
+_See code: [src/commands/app/debug-proxy.ts](src/commands/app/debug-proxy.ts)_
+
 ## `kourou app:scaffold DESTINATION`
 
 Scaffolds a new Kuzzle application
@@ -341,7 +385,7 @@ EXAMPLES
   $ kourou autocomplete --refresh-cache
 ```
 
-_See code: [@oclif/plugin-autocomplete](https://github.com/oclif/plugin-autocomplete/blob/v1.2.0/src/commands/autocomplete/index.ts)_
+_See code: [@oclif/plugin-autocomplete](https://github.com/oclif/plugin-autocomplete/blob/v1.3.0/src/commands/autocomplete/index.ts)_
 
 ## `kourou collection:create INDEX COLLECTION [BODY]`
 
@@ -365,6 +409,7 @@ OPTIONS
   --port=port          [default: 7512] Kuzzle server port
   --protocol=protocol  [default: ws] Kuzzle protocol (http or ws)
   --ssl                Use SSL to connect to Kuzzle
+  --ttl=ttl            [default: 90] Kuzzle login TTL (in seconds)
   --username=username  [default: anonymous] Kuzzle username (local strategy)
 ```
 
@@ -437,6 +482,9 @@ OPTIONS
   --ssl
       Use SSL to connect to Kuzzle
 
+  --ttl=ttl
+      [default: 90] Kuzzle login TTL (in seconds)
+
   --username=username
       [default: anonymous] Kuzzle username (local strategy)
 
@@ -471,6 +519,7 @@ OPTIONS
   --port=port              [default: 7512] Kuzzle server port
   --protocol=protocol      [default: ws] Kuzzle protocol (http or websocket)
   --ssl                    Use SSL to connect to Kuzzle
+  --ttl=ttl                [default: 90] Kuzzle login TTL (in seconds)
   --username=username      [default: anonymous] Kuzzle username (local strategy)
 ```
 
@@ -526,6 +575,7 @@ OPTIONS
   --size=size          Optional page size
   --sort=sort          [default: {}] Sort in JS or JSON format.
   --ssl                Use SSL to connect to Kuzzle
+  --ttl=ttl            [default: 90] Kuzzle login TTL (in seconds)
   --username=username  [default: anonymous] Kuzzle username (local strategy)
 
 EXAMPLES
@@ -602,9 +652,12 @@ USAGE
 OPTIONS
   --batch-size=batch-size  [default: 1000] How many documents to move in batch per operation
   --dest=dest              (required) Destination Elasticsearch server URL
+  --dry-run                Print witch collections will be migrated
   --help                   show CLI help
   --no-interactive         Skip confirmation interactive prompts (perfect for scripting)
+  --pattern=pattern        Pattern to match indices to migrate
   --reset                  Reset destination Elasticsearch server
+  --scroll=scroll          [default: 30s] Scroll duration for Elasticsearch scrolling
   --src=src                (required) Source Elasticsearch server URL
 
 EXAMPLES
@@ -777,6 +830,7 @@ OPTIONS
   --preserve-anonymous     Preserve anonymous rights
   --protocol=protocol      [default: ws] Kuzzle protocol (http or websocket)
   --ssl                    Use SSL to connect to Kuzzle
+  --ttl=ttl                [default: 90] Kuzzle login TTL (in seconds)
   --username=username      [default: anonymous] Kuzzle username (local strategy)
 ```
 
@@ -817,6 +871,8 @@ OPTIONS
 
   --ssl                    Use SSL to connect to Kuzzle
 
+  --ttl=ttl                [default: 90] Kuzzle login TTL (in seconds)
+
   --username=username      [default: anonymous] Kuzzle username (local strategy)
 
 EXAMPLES
@@ -849,6 +905,7 @@ OPTIONS
   --port=port              [default: 7512] Kuzzle server port
   --protocol=protocol      [default: ws] Kuzzle protocol (http or websocket)
   --ssl                    Use SSL to connect to Kuzzle
+  --ttl=ttl                [default: 90] Kuzzle login TTL (in seconds)
   --username=username      [default: anonymous] Kuzzle username (local strategy)
 
 EXAMPLES
@@ -915,17 +972,37 @@ OPTIONS
 
 _See code: [src/commands/instance/spawn.ts](src/commands/instance/spawn.ts)_
 
-## `kourou paas:init USERNAME NAMESPACE`
+## `kourou paas:deploy ENVIRONMENT APPLICATIONID IMAGE`
 
-Initialize a PaaS namespace in current directory
+Deploy a new version of the application in the PaaS
 
 ```
 USAGE
-  $ kourou paas:init USERNAME NAMESPACE
+  $ kourou paas:deploy ENVIRONMENT APPLICATIONID IMAGE
 
 ARGUMENTS
-  USERNAME   Username
-  NAMESPACE  Namespace
+  ENVIRONMENT    Project environment name
+  APPLICATIONID  Application Identifier
+  IMAGE          Image name and hash as myimage:mytag
+
+OPTIONS
+  --help             show CLI help
+  --project=project  Current PaaS project
+  --token=token      Authentication token
+```
+
+_See code: [src/commands/paas/deploy.ts](src/commands/paas/deploy.ts)_
+
+## `kourou paas:init PROJECT`
+
+Initialize a PaaS project in current directory
+
+```
+USAGE
+  $ kourou paas:init PROJECT
+
+ARGUMENTS
+  PROJECT  Kuzzle PaaS project name
 
 OPTIONS
   --help  show CLI help
@@ -935,39 +1012,38 @@ _See code: [src/commands/paas/init.ts](src/commands/paas/init.ts)_
 
 ## `kourou paas:login`
 
-Login for a PaaS namespace
+Login for a PaaS project
 
 ```
 USAGE
   $ kourou paas:login
 
 OPTIONS
-  --help                 show CLI help
-  --namespace=namespace  Current PaaS namespace
-  --username=username    PaaS username
+  --help               show CLI help
+  --project=project    Current PaaS project
+  --username=username  PaaS username
 ```
 
 _See code: [src/commands/paas/login.ts](src/commands/paas/login.ts)_
 
-## `kourou paas:publish PROJECT IMAGE`
+## `kourou paas:logs ENVIRONMENT APPLICATION`
 
-Deploy a new version of the application in the PaaS
+Show logs of the targeted application
 
 ```
 USAGE
-  $ kourou paas:publish PROJECT IMAGE
+  $ kourou paas:logs ENVIRONMENT APPLICATION
 
 ARGUMENTS
-  PROJECT  Project name
-  IMAGE    Image name and hash
+  ENVIRONMENT  Kuzzle PaaS environment
+  APPLICATION  Kuzzle PaaS application
 
 OPTIONS
-  --help                 show CLI help
-  --namespace=namespace  Current PaaS namespace
-  --token=token          Authentication token
+  --help             show CLI help
+  --project=project  Current PaaS project
 ```
 
-_See code: [src/commands/paas/publish.ts](src/commands/paas/publish.ts)_
+_See code: [src/commands/paas/logs.ts](src/commands/paas/logs.ts)_
 
 ## `kourou profile:export`
 
@@ -987,6 +1063,7 @@ OPTIONS
   --port=port          [default: 7512] Kuzzle server port
   --protocol=protocol  [default: ws] Kuzzle protocol (http or websocket)
   --ssl                Use SSL to connect to Kuzzle
+  --ttl=ttl            [default: 90] Kuzzle login TTL (in seconds)
   --username=username  [default: anonymous] Kuzzle username (local strategy)
 ```
 
@@ -1012,6 +1089,7 @@ OPTIONS
   --port=port          [default: 7512] Kuzzle server port
   --protocol=protocol  [default: ws] Kuzzle protocol (http or websocket)
   --ssl                Use SSL to connect to Kuzzle
+  --ttl=ttl            [default: 90] Kuzzle login TTL (in seconds)
   --username=username  [default: anonymous] Kuzzle username (local strategy)
 ```
 
@@ -1053,6 +1131,8 @@ OPTIONS
 
   --ssl                Use SSL to connect to Kuzzle
 
+  --ttl=ttl            [default: 90] Kuzzle login TTL (in seconds)
+
   --username=username  [default: anonymous] Kuzzle username (local strategy)
 
   --users=users        [default: all] Subscribe to users entering or leaving the room (all, in, out, none)
@@ -1092,6 +1172,7 @@ OPTIONS
   --remove             Remove matching keys
   --size=size          [default: 100] Page size
   --ssl                Use SSL to connect to Kuzzle
+  --ttl=ttl            [default: 90] Kuzzle login TTL (in seconds)
   --username=username  [default: anonymous] Kuzzle username (local strategy)
 
 EXAMPLES
@@ -1119,6 +1200,7 @@ OPTIONS
   --port=port          [default: 7512] Kuzzle server port
   --protocol=protocol  [default: ws] Kuzzle protocol (http or websocket)
   --ssl                Use SSL to connect to Kuzzle
+  --ttl=ttl            [default: 90] Kuzzle login TTL (in seconds)
   --username=username  [default: anonymous] Kuzzle username (local strategy)
 ```
 
@@ -1145,6 +1227,7 @@ OPTIONS
   --preserve-anonymous  Preserve anonymous rights
   --protocol=protocol   [default: ws] Kuzzle protocol (http or websocket)
   --ssl                 Use SSL to connect to Kuzzle
+  --ttl=ttl             [default: 90] Kuzzle login TTL (in seconds)
   --username=username   [default: anonymous] Kuzzle username (local strategy)
 ```
 
@@ -1174,6 +1257,7 @@ OPTIONS
   --print-raw          Print only the script result to stdout
   --protocol=protocol  [default: ws] Kuzzle protocol (http or ws)
   --ssl                Use SSL to connect to Kuzzle
+  --ttl=ttl            [default: 90] Kuzzle login TTL (in seconds)
   --username=username  [default: anonymous] Kuzzle username (local strategy)
 
 DESCRIPTION
@@ -1247,6 +1331,8 @@ OPTIONS
 
   --ssl                        Use SSL to connect to Kuzzle
 
+  --ttl=ttl                    [default: 90] Kuzzle login TTL (in seconds)
+
   --username=username          [default: anonymous] Kuzzle username (local strategy)
 
 DESCRIPTION
@@ -1329,6 +1415,7 @@ OPTIONS
   --port=port                              [default: 7512] Kuzzle server port
   --protocol=protocol                      [default: ws] Kuzzle protocol (http or websocket)
   --ssl                                    Use SSL to connect to Kuzzle
+  --ttl=ttl                                [default: 90] Kuzzle login TTL (in seconds)
   --username=username                      [default: anonymous] Kuzzle username (local strategy)
 
 DESCRIPTION
@@ -1377,6 +1464,7 @@ OPTIONS
   --port=port          [default: 7512] Kuzzle server port
   --protocol=protocol  [default: ws] Kuzzle protocol (http or websocket)
   --ssl                Use SSL to connect to Kuzzle
+  --ttl=ttl            [default: 90] Kuzzle login TTL (in seconds)
   --username=username  [default: anonymous] Kuzzle username (local strategy)
 ```
 
@@ -1402,6 +1490,7 @@ OPTIONS
   --port=port          [default: 7512] Kuzzle server port
   --protocol=protocol  [default: ws] Kuzzle protocol (http or websocket)
   --ssl                Use SSL to connect to Kuzzle
+  --ttl=ttl            [default: 90] Kuzzle login TTL (in seconds)
   --username=username  [default: anonymous] Kuzzle username (local strategy)
 ```
 
@@ -1427,6 +1516,7 @@ OPTIONS
   --port=port          [default: 7512] Kuzzle server port
   --protocol=protocol  [default: ws] Kuzzle protocol (http or websocket)
   --ssl                Use SSL to connect to Kuzzle
+  --ttl=ttl            [default: 90] Kuzzle login TTL (in seconds)
   --username=username  [default: anonymous] Kuzzle username (local strategy)
 ```
 

package/lib/commands/app/debug-proxy.d.ts

@@ -0,0 +1,26 @@
+import { flags } from '@oclif/command';
+import { Kommand } from '../../common';
+export default class DebugProxy extends Kommand {
+    static description: string;
+    static flags: {
+        host: flags.IOptionFlag<string>;
+        port: flags.IOptionFlag<string>;
+        ssl: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+        username: flags.IOptionFlag<string>;
+        password: flags.IOptionFlag<string | undefined>;
+        protocol: flags.IOptionFlag<string>;
+        as: flags.IOptionFlag<string | undefined>;
+        'api-key': flags.IOptionFlag<string | undefined>;
+        help: import("@oclif/parser/lib/flags").IBooleanFlag<void>;
+        forwardPort: import("@oclif/parser/lib/flags").IOptionFlag<number>;
+        ttl: flags.IOptionFlag<string>;
+        keepAuth: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+        noAutoEnableDebugger: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+        showDebuggerEvents: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+        showDebuggerPayloads: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+    };
+    static sdkOptions: {
+        protocol: string;
+    };
+    runSafe(): Promise<void>;
+}

package/lib/commands/app/debug-proxy.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const command_1 = require("@oclif/command");
+const common_1 = require("../../common");
+const kuzzle_1 = require("../../support/kuzzle");
+const http_1 = tslib_1.__importDefault(require("http"));
+const ws_1 = tslib_1.__importDefault(require("ws"));
+// Add the proper headers and send the body in the response
+function sendResponse(response, bodyObject) {
+    response.setHeader('Content-Type', 'application/json; charset=UTF-8');
+    response.setHeader('Cache-Control', 'no-cache');
+    const body = JSON.stringify(bodyObject);
+    response.setHeader('Content-Length', Buffer.byteLength(body));
+    response.writeHead(200);
+    response.end(body);
+}
+class DebugProxy extends common_1.Kommand {
+    async runSafe() {
+        const nodeVersionResponse = await this.sdk.query({
+            controller: 'debug',
+            action: 'nodeVersion'
+        });
+        this.logInfo(`Connected to Kuzzle node: ${nodeVersionResponse.node}`);
+        /**
+         * To allow the Chrome Debugger to see the proxy server we must implement the following routes:
+         * - /json/version
+         * - /json
+         */
+        const server = http_1.default.createServer((request, response) => {
+            if (request.url === '/json/version') {
+                sendResponse(response, {
+                    Browser: `node.js/${nodeVersionResponse.result}`,
+                    "Protocol-Version": "1.1"
+                });
+                return;
+            }
+            else if (request.url === '/json') {
+                // Here we send a bunch of information about the Remote Target to the Chrome Debugger
+                // Those are the informations that the Chrome Debugger uses to know how to connect to Remote Target
+                // We give the Chrome Inspector our own Websocket endpoint so that it can connect to our proxy server
+                sendResponse(response, [{
+                        description: 'node.js instance',
+                        devtoolsFrontendUrl: `devtools://devtools/bundled/js_app.html?experiments=true&v8only=true&ws=${request.headers.host}/kuzzle-debugger`,
+                        devtoolsFrontendUrlCompat: `devtools://devtools/bundled/inspector.html?experiments=true&v8only=true&ws=${request.headers.host}/kuzzle-debugger`,
+                        faviconUrl: 'https://nodejs.org/static/images/favicons/favicon.ico',
+                        id: 'kuzzle-debugger',
+                        title: `Kuzzle Debugger - ${this.flags.host}:${this.flags.port}`,
+                        type: 'node',
+                        webSocketDebuggerUrl: `ws://${request.headers.host}/kuzzle-debugger`
+                    }]);
+                return;
+            }
+            response.writeHead(404);
+        });
+        const closeServer = async () => {
+            this.logInfo('Connection closed.');
+            if (!this.flags.noAutoEnableDebugger) {
+                await this.sdk.query({
+                    controller: 'debug',
+                    action: 'disable'
+                });
+            }
+            this.sdk.disconnect();
+            server.close();
+        };
+        const wss = new ws_1.default.Server({
+            server
+        });
+        if (!this.flags.noAutoEnableDebugger) {
+            await this.sdk.query({
+                controller: 'debug',
+                action: 'enable'
+            });
+        }
+        // Listen to all events emitted by the Debug Controller
+        await this.sdk.query({
+            controller: 'debug',
+            action: 'addListener',
+            body: {
+                event: '*'
+            }
+        });
+        wss.on('connection', ws => {
+            this.logInfo('Connection established.');
+            /**
+             * Listen to the room were events from the DebugController are sent
+             * and only forward events from the Chrome  Devtools Protocol
+             */
+            this.sdk.sdk.protocol.on('kuzzle-debugger-event', (payload) => {
+                if (!payload.event || payload.event.startsWith('Kuzzle')) {
+                    return;
+                }
+                if (this.flags.showDebuggerEvents) {
+                    this.logInfo(JSON.stringify(payload.result, null, 2));
+                }
+                ws.send(JSON.stringify(payload.result));
+            });
+            // When receiving message from Chrome Devtools Protocol, we forward it to the DebugController
+            ws.on('message', async (message) => {
+                try {
+                    const json = JSON.parse(message.toString());
+                    if (json.id === undefined || json.method === undefined) {
+                        return;
+                    }
+                    if (this.flags.showDebuggerPayloads) {
+                        this.logInfo(JSON.stringify({
+                            method: json.method,
+                            params: json.params,
+                        }, null, 2));
+                    }
+                    const response = await this.sdk.query({
+                        controller: 'debug',
+                        action: 'post',
+                        body: {
+                            method: json.method,
+                            params: json.params,
+                        }
+                    });
+                    if (this.flags.showDebuggerPayloads) {
+                        this.logInfo(JSON.stringify({
+                            id: json.id,
+                            result: response.result
+                        }, null, 2));
+                    }
+                    // Send back the response using the same ID received
+                    ws.send(JSON.stringify({
+                        id: json.id,
+                        result: response.result
+                    }));
+                }
+                catch (e) {
+                    this.logKo(`${e}`);
+                }
+            });
+            ws.on('close', closeServer);
+        });
+        server.on('error', async (err) => {
+            this.logKo(err.message);
+            this.logKo(err.stack);
+            await closeServer();
+        });
+        server.listen(this.flags.forwardPort, () => {
+            this.logOk(`Listening on port ${this.flags.forwardPort}, forwarding to Kuzzle at ${this.flags.host}:${this.flags.port}`);
+            this.logInfo(`Showing to Chrome Debugger as "Kuzzle Debugger - ${this.flags.host}:${this.flags.port}"`);
+            this.logInfo('Waiting for Chrome Debugger to connect...');
+        });
+        let resolve;
+        const promise = new Promise(res => {
+            resolve = res;
+        });
+        server.on('close', () => {
+            resolve();
+        });
+        await promise;
+    }
+}
+exports.default = DebugProxy;
+DebugProxy.description = 'Create a Proxy Server that allows Chrome to debug Kuzzle remotely using the DebugController';
+DebugProxy.flags = Object.assign({ help: command_1.flags.help(), forwardPort: command_1.flags.integer({
+        description: 'Port of the forwarding server',
+        default: 9222
+    }), ttl: command_1.flags.string({
+        description: 'Kuzzle login TTL',
+        default: '1h',
+    }), keepAuth: command_1.flags.boolean({
+        description: 'Keep the user authenticated',
+        default: false,
+    }), noAutoEnableDebugger: command_1.flags.boolean({
+        description: 'True if Kourou should not enable and disable the Debugger automatically before and after usage',
+        default: false
+    }), showDebuggerEvents: command_1.flags.boolean({
+        description: 'Verbose mode to display events sent to the Chrome Debugger',
+        default: false,
+    }), showDebuggerPayloads: command_1.flags.boolean({
+        description: 'Verbose mode to display payloads sent by and to the Chrome Debugger',
+        default: false,
+    }) }, kuzzle_1.kuzzleFlags);
+// Force the usage of Websocket otherwise each request might end up executed on a different Kuzzle Node
+DebugProxy.sdkOptions = {
+    protocol: 'ws'
+};

package/lib/commands/es/migrate.d.ts

@@ -1,4 +1,5 @@
 import { flags } from '@oclif/command';
+import { Client } from '@elastic/elasticsearch';
 import { Kommand } from '../../common';
 export default class EsMigrate extends Kommand {
     static initSdk: boolean;
@@ -10,11 +11,13 @@ export default class EsMigrate extends Kommand {
         reset: import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
         'batch-size': import("@oclif/parser/lib/flags").IOptionFlag<number>;
         'no-interactive': import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+        'dry-run': import("@oclif/parser/lib/flags").IBooleanFlag<boolean>;
+        pattern: flags.IOptionFlag<string | undefined>;
+        scroll: flags.IOptionFlag<string>;
     };
     static examples: string[];
-    private src;
-    private dest;
     private migrateMappings;
     private migrateData;
+    runMigrate(index: string, src: Client, dest: Client): Promise<void>;
     runSafe(): Promise<void>;
 }

package/lib/commands/es/migrate.js

@@ -8,16 +8,16 @@ const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const node_emoji_1 = tslib_1.__importDefault(require("node-emoji"));
 const common_1 = require("../../common");
 class EsMigrate extends common_1.Kommand {
-    async migrateMappings(index) {
-        const { body } = await this.src.indices.getMapping({ index, format: 'json' });
+    async migrateMappings(index, src, dest) {
+        const { body } = await src.indices.getMapping({ index });
         const mappings = body[index];
-        await this.dest.indices.create({ index, body: mappings });
+        await dest.indices.create({ index, body: { mappings: mappings.mappings } });
     }
-    async migrateData(index, batch_size) {
+    async migrateData(index, batch_size, src, dest) {
         const queue = [];
-        const { body } = await this.src.search({
+        const { body } = await src.search({
             index,
-            scroll: '20s',
+            scroll: this.flags.scroll,
             size: batch_size,
             body: {
                 query: {
@@ -42,42 +42,52 @@ class EsMigrate extends common_1.Kommand {
                 bulk.push(doc._source);
                 count++;
             }
-            await this.dest.bulk({ body: bulk });
+            await dest.bulk({ body: bulk });
             progressBar.update(count);
-            const { body: { hits } } = await this.src.scroll({
-                scrollId,
-                scroll: '20s'
+            const { body: { hits } } = await src.scroll({
+                scroll_id: scrollId,
+                scroll: this.flags.scroll
             });
             queue.push(hits);
         }
         progressBar.stop();
         return total;
     }
+    async runMigrate(index, src, dest) {
+        this.logInfo(`Importing ${chalk_1.default.bold(index)} to ${chalk_1.default.bold(this.flags.dest)}`);
+        await this.migrateMappings(index, src, dest);
+        this.logOk('Mappings successfully imported!');
+        const count = await this.migrateData(index, this.flags['batch-size'], src, dest);
+        if (count === 0) {
+            this.logInfo('No documents to import\n');
+        }
+        else {
+            this.logOk(`${chalk_1.default.bold(count)} document(s) imported!\n`);
+        }
+    }
     async runSafe() {
-        this.src = new elasticsearch_1.Client({ node: this.flags.src });
-        this.dest = new elasticsearch_1.Client({ node: this.flags.dest });
+        const src = new elasticsearch_1.Client({ node: this.flags.src });
+        const dest = new elasticsearch_1.Client({ node: this.flags.dest });
         if (this.flags.reset && !this.flags['no-interactive']) {
             this.log(chalk_1.default.red(`${node_emoji_1.default.get('fire')} Are you sure you want to reset ${chalk_1.default.bold(this.flags.dest)}?`));
             await cli_ux_1.default.confirm(chalk_1.default.redBright(` ${node_emoji_1.default.get('fire')} You will lose all the data stored in it (Type "yes" to confirm)`));
-            await this.dest.indices.delete({ index: '_all' });
+            await dest.indices.delete({ index: '_all' });
         }
         this.logInfo(`Fetching indices list from ${chalk_1.default.bold(this.flags.src)}`);
-        const { body } = await this.src.cat.indices({ format: 'json' });
-        const indices = body
+        const srcBody = await src.cat.indices({ format: 'json' });
+        const srcIndices = srcBody.body
             .map(({ index }) => index)
+            .filter((index) => index.match(this.flags.pattern))
             .sort();
-        this.logOk(`Found ${chalk_1.default.bold(indices.length)} indices in the source Elasticsearch server\n`);
-        this.logInfo(`Starting indices migration from ${chalk_1.default.bold(this.flags.src)} to ${chalk_1.default.bold(this.flags.dest)}`);
-        for (const index of indices) {
-            this.logInfo(`Importing ${chalk_1.default.bold(index)} to ${chalk_1.default.bold(this.flags.dest)}`);
-            await this.migrateMappings(index);
-            this.logOk('Mappings successfully imported!');
-            const count = await this.migrateData(index, this.flags['batch-size']);
-            if (count === 0) {
-                this.logInfo('No documents to import\n');
-            }
-            else {
-                this.logOk(`${chalk_1.default.bold(count)} document(s) imported!\n`);
+        this.logOk(`Found ${chalk_1.default.bold(srcIndices.length)} indices in the source Elasticsearch server\n`);
+        if (this.flags['dry-run']) {
+            this.log(`${chalk_1.default.bold(srcIndices)}`);
+            this.logInfo(`${chalk_1.default.bold(srcIndices.length)} indices will be migrated`);
+        }
+        else {
+            this.logInfo(`Starting indices migration from ${chalk_1.default.bold(this.flags.src)} to ${chalk_1.default.bold(this.flags.dest)}`);
+            for (const index of srcIndices) {
+                await this.runMigrate(index, src, dest);
             }
         }
     }
@@ -109,6 +119,17 @@ EsMigrate.flags = {
         description: 'Skip confirmation interactive prompts (perfect for scripting)',
         default: false,
     }),
+    'dry-run': command_1.flags.boolean({
+        description: 'Print witch collections will be migrated',
+        default: false,
+    }),
+    'pattern': command_1.flags.string({
+        description: 'Pattern to match indices to migrate'
+    }),
+    'scroll': command_1.flags.string({
+        description: 'Scroll duration for Elasticsearch scrolling',
+        default: '30s'
+    }),
 };
 EsMigrate.examples = [
     'kourou es:migrate --src http://elasticsearch:9200 --dest http://otherElasticsearch:9200 --reset --batch-size 2000',

package/lib/commands/paas/{publish.d.ts → deploy.d.ts}

@@ -1,11 +1,11 @@
 import { flags } from '@oclif/command';
 import { PaasKommand } from '../../support/PaasKommand';
-declare class PaasPublish extends PaasKommand {
+declare class PaasDeploy extends PaasKommand {
     static description: string;
     static flags: {
         help: import("@oclif/parser/lib/flags").IBooleanFlag<void>;
         token: flags.IOptionFlag<string | undefined>;
-        namespace: flags.IOptionFlag<string | undefined>;
+        project: flags.IOptionFlag<string | undefined>;
     };
     static args: {
         name: string;
@@ -15,4 +15,4 @@ declare class PaasPublish extends PaasKommand {
     runSafe(): Promise<void>;
     getCredentials(): Promise<any>;
 }
-export default PaasPublish;
+export default PaasDeploy;

package/lib/commands/paas/{publish.js → deploy.js}

@@ -6,57 +6,62 @@ const command_1 = require("@oclif/command");
 const cli_ux_1 = tslib_1.__importDefault(require("cli-ux"));
 const login_1 = tslib_1.__importDefault(require("./login"));
 const PaasKommand_1 = require("../../support/PaasKommand");
-class PaasPublish extends PaasKommand_1.PaasKommand {
+class PaasDeploy extends PaasKommand_1.PaasKommand {
     async runSafe() {
         const apiKey = await this.getCredentials();
         await this.initPaasClient({ apiKey });
         const user = await this.paas.auth.getCurrentUser();
-        this.logInfo(`Logged as "${user._id}" for project "${this.args.project}"`);
+        this.logInfo(`Logged as "${user._id}" for project "${this.flags.project || this.getProject()}"`);
         const [image, tag] = this.args.image.split(':');
         this.logInfo(`Deploy application with image "${image}:${tag}"`);
         await this.paas.query({
-            controller: 'config',
-            action: 'updateImage',
+            controller: 'application',
+            action: 'deploy',
+            environmentId: this.args.environment,
+            projectId: this.flags.project || this.getProject(),
+            applicationId: this.args.applicationId,
             body: {
-                namespace: this.args.project,
-                image,
-                tag,
+                image: {
+                    name: image,
+                    tag,
+                },
             }
         });
         this.logOk('Deployment in progress');
     }
     async getCredentials() {
-        const namespace = this.getNamespace();
-        const namespaceFile = this.fileNamespaceCredentials(namespace);
-        if (!fs_1.default.existsSync(namespaceFile)) {
+        const project = this.getProject();
+        const projectFile = this.fileProjectCredentials(project);
+        if (!fs_1.default.existsSync(projectFile)) {
             this.log('');
-            const nextStep = await cli_ux_1.default.prompt('Cannot find credentials for this namespace. Do you want to login first? [Y/N]', { type: 'single' });
+            const nextStep = await cli_ux_1.default.prompt('Cannot find credentials for this project. Do you want to login first? [Y/N]', { type: 'single' });
             this.log('');
             if (nextStep.toLowerCase().startsWith('y')) {
-                await login_1.default.run(['--namespace', namespace]);
+                await login_1.default.run(['--project', project]);
             }
             else {
                 this.logKo('Aborting.');
                 process.exit(1);
             }
         }
-        const credentials = JSON.parse(fs_1.default.readFileSync(namespaceFile, 'utf8'));
+        const credentials = JSON.parse(fs_1.default.readFileSync(projectFile, 'utf8'));
         return credentials.apiKey;
     }
 }
-PaasPublish.description = 'Deploy a new version of the application in the PaaS';
-PaasPublish.flags = {
+PaasDeploy.description = 'Deploy a new version of the application in the PaaS';
+PaasDeploy.flags = {
     help: command_1.flags.help(),
     token: command_1.flags.string({
         default: process.env.KUZZLE_PAAS_TOKEN,
         description: 'Authentication token'
     }),
-    namespace: command_1.flags.string({
-        description: 'Current PaaS namespace'
+    project: command_1.flags.string({
+        description: 'Current PaaS project',
     }),
 };
-PaasPublish.args = [
-    { name: 'project', description: 'Project name', required: true },
-    { name: 'image', description: 'Image name and hash', required: true },
+PaasDeploy.args = [
+    { name: 'environment', description: 'Project environment name', required: true },
+    { name: 'applicationId', description: 'Application Identifier', required: true },
+    { name: 'image', description: 'Image name and hash as myimage:mytag', required: true },
 ];
-exports.default = PaasPublish;
+exports.default = PaasDeploy;

package/lib/commands/paas/init.js

@@ -3,9 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 const path_1 = tslib_1.__importDefault(require("path"));
 const fs_1 = tslib_1.__importDefault(require("fs"));
-const cli_ux_1 = require("cli-ux");
 const command_1 = require("@oclif/command");
-const login_1 = tslib_1.__importDefault(require("./login"));
 const PaasKommand_1 = require("../../support/PaasKommand");
 class PaasInit extends PaasKommand_1.PaasKommand {
     async runSafe() {
@@ -17,25 +15,17 @@ class PaasInit extends PaasKommand_1.PaasKommand {
         this.logInfo('Add the "kuzzle" property inside project package.json.');
         packageJson.kuzzle = {
             paas: {
-                application: 'kuzzle',
-                namespace: this.args.namespace,
+                project: this.args.project,
             },
         };
         fs_1.default.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
-        this.log('');
-        const nextStep = await cli_ux_1.cli.prompt('Do you want to login to the namespace? [Y/N]', { type: 'single' });
-        this.log('');
-        if (nextStep.toLowerCase().startsWith('y')) {
-            await login_1.default.run(['--username', this.args.username, '--namespace', this.args.namespace]);
-        }
     }
 }
-PaasInit.description = 'Initialize a PaaS namespace in current directory';
+PaasInit.description = 'Initialize a PaaS project in current directory';
 PaasInit.flags = {
     help: command_1.flags.help(),
 };
 PaasInit.args = [
-    { name: 'username', description: 'Username', required: true },
-    { name: 'namespace', description: 'Namespace', required: true },
+    { name: 'project', description: 'Kuzzle PaaS project name', required: true },
 ];
 exports.default = PaasInit;

package/lib/commands/paas/login.d.ts

@@ -5,10 +5,11 @@ declare class PaasLogin extends PaasKommand {
     static description: string;
     static flags: {
         help: import("@oclif/parser/lib/flags").IBooleanFlag<void>;
-        namespace: flags.IOptionFlag<string | undefined>;
+        project: flags.IOptionFlag<string | undefined>;
         username: flags.IOptionFlag<string | undefined>;
     };
     runSafe(): Promise<void>;
-    createNamespaceCredentials(apiKey: ApiKey): void;
+    createProjectCredentials(apiKey: ApiKey): void;
+    authenticateNPM(username: string, password: string): Promise<void>;
 }
 export default PaasLogin;

package/lib/commands/paas/login.js

@@ -2,9 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 const fs_1 = tslib_1.__importDefault(require("fs"));
+const node_fetch_1 = tslib_1.__importDefault(require("node-fetch"));
 const command_1 = require("@oclif/command");
 const cli_ux_1 = tslib_1.__importDefault(require("cli-ux"));
 const PaasKommand_1 = require("../../support/PaasKommand");
+const child_process_1 = require("child_process");
 class PaasLogin extends PaasKommand_1.PaasKommand {
     async runSafe() {
         this.createKourouDir();
@@ -16,24 +18,44 @@ class PaasLogin extends PaasKommand_1.PaasKommand {
             : await cli_ux_1.default.prompt(`    Password`, { type: 'hide' });
         await this.initPaasClient({ username, password });
         const apiKey = await this.paas.auth.createApiKey('Kourou PaaS API Key');
-        this.createNamespaceCredentials(apiKey);
+        this.createProjectCredentials(apiKey);
+        await this.authenticateNPM(username, password);
+        this.logOk(`Successfully logged in as ${username}. Your Kuzzle Enterprise license is now enabled on this host.`);
     }
-    createNamespaceCredentials(apiKey) {
-        const namespace = this.getNamespace();
-        const namespaceFile = this.fileNamespaceCredentials(namespace);
+    createProjectCredentials(apiKey) {
+        const project = this.getProject();
+        const projectFile = this.fileProjectCredentials(project);
         const credentials = {
             apiKey: apiKey._source.token,
         };
-        this.logInfo(`Saving credentials for namespace "${namespace}" in "${namespaceFile}".`);
-        fs_1.default.writeFileSync(namespaceFile, JSON.stringify(credentials, null, 2));
-        fs_1.default.chmodSync(namespaceFile, 0o600);
+        this.logInfo(`Saving credentials for project "${project}" in "${projectFile}".`);
+        fs_1.default.writeFileSync(projectFile, JSON.stringify(credentials, null, 2));
+        fs_1.default.chmodSync(projectFile, 0o600);
+    }
+    async authenticateNPM(username, password) {
+        const options = {
+            method: 'PUT',
+            headers: {
+                'Content-Type': 'application/json',
+                'Accept': 'application/json',
+                'Authorization': `Basic ${Buffer.from(`${username}:${password}`).toString('base64')}`
+            },
+            body: JSON.stringify({
+                name: username,
+                password,
+            })
+        };
+        const response = await (0, node_fetch_1.default)(`https://packages.paas.kuzzle.io/-/user/org.couchdb.user:${username}`, options);
+        const { token } = await response.json();
+        (0, child_process_1.spawnSync)('npm', ['config', 'set', '@kuzzleio:registry', 'https://packages.paas.kuzzle.io'], { stdio: 'inherit' });
+        (0, child_process_1.spawnSync)('npm', ['set', '//packages.paas.kuzzle.io/:_authToken', token], { stdio: 'inherit' });
     }
 }
-PaasLogin.description = 'Login for a PaaS namespace';
+PaasLogin.description = 'Login for a PaaS project';
 PaasLogin.flags = {
     help: command_1.flags.help(),
-    namespace: command_1.flags.string({
-        description: 'Current PaaS namespace'
+    project: command_1.flags.string({
+        description: 'Current PaaS project'
     }),
     username: command_1.flags.string({
         description: 'PaaS username',

package/lib/commands/paas/logs.d.ts

@@ -0,0 +1,17 @@
+import { flags } from "@oclif/command";
+import { PaasKommand } from "../../support/PaasKommand";
+declare class PaasLogs extends PaasKommand {
+    static description: string;
+    static flags: {
+        help: import("@oclif/parser/lib/flags").IBooleanFlag<void>;
+        project: flags.IOptionFlag<string | undefined>;
+    };
+    static args: {
+        name: string;
+        description: string;
+        required: boolean;
+    }[];
+    runSafe(): Promise<void>;
+    getCredentials(): Promise<any>;
+}
+export default PaasLogs;

package/lib/commands/paas/logs.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const command_1 = require("@oclif/command");
+const PaasKommand_1 = require("../../support/PaasKommand");
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const login_1 = tslib_1.__importDefault(require("./login"));
+const cli_ux_1 = require("cli-ux");
+class PaasLogs extends PaasKommand_1.PaasKommand {
+    async runSafe() {
+        const apiKey = await this.getCredentials();
+        await this.initPaasClient({ apiKey });
+        const user = await this.paas.auth.getCurrentUser();
+        this.logInfo(`Logged as "${user._id}" for project "${this.flags.project || this.getProject()}"`);
+        const logs = await this.paas.query({
+            controller: 'application',
+            action: 'logs',
+            environmentId: this.args.environment,
+            projectId: this.flags.project || this.getProject(),
+            applicationId: this.args.application,
+        });
+        this.logOk(logs.result.join('\n '));
+    }
+    async getCredentials() {
+        const project = this.getProject();
+        const projectFile = this.fileProjectCredentials(project);
+        if (!fs_1.default.existsSync(projectFile)) {
+            this.log('');
+            const nextStep = await cli_ux_1.cli.prompt('Cannot find credentials for this project. Do you want to login first? [Y/N]', { type: 'single' });
+            this.log('');
+            if (nextStep.toLowerCase().startsWith('y')) {
+                await login_1.default.run(['--project', project]);
+            }
+            else {
+                this.logKo('Aborting.');
+                process.exit(1);
+            }
+        }
+        const credentials = JSON.parse(fs_1.default.readFileSync(projectFile, 'utf8'));
+        return credentials.apiKey;
+    }
+}
+PaasLogs.description = 'Show logs of the targeted application';
+PaasLogs.flags = {
+    help: command_1.flags.help(),
+    project: command_1.flags.string({
+        description: 'Current PaaS project'
+    }),
+};
+PaasLogs.args = [
+    { name: 'environment', description: 'Kuzzle PaaS environment', required: true },
+    { name: 'application', description: 'Kuzzle PaaS application', required: true },
+];
+exports.default = PaasLogs;

package/lib/common.js

@@ -104,10 +104,16 @@ class Kommand extends command_1.Command {
                 ? ` (https://docs.kuzzle.io/core/2/api/errors/error-codes/${error.id.split('.')[0]})`
                 : '';
             this.logKo(`Error stack: \n${stack || error.message}\n\nError status: ${error.status}\n\nError id: ${error.id}${errorLink}`);
-            for (const e of error.errors) {
-                this.logKo(`${e.document._id} : ${e.reason}`);
+            if (Array.isArray(error.errors)) {
+                for (const e of error.errors) {
+                    this.logKo(`${e.document._id} : ${e.reason}`);
+                }
+            }
+            else {
+                this.logKo(JSON.stringify(error.reason));
             }
             err = true;
+            this.exitCode = 1;
         }
         finally {
             if (kommand.id !== undefined) {
@@ -122,6 +128,7 @@ class Kommand extends command_1.Command {
                 ]);
             }
             this.sdk.disconnect();
+            process.exit(this.exitCode);
         }
         return this.exitCode;
     }

package/lib/support/PaasKommand.d.ts

@@ -10,13 +10,13 @@ export declare class PaasKommand extends Kommand {
     static initSdk: boolean;
     protected host: string;
     protected port: number;
-    protected ssl: boolean;
+    protected ssl: any;
     protected paas: KuzzleSDK;
     initPaasClient(credentials: PaaSClientCredentials): Promise<void>;
-    fileNamespaceCredentials(namespace: string): string;
+    fileProjectCredentials(project: string): string;
     /**
-     * Retrieve the current namespace name from the command line or current package.json
+     * Retrieve the current project name from the command line or current package.json
      */
-    getNamespace(): any;
+    getProject(): any;
 }
 export {};

package/lib/support/PaasKommand.js

@@ -9,9 +9,15 @@ const kuzzle_1 = require("./kuzzle");
 class PaasKommand extends common_1.Kommand {
     constructor() {
         super(...arguments);
-        this.host = 'api.console.paas.kuzzle.io';
-        this.port = 443;
-        this.ssl = true;
+        this.host = process.env.KUZZLE_PAAS_HOST
+            ? process.env.KUZZLE_PAAS_HOST
+            : 'console.paas.kuzzle.io';
+        this.port = process.env.KUZZLE_PAAS_PORT
+            ? parseInt(process.env.KUZZLE_PAAS_PORT)
+            : 443;
+        this.ssl = process.env.KUZZLE_PAAS_SSL
+            ? JSON.parse(process.env.KUZZLE_PAAS_SSL)
+            : true;
         // Instantiate a dummy SDK to avoid the this.paas? notation everywhere -_-
         this.paas = new kuzzle_1.KuzzleSDK({});
     }
@@ -28,24 +34,24 @@ class PaasKommand extends common_1.Kommand {
             throw error;
         }
     }
-    fileNamespaceCredentials(namespace) {
-        return path_1.default.join(this.kourouDir, `${namespace}.paas.json`);
+    fileProjectCredentials(project) {
+        return path_1.default.join(this.kourouDir, `${project}.paas.json`);
     }
     /**
-     * Retrieve the current namespace name from the command line or current package.json
+     * Retrieve the current project name from the command line or current package.json
      */
-    getNamespace() {
+    getProject() {
         const packageJsonPath = path_1.default.join(process.cwd(), 'package.json');
         if (fs_1.default.existsSync(packageJsonPath)) {
             const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf8'));
             if (packageJson.kuzzle && packageJson.kuzzle.paas) {
-                return packageJson.kuzzle.paas.namespace;
+                return packageJson.kuzzle.paas.project;
             }
         }
-        if (!this.flags.namespace) {
-            throw new Error('Cannot find PaaS namespace in package.json or command line');
+        if (!this.flags.project) {
+            throw new Error('Cannot find PaaS project in package.json or command line');
         }
-        return this.flags.namespace;
+        return this.flags.project;
     }
 }
 exports.PaasKommand = PaasKommand;

package/lib/support/kuzzle.d.ts

@@ -44,7 +44,7 @@ export declare class KuzzleSDK {
     get index(): import("kuzzle-sdk").IndexController;
     get security(): import("kuzzle-sdk/src/controllers/Security").SecurityController;
     get auth(): import("kuzzle-sdk").AuthController;
-    get server(): any;
+    get server(): import("kuzzle-sdk").ServerController;
     get realtime(): import("kuzzle-sdk").RealtimeController;
     get ms(): any;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "kourou",
   "description": "The CLI that helps you manage your Kuzzle instances",
-  "version": "0.21.1",
+  "version": "0.24.0",
   "author": "The Kuzzle Team <support@kuzzle.io>",
   "bin": {
     "kourou": "./bin/run"
@@ -39,10 +39,12 @@
     "lodash": "^4.17.21",
     "ndjson": "^2.0.0",
     "node-emoji": "^1.10.0",
+    "node-fetch": "^2.6.7",
     "production": "0.0.2",
     "strip-json-comments": "^3.1.1",
     "tmp": "^0.2.1",
-    "tslib": "^2.3.1"
+    "tslib": "^2.3.1",
+    "ws": "^8.8.0"
   },
   "devDependencies": {
     "@istanbuljs/nyc-config-typescript": "^1.0.1",
@@ -54,6 +56,8 @@
     "@types/mocha": "^8.2.2",
     "@types/node": "^14.14.41",
     "@types/node-emoji": "^1.8.1",
+    "@types/node-fetch": "^2.6.1",
+    "@types/ws": "^8.5.3",
     "@typescript-eslint/eslint-plugin": "^4.22.0",
     "@typescript-eslint/parser": "^4.22.0",
     "chai": "^4.3.4",