@constellation-network/node-pilot 0.0.1

package/dist/services/fastforward-service.js

@@ -0,0 +1,84 @@
+import { serializeBrotli } from "@stardust-collective/dag4-keystore";
+import chalk from "chalk";
+import fs from "node:fs";
+import 'json-bigint-patch';
+import path from "node:path";
+import { clm } from "../clm.js";
+import { configStore } from "../config-store.js";
+const CHUNK_SIZE = 20_000;
+export class FastforwardService {
+    dataDir;
+    lbUrl;
+    network;
+    tmpDir;
+    constructor() {
+        const { projectDir } = configStore.getProjectInfo();
+        const { type } = configStore.getNetworkInfo();
+        this.network = type;
+        this.tmpDir = path.join(projectDir, 'app-data', 'tmp');
+        this.dataDir = path.join(projectDir, 'app-data', 'gl0-data'); // gl0
+        fs.mkdirSync(this.tmpDir, { recursive: true });
+        fs.mkdirSync(this.dataDir, { recursive: true });
+        const env = configStore.getEnvCommonInfo();
+        // this.lbUrl = `https://l0-lb-${this.network}.constellationnetwork.io`;
+        this.lbUrl = `http://${env.CL_GLOBAL_L0_PEER_HOST}:${env.CL_GLOBAL_L0_PEER_HTTP_PORT}`;
+    }
+    static async synctoLatestSnapshot() {
+        const ffs = new FastforwardService();
+        await ffs.runFastForwardSnapshot();
+    }
+    async runFastForwardSnapshot() {
+        const [ordinal, snapshotIncremental, snapshotInfo] = await this.fetchLatestSnapshot();
+        const compressedSnapshotIncremental = await serializeBrotli(snapshotIncremental);
+        const compressedSnapshotInfo = await serializeBrotli(snapshotInfo);
+        const hash = await this.fetchSnapshotHash(ordinal);
+        // clm.debug('hash', Buffer.from(jsSha256.sha256(compressedSnapshotIncremental)).toString('hex'));
+        const snapshotInfoDir = path.join(this.dataDir, 'snapshot_info');
+        fs.mkdirSync(snapshotInfoDir, { recursive: true });
+        fs.writeFileSync(path.join(snapshotInfoDir, ordinal.toString()), compressedSnapshotInfo);
+        fs.writeFileSync(path.join(this.tmpDir, ordinal.toString() + '.c'), compressedSnapshotIncremental);
+        await this.saveSnapshotFiles(ordinal.toString(), hash);
+        clm.postStep('Fastforward completed.');
+    }
+    async fetchLatestSnapshot() {
+        const url = `${this.lbUrl}/global-snapshots/latest/combined`;
+        clm.debug('Fetching latest snapshot ordinal from: ' + chalk.cyan(url));
+        return fetch(url).then(res => res.json()
+            .then(data => {
+            const { ordinal } = data[0].value;
+            clm.debug('fetchLatestSnapshot - ' + chalk.cyan(ordinal));
+            return [ordinal, data[0], data[1]];
+        }));
+    }
+    async fetchSnapshot(ordinal) {
+        const url = `${this.lbUrl}/global-snapshots/${ordinal}`;
+        clm.debug('Fetching latest snapshot ordinal from: ' + url);
+        return fetch(url).then(res => res.json());
+    }
+    async fetchSnapshotHash(ordinal) {
+        const url = `${this.lbUrl}/global-snapshots/${ordinal}/hash`;
+        const hash = await fetch(url).then(res => res.text().then(t => t.replace(/^"(.*)"$/, '$1')));
+        clm.debug('fetchLatestSnapshotHash: ' + chalk.cyan(hash));
+        return hash;
+    }
+    async saveSnapshotFiles(ordinal, hash) {
+        const fileName = ordinal + '.c';
+        const ordinalFile = path.join(this.tmpDir, fileName);
+        if (!fs.existsSync(ordinalFile)) {
+            clm.error(`File ${ordinalFile} does not exist.`);
+        }
+        const ordinalRounded = Math.floor(Number(ordinal) / CHUNK_SIZE) * CHUNK_SIZE;
+        const hashSubdir = path.join(hash.slice(0, 3), hash.slice(3, 6));
+        // const snapshotInfoDir = path.join(OUTPUT_DIR, 'snapshot-info');
+        const incrementalSnapshotDir = path.join(this.dataDir, 'incremental_snapshot');
+        const hashDir = path.join(incrementalSnapshotDir, 'hash', hashSubdir);
+        const ordinalDir = path.join(incrementalSnapshotDir, 'ordinal', ordinalRounded.toString());
+        fs.mkdirSync(hashDir, { recursive: true });
+        fs.mkdirSync(ordinalDir, { recursive: true });
+        const destOrdinalFile = path.join(ordinalDir, ordinal);
+        fs.copyFileSync(ordinalFile, destOrdinalFile);
+        const hashFile = path.join(hashDir, hash);
+        fs.linkSync(destOrdinalFile, hashFile);
+        fs.writeFileSync(path.join(this.dataDir, 'snapshot-version'), `${this.network}:${ordinal}`);
+    }
+}

package/dist/services/node-service.d.ts

@@ -0,0 +1,10 @@
+import { NodeInfo, TessellationLayer } from "../types.js";
+export declare const nodeService: {
+    getNodeInfo(layer: "first" | TessellationLayer): Promise<NodeInfo>;
+    getSnapshotHash(ipAddr: string, ordinal: number): Promise<string>;
+    joinCluster(layer: TessellationLayer): Promise<void>;
+    leaveCluster(layer: TessellationLayer): Promise<boolean>;
+    leaveClusterAllLayers(): Promise<boolean>;
+    pollForLayersState(layers: TessellationLayer[], state?: string): Promise<boolean>;
+    pollForState(layer: TessellationLayer, expectedState?: string): Promise<boolean>;
+};

package/dist/services/node-service.js

@@ -0,0 +1,117 @@
+import { clm } from "../clm.js";
+import { configStore } from "../config-store.js";
+import { clusterService } from "./cluster-service.js";
+import { shellService } from "./shell-service.js";
+export const nodeService = {
+    async getNodeInfo(layer) {
+        if (layer === 'first') {
+            layer = configStore.getProjectInfo().layersToRun[0];
+        }
+        const portInfo = configStore.getLayerPortInfo(layer);
+        return fetch(`http://localhost:${portInfo.PUBLIC}/node/info`)
+            .then(res => {
+            if (res.ok)
+                return res.json().then(i => ({ ...i, layer }));
+            throw new Error(`Failed`);
+        })
+            .catch(() => ({ layer, state: "Unavailable" }));
+    },
+    async getSnapshotHash(ipAddr, ordinal) {
+        return fetch(`${ipAddr}/global-snapshots/${ordinal}/hash`)
+            .then(res => {
+            if (res.ok)
+                return res.json();
+            clm.warn(`Failed to get snapshot hash. Status code ${res.status}`);
+            return '';
+        })
+            .catch(() => (''));
+    },
+    async joinCluster(layer) {
+        const { state } = await this.getNodeInfo(layer);
+        if (state !== "ReadyToJoin") {
+            clm.warn(`Node is not ready to join the cluster. Current state: "${state}".`);
+            return;
+        }
+        const layerPortInfo = configStore.getLayerPortInfo(layer);
+        const peerInfo = await clusterService.getSourceNodeInfo();
+        const nodeId = peerInfo.id;
+        const nodeIp = peerInfo.host;
+        const cliPort = layerPortInfo.CLI;
+        const nodeP2pPort = peerInfo.p2pPort;
+        if (layer === 'gl0') {
+            await clusterService.fastForwardSnapshot();
+        }
+        // escape only the quotes in the body
+        const body = JSON.stringify({ id: nodeId, ip: nodeIp, p2pPort: nodeP2pPort }).replaceAll('"', String.raw `\"`);
+        const url = `http://localhost:${cliPort}/cluster/join`;
+        clm.preStep(`Joining ${layer} to cluster`); // on ${cliPort}...${body} ... ${url}`);
+        await shellService.execDockerShell(layer, `curl -X POST '${url}' -H 'Content-Type: application/json' --data '${body}'`);
+        await this.pollForState(layer, 'Ready');
+    },
+    async leaveCluster(layer) {
+        const { state } = await this.getNodeInfo(layer);
+        if (state === "Offline") {
+            clm.echo(`Node has already left the cluster. Current state: "${state}".`);
+            return true;
+        }
+        if (state === "ReadyToJoin") {
+            clm.echo(`Node has not joined the cluster yet. Current state: "${state}".`);
+            return true;
+        }
+        if (state === "Unavailable") {
+            clm.echo(`Node is not running.`);
+            return true;
+        }
+        const { CLI: cliPort } = configStore.getLayerPortInfo(layer);
+        clm.preStep(`${layer} is leaving the cluster. Current state: "${state}"`);
+        return shellService.execDockerShell(layer, `curl -X POST 'http://localhost:${cliPort}/cluster/leave'`)
+            .then(() => true)
+            .catch(() => false);
+    },
+    async leaveClusterAllLayers() {
+        const layers = configStore.getProjectInfo().layersToRun;
+        const promises = layers.map(l => this.leaveCluster(l));
+        const results = await Promise.all(promises);
+        return results.every(Boolean);
+    },
+    async pollForLayersState(layers, state = 'ReadyToJoin') {
+        for (const layer of layers) {
+            // eslint-disable-next-line no-await-in-loop
+            const readyToJoin = await this.pollForState(layer, state);
+            if (!readyToJoin) {
+                return false;
+            }
+        }
+        return true;
+    },
+    async pollForState(layer, expectedState = 'ReadyToJoin') {
+        clm.preStep(`Waiting for ${layer.toUpperCase()} Validator Node to become ${expectedState}...`);
+        await sleep(1);
+        for (let i = 1; i <= 60; i++) {
+            // eslint-disable-next-line no-await-in-loop
+            const { state } = await this.getNodeInfo(layer);
+            if (state === "Unavailable" || state === "ReadyToJoin") {
+                if (expectedState === 'Offline')
+                    return true;
+                clm.echo(`     Validator Node is not running.`);
+            }
+            if (layer === 'gl0' && expectedState === 'Ready' && state === "WaitingForDownload") {
+                clm.echo(`    [${layer}] Attempt ${i}: Current state is "${state}"`);
+            }
+            else {
+                clm.echo(`    [${layer}] Attempt ${i}: Current state is "${state}"`);
+            }
+            if (state === expectedState) {
+                clm.postStep(`    ${layer} is ${expectedState}`);
+                return true;
+            }
+            // eslint-disable-next-line no-await-in-loop
+            await sleep(5);
+        }
+        clm.warn(`    ${layer} is not ${expectedState} after 5 minutes`);
+        return false;
+    }
+};
+function sleep(sec) {
+    return new Promise(resolve => { setTimeout(resolve, sec * 1000); });
+}

package/dist/services/shell-service.d.ts

@@ -0,0 +1,9 @@
+import shell from "shelljs";
+export declare const shellService: {
+    checkCommandAvailable(cmd: string): Promise<boolean>;
+    execDockerShell(serviceName: string, command: string): Promise<string>;
+    existsScript(filePath: string): boolean;
+    resolvePath(keyPath: string): string;
+    runCommand(command: string, env?: object, silent?: boolean): Promise<shell.ShellString>;
+    runCommandWithOutput(command: string, env?: object): Promise<string>;
+};

package/dist/services/shell-service.js

@@ -0,0 +1,53 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import shell from "shelljs";
+import { clm } from "../clm.js";
+import { configStore } from "../config-store.js";
+export const shellService = {
+    async checkCommandAvailable(cmd) {
+        return this.runCommand(`command -v ${cmd}`, undefined, true)
+            .then(() => true)
+            .catch(() => false);
+    },
+    async execDockerShell(serviceName, command) {
+        const { projectDir } = configStore.getProjectInfo();
+        clm.debug(`Running command: docker compose exec ${serviceName} bash -c "${command}"`);
+        const result = shell.exec(`docker compose exec ${serviceName} bash -c "${command}"`, { cwd: projectDir, silent: true });
+        if (result.stderr && result.code > 0) {
+            clm.error(`Command Failed - ${command} with stderr: ${result.stderr}`);
+        }
+        return result.stdout;
+    },
+    existsScript(filePath) {
+        const { projectDir } = configStore.getProjectInfo();
+        return fs.existsSync(path.join(projectDir, filePath));
+    },
+    resolvePath(keyPath) {
+        if (keyPath.startsWith('~/')) {
+            return path.join(os.homedir(), keyPath.slice(2));
+        }
+        if (keyPath.startsWith('/')) {
+            return keyPath;
+        }
+        return path.resolve(process.cwd(), keyPath);
+    },
+    async runCommand(command, env, silent = false) {
+        const { projectDir } = configStore.getProjectInfo();
+        let nodeEnv;
+        if (env) {
+            nodeEnv = { ...env, ...process.env };
+        }
+        clm.debug(`START Running command: "${command}" in directory: "${projectDir}"`);
+        const result = shell.exec(command, { cwd: projectDir, env: nodeEnv, silent });
+        clm.debug(`END ${command}. Exit code: ${result.code}`);
+        if (result.code > 0) {
+            throw new Error(`Failed running command: ${result.stderr}`);
+        }
+        return result;
+    },
+    async runCommandWithOutput(command, env) {
+        const result = await this.runCommand(command, env, true);
+        return result.stdout.trim();
+    }
+};

package/dist/styles.d.ts

@@ -0,0 +1,4 @@
+export declare const blue: (m: boolean | number | string) => string;
+export declare const green: (m: boolean | number | string) => string;
+export declare const red: (m: boolean | number | string) => string;
+export declare const cyan: (m: boolean | number | string) => string;

package/dist/styles.js

@@ -0,0 +1,5 @@
+import chalk from "chalk";
+export const blue = (m) => chalk.blueBright(m);
+export const green = (m) => chalk.green(m);
+export const red = (m) => chalk.red(m);
+export const cyan = (m) => chalk.cyan(m);

package/dist/types.d.ts

@@ -0,0 +1,22 @@
+export type TessellationLayer = 'cl1' | 'dl1' | 'gl0' | 'gl1' | 'ml0';
+export type NodeInfo = {
+    clusterSession: number;
+    host: string;
+    id: string;
+    layer: TessellationLayer;
+    p2pPort: number;
+    publicPort: number;
+    session: number;
+    state: string;
+    version: string;
+};
+export type ClusterInfo = {
+    clusterSession: string;
+    id: string;
+    ip: string;
+    jar: string;
+    p2pPort: number;
+    publicPort: number;
+    session: string;
+    state: 'DownloadInProgress' | 'GenesisReady' | 'Initial' | 'Leaving' | 'LoadingGenesis' | 'Offline' | 'Ready' | 'ReadyToJoin' | 'SessionStarted' | 'StartingSession' | 'Unavailable' | 'WaitingForDownload';
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/oclif.manifest.json

@@ -0,0 +1,241 @@
+{
+  "commands": {
+    "config": {
+      "aliases": [],
+      "args": {},
+      "description": "Update configuration settings",
+      "examples": [
+        "<%= config.bin %> <%= command.id %>"
+      ],
+      "flags": {},
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "config",
+      "pluginAlias": "@constellation-network/node-pilot",
+      "pluginName": "@constellation-network/node-pilot",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "config.js"
+      ]
+    },
+    "info": {
+      "aliases": [],
+      "args": {},
+      "description": "Display general info about the validator node",
+      "examples": [
+        "<%= config.bin %> <%= command.id %>"
+      ],
+      "flags": {},
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "info",
+      "pluginAlias": "@constellation-network/node-pilot",
+      "pluginName": "@constellation-network/node-pilot",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "info.js"
+      ]
+    },
+    "logs": {
+      "aliases": [],
+      "args": {
+        "layer": {
+          "description": "network layer to view. e.g. gl0",
+          "name": "layer"
+        }
+      },
+      "description": "view validator node runtime logs",
+      "examples": [
+        "<%= config.bin %> <%= command.id %>"
+      ],
+      "flags": {
+        "follow": {
+          "char": "f",
+          "description": "continuously wait for additional data to be appended",
+          "name": "follow",
+          "allowNo": false,
+          "type": "boolean"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "logs",
+      "pluginAlias": "@constellation-network/node-pilot",
+      "pluginName": "@constellation-network/node-pilot",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "logs.js"
+      ]
+    },
+    "restart": {
+      "aliases": [],
+      "args": {},
+      "description": "A full shutdown of the validator node, then restart",
+      "examples": [
+        "<%= config.bin %> <%= command.id %>"
+      ],
+      "flags": {},
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "restart",
+      "pluginAlias": "@constellation-network/node-pilot",
+      "pluginName": "@constellation-network/node-pilot",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "restart.js"
+      ]
+    },
+    "shutdown": {
+      "aliases": [],
+      "args": {},
+      "description": "A full shutdown of the validator node",
+      "examples": [
+        "<%= config.bin %> <%= command.id %>"
+      ],
+      "flags": {},
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "shutdown",
+      "pluginAlias": "@constellation-network/node-pilot",
+      "pluginName": "@constellation-network/node-pilot",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "shutdown.js"
+      ]
+    },
+    "status": {
+      "aliases": [],
+      "args": {},
+      "description": "Display node status and configuration settings",
+      "flags": {},
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "status",
+      "pluginAlias": "@constellation-network/node-pilot",
+      "pluginName": "@constellation-network/node-pilot",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "status.js"
+      ]
+    },
+    "test": {
+      "aliases": [],
+      "args": {},
+      "description": "node pilot test command",
+      "flags": {},
+      "hasDynamicHelp": false,
+      "hidden": true,
+      "hiddenAliases": [],
+      "id": "test",
+      "pluginAlias": "@constellation-network/node-pilot",
+      "pluginName": "@constellation-network/node-pilot",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "test.js"
+      ]
+    },
+    "config:get": {
+      "aliases": [],
+      "args": {
+        "name": {
+          "description": "configuration to get",
+          "name": "name"
+        }
+      },
+      "description": "Show all configuration settings or a specific one",
+      "examples": [
+        "<%= config.bin %> <%= command.id %>",
+        "<%= config.bin %> <%= command.id %> CL_EXTERNAL_IP",
+        "<%= config.bin %> <%= command.id %> gl0:CL_PUBLIC_HTTP_PORT"
+      ],
+      "flags": {},
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "config:get",
+      "pluginAlias": "@constellation-network/node-pilot",
+      "pluginName": "@constellation-network/node-pilot",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "config",
+        "get.js"
+      ]
+    },
+    "config:set": {
+      "aliases": [],
+      "args": {
+        "name": {
+          "description": "configuration name",
+          "name": "name",
+          "required": true
+        },
+        "value": {
+          "description": "the value to set to the configuration",
+          "name": "value",
+          "required": true
+        }
+      },
+      "description": "Set a configuration setting",
+      "examples": [
+        "<%= config.bin %> <%= command.id %> CL_EXTERNAL_IP 127.0.0.1",
+        "<%= config.bin %> <%= command.id %> gl0:CL_PUBLIC_HTTP_PORT 9000"
+      ],
+      "flags": {},
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "config:set",
+      "pluginAlias": "@constellation-network/node-pilot",
+      "pluginName": "@constellation-network/node-pilot",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "config",
+        "set.js"
+      ]
+    }
+  },
+  "version": "0.0.1"
+}

package/package.json

@@ -0,0 +1,98 @@
+{
+  "name": "@constellation-network/node-pilot",
+  "description": "An easy deployment and monitoring tool for Constellation nodes.",
+  "version": "0.0.1",
+  "author": "Frank Fox",
+  "bin": {
+    "cpilot": "bin/run.js"
+  },
+  "bugs": "https://github.com/Constellation-Labs/node-pilot/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Constellation-Labs/node-pilot.git"
+  },
+  "scripts": {
+    "build": "shx rm -rf dist && tsc -b",
+    "lint": "eslint",
+    "postpack": "shx rm -f oclif.manifest.json",
+    "posttest": "yarn lint",
+    "prepack": "oclif manifest && oclif readme",
+    "test": "mocha --forbid-only \"test/**/*.test.ts\"",
+    "version": "oclif readme && git add README.md",
+    "start": "./bin/dev.js",
+    "debug": "DEBUG=true ./bin/dev.js",
+    "publish": "npm publish --access public"
+  },
+  "types": "dist/index.d.ts",
+  "engines": {
+    "node": ">=22.3.0"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^7.8.0",
+    "@oclif/core": "^4",
+    "@oclif/plugin-help": "^6",
+    "@oclif/plugin-plugins": "^5",
+    "@stardust-collective/dag4-keystore": "^2.6.0",
+    "chalk": "^5.5.0",
+    "dotenv": "^17.2.1",
+    "js-sha256": "^0.11.1",
+    "json-bigint-patch": "^0.0.8",
+    "node-localstorage": "^3.0.5",
+    "shelljs": "^0.10.0",
+    "tty-table": "^4.2.3"
+  },
+  "devDependencies": {
+    "@eslint/compat": "^1",
+    "@oclif/prettier-config": "^0.2.1",
+    "@oclif/test": "^4",
+    "@types/chai": "^4",
+    "@types/mocha": "^10",
+    "@types/node": "^22.17.1",
+    "@types/node-localstorage": "^1.3.3",
+    "@types/shelljs": "^0.8.17",
+    "chai": "^4",
+    "eslint": "^9",
+    "eslint-config-oclif": "^6",
+    "eslint-config-prettier": "^10",
+    "mocha": "^10",
+    "oclif": "^4",
+    "shx": "^0.3.3",
+    "ts-node": "^10.9.2",
+    "typescript": "^5"
+  },
+  "files": [
+    "./bin",
+    "./dist",
+    "./oclif.manifest.json",
+    "./projects",
+    "./README.md"
+  ],
+  "homepage": "https://github.com/Constellation-Labs/node-pilot",
+  "keywords": [
+    "constellation network",
+    "validator",
+    "node"
+  ],
+  "license": "MIT",
+  "main": "dist/index.js",
+  "type": "module",
+  "oclif": {
+    "bin": "cpilot",
+    "dirname": "cpilot",
+    "commands": {
+      "default": "status",
+      "strategy": "pattern",
+      "target": "./dist/commands"
+    },
+    "plugins": [
+      "@oclif/plugin-help"
+    ],
+    "additionalHelpFlags": [
+      "-h"
+    ],
+    "additionalVersionFlags": [
+      "-v"
+    ],
+    "topicSeparator": " "
+  }
+}