ableton-js 2.9.1 → 3.0.1

package/CHANGELOG.md

@@ -4,8 +4,23 @@ All notable changes to this project will be documented in this file. Dates are d
 
 Generated by [`auto-changelog`](https://github.com/CookPete/auto-changelog).
 
+#### [v3.0.1](https://github.com/leolabs/ableton.js/compare/v3.0.0...v3.0.1)
+
+- :memo: Add breaking change reminder to the changelog [`3158328`](https://github.com/leolabs/ableton.js/commit/31583280950ac4c9a4d8d425592c05481ee7b3e7)
+- :sparkles: Don't allow starting the server multiple times [`83a42b1`](https://github.com/leolabs/ableton.js/commit/83a42b1186ede6820efa13c6cec7b599693a1bb5)
+
+### [v3.0.0](https://github.com/leolabs/ableton.js/compare/v2.9.1...v3.0.0)
+
+> 25 February 2023
+
+- :sparkles: Don't rely on fixed ports, make server and client bind to a random free one [`54f7737`](https://github.com/leolabs/ableton.js/commit/54f773758ec359ab9b5bc3f5fd3e7c96cae4e8b8)
+- :sparkles: Add a timeout param to the start method [`600e752`](https://github.com/leolabs/ableton.js/commit/600e752c5f7c0e349b0cb69aaf4b8f6238f6a1d4)
+- :loud_sound: Add a logger interface for the library to log information [`e31e9cc`](https://github.com/leolabs/ableton.js/commit/e31e9cc1a33b90e0c482e87eae645976a8668ad2)
+
 #### [v2.9.1](https://github.com/leolabs/ableton.js/compare/v2.9.0...v2.9.1)
 
+> 21 February 2023
+
 - :sparkles: Add support for available_(input/output)_routing_(channels/types) [`0c09881`](https://github.com/leolabs/ableton.js/commit/0c098819369cccf257284ad4510178833853d1e5)
 - Use enum-style values for NavDirection [`713f864`](https://github.com/leolabs/ableton.js/commit/713f86475036debabf4e401c87ddb8b08510d262)
 

package/README.md

@@ -51,6 +51,9 @@ import { Ableton } from "ableton-js";
 const ableton = new Ableton();
 
 const test = async () => {
+  // Establishes a connection with Live
+  await ableton.start();
+
   // Observe the current playback state and tempo
   ableton.song.addListener("is_playing", (p) => console.log("Playing:", p));
   ableton.song.addListener("tempo", (t) => console.log("Tempo:", t));
@@ -94,6 +97,11 @@ Ableton.js uses UDP to communicate with the MIDI Script. Each message is a JSON
 object containing required data and a UUID so request and response can be
 associated with each other.
 
+### Used Ports
+
+Both the client and the server bind to a random available port and store that
+port in a local file so the other side knows which port to send messages to.
+
 ### Compression and Chunking
 
 To allow sending large JSON payloads, requests to and responses from the MIDI

package/index.d.ts

@@ -6,6 +6,7 @@ import { Internal } from "./ns/internal";
 import { Application } from "./ns/application";
 import { Midi } from "./ns/midi";
 import { Cache } from "./util/cache";
+import { Logger } from "./util/logger";
 interface Command {
     uuid: string;
     ns: string;
@@ -36,13 +37,14 @@ export declare class TimeoutError extends Error {
     constructor(message: string, payload: Command);
 }
 export interface AbletonOptions {
-    host?: string;
-    sendPort?: number;
-    listenPort?: number;
+    serverPortFile?: string;
+    clientPortFile?: string;
     heartbeatInterval?: number;
     cacheOptions?: LruCache.Options<string, any>;
+    logger?: Logger;
 }
 export declare class Ableton extends EventEmitter implements ConnectionEventEmitter {
+    private options?;
     private client;
     private msgMap;
     private eventListeners;
@@ -51,16 +53,27 @@ export declare class Ableton extends EventEmitter implements ConnectionEventEmit
     private cancelConnectionEvent;
     private buffer;
     private latency;
-    private host;
-    private sendPort;
-    private listenPort;
+    private serverPort;
     cache: Cache;
     song: Song;
     application: Application;
     internal: Internal;
     midi: Midi;
-    constructor(options?: AbletonOptions);
-    close(): void;
+    private clientPortFile;
+    private serverPortFile;
+    private logger;
+    private clientState;
+    constructor(options?: AbletonOptions | undefined);
+    /**
+     * Starts the server and waits for a connection with Live to be established.
+     *
+     * @param timeoutMs
+     * If set, the function will throw an error if it can't establish a connection
+     * in the given time. Should be higher than 2000ms to avoid false positives.
+     */
+    start(timeoutMs?: number): Promise<void>;
+    /** Closes the client */
+    close(): Promise<void>;
     /**
      * Returns the latency between the last command and its response.
      * This is a rough measurement, so don't rely too much on it.

package/index.js

@@ -87,18 +87,24 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPackageVersion = exports.Ableton = exports.TimeoutError = void 0;
+var os_1 = __importDefault(require("os"));
+var path_1 = __importDefault(require("path"));
 var dgram_1 = __importDefault(require("dgram"));
 var events_1 = require("events");
 var uuid_1 = require("uuid");
 var semver_1 = __importDefault(require("semver"));
 var zlib_1 = require("zlib");
 var lru_cache_1 = __importDefault(require("lru-cache"));
+var fs_1 = require("fs");
+var promises_1 = require("fs/promises");
 var song_1 = require("./ns/song");
 var internal_1 = require("./ns/internal");
 var application_1 = require("./ns/application");
 var midi_1 = require("./ns/midi");
 var package_version_1 = require("./util/package-version");
 var cache_1 = require("./util/cache");
+var SERVER_PORT_FILE = "ableton-js-server.port";
+var CLIENT_PORT_FILE = "ableton-js-client.port";
 var TimeoutError = /** @class */ (function (_super) {
     __extends(TimeoutError, _super);
     function TimeoutError(message, payload) {
@@ -115,6 +121,7 @@ var Ableton = /** @class */ (function (_super) {
     function Ableton(options) {
         var _a, _b, _c, _d;
         var _this = _super.call(this) || this;
+        _this.options = options;
         _this.msgMap = new Map();
         _this.eventListeners = new Map();
         _this._isConnected = false;
@@ -125,61 +132,193 @@ var Ableton = /** @class */ (function (_super) {
         _this.application = new application_1.Application(_this);
         _this.internal = new internal_1.Internal(_this);
         _this.midi = new midi_1.Midi(_this);
-        _this.host = (_a = options === null || options === void 0 ? void 0 : options.host) !== null && _a !== void 0 ? _a : "127.0.0.1";
-        _this.sendPort = (_b = options === null || options === void 0 ? void 0 : options.sendPort) !== null && _b !== void 0 ? _b : 39041;
-        _this.listenPort = (_c = options === null || options === void 0 ? void 0 : options.listenPort) !== null && _c !== void 0 ? _c : 39031;
-        _this.client = dgram_1.default.createSocket({ type: "udp4" });
-        _this.client.bind(_this.listenPort, _this.host);
-        _this.client.addListener("message", _this.handleIncoming.bind(_this));
+        _this.clientState = "closed";
+        _this.logger = options === null || options === void 0 ? void 0 : options.logger;
         _this.cache = new lru_cache_1.default(__assign({ max: 500, ttl: 1000 * 60 * 10 }, options === null || options === void 0 ? void 0 : options.cacheOptions));
-        var heartbeat = function () { return __awaiter(_this, void 0, void 0, function () {
-            var e_1;
+        _this.clientPortFile = path_1.default.join(os_1.default.tmpdir(), (_b = (_a = _this.options) === null || _a === void 0 ? void 0 : _a.clientPortFile) !== null && _b !== void 0 ? _b : CLIENT_PORT_FILE);
+        _this.serverPortFile = path_1.default.join(os_1.default.tmpdir(), (_d = (_c = _this.options) === null || _c === void 0 ? void 0 : _c.serverPortFile) !== null && _d !== void 0 ? _d : SERVER_PORT_FILE);
+        return _this;
+    }
+    /**
+     * Starts the server and waits for a connection with Live to be established.
+     *
+     * @param timeoutMs
+     * If set, the function will throw an error if it can't establish a connection
+     * in the given time. Should be higher than 2000ms to avoid false positives.
+     */
+    Ableton.prototype.start = function (timeoutMs) {
+        var _a, _b, _c, _d, _e;
+        return __awaiter(this, void 0, void 0, function () {
+            var connection, timeout, heartbeat;
+            var _this = this;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0:
+                        if (this.clientState !== "closed") {
+                            (_a = this.logger) === null || _a === void 0 ? void 0 : _a.warn("Tried call start, but client is already " + this.clientState);
+                            return [2 /*return*/];
+                        }
+                        this.clientState = "starting";
+                        this.client = dgram_1.default.createSocket({ type: "udp4" });
+                        this.client.addListener("message", this.handleIncoming.bind(this));
+                        this.client.addListener("listening", function () { return __awaiter(_this, void 0, void 0, function () {
+                            var clientPort;
+                            var _a, _b;
+                            return __generator(this, function (_c) {
+                                switch (_c.label) {
+                                    case 0:
+                                        clientPort = (_a = this.client) === null || _a === void 0 ? void 0 : _a.address().port;
+                                        (_b = this.logger) === null || _b === void 0 ? void 0 : _b.info("Bound client to port:", { clientPort: clientPort });
+                                        // Write used port to a file to Live can read from it
+                                        return [4 /*yield*/, promises_1.writeFile(this.clientPortFile, String(clientPort))];
+                                    case 1:
+                                        // Write used port to a file to Live can read from it
+                                        _c.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); });
+                        this.client.bind(undefined, "127.0.0.1");
+                        // Wait for the server port file to exist
+                        return [4 /*yield*/, new Promise(function (res) { return __awaiter(_this, void 0, void 0, function () {
+                                var serverPort, e_1;
+                                var _this = this;
+                                var _a;
+                                return __generator(this, function (_b) {
+                                    switch (_b.label) {
+                                        case 0:
+                                            _b.trys.push([0, 2, , 3]);
+                                            return [4 /*yield*/, promises_1.readFile(this.serverPortFile)];
+                                        case 1:
+                                            serverPort = _b.sent();
+                                            this.serverPort = Number(serverPort.toString());
+                                            (_a = this.logger) === null || _a === void 0 ? void 0 : _a.info("Server port:", { port: this.serverPort });
+                                            res();
+                                            return [3 /*break*/, 3];
+                                        case 2:
+                                            e_1 = _b.sent();
+                                            return [3 /*break*/, 3];
+                                        case 3:
+                                            // Set up a watcher in case the server port changes
+                                            fs_1.watchFile(this.serverPortFile, function (curr) { return __awaiter(_this, void 0, void 0, function () {
+                                                var serverPort, newPort;
+                                                var _a;
+                                                return __generator(this, function (_b) {
+                                                    switch (_b.label) {
+                                                        case 0:
+                                                            if (!curr.isFile()) return [3 /*break*/, 2];
+                                                            return [4 /*yield*/, promises_1.readFile(this.serverPortFile)];
+                                                        case 1:
+                                                            serverPort = _b.sent();
+                                                            newPort = Number(serverPort.toString());
+                                                            if (!isNaN(newPort) && newPort !== this.serverPort) {
+                                                                (_a = this.logger) === null || _a === void 0 ? void 0 : _a.info("Server port changed:", { port: newPort });
+                                                                this.serverPort = Number(serverPort.toString());
+                                                            }
+                                                            res();
+                                                            _b.label = 2;
+                                                        case 2: return [2 /*return*/];
+                                                    }
+                                                });
+                                            }); });
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            }); })];
+                    case 1:
+                        // Wait for the server port file to exist
+                        _f.sent();
+                        (_b = this.logger) === null || _b === void 0 ? void 0 : _b.info("Checking connection...");
+                        connection = new Promise(function (res) { return _this.once("connect", res); });
+                        if (!timeoutMs) return [3 /*break*/, 3];
+                        timeout = new Promise(function (_, rej) {
+                            return setTimeout(function () { return rej("Connection timed out."); }, timeoutMs);
+                        });
+                        return [4 /*yield*/, Promise.race([connection, timeout])];
+                    case 2:
+                        _f.sent();
+                        return [3 /*break*/, 5];
+                    case 3: return [4 /*yield*/, connection];
+                    case 4:
+                        _f.sent();
+                        _f.label = 5;
+                    case 5:
+                        (_c = this.logger) === null || _c === void 0 ? void 0 : _c.info("Got connection!");
+                        this.clientState = "started";
+                        heartbeat = function () { return __awaiter(_this, void 0, void 0, function () {
+                            var e_2;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        this.cancelConnectionEvent = false;
+                                        _a.label = 1;
+                                    case 1:
+                                        _a.trys.push([1, 3, , 4]);
+                                        return [4 /*yield*/, this.internal.get("ping")];
+                                    case 2:
+                                        _a.sent();
+                                        if (!this._isConnected && !this.cancelConnectionEvent) {
+                                            this._isConnected = true;
+                                            this.emit("connect", "heartbeat");
+                                        }
+                                        return [3 /*break*/, 4];
+                                    case 3:
+                                        e_2 = _a.sent();
+                                        if (this._isConnected && !this.cancelConnectionEvent) {
+                                            this._isConnected = false;
+                                            this.eventListeners.clear();
+                                            this.msgMap.forEach(function (msg) { return msg.clearTimeout(); });
+                                            this.msgMap.clear();
+                                            this.emit("disconnect", "heartbeat");
+                                        }
+                                        return [3 /*break*/, 4];
+                                    case 4: return [2 /*return*/];
+                                }
+                            });
+                        }); };
+                        this.heartbeatInterval = setInterval(heartbeat, (_e = (_d = this.options) === null || _d === void 0 ? void 0 : _d.heartbeatInterval) !== null && _e !== void 0 ? _e : 2000);
+                        heartbeat();
+                        this.internal
+                            .get("version")
+                            .then(function (v) {
+                            var _a;
+                            var jsVersion = package_version_1.getPackageVersion();
+                            if (semver_1.default.lt(v, jsVersion)) {
+                                (_a = _this.logger) === null || _a === void 0 ? void 0 : _a.warn("The installed version of your AbletonJS plugin (" + v + ") is lower than the JS library (" + jsVersion + ").", "Please update your AbletonJS plugin to the latest version: https://git.io/JvaOu");
+                            }
+                        })
+                            .catch(function () { });
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /** Closes the client */
+    Ableton.prototype.close = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var closePromise;
+            var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        this.cancelConnectionEvent = false;
-                        _a.label = 1;
+                        this.cancelConnectionEvent = true;
+                        fs_1.unwatchFile(this.serverPortFile);
+                        if (this.heartbeatInterval) {
+                            clearInterval(this.heartbeatInterval);
+                        }
+                        if (!this.client) return [3 /*break*/, 2];
+                        closePromise = new Promise(function (res) { var _a; return (_a = _this.client) === null || _a === void 0 ? void 0 : _a.once("close", res); });
+                        this.client.close();
+                        return [4 /*yield*/, closePromise];
                     case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, this.song.get("current_song_time")];
-                    case 2:
                         _a.sent();
-                        if (!this._isConnected && !this.cancelConnectionEvent) {
-                            this._isConnected = true;
-                            this.emit("connect", "heartbeat");
-                        }
-                        return [3 /*break*/, 4];
-                    case 3:
-                        e_1 = _a.sent();
-                        if (this._isConnected && !this.cancelConnectionEvent) {
-                            this._isConnected = false;
-                            this.eventListeners.clear();
-                            this.msgMap.forEach(function (msg) { return msg.clearTimeout(); });
-                            this.msgMap.clear();
-                            this.emit("disconnect", "heartbeat");
-                        }
-                        return [3 /*break*/, 4];
-                    case 4: return [2 /*return*/];
+                        _a.label = 2;
+                    case 2:
+                        this.clientState = "closed";
+                        return [2 /*return*/];
                 }
             });
-        }); };
-        _this.heartbeatInterval = setInterval(heartbeat, (_d = options === null || options === void 0 ? void 0 : options.heartbeatInterval) !== null && _d !== void 0 ? _d : 2000);
-        heartbeat();
-        _this.internal
-            .get("version")
-            .then(function (v) {
-            var jsVersion = package_version_1.getPackageVersion();
-            if (semver_1.default.lt(v, jsVersion)) {
-                console.warn("The installed version of your AbletonJS plugin (" + v + ") is lower than the JS library (" + jsVersion + ").", "Please update your AbletonJS plugin to the latest version: https://git.io/JvaOu");
-            }
-        })
-            .catch(function () { });
-        return _this;
-    }
-    Ableton.prototype.close = function () {
-        this.cancelConnectionEvent = true;
-        clearInterval(this.heartbeatInterval);
-        this.client.close();
+        });
     };
     /**
      * Returns the latency between the last command and its response.
@@ -209,6 +348,7 @@ var Ableton = /** @class */ (function (_super) {
         }
     };
     Ableton.prototype.handleUncompressedMessage = function (msg) {
+        var _a;
         this.emit("raw_message", msg);
         var data = JSON.parse(msg);
         var functionCallback = this.msgMap.get(data.uuid);
@@ -233,6 +373,12 @@ var Ableton = /** @class */ (function (_super) {
             return;
         }
         if (data.event === "connect") {
+            if (data.data.port && data.data.port !== this.serverPort) {
+                (_a = this.logger) === null || _a === void 0 ? void 0 : _a.info("Got new server port via connect:", {
+                    port: data.data.port,
+                });
+                this.serverPort = data.data.port;
+            }
             if (this._isConnected === false) {
                 this._isConnected = true;
                 this.cancelConnectionEvent = true;
@@ -269,8 +415,7 @@ var Ableton = /** @class */ (function (_super) {
                             rej(new TimeoutError([
                                 "The command " + cls + "." + command.name + "(" + arg + ") timed out after " + timeout + " ms.",
                                 "Please make sure that Ableton is running and that you have the latest",
-                                "version of AbletonJS' midi script installed and renamed to \"AbletonJS\", listening on port",
-                                _this.sendPort + " and sending on port " + _this.listenPort + ".",
+                                "version of AbletonJS' MIDI script installed and renamed to \"AbletonJS\".",
                             ].join(" "), payload));
                         }, timeout);
                         var currentTimestamp = Date.now();
@@ -417,6 +562,9 @@ var Ableton = /** @class */ (function (_super) {
         this.eventListeners.clear();
     };
     Ableton.prototype.sendRaw = function (msg) {
+        if (!this.client || !this.serverPort) {
+            throw new Error("The client hasn't been started yet. Please call start() first.");
+        }
         var buffer = zlib_1.deflateSync(Buffer.from(msg));
         // Based on this thread, 7500 bytes seems like a safe value
         // https://stackoverflow.com/questions/22819214/udp-message-too-long
@@ -429,7 +577,7 @@ var Ableton = /** @class */ (function (_super) {
                 Buffer.alloc(1, i + 1 === chunks ? 255 : i),
                 buffer.slice(i * byteLimit, i * byteLimit + byteLimit),
             ]);
-            this.client.send(chunk, 0, chunk.length, this.sendPort, this.host);
+            this.client.send(chunk, 0, chunk.length, this.serverPort, "127.0.0.1");
         }
     };
     Ableton.prototype.isConnected = function () {

package/midi-script/AbletonJS.py

@@ -52,8 +52,6 @@ class AbletonJS(ControlSurface):
 
         self.recv_loop.start()
 
-        self.socket.send("connect")
-
     def build_midi_map(self, midi_map_handle):
         script_handle = self._c_instance.handle()
         for midi in self.tracked_midi:
@@ -76,9 +74,12 @@ class AbletonJS(ControlSurface):
         super(AbletonJS, self).disconnect()
 
     def command_handler(self, payload):
-        self.log_message("Received command: " + str(payload))
         namespace = payload["ns"]
 
+        # Don't clutter the logs
+        if not (namespace == "internal" and payload["name"] == "get_prop" and payload["args"]["prop"] == "ping"):
+            self.log_message("Received command: " + str(payload))
+
         if namespace in self.handlers:
             handler = self.handlers[namespace]
             handler.handle(payload)

package/midi-script/Internal.py

@@ -9,5 +9,8 @@ class Internal(Interface):
     def get_ns(self, nsid):
         return self
 
+    def get_ping(self, nsid):
+        return True
+
     def get_version(self, ns):
-        return "2.9.1"
+        return "3.0.1"

package/midi-script/Socket.py

@@ -2,7 +2,8 @@ import socket
 import json
 import struct
 import zlib
-import hashlib
+import os
+import tempfile
 from threading import Timer
 
 import Live
@@ -15,6 +16,13 @@ def split_by_n(seq, n):
         seq = seq[n:]
 
 
+server_port_file = "ableton-js-server.port"
+client_port_file = "ableton-js-client.port"
+
+client_port_path = os.path.join(tempfile.gettempdir(), client_port_file)
+server_port_path = os.path.join(tempfile.gettempdir(), server_port_file)
+
+
 class Socket(object):
 
     @staticmethod
@@ -25,12 +33,30 @@ class Socket(object):
     def set_message(func):
         Socket.show_message = func
 
-    def __init__(self, handler, remotehost='127.0.0.1', remoteport=39031, localhost='127.0.0.1', localport=39041):
+    def __init__(self, handler):
         self.input_handler = handler
-        self._local_addr = (localhost, localport)
-        self._remote_addr = (remotehost, remoteport)
+        self._server_addr = ('127.0.0.1', 0)
+        self._client_addr = ('127.0.0.1', 39031)
+        self.read_remote_port()
         self.init_socket()
 
+    def read_remote_port(self):
+        '''Reads the port our client is listening on'''
+        try:
+            with open(client_port_path) as file:
+                port = int(file.read())
+                if port != self._client_addr[1]:
+                    self.log_message("Client port changed: " + str(port))
+                    self._client_addr = ('127.0.0.1', port)
+
+                    if hasattr(self, "_socket"):
+                        self.send("connect", {"port": self._server_addr[1]})
+        except Exception as e:
+            self.log_message("Couldn't read remote port:", str(e.args))
+
+        t = Timer(1, self.read_remote_port)
+        t.start()
+
     def init_socket(self):
         self._socket = socket.socket(
             socket.AF_INET, socket.SOCK_DGRAM)
@@ -43,12 +69,22 @@ class Socket(object):
 
     def bind(self):
         try:
-            self._socket.bind(self._local_addr)
-            self.log_message('Starting on: ' + str(self._local_addr) +
-                             ', remote addr: ' + str(self._remote_addr))
-        except:
+            self._socket.bind(self._server_addr)
+            port = self._socket.getsockname()[1]
+
+            # Write the chosen port to a file
+            with open(server_port_path, "w") as file:
+                file.write(str(port))
+
+            self.send("connect", {"port": port})
+
+            self.log_message('Starting on: ' + str(self._socket.getsockname()) +
+                             ', remote addr: ' + str(self._client_addr))
+        except Exception as e:
             msg = 'ERROR: Cannot bind to ' + \
-                str(self._local_addr) + ', port in use. Trying again...'
+                str(self._server_addr) + ': ' + \
+                str(e.args) + ', trying again. ' + \
+                'If this keeps happening, try restarting your computer.'
             self.show_message(msg)
             self.log_message(msg)
             t = Timer(5, self.bind)
@@ -62,13 +98,13 @@ class Socket(object):
         limit = 7500
 
         if len(compressed) < limit:
-            self._socket.sendto(b'\xFF' + compressed, self._remote_addr)
+            self._socket.sendto(b'\xFF' + compressed, self._client_addr)
         else:
             chunks = list(split_by_n(compressed, limit))
             count = len(chunks)
             for i, chunk in enumerate(chunks):
                 count_byte = struct.pack("B", i if i + 1 < count else 255)
-                self._socket.sendto(count_byte + chunk, self._remote_addr)
+                self._socket.sendto(count_byte + chunk, self._client_addr)
 
     def send(self, name, obj=None, uuid=None):
         def jsonReplace(o):

package/ns/internal.d.ts

@@ -2,6 +2,7 @@ import { Ableton } from "..";
 import { Namespace } from ".";
 export interface GettableProperties {
     version: string;
+    ping: boolean;
 }
 export interface TransformedProperties {
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ableton-js",
-  "version": "2.9.1",
+  "version": "3.0.1",
   "description": "Control Ableton Live from Node",
   "main": "index.js",
   "author": "Leo Bernard <admin@leolabs.org>",

package/util/logger.d.ts

@@ -0,0 +1,6 @@
+export interface Logger {
+    debug: (msg: string, ...args: any[]) => unknown;
+    info: (msg: string, ...args: any[]) => unknown;
+    warn: (msg: string, ...args: any[]) => unknown;
+    error: (msg: string, ...args: any[]) => unknown;
+}

package/util/logger.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/util/tests.js

@@ -45,17 +45,20 @@ var withAbleton = function (callback) { return __awaiter(void 0, void 0, void 0,
             case 0:
                 ab = new __1.Ableton();
                 ab.on("error", console.error);
-                _a.label = 1;
+                return [4 /*yield*/, ab.start(2000)];
             case 1:
-                _a.trys.push([1, , 3, 4]);
-                return [4 /*yield*/, callback(ab)];
-            case 2:
                 _a.sent();
-                return [3 /*break*/, 4];
+                _a.label = 2;
+            case 2:
+                _a.trys.push([2, , 4, 5]);
+                return [4 /*yield*/, callback(ab)];
             case 3:
+                _a.sent();
+                return [3 /*break*/, 5];
+            case 4:
                 ab.close();
                 return [7 /*endfinally*/];
-            case 4: return [2 /*return*/];
+            case 5: return [2 /*return*/];
         }
     });
 }); };