teleportation-cli 1.4.0 → 1.4.1

package/lib/daemon/transcript-ingestion.js

@@ -7,9 +7,12 @@
  * @module lib/daemon/transcript-ingestion
  */
 
-import { readFile, readdir, writeFile, mkdir } from 'fs/promises';
+import { readFile, readdir, writeFile, mkdir, appendFile } from 'fs/promises';
 import { homedir, tmpdir } from 'os';
 import { join } from 'path';
+import { createHash } from 'node:crypto';
+import { sanitizeEventData } from '../utils/log-sanitizer.js';
+import { normalizeTranscriptEvents, normalizeTranscriptEntry } from '../intelligence/schema.js';
 
 // ============================================================================
 // Configuration Constants
@@ -131,6 +134,26 @@ const RETRY_BASE_DELAY_MS = 100;
  * Set TELEPORTATION_DEBUG=true to enable verbose logging to tmpdir()
  */
 const DEBUG = process.env.TELEPORTATION_DEBUG === 'true';
+const ENABLE_REMOTE_INTELLIGENCE_INGEST = process.env.TELEPORTATION_INTELLIGENCE_REMOTE_INGEST === 'true';
+const ENABLE_LOCAL_INTELLIGENCE_SPOOL = process.env.TELEPORTATION_INTELLIGENCE_LOCAL_SPOOL !== 'false';
+const INTELLIGENCE_SPOOL_DIR = join(tmpdir(), 'teleportation-intelligence');
+const INTELLIGENCE_BATCH_PATH = '/api/intelligence/transcripts/batch';
+
+/**
+ * Generate a deterministic UUID-formatted event ID from an input string and event index.
+ * Uses the same sha256 + UUID-dash format as stop.mjs for consistency, enabling
+ * server-side deduplication via ON CONFLICT (id) DO NOTHING.
+ *
+ * Format: 8-4-4-4-12 hex characters (matches stop.mjs deterministicEventId)
+ *
+ * @param {string} input - Unique input (msg UUID or session:msg:event composite key)
+ * @param {number} eventIndex - Event index within the message
+ * @returns {string} UUID-formatted hex string (36 characters with dashes)
+ */
+function deterministicEventId(input, eventIndex) {
+  const hash = createHash('sha256').update(`${input}:${eventIndex}`).digest('hex');
+  return [hash.slice(0, 8), hash.slice(8, 12), hash.slice(12, 16), hash.slice(16, 20), hash.slice(20, 32)].join('-');
+}
 
 /**
  * Local cursor directory for tracking last-processed transcript index.
@@ -279,6 +302,10 @@ async function pushEventsInChunks(events, relayApiUrl, apiKey, parent_session_id
           events: chunk.map(event => ({
             type: event.type,
             source: event.source,
+            // Top-level timestamp and id for relay batch endpoint
+            // (logTimelineEventsBatch accepts clientTimestamp and clientId)
+            timestamp: event.timestamp,
+            id: event.id || undefined,
             data: {
               ...event.meta,
               task_id,
@@ -318,11 +345,16 @@ async function pushEventsInChunks(events, relayApiUrl, apiKey, parent_session_id
               session_id: parent_session_id,
               type: event.type,
               source: event.source,
+              // Top-level timestamp and id kept for forward-compat; also inside data
+              // because relay's /api/timeline passes only `data` to logTimelineEvent()
+              timestamp: event.timestamp,
+              id: event.id || undefined,
               data: {
                 ...event.meta,
                 task_id,
                 claude_session_id,
                 timestamp: event.timestamp,
+                id: event.id || undefined,
               }
             })
           });
@@ -420,9 +452,10 @@ function parseTimestamp(entry) {
  * Supports both old format (message at root) and new format (message nested)
  * @param {Array} transcript - Transcript messages
  * @param {number} fromIndex - Start extracting from this index (to avoid duplicates)
- * @returns {Array} Timeline events to push
+ * @param {string} sessionId - Session ID for deterministic fallback IDs (when entry has no uuid)
+ * @returns {Array} Timeline events to push (each with deterministic `id` field)
  */
-function extractTimelineEvents(transcript, fromIndex = 0) {
+function extractTimelineEvents(transcript, fromIndex = 0, sessionId = '') {
   const events = [];
 
   console.log(`[transcript] extractTimelineEvents: processing ${transcript.length - fromIndex} messages from index ${fromIndex}`);
@@ -452,6 +485,13 @@ function extractTimelineEvents(transcript, fromIndex = 0) {
     const content = message.content;
     const timestamp = parseTimestamp(entry);
 
+    // Deterministic ID generation (Bug 3):
+    // Use entry.uuid (Claude Code transcript UUID) when available,
+    // fall back to entry.message.uuid, or a composite key from sessionId:messageIndex.
+    const msgUuid = entry.uuid || message.uuid || null;
+    const msgKey = msgUuid || `${sessionId}:${i}`;
+    let msgEventIndex = 0;
+
     // Extract assistant responses
     // Schema matches stop hook batch: data.message (canonical field name)
     if (role === 'assistant' && content) {
@@ -465,6 +505,7 @@ function extractTimelineEvents(transcript, fromIndex = 0) {
           type: 'assistant_response',
           source: 'cli_interactive',
           timestamp,
+          id: deterministicEventId(msgKey, msgEventIndex++),
           meta: {
             message: trimmedContent.slice(0, MAX_ASSISTANT_RESPONSE_LENGTH),
             full_length: trimmedContent.length,
@@ -487,6 +528,7 @@ function extractTimelineEvents(transcript, fromIndex = 0) {
           type: 'tool_use',
           source: 'cli_interactive',
           timestamp,
+          id: deterministicEventId(msgKey, msgEventIndex++),
           meta: {
             tool_name: toolUse.name,
             tool_use_id: toolUse.id,
@@ -517,6 +559,7 @@ function extractTimelineEvents(transcript, fromIndex = 0) {
           type: isError ? 'tool_failed' : 'tool_completed',
           source: 'cli_interactive',
           timestamp,
+          id: deterministicEventId(msgKey, msgEventIndex++),
           meta: {
             tool_use_id: toolResult.tool_use_id,
             tool_name: toolInfo?.name || null,
@@ -532,7 +575,29 @@ function extractTimelineEvents(transcript, fromIndex = 0) {
   }
 
   console.log(`[transcript] extractTimelineEvents: found ${events.length} events`);
-  return events;
+
+  // Sanitize all event meta to redact secrets (API keys, tokens, passwords, etc.)
+  return events.map(event => ({
+    ...event,
+    meta: sanitizeEventData(event.meta),
+  }));
+}
+
+/**
+ * Convert timeline events to canonical transcript intelligence events.
+ * Returns [] on normalization failures to preserve ingestion behavior.
+ *
+ * @param {Array} events - Raw timeline events from extractTimelineEvents
+ * @param {Object} context - Normalization context
+ * @returns {Array} Normalized intelligence events
+ */
+function normalizeTimelineEventsForIntelligence(events, context = {}) {
+  try {
+    return normalizeTranscriptEvents(events, context);
+  } catch (error) {
+    console.warn(`[transcript] Intelligence normalization failed: ${error.message}`);
+    return [];
+  }
 }
 
 /**
@@ -598,12 +663,13 @@ async function updateLastIngestedIndex(task_id, session_id, lastIndex, config) {
  * @param {string} options.task_id - Task ID (for event metadata)
  * @param {string} options.cwd - Working directory (to derive project slug)
  * @param {Object} options.config - Config with relayApiUrl, apiKey
+ * @param {Function} [options.onNormalizedEvents] - Optional callback for normalized intelligence events
  * @param {boolean} options.realTimeMode - If true, only process last 10 events (fast, for hooks)
  * @param {number} options.maxEvents - Maximum events to process (default: 100 for daemon, 10 for realTime)
  * @returns {Promise<Object>} Result { events_pushed: number }
  */
 export async function ingestTranscriptToTimeline(options) {
-  const { claude_session_id, parent_session_id, task_id, cwd, config, realTimeMode = false, maxEvents } = options;
+  const { claude_session_id, parent_session_id, task_id, cwd, config, onNormalizedEvents, realTimeMode = false, maxEvents } = options;
   const { relayApiUrl, apiKey } = config;
 
   // Determine max events based on mode
@@ -738,13 +804,29 @@ export async function ingestTranscriptToTimeline(options) {
   }
 
   // 3. Extract only NEW events from determined index
-  const allEvents = extractTimelineEvents(transcript, fromIndex);
+  const allEvents = extractTimelineEvents(transcript, fromIndex, parent_session_id);
 
   log(`Extracted ${allEvents.length} events from transcript`);
+
   if (allEvents.length === 0) {
     log(`No new events since index ${fromIndex} - returning`);
     console.log(`[transcript] No new events since index ${fromIndex} (transcript length: ${transcript.length})`);
-    return { events_pushed: 0 };
+    return { events_pushed: 0, normalized_events: 0 };
+  }
+
+  const normalizedEvents = normalizeTimelineEventsForIntelligence(allEvents, {
+    session_id: parent_session_id,
+    task_id,
+    provider: 'claude-code',
+  });
+
+  log(`Normalized ${normalizedEvents.length} intelligence events`);
+  if (typeof onNormalizedEvents === 'function') {
+    try {
+      await onNormalizedEvents(normalizedEvents);
+    } catch (error) {
+      log(`Failed to deliver normalized events: ${error.message}`);
+    }
   }
 
   // 4. Limit events to process (most recent N events)
@@ -787,7 +869,7 @@ export async function ingestTranscriptToTimeline(options) {
     }
   }
 
-  return { events_pushed: successCount, events_failed: failCount };
+  return { events_pushed: successCount, events_failed: failCount, normalized_events: normalizedEvents.length };
 }
 
 /**
@@ -801,4 +883,73 @@ export async function getTranscriptLength(claude_session_id) {
 }
 
 // Export internals for unit testing
-export { parseTimestamp, extractTimelineEvents, readCursor, writeCursor };
+/**
+ * Extract normalized transcript entries for the intelligence pipeline.
+ * Operates on raw transcript messages (not timeline events).
+ */
+function extractNormalizedTranscriptEntries(transcript, fromIndex = 0, sessionId = '', harness = 'claude-code') {
+  const normalized = [];
+  for (let i = fromIndex; i < transcript.length; i++) {
+    normalized.push(normalizeTranscriptEntry(transcript[i], {
+      sessionId,
+      messageIndex: i,
+      harness,
+    }));
+  }
+  return normalized;
+}
+
+function toSessionFilename(sessionId) {
+  const safe = typeof sessionId === 'string' && sessionId.trim()
+    ? sessionId.trim().replace(/[^a-zA-Z0-9._-]/g, '-')
+    : 'unknown-session';
+  return `${safe}.jsonl`;
+}
+
+/**
+ * Append normalized transcript entries to a local JSONL spool file.
+ * Enabled by default; disable with TELEPORTATION_INTELLIGENCE_LOCAL_SPOOL=false.
+ */
+async function appendLocalIntelligenceSpool(sessionId, entries, log = () => {}) {
+  if (!ENABLE_LOCAL_INTELLIGENCE_SPOOL || entries.length === 0) {
+    return { written: 0, skipped: true };
+  }
+  await mkdir(INTELLIGENCE_SPOOL_DIR, { recursive: true });
+  const filePath = join(INTELLIGENCE_SPOOL_DIR, toSessionFilename(sessionId));
+  const lines = entries.map(entry => JSON.stringify(entry)).join('\n') + '\n';
+  await appendFile(filePath, lines, 'utf8');
+  log(`Wrote ${entries.length} normalized entries to local spool: ${filePath}`);
+  return { written: entries.length, skipped: false, filePath };
+}
+
+/**
+ * Push normalized transcript entries to the relay intelligence endpoint.
+ * Off by default; enable with TELEPORTATION_INTELLIGENCE_REMOTE_INGEST=true.
+ */
+async function pushNormalizedEntriesRemote(entries, relayApiUrl, apiKey, sessionId, log = () => {}) {
+  if (!ENABLE_REMOTE_INTELLIGENCE_INGEST || entries.length === 0) {
+    return { pushed: 0, skipped: true };
+  }
+  try {
+    const response = await fetch(`${relayApiUrl}${INTELLIGENCE_BATCH_PATH}`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`,
+      },
+      body: JSON.stringify({ session_id: sessionId, entries }),
+    });
+    if (!response.ok) {
+      const body = await response.text().catch(() => '');
+      console.warn(`[transcript] Intelligence remote ingest failed: ${response.status} ${body}`);
+      return { pushed: 0, skipped: false, failed: true, status: response.status };
+    }
+    log(`Pushed ${entries.length} normalized entries to remote intelligence endpoint`);
+    return { pushed: entries.length, skipped: false };
+  } catch (error) {
+    console.warn(`[transcript] Intelligence remote ingest error: ${error.message}`);
+    return { pushed: 0, skipped: false, failed: true, error: error.message };
+  }
+}
+
+export { parseTimestamp, extractTimelineEvents, extractNormalizedTranscriptEntries, readCursor, writeCursor, pushEventsInChunks, deterministicEventId, normalizeTimelineEventsForIntelligence, appendLocalIntelligenceSpool, pushNormalizedEntriesRemote };

package/lib/daemon/utils.js

@@ -33,15 +33,6 @@ export function truncateOutput(output, label) {
   return output.slice(0, MAX_OUTPUT_SIZE) + `\n\n... (output truncated, total size: ${output.length} characters) ...`;
 }
 
-/**
- * Sanitize for log (remove sensitive info)
- */
-export function sanitizeForLog(data) {
-  if (!data) return data;
-  // Simple sanitization - in a real app, use a more robust library
-  return String(data).replace(/Bearer\s+[a-zA-Z0-9._-]+/g, 'Bearer [REDACTED]');
-}
-
 /**
  * Validation helpers
  */

package/lib/install/installer.js

@@ -10,6 +10,7 @@
  */
 
 import { copyFile, mkdir, chmod, readFile, writeFile, stat, readdir } from 'fs/promises';
+import { existsSync } from 'fs';
 import { join, dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
 import { homedir } from 'os';
@@ -79,6 +80,28 @@ export function checkClaudeCode() {
   };
 }
 
+/**
+ * Check if Cursor IDE is installed by detecting ~/.cursor directory or cursor binary
+ */
+export function checkCursorIde() {
+  const cursorDir = join(HOME_DIR, '.cursor');
+  if (existsSync(cursorDir)) {
+    return { valid: true, path: cursorDir };
+  }
+  try {
+    const cursorPath = execSync('which cursor', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+    if (cursorPath) {
+      return { valid: true, path: cursorPath };
+    }
+  } catch (e) {
+    // Cursor binary not found
+  }
+  return {
+    valid: false,
+    error: 'Cursor IDE not found. Install Cursor or ensure ~/.cursor directory exists.'
+  };
+}
+
 /**
  * Check if Gemini CLI is installed
  */
@@ -307,6 +330,88 @@ export async function installGeminiHooks(sourceGeminiHooksDir) {
   };
 }
 
+/**
+ * Install Teleportation hooks for Cursor IDE.
+ * Writes/merges ~/.cursor/hooks.json to point at the installed hook scripts.
+ * Cursor reads this file natively — no "Third-party skills" toggle required.
+ *
+ * @param {string} sourceHooksDir - Absolute path to the installed .claude/hooks/ directory
+ */
+export async function installCursorHooks(sourceHooksDir) {
+  const cursorDir = join(HOME_DIR, '.cursor');
+  const hooksJsonPath = join(cursorDir, 'hooks.json');
+  await mkdir(cursorDir, { recursive: true });
+
+  // Build the native Cursor hooks.json format
+  const hooksConfig = {
+    preToolUse: [{ command: `bun ${join(sourceHooksDir, 'pre_tool_use.mjs')}` }],
+    postToolUse: [{ command: `bun ${join(sourceHooksDir, 'post_tool_use.mjs')}` }],
+    sessionStart: [{ command: `bun ${join(sourceHooksDir, 'session_start.mjs')}` }],
+    sessionEnd: [{ command: `bun ${join(sourceHooksDir, 'session_end.mjs')}` }],
+    stop: [{ command: `bun ${join(sourceHooksDir, 'stop.mjs')}` }],
+    beforeSubmitPrompt: [{ command: `bun ${join(sourceHooksDir, 'user_prompt_submit.mjs')}` }],
+  };
+
+  // Merge with any existing hooks.json to preserve other tools' hooks
+  let existing = { version: 1, hooks: {} };
+  try {
+    const content = await readFile(hooksJsonPath, 'utf8');
+    existing = JSON.parse(content);
+    existing.hooks = existing.hooks || {};
+  } catch (e) {
+    // No existing file — start fresh
+  }
+
+  // Overwrite only Teleportation-managed hooks; leave others untouched
+  const merged = {
+    ...existing,
+    version: 1,
+    hooks: { ...existing.hooks, ...hooksConfig },
+  };
+
+  await writeFile(hooksJsonPath, JSON.stringify(merged, null, 2));
+  return { hooksJsonPath, hooksInstalled: Object.keys(hooksConfig) };
+}
+
+/**
+ * Remove Teleportation hooks from ~/.cursor/hooks.json without deleting the file.
+ * Preserves hooks belonging to other tools.
+ */
+export async function uninstallCursorHooks() {
+  const hooksJsonPath = join(HOME_DIR, '.cursor', 'hooks.json');
+  const teleportationKeys = ['preToolUse', 'postToolUse', 'sessionStart', 'sessionEnd', 'stop', 'beforeSubmitPrompt'];
+  const teleportationHookFiles = [
+    'pre_tool_use.mjs',
+    'post_tool_use.mjs',
+    'session_start.mjs',
+    'session_end.mjs',
+    'stop.mjs',
+    'user_prompt_submit.mjs',
+  ];
+
+  try {
+    const content = await readFile(hooksJsonPath, 'utf8');
+    const parsed = JSON.parse(content);
+    if (parsed.hooks) {
+      for (const key of teleportationKeys) {
+        if (!Array.isArray(parsed.hooks[key])) continue;
+        parsed.hooks[key] = parsed.hooks[key].filter((entry) => {
+          const command = entry?.command || '';
+          return !teleportationHookFiles.some((file) => command.includes(file));
+        });
+        if (parsed.hooks[key].length === 0) {
+          delete parsed.hooks[key];
+        }
+      }
+    }
+    await writeFile(hooksJsonPath, JSON.stringify(parsed, null, 2));
+    return { success: true, hooksJsonPath };
+  } catch (e) {
+    if (e.code === 'ENOENT') return { success: true, hooksJsonPath }; // Nothing to remove
+    throw e;
+  }
+}
+
 /**
  * Copy daemon files to ~/.teleportation/daemon/
  */
@@ -662,6 +767,7 @@ export async function verifyInstallation() {
  * @param {Object} [options] - Installation options
  * @param {boolean} [options.includeClaude] - Force include Claude hooks (overrides detection)
  * @param {boolean} [options.includeGemini] - Force include Gemini hooks (overrides detection)
+ * @param {boolean} [options.includeCursor] - Force include Cursor hooks (overrides detection)
  */
 export async function install(sourceHooksDir, options = {}) {
   // Pre-flight checks
@@ -673,6 +779,7 @@ export async function install(sourceHooksDir, options = {}) {
   // Check available CLIs
   const claudeCheck = checkClaudeCode();
   const geminiCheck = checkGeminiCli();
+  const cursorCheck = checkCursorIde();
   
   // Resolve what to install based on options and detection
   const shouldInstallClaude = options.includeClaude !== undefined 
@@ -683,11 +790,15 @@ export async function install(sourceHooksDir, options = {}) {
     ? options.includeGemini 
     : geminiCheck.valid;
 
-  if (!shouldInstallClaude && !shouldInstallGemini) {
-    if (options.includeClaude === false && options.includeGemini === false) {
+  const shouldInstallCursor = options.includeCursor !== undefined
+    ? options.includeCursor
+    : cursorCheck.valid;
+
+  if (!shouldInstallClaude && !shouldInstallGemini && !shouldInstallCursor) {
+    if (options.includeClaude === false && options.includeGemini === false && options.includeCursor === false) {
       throw new Error('No targets selected for installation.');
     }
-    throw new Error('Neither Claude Code nor Gemini CLI found. Please install one of them first, or specify a target.');
+    throw new Error('Neither Claude Code, Gemini CLI, nor Cursor IDE found. Please install one of them first, or specify a target.');
   }
 
   // Create directories
@@ -695,6 +806,7 @@ export async function install(sourceHooksDir, options = {}) {
 
   let hooksInstalled = 0;
   let geminiHooksInstalled = 0;
+  let cursorHooksInstalled = 0;
 
   // 1. Install Claude hooks
   if (shouldInstallClaude) {
@@ -719,6 +831,16 @@ export async function install(sourceHooksDir, options = {}) {
     }
   }
 
+  // 3. Install Cursor hooks
+  if (shouldInstallCursor) {
+    try {
+      const cursorResult = await installCursorHooks(resolve(getProjectHooksDir()));
+      cursorHooksInstalled = cursorResult.hooksInstalled.length;
+    } catch (e) {
+      console.warn(`Warning: Cursor hooks failed to install: ${e.message}`);
+    }
+  }
+
   // Install daemon (still goes to ~/.teleportation/daemon/)
   const daemonResult = await installDaemon();
   if (daemonResult.failed.length > 0) {
@@ -753,6 +875,7 @@ export async function install(sourceHooksDir, options = {}) {
     success: true,
     hooksInstalled,
     geminiHooksInstalled,
+    cursorHooksInstalled,
     daemonInstalled: daemonResult.installed.length,
     libFilesInstalled: libResult.installed.length,
     settingsFile: getProjectSettings(),

package/lib/install/uhr-installer.js

@@ -13,35 +13,41 @@
  */
 
 import { execSync } from 'child_process';
-import { join } from 'path';
+import { join, resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
 import { tmpdir } from 'os';
 
+const __dirname = dirname(fileURLToPath(import.meta.url));
+// Absolute path to the local uhr binary shipped with teleportation
+const LOCAL_UHR_BIN = resolve(__dirname, '..', '..', 'node_modules', '.bin', 'uhr');
+
 /**
- * Check if the UHR CLI is available on this system.
- *
- * Checks two locations:
- *   1. `uhr` on the system PATH (via `which uhr`)
- *   2. `node_modules/.bin/uhr` (local project install)
- *
- * @returns {Promise<boolean>} true if UHR CLI is reachable
+ * Resolve the uhr binary path, preferring PATH then the local node_modules install.
+ * Returns the binary path string, or null if not found.
+ * @returns {Promise<string|null>}
  */
-export async function isUhrAvailable() {
+export async function resolveUhrBin() {
   // Check PATH first
   try {
-    execSync('which uhr', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
-    return true;
+    const found = execSync('which uhr', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+    if (found) return found;
   } catch (_) {
     // Not in PATH
   }
 
-  // Check local node_modules
+  // Check absolute path to local node_modules/.bin/uhr
   try {
-    const localBin = join('node_modules', '.bin', 'uhr');
-    const file = Bun.file(localBin);
-    return await file.exists();
+    const file = Bun.file(LOCAL_UHR_BIN);
+    if (await file.exists()) return LOCAL_UHR_BIN;
   } catch (_) {
-    return false;
+    // continue
   }
+
+  return null;
+}
+
+export async function isUhrAvailable() {
+  return (await resolveUhrBin()) !== null;
 }
 
 /**
@@ -89,9 +95,14 @@ export async function installViaUhr(manifestPath, hooksDir, options = {}) {
   }
 
   // 5. Run uhr install
+  const uhrBin = await resolveUhrBin();
+  if (!uhrBin) {
+    return { success: false, reason: 'UHR CLI not found (checked PATH and node_modules/.bin/uhr)' };
+  }
+
   const warnings = [];
   try {
-    const output = execSync(`uhr install ${tempManifestPath}`, {
+    const output = execSync(`"${uhrBin}" install "${tempManifestPath}"`, {
       encoding: 'utf8',
       stdio: ['ignore', 'pipe', 'pipe'],
       timeout: 30000,
@@ -123,8 +134,11 @@ export async function installViaUhr(manifestPath, hooksDir, options = {}) {
  * @returns {Promise<{success: boolean}>}
  */
 export async function uninstallViaUhr(serviceName) {
+  const uhrBin = await resolveUhrBin();
+  if (!uhrBin) return { success: false };
+
   try {
-    execSync(`uhr uninstall ${serviceName}`, {
+    execSync(`"${uhrBin}" uninstall "${serviceName}"`, {
       encoding: 'utf8',
       stdio: ['ignore', 'pipe', 'pipe'],
       timeout: 30000,