deepseek-pp-shell-host 0.4.4

package/README.md

@@ -0,0 +1,16 @@
+# deepseek-pp-shell-host
+
+Native Messaging Shell MCP host installer for DeepSeek++.
+
+```bash
+npx deepseek-pp-shell-host install --browser chrome --extension-id <extension-id>
+```
+
+The installer writes the browser Native Messaging manifest, installs the Shell MCP host into the user's profile directory, and installs command-based OfficeCLI by default.
+
+Useful commands:
+
+```bash
+npx deepseek-pp-shell-host status --browser chrome
+npx deepseek-pp-shell-host uninstall --browser chrome
+```

package/bin/deepseek-pp-shell-host.mjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { main } from '../lib/installer.mjs';
+
+main().catch((err) => {
+  console.error(`\nInstall failed: ${err.message}`);
+  process.exit(1);
+});

package/lib/installer.mjs

@@ -0,0 +1,547 @@
+#!/usr/bin/env node
+import {
+  chmodSync,
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import { execFileSync, execSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { dirname, resolve } from 'node:path';
+import { arch, homedir, platform, tmpdir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+
+export const HOST_NAME = 'com.deepseek_pp.shell';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PACKAGE_ROOT = resolve(__dirname, '..');
+const HOST_SOURCE = resolve(PACKAGE_ROOT, 'native', 'shell-mcp-host.mjs');
+const FIREFOX_EXTENSION_ID = 'deepseek-pp@zhu1090093659.github';
+const SUPPORTED_BROWSERS = new Set(['chrome', 'chromium', 'edge', 'firefox']);
+const COMMANDS = new Set(['install', 'status', 'uninstall']);
+const OFFICECLI_REPO = 'iOfficeAI/OfficeCLI';
+const OFFICECLI_BINARY = platform() === 'win32' ? 'officecli.exe' : 'officecli';
+const OFFICECLI_MIRROR_BASE = 'https://d.officecli.ai';
+const OFFICECLI_GITHUB_RELEASE_BASE = `https://github.com/${OFFICECLI_REPO}/releases/latest/download`;
+const OFFICECLI_REQUIRED_HELP_PATTERNS = [
+  /\bview\s+<file>\s+<mode>/,
+  /\bget\s+<file>\s+<path>/,
+  /\bset\s+<file>\s+<path>/,
+  /\bbatch\s+<file>/,
+  /\bvalidate\s+<file>/,
+  /--json\b/,
+];
+
+function parseArgs(argv) {
+  const args = {
+    command: 'install',
+    extensionId: null,
+    browser: 'chrome',
+    skipOfficecli: false,
+    forceOfficecli: false,
+  };
+  const tokens = [...argv];
+
+  if (tokens[0] && COMMANDS.has(tokens[0])) {
+    args.command = tokens.shift();
+  }
+
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (token === '--extension-id' && tokens[i + 1]) args.extensionId = tokens[++i];
+    else if (token === '--browser' && tokens[i + 1]) args.browser = tokens[++i].toLowerCase();
+    else if (token === '--skip-officecli') args.skipOfficecli = true;
+    else if (token === '--force-officecli') args.forceOfficecli = true;
+    else if (token === '--help' || token === '-h') {
+      printHelp();
+      process.exit(0);
+    } else {
+      throw new Error(`Unknown option: ${token}`);
+    }
+  }
+
+  if (!SUPPORTED_BROWSERS.has(args.browser)) {
+    throw new Error(`Unsupported browser: ${args.browser}`);
+  }
+
+  return args;
+}
+
+function printHelp() {
+  console.log(`DeepSeek++ Shell Native Host installer
+
+Usage:
+  deepseek-pp-shell-host install --browser chrome --extension-id <extension-id>
+  deepseek-pp-shell-host status --browser chrome
+  deepseek-pp-shell-host uninstall --browser chrome
+
+Commands:
+  install              Install the Shell Native Host and OfficeCLI
+  status               Show manifest, host, and OfficeCLI status
+  uninstall            Remove the Shell Native Host manifest and installed host files
+
+Options:
+  --extension-id <id>  Chrome/Edge/Chromium extension ID
+  --browser <name>     Target browser: chrome, chromium, edge, firefox (default: chrome)
+  --skip-officecli     Install only the Shell Native Host
+  --force-officecli    Reinstall OfficeCLI even if a compatible binary exists
+  --help               Show this help
+
+Examples:
+  npx deepseek-pp-shell-host install --browser chrome --extension-id abcdefghijklmnopqrstuvwxyz123456
+  npx deepseek-pp-shell-host install --browser firefox
+`);
+}
+
+function getAppDataRoot() {
+  const home = homedir();
+  if (platform() === 'darwin') return `${home}/Library/Application Support/DeepSeek++`;
+  if (platform() === 'linux') return `${home}/.local/share/deepseek-pp`;
+  if (platform() === 'win32') {
+    const localAppData = process.env.LOCALAPPDATA || resolve(home, 'AppData', 'Local');
+    return resolve(localAppData, 'DeepSeek++');
+  }
+  throw new Error(`Unsupported platform: ${platform()}`);
+}
+
+function getHostInstallDir() {
+  const root = getAppDataRoot();
+  return platform() === 'linux' ? resolve(root, 'native-host') : resolve(root, 'NativeHost');
+}
+
+function getManifestDir(browser) {
+  const os = platform();
+  const home = homedir();
+
+  if (os === 'darwin') {
+    switch (browser) {
+      case 'chrome': return `${home}/Library/Application Support/Google/Chrome/NativeMessagingHosts`;
+      case 'chromium': return `${home}/Library/Application Support/Chromium/NativeMessagingHosts`;
+      case 'edge': return `${home}/Library/Application Support/Microsoft Edge/NativeMessagingHosts`;
+      case 'firefox': return `${home}/Library/Application Support/Mozilla/NativeMessagingHosts`;
+      default: return `${home}/Library/Application Support/Google/Chrome/NativeMessagingHosts`;
+    }
+  }
+
+  if (os === 'linux') {
+    switch (browser) {
+      case 'chrome': return `${home}/.config/google-chrome/NativeMessagingHosts`;
+      case 'chromium': return `${home}/.config/chromium/NativeMessagingHosts`;
+      case 'edge': return `${home}/.config/microsoft-edge/NativeMessagingHosts`;
+      case 'firefox': return `${home}/.mozilla/native-messaging-hosts`;
+      default: return `${home}/.config/google-chrome/NativeMessagingHosts`;
+    }
+  }
+
+  if (os === 'win32') {
+    return resolve(getAppDataRoot(), 'NativeMessagingHosts');
+  }
+
+  throw new Error(`Unsupported platform: ${os}`);
+}
+
+function getManifestPath(browser) {
+  return resolve(getManifestDir(browser), `${HOST_NAME}.json`);
+}
+
+function getRegistryKey(browser) {
+  switch (browser) {
+    case 'chrome': return `HKCU\\Software\\Google\\Chrome\\NativeMessagingHosts\\${HOST_NAME}`;
+    case 'edge': return `HKCU\\Software\\Microsoft\\Edge\\NativeMessagingHosts\\${HOST_NAME}`;
+    case 'chromium': return `HKCU\\Software\\Chromium\\NativeMessagingHosts\\${HOST_NAME}`;
+    default: return null;
+  }
+}
+
+function buildManifest(args, wrapperPath) {
+  const manifest = {
+    name: HOST_NAME,
+    description: 'DeepSeek++ Shell MCP - General purpose shell execution via Native Messaging',
+    path: wrapperPath,
+    type: 'stdio',
+  };
+
+  if (args.browser === 'firefox') {
+    manifest.allowed_extensions = [FIREFOX_EXTENSION_ID];
+  } else {
+    if (!args.extensionId) {
+      throw new Error('--extension-id is required for Chrome/Edge/Chromium.');
+    }
+    manifest.allowed_origins = [`chrome-extension://${args.extensionId}/`];
+  }
+
+  return manifest;
+}
+
+function copyHostScript(installDir) {
+  const hostPath = resolve(installDir, 'shell-mcp-host.mjs');
+  mkdirSync(installDir, { recursive: true });
+  copyFileSync(HOST_SOURCE, hostPath);
+  if (platform() !== 'win32') chmodSync(hostPath, 0o755);
+  return hostPath;
+}
+
+function createWrapper(hostPath) {
+  const installDir = dirname(hostPath);
+  const nodePath = process.execPath;
+
+  if (platform() === 'win32') {
+    const wrapperPath = resolve(installDir, 'shell-mcp-host.bat');
+    const content = `@echo off\r\n"${nodePath}" "${hostPath}" %*\r\n`;
+    writeFileSync(wrapperPath, content);
+    return wrapperPath;
+  }
+
+  const wrapperPath = resolve(installDir, 'shell-mcp-host');
+  const content = `#!/bin/sh\nexec "${nodePath}" "${hostPath}" "$@"\n`;
+  writeFileSync(wrapperPath, content, { mode: 0o755 });
+  return wrapperPath;
+}
+
+function writeWindowsRegistry(browser, manifestPath) {
+  const regKey = getRegistryKey(browser);
+  if (!regKey) return;
+
+  try {
+    execSync(`reg add "${regKey}" /ve /t REG_SZ /d "${manifestPath}" /f`, { stdio: 'pipe' });
+    console.log(`Registry: ${regKey}`);
+  } catch {
+    console.error('Warning: Failed to write registry key. You may need to run as Administrator.');
+    console.error(`  Manual: reg add "${regKey}" /ve /t REG_SZ /d "${manifestPath}" /f`);
+  }
+}
+
+function removeWindowsRegistry(browser) {
+  const regKey = getRegistryKey(browser);
+  if (!regKey) return;
+
+  try {
+    execSync(`reg delete "${regKey}" /f`, { stdio: 'pipe' });
+    console.log(`Removed registry key: ${regKey}`);
+  } catch {
+    console.log(`Registry key not removed or was already absent: ${regKey}`);
+  }
+}
+
+function getOfficeCliInstallDir() {
+  if (platform() === 'win32') {
+    const localAppData = process.env.LOCALAPPDATA || resolve(homedir(), 'AppData', 'Local');
+    return resolve(localAppData, 'OfficeCLI');
+  }
+  return resolve(homedir(), '.local', 'bin');
+}
+
+function isProjectNodeModulesPath(path) {
+  const normalized = path.replaceAll('\\', '/');
+  return normalized.includes('/node_modules/.bin/');
+}
+
+function getPathOfficeCliCandidates() {
+  const command = platform() === 'win32' ? 'where.exe' : 'which';
+  const args = platform() === 'win32' ? [OFFICECLI_BINARY] : ['-a', 'officecli'];
+  try {
+    const out = execFileSync(command, args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+    return out
+      .split(/\r?\n/)
+      .map(line => line.trim())
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function getOfficeCliCandidates() {
+  const installPath = resolve(getOfficeCliInstallDir(), OFFICECLI_BINARY);
+  const candidates = [installPath, ...getPathOfficeCliCandidates()]
+    .filter(candidate => !isProjectNodeModulesPath(candidate));
+  return [...new Set(candidates)];
+}
+
+function isCompatibleOfficeCli(binaryPath) {
+  if (!existsSync(binaryPath)) return false;
+  try {
+    const help = execFileSync(binaryPath, ['--help'], {
+      encoding: 'utf8',
+      timeout: 20_000,
+      env: { ...process.env, OFFICECLI_SKIP_UPDATE: '1' },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    return OFFICECLI_REQUIRED_HELP_PATTERNS.every(pattern => pattern.test(help));
+  } catch {
+    return false;
+  }
+}
+
+function findCompatibleOfficeCli() {
+  return getOfficeCliCandidates().find(isCompatibleOfficeCli) ?? null;
+}
+
+function detectLinuxMusl() {
+  if (existsSync('/etc/alpine-release')) return true;
+  try {
+    const out = execFileSync('ldd', ['--version'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+    return /musl/i.test(out);
+  } catch {
+    return false;
+  }
+}
+
+function getOfficeCliAssetName() {
+  const os = platform();
+  const cpu = arch();
+  if (os === 'darwin') {
+    if (cpu === 'arm64') return 'officecli-mac-arm64';
+    if (cpu === 'x64') return 'officecli-mac-x64';
+  }
+  if (os === 'linux') {
+    const distro = detectLinuxMusl() ? 'linux-alpine' : 'linux';
+    if (cpu === 'x64') return `officecli-${distro}-x64`;
+    if (cpu === 'arm64') return `officecli-${distro}-arm64`;
+  }
+  if (os === 'win32') {
+    if (cpu === 'x64') return 'officecli-win-x64.exe';
+    if (cpu === 'arm64') return 'officecli-win-arm64.exe';
+  }
+  throw new Error(`Unsupported OfficeCLI platform: ${os}/${cpu}`);
+}
+
+async function fetchBytes(url) {
+  const response = await fetch(url, {
+    headers: { 'user-agent': 'deepseek-pp-officecli-installer' },
+  });
+  if (!response.ok) {
+    throw new Error(`${response.status} ${response.statusText}`);
+  }
+  return Buffer.from(await response.arrayBuffer());
+}
+
+async function downloadWithFallback(asset, outPath) {
+  const primary = `${OFFICECLI_MIRROR_BASE}/releases/latest/download/${asset}`;
+  const fallback = `${OFFICECLI_GITHUB_RELEASE_BASE}/${asset}`;
+  try {
+    writeFileSync(outPath, await fetchBytes(primary));
+    console.log(`  downloaded ${asset} via mirror`);
+  } catch (primaryError) {
+    console.log(`  mirror unavailable for ${asset}, falling back to GitHub`);
+    try {
+      writeFileSync(outPath, await fetchBytes(fallback));
+    } catch (fallbackError) {
+      throw new Error(`Failed to download ${asset}: mirror=${primaryError.message}; github=${fallbackError.message}`);
+    }
+  }
+}
+
+async function verifyOfficeCliChecksum(asset, binaryPath) {
+  const sumsPath = resolve(tmpdir(), `officecli-SHA256SUMS-${process.pid}`);
+  try {
+    try {
+      await downloadWithFallback('SHA256SUMS', sumsPath);
+    } catch {
+      console.log('  checksum file unavailable, skipping verification');
+      return;
+    }
+    const sums = readFileSync(sumsPath, 'utf8');
+    const expectedLine = sums.split(/\r?\n/).find(line => line.includes(asset));
+    if (!expectedLine) {
+      console.log('  checksum entry not found, skipping verification');
+      return;
+    }
+    const expected = expectedLine.trim().split(/\s+/)[0].toLowerCase();
+    const actual = createHash('sha256').update(readFileSync(binaryPath)).digest('hex');
+    if (actual !== expected) {
+      throw new Error(`Checksum mismatch for ${asset}: expected ${expected}, got ${actual}`);
+    }
+    console.log('  checksum verified');
+  } finally {
+    rmSync(sumsPath, { force: true });
+  }
+}
+
+function verifyDownloadedOfficeCli(binaryPath) {
+  if (platform() !== 'win32') {
+    chmodSync(binaryPath, 0o755);
+  }
+  execFileSync(binaryPath, ['--version'], {
+    timeout: 20_000,
+    stdio: ['ignore', 'ignore', 'pipe'],
+    env: { ...process.env, OFFICECLI_SKIP_UPDATE: '1' },
+  });
+  if (!isCompatibleOfficeCli(binaryPath)) {
+    throw new Error('Downloaded OfficeCLI does not expose the required command-based interface.');
+  }
+}
+
+function addOfficeCliToUserPath(installDir) {
+  if (platform() === 'win32') {
+    try {
+      execFileSync('powershell.exe', [
+        '-NoProfile',
+        '-ExecutionPolicy',
+        'Bypass',
+        '-Command',
+        `$p=[Environment]::GetEnvironmentVariable('Path','User'); if (($p -split ';') -notcontains '${installDir.replaceAll("'", "''")}') { [Environment]::SetEnvironmentVariable('Path', (($p.TrimEnd(';') + ';${installDir.replaceAll("'", "''")}').TrimStart(';')), 'User') }`,
+      ], { stdio: 'pipe' });
+      console.log(`Added ${installDir} to the user PATH.`);
+    } catch {
+      console.log(`Could not update the user PATH automatically. Add this directory manually: ${installDir}`);
+    }
+    return;
+  }
+
+  const shellRc = platform() === 'darwin' || process.env.SHELL?.includes('zsh')
+    ? resolve(homedir(), '.zshrc')
+    : resolve(homedir(), '.bashrc');
+  const pathLine = `export PATH="${installDir}:$PATH"`;
+  try {
+    const existing = existsSync(shellRc) ? readFileSync(shellRc, 'utf8') : '';
+    if (!existing.includes(installDir)) {
+      writeFileSync(shellRc, `${existing}${existing.endsWith('\n') || existing.length === 0 ? '' : '\n'}\n${pathLine}\n`);
+      console.log(`Added ${installDir} to PATH in ${shellRc}.`);
+    }
+  } catch {
+    console.log(`Could not update shell PATH automatically. Add this line manually: ${pathLine}`);
+  }
+}
+
+async function ensureOfficeCliInstalled({ force }) {
+  if (!force) {
+    const existing = findCompatibleOfficeCli();
+    if (existing) {
+      console.log(`OfficeCLI command binary already available: ${existing}`);
+      return existing;
+    }
+  }
+
+  const asset = getOfficeCliAssetName();
+  const installDir = getOfficeCliInstallDir();
+  const targetPath = resolve(installDir, OFFICECLI_BINARY);
+  const tempPath = resolve(tmpdir(), `${OFFICECLI_BINARY}-${process.pid}`);
+  const stagedPath = `${targetPath}.new`;
+
+  console.log(`Installing OfficeCLI from ${OFFICECLI_REPO} (${asset})...`);
+  await downloadWithFallback(asset, tempPath);
+  await verifyOfficeCliChecksum(asset, tempPath);
+  verifyDownloadedOfficeCli(tempPath);
+
+  mkdirSync(installDir, { recursive: true });
+  copyFileSync(tempPath, stagedPath);
+  if (platform() !== 'win32') {
+    chmodSync(stagedPath, 0o755);
+  }
+  if (platform() === 'darwin') {
+    try { execFileSync('xattr', ['-d', 'com.apple.quarantine', stagedPath], { stdio: 'ignore' }); } catch {}
+    try { execFileSync('codesign', ['-s', '-', '-f', stagedPath], { stdio: 'ignore' }); } catch {}
+  }
+  renameSync(stagedPath, targetPath);
+  rmSync(tempPath, { force: true });
+
+  addOfficeCliToUserPath(installDir);
+  console.log(`OfficeCLI installed: ${targetPath}`);
+  return targetPath;
+}
+
+function readManifest(manifestPath) {
+  if (!existsSync(manifestPath)) return null;
+  return JSON.parse(readFileSync(manifestPath, 'utf8'));
+}
+
+function install(args) {
+  const manifestPath = getManifestPath(args.browser);
+  const manifestDir = dirname(manifestPath);
+  const hostPath = copyHostScript(getHostInstallDir());
+  const wrapperPath = createWrapper(hostPath);
+  const manifest = buildManifest(args, wrapperPath);
+
+  mkdirSync(manifestDir, { recursive: true });
+  writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
+
+  if (platform() === 'win32') {
+    writeWindowsRegistry(args.browser, manifestPath);
+  }
+
+  console.log('\nInstalled native messaging host manifest:');
+  console.log(`  ${manifestPath}\n`);
+  console.log(`Host script: ${hostPath}`);
+  console.log(`Wrapper:     ${manifest.path}`);
+  console.log(`Host name:   ${HOST_NAME}`);
+  console.log(`Browser:     ${args.browser}`);
+  if (manifest.allowed_origins) console.log(`Origin:      ${manifest.allowed_origins[0]}`);
+  if (manifest.allowed_extensions) console.log(`Extension:   ${manifest.allowed_extensions[0]}`);
+  console.log('');
+  if (args.skipOfficecli) {
+    console.log('OfficeCLI install skipped by --skip-officecli.');
+  }
+}
+
+function status(args) {
+  const installDir = getHostInstallDir();
+  const hostPath = resolve(installDir, 'shell-mcp-host.mjs');
+  const wrapperPath = resolve(installDir, platform() === 'win32' ? 'shell-mcp-host.bat' : 'shell-mcp-host');
+  const manifestPath = getManifestPath(args.browser);
+  const manifest = readManifest(manifestPath);
+  const officeCli = findCompatibleOfficeCli();
+  const isReady = Boolean(manifest && existsSync(hostPath) && existsSync(manifest.path ?? wrapperPath));
+
+  console.log('DeepSeek++ Shell Native Host status');
+  console.log(`Browser:      ${args.browser}`);
+  console.log(`Host name:    ${HOST_NAME}`);
+  console.log(`Install dir:  ${installDir}`);
+  console.log(`Host script:  ${existsSync(hostPath) ? 'found' : 'missing'} (${hostPath})`);
+  console.log(`Wrapper:      ${existsSync(wrapperPath) ? 'found' : 'missing'} (${wrapperPath})`);
+  console.log(`Manifest:     ${manifest ? 'found' : 'missing'} (${manifestPath})`);
+  if (manifest) {
+    console.log(`Target path:  ${manifest.path}`);
+    if (manifest.allowed_origins) console.log(`Origins:      ${manifest.allowed_origins.join(', ')}`);
+    if (manifest.allowed_extensions) console.log(`Extensions:   ${manifest.allowed_extensions.join(', ')}`);
+  }
+  if (platform() === 'win32') {
+    const regKey = getRegistryKey(args.browser);
+    if (regKey) console.log(`Registry:     ${regKey}`);
+  }
+  console.log(`OfficeCLI:    ${officeCli ? `compatible (${officeCli})` : 'missing or incompatible'}`);
+
+  if (!isReady) {
+    process.exitCode = 1;
+  }
+}
+
+function uninstall(args) {
+  const manifestPath = getManifestPath(args.browser);
+  rmSync(manifestPath, { force: true });
+  if (platform() === 'win32') {
+    removeWindowsRegistry(args.browser);
+  }
+  rmSync(getHostInstallDir(), { recursive: true, force: true });
+  console.log(`Removed Shell Native Host for ${args.browser}.`);
+  console.log('OfficeCLI was left in place because it may be shared by other tools.');
+}
+
+export async function main(argv = process.argv.slice(2)) {
+  const args = parseArgs(argv);
+  if (args.command === 'status') {
+    status(args);
+    return;
+  }
+  if (args.command === 'uninstall') {
+    uninstall(args);
+    return;
+  }
+
+  install(args);
+  if (!args.skipOfficecli) {
+    await ensureOfficeCliInstalled({ force: args.forceOfficecli });
+  }
+  console.log(`\nDone. Restart ${args.browser} to activate.`);
+}
+
+const isDirect = process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isDirect) {
+  main().catch((err) => {
+    console.error(`\nInstall failed: ${err.message}`);
+    process.exit(1);
+  });
+}

package/native/shell-mcp-host.mjs

@@ -0,0 +1,358 @@
+#!/usr/bin/env node
+import { 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 { existsSync } from 'node:fs';
+
+// Resolve package root from this script's location (native/ -> package root).
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PROJECT_ROOT = resolve(__dirname, '..');
+
+// Ensure child processes can find node and project binaries via PATH.
+// Chrome-launched native hosts inherit a minimal PATH that often excludes
+// Homebrew/nvm/fnm directories, breaking #!/usr/bin/env node shebangs.
+const nodeBinDir = dirname(process.execPath);
+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 localAppData = process.env.LOCALAPPDATA || resolve(homedir(), 'AppData', 'Local');
+const userBinDirs = platform() === 'win32'
+  ? [resolve(localAppData, 'OfficeCLI')]
+  : [
+      resolve(homedir(), '.local', 'bin'),
+      '/opt/homebrew/bin',
+      '/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 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 TOOL_DEFINITIONS = [
+  {
+    name: 'shell_exec',
+    title: 'Execute Shell Command',
+    description: 'Execute a shell command on the local system. Returns stdout, stderr, and exit code.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        command: { type: 'string', description: 'The shell command to execute.' },
+        cwd: { type: 'string', description: 'Working directory. Defaults to user home.' },
+        env: { type: 'object', additionalProperties: { type: 'string' }, description: 'Additional environment variables to set.' },
+        timeout_ms: { type: 'integer', minimum: 1000, maximum: 600000, description: 'Timeout in milliseconds. Default 120000.' },
+      },
+      required: ['command'],
+      additionalProperties: false,
+    },
+    annotations: { operation: 'write', risk: 'high' },
+  },
+  {
+    name: 'shell_status',
+    title: 'Shell Host Status',
+    description: 'Report host health, platform, shell, current working directory, and Node.js version.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    annotations: { operation: 'read', risk: 'low' },
+  },
+];
+
+// --- Native messaging framing (4-byte LE length prefix) ---
+
+let buffer = Buffer.alloc(0);
+let messageResolve = null;
+const messageQueue = [];
+
+function onStdinData(chunk) {
+  buffer = Buffer.concat([buffer, chunk]);
+  drainBuffer();
+}
+
+function drainBuffer() {
+  while (true) {
+    if (buffer.length < 4) return;
+    const len = buffer.readUInt32LE(0);
+    if (len === 0 || len > 10 * 1024 * 1024) {
+      process.stderr.write(`[shell-mcp-host] Invalid message length: ${len}\n`);
+      process.exit(1);
+    }
+    if (buffer.length < 4 + len) return;
+    const json = buffer.subarray(4, 4 + len).toString('utf8');
+    buffer = buffer.subarray(4 + len);
+    try {
+      const msg = JSON.parse(json);
+      if (messageResolve) {
+        const r = messageResolve;
+        messageResolve = null;
+        r(msg);
+      } else {
+        messageQueue.push(msg);
+      }
+    } catch (err) {
+      process.stderr.write(`[shell-mcp-host] JSON parse error: ${err.message}\n`);
+    }
+  }
+}
+
+let stdinEnded = false;
+const EOF = Symbol('EOF');
+
+function readMessage() {
+  if (messageQueue.length > 0) return Promise.resolve(messageQueue.shift());
+  if (stdinEnded) return Promise.resolve(EOF);
+  return new Promise((resolve) => { messageResolve = resolve; });
+}
+
+process.stdin.on('data', onStdinData);
+process.stdin.on('end', () => {
+  stdinEnded = true;
+  if (messageResolve) {
+    const r = messageResolve;
+    messageResolve = null;
+    r(EOF);
+  }
+});
+process.stdin.on('error', () => {
+  stdinEnded = true;
+  if (messageResolve) {
+    const r = messageResolve;
+    messageResolve = null;
+    r(EOF);
+  }
+});
+
+function writeNativeMessage(message) {
+  return new Promise((resolve) => {
+    const json = JSON.stringify(message);
+    const body = Buffer.from(json, 'utf8');
+    const header = Buffer.alloc(4);
+    header.writeUInt32LE(body.length, 0);
+    process.stdout.write(header);
+    process.stdout.write(body, resolve);
+  });
+}
+
+// --- JSON-RPC helpers ---
+
+function jsonRpcResult(id, result) {
+  return { jsonrpc: '2.0', id, result };
+}
+
+function jsonRpcError(id, code, message, data) {
+  return { jsonrpc: '2.0', id, error: { code, message, ...(data ? { data } : {}) } };
+}
+
+// --- Request handlers ---
+
+function handleInitialize(id) {
+  return jsonRpcResult(id, {
+    protocolVersion: MCP_PROTOCOL_VERSION,
+    capabilities: { tools: {} },
+    serverInfo: { name: 'deepseek-pp-shell', version: '1.0.0' },
+    instructions: 'General-purpose shell execution host. Use shell_exec to run any command on the local system.',
+  });
+}
+
+function handleListTools(id) {
+  return jsonRpcResult(id, { tools: TOOL_DEFINITIONS });
+}
+
+async function handleCallTool(id, params) {
+  const name = params?.name;
+  const args = params?.arguments ?? {};
+
+  if (name === 'shell_status') {
+    return jsonRpcResult(id, {
+      content: [{ type: 'text', text: `Shell host ready on ${platform()} ${arch()}` }],
+      structuredContent: {
+        ok: true,
+        data: {
+          platform: platform(),
+          arch: arch(),
+          shell: DEFAULT_SHELL,
+          cwd: homedir(),
+          nodeVersion: process.version,
+          hostname: hostname(),
+        },
+      },
+    });
+  }
+
+  if (name === 'shell_exec') {
+    const command = args.command;
+    if (typeof command !== 'string' || command.trim().length === 0) {
+      return jsonRpcResult(id, {
+        isError: true,
+        content: [{ type: 'text', text: 'command is required and must be a non-empty string.' }],
+      });
+    }
+
+    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 timeoutMs = typeof args.timeout_ms === 'number' && args.timeout_ms >= 1000
+      ? Math.min(args.timeout_ms, 600_000)
+      : DEFAULT_TIMEOUT_MS;
+
+    try {
+      const result = await execCommand(command, { cwd, env, timeoutMs });
+      return jsonRpcResult(id, {
+        content: [{ type: 'text', text: formatExecSummary(result) }],
+        structuredContent: {
+          ok: result.exitCode === 0,
+          data: result,
+        },
+        isError: result.exitCode !== 0,
+      });
+    } catch (err) {
+      return jsonRpcResult(id, {
+        isError: true,
+        content: [{ type: 'text', text: err.message }],
+      });
+    }
+  }
+
+  return jsonRpcError(id, -32602, `Unknown tool: ${name}`);
+}
+
+// --- Shell execution ---
+
+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 child = spawn(shellBin, shellArgs, {
+      cwd,
+      env,
+      shell: false,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      windowsHide: true,
+    });
+
+    const stdout = [];
+    const stderr = [];
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
+    let timedOut = false;
+
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill('SIGTERM');
+      setTimeout(() => child.kill('SIGKILL'), 3000);
+    }, timeoutMs);
+
+    child.stdout.on('data', (chunk) => {
+      if (stdoutBytes < MAX_OUTPUT_BYTES) {
+        const remaining = MAX_OUTPUT_BYTES - stdoutBytes;
+        stdout.push(chunk.length <= remaining ? chunk : chunk.subarray(0, remaining));
+      }
+      stdoutBytes += chunk.length;
+    });
+
+    child.stderr.on('data', (chunk) => {
+      if (stderrBytes < MAX_OUTPUT_BYTES) {
+        const remaining = MAX_OUTPUT_BYTES - stderrBytes;
+        stderr.push(chunk.length <= remaining ? chunk : chunk.subarray(0, remaining));
+      }
+      stderrBytes += chunk.length;
+    });
+
+    child.on('error', (err) => {
+      clearTimeout(timer);
+      reject(new Error(`Failed to spawn command: ${err.message}`));
+    });
+
+    child.on('close', (exitCode, signal) => {
+      clearTimeout(timer);
+      resolve({
+        command,
+        exitCode: timedOut ? -1 : (exitCode ?? -1),
+        signal: signal || (timedOut ? 'SIGTERM' : null),
+        stdout: Buffer.concat(stdout).toString('utf8'),
+        stderr: Buffer.concat(stderr).toString('utf8'),
+        truncated: stdoutBytes > MAX_OUTPUT_BYTES || stderrBytes > MAX_OUTPUT_BYTES,
+        timedOut,
+      });
+    });
+  });
+}
+
+function formatExecSummary(result) {
+  const parts = [];
+  if (result.timedOut) parts.push('[TIMED OUT]');
+  if (result.exitCode !== 0) parts.push(`[exit ${result.exitCode}]`);
+  if (result.truncated) parts.push('[output truncated]');
+  if (result.stdout) parts.push(result.stdout.slice(0, 4000));
+  if (result.stderr) parts.push(`STDERR: ${result.stderr.slice(0, 2000)}`);
+  return parts.join('\n') || '(no output)';
+}
+
+// --- Message dispatch ---
+
+async function handleMessage(envelope) {
+  if (envelope.protocol !== 'deepseek-pp-mcp-native' || envelope.version !== 1) {
+    await writeNativeMessage(jsonRpcError(null, -32600, 'Invalid envelope: expected deepseek-pp-mcp-native v1'));
+    return;
+  }
+
+  const message = envelope.message;
+  if (!message || typeof message !== 'object' || message.jsonrpc !== '2.0' || typeof message.method !== 'string') {
+    await writeNativeMessage(jsonRpcError(null, -32600, 'Invalid JSON-RPC request.'));
+    return;
+  }
+
+  const id = message.id ?? null;
+
+  if (!('id' in message)) {
+    return;
+  }
+
+  let response;
+  switch (message.method) {
+    case 'initialize':
+      response = handleInitialize(id);
+      break;
+    case 'tools/list':
+      response = handleListTools(id);
+      break;
+    case 'tools/call':
+      response = await handleCallTool(id, message.params);
+      break;
+    default:
+      response = jsonRpcError(id, -32601, `Unsupported method: ${message.method}`);
+  }
+
+  await writeNativeMessage(response);
+}
+
+// --- Persistent main loop ---
+
+async function main() {
+  while (true) {
+    let envelope;
+    try {
+      envelope = await readMessage();
+    } catch {
+      break;
+    }
+    if (envelope === EOF) break;
+    try {
+      await handleMessage(envelope);
+    } catch (err) {
+      process.stderr.write(`[shell-mcp-host] Error: ${err.message || err}\n`);
+      await writeNativeMessage(jsonRpcError(null, -32603, err.message || 'Internal error'));
+    }
+  }
+}
+
+main().catch((err) => {
+  process.stderr.write(`[shell-mcp-host] Fatal: ${err.message || err}\n`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "deepseek-pp-shell-host",
+  "version": "0.4.4",
+  "description": "Native Messaging Shell MCP host installer for DeepSeek++",
+  "type": "module",
+  "private": false,
+  "bin": {
+    "deepseek-pp-shell-host": "bin/deepseek-pp-shell-host.mjs"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "native/",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18.17"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}