@eagleoutice/flowr 1.3.11

package/cli/repl/server/connection.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowRServerConnection = void 0;
+const core_1 = require("../../../core");
+const r_bridge_1 = require("../../../r-bridge");
+const send_1 = require("./send");
+const validate_1 = require("./validate");
+const analysis_1 = require("./messages/analysis");
+const slice_1 = require("./messages/slice");
+const server_1 = require("./server");
+const repl_1 = require("./messages/repl");
+const core_2 = require("../core");
+const statistics_1 = require("../../../statistics");
+const cfg_1 = require("../../../util/cfg");
+const quads_1 = require("../../../util/quads");
+const objects_1 = require("../../../util/objects");
+/**
+ * Each connection handles a single client, answering to its requests.
+ * There is no need to construct this class manually, {@link FlowRServer} will do it for you.
+ */
+class FlowRServerConnection {
+    socket;
+    shell;
+    name;
+    logger;
+    // maps token to information
+    fileMap = new Map();
+    // we do not have to ensure synchronized shell-access as we are always running synchronized
+    constructor(socket, name, shell) {
+        this.socket = socket;
+        this.shell = shell;
+        this.name = name;
+        this.logger = server_1.serverLog.getSubLogger({ name });
+        this.socket.on('data', data => this.handleData(String(data)));
+        this.socket.on('error', e => this.logger.error(`[${this.name}] Error while handling connection: ${String(e)}`));
+    }
+    currentMessageBuffer = '';
+    handleData(message) {
+        if (!message.endsWith('\n')) {
+            this.currentMessageBuffer += message;
+            this.logger.trace(`[${this.name}] Received partial message. Buffering ${this.currentMessageBuffer.length}.`);
+            return;
+        }
+        message = this.currentMessageBuffer + message;
+        if (this.logger.settings.minLevel >= 2 /* LogLevel.Debug */) {
+            this.logger.debug(`[${this.name}] Received message: ${message}`);
+        }
+        this.currentMessageBuffer = '';
+        const request = (0, validate_1.validateBaseMessageFormat)(message);
+        if (request.type === 'error') {
+            (0, validate_1.answerForValidationError)(this.socket, request);
+            return;
+        }
+        switch (request.message.type) {
+            case 'request-file-analysis':
+                this.handleFileAnalysisRequest(request.message);
+                break;
+            case 'request-slice':
+                this.handleSliceRequest(request.message);
+                break;
+            case 'request-repl-execution':
+                this.handleRepl(request.message);
+                break;
+            default:
+                (0, send_1.sendMessage)(this.socket, {
+                    id: request.message.id,
+                    type: 'error',
+                    fatal: true,
+                    reason: `The message type ${JSON.stringify(request.message.type ?? 'undefined')} is not supported.`
+                });
+                this.socket.end();
+        }
+    }
+    handleFileAnalysisRequest(base) {
+        const requestResult = (0, validate_1.validateMessage)(base, analysis_1.requestAnalysisMessage);
+        if (requestResult.type === 'error') {
+            (0, validate_1.answerForValidationError)(this.socket, requestResult, base.id);
+            return;
+        }
+        const message = requestResult.message;
+        this.logger.info(`[${this.name}] Received file analysis request for ${message.filename ?? 'unknown file'}${message.filetoken ? ' with token: ' + message.filetoken : ''}`);
+        if (message.filetoken && this.fileMap.has(message.filetoken)) {
+            this.logger.warn(`File token ${message.filetoken} already exists. Overwriting.`);
+        }
+        const slicer = this.createSteppingSlicerForRequest(message);
+        void slicer.allRemainingSteps(false).then(async (results) => await this.sendFileAnalysisResponse(results, message))
+            .catch(e => {
+            this.logger.error(`[${this.name}] Error while analyzing file ${message.filename ?? 'unknown file'}: ${String(e)}`);
+            (0, send_1.sendMessage)(this.socket, {
+                id: message.id,
+                type: 'error',
+                fatal: false,
+                reason: `Error while analyzing file ${message.filename ?? 'unknown file'}: ${String(e)}`
+            });
+        });
+    }
+    async sendFileAnalysisResponse(results, message) {
+        let cfg = undefined;
+        if (message.cfg) {
+            cfg = (0, cfg_1.extractCFG)(results.normalize);
+        }
+        const config = () => ({ context: message.filename ?? 'unknown', getId: (0, quads_1.defaultQuadIdGenerator)() });
+        const parseConfig = (0, objects_1.deepMergeObject)(r_bridge_1.DEFAULT_XML_PARSER_CONFIG, { tokenMap: await this.shell.tokenMap() });
+        if (message.format === 'n-quads') {
+            (0, send_1.sendMessage)(this.socket, {
+                type: 'response-file-analysis',
+                format: 'n-quads',
+                id: message.id,
+                cfg: cfg ? (0, cfg_1.cfg2quads)(cfg, config()) : undefined,
+                results: {
+                    parse: await (0, core_1.printStepResult)('parse', results.parse, 5 /* StepOutputFormat.RdfQuads */, config(), parseConfig),
+                    normalize: await (0, core_1.printStepResult)('normalize', results.normalize, 5 /* StepOutputFormat.RdfQuads */, config()),
+                    dataflow: await (0, core_1.printStepResult)('dataflow', results.dataflow, 5 /* StepOutputFormat.RdfQuads */, config()),
+                }
+            });
+        }
+        else {
+            (0, send_1.sendMessage)(this.socket, {
+                type: 'response-file-analysis',
+                format: 'json',
+                id: message.id,
+                cfg,
+                results: {
+                    ...results,
+                    normalize: {
+                        ...results.normalize,
+                        idMap: undefined
+                    }
+                }
+            });
+        }
+    }
+    createSteppingSlicerForRequest(message) {
+        const slicer = new core_1.SteppingSlicer({
+            stepOfInterest: core_1.LAST_STEP,
+            shell: this.shell,
+            // we have to make sure, that the content is not interpreted as a file path if it starts with 'file://' therefore, we do it manually
+            request: {
+                request: message.content === undefined ? 'file' : 'text',
+                content: message.content ?? message.filepath,
+                ensurePackageInstalled: false
+            },
+            criterion: [] // currently unknown
+        });
+        if (message.filetoken) {
+            this.logger.info(`Storing file token ${message.filetoken}`);
+            this.fileMap.set(message.filetoken, {
+                filename: message.filename,
+                slicer
+            });
+        }
+        return slicer;
+    }
+    handleSliceRequest(base) {
+        const requestResult = (0, validate_1.validateMessage)(base, slice_1.requestSliceMessage);
+        if (requestResult.type === 'error') {
+            (0, validate_1.answerForValidationError)(this.socket, requestResult, base.id);
+            return;
+        }
+        const request = requestResult.message;
+        this.logger.info(`[${request.filetoken}] Received slice request with criteria ${JSON.stringify(request.criterion)}`);
+        const fileInformation = this.fileMap.get(request.filetoken);
+        if (!fileInformation) {
+            (0, send_1.sendMessage)(this.socket, {
+                id: request.id,
+                type: 'error',
+                fatal: false,
+                reason: `The file token ${request.filetoken} has never been analyzed.`
+            });
+            return;
+        }
+        fileInformation.slicer.updateCriterion(request.criterion);
+        void fileInformation.slicer.allRemainingSteps(true).then(results => {
+            (0, send_1.sendMessage)(this.socket, {
+                type: 'response-slice',
+                id: request.id,
+                results: Object.fromEntries(Object.entries(results).filter(([k,]) => Object.hasOwn(core_1.STEPS_PER_SLICE, k)))
+            });
+        }).catch(e => {
+            this.logger.error(`[${this.name}] Error while analyzing file for token ${request.filetoken}: ${String(e)}`);
+            (0, send_1.sendMessage)(this.socket, {
+                id: request.id,
+                type: 'error',
+                fatal: false,
+                reason: `Error while analyzing file for token ${request.filetoken}: ${String(e)}`
+            });
+        });
+    }
+    handleRepl(base) {
+        const requestResult = (0, validate_1.validateMessage)(base, repl_1.requestExecuteReplExpressionMessage);
+        if (requestResult.type === 'error') {
+            (0, validate_1.answerForValidationError)(this.socket, requestResult, base.id);
+            return;
+        }
+        const request = requestResult.message;
+        const out = (stream, msg) => {
+            (0, send_1.sendMessage)(this.socket, {
+                type: 'response-repl-execution',
+                id: request.id,
+                result: msg,
+                stream
+            });
+        };
+        void (0, core_2.replProcessAnswer)({
+            formatter: request.ansi ? statistics_1.ansiFormatter : statistics_1.voidFormatter,
+            stdout: msg => out('stdout', msg),
+            stderr: msg => out('stderr', msg)
+        }, request.expression, this.shell).then(() => {
+            (0, send_1.sendMessage)(this.socket, {
+                type: 'end-repl-execution',
+                id: request.id
+            });
+        });
+    }
+}
+exports.FlowRServerConnection = FlowRServerConnection;
+//# sourceMappingURL=connection.js.map

package/cli/repl/server/messages/analysis.d.ts

@@ -0,0 +1,71 @@
+import { IdMessageBase, MessageDefinition } from './messages';
+import { LAST_PER_FILE_STEP, StepResults } from '../../../../core';
+import { ControlFlowInformation } from '../../../../util/cfg';
+/**
+ * Send by the client to request an analysis of a given file.
+ * Answered by either an {@link FlowrErrorMessage} or a {@link FileAnalysisResponseMessageJson}.
+ */
+export interface FileAnalysisRequestMessage extends IdMessageBase {
+    type: 'request-file-analysis';
+    /**
+     * This is a unique token that you assign to subsequently slice the respective files.
+     * If you pass the same token multiple times, previous results will be overwritten.
+     *
+     * If you do not pass a file token, the server will _not_ store the results!
+     */
+    filetoken?: string;
+    /**
+     * A human-readable file name. If you present a `filepath` or read from a file this should be straightforward.
+     * However, the name is only for debugging and bears no semantic meaning.
+     */
+    filename?: string;
+    /** The contents of the file, or an R expression itself (like `1 + 1`), give either this or the `filepath`. */
+    content?: string;
+    /** The filepath on the local machine, accessible to flowR, or simply. Give either this or the `content` */
+    filepath?: string;
+    /** Can be used to additionally extract the {@link ControlFlowInformation} of the file, which is not exposed (and not fully calculated) by default. */
+    cfg?: boolean;
+    /** Controls the serialization of the `results` (and the {@link ControlFlowGraph} if the corresponding flag is set). If missing, we assume _json_. */
+    format?: 'json' | 'n-quads';
+}
+export declare const requestAnalysisMessage: MessageDefinition<FileAnalysisRequestMessage>;
+/**
+ * Answer for a successful {@link FileAnalysisRequestMessage}.
+ * It contains the results of the analysis in JSON format (guided by {@link FileAnalysisRequestMessage#format}).
+ *
+ * The `idMap` of the normalization step (see {@link NormalizedAst}) is not serialized as it would essentially
+ * repeat the complete normalized AST.
+ *
+ * @note The serialization of maps and sets is controlled by the {@link jsonReplacer} as part of {@link sendMessage}.
+ *
+ * @see FileAnalysisResponseMessageNQuads
+ */
+export interface FileAnalysisResponseMessageJson extends IdMessageBase {
+    type: 'response-file-analysis';
+    format: 'json';
+    /**
+     * See the {@link SteppingSlicer} and {@link StepResults} for details on the results.
+     */
+    results: StepResults<typeof LAST_PER_FILE_STEP>;
+    /**
+     * Only if the {@link FileAnalysisRequestMessage} contained a `cfg: true` this will contain the {@link ControlFlowInformation} of the file.
+     */
+    cfg?: ControlFlowInformation;
+}
+/**
+ * Similar to {@link FileAnalysisResponseMessageJson} but using n-quads as serialization format.
+ */
+export interface FileAnalysisResponseMessageNQuads extends IdMessageBase {
+    type: 'response-file-analysis';
+    format: 'n-quads';
+    /**
+     * @see FileAnalysisResponseMessageJson#results
+     */
+    results: {
+        [K in keyof StepResults<typeof LAST_PER_FILE_STEP>]: string;
+    };
+    /**
+     * @see FileAnalysisResponseMessageJson#cfg
+     */
+    cfg?: string;
+}

package/cli/repl/server/messages/analysis.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestAnalysisMessage = void 0;
+const joi_1 = __importDefault(require("joi"));
+exports.requestAnalysisMessage = {
+    type: 'request-file-analysis',
+    schema: joi_1.default.object({
+        type: joi_1.default.string().valid('request-file-analysis').required(),
+        id: joi_1.default.string().optional(),
+        filetoken: joi_1.default.string().optional(),
+        filename: joi_1.default.string().optional(),
+        content: joi_1.default.string().optional(),
+        filepath: joi_1.default.string().optional(),
+        cfg: joi_1.default.boolean().optional(),
+        format: joi_1.default.string().valid('json', 'n-quads').optional()
+    }).xor('content', 'filepath')
+};
+//# sourceMappingURL=analysis.js.map

package/cli/repl/server/messages/error.d.ts

@@ -0,0 +1,11 @@
+import { IdMessageBase } from './messages';
+/**
+ * Sent in case of any error (e.g., if the analysis fails, or the message contains syntax errors).
+ */
+export interface FlowrErrorMessage extends IdMessageBase {
+    type: 'error';
+    /** if fatal, the connection will be partially closed afterward */
+    fatal: boolean;
+    /** the human-readable reason for the error */
+    reason: string;
+}

package/cli/repl/server/messages/error.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=error.js.map

package/cli/repl/server/messages/hello.d.ts

@@ -0,0 +1,20 @@
+import { VersionInformation } from '../../commands/version';
+import { IdMessageBase } from './messages';
+/**
+ * The hello message is automatically send by the sever upon connection.
+ */
+export interface FlowrHelloResponseMessage extends IdMessageBase {
+    type: 'hello';
+    /** The hello message never has an id, it is always undefined */
+    id: undefined;
+    /**
+     * A unique name that is assigned to each client.
+     * It has no semantic meaning and is only used/useful for debugging.
+     */
+    clientName: string;
+    /**
+     * Describes which versions are in use on the server.
+     * @see VersionInformation
+     */
+    versions: VersionInformation;
+}

package/cli/repl/server/messages/hello.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=hello.js.map

package/cli/repl/server/messages/index.d.ts

@@ -0,0 +1 @@
+export { FlowrMessage } from './messages';

package/cli/repl/server/messages/index.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=index.js.map

package/cli/repl/server/messages/messages.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Provides the capability of connecting to the repl of flowr via messages.
+ *
+ * @module
+ */
+import Joi from 'joi';
+import { FlowrHelloResponseMessage } from './hello';
+import { FileAnalysisRequestMessage, FileAnalysisResponseMessageJson } from './analysis';
+import { ExecuteEndMessage, ExecuteIntermediateResponseMessage, ExecuteRequestMessage } from './repl';
+import { SliceRequestMessage, SliceResponseMessage } from './slice';
+import { FlowrErrorMessage } from './error';
+/**
+ * If you send a message it must *not* contain a newline but the message must be terminated by a newline.
+ */
+export interface IdMessageBase {
+    /**
+     * The at this time unknown type
+     */
+    type: string;
+    /**
+     * The id that links a request with its responses, it is up to the calling client to make sure it is unique.
+     * However, the client does not have to pass the id if it does not need to link the request with its response.
+     * The id is always undefined if the message is unprompted (e.g., with hello) or the id unknown.
+     */
+    id: string | undefined;
+}
+export interface MessageDefinition<T extends FlowrMessage | IdMessageBase> {
+    type: T['type'] | undefined;
+    schema: Joi.Schema;
+}
+export declare const baseMessage: MessageDefinition<IdMessageBase>;
+/**
+ * This is the main message type that should be used to represent a message in *flowR*
+ */
+export type FlowrMessage = FlowrHelloResponseMessage | FileAnalysisRequestMessage | FileAnalysisResponseMessageJson | ExecuteRequestMessage | ExecuteIntermediateResponseMessage | ExecuteEndMessage | SliceRequestMessage | SliceResponseMessage | FlowrErrorMessage;

package/cli/repl/server/messages/messages.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.baseMessage = void 0;
+/**
+ * Provides the capability of connecting to the repl of flowr via messages.
+ *
+ * @module
+ */
+const joi_1 = __importDefault(require("joi"));
+exports.baseMessage = {
+    type: '**base**',
+    schema: joi_1.default.object({
+        type: joi_1.default.string().required(),
+        id: joi_1.default.string().optional()
+    }).unknown(true)
+};
+//# sourceMappingURL=messages.js.map

package/cli/repl/server/messages/repl.d.ts

@@ -0,0 +1,33 @@
+import { IdMessageBase, MessageDefinition } from './messages';
+/**
+ * Request the execution of the given expression as a REPL statement.
+ * We strongly recommend that you make use of a unique {@link IdMessageBase#id}
+ * in case the message responses happen in parallel.
+ *
+ * @see ExecuteIntermediateResponseMessage
+ * @see ExecuteEndMessage
+ */
+export interface ExecuteRequestMessage extends IdMessageBase {
+    type: 'request-repl-execution';
+    /** Should ansi formatting be enabled for the response? Is `false` by default.  */
+    ansi?: boolean;
+    /** The expression to execute */
+    expression: string;
+}
+export declare const requestExecuteReplExpressionMessage: MessageDefinition<ExecuteRequestMessage>;
+/**
+ * This message may be sent multiple times, triggered for every "output" performed by the execution.
+ * {@link ExecuteEndMessage} marks the end of these messages.
+ */
+export interface ExecuteIntermediateResponseMessage extends IdMessageBase {
+    type: 'response-repl-execution';
+    stream: 'stdout' | 'stderr';
+    result: string;
+}
+/**
+ * Marks the end of the execution of the respective {@link ExecuteRequestMessage}.
+ * The underlying TCP connection should ensure the ordering so that this message is the last.
+ */
+export interface ExecuteEndMessage extends IdMessageBase {
+    type: 'end-repl-execution';
+}

package/cli/repl/server/messages/repl.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestExecuteReplExpressionMessage = void 0;
+const joi_1 = __importDefault(require("joi"));
+exports.requestExecuteReplExpressionMessage = {
+    type: 'request-repl-execution',
+    schema: joi_1.default.object({
+        type: joi_1.default.string().valid('request-repl-execution').required(),
+        id: joi_1.default.string().optional(),
+        ansi: joi_1.default.boolean().optional(),
+        expression: joi_1.default.string().required(),
+    })
+};
+//# sourceMappingURL=repl.js.map

package/cli/repl/server/messages/slice.d.ts

@@ -0,0 +1,25 @@
+import { SlicingCriteria } from '../../../../slicing';
+import { LAST_PER_FILE_STEP, LAST_STEP, StepResults } from '../../../../core';
+import { IdMessageBase, MessageDefinition } from './messages';
+/**
+ * Can only be sent after you have sent the {@link FileAnalysisRequestMessage}.
+ * Using the same `filetoken` as in the {@link FileAnalysisRequestMessage} you
+ * can slice the respective file given the respective criteria.
+ */
+export interface SliceRequestMessage extends IdMessageBase {
+    type: 'request-slice';
+    /** The {@link FileAnalysisRequestMessage#filetoken} of the file/data to slice */
+    filetoken: string;
+    /** The slicing criteria to use */
+    criterion: SlicingCriteria;
+}
+export declare const requestSliceMessage: MessageDefinition<SliceRequestMessage>;
+/**
+ * Similar to {@link FileAnalysisResponseMessage} this only contains the results of
+ * the slice steps.
+ */
+export interface SliceResponseMessage extends IdMessageBase {
+    type: 'response-slice';
+    /** only contains the results of the slice steps to not repeat ourselves */
+    results: Omit<StepResults<typeof LAST_STEP>, keyof StepResults<typeof LAST_PER_FILE_STEP>>;
+}

package/cli/repl/server/messages/slice.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestSliceMessage = void 0;
+const joi_1 = __importDefault(require("joi"));
+exports.requestSliceMessage = {
+    type: 'request-slice',
+    schema: joi_1.default.object({
+        type: joi_1.default.string().valid('request-slice').required(),
+        id: joi_1.default.string().optional(),
+        filetoken: joi_1.default.string().required(),
+        criterion: joi_1.default.array().items(joi_1.default.string().regex(/\d+:\d+|\d+@.*|\$\d+/)).min(0).required()
+    })
+};
+//# sourceMappingURL=slice.js.map

package/cli/repl/server/net.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="node" />
+/** Function handler that should be triggered when the respective socket connects */
+export type OnConnect = (c: Socket) => void;
+/**
+ * A generic server interface that allows us to mock the server's behavior in tests.
+ */
+export interface Server {
+    /**
+     * Register a function to be called when a new socket connects.
+     * This should be only called once per server.
+     */
+    onConnect(handler: OnConnect): void;
+    start(port: number): void;
+}
+/**
+ * The socket abstraction of *flowR*.
+ * Essentially a subset of what the default `net.Socket` of `node` provides.
+ */
+export interface Socket {
+    remoteAddress?: string;
+    remotePort?: number;
+    on(event: 'error', listener: (e: unknown) => void): void;
+    on(event: 'close', listener: () => void): void;
+    on(event: 'data', listener: (data: Buffer) => void): void;
+    write(data: string): void;
+    end(): void;
+}
+export declare class NetServer implements Server {
+    private readonly server;
+    constructor();
+    onConnect(handler: OnConnect): void;
+    start(port: number): void;
+}

package/cli/repl/server/net.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetServer = void 0;
+/**
+ * This is just a simple layer to allow me to mock the server's behavior in tests.
+ */
+const node_net_1 = __importDefault(require("node:net"));
+class NetServer {
+    server;
+    constructor() {
+        this.server = node_net_1.default.createServer();
+    }
+    onConnect(handler) {
+        this.server.on('connection', handler);
+    }
+    start(port) {
+        this.server.listen(port);
+    }
+}
+exports.NetServer = NetServer;
+//# sourceMappingURL=net.js.map

package/cli/repl/server/send.d.ts

@@ -0,0 +1,4 @@
+import { IdMessageBase } from './messages/messages';
+import { Socket } from './net';
+export declare function getUnnamedSocketName(c: Socket): string;
+export declare function sendMessage<T extends IdMessageBase>(c: Socket, message: T): void;

package/cli/repl/server/send.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendMessage = exports.getUnnamedSocketName = void 0;
+const json_1 = require("../../../util/json");
+const server_1 = require("./server");
+function getUnnamedSocketName(c) {
+    return `${c.remoteAddress ?? '?'}@${c.remotePort ?? '?'}`;
+}
+exports.getUnnamedSocketName = getUnnamedSocketName;
+function sendMessage(c, message) {
+    const msg = JSON.stringify(message, json_1.jsonReplacer);
+    if (server_1.serverLog.settings.minLevel >= 2 /* LogLevel.Debug */) {
+        server_1.serverLog.debug(`[${getUnnamedSocketName(c)}] sending message: ${msg}`);
+    }
+    c.write(`${msg}\n`);
+}
+exports.sendMessage = sendMessage;
+//# sourceMappingURL=send.js.map

package/cli/repl/server/server.d.ts

@@ -0,0 +1,20 @@
+import { RShell } from '../../../r-bridge';
+import { Server } from './net';
+import { FlowrLogger } from '../../../util/log';
+export declare const serverLog: FlowrLogger;
+/**
+ * This class controls the TCP server, which can be started by calling {@link start}.
+ * Afterward, each incoming connection will be greeted with {@link helloClient} and from
+ * thereon be handled by a {@link FlowRServerConnection}.
+ */
+export declare class FlowRServer {
+    private readonly server;
+    private readonly shell;
+    private versionInformation;
+    /** maps names to the respective connection */
+    private connections;
+    private nameCounter;
+    constructor(shell: RShell, server?: Server);
+    start(port: number): Promise<void>;
+    private onConnect;
+}