agent-ssh-cli 0.1.0 → 0.1.2

package/README.md

@@ -11,7 +11,8 @@
   <a href="https://github.com/sleepinginsummer/agent-ssh-cli/blob/main/LICENSE"><img src="https://img.shields.io/badge/License-MIT-green" alt="License MIT"></a>
   <a href="https://nodejs.org/"><img src="https://img.shields.io/badge/Node.js-%3E%3D18-339933?logo=node.js&logoColor=white" alt="Node.js >=18"></a>
   <a href="https://www.npmjs.com/"><img src="https://img.shields.io/badge/npm-%3E%3D8-CB3837?logo=npm&logoColor=white" alt="npm >=8"></a>
-  <a href="https://github.com/sleepinginsummer/agent-ssh-cli/releases"><img src="https://img.shields.io/badge/release-v0.1.0-blue" alt="release v0.1.0"></a>
+  <a href="https://github.com/sleepinginsummer/agent-ssh-cli"><img src="https://img.shields.io/badge/Windows-MacOS-0078D6?labelColor=0078D6&color=C0C0C0" alt="Windows/MacOS"></a>
+  <a href="https://github.com/sleepinginsummer/agent-ssh-cli/releases"><img src="https://img.shields.io/badge/release-v0.1.2-blue" alt="release v0.1.2"></a>
   <a href="https://github.com/sleepinginsummer/agent-ssh-cli/pulls"><img src="https://img.shields.io/badge/PRs-welcome-brightgreen" alt="PRs welcome"></a>
 </p>
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-ssh-cli",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "基于 CLI 的 SSH 代理工具，按 ssh-mcp-server 的能力一一映射",
   "type": "module",
   "engines": {

package/src/cli.js

@@ -242,10 +242,20 @@ function parseExecuteArgs(argv) {
     return parsed;
   }
   const args = [...parsed.args];
-  const connectionName = resolveValue(args, ["--connection", "-c"], "connectionName");
-  const command = resolveValue(args, ["--command"], "command");
-  const directory = resolveValue(args, ["--directory", "-d"], "directory");
-  const timeoutValue = resolveValue(args, ["--timeout", "-t"], "timeout");
+  const connectionNameOption = takeOption(args, ["--connection", "-c"]);
+  const commandOption = takeOption(args, ["--command"]);
+  const directoryOption = takeOption(args, ["--directory", "-d"]);
+  const timeoutOption = takeOption(args, ["--timeout", "-t"]);
+  const connectionNamePositional = takePositional(args, "connectionName");
+  const commandPositional = takePositional(args, "command");
+
+  ensureNoMixedInput(connectionNameOption.present ? connectionNameOption.value : undefined, connectionNamePositional, "connectionName");
+  ensureNoMixedInput(commandOption.present ? commandOption.value : undefined, commandPositional, "command");
+
+  const connectionName = connectionNameOption.present ? connectionNameOption.value : connectionNamePositional;
+  const command = commandOption.present ? commandOption.value : commandPositional;
+  const directory = directoryOption.present ? directoryOption.value : undefined;
+  const timeoutValue = timeoutOption.present ? timeoutOption.value : undefined;
   for (let index = 0; index < args.length; index += 1) {
     if (args[index]?.startsWith("--")) {
       throw new Error(`不支持的参数: ${args[index]}`);

package/src/config.js

@@ -6,6 +6,7 @@ import { fileURLToPath } from "node:url";
 
 const DEFAULT_CONFIG_DIR = ".agent-ssh-cli";
 const DEFAULT_CONFIG_FILE = "config.json";
+const configCache = new Map();
 
 function isNonEmptyString(value) {
   return typeof value === "string" && value.trim() !== "";
@@ -23,7 +24,10 @@ function ensureRegexArray(patterns, fieldName, index) {
       throw new Error(`ssh-config.json 第 ${index + 1} 项的 ${fieldName} 必须只包含非空字符串`);
     }
     try {
-      return new RegExp(pattern), pattern;
+      return {
+        pattern,
+        regex: new RegExp(pattern)
+      };
     } catch (error) {
       throw new Error(`ssh-config.json 第 ${index + 1} 项的 ${fieldName} 含有非法正则: ${pattern}，${error.message}`);
     }
@@ -110,7 +114,13 @@ export function getDefaultConfigPath() {
 }
 
 export function loadConfig(configPath = getDefaultConfigPath()) {
-  const raw = fs.readFileSync(configPath, "utf8");
+  const resolvedConfigPath = path.resolve(configPath);
+  const stat = fs.statSync(resolvedConfigPath);
+  const cached = configCache.get(resolvedConfigPath);
+  if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) {
+    return cached.configs;
+  }
+  const raw = fs.readFileSync(resolvedConfigPath, "utf8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -131,6 +141,11 @@ export function loadConfig(configPath = getDefaultConfigPath()) {
     }
     seenNames.add(config.name);
   }
+  configCache.set(resolvedConfigPath, {
+    mtimeMs: stat.mtimeMs,
+    size: stat.size,
+    configs
+  });
   return configs;
 }
 

package/src/daemon-client.js

@@ -1,8 +1,10 @@
 import { spawn } from "node:child_process";
+import crypto from "node:crypto";
+import fs from "node:fs";
 import net from "node:net";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { getSocketPath, unlinkSocketPath } from "./daemon-paths.js";
+import { getSocketPath, getTokenPath, unlinkSocketPath } from "./daemon-paths.js";
 
 const DAEMON_START_TIMEOUT_MS = 3000;
 const DAEMON_REQUEST_TIMEOUT_MS = 86400000;
@@ -39,8 +41,19 @@ function connectSocket(socketPath, timeoutMs = DAEMON_REQUEST_TIMEOUT_MS) {
   });
 }
 
-function spawnDaemon(socketPath) {
-  const child = spawn(process.execPath, [getDaemonEntryPath(), "--socket", socketPath], {
+function readToken(tokenPath) {
+  return fs.readFileSync(tokenPath, "utf8").trim();
+}
+
+function createToken(tokenPath) {
+  const token = crypto.randomBytes(32).toString("hex");
+  fs.writeFileSync(tokenPath, token, { mode: 0o600 });
+  fs.chmodSync(tokenPath, 0o600);
+  return token;
+}
+
+function spawnDaemon(socketPath, configPath, tokenPath) {
+  const child = spawn(process.execPath, [getDaemonEntryPath(), "--socket", socketPath, "--config", path.resolve(configPath), "--token-file", tokenPath], {
     detached: true,
     stdio: "ignore"
   });
@@ -63,11 +76,15 @@ async function waitForDaemon(socketPath) {
   throw new Error(`启动 SSH 缓存进程失败: ${lastError?.message || "未知错误"}`);
 }
 
-async function ensureDaemon(socketPath) {
+async function ensureDaemon(socketPath, configPath, tokenPath) {
   try {
     const socket = await connectSocket(socketPath, 500);
     socket.end();
-    return;
+    try {
+      return readToken(tokenPath);
+    } catch (error) {
+      unlinkSocketPath(socketPath);
+    }
   } catch (error) {
     if (!isMissingSocketError(error)) {
       throw error;
@@ -76,13 +93,16 @@ async function ensureDaemon(socketPath) {
       unlinkSocketPath(socketPath);
     }
   }
-  spawnDaemon(socketPath);
+  const token = createToken(tokenPath);
+  spawnDaemon(socketPath, configPath, tokenPath);
   await waitForDaemon(socketPath);
+  return token;
 }
 
 export async function requestDaemon(configPath, request) {
   const socketPath = getSocketPath(configPath);
-  await ensureDaemon(socketPath);
+  const tokenPath = getTokenPath(configPath);
+  const token = await ensureDaemon(socketPath, configPath, tokenPath);
   const socket = await connectSocket(socketPath);
   socket.setEncoding("utf8");
 
@@ -128,6 +148,6 @@ export async function requestDaemon(configPath, request) {
         settle(reject, new Error("SSH 缓存进程提前关闭连接"));
       }
     });
-    socket.write(`${JSON.stringify(request)}\n`);
+    socket.write(`${JSON.stringify({ ...request, token })}\n`);
   });
 }

package/src/daemon-paths.js

@@ -29,6 +29,11 @@ export function getSocketPath(configPath) {
   return path.join(getDaemonDir(), `${digest}.sock`);
 }
 
+export function getTokenPath(configPath) {
+  const digest = crypto.createHash("sha256").update(path.resolve(configPath)).digest("hex").slice(0, 24);
+  return path.join(getDaemonDir(), `${digest}.token`);
+}
+
 export function unlinkSocketPath(socketPath) {
   if (isWindowsPlatform()) {
     return;

package/src/ssh-client.js

@@ -1,12 +1,39 @@
 import fs from "node:fs";
+import net from "node:net";
+import { pipeline } from "node:stream/promises";
 import { Client } from "ssh2";
 
+const SOCKS5_VERSION = 0x05;
+const SOCKS5_CONNECT_COMMAND = 0x01;
+const SOCKS5_RESERVED = 0x00;
+const SOCKS5_AUTH_NONE = 0x00;
+const SOCKS5_AUTH_PASSWORD = 0x02;
+const SOCKS5_AUTH_UNACCEPTABLE = 0xff;
+const SOCKS5_ADDRESS_IPV4 = 0x01;
+const SOCKS5_ADDRESS_DOMAIN = 0x03;
+const SOCKS5_ADDRESS_IPV6 = 0x04;
+const SOCKS5_REPLY_SUCCESS = 0x00;
+
+function getCompiledPattern(pattern, label) {
+  if (pattern instanceof RegExp) {
+    return pattern;
+  }
+  if (pattern?.regex instanceof RegExp) {
+    return pattern.regex;
+  }
+  try {
+    return new RegExp(pattern?.pattern || pattern);
+  } catch (error) {
+    throw new Error(`${label} 正则非法: ${pattern?.pattern || pattern}，${error.message}`);
+  }
+}
+
 function compilePatterns(patterns, label) {
   return (patterns || []).map((pattern) => {
     try {
-      return new RegExp(pattern);
+      return getCompiledPattern(pattern, label);
     } catch (error) {
-      throw new Error(`${label} 正则非法: ${pattern}，${error.message}`);
+      throw new Error(error.message);
     }
   });
 }
@@ -23,12 +50,201 @@ export function validateCommand(connection, command) {
   }
 }
 
-function createConnectConfig(connection) {
+function parseSocksProxy(proxy) {
+  const value = proxy.includes("://") ? proxy : `socks5://${proxy}`;
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch (error) {
+    throw new Error(`socksProxy 格式非法: ${proxy}，${error.message}`);
+  }
+  if (parsed.protocol !== "socks5:") {
+    throw new Error("socksProxy 仅支持 socks5:// 协议");
+  }
+  if (!parsed.hostname || !parsed.port) {
+    throw new Error("socksProxy 必须包含代理主机和端口");
+  }
+  const port = Number(parsed.port);
+  if (!Number.isInteger(port) || port <= 0 || port > 65535) {
+    throw new Error("socksProxy 端口非法");
+  }
+  const username = decodeURIComponent(parsed.username);
+  const password = decodeURIComponent(parsed.password);
+  if ((username && !password) || (!username && password)) {
+    throw new Error("socksProxy 用户名和密码必须同时提供");
+  }
+  return {
+    host: parsed.hostname,
+    port,
+    username: username || undefined,
+    password: password || undefined
+  };
+}
+
+function readExactly(socket, length) {
+  return new Promise((resolve, reject) => {
+    let buffer = Buffer.alloc(0);
+    const cleanup = () => {
+      socket.removeListener("data", onData);
+      socket.removeListener("error", onError);
+      socket.removeListener("close", onClose);
+    };
+    const onError = (error) => {
+      cleanup();
+      reject(error);
+    };
+    const onClose = () => {
+      cleanup();
+      reject(new Error("SOCKS5 代理连接提前关闭"));
+    };
+    const onData = (chunk) => {
+      buffer = Buffer.concat([buffer, chunk]);
+      if (buffer.length < length) {
+        return;
+      }
+      const result = buffer.subarray(0, length);
+      const rest = buffer.subarray(length);
+      cleanup();
+      if (rest.length > 0) {
+        socket.unshift(rest);
+      }
+      resolve(result);
+    };
+    socket.on("data", onData);
+    socket.once("error", onError);
+    socket.once("close", onClose);
+  });
+}
+
+function writeAll(socket, data) {
+  return new Promise((resolve, reject) => {
+    socket.write(data, (error) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve();
+    });
+  });
+}
+
+function connectTcp(host, port) {
+  return new Promise((resolve, reject) => {
+    const socket = net.createConnection({ host, port });
+    const cleanup = () => {
+      socket.removeListener("error", onError);
+    };
+    const onError = (error) => {
+      cleanup();
+      reject(error);
+    };
+    socket.once("connect", () => {
+      cleanup();
+      resolve(socket);
+    });
+    socket.once("error", onError);
+  });
+}
+
+function encodeTargetAddress(host) {
+  const ipVersion = net.isIP(host);
+  if (ipVersion === 4) {
+    return Buffer.concat([Buffer.from([SOCKS5_ADDRESS_IPV4]), Buffer.from(host.split(".").map(Number))]);
+  }
+  const hostBuffer = Buffer.from(host, "utf8");
+  if (hostBuffer.length > 255) {
+    throw new Error("SOCKS5 目标主机名过长");
+  }
+  return Buffer.concat([Buffer.from([SOCKS5_ADDRESS_DOMAIN, hostBuffer.length]), hostBuffer]);
+}
+
+async function authenticateSocksProxy(socket, proxyConfig) {
+  const methods = proxyConfig.username ? [SOCKS5_AUTH_PASSWORD] : [SOCKS5_AUTH_NONE];
+  await writeAll(socket, Buffer.from([SOCKS5_VERSION, methods.length, ...methods]));
+  const response = await readExactly(socket, 2);
+  if (response[0] !== SOCKS5_VERSION) {
+    throw new Error("SOCKS5 代理响应版本非法");
+  }
+  if (response[1] === SOCKS5_AUTH_UNACCEPTABLE) {
+    throw new Error("SOCKS5 代理不接受当前认证方式");
+  }
+  if (response[1] === SOCKS5_AUTH_NONE) {
+    return;
+  }
+  if (response[1] !== SOCKS5_AUTH_PASSWORD || !proxyConfig.username) {
+    throw new Error("SOCKS5 代理返回了不支持的认证方式");
+  }
+  const usernameBuffer = Buffer.from(proxyConfig.username, "utf8");
+  const passwordBuffer = Buffer.from(proxyConfig.password, "utf8");
+  if (usernameBuffer.length > 255 || passwordBuffer.length > 255) {
+    throw new Error("SOCKS5 用户名或密码过长");
+  }
+  await writeAll(socket, Buffer.concat([
+    Buffer.from([0x01, usernameBuffer.length]),
+    usernameBuffer,
+    Buffer.from([passwordBuffer.length]),
+    passwordBuffer
+  ]));
+  const authResponse = await readExactly(socket, 2);
+  if (authResponse[1] !== 0x00) {
+    throw new Error("SOCKS5 代理认证失败");
+  }
+}
+
+async function readSocksConnectResponse(socket) {
+  const header = await readExactly(socket, 4);
+  if (header[0] !== SOCKS5_VERSION) {
+    throw new Error("SOCKS5 代理响应版本非法");
+  }
+  if (header[1] !== SOCKS5_REPLY_SUCCESS) {
+    throw new Error(`SOCKS5 代理连接目标失败，响应码 ${header[1]}`);
+  }
+  if (header[2] !== SOCKS5_RESERVED) {
+    throw new Error("SOCKS5 代理响应保留字段非法");
+  }
+  if (header[3] === SOCKS5_ADDRESS_IPV4) {
+    await readExactly(socket, 4);
+  } else if (header[3] === SOCKS5_ADDRESS_IPV6) {
+    await readExactly(socket, 16);
+  } else if (header[3] === SOCKS5_ADDRESS_DOMAIN) {
+    const length = (await readExactly(socket, 1))[0];
+    await readExactly(socket, length);
+  } else {
+    throw new Error("SOCKS5 代理响应地址类型非法");
+  }
+  await readExactly(socket, 2);
+}
+
+async function connectSocksProxy(connection) {
+  const proxyConfig = parseSocksProxy(connection.socksProxy);
+  const socket = await connectTcp(proxyConfig.host, proxyConfig.port);
+  try {
+    await authenticateSocksProxy(socket, proxyConfig);
+    const targetAddress = encodeTargetAddress(connection.host);
+    const targetPort = Buffer.alloc(2);
+    targetPort.writeUInt16BE(connection.port);
+    await writeAll(socket, Buffer.concat([
+      Buffer.from([SOCKS5_VERSION, SOCKS5_CONNECT_COMMAND, SOCKS5_RESERVED]),
+      targetAddress,
+      targetPort
+    ]));
+    await readSocksConnectResponse(socket);
+    return socket;
+  } catch (error) {
+    socket.destroy();
+    throw error;
+  }
+}
+
+async function createConnectConfig(connection) {
   const connectConfig = {
     host: connection.host,
     port: connection.port,
     username: connection.username
   };
+  if (connection.socksProxy) {
+    connectConfig.sock = await connectSocksProxy(connection);
+  }
   if (connection.agent) {
     connectConfig.agent = connection.agent;
   } else if (connection.privateKey) {
@@ -46,7 +262,7 @@ function createConnectConfig(connection) {
 
 export async function connectSshClient(connection) {
   const client = new Client();
-  const connectConfig = createConnectConfig(connection);
+  const connectConfig = await createConnectConfig(connection);
   await new Promise((resolve, reject) => {
     client.once("ready", resolve);
     client.once("error", reject);
@@ -77,17 +293,28 @@ export async function executeRemoteCommandWithClient(client, connection, remoteC
     let exitCode;
     let exitSignal;
     let settled = false;
-    const timer = setTimeout(() => {
+    let commandStream;
+    const settle = (callback, value) => {
+      if (settled) {
+        return;
+      }
       settled = true;
-      reject(new Error(`命令执行超时，超过 ${timeout}ms`));
+      clearTimeout(timer);
+      callback(value);
+    };
+    const timer = setTimeout(() => {
+      if (commandStream) {
+        commandStream.close();
+      }
+      settle(reject, new Error(`命令执行超时，超过 ${timeout}ms`));
     }, timeout);
 
     client.exec(remoteCommand, { pty: connection.pty ?? true }, (err, stream) => {
       if (err) {
-        clearTimeout(timer);
-        reject(err);
+        settle(reject, err);
         return;
       }
+      commandStream = stream;
 
       stream.on("data", (chunk) => {
         stdout += chunk.toString();
@@ -100,11 +327,9 @@ export async function executeRemoteCommandWithClient(client, connection, remoteC
         exitSignal = signal;
       });
       stream.on("close", (code, signal) => {
-        clearTimeout(timer);
         if (settled) {
           return;
         }
-        settled = true;
         exitCode = exitCode ?? code;
         exitSignal = exitSignal ?? signal;
         if ((exitCode ?? 0) !== 0 || exitSignal) {
@@ -121,18 +346,13 @@ export async function executeRemoteCommandWithClient(client, connection, remoteC
           if (exitSignal) {
             parts.push(`[signal] ${exitSignal}`);
           }
-          reject(new Error(parts.join("\n") || "命令执行失败"));
+          settle(reject, new Error(parts.join("\n") || "命令执行失败"));
           return;
         }
-        resolve(stdout.trimEnd());
+        settle(resolve, stdout.trimEnd());
       });
       stream.on("error", (streamError) => {
-        clearTimeout(timer);
-        if (settled) {
-          return;
-        }
-        settled = true;
-        reject(streamError);
+        settle(reject, streamError);
       });
     });
   });
@@ -143,37 +363,20 @@ export async function uploadFile(connection, localPath, remotePath) {
 }
 
 export async function uploadFileWithClient(client, localPath, remotePath) {
-  return new Promise((resolve, reject) => {
+  const sftp = await new Promise((resolve, reject) => {
     client.sftp((err, sftp) => {
       if (err) {
         reject(err);
         return;
       }
-      const readStream = fs.createReadStream(localPath);
-      const writeStream = sftp.createWriteStream(remotePath);
-      let closed = false;
-      const cleanup = () => {
-        if (!closed) {
-          closed = true;
-          sftp.end();
-        }
-      };
-
-      readStream.on("error", (readError) => {
-        cleanup();
-        reject(readError);
-      });
-      writeStream.on("error", (writeError) => {
-        cleanup();
-        reject(writeError);
-      });
-      writeStream.on("close", () => {
-        cleanup();
-        resolve();
-      });
-      readStream.pipe(writeStream);
+      resolve(sftp);
     });
   });
+  try {
+    await pipeline(fs.createReadStream(localPath), sftp.createWriteStream(remotePath));
+  } finally {
+    sftp.end();
+  }
 }
 
 export async function downloadFile(connection, remotePath, localPath) {
@@ -181,35 +384,18 @@ export async function downloadFile(connection, remotePath, localPath) {
 }
 
 export async function downloadFileWithClient(client, remotePath, localPath) {
-  return new Promise((resolve, reject) => {
+  const sftp = await new Promise((resolve, reject) => {
     client.sftp((err, sftp) => {
       if (err) {
         reject(err);
         return;
       }
-      const readStream = sftp.createReadStream(remotePath);
-      const writeStream = fs.createWriteStream(localPath);
-      let closed = false;
-      const cleanup = () => {
-        if (!closed) {
-          closed = true;
-          sftp.end();
-        }
-      };
-
-      readStream.on("error", (readError) => {
-        cleanup();
-        reject(readError);
-      });
-      writeStream.on("error", (writeError) => {
-        cleanup();
-        reject(writeError);
-      });
-      writeStream.on("close", () => {
-        cleanup();
-        resolve();
-      });
-      readStream.pipe(writeStream);
+      resolve(sftp);
     });
   });
+  try {
+    await pipeline(sftp.createReadStream(remotePath), fs.createWriteStream(localPath));
+  } finally {
+    sftp.end();
+  }
 }

package/src/ssh-daemon.js

@@ -19,15 +19,29 @@ let lastActivityAt = Date.now();
 let exitTimer;
 let server;
 let socketPath;
+let boundConfigPath;
+let daemonToken;
 
 function parseArgs(argv) {
   const socketIndex = argv.indexOf("--socket");
-  const value = socketIndex === -1 ? undefined : argv[socketIndex + 1];
-  if (!value) {
+  const configIndex = argv.indexOf("--config");
+  const tokenFileIndex = argv.indexOf("--token-file");
+  const parsedSocketPath = socketIndex === -1 ? undefined : argv[socketIndex + 1];
+  const configPath = configIndex === -1 ? undefined : argv[configIndex + 1];
+  const tokenFilePath = tokenFileIndex === -1 ? undefined : argv[tokenFileIndex + 1];
+  if (!parsedSocketPath) {
     throw new Error("daemon 缺少 --socket 参数");
   }
+  if (!configPath) {
+    throw new Error("daemon 缺少 --config 参数");
+  }
+  if (!tokenFilePath) {
+    throw new Error("daemon 缺少 --token-file 参数");
+  }
   return {
-    socketPath: value
+    socketPath: parsedSocketPath,
+    configPath: path.resolve(configPath),
+    tokenFilePath: path.resolve(tokenFilePath)
   };
 }
 
@@ -47,6 +61,7 @@ function buildConnectionKey(configPath, connection) {
     host: connection.host,
     port: connection.port,
     username: connection.username,
+    socksProxy: connection.socksProxy,
     auth
   });
   return crypto.createHash("sha256").update(raw).digest("hex");
@@ -141,13 +156,20 @@ async function runSerialized(entry, operation) {
 }
 
 async function executeRequest(request) {
+  if (request.token !== daemonToken) {
+    throw new Error("SSH 缓存进程认证失败");
+  }
+  const requestConfigPath = path.resolve(request.configPath);
+  if (requestConfigPath !== boundConfigPath) {
+    throw new Error("SSH 缓存进程拒绝访问非绑定配置文件");
+  }
   const ttlMs = normalizeCacheTtl(request.cacheTtlMs);
-  const configs = loadConfig(request.configPath);
+  const configs = loadConfig(boundConfigPath);
   const connection = findConnection(configs, request.connectionName);
   if (request.operation === "execute") {
     validateCommand(connection, request.command);
   }
-  const entry = await getPoolEntry(request.configPath, connection, ttlMs);
+  const entry = await getPoolEntry(boundConfigPath, connection, ttlMs);
 
   try {
     if (request.operation === "execute") {
@@ -221,7 +243,10 @@ function shutdown() {
 }
 
 try {
-  ({ socketPath } = parseArgs(process.argv.slice(2)));
+  const parsedArgs = parseArgs(process.argv.slice(2));
+  socketPath = parsedArgs.socketPath;
+  boundConfigPath = parsedArgs.configPath;
+  daemonToken = fs.readFileSync(parsedArgs.tokenFilePath, "utf8").trim();
   unlinkSocketPath(socketPath);
   server = net.createServer(handleSocket);
   server.listen(socketPath, () => {