deepseek-pp-shell-host 0.4.4 → 0.6.2

package/native/shell-mcp-host.mjs

@@ -1,8 +1,16 @@
 #!/usr/bin/env node
-import { spawn } from 'node:child_process';
+import { execFileSync, spawn } from 'node:child_process';
 import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { homedir, hostname, platform, arch } from 'node:os';
+import {
+  arch,
+  homedir,
+  hostname,
+  platform,
+  release as osRelease,
+  type as osType,
+  version as osVersion,
+} from 'node:os';
 import { existsSync } from 'node:fs';
 
 // Resolve package root from this script's location (native/ -> package root).
@@ -17,8 +25,8 @@ const localBinDirs = [
   resolve(PROJECT_ROOT, 'node_modules', '.bin'),
   resolve(PROJECT_ROOT, '..', '..', 'node_modules', '.bin'),
 ].filter(existsSync);
-const sep = platform() === 'win32' ? ';' : ':';
-const currentPath = process.env.PATH || (platform() === 'win32' ? '' : '/usr/bin:/bin');
+const PATH_SEPARATOR = platform() === 'win32' ? ';' : ':';
+const currentPath = getEnvironmentPath(process.env) || (platform() === 'win32' ? '' : '/usr/bin:/bin');
 const localAppData = process.env.LOCALAPPDATA || resolve(homedir(), 'AppData', 'Local');
 const userBinDirs = platform() === 'win32'
   ? [resolve(localAppData, 'OfficeCLI')]
@@ -28,19 +36,32 @@ const userBinDirs = platform() === 'win32'
       '/usr/local/bin',
     ];
 const managedPathDirs = new Set([nodeBinDir, ...localBinDirs, ...userBinDirs]);
-const existingPathDirs = currentPath.split(sep).filter(d => d && !managedPathDirs.has(d));
-process.env.PATH = [...new Set([nodeBinDir, ...userBinDirs, ...existingPathDirs, ...localBinDirs])].join(sep);
+const existingPathDirs = splitPath(currentPath).filter(d => !managedPathDirs.has(d));
+const hostPath = dedupePathDirs([
+  nodeBinDir,
+  ...userBinDirs,
+  ...readWindowsUserMachinePathDirs(),
+  ...existingPathDirs,
+  ...localBinDirs,
+]).join(PATH_SEPARATOR);
+setEnvironmentPath(process.env, hostPath);
 
 const MCP_PROTOCOL_VERSION = '2025-06-18';
 const DEFAULT_TIMEOUT_MS = 120_000;
 const MAX_OUTPUT_BYTES = 128_000;
 const DEFAULT_SHELL = platform() === 'win32' ? 'powershell.exe' : process.env.SHELL || '/bin/sh';
+const WINDOWS_POWERSHELL_UTF8_PREAMBLE = [
+  '[Console]::InputEncoding = [System.Text.UTF8Encoding]::new($false)',
+  '[Console]::OutputEncoding = [System.Text.UTF8Encoding]::new($false)',
+  '$OutputEncoding = [Console]::OutputEncoding',
+  'try { chcp.com 65001 > $null } catch {}',
+].join('; ');
 
 const TOOL_DEFINITIONS = [
   {
     name: 'shell_exec',
     title: 'Execute Shell Command',
-    description: 'Execute a shell command on the local system. Returns stdout, stderr, and exit code.',
+    description: 'Execute a command in the shell reported by shell_status. Returns stdout, stderr, and exit code.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -175,10 +196,16 @@ async function handleCallTool(id, params) {
         data: {
           platform: platform(),
           arch: arch(),
+          osType: osType(),
+          osRelease: osRelease(),
+          osVersion: osVersion(),
+          windowsVersion: getWindowsVersionLabel(),
           shell: DEFAULT_SHELL,
           cwd: homedir(),
           nodeVersion: process.version,
           hostname: hostname(),
+          path: getEnvironmentPath(process.env),
+          pathEntries: splitPath(getEnvironmentPath(process.env)),
         },
       },
     });
@@ -194,7 +221,7 @@ async function handleCallTool(id, params) {
     }
 
     const cwd = typeof args.cwd === 'string' && args.cwd.trim() ? args.cwd.trim() : homedir();
-    const env = args.env && typeof args.env === 'object' ? { ...process.env, ...args.env } : process.env;
+    const env = createChildEnv(args.env);
     const timeoutMs = typeof args.timeout_ms === 'number' && args.timeout_ms >= 1000
       ? Math.min(args.timeout_ms, 600_000)
       : DEFAULT_TIMEOUT_MS;
@@ -224,9 +251,7 @@ async function handleCallTool(id, params) {
 
 function execCommand(command, { cwd, env, timeoutMs }) {
   return new Promise((resolve, reject) => {
-    const isWin = platform() === 'win32';
-    const shellArgs = isWin ? ['/c', command] : ['-c', command];
-    const shellBin = isWin ? 'cmd.exe' : DEFAULT_SHELL;
+    const { shellBin, shellArgs } = createShellInvocation(command);
 
     const child = spawn(shellBin, shellArgs, {
       cwd,
@@ -273,6 +298,7 @@ function execCommand(command, { cwd, env, timeoutMs }) {
       clearTimeout(timer);
       resolve({
         command,
+        shell: shellBin,
         exitCode: timedOut ? -1 : (exitCode ?? -1),
         signal: signal || (timedOut ? 'SIGTERM' : null),
         stdout: Buffer.concat(stdout).toString('utf8'),
@@ -284,6 +310,119 @@ function execCommand(command, { cwd, env, timeoutMs }) {
   });
 }
 
+function createChildEnv(extraEnv) {
+  const explicitPath = getExplicitPathOverride(extraEnv);
+  const env = extraEnv && typeof extraEnv === 'object' ? { ...process.env, ...extraEnv } : { ...process.env };
+  const pathValue = explicitPath !== null ? explicitPath : (getEnvironmentPath(env) || getEnvironmentPath(process.env));
+  setEnvironmentPath(env, pathValue);
+  if (platform() === 'win32') {
+    env.PYTHONUTF8 ??= '1';
+    env.PYTHONIOENCODING ??= 'utf-8';
+  }
+  return env;
+}
+
+function createShellInvocation(command) {
+  if (platform() === 'win32') {
+    return {
+      shellBin: DEFAULT_SHELL,
+      shellArgs: [
+        '-NoLogo',
+        '-NoProfile',
+        '-NonInteractive',
+        '-Command',
+        `${WINDOWS_POWERSHELL_UTF8_PREAMBLE}; ${command}`,
+      ],
+    };
+  }
+
+  return { shellBin: DEFAULT_SHELL, shellArgs: ['-c', command] };
+}
+
+function splitPath(value) {
+  return (value || '')
+    .split(PATH_SEPARATOR)
+    .map(entry => entry.trim())
+    .filter(Boolean);
+}
+
+function getEnvironmentPath(env) {
+  const canonicalKey = platform() === 'win32' ? 'Path' : 'PATH';
+  if (typeof env[canonicalKey] === 'string') return env[canonicalKey];
+  const key = Object.keys(env).find(name => name.toLowerCase() === 'path');
+  return key ? env[key] || '' : '';
+}
+
+function setEnvironmentPath(env, value) {
+  for (const key of Object.keys(env)) {
+    if (key.toLowerCase() === 'path') delete env[key];
+  }
+  env[platform() === 'win32' ? 'Path' : 'PATH'] = value;
+}
+
+function getExplicitPathOverride(env) {
+  if (!env || typeof env !== 'object') return null;
+  let value = null;
+  for (const [key, candidate] of Object.entries(env)) {
+    if (key.toLowerCase() === 'path' && typeof candidate === 'string') {
+      value = candidate;
+    }
+  }
+  return value;
+}
+
+function dedupePathDirs(dirs) {
+  const seen = new Set();
+  const result = [];
+  for (const dir of dirs) {
+    if (!dir) continue;
+    const key = platform() === 'win32'
+      ? dir.replace(/[\\/]+$/, '').toLowerCase()
+      : dir.replace(/\/+$/, '');
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(dir);
+  }
+  return result;
+}
+
+function readWindowsUserMachinePathDirs() {
+  if (platform() !== 'win32') return [];
+  const command = [
+    "[Console]::OutputEncoding = [System.Text.UTF8Encoding]::new($false)",
+    "$paths = @([Environment]::GetEnvironmentVariable('Path', 'Machine'), [Environment]::GetEnvironmentVariable('Path', 'User'))",
+    "$paths | Where-Object { $_ } | ForEach-Object { [Environment]::ExpandEnvironmentVariables($_) }",
+  ].join('; ');
+  try {
+    const out = execFileSync('powershell.exe', [
+      '-NoLogo',
+      '-NoProfile',
+      '-NonInteractive',
+      '-Command',
+      command,
+    ], {
+      encoding: 'utf8',
+      timeout: 10_000,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      windowsHide: true,
+    });
+    return splitPath(out.replace(/\r?\n/g, PATH_SEPARATOR));
+  } catch (err) {
+    process.stderr.write(`[shell-mcp-host] Could not read Windows User/Machine PATH: ${err.message}\n`);
+    return [];
+  }
+}
+
+function getWindowsVersionLabel() {
+  if (platform() !== 'win32') return null;
+  const release = osRelease();
+  const parts = release.split('.').map(part => Number.parseInt(part, 10));
+  const build = parts[2] || 0;
+  if (parts[0] === 10 && build >= 22000) return `Windows 11 (${release})`;
+  if (parts[0] === 10) return `Windows 10 (${release})`;
+  return `Windows (${release})`;
+}
+
 function formatExecSummary(result) {
   const parts = [];
   if (result.timedOut) parts.push('[TIMED OUT]');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepseek-pp-shell-host",
-  "version": "0.4.4",
+  "version": "0.6.2",
   "description": "Native Messaging Shell MCP host installer for DeepSeek++",
   "type": "module",
   "private": false,