@livedesk/client 0.1.0

package/bin/livedesk-client.js

@@ -0,0 +1,306 @@
+#!/usr/bin/env node
+
+import { chmodSync, existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { spawn, spawnSync } from 'node:child_process';
+import os from 'node:os';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const packageRoot = resolve(__dirname, '..');
+const nodeAgentPath = join(__dirname, 'livedesk-client-node.js');
+const FAST_PREFLIGHT_TIMEOUT_MS = 5000;
+
+function printHelp() {
+    const result = spawnSync(process.execPath, [nodeAgentPath, '--help'], {
+        encoding: 'utf8'
+    });
+    const help = result.stdout || '';
+    process.stdout.write(`${help}
+
+Engine selection:
+  --engine auto|fast|csharp|node  Select agent engine. Default: auto.
+  --fast                          Force C# RemoteFast frame.binary engine.
+  --node                          Force the legacy Node agent.
+  --control                       Enable RemoteFast keyboard/mouse control.
+  --no-control                    Disable RemoteFast keyboard/mouse control.
+  --transport ws|tcp              RemoteFast hub transport. Default: ws.
+
+Auto uses C# RemoteFast when supported and falls back to Node for AI assist or
+when a packaged RemoteFast runtime is unavailable.
+`);
+}
+
+function normalizeEngine(value) {
+    const engine = String(value || 'auto').trim().toLowerCase();
+    if (engine === 'c#' || engine === 'csharp' || engine === 'fast') {
+        return 'fast';
+    }
+    if (engine === 'js' || engine === 'node' || engine === 'legacy') {
+        return 'node';
+    }
+    return 'auto';
+}
+
+function parseLauncherArgs(argv) {
+    const forwarded = [];
+    let engine = normalizeEngine(process.env.LIVEDESK_CLIENT_ENGINE || process.env.MINDEXEC_REMOTE_ENGINE);
+    let help = false;
+    let nodeOnlyFeature = false;
+    let fakeThumbnail = false;
+
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (arg === '--engine') {
+            engine = normalizeEngine(argv[index + 1]);
+            index += 1;
+            continue;
+        }
+        if (arg === '--fast' || arg === '--csharp') {
+            engine = 'fast';
+            continue;
+        }
+        if (arg === '--node') {
+            engine = 'node';
+            continue;
+        }
+
+        if (arg === '--help' || arg === '-h') {
+            help = true;
+        }
+        if (arg === '--ai' || arg === '--fake-ai' || arg === '--ai-model' || arg === '--no-ai') {
+            nodeOnlyFeature = true;
+        }
+        if (arg === '--fake-thumbnail') {
+            fakeThumbnail = true;
+        }
+        forwarded.push(arg);
+    }
+
+    return {
+        engine,
+        forwarded,
+        help,
+        nodeOnlyFeature,
+        fakeThumbnail
+    };
+}
+
+function getFastRuntime() {
+    const platform = os.platform();
+    const arch = os.arch();
+    if (platform === 'win32' && arch === 'x64') {
+        return {
+            rid: 'win-x64',
+            executable: join(packageRoot, 'fast', 'win-x64', 'mindexec-remote-fast.exe'),
+            dll: join(packageRoot, 'fast', 'win-x64', 'mindexec-remote-fast.dll')
+        };
+    }
+    if (platform === 'darwin' && arch === 'arm64') {
+        return {
+            rid: 'osx-arm64',
+            executable: join(packageRoot, 'fast', 'osx-arm64', 'mindexec-remote-fast'),
+            dll: join(packageRoot, 'fast', 'osx-arm64', 'mindexec-remote-fast.dll')
+        };
+    }
+    if (platform === 'darwin' && arch === 'x64') {
+        return {
+            rid: 'osx-x64',
+            executable: join(packageRoot, 'fast', 'osx-x64', 'mindexec-remote-fast'),
+            dll: join(packageRoot, 'fast', 'osx-x64', 'mindexec-remote-fast.dll')
+        };
+    }
+
+    return null;
+}
+
+function summarizeText(value, maxLength = 600) {
+    const text = String(value || '').replace(/\s+/g, ' ').trim();
+    if (text.length <= maxLength) {
+        return text;
+    }
+
+    return `${text.slice(0, maxLength - 3)}...`;
+}
+
+function getDotnetRuntimeStatus() {
+    if (process.env.LIVEDESK_CLIENT_FAST_DISABLE_DOTNET === '1' || process.env.MINDEXEC_REMOTE_FAST_DISABLE_DOTNET === '1') {
+        return { ok: false, reason: 'dotnet disabled by LIVEDESK_CLIENT_FAST_DISABLE_DOTNET' };
+    }
+
+    const result = spawnSync('dotnet', ['--list-runtimes'], {
+        encoding: 'utf8',
+        windowsHide: true,
+        timeout: FAST_PREFLIGHT_TIMEOUT_MS
+    });
+    if (result.error) {
+        return { ok: false, reason: result.error.message || 'dotnet runtime check failed' };
+    }
+
+    if (result.status !== 0) {
+        return {
+            ok: false,
+            reason: summarizeText(result.stderr || result.stdout || `dotnet exited with ${result.status}`)
+        };
+    }
+
+    if (!/Microsoft\.NETCore\.App\s+9\./i.test(result.stdout || '')) {
+        return { ok: false, reason: '.NET 9 runtime is not installed' };
+    }
+
+    return { ok: true, reason: 'ok' };
+}
+
+function hasDotnetRuntime() {
+    return getDotnetRuntimeStatus().ok;
+}
+
+function hasFastExecutable(runtime) {
+    return !!runtime?.executable && existsSync(runtime.executable);
+}
+
+function hasFastDll(runtime) {
+    return !!runtime?.dll && existsSync(runtime.dll);
+}
+
+function describePreflightFailure(result) {
+    if (result?.error) {
+        return result.error.message || String(result.error);
+    }
+
+    const exitText = result?.signal
+        ? `signal:${result.signal}`
+        : `exit:${Number.isFinite(result?.status) ? result.status : 'unknown'}`;
+    return summarizeText(result?.stderr || result?.stdout || exitText);
+}
+
+function prepareFastExecutable(executable) {
+    if (os.platform() === 'win32') {
+        return;
+    }
+
+    try {
+        chmodSync(executable, 0o755);
+    } catch {
+        // npm normally preserves executable bits; chmod is only a best-effort repair.
+    }
+}
+
+function buildFastArgs(args, fakeThumbnail) {
+    const forwarded = [];
+    for (const arg of args) {
+        if (arg === '--fake-thumbnail') {
+            forwarded.push('--fake-frame');
+            continue;
+        }
+        if (arg === '--tasks' || arg === '--no-tasks' || arg === '--no-ai') {
+            continue;
+        }
+        forwarded.push(arg);
+    }
+    if (fakeThumbnail && !forwarded.includes('--fake-frame')) {
+        forwarded.push('--fake-frame');
+    }
+    return forwarded;
+}
+
+function resolveFastLaunch(runtime) {
+    if (!runtime) {
+        return {
+            ok: false,
+            reason: 'C# RemoteFast is not packaged for this OS/architecture'
+        };
+    }
+
+    const failures = [];
+    if (hasFastExecutable(runtime)) {
+        prepareFastExecutable(runtime.executable);
+        const result = spawnSync(runtime.executable, ['--version'], {
+            encoding: 'utf8',
+            windowsHide: true,
+            timeout: FAST_PREFLIGHT_TIMEOUT_MS
+        });
+        if (result.status === 0) {
+            return {
+                ok: true,
+                command: runtime.executable,
+                argsPrefix: []
+            };
+        }
+
+        failures.push(`apphost: ${describePreflightFailure(result)}`);
+    }
+
+    if (hasFastDll(runtime)) {
+        const dotnet = getDotnetRuntimeStatus();
+        if (dotnet.ok) {
+            return {
+                ok: true,
+                command: 'dotnet',
+                argsPrefix: [runtime.dll]
+            };
+        }
+
+        failures.push(`dotnet: ${dotnet.reason}`);
+    }
+
+    return {
+        ok: false,
+        reason: failures.length > 0
+            ? failures.join('; ')
+            : `C# RemoteFast runtime files are missing for ${runtime.rid}`
+    };
+}
+
+function spawnAgent(command, args) {
+    const child = spawn(command, args, {
+        stdio: 'inherit',
+        windowsHide: true
+    });
+
+    child.once('error', error => {
+        console.error(`Failed to launch ${command}: ${error.message}`);
+        process.exitCode = 1;
+    });
+    child.once('exit', (code, signal) => {
+        if (signal) {
+            process.kill(process.pid, signal);
+            return;
+        }
+        process.exit(code ?? 0);
+    });
+}
+
+function shouldUseFast(parsed) {
+    if (parsed.engine === 'node') {
+        return false;
+    }
+    if (parsed.engine === 'fast') {
+        return true;
+    }
+    return !parsed.nodeOnlyFeature;
+}
+
+const parsed = parseLauncherArgs(process.argv.slice(2));
+if (parsed.help) {
+    printHelp();
+    process.exit(0);
+}
+
+const fastRuntime = getFastRuntime();
+const useFast = shouldUseFast(parsed);
+if (useFast) {
+    const fastArgs = buildFastArgs(parsed.forwarded, parsed.fakeThumbnail);
+    const fastLaunch = resolveFastLaunch(fastRuntime);
+    if (fastLaunch.ok) {
+        spawnAgent(fastLaunch.command, [...fastLaunch.argsPrefix, ...fastArgs]);
+    } else if (parsed.engine === 'fast') {
+        console.error(`C# RemoteFast is unavailable: ${fastLaunch.reason}. Use --engine node to run the legacy Node agent.`);
+        process.exit(2);
+    } else {
+        console.warn(`C# RemoteFast is unavailable (${fastLaunch.reason}). Falling back to the Node remote agent.`);
+        spawnAgent(process.execPath, [nodeAgentPath, ...parsed.forwarded]);
+    }
+} else {
+    spawnAgent(process.execPath, [nodeAgentPath, ...parsed.forwarded]);
+}

package/fast/osx-arm64/mindexec-remote-fast.deps.json

@@ -0,0 +1,24 @@
+{
+  "runtimeTarget": {
+    "name": ".NETCoreApp,Version=v9.0/osx-arm64",
+    "signature": ""
+  },
+  "compilationOptions": {},
+  "targets": {
+    ".NETCoreApp,Version=v9.0": {},
+    ".NETCoreApp,Version=v9.0/osx-arm64": {
+      "mindexec-remote-fast/1.0.0": {
+        "runtime": {
+          "mindexec-remote-fast.dll": {}
+        }
+      }
+    }
+  },
+  "libraries": {
+    "mindexec-remote-fast/1.0.0": {
+      "type": "project",
+      "serviceable": false,
+      "sha512": ""
+    }
+  }
+}

package/fast/osx-arm64/mindexec-remote-fast.runtimeconfig.json

@@ -0,0 +1,13 @@
+{
+  "runtimeOptions": {
+    "tfm": "net9.0",
+    "framework": {
+      "name": "Microsoft.NETCore.App",
+      "version": "9.0.0"
+    },
+    "configProperties": {
+      "System.Reflection.Metadata.MetadataUpdater.IsSupported": false,
+      "System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization": false
+    }
+  }
+}

package/fast/osx-x64/mindexec-remote-fast.deps.json

@@ -0,0 +1,24 @@
+{
+  "runtimeTarget": {
+    "name": ".NETCoreApp,Version=v9.0/osx-x64",
+    "signature": ""
+  },
+  "compilationOptions": {},
+  "targets": {
+    ".NETCoreApp,Version=v9.0": {},
+    ".NETCoreApp,Version=v9.0/osx-x64": {
+      "mindexec-remote-fast/1.0.0": {
+        "runtime": {
+          "mindexec-remote-fast.dll": {}
+        }
+      }
+    }
+  },
+  "libraries": {
+    "mindexec-remote-fast/1.0.0": {
+      "type": "project",
+      "serviceable": false,
+      "sha512": ""
+    }
+  }
+}

package/fast/osx-x64/mindexec-remote-fast.runtimeconfig.json

@@ -0,0 +1,13 @@
+{
+  "runtimeOptions": {
+    "tfm": "net9.0",
+    "framework": {
+      "name": "Microsoft.NETCore.App",
+      "version": "9.0.0"
+    },
+    "configProperties": {
+      "System.Reflection.Metadata.MetadataUpdater.IsSupported": false,
+      "System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization": false
+    }
+  }
+}

package/fast/win-x64/mindexec-remote-fast.deps.json

@@ -0,0 +1,24 @@
+{
+  "runtimeTarget": {
+    "name": ".NETCoreApp,Version=v9.0/win-x64",
+    "signature": ""
+  },
+  "compilationOptions": {},
+  "targets": {
+    ".NETCoreApp,Version=v9.0": {},
+    ".NETCoreApp,Version=v9.0/win-x64": {
+      "mindexec-remote-fast/1.0.0": {
+        "runtime": {
+          "mindexec-remote-fast.dll": {}
+        }
+      }
+    }
+  },
+  "libraries": {
+    "mindexec-remote-fast/1.0.0": {
+      "type": "project",
+      "serviceable": false,
+      "sha512": ""
+    }
+  }
+}

package/fast/win-x64/mindexec-remote-fast.runtimeconfig.json

@@ -0,0 +1,20 @@
+{
+  "runtimeOptions": {
+    "tfm": "net9.0",
+    "frameworks": [
+      {
+        "name": "Microsoft.NETCore.App",
+        "version": "9.0.0"
+      },
+      {
+        "name": "Microsoft.WindowsDesktop.App",
+        "version": "9.0.0"
+      }
+    ],
+    "configProperties": {
+      "System.Reflection.Metadata.MetadataUpdater.IsSupported": false,
+      "System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization": false,
+      "CSWINRT_USE_WINDOWS_UI_XAML_PROJECTIONS": false
+    }
+  }
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@livedesk/client",
+  "version": "0.1.0",
+  "description": "LiveDesk local remote client",
+  "type": "module",
+  "bin": {
+    "livedesk-client": "bin/livedesk-client.js",
+    "livedesk-client-node": "bin/livedesk-client-node.js",
+    "livedesk-client-fast": "bin/livedesk-client-fast.js"
+  },
+  "files": [
+    "bin/",
+    "fast/",
+    "README.md"
+  ],
+  "scripts": {
+    "check": "node --check bin/livedesk-client.js && node --check bin/livedesk-client-node.js && node --check bin/livedesk-client-fast.js",
+    "pack:dry": "npm pack --dry-run"
+  },
+  "keywords": [
+    "livedesk",
+    "remote",
+    "agent",
+    "local",
+    "desktop"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "node-screenshots": "^0.2.8",
+    "openai": "^6.42.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}