herdr-remote 0.2.18 → 0.2.20

package/dist/connector/font-server.js

@@ -0,0 +1,165 @@
+// Serving the workstation's terminal font to browser windows: its public
+// description, its files a chunk at a time, and characters cut out of large
+// (CJK) fonts on demand.
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import { TERMINAL_FONT_CHUNK_BYTES } from 'herdr-remote-relay/protocol';
+import { FontSubsetter } from '../font-subset.js';
+import { loadHostTerminalFont, publicTerminalFont, readFontChunk, } from '../terminal-font/index.js';
+/** Cut fonts kept for the slices a browser has yet to fetch, by total size. */
+const FONT_SUBSET_CACHE_BYTES = 48 * 1024 * 1024;
+const FONT_CHANGED = 'The terminal font changed or is no longer on this workstation';
+/**
+ * Only the family, size and file hashes leave this process; a browser that
+ * lacks the font fetches the files by hash, one chunk at a time.
+ */
+export class FontServer {
+    font;
+    load;
+    subsetter;
+    /** Subsets too large for one message, by hash, until fetched. */
+    subsets = new Map();
+    send;
+    constructor(options, send) {
+        this.load = options.loadTerminalFont || loadHostTerminalFont;
+        this.font = options.terminalFont !== undefined ? options.terminalFont : this.load();
+        this.subsetter = options.fontSubsetter || new FontSubsetter();
+        this.send = send;
+    }
+    /** What may leave this machine: the record without its file paths. */
+    publicFont() {
+        return publicTerminalFont(this.font);
+    }
+    /**
+     * A service started at boot runs before anything has seen a terminal, so it
+     * starts with no font. The first `herdr-remote start` from a terminal (or
+     * from Herdr's plugin hook) writes one down; the next window to open picks
+     * it up here instead of waiting for a restart.
+     */
+    pickUp() {
+        if (this.font)
+            return;
+        let next = null;
+        try {
+            next = this.load();
+        }
+        catch {
+            // Unreadable now; the next window to open asks again.
+            return;
+        }
+        if (!next)
+            return;
+        this.font = next;
+        this.send({ type: 'terminal_font', terminalFont: publicTerminalFont(next) });
+    }
+    /**
+     * Read the terminal's font settings again, at a browser's request. Every
+     * window of this workstation hears the answer, since they all draw with it.
+     */
+    refresh() {
+        try {
+            const next = this.load({ refresh: true });
+            if (next)
+                this.font = next;
+        }
+        catch (error) {
+            process.stderr.write(`herdr-remote host connector: could not read the terminal font: ${error.message}\n`);
+        }
+        this.send({ type: 'terminal_font', terminalFont: this.publicFont() });
+    }
+    /** One slice of a terminal font file, for the window that asked for it. */
+    sendChunk(streamId, request) {
+        const chunk = this.subsetChunk(request.sha256, request.index) ||
+            readFontChunk(this.font, request.sha256, request.index);
+        if (!chunk) {
+            this.send({
+                type: 'error',
+                clientId: streamId,
+                code: 'host_font_unavailable',
+                message: FONT_CHANGED,
+            });
+            return;
+        }
+        this.send({
+            type: 'host_font_chunk',
+            clientId: streamId,
+            sha256: request.sha256,
+            index: request.index,
+            total: chunk.total,
+            dataBase64: chunk.data.toString('base64'),
+        });
+    }
+    /**
+     * The characters a window is about to draw, cut out of a large font (CJK).
+     * A small result travels in the answer itself; a large one (the common
+     * characters fetched up front) is held here and pulled in slices.
+     */
+    sendSubset(streamId, request) {
+        const fail = (code, text) => this.send({ type: 'error', clientId: streamId, code, message: text });
+        const source = this.font?.subsets?.find((candidate) => candidate.sha256 === request.sha256);
+        if (!source || !this.unchanged(source)) {
+            fail('host_font_unavailable', FONT_CHANGED);
+            return;
+        }
+        const codepoints = [
+            ...new Set(Array.from(String(request.text || ''), (char) => char.codePointAt(0))),
+        ];
+        let data;
+        try {
+            data = this.subsetter.subset(source, codepoints);
+        }
+        catch (error) {
+            fail('host_font_subset_failed', error.message || 'The font could not be subset');
+            return;
+        }
+        const subsetSha = crypto.createHash('sha256').update(data).digest('hex');
+        const answer = {
+            type: 'host_font_subset_ready',
+            clientId: streamId,
+            requestId: request.requestId,
+            sha256: source.sha256,
+            subsetSha,
+            bytes: data.length,
+        };
+        if (data.length <= TERMINAL_FONT_CHUNK_BYTES) {
+            answer.dataBase64 = data.toString('base64');
+        }
+        else {
+            this.hold(subsetSha, data);
+        }
+        this.send(answer);
+    }
+    /** Whether the file behind `source` is still the one that was announced. */
+    unchanged(source) {
+        try {
+            const stat = fs.statSync(source.path);
+            return stat.size === source.bytes && stat.mtimeMs === source.mtimeMs;
+        }
+        catch {
+            return false;
+        }
+    }
+    /** Keep a cut font for its slices, dropping the oldest beyond the cache size. */
+    hold(subsetSha, data) {
+        this.subsets.delete(subsetSha);
+        this.subsets.set(subsetSha, data);
+        let held = [...this.subsets.values()].reduce((sum, item) => sum + item.length, 0);
+        for (const [key, item] of this.subsets) {
+            if (held <= FONT_SUBSET_CACHE_BYTES || key === subsetSha)
+                break;
+            this.subsets.delete(key);
+            held -= item.length;
+        }
+    }
+    /** A slice of a cut font still held for the browser that asked for it. */
+    subsetChunk(sha256, index) {
+        const data = this.subsets.get(sha256);
+        if (!data)
+            return null;
+        const total = Math.ceil(data.length / TERMINAL_FONT_CHUNK_BYTES);
+        if (!Number.isInteger(index) || index < 0 || index >= total)
+            return null;
+        const start = index * TERMINAL_FONT_CHUNK_BYTES;
+        return { data: data.subarray(start, start + TERMINAL_FONT_CHUNK_BYTES), total };
+    }
+}

package/dist/connector/host-connector.js

@@ -0,0 +1,430 @@
+// The workstation's link to the relay: connect and reconnect, say hello, keep
+// the socket alive, report load while someone watches, and hand each relay
+// message to the part of the connector that owns it.
+import os from 'node:os';
+import path from 'node:path';
+import { CAPABILITY, PROTOCOL_VERSION, unpackStreamFrame, } from 'herdr-remote-relay/protocol';
+import { WebSocket } from 'ws';
+import { loadConfig } from '../config.js';
+import { EXIT_AUTH_FAILED, EXIT_REPLACED } from '../exit-codes.js';
+import { cleanPastedDir, savePastedFile } from '../pasted-files.js';
+import { stateDir } from '../paths.js';
+import { hostWebSocketUrl, resolveHostRelayUrl } from '../relay-urls.js';
+import { resolveSocketPath } from '../socket-discovery.js';
+import { resolveHostPalette } from '../terminal-palette.js';
+import { randomToken } from 'herdr-remote-relay/state';
+import { AgentWatch } from './agent-watch.js';
+import { FontServer } from './font-server.js';
+import { acquireHostLock, releaseHostLock } from './lock.js';
+import { Sessions } from './sessions.js';
+import { UpdateReport } from './update-report.js';
+import { closeSocket, sendJson, streamOf, terminateSocket } from './wire.js';
+/** Handshake errors that no reconnect can fix. */
+const AUTH_ERROR_CODES = [
+    'relay_password_required',
+    'host_auth_failed',
+    'invalid_host_credentials',
+];
+export class HostConnector {
+    config;
+    relayUrl;
+    hostId;
+    hostToken;
+    relayPassword;
+    socketPath;
+    /**
+     * What the workstation's own terminal looks like. A browser has no way to
+     * know it — the PTY carries color indices, not colors — so the host reports
+     * it and the browser renders the session the way the workstation sees it.
+     * Normally captured by the start path that still had a terminal and passed
+     * down in the environment; `null` when nobody could ask.
+     */
+    terminalPalette;
+    sessions;
+    font;
+    agents;
+    updates;
+    ws = null;
+    reconnectTimer = null;
+    heartbeatTimer = null;
+    keepaliveTimer = null;
+    reconnectAttempts = 0;
+    clientCount = 0;
+    /** The relay predates `client_count`; report load all the time, as it expects. */
+    legacyHeartbeat = false;
+    authFailure = false;
+    stopping = false;
+    lockPath;
+    lockFd = null;
+    onFatal;
+    constructor(options = {}) {
+        const config = options.config || loadConfig();
+        this.config = config;
+        this.relayUrl =
+            options.relayUrl ||
+                (process.env.RELAY_URL
+                    ? hostWebSocketUrl(process.env.RELAY_URL)
+                    : resolveHostRelayUrl(config));
+        this.hostId = options.hostId || process.env.RELAY_HOST_ID || `host-${randomToken(9)}`;
+        this.hostToken = options.hostToken || process.env.RELAY_HOST_TOKEN || '';
+        // Optional; a relay without a password accepts any workstation.
+        this.relayPassword = options.relayPassword ?? process.env.RELAY_PASSWORD ?? '';
+        this.socketPath = options.socketPath || resolveSocketPath(config.herdr.socketPath);
+        this.terminalPalette =
+            options.terminalPalette !== undefined ? options.terminalPalette : resolveHostPalette();
+        const send = (payload) => sendJson(this.ws, payload);
+        this.sessions = new Sessions({
+            ...options,
+            socketPath: this.socketPath,
+            herdrArgs: options.herdrArgs || config.herdr.args,
+            cwd: options.cwd || config.herdr.cwd,
+            herdrLogPath: options.herdrLogPath || path.join(stateDir(), 'herdr-server.log'),
+        }, {
+            send,
+            sendFrame: (frame) => {
+                if (this.ws?.readyState === WebSocket.OPEN)
+                    this.ws.send(frame);
+            },
+            changed: () => this.sendHeartbeat(),
+        });
+        this.font = new FontServer(options, send);
+        this.agents = new AgentWatch({ ...options, socketPath: this.socketPath }, send);
+        this.updates = new UpdateReport(options, send);
+        this.lockPath =
+            options.lockPath ||
+                process.env.HERDR_REMOTE_HOST_LOCK ||
+                path.join(stateDir(), 'host-connector.lock');
+        this.onFatal = options.onFatal || ((exitCode) => process.exit(exitCode));
+        try {
+            cleanPastedDir();
+        }
+        catch {
+            // Old pastes are tidied again next start; a connector must still come up.
+        }
+    }
+    acquireLock() {
+        if (this.lockFd !== null)
+            return;
+        this.lockFd = acquireHostLock(this.lockPath, this.hostId);
+    }
+    releaseLock() {
+        if (this.lockFd === null)
+            return;
+        releaseHostLock(this.lockPath, this.lockFd);
+        this.lockFd = null;
+    }
+    start() {
+        if (!this.hostToken) {
+            throw new Error('RELAY_HOST_TOKEN is required');
+        }
+        this.acquireLock();
+        this.stopping = false;
+        this.connect();
+        // Off unless the user switched it on: Herdr is theirs to start.
+        if (this.config.herdr?.autoStart) {
+            this.sessions.startHerdr().catch((error) => {
+                process.stderr.write(`herdr-remote host connector: could not start Herdr: ${error.message}\n`);
+            });
+        }
+    }
+    stop() {
+        this.stopping = true;
+        if (this.reconnectTimer)
+            clearTimeout(this.reconnectTimer);
+        this.reconnectTimer = null;
+        sendJson(this.ws, { type: 'host_shutdown' });
+        this.disconnected();
+        closeSocket(this.ws, 'host_shutdown');
+        this.ws = null;
+        this.releaseLock();
+    }
+    /** Forget everything that lived on the relay connection. */
+    disconnected() {
+        if (this.heartbeatTimer)
+            clearInterval(this.heartbeatTimer);
+        this.heartbeatTimer = null;
+        this.stopKeepalive();
+        // Nothing to report to, so stop asking Herdr. A reconnect brings the
+        // watcher back with the relay's next client count.
+        this.agents.stop();
+        this.clientCount = 0;
+        this.legacyHeartbeat = false;
+        this.sessions.stopAll();
+    }
+    connect() {
+        if (this.stopping ||
+            this.ws?.readyState === WebSocket.OPEN ||
+            this.ws?.readyState === WebSocket.CONNECTING)
+            return;
+        this.stopKeepalive();
+        let ws;
+        try {
+            ws = new WebSocket(this.relayUrl);
+        }
+        catch (error) {
+            this.scheduleReconnect(error);
+            return;
+        }
+        this.ws = ws;
+        ws.isAlive = true;
+        ws.on('open', () => {
+            // Disable Nagle's algorithm to prevent small frames from stalling ~40ms when delayed ACK is active.
+            try {
+                ws._socket?.setNoDelay(true);
+            }
+            catch {
+                // The socket may not be TCP (tests) or already gone; Nagle is only a latency tweak.
+            }
+            ws.isAlive = true;
+            this.authFailure = false;
+            sendJson(ws, {
+                type: 'host_hello',
+                protocol: PROTOCOL_VERSION,
+                hostId: this.hostId,
+                token: this.hostToken,
+                password: this.relayPassword || null,
+                hostname: os.hostname(),
+                platform: process.platform,
+                arch: process.arch,
+                terminalPalette: this.terminalPalette || null,
+                terminalFont: this.font.publicFont(),
+                capabilities: [CAPABILITY.hostHandoff, CAPABILITY.idleHeartbeat, CAPABILITY.binaryFrameV2],
+            });
+            // The relay sends host_ready with the current browser count. No business
+            // heartbeat is started until that message says somebody is watching.
+        });
+        ws.on('pong', () => {
+            ws.isAlive = true;
+        });
+        ws.on('message', (raw, isBinary) => this.handleMessage(raw, isBinary));
+        ws.on('close', (_code, rawReason) => {
+            // A replacement socket may be live while an older socket is still
+            // delivering its close event. Never let that stale event destroy the new
+            // session or clear its heartbeat timer.
+            if (this.ws !== ws)
+                return;
+            this.ws = null;
+            this.disconnected();
+            // Another connector has claimed this workstation. Reconnecting would just
+            // displace it in turn, and each swap drops every attached browser, so
+            // stand down instead of fighting for the slot.
+            const reason = rawReason ? rawReason.toString() : '';
+            if (reason === 'host_replaced') {
+                process.stderr.write('herdr-remote host connector: another instance took over this workstation; exiting\n');
+                this.stop();
+                this.onFatal(EXIT_REPLACED);
+                return;
+            }
+            if (this.authFailure) {
+                this.stopping = true;
+                process.stderr.write('herdr-remote host connector: authentication failed; update relay credentials and restart the service\n');
+                this.releaseLock();
+                this.onFatal(EXIT_AUTH_FAILED);
+                return;
+            }
+            this.scheduleReconnect();
+        });
+        ws.on('error', (error) => {
+            process.stderr.write(`herdr-remote host connector: ${error.message}\n`);
+        });
+    }
+    scheduleReconnect(error = null) {
+        if (this.stopping || this.reconnectTimer)
+            return;
+        if (error)
+            process.stderr.write(`herdr-remote host connector: ${error.message}\n`);
+        const delay = Math.min(30_000, 500 * 1.5 ** this.reconnectAttempts + Math.floor(Math.random() * 250));
+        this.reconnectAttempts += 1;
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            this.connect();
+        }, delay);
+    }
+    handleMessage(raw, isBinary = false) {
+        if (isBinary) {
+            this.handleFrame(raw);
+            return undefined;
+        }
+        let message;
+        try {
+            message = JSON.parse(typeof raw === 'string' ? raw : raw.toString('utf8'));
+        }
+        catch {
+            // Not JSON: nothing a relay speaking this protocol would send.
+            return undefined;
+        }
+        switch (message.type) {
+            case 'error':
+                // A relay-level error (no clientId) is a rejected handshake — a wrong
+                // relay password, or a host token the relay does not recognise. Without
+                // this the connection just closed silently and reconnected forever,
+                // leaving the user with an empty log and no idea what was wrong.
+                if (message.clientId)
+                    return undefined;
+                this.authFailure = AUTH_ERROR_CODES.includes(message.code);
+                process.stderr.write(`herdr-remote host connector: relay rejected the connection: ${message.message || message.code}\n`);
+                return undefined;
+            case 'host_ready':
+                this.hostReady(message);
+                return undefined;
+            case 'client_count':
+                this.setClientCount(message.clientCount);
+                return undefined;
+            case 'session_start':
+                return this.startSession(message);
+            case 'herdr_start':
+                return this.sessions.startHerdrFor(streamOf(message));
+            case 'session_stop': {
+                const streamId = streamOf(message);
+                if (streamId)
+                    this.sessions.stop(streamId);
+                return undefined;
+            }
+            case 'resize':
+                this.sessions.resize(message);
+                return undefined;
+            case 'paste_file':
+                this.savePaste(streamOf(message), message);
+                return undefined;
+            case 'host_font_chunk_request':
+                this.font.sendChunk(streamOf(message), message);
+                return undefined;
+            case 'host_font_subset_request':
+                this.font.sendSubset(streamOf(message), message);
+                return undefined;
+            case 'host_font_refresh':
+                this.font.refresh();
+                return undefined;
+            default:
+                return undefined;
+        }
+    }
+    handleFrame(raw) {
+        let frame;
+        try {
+            frame = unpackStreamFrame(raw);
+        }
+        catch (error) {
+            process.stderr.write(`herdr-remote host connector: invalid relay frame: ${error.message}\n`);
+            return;
+        }
+        if (frame.type !== 'input')
+            return;
+        this.sessions.write(frame.version === 2 ? { streamIndex: frame.streamIndex } : { streamId: frame.streamId }, frame.payload);
+    }
+    hostReady(message) {
+        this.reconnectAttempts = 0;
+        this.startKeepalive();
+        if (Object.hasOwn(message, 'clientCount')) {
+            this.legacyHeartbeat = false;
+            this.setClientCount(message.clientCount);
+            return;
+        }
+        // An older relay does not know client_count. Keep its historical
+        // telemetry behavior so rolling upgrades do not silently lose status.
+        this.legacyHeartbeat = true;
+        this.sendHeartbeat(true);
+        this.heartbeatTimer = setInterval(() => this.sendHeartbeat(), this.config.cleanup.heartbeatIntervalMs);
+    }
+    startSession(message) {
+        if (!streamOf(message))
+            return undefined;
+        // A window opening is when a person is looking; that is when to ask.
+        this.updates.report();
+        this.font.pickUp();
+        return this.sessions.start(message);
+    }
+    savePaste(streamId, message) {
+        try {
+            const savedPath = savePastedFile({ mime: message.mime, dataBase64: message.dataBase64 });
+            sendJson(this.ws, { type: 'paste_file_ready', clientId: streamId, path: savedPath });
+        }
+        catch (error) {
+            sendJson(this.ws, {
+                type: 'error',
+                clientId: streamId,
+                code: 'paste_file_write_failed',
+                message: error.message || 'Failed to save pasted file',
+            });
+        }
+    }
+    startKeepalive() {
+        this.stopKeepalive();
+        if (!this.ws || this.stopping)
+            return;
+        this.ws.isAlive = true;
+        const interval = this.config?.cleanup?.heartbeatIntervalMs || 30_000;
+        this.keepaliveTimer = setInterval(() => this.tickKeepalive(), interval);
+    }
+    stopKeepalive() {
+        if (this.keepaliveTimer) {
+            clearInterval(this.keepaliveTimer);
+            this.keepaliveTimer = null;
+        }
+    }
+    tickKeepalive() {
+        const ws = this.ws;
+        if (!ws || this.stopping)
+            return;
+        if (ws.readyState === WebSocket.CLOSING) {
+            terminateSocket(ws);
+            return;
+        }
+        if (ws.readyState !== WebSocket.OPEN)
+            return;
+        if (!ws.isAlive) {
+            terminateSocket(ws);
+            return;
+        }
+        ws.isAlive = false;
+        try {
+            if (typeof ws.ping === 'function')
+                ws.ping();
+        }
+        catch {
+            // A socket failing mid-ping is caught by the next heartbeat, which terminates it.
+        }
+        if (this.clientCount <= 0 && !this.legacyHeartbeat) {
+            sendJson(ws, { type: 'heartbeat', load: {}, ptys: [] });
+        }
+    }
+    setClientCount(value) {
+        const next = Number.isInteger(value) ? Math.max(0, value) : 0;
+        if (next === this.clientCount && (next === 0 || this.heartbeatTimer))
+            return;
+        const wasActive = this.clientCount > 0;
+        this.clientCount = next;
+        if (this.heartbeatTimer)
+            clearInterval(this.heartbeatTimer);
+        this.heartbeatTimer = null;
+        if (next > 0) {
+            this.sendHeartbeat(true);
+            this.heartbeatTimer = setInterval(() => this.sendHeartbeat(), this.config.cleanup.heartbeatIntervalMs);
+        }
+        else if (wasActive) {
+            this.sendHeartbeat(true);
+        }
+        // Nobody watching, nothing to ask Herdr about itself.
+        if (next > 0 && !this.stopping)
+            this.agents.start();
+        else
+            this.agents.stop();
+    }
+    sendHeartbeat(force = false) {
+        if (!force && this.clientCount <= 0 && !this.legacyHeartbeat)
+            return;
+        const memory = process.memoryUsage();
+        const load = os.loadavg();
+        sendJson(this.ws, {
+            type: 'heartbeat',
+            load: {
+                load1m: load[0] || 0,
+                load5m: load[1] || 0,
+                load15m: load[2] || 0,
+                rssBytes: memory.rss,
+                heapUsedBytes: memory.heapUsed,
+            },
+            ptys: this.sessions.summaries(),
+        });
+    }
+}

package/dist/connector/lock.js

@@ -0,0 +1,66 @@
+// One host connector per workstation: a lock file naming the process that holds it.
+import fs from 'node:fs';
+import path from 'node:path';
+import { ensureDir } from 'herdr-remote-relay/state';
+import { pidAlive } from '../lib/process.js';
+function readOwner(lockPath) {
+    try {
+        return JSON.parse(fs.readFileSync(lockPath, 'utf8'));
+    }
+    catch {
+        // Missing, or half-written by a process that died mid-write: nobody owns it.
+        return null;
+    }
+}
+function lockError(message, code) {
+    const error = new Error(message);
+    error.code = code;
+    return error;
+}
+/**
+ * Take the lock, or throw `HOST_ALREADY_RUNNING` when a live process holds it.
+ * A lock left by a dead process is removed and taken over.
+ */
+export function acquireHostLock(lockPath, hostId) {
+    ensureDir(path.dirname(lockPath));
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        try {
+            const fd = fs.openSync(lockPath, 'wx', 0o600);
+            fs.writeFileSync(fd, `${JSON.stringify({ pid: process.pid, hostId, startedAt: new Date().toISOString() })}\n`);
+            return fd;
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+            const owner = readOwner(lockPath);
+            if (owner && pidAlive(owner.pid)) {
+                throw lockError(`another host connector is already running (pid ${owner.pid})`, 'HOST_ALREADY_RUNNING');
+            }
+            try {
+                fs.rmSync(lockPath, { force: true });
+            }
+            catch {
+                // Not ours to remove; the second attempt fails and says so below.
+            }
+        }
+    }
+    throw lockError('could not acquire host connector lock', 'HOST_LOCK_FAILED');
+}
+/** Close `fd` and remove the lock, unless another process has taken it since. */
+export function releaseHostLock(lockPath, fd) {
+    try {
+        fs.closeSync(fd);
+    }
+    catch {
+        // Already closed; the file below is what matters.
+    }
+    const owner = readOwner(lockPath);
+    if (owner && owner.pid !== process.pid)
+        return;
+    try {
+        fs.rmSync(lockPath, { force: true });
+    }
+    catch {
+        // Stopping must not fail over a lock file; a dead owner's lock is taken over.
+    }
+}

package/dist/connector/main.js

@@ -0,0 +1,18 @@
+// Process entry for the host connector; service.ts spawns this file.
+import { EXIT_REPLACED } from '../exit-codes.js';
+import { HostConnector } from './host-connector.js';
+const connector = new HostConnector({ onFatal: (exitCode) => process.exit(exitCode) });
+try {
+    connector.start();
+}
+catch (error) {
+    const { code, message } = error;
+    process.stderr.write(`herdr-remote host connector failed: ${message}\n`);
+    process.exitCode = code === 'HOST_ALREADY_RUNNING' ? EXIT_REPLACED : 1;
+}
+const stop = () => {
+    connector.stop();
+    process.exit(0);
+};
+process.once('SIGINT', stop);
+process.once('SIGTERM', stop);