midi-shell-commands 1.0.0 → 1.1.2

package/coverage/sorter.js

@@ -0,0 +1,210 @@
+/* eslint-disable */
+var addSorting = (function() {
+    'use strict';
+    var cols,
+        currentSort = {
+            index: 0,
+            desc: false
+        };
+
+    // returns the summary table element
+    function getTable() {
+        return document.querySelector('.coverage-summary');
+    }
+    // returns the thead element of the summary table
+    function getTableHeader() {
+        return getTable().querySelector('thead tr');
+    }
+    // returns the tbody element of the summary table
+    function getTableBody() {
+        return getTable().querySelector('tbody');
+    }
+    // returns the th element for nth column
+    function getNthColumn(n) {
+        return getTableHeader().querySelectorAll('th')[n];
+    }
+
+    function onFilterInput() {
+        const searchValue = document.getElementById('fileSearch').value;
+        const rows = document.getElementsByTagName('tbody')[0].children;
+
+        // Try to create a RegExp from the searchValue. If it fails (invalid regex),
+        // it will be treated as a plain text search
+        let searchRegex;
+        try {
+            searchRegex = new RegExp(searchValue, 'i'); // 'i' for case-insensitive
+        } catch (error) {
+            searchRegex = null;
+        }
+
+        for (let i = 0; i < rows.length; i++) {
+            const row = rows[i];
+            let isMatch = false;
+
+            if (searchRegex) {
+                // If a valid regex was created, use it for matching
+                isMatch = searchRegex.test(row.textContent);
+            } else {
+                // Otherwise, fall back to the original plain text search
+                isMatch = row.textContent
+                    .toLowerCase()
+                    .includes(searchValue.toLowerCase());
+            }
+
+            row.style.display = isMatch ? '' : 'none';
+        }
+    }
+
+    // loads the search box
+    function addSearchBox() {
+        var template = document.getElementById('filterTemplate');
+        var templateClone = template.content.cloneNode(true);
+        templateClone.getElementById('fileSearch').oninput = onFilterInput;
+        template.parentElement.appendChild(templateClone);
+    }
+
+    // loads all columns
+    function loadColumns() {
+        var colNodes = getTableHeader().querySelectorAll('th'),
+            colNode,
+            cols = [],
+            col,
+            i;
+
+        for (i = 0; i < colNodes.length; i += 1) {
+            colNode = colNodes[i];
+            col = {
+                key: colNode.getAttribute('data-col'),
+                sortable: !colNode.getAttribute('data-nosort'),
+                type: colNode.getAttribute('data-type') || 'string'
+            };
+            cols.push(col);
+            if (col.sortable) {
+                col.defaultDescSort = col.type === 'number';
+                colNode.innerHTML =
+                    colNode.innerHTML + '<span class="sorter"></span>';
+            }
+        }
+        return cols;
+    }
+    // attaches a data attribute to every tr element with an object
+    // of data values keyed by column name
+    function loadRowData(tableRow) {
+        var tableCols = tableRow.querySelectorAll('td'),
+            colNode,
+            col,
+            data = {},
+            i,
+            val;
+        for (i = 0; i < tableCols.length; i += 1) {
+            colNode = tableCols[i];
+            col = cols[i];
+            val = colNode.getAttribute('data-value');
+            if (col.type === 'number') {
+                val = Number(val);
+            }
+            data[col.key] = val;
+        }
+        return data;
+    }
+    // loads all row data
+    function loadData() {
+        var rows = getTableBody().querySelectorAll('tr'),
+            i;
+
+        for (i = 0; i < rows.length; i += 1) {
+            rows[i].data = loadRowData(rows[i]);
+        }
+    }
+    // sorts the table using the data for the ith column
+    function sortByIndex(index, desc) {
+        var key = cols[index].key,
+            sorter = function(a, b) {
+                a = a.data[key];
+                b = b.data[key];
+                return a < b ? -1 : a > b ? 1 : 0;
+            },
+            finalSorter = sorter,
+            tableBody = document.querySelector('.coverage-summary tbody'),
+            rowNodes = tableBody.querySelectorAll('tr'),
+            rows = [],
+            i;
+
+        if (desc) {
+            finalSorter = function(a, b) {
+                return -1 * sorter(a, b);
+            };
+        }
+
+        for (i = 0; i < rowNodes.length; i += 1) {
+            rows.push(rowNodes[i]);
+            tableBody.removeChild(rowNodes[i]);
+        }
+
+        rows.sort(finalSorter);
+
+        for (i = 0; i < rows.length; i += 1) {
+            tableBody.appendChild(rows[i]);
+        }
+    }
+    // removes sort indicators for current column being sorted
+    function removeSortIndicators() {
+        var col = getNthColumn(currentSort.index),
+            cls = col.className;
+
+        cls = cls.replace(/ sorted$/, '').replace(/ sorted-desc$/, '');
+        col.className = cls;
+    }
+    // adds sort indicators for current column being sorted
+    function addSortIndicators() {
+        getNthColumn(currentSort.index).className += currentSort.desc
+            ? ' sorted-desc'
+            : ' sorted';
+    }
+    // adds event listeners for all sorter widgets
+    function enableUI() {
+        var i,
+            el,
+            ithSorter = function ithSorter(i) {
+                var col = cols[i];
+
+                return function() {
+                    var desc = col.defaultDescSort;
+
+                    if (currentSort.index === i) {
+                        desc = !currentSort.desc;
+                    }
+                    sortByIndex(i, desc);
+                    removeSortIndicators();
+                    currentSort.index = i;
+                    currentSort.desc = desc;
+                    addSortIndicators();
+                };
+            };
+        for (i = 0; i < cols.length; i += 1) {
+            if (cols[i].sortable) {
+                // add the click event handler on the th so users
+                // dont have to click on those tiny arrows
+                el = getNthColumn(i).querySelector('.sorter').parentElement;
+                if (el.addEventListener) {
+                    el.addEventListener('click', ithSorter(i));
+                } else {
+                    el.attachEvent('onclick', ithSorter(i));
+                }
+            }
+        }
+    }
+    // adds sorting functionality to the UI
+    return function() {
+        if (!getTable()) {
+            return;
+        }
+        cols = loadColumns();
+        loadData();
+        addSearchBox();
+        addSortIndicators();
+        enableUI();
+    };
+})();
+
+window.addEventListener('load', addSorting);

package/eslint.config.js

@@ -0,0 +1,12 @@
+import js from '@eslint/js';
+import { defineConfig } from 'eslint/config';
+import globals from 'globals';
+
+export default defineConfig([
+  {
+    files: ['**/*.{js,mjs,cjs}'],
+    plugins: { js },
+    extends: ['js/recommended'],
+    languageOptions: { globals: globals.node },
+  },
+]);

package/lib/check-inputs.js

@@ -0,0 +1,9 @@
+import easyMIDI from 'easymidi';
+import { listenToInput } from './listen-to-input.js';
+
+export function checkInputs() {
+  const inputNames = easyMIDI.getInputs();
+  for (const inputName of inputNames) {
+    listenToInput(inputName);
+  }
+}

package/lib/clean-up-inputs.js

@@ -0,0 +1,9 @@
+import { log } from './log.js';
+import { state } from './state.js';
+
+export function cleanUpInputs() {
+  for (const input of Object.values(state.watchedInputs)) {
+    input.close();
+  }
+  log('Cleaned up midi input watchers');
+}

package/lib/clean-up-watcher.js

@@ -0,0 +1,10 @@
+import { log } from './log.js';
+import { state } from './state.js';
+
+export function cleanUpWatcher() {
+  if (state.watcher) {
+    log('Stopped watching scripts directory');
+    state.watcher.close();
+    state.watcher = undefined;
+  }
+}

package/lib/escape-path.js

@@ -0,0 +1,7 @@
+export function escapePath(p) {
+  // Simple shell escaping for spaces
+  if (p.includes(' ')) {
+    return `'${p.replace(/'/g, '\'\\\'\'')}'`;
+  }
+  return p;
+}

package/lib/initialize-midi.js

@@ -0,0 +1,9 @@
+import { checkInputs } from './check-inputs.js';
+import { cleanUpInputs } from './clean-up-inputs.js';
+
+export function initializeMidi() {
+  const checkDelay = 60 * 1000 + (Math.random() * 3000) | 0;
+  checkInputs();
+  setInterval(checkInputs, checkDelay);
+  process.on('exit', cleanUpInputs);
+}

package/lib/initialize-scripts-directory.js

@@ -0,0 +1,37 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { cleanUpWatcher } from './clean-up-watcher.js';
+import { log } from './log.js';
+import { refreshScripts } from './refresh-scripts.js';
+import { state } from './state.js';
+
+export function initializeScriptsDirectory() {
+  // Default to ~/Documents/MidiShellCommands if no directory is provided
+  let targetDirArg = process.argv[process.argv.length - 1];
+  if (process.argv.length === 2 || targetDirArg === '--daemon') {
+    targetDirArg = path.join(os.homedir(), 'Documents', 'MidiShellCommands');
+  }
+
+  // Ensure the directory exists
+  state.watchDir = path.resolve(targetDirArg);
+  try {
+    fs.mkdirSync(state.watchDir, { recursive: true });
+  }
+  catch (e) {
+    console.error('Failed to create or access scripts directory:', state.watchDir);
+    console.error(e);
+    process.exit(1);
+  }
+
+  refreshScripts();
+  try {
+    state.watcher = fs.watch(state.watchDir, { persistent: true }, refreshScripts);
+  }
+  catch {
+    // Non-fatal on some platforms
+  }
+  process.on('exit', cleanUpWatcher);
+
+  log(`Watching ${targetDirArg}`);
+}

package/lib/invoke-scripts.js

@@ -0,0 +1,18 @@
+import childProcess from 'node:child_process';
+import { log } from './log.js';
+import { mapMessageToFileNames } from './map-message-to-file-names.js';
+import { reportErrors } from './report-errors.js';
+import { state } from './state.js';
+
+export function invokeScripts(msg) {
+  const possibleFileNames = mapMessageToFileNames(msg);
+  log(possibleFileNames[0]);
+  for (const possibleFileName of possibleFileNames) {
+    for (let i = 0; i < state.scriptsWithoutExtension.length; i++) {
+      if (state.scriptsWithoutExtension[i] === possibleFileName) {
+        log('Executing ' + state.scripts[i]);
+        childProcess.exec(`./${state.scripts[i]}`, { cwd: state.watchDir }, reportErrors);
+      }
+    }
+  }
+}

package/lib/listen-to-input.js

@@ -0,0 +1,11 @@
+import easyMIDI from 'easymidi';
+import { invokeScripts } from './invoke-scripts.js';
+import { state } from './state.js';
+
+export function listenToInput(inputName) {
+  if (!state.watchedInputs[inputName]) {
+    const input = state.watchedInputs[inputName] = new easyMIDI.Input(inputName);
+    input.on('noteon', invokeScripts);
+    input.on('noteoff', invokeScripts);
+  }
+}

package/lib/log.js

@@ -0,0 +1,3 @@
+export function log(msg) {
+  console.log(`[midi-shell-commands] ${msg}`);
+}

package/lib/map-message-to-file-names.js

@@ -0,0 +1,7 @@
+export function mapMessageToFileNames(msg) {
+  return [
+    `${msg._type}.${msg.note}.${msg.channel}.${msg.velocity}`,
+    `${msg._type}.${msg.note}.${msg.channel}`,
+    `${msg._type}.${msg.note}`,
+  ];
+}

package/lib/post-install.js

@@ -0,0 +1,135 @@
+#!/usr/local/bin/node
+import childProcess from 'node:child_process';
+/**
+ * Postinstall script to set up a macOS LaunchAgent which runs midi-shell-commands
+ * pointing at ~/Documents/MidiShellCommands.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { escapePath } from './escape-path.js';
+import { log } from './log.js';
+
+(function main() {
+  const platform = process.platform;
+  if (platform !== 'darwin') {
+    log('Postinstall daemon setup skipped (not macOS).');
+    return;
+  }
+
+  const home = os.homedir();
+  const scriptsDir = path.join(home, 'Documents', 'MidiShellCommands');
+  try {
+    fs.mkdirSync(scriptsDir, { recursive: true });
+    // Add a sample README the first time, without overwriting user files.
+    const readmePath = path.join(scriptsDir, 'README.txt');
+    if (!fs.existsSync(readmePath)) {
+      fs.writeFileSync(readmePath, 'Place executable scripts here. Names should match patterns like:\nnoteon.<note>\nnoteon.<note>.<channel>\nnoteon.<note>.<channel>.<velocity>\nMake files executable (chmod +x).');
+    }
+  }
+  catch (e) {
+    log(`Failed to create scripts directory at ${scriptsDir}: ${e.message}`);
+    // Continue; LaunchAgent will still start and the app will create it on run.
+  }
+
+  // Determine bin path where npm linked the CLI
+  const npmPrefix = process.env.npm_config_prefix || '';
+  let binPath = '';
+  if (npmPrefix) {
+    // Typical global install
+    binPath = path.join(npmPrefix, 'bin', 'midi-shell-commands');
+  }
+  if (!binPath || !fs.existsSync(binPath)) {
+    // Fallback to local project binary path
+    binPath = path.join(process.cwd(), 'midi-shell-commands.js');
+  }
+
+  const launchAgentsDir = path.join(home, 'Library', 'LaunchAgents');
+  const label = 'com.midi-shell-commands';
+  const plistPath = path.join(launchAgentsDir, `${label}.plist`);
+
+  try {
+    fs.mkdirSync(launchAgentsDir, { recursive: true });
+  }
+  catch (e) {
+    log(`Failed to ensure LaunchAgents directory: ${e.message}`);
+    return;
+  }
+
+  const stdoutPath = path.join(home, 'Library', 'Logs', 'midi-shell-commands.stdout.log');
+  const stderrPath = path.join(home, 'Library', 'Logs', 'midi-shell-commands.stderr.log');
+
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+  <dict>
+    <key>Label</key>
+    <string>${label}</string>
+    <key>ProgramArguments</key>
+    <array>
+      <string>${binPath}</string>
+      <string>${scriptsDir}</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <key>StandardOutPath</key>
+    <string>${stdoutPath}</string>
+    <key>StandardErrorPath</key>
+    <string>${stderrPath}</string>
+    <key>EnvironmentVariables</key>
+    <dict>
+      <key>PATH</key>
+      <string>/usr/local/bin:/usr/local/sbin:/usr/bin:/bin:/usr/sbin:/sbin</string>
+    </dict>
+  </dict>
+</plist>`;
+
+  try {
+    fs.writeFileSync(plistPath, plist, { encoding: 'utf8' });
+    log(`Installed LaunchAgent at ${plistPath}`);
+  }
+  catch (e) {
+    log(`Failed to write LaunchAgent plist: ${e.message}`);
+    return;
+  }
+
+  // Try to (re)load the LaunchAgent so it starts now
+  try {
+    if (process.env.SUDO_UID) {
+      // Avoid trying to load as root for a user agent
+      log('Skipping launchctl load because running under sudo. You can load it later with your user session.');
+      return;
+    }
+
+    // Unload if already loaded to pick up updates
+    try {
+      childProcess.execSync(`launchctl unload ${escapePath(plistPath)}`, { stdio: 'ignore' });
+    }
+    catch {
+      // Unload failed, proceed forward.
+    }
+
+    // Preferred modern approach: bootstrap into the current user session
+    const uid = process.getuid && process.getuid();
+    if (uid) {
+      try {
+        childProcess.execSync(`launchctl bootstrap gui/${uid} ${escapePath(plistPath)}`, { stdio: 'ignore' });
+        log('LaunchAgent bootstrapped.');
+        return;
+      }
+      catch {
+        console.log('Current user session bootstrap failed, falling back to legacy load.');
+      }
+    }
+
+    // Fallback to legacy load
+    childProcess.execSync(`launchctl load -w ${escapePath(plistPath)}`, { stdio: 'ignore' });
+    log('LaunchAgent loaded.');
+  }
+  catch (e) {
+    log(`Could not load LaunchAgent automatically: ${e.message}\nYou can load it manually with:\n  launchctl load -w ${plistPath}`);
+  }
+})();
+

package/lib/refresh-scripts.js

@@ -0,0 +1,13 @@
+import fs from 'node:fs';
+import { state } from './state.js';
+
+export function refreshScripts() {
+  try {
+    state.scripts = fs.readdirSync(state.watchDir).filter(f => f[0] !== '.');
+    state.scriptsWithoutExtension = state.scripts.map(script => script.split('.').slice(0, -1).join('.'));
+  }
+  catch (e) {
+    console.error('Failed to read scripts directory:', state.watchDir);
+    console.error(e);
+  }
+}

package/lib/report-errors.js

@@ -0,0 +1,5 @@
+export function reportErrors(err) {
+  if (err) {
+    console.error(err);
+  }
+}

package/lib/state.js

@@ -0,0 +1,7 @@
+export const state = {
+  scripts: [],
+  scriptsWithoutExtension: [],
+  watchedInputs: {},
+  watchDir: undefined,
+  watcher: undefined,
+};

package/midi-shell-commands.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import { initializeMidi } from './lib/initialize-midi.js';
+import { initializeScriptsDirectory } from './lib/initialize-scripts-directory.js';
+import { log } from './lib/log.js';
+
+log('Starting up!');
+initializeScriptsDirectory();
+initializeMidi();

package/package.json

@@ -1,19 +1,39 @@
 {
   "name": "midi-shell-commands",
-  "version": "1.0.0",
-  "main": "index.js",
-  "bin": {
-    "midi-shell-commands": "index.js"
-  },
+  "version": "1.1.2",
+  "author": "Dawson Toth",
+  "repository": "https://github.com/dawsontoth/midi-shell-commands.git",
   "scripts": {
-    "start": "node index.js ./scripts",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "start": "node midi-shell-commands.js ./scripts",
+    "postinstall": "node lib/post-install.js",
+    "test": "vitest",
+    "test:ci": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix"
   },
+  "description": "Execute shell scripts on MIDI note events; supports macOS daemon mode via LaunchAgent.",
+  "type": "module",
   "keywords": [],
-  "author": "",
+  "main": "midi-shell-commands.js",
+  "bin": {
+    "midi-shell-commands": "midi-shell-commands.js"
+  },
   "license": "ISC",
-  "description": "",
   "dependencies": {
     "easymidi": "^3.1.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.36.0",
+    "@semantic-release/commit-analyzer": "^13.0.1",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^11.0.6",
+    "@semantic-release/npm": "^12.0.2",
+    "@semantic-release/release-notes-generator": "^14.1.0",
+    "@vitest/coverage-v8": "^3.0.0",
+    "eslint": "^9.36.0",
+    "globals": "^16.4.0",
+    "semantic-release": "^24.2.9",
+    "vitest": "^3.0.0"
   }
 }

package/renovate.json

@@ -0,0 +1,26 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": [
+    "config:recommended"
+  ],
+  "lockFileMaintenance": {
+    "enabled": true,
+    "automerge": true
+  },
+  "packageRules": [
+    {
+      "matchDepTypes": [
+        "action"
+      ],
+      "pinDigests": true
+    },
+    {
+      "matchUpdateTypes": [
+        "minor",
+        "patch"
+      ],
+      "matchCurrentVersion": "!/^0/",
+      "automerge": true
+    }
+  ]
+}

package/index.js

@@ -1,67 +0,0 @@
-#!/usr/bin/env node
-const childProcess = require('child_process');
-const easyMIDI = require('easymidi');
-const fs = require('fs');
-const path = require('path');
-
-if (process.argv.length === 2) {
-  console.error('Please pass the path to the directory containing your scripts.');
-  process.exit(1);
-}
-
-const watchDir = path.resolve(process.argv[process.argv.length - 1]);
-const scripts = fs.readdirSync(watchDir).filter(f => f[0] !== '.');
-const scriptsWithoutExtension = scripts.map(script => script.split('.').slice(0, -1).join('.'));
-const checkDelay = 60 * 1000 + (Math.random() * 3000) | 0;
-
-const watchedInputs = {};
-checkInputs();
-setInterval(checkInputs, checkDelay);
-
-function checkInputs() {
-  const inputNames = easyMIDI.getInputs();
-  for (const inputName of inputNames) {
-    listenToInput(inputName);
-  }
-}
-
-function listenToInput(inputName) {
-  if (watchedInputs[inputName]) {
-    return;
-  }
-  const input = watchedInputs[inputName] = new easyMIDI.Input(inputName);
-  input.on('noteon', invokeScripts);
-  input.on('noteoff', invokeScripts);
-}
-
-function invokeScripts(msg) {
-  const possibleFileNames = mapMessageToFileNames(msg);
-  for (const possibleFileName of possibleFileNames) {
-    for (let i = 0; i < scriptsWithoutExtension.length; i++) {
-      if (scriptsWithoutExtension[i] === possibleFileName) {
-        console.log('Executing ' + scripts[i]);
-        childProcess.exec(`./${scripts[i]}`, { cwd: watchDir }, reportErrors);
-      }
-    }
-  }
-}
-
-function mapMessageToFileNames(msg) {
-  return [
-    `${msg._type}.${msg.note}.${msg.channel}.${msg.velocity}`,
-    `${msg._type}.${msg.note}.${msg.channel}`,
-    `${msg._type}.${msg.note}`,
-  ];
-}
-
-function reportErrors(err) {
-  if (err) {
-    console.error(err);
-  }
-}
-
-process.on('exit', () => {
-  for (const input of Object.values(watchedInputs)) {
-    input.close();
-  }
-});