remotelink 0.4.1 → 0.4.3

package/dist/index.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { createRequire as __remoteArcCreateRequire } from "node:module"; const require = __remoteArcCreateRequire(import.meta.url);
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -5275,8 +5276,10 @@ var CONFIG_DIR = path5.join(os3.homedir(), ".remotearc");
 var AGENT_DIR = path5.join(CONFIG_DIR, "agent");
 var LOG_DIR = path5.join(CONFIG_DIR, "logs");
 var AGENT_BUNDLE = path5.join(AGENT_DIR, "remotelink.mjs");
+var AGENT_VERSION_FILE = path5.join(AGENT_DIR, "version");
 var MAC_LABEL = "app.remotearc.agent";
-var WINDOWS_TASK = "Remote Arc Agent";
+var WINDOWS_RUN_KEY = "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run";
+var WINDOWS_RUN_VALUE = "Remote Arc Agent";
 var LINUX_UNIT = "remotearc-agent.service";
 async function run2(command, args, options = {}) {
   return new Promise((resolve, reject) => {
@@ -5319,7 +5322,7 @@ function xmlEscape(value) {
 function psQuote(value) {
   return "'" + value.replaceAll("'", "''") + "'";
 }
-async function ensureBundle(sourcePath) {
+async function ensureBundle(sourcePath, version) {
   await fs5.mkdir(AGENT_DIR, { recursive: true });
   await fs5.mkdir(LOG_DIR, { recursive: true });
   if (path5.resolve(sourcePath) !== path5.resolve(AGENT_BUNDLE)) {
@@ -5328,6 +5331,12 @@ async function ensureBundle(sourcePath) {
       await fs5.chmod(AGENT_BUNDLE, 448).catch(() => void 0);
     }
   }
+  if (version) {
+    await fs5.writeFile(AGENT_VERSION_FILE, version + "\n", { mode: 384 });
+  }
+}
+async function backgroundBundleVersion() {
+  return fs5.readFile(AGENT_VERSION_FILE, "utf8").then((value) => value.trim() || null).catch(() => null);
 }
 function macPlistPath() {
   return path5.join(os3.homedir(), "Library", "LaunchAgents", MAC_LABEL + ".plist");
@@ -5335,8 +5344,8 @@ function macPlistPath() {
 function linuxUnitPath() {
   return path5.join(os3.homedir(), ".config", "systemd", "user", LINUX_UNIT);
 }
-async function enableMac(sourcePath, preserveCurrent) {
-  await ensureBundle(sourcePath);
+async function enableMac(sourcePath, preserveCurrent, version) {
+  await ensureBundle(sourcePath, version);
   const plistPath = macPlistPath();
   await fs5.mkdir(path5.dirname(plistPath), { recursive: true });
   const stdoutPath = path5.join(LOG_DIR, "agent.log");
@@ -5358,6 +5367,11 @@ async function enableMac(sourcePath, preserveCurrent) {
     <key>SuccessfulExit</key><false/>
   </dict>
   <key>ProcessType</key><string>Background</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key><string>${xmlEscape(process.env.PATH || "/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin")}</string>
+    <key>HOME</key><string>${xmlEscape(os3.homedir())}</string>
+  </dict>
   <key>ThrottleInterval</key><integer>5</integer>
   <key>StandardOutPath</key><string>${xmlEscape(stdoutPath)}</string>
   <key>StandardErrorPath</key><string>${xmlEscape(stderrPath)}</string>
@@ -5402,21 +5416,23 @@ async function disableMac(stopCurrent) {
 async function statusMac() {
   const plistPath = macPlistPath();
   const enabled = await fs5.access(plistPath).then(() => true).catch(() => false);
-  const domain = `gui/${process.getuid?.() ?? os3.userInfo().uid}`;
-  const result = await run2(
-    "launchctl",
-    ["print", domain + "/" + MAC_LABEL],
-    { ignoreFailure: true }
-  );
+  const domain = "gui/" + (process.getuid?.() ?? os3.userInfo().uid);
+  const result = await run2("launchctl", ["print", domain + "/" + MAC_LABEL], { ignoreFailure: true });
+  const pidMatch = result.stdout.match(/\\bpid = (\\d+)/);
+  const pid = pidMatch ? Number(pidMatch[1]) : null;
+  const active = result.code === 0 && pid !== null && /\\bstate = running\\b/i.test(result.stdout);
   return {
     supported: true,
     enabled,
-    active: result.code === 0,
-    service: "launchd"
+    active,
+    service: "launchd",
+    pid,
+    version: await backgroundBundleVersion(),
+    detail: enabled && !active ? "Background connection is configured but the launchd agent is not currently running." : void 0
   };
 }
-async function enableLinux(sourcePath, preserveCurrent) {
-  await ensureBundle(sourcePath);
+async function enableLinux(sourcePath, preserveCurrent, version) {
+  await ensureBundle(sourcePath, version);
   const unitPath = linuxUnitPath();
   await fs5.mkdir(path5.dirname(unitPath), { recursive: true });
   const unit = `[Unit]
@@ -5457,66 +5473,81 @@ async function disableLinux(stopCurrent) {
   return backgroundAgentStatus();
 }
 async function statusLinux() {
-  const enabledResult = await run2(
-    "systemctl",
-    ["--user", "is-enabled", LINUX_UNIT],
-    { ignoreFailure: true }
-  );
-  const activeResult = await run2(
-    "systemctl",
-    ["--user", "is-active", LINUX_UNIT],
-    { ignoreFailure: true }
-  );
-  const supported = enabledResult.stderr.toLowerCase().includes("failed to connect to bus") ? false : true;
+  const enabledResult = await run2("systemctl", ["--user", "is-enabled", LINUX_UNIT], { ignoreFailure: true });
+  const activeResult = await run2("systemctl", ["--user", "is-active", LINUX_UNIT], { ignoreFailure: true });
+  const pidResult = await run2("systemctl", ["--user", "show", LINUX_UNIT, "--property", "MainPID", "--value"], { ignoreFailure: true });
+  const supported = !enabledResult.stderr.toLowerCase().includes("failed to connect to bus");
+  const pidValue = Number(pidResult.stdout.trim());
   return {
     supported,
     enabled: enabledResult.code === 0,
-    active: activeResult.code === 0,
+    active: activeResult.code === 0 && Number.isFinite(pidValue) && pidValue > 0,
     service: supported ? "systemd-user" : "unsupported",
+    pid: Number.isFinite(pidValue) && pidValue > 0 ? pidValue : null,
+    version: await backgroundBundleVersion(),
     detail: supported ? void 0 : "systemd user services are unavailable"
   };
 }
 async function powershell(script, ignoreFailure = false) {
+  const utf8Script = "$OutputEncoding = [Console]::OutputEncoding = [System.Text.UTF8Encoding]::new(); " + script;
   return run2(
     "powershell.exe",
-    ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", script],
+    ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", utf8Script],
     { ignoreFailure }
   );
 }
-async function enableWindows(sourcePath, preserveCurrent) {
-  await ensureBundle(sourcePath);
-  const args = `"${AGENT_BUNDLE}" --agent`;
-  const script = [
-    `$action = New-ScheduledTaskAction -Execute ${psQuote(process.execPath)} -Argument ${psQuote(args)}`,
-    "$trigger = New-ScheduledTaskTrigger -AtLogOn",
-    "$settings = New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -StartWhenAvailable -RestartCount 999 -RestartInterval (New-TimeSpan -Minutes 1)",
-    `Register-ScheduledTask -TaskName ${psQuote(WINDOWS_TASK)} -Action $action -Trigger $trigger -Settings $settings -Description 'Remote Arc background connection' -Force | Out-Null`,
-    ...preserveCurrent ? [] : [`Start-ScheduledTask -TaskName ${psQuote(WINDOWS_TASK)}`]
-  ].join("; ");
-  await powershell(script);
+async function windowsAgentPid() {
+  const escapedBundle = AGENT_BUNDLE.replaceAll("'", "''");
+  const script = "$p = Get-CimInstance Win32_Process | Where-Object { $_.Name -ieq 'node.exe' -and $_.CommandLine -like '*" + escapedBundle + "*' -and $_.CommandLine -like '*--agent*' } | Select-Object -First 1 -ExpandProperty ProcessId; if ($null -ne $p) { Write-Output $p }";
+  const result = await powershell(script, true);
+  const pid = Number(result.stdout.trim());
+  return Number.isFinite(pid) && pid > 0 ? pid : null;
+}
+async function enableWindows(sourcePath, preserveCurrent, version) {
+  await ensureBundle(sourcePath, version);
+  const command = '"' + process.execPath + '" "' + AGENT_BUNDLE + '" --agent';
+  await run2("reg.exe", [
+    "add",
+    WINDOWS_RUN_KEY,
+    "/v",
+    WINDOWS_RUN_VALUE,
+    "/t",
+    "REG_SZ",
+    "/d",
+    command,
+    "/f"
+  ]);
+  if (!preserveCurrent && !await windowsAgentPid()) {
+    const stdoutPath = path5.join(LOG_DIR, "agent.log");
+    const stderrPath = path5.join(LOG_DIR, "agent-error.log");
+    await powershell(
+      "Start-Process -FilePath " + psQuote(process.execPath) + " -ArgumentList @(" + psQuote(AGENT_BUNDLE) + ", '--agent') -WindowStyle Hidden -RedirectStandardOutput " + psQuote(stdoutPath) + " -RedirectStandardError " + psQuote(stderrPath) + " | Out-Null"
+    );
+    await new Promise((resolve) => setTimeout(resolve, 350));
+  }
   return backgroundAgentStatus();
 }
 async function disableWindows(stopCurrent) {
-  const commands = [];
+  await run2("reg.exe", ["delete", WINDOWS_RUN_KEY, "/v", WINDOWS_RUN_VALUE, "/f"], { ignoreFailure: true });
   if (stopCurrent) {
-    commands.push(
-      `Stop-ScheduledTask -TaskName ${psQuote(WINDOWS_TASK)} -ErrorAction SilentlyContinue`
-    );
+    const pid = await windowsAgentPid();
+    if (pid) {
+      await powershell("Stop-Process -Id " + pid + " -Force -ErrorAction SilentlyContinue", true);
+    }
   }
-  commands.push(
-    `Unregister-ScheduledTask -TaskName ${psQuote(WINDOWS_TASK)} -Confirm:$false -ErrorAction SilentlyContinue`
-  );
-  await powershell(commands.join("; "), true);
   return backgroundAgentStatus();
 }
 async function statusWindows() {
-  const script = `$task = Get-ScheduledTask -TaskName ${psQuote(WINDOWS_TASK)} -ErrorAction SilentlyContinue; if ($null -eq $task) { exit 3 }; Write-Output $task.State`;
-  const result = await powershell(script, true);
+  const enabledResult = await run2("reg.exe", ["query", WINDOWS_RUN_KEY, "/v", WINDOWS_RUN_VALUE], { ignoreFailure: true });
+  const pid = await windowsAgentPid();
   return {
     supported: true,
-    enabled: result.code === 0,
-    active: result.code === 0 && /running/i.test(result.stdout),
-    service: "task-scheduler"
+    enabled: enabledResult.code === 0,
+    active: pid !== null,
+    service: "registry-run",
+    pid,
+    version: await backgroundBundleVersion(),
+    detail: enabledResult.code === 0 && pid === null ? "Background connection is configured but the user-level agent is not currently running." : void 0
   };
 }
 async function backgroundAgentStatus() {
@@ -5533,9 +5564,9 @@ async function backgroundAgentStatus() {
 }
 async function enableBackgroundAgent(sourcePath, options = {}) {
   const preserveCurrent = options.preserveCurrent ?? false;
-  if (process.platform === "darwin") return enableMac(sourcePath, preserveCurrent);
-  if (process.platform === "win32") return enableWindows(sourcePath, preserveCurrent);
-  if (process.platform === "linux") return enableLinux(sourcePath, preserveCurrent);
+  if (process.platform === "darwin") return enableMac(sourcePath, preserveCurrent, options.version);
+  if (process.platform === "win32") return enableWindows(sourcePath, preserveCurrent, options.version);
+  if (process.platform === "linux") return enableLinux(sourcePath, preserveCurrent, options.version);
   return backgroundAgentStatus();
 }
 async function disableBackgroundAgent(options = {}) {
@@ -5547,7 +5578,7 @@ async function disableBackgroundAgent(options = {}) {
 }
 
 // src/index.ts
-var VERSION = "0.4.1";
+var VERSION = "0.4.3";
 var DEFAULT_ORIGIN = "https://mcp.remotearc.app";
 var CONFIG_DIR2 = path6.join(os4.homedir(), ".remotearc");
 var CONFIG_PATH = path6.join(CONFIG_DIR2, "config.json");
@@ -5883,7 +5914,10 @@ async function connectAgent(config) {
             platform: process3.platform,
             arch: process3.arch,
             hostname: os4.hostname(),
-            agentVersion: VERSION
+            agentVersion: VERSION,
+            pid: process3.pid,
+            backgroundProcess: argFlag("--agent"),
+            connectedAt: (/* @__PURE__ */ new Date()).toISOString()
           },
           tools: [...tools.map((tool) => tool.name), ...internalTools],
           capabilities: [
@@ -5981,19 +6015,24 @@ async function connectAgent(config) {
               await writeConfig(config);
               if (enabled) {
                 const current = await backgroundAgentStatus();
-                result = current.enabled ? { ...current, desired_enabled: true } : {
+                result = current.enabled && current.active ? { ...current, desired_enabled: true } : {
                   ...await enableBackgroundAgent(SELF_PATH, {
-                    preserveCurrent: argFlag("--agent")
+                    preserveCurrent: argFlag("--agent"),
+                    version: VERSION
                   }),
                   desired_enabled: true
                 };
                 exitAfterResponse = !argFlag("--agent");
               } else {
+                const stopCurrent = message.arguments?.stop_current === true;
+                const runningAsBackgroundAgent = argFlag("--agent");
                 result = {
-                  ...await disableBackgroundAgent({ stopCurrent: false }),
+                  ...await disableBackgroundAgent({
+                    stopCurrent: stopCurrent && !runningAsBackgroundAgent
+                  }),
                   desired_enabled: false
                 };
-                exitAfterResponse = false;
+                exitAfterResponse = stopCurrent && runningAsBackgroundAgent;
               }
             } else {
               result = await core.call(
@@ -6140,7 +6179,7 @@ async function main() {
     }
     if (!foregroundMode && config.backgroundEnabled === true) {
       try {
-        const status = await enableBackgroundAgent(SELF_PATH);
+        const status = await enableBackgroundAgent(SELF_PATH, { version: VERSION });
         if (status.supported && status.enabled) {
           banner();
           logLine("success", "Background connection enabled.");