artnet2usb-cli 0.2.0

package/dist-cli/cli/index.js

@@ -0,0 +1,422 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const store_1 = require("../shared/store");
+const configDir_1 = require("./configDir");
+const bridge_1 = require("./bridge");
+const artnet_1 = require("../app/artnet");
+const dmxOutput_1 = require("../app/dmxOutput");
+const autoRoute_1 = require("./autoRoute");
+const doctor_1 = require("./doctor");
+const routeCommands_1 = require("./routeCommands");
+const serviceInstall_1 = require("./serviceInstall");
+function ts() {
+    return new Date().toISOString().slice(11, 19);
+}
+async function listPorts() {
+    const engine = new dmxOutput_1.DmxOutputEngine(() => null, () => ({ onSignalLoss: 'hold', signalLossMs: 3000 }));
+    const devices = await engine.listDevices();
+    if (devices.length === 0) {
+        console.log('No USB serial devices found.');
+        return;
+    }
+    console.log(`${devices.length} device(s) found:\n`);
+    for (const d of devices) {
+        const extra = [d.manufacturer, d.serialNumber ? `SN:${d.serialNumber}` : null].filter(Boolean).join(', ');
+        console.log(`  ${d.path}  (uid: ${d.uid})${extra ? `  — ${extra}` : ''}`);
+    }
+}
+function statusLine(nowTs, r, status, json) {
+    if (json) {
+        return JSON.stringify({
+            ts: nowTs,
+            type: 'status',
+            routeId: r.id,
+            universe: r.universe,
+            deviceUid: r.deviceUid,
+            protocol: r.protocol,
+            hz: r.hz,
+            active: status.active,
+            error: status.error,
+            framesSent: status.framesSent,
+            frozen: status.frozen
+        });
+    }
+    const line = status.active
+        ? `OK — ${status.framesSent} frames sent${status.frozen ? ' (frozen)' : ''}`
+        : `ERROR: ${status.error ?? 'device not connected'}`;
+    return `[${nowTs}] universe ${r.universe} -> ${r.deviceUid} (${r.protocol}, ${r.hz}Hz): ${line}`;
+}
+async function runBridge(configDir, opts = {}) {
+    const store = new store_1.Store(configDir);
+    if (store.routes.length === 0) {
+        if (opts.json)
+            console.log(JSON.stringify({ ts: ts(), type: 'error', message: 'no_routes_configured' }));
+        else
+            console.log('No routes configured. Run `artnet2usb-cli configure` first.');
+        return;
+    }
+    if (opts.json) {
+        console.log(JSON.stringify({ ts: ts(), type: 'startup', configDir }));
+    }
+    else {
+        console.log(`[${ts()}] config: ${configDir}`);
+        console.log(`[${ts()}] starting bridge...`);
+    }
+    const bridge = await (0, bridge_1.startBridge)(store);
+    const enabled = store.routes.filter((r) => r.enabled);
+    if (opts.json)
+        console.log(JSON.stringify({ ts: ts(), type: 'summary', enabled: enabled.length, total: store.routes.length }));
+    else
+        console.log(`[${ts()}] ${enabled.length}/${store.routes.length} route(s) enabled.`);
+    const statusInterval = setInterval(() => {
+        for (const r of store.routes) {
+            if (!r.enabled)
+                continue;
+            console.log(statusLine(ts(), r, bridge.engine.statusOf(r), opts.json));
+        }
+    }, 2000);
+    let shuttingDown = false;
+    const shutdown = async () => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        clearInterval(statusInterval);
+        if (opts.json)
+            console.log(JSON.stringify({ ts: ts(), type: 'shutdown' }));
+        else
+            console.log(`\n[${ts()}] shutting down...`);
+        await bridge.shutdown();
+        process.exit(0);
+    };
+    process.on('SIGINT', () => void shutdown());
+    process.on('SIGTERM', () => void shutdown());
+    // The setInterval + open UDP socket keep the process alive — it waits until Ctrl+C/SIGTERM.
+}
+async function runAuto(configDir, opts) {
+    const store = new store_1.Store(configDir);
+    const listener = new artnet_1.ArtNetListener();
+    listener.start();
+    await new Promise((r) => setTimeout(r, 3000));
+    const universes = listener.list();
+    listener.stop();
+    const engine = new dmxOutput_1.DmxOutputEngine(() => null, () => store.settings);
+    const devices = await engine.listDevices();
+    const result = (0, autoRoute_1.pickAutoRoute)(universes, devices);
+    if ('error' in result) {
+        console.error(result.error);
+        process.exitCode = 1;
+        return;
+    }
+    const existing = store.routes.find((r) => r.id === 'auto');
+    const { protocol, hz, channelOffset } = (0, autoRoute_1.resolveAutoRouteFields)(existing, opts);
+    store.upsertRoute({
+        id: 'auto',
+        universe: result.universe,
+        deviceUid: result.deviceUid,
+        protocol,
+        hz,
+        channelOffset,
+        enabled: true
+    });
+    console.log(`Route saved: universe ${result.universe} -> ${result.deviceUid} (${protocol}, ${hz}Hz${channelOffset ? `, offset ${channelOffset > 0 ? '+' : ''}${channelOffset}` : ''})`);
+    if (opts.start)
+        await runBridge(configDir, { json: opts.json });
+}
+async function listNodes() {
+    const listener = new artnet_1.ArtNetListener();
+    listener.start();
+    await new Promise((r) => setTimeout(r, 3000));
+    const nodes = listener.listNodes();
+    listener.stop();
+    if (nodes.length === 0) {
+        console.log('No Art-Net nodes found (listened for 3s).');
+        return;
+    }
+    console.log(`${nodes.length} node(s) found:\n`);
+    for (const n of nodes) {
+        console.log(`  ${n.ip}  ${n.shortName}${n.longName && n.longName !== n.shortName ? ` — ${n.longName}` : ''}`);
+    }
+}
+async function promptManualUniverse(clack) {
+    const v = await clack.text({
+        message: 'Universe number (0-32767)',
+        validate: (s) => {
+            const n = Number(s);
+            return Number.isInteger(n) && n >= 0 && n <= 32767 ? undefined : 'Enter a valid universe number';
+        }
+    });
+    if (clack.isCancel(v))
+        return undefined;
+    return Number(v);
+}
+async function addRouteFlow(clack, store) {
+    const listener = new artnet_1.ArtNetListener();
+    const sp = clack.spinner();
+    sp.start('Listening for Art-Net traffic (3s)...');
+    listener.start();
+    await new Promise((r) => setTimeout(r, 3000));
+    const seen = listener.list();
+    listener.stop();
+    sp.stop(`${seen.length} universe(s) detected.`);
+    let universe;
+    if (seen.length > 0) {
+        const picked = await clack.select({
+            message: 'Select a universe',
+            options: [
+                ...seen.map((u) => ({ value: u.universe, label: `Universe ${u.universe}`, hint: `${u.fps}fps, ${u.sourceIp}` })),
+                { value: -1, label: 'Enter manually...' }
+            ]
+        });
+        if (clack.isCancel(picked))
+            return;
+        universe = picked === -1 ? await promptManualUniverse(clack) : picked;
+    }
+    else {
+        universe = await promptManualUniverse(clack);
+    }
+    if (universe == null)
+        return;
+    const engine = new dmxOutput_1.DmxOutputEngine(() => null, () => store.settings);
+    const sp2 = clack.spinner();
+    sp2.start('Scanning USB devices...');
+    const devices = await engine.listDevices();
+    sp2.stop(`${devices.length} device(s) found.`);
+    if (devices.length === 0) {
+        clack.log.error('No USB serial device found — connect your DMX interface and try again.');
+        return;
+    }
+    const deviceUid = await clack.select({
+        message: 'Select a device',
+        options: devices.map((d) => ({ value: d.uid, label: store.deviceNames[d.uid] ?? d.path, hint: d.manufacturer }))
+    });
+    if (clack.isCancel(deviceUid))
+        return;
+    const protocol = await clack.select({
+        message: 'Protocol',
+        options: [
+            { value: 'enttec-pro', label: 'Enttec DMX USB Pro' },
+            { value: 'open-dmx', label: 'Open DMX (raw FTDI)' }
+        ]
+    });
+    if (clack.isCancel(protocol))
+        return;
+    const hzStr = await clack.text({
+        message: 'Output rate (Hz, 1-44)',
+        initialValue: '40',
+        validate: (v) => {
+            const n = Number(v);
+            return Number.isInteger(n) && n >= 1 && n <= 44 ? undefined : 'Enter an integer between 1 and 44';
+        }
+    });
+    if (clack.isCancel(hzStr))
+        return;
+    const channelOffsetStr = await clack.text({
+        message: 'Channel start (patch) offset, -511 to 511 (rotates circularly — no data is dropped)',
+        initialValue: '0',
+        validate: (v) => {
+            const n = Number(v);
+            return Number.isInteger(n) && n >= -511 && n <= 511 ? undefined : 'Enter an integer between -511 and 511';
+        }
+    });
+    if (clack.isCancel(channelOffsetStr))
+        return;
+    store.upsertRoute({
+        id: `route-${Date.now()}`,
+        universe,
+        deviceUid: deviceUid,
+        protocol: protocol,
+        hz: Number(hzStr),
+        channelOffset: Number(channelOffsetStr),
+        enabled: true
+    });
+    clack.log.success('Route saved.');
+}
+async function removeRouteFlow(clack, store) {
+    const id = await clack.select({
+        message: 'Select a route to remove',
+        options: store.routes.map((r) => ({ value: r.id, label: `universe ${r.universe} -> ${r.deviceUid}` }))
+    });
+    if (clack.isCancel(id))
+        return;
+    store.removeRoute(id);
+    clack.log.success('Route removed.');
+}
+async function runConfigure(clack, configDir) {
+    clack.intro('artnet2usb-cli — configure');
+    const store = new store_1.Store(configDir);
+    for (;;) {
+        const routes = store.routes;
+        if (routes.length > 0) {
+            clack.log.info(`Current routes:\n${routes
+                .map((r) => `  ${r.enabled ? '●' : '○'} universe ${r.universe} -> ${r.deviceUid} (${r.protocol}, ${r.hz}Hz${r.channelOffset ? `, offset ${r.channelOffset > 0 ? '+' : ''}${r.channelOffset}` : ''})`)
+                .join('\n')}`);
+        }
+        else {
+            clack.log.info('No routes configured yet.');
+        }
+        const action = await clack.select({
+            message: 'What would you like to do?',
+            options: [
+                { value: 'add', label: 'Add a route' },
+                ...(routes.length > 0 ? [{ value: 'remove', label: 'Remove a route' }] : []),
+                ...(routes.length > 0 ? [{ value: 'start', label: 'Start routes and exit' }] : []),
+                { value: 'exit', label: 'Exit (keep saved, do not start)' }
+            ]
+        });
+        if (clack.isCancel(action) || action === 'exit')
+            break;
+        if (action === 'add')
+            await addRouteFlow(clack, store);
+        if (action === 'remove')
+            await removeRouteFlow(clack, store);
+        if (action === 'start') {
+            clack.outro('Starting routes — press Ctrl+C to stop.');
+            await runBridge(configDir);
+            return;
+        }
+    }
+    clack.outro('Bye!');
+}
+async function main() {
+    const { Command } = (await Promise.resolve().then(() => __importStar(require('commander'))));
+    const clack = (await Promise.resolve().then(() => __importStar(require('@clack/prompts'))));
+    // Running with no arguments → go straight to the interactive wizard (the simplest and
+    // most predictable approach, instead of dealing with commander's "default command" setup).
+    if (process.argv.length <= 2) {
+        await runConfigure(clack, (0, configDir_1.resolveConfigDir)());
+        return;
+    }
+    const program = new Command();
+    program
+        .name('artnet2usb-cli')
+        .description('Headless Art-Net -> USB DMX bridge (shares config with the desktop app)')
+        .version('0.2.0');
+    program
+        .command('list-ports')
+        .description('List connected USB serial devices')
+        .action(async () => {
+        await listPorts();
+    });
+    program
+        .command('run')
+        .description('Start the bridge using saved routes and run until stopped (Ctrl+C)')
+        .option('--config <dir>', 'Config directory override (default: shared with the desktop app)')
+        .option('--json', 'Emit newline-delimited JSON status instead of human-readable text')
+        .action(async (opts) => {
+        await runBridge(opts.config ?? (0, configDir_1.resolveConfigDir)(), { json: opts.json });
+    });
+    program
+        .command('configure')
+        .description('Interactively add/remove routes (terminal wizard)')
+        .option('--config <dir>', 'Config directory override (default: shared with the desktop app)')
+        .action(async (opts) => {
+        await runConfigure(clack, opts.config ?? (0, configDir_1.resolveConfigDir)());
+    });
+    program
+        .command('auto')
+        .description('Auto-detect a single Art-Net universe and USB device, save the route, and start it (unless --no-start)')
+        .option('--protocol <protocol>', 'enttec-pro or open-dmx', 'open-dmx')
+        .option('--hz <hz>', 'Output rate in Hz (1-44)', '40')
+        .option('--channel-offset <n>', 'Channel start (patch) offset, -511 to 511. Rotates the universe circularly — no data is dropped, channels that fall off one end wrap to the other.', '0')
+        .option('--config <dir>', 'Config directory override (default: shared with the desktop app)')
+        .option('--no-start', 'Only detect and save the route, do not start the bridge')
+        .option('--json', 'Emit newline-delimited JSON status instead of human-readable text')
+        .action(async (opts, command) => {
+        const protocol = opts.protocol;
+        if (protocol !== 'enttec-pro' && protocol !== 'open-dmx') {
+            console.error(`Invalid --protocol: ${opts.protocol} (expected enttec-pro or open-dmx)`);
+            process.exitCode = 1;
+            return;
+        }
+        const hz = Number(opts.hz);
+        if (!Number.isInteger(hz) || hz < 1 || hz > 44) {
+            console.error(`Invalid --hz: ${opts.hz} (expected an integer between 1 and 44)`);
+            process.exitCode = 1;
+            return;
+        }
+        const channelOffset = Number(opts.channelOffset);
+        if (!Number.isInteger(channelOffset) || channelOffset < -511 || channelOffset > 511) {
+            console.error(`Invalid --channel-offset: ${opts.channelOffset} (expected an integer between -511 and 511)`);
+            process.exitCode = 1;
+            return;
+        }
+        // If the flag was not explicitly passed (only commander's default applied), undefined is passed through —
+        // in that case runAuto() preserves the existing "auto" route's value (see the runAuto comment).
+        const explicit = (key) => command.getOptionValueSource(key) === 'cli';
+        await runAuto(opts.config ?? (0, configDir_1.resolveConfigDir)(), {
+            protocol: explicit('protocol') ? protocol : undefined,
+            hz: explicit('hz') ? hz : undefined,
+            channelOffset: explicit('channelOffset') ? channelOffset : undefined,
+            start: opts.start,
+            json: opts.json
+        });
+    });
+    program
+        .command('doctor')
+        .description('Check the saved config for common problems (disconnected devices, conflicting routes)')
+        .option('--config <dir>', 'Config directory override (default: shared with the desktop app)')
+        .action(async (opts) => {
+        const configDir = opts.config ?? (0, configDir_1.resolveConfigDir)();
+        const store = new store_1.Store(configDir);
+        const engine = new dmxOutput_1.DmxOutputEngine(() => null, () => store.settings);
+        const devices = await engine.listDevices();
+        const issues = (0, doctor_1.runDoctorChecks)(store.routes, devices);
+        console.log(`config: ${configDir}`);
+        console.log(`${store.routes.length} route(s), ${store.routes.filter((r) => r.enabled).length} enabled.`);
+        if (issues.length === 0) {
+            console.log('No issues found.');
+            return;
+        }
+        for (const issue of issues)
+            console.log(`  ${issue.level === 'error' ? '✗' : '⚠'} ${issue.message}`);
+        if (issues.some((i) => i.level === 'error'))
+            process.exitCode = 1;
+    });
+    program
+        .command('list-nodes')
+        .description('Listen for Art-Net nodes on the network (~3s) and list them')
+        .action(async () => {
+        await listNodes();
+    });
+    (0, routeCommands_1.registerRouteCommands)(program);
+    (0, serviceInstall_1.registerServiceCommands)(program);
+    await program.parseAsync(process.argv);
+}
+main().catch((err) => {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+});

package/dist-cli/cli/routeCommands.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerRouteCommands = registerRouteCommands;
+const store_1 = require("../shared/store");
+const configDir_1 = require("./configDir");
+function formatRoute(r) {
+    const offset = r.channelOffset ? `, offset ${r.channelOffset > 0 ? '+' : ''}${r.channelOffset}` : '';
+    return `  ${r.enabled ? '●' : '○'} [${r.id}] universe ${r.universe} -> ${r.deviceUid} (${r.protocol}, ${r.hz}Hz${offset})`;
+}
+/**
+ * `route add/list/remove` — lets you bulk-provision routes via a script
+ * (Ansible/shell), bypassing the configure wizard. Reads/writes the same
+ * config.json shared with the GUI (via shared/store.ts).
+ */
+function registerRouteCommands(program) {
+    const route = program.command('route').description('Manage routes non-interactively (scriptable)');
+    route
+        .command('add')
+        .description('Add or update a route')
+        .requiredOption('--universe <n>', 'Art-Net universe number (0-32767)')
+        .requiredOption('--device <uid>', 'Target device uid (see list-ports)')
+        .option('--protocol <protocol>', 'enttec-pro or open-dmx', 'open-dmx')
+        .option('--hz <hz>', 'Output rate in Hz (1-44)', '40')
+        .option('--channel-offset <n>', 'Channel start (patch) offset, -511 to 511. Rotates the universe circularly — no data is dropped, channels that fall off one end wrap to the other.', '0')
+        .option('--disabled', 'Save the route disabled (not started automatically)')
+        .option('--id <id>', 'Route id — reuses/updates an existing route if it already exists')
+        .option('--config <dir>', 'Config directory override (default: shared with the desktop app)')
+        .action((opts) => {
+        const universe = Number(opts.universe);
+        if (!Number.isInteger(universe) || universe < 0 || universe > 32767) {
+            console.error(`Invalid --universe: ${opts.universe}`);
+            process.exitCode = 1;
+            return;
+        }
+        const hz = Number(opts.hz);
+        if (!Number.isInteger(hz) || hz < 1 || hz > 44) {
+            console.error(`Invalid --hz: ${opts.hz}`);
+            process.exitCode = 1;
+            return;
+        }
+        const channelOffset = Number(opts.channelOffset);
+        if (!Number.isInteger(channelOffset) || channelOffset < -511 || channelOffset > 511) {
+            console.error(`Invalid --channel-offset: ${opts.channelOffset} (expected an integer between -511 and 511)`);
+            process.exitCode = 1;
+            return;
+        }
+        const protocol = opts.protocol;
+        if (protocol !== 'enttec-pro' && protocol !== 'open-dmx') {
+            console.error(`Invalid --protocol: ${opts.protocol} (expected enttec-pro or open-dmx)`);
+            process.exitCode = 1;
+            return;
+        }
+        const store = new store_1.Store(opts.config ?? (0, configDir_1.resolveConfigDir)());
+        const id = opts.id ?? `route-${Date.now()}`;
+        store.upsertRoute({ id, universe, deviceUid: opts.device, protocol, hz, channelOffset, enabled: !opts.disabled });
+        console.log(`Saved route "${id}".`);
+    });
+    route
+        .command('list')
+        .description('List saved routes')
+        .option('--config <dir>', 'Config directory override (default: shared with the desktop app)')
+        .action((opts) => {
+        const store = new store_1.Store(opts.config ?? (0, configDir_1.resolveConfigDir)());
+        if (store.routes.length === 0) {
+            console.log('No routes configured.');
+            return;
+        }
+        for (const r of store.routes)
+            console.log(formatRoute(r));
+    });
+    route
+        .command('remove <id>')
+        .description('Remove a saved route by id')
+        .option('--config <dir>', 'Config directory override (default: shared with the desktop app)')
+        .action((id, opts) => {
+        const store = new store_1.Store(opts.config ?? (0, configDir_1.resolveConfigDir)());
+        store.removeRoute(id);
+        console.log(`Removed route "${id}" (if it existed).`);
+    });
+}

package/dist-cli/cli/serviceInstall.js

@@ -0,0 +1,181 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildLaunchdPlist = buildLaunchdPlist;
+exports.buildSystemdUnit = buildSystemdUnit;
+exports.registerServiceCommands = registerServiceCommands;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const portableConfig_1 = require("../shared/portableConfig");
+function escapeXml(s) {
+    return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}
+function quoteShellArg(s) {
+    return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+/** macOS LaunchAgent — user-level, does not require sudo. (Pure — testable.) */
+function buildLaunchdPlist(opts) {
+    const argsXml = [...(opts.scriptPath ? [opts.scriptPath] : []), ...opts.args]
+        .map((a) => `    <string>${escapeXml(a)}</string>`)
+        .join('\n');
+    return `<?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>${escapeXml(opts.label)}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${escapeXml(opts.nodePath)}</string>
+${argsXml}
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>/tmp/${escapeXml(opts.label)}.log</string>
+  <key>StandardErrorPath</key>
+  <string>/tmp/${escapeXml(opts.label)}.err.log</string>
+</dict>
+</plist>
+`;
+}
+/** Linux systemd system unit — starts automatically on boot/after a crash, requires sudo. (Pure — testable.) */
+function buildSystemdUnit(opts) {
+    const execArgs = [...(opts.scriptPath ? [opts.scriptPath] : []), ...opts.args].map(quoteShellArg).join(' ');
+    return `[Unit]
+Description=${opts.label}
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+User=${opts.user}
+ExecStart=${quoteShellArg(opts.nodePath)} ${execArgs}
+Restart=always
+RestartSec=3
+
+[Install]
+WantedBy=multi-user.target
+`;
+}
+const LABEL = 'tech.remana.relackout.artnet2usb-cli';
+const SYSTEMD_UNIT_PATH = '/etc/systemd/system/artnet2usb-cli.service';
+/**
+ * Writing to /etc/systemd/system on Linux almost always requires sudo —
+ * in that case os.userInfo().username returns 'root', so the service would be
+ * generated as root by mistake. `sudo` leaves the real invoking user in
+ * SUDO_USER; use it when present (systemd's User= field should be this user).
+ */
+function resolveInvokingUser() {
+    const sudoUser = process.env.SUDO_USER;
+    return sudoUser && sudoUser !== 'root' ? sudoUser : node_os_1.default.userInfo().username;
+}
+function launchdPlistPath() {
+    return node_path_1.default.join(node_os_1.default.homedir(), 'Library', 'LaunchAgents', `${LABEL}.plist`);
+}
+/**
+ * `install-service` / `uninstall-service` — sets up a background service that
+ * starts automatically on boot/after a crash. Since this is a persistent
+ * system change, the command writes/removes the service DEFINITION FILE but
+ * does NOT itself run `launchctl load` / `systemctl enable --now` — it prints
+ * the final activation step to the user as a copy-paste command.
+ */
+function registerServiceCommands(program) {
+    program
+        .command('install-service')
+        .description('Generate an autostart service definition (prints the command to enable it — does not run it)')
+        .option('--command <cmd>', 'Which CLI command the service runs: auto or run', 'auto')
+        .option('--config <dir>', 'Config directory to pass to the service (default: shared with the desktop app)')
+        .action((opts) => {
+        if (opts.command !== 'auto' && opts.command !== 'run') {
+            console.error(`Invalid --command: ${opts.command} (expected "auto" or "run")`);
+            process.exitCode = 1;
+            return;
+        }
+        // In the compiled single-file binary, execPath is the CLI itself; argv[1]
+        // points to a virtual path inside the snapshot and must not be written to the service.
+        const scriptPath = (0, portableConfig_1.isCompiledBinary)() ? null : node_path_1.default.resolve(process.argv[1]);
+        const args = [opts.command, ...(opts.config ? ['--config', opts.config] : [])];
+        const serviceOpts = {
+            nodePath: process.execPath,
+            scriptPath,
+            args,
+            user: resolveInvokingUser(),
+            label: LABEL
+        };
+        if (process.platform === 'darwin') {
+            const file = launchdPlistPath();
+            node_fs_1.default.mkdirSync(node_path_1.default.dirname(file), { recursive: true });
+            node_fs_1.default.writeFileSync(file, buildLaunchdPlist(serviceOpts));
+            console.log(`Wrote ${file}`);
+            console.log('To enable and start it now, run:');
+            console.log(`  launchctl load -w "${file}"`);
+            console.log('To check status:');
+            console.log(`  launchctl list | grep ${LABEL}`);
+        }
+        else if (process.platform === 'linux') {
+            try {
+                node_fs_1.default.writeFileSync(SYSTEMD_UNIT_PATH, buildSystemdUnit(serviceOpts));
+            }
+            catch (err) {
+                console.error(`Could not write ${SYSTEMD_UNIT_PATH}: ${err instanceof Error ? err.message : String(err)}`);
+                console.error('Re-run with sudo (e.g. `sudo artnet2usb-cli install-service`).');
+                process.exitCode = 1;
+                return;
+            }
+            console.log(`Wrote ${SYSTEMD_UNIT_PATH}`);
+            console.log('To enable and start it now, run:');
+            console.log('  sudo systemctl daemon-reload');
+            console.log('  sudo systemctl enable --now artnet2usb-cli');
+        }
+        else {
+            console.error(`install-service is not supported on ${process.platform} yet.`);
+            process.exitCode = 1;
+        }
+    });
+    program
+        .command('uninstall-service')
+        .description('Remove the installed service definition (prints the command to disable it first)')
+        .action(() => {
+        if (process.platform === 'darwin') {
+            const file = launchdPlistPath();
+            console.log('Before removing, unload it:');
+            console.log(`  launchctl unload -w "${file}"`);
+            if (node_fs_1.default.existsSync(file)) {
+                node_fs_1.default.rmSync(file);
+                console.log(`Removed ${file}`);
+            }
+            else {
+                console.log('No service file found.');
+            }
+        }
+        else if (process.platform === 'linux') {
+            console.log('Before removing, disable it:');
+            console.log('  sudo systemctl disable --now artnet2usb-cli');
+            if (node_fs_1.default.existsSync(SYSTEMD_UNIT_PATH)) {
+                try {
+                    node_fs_1.default.rmSync(SYSTEMD_UNIT_PATH);
+                    console.log(`Removed ${SYSTEMD_UNIT_PATH}`);
+                    console.log('Then run: sudo systemctl daemon-reload');
+                }
+                catch (err) {
+                    console.error(`Could not remove ${SYSTEMD_UNIT_PATH}: ${err instanceof Error ? err.message : String(err)}`);
+                    console.error('Re-run with sudo, or remove it manually.');
+                    process.exitCode = 1;
+                }
+            }
+            else {
+                console.log('No service file found.');
+            }
+        }
+        else {
+            console.error(`uninstall-service is not supported on ${process.platform}.`);
+            process.exitCode = 1;
+        }
+    });
+}