hupilot-shell-host 1.0.0

package/bin/hupilot-shell-host.mjs

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+import { parseArgs, install, status, uninstall } from '../lib/installer.mjs';
+import { COMMANDS } from '../lib/constants.mjs';
+
+const args = process.argv.slice(2);
+
+if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
+  console.log('Hupilot Shell Native Host\n');
+  console.log('Usage:');
+  console.log('  hupilot-shell-host install --browser edge --extension-id <id>');
+  console.log('  hupilot-shell-host status --browser edge');
+  console.log('  hupilot-shell-host uninstall --browser edge\n');
+  console.log('Commands:');
+  console.log('  install    Install the Shell Native Host');
+  console.log('  status     Show installation status');
+  console.log('  uninstall  Remove the Shell Native Host\n');
+  console.log('Options:');
+  console.log('  --extension-id <id>  Extension ID for Chrome/Edge/Chromium');
+  console.log('  --browser <name>     chrome, chromium, edge, or firefox (default: chrome)');
+  process.exit(0);
+}
+
+const command = COMMANDS.has(args[0]) ? args[0] : 'install';
+const opts = parseArgs(args);
+
+switch (opts.command) {
+  case 'install':
+    install(args);
+    break;
+  case 'status':
+    status(opts);
+    break;
+  case 'uninstall':
+    uninstall(opts);
+    break;
+  default:
+    console.error('Unknown command: ' + opts.command);
+    process.exit(1);
+}

package/lib/constants.mjs

@@ -0,0 +1,11 @@
+export const HOST_NAME = 'com.hupilot.shell';
+export const MCP_PROTOCOL_VERSION = '2025-06-18';
+export const DEFAULT_TIMEOUT_MS = 120_000;
+export const MAX_OUTPUT_BYTES = 128_000;
+export const DEFAULT_PYTHON_TIMEOUT_MS = 10_000;
+export const MAX_PYTHON_TIMEOUT_MS = 30_000;
+export const MAX_PYTHON_CODE_BYTES = 60_000;
+export const MAX_PYTHON_OUTPUT_BYTES = 64_000;
+export const SUPPORTED_BROWSERS = new Set(['chrome', 'chromium', 'edge', 'firefox']);
+export const COMMANDS = new Set(['install', 'status', 'uninstall']);
+export const DEFAULT_EXTENSION_ID = 'kgpeoblpookpclfcoicagocelngcaohe';

package/lib/installer.mjs

@@ -0,0 +1,267 @@
+import { chmodSync, copyFileSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { execFileSync, execSync } from 'node:child_process';
+import { dirname, resolve } from 'node:path';
+import { homedir, platform } from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { HOST_NAME, SUPPORTED_BROWSERS, COMMANDS, DEFAULT_EXTENSION_ID } from './constants.mjs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PACKAGE_ROOT = resolve(__dirname, '..');
+const HOST_SOURCE = resolve(PACKAGE_ROOT, 'native', 'hupilot-shell-host.mjs');
+
+function parseArgs(argv) {
+  const args = { command: 'install', extensionId: null, browser: 'chrome' };
+  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 === '--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('Hupilot Shell Native Host installer\n');
+  console.log('Usage:');
+  console.log('  hupilot-shell-host install --browser chrome --extension-id <extension-id>');
+  console.log('  hupilot-shell-host status --browser chrome');
+  console.log('  hupilot-shell-host uninstall --browser chrome\n');
+  console.log('Commands:');
+  console.log('  install              Install the Shell Native Host');
+  console.log('  status               Show installation status');
+  console.log('  uninstall            Remove the Shell Native Host\n');
+  console.log('Options:');
+  console.log('  --extension-id <id>  Extension ID for the target browser');
+  console.log('  --browser <name>     Target browser: chrome, chromium, edge, firefox (default: chrome)');
+  console.log('  --help               Show this help\n');
+  console.log('Examples:');
+  console.log('  npx hupilot-shell-host install --browser edge --extension-id ' + DEFAULT_EXTENSION_ID);
+}
+
+function getAppDataRoot() {
+  const home = homedir();
+  if (platform() === 'darwin') return home + '/Library/Application Support/Hupilot';
+  if (platform() === 'linux') return home + '/.local/share/hupilot';
+  if (platform() === 'win32') {
+    const localAppData = process.env.LOCALAPPDATA || resolve(home, 'AppData', 'Local');
+    return resolve(localAppData, 'Hupilot');
+  }
+  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 home = homedir();
+  const os = platform();
+
+  if (os === 'darwin') {
+    const map = { chrome: 'Google/Chrome', chromium: 'Chromium', edge: 'Microsoft Edge', firefox: 'Mozilla' };
+    return home + '/Library/Application Support/' + (map[browser] || 'Google/Chrome') + '/NativeMessagingHosts';
+  }
+  if (os === 'linux') {
+    const map = { chrome: 'google-chrome', chromium: 'chromium', edge: 'microsoft-edge', firefox: 'mozilla' };
+    return home + '/.config/' + (map[browser] || 'google-chrome') + '/NativeMessagingHosts';
+  }
+  if (os === 'win32') {
+    return resolve(getAppDataRoot(), 'NativeMessagingHosts');
+  }
+  throw new Error('Unsupported platform: ' + os);
+}
+
+function getRegistryKey(browser) {
+  const map = { chrome: 'Google\\Chrome', edge: 'Microsoft\\Edge', chromium: 'Chromium' };
+  const key = map[browser];
+  if (!key) return null;
+  return 'HKCU\\Software\\' + key + '\\NativeMessagingHosts\\' + HOST_NAME;
+}
+
+function buildManifest(args, wrapperPath) {
+  const manifest = {
+    name: HOST_NAME,
+    description: 'Hupilot Shell Native Host - local command execution and file access',
+    path: wrapperPath,
+    type: 'stdio',
+  };
+  if (args.browser === 'firefox') {
+    manifest.allowed_extensions = [args.extensionId || 'hupilot@firefox'];
+  } else {
+    const extId = args.extensionId || DEFAULT_EXTENSION_ID;
+    manifest.allowed_origins = ['chrome-extension://' + extId + '/'];
+  }
+  return manifest;
+}
+
+function copyHostScript(installDir) {
+  const hostPath = resolve(installDir, 'hupilot-shell-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, 'hupilot-shell-host.bat');
+    const content = '@echo off\r\n"' + nodePath + '" "' + hostPath + '" %*\r\n';
+    writeFileSync(wrapperPath, content);
+    return wrapperPath;
+  }
+
+  const wrapperPath = resolve(installDir, 'hupilot-shell-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. Try running 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 found or already removed: ' + regKey);
+  }
+}
+
+function writeManifest(args, wrapperPath) {
+  const manifestDir = getManifestDir(args.browser);
+  const manifestPath = resolve(manifestDir, HOST_NAME + '.json');
+  mkdirSync(manifestDir, { recursive: true });
+
+  const manifest = buildManifest(args, wrapperPath);
+  writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), 'utf8');
+  console.log('Manifest: ' + manifestPath);
+  return manifestPath;
+}
+
+function removeManifest(browser) {
+  const manifestDir = getManifestDir(browser);
+  const manifestPath = resolve(manifestDir, HOST_NAME + '.json');
+  try {
+    rmSync(manifestPath, { force: true });
+    console.log('Removed manifest: ' + manifestPath);
+  } catch {
+    console.log('Manifest not found: ' + manifestPath);
+  }
+}
+
+function getHostStatus(browser) {
+  const installDir = getHostInstallDir();
+  const hostPath = resolve(installDir, 'hupilot-shell-host.mjs');
+  const manifestDir = getManifestDir(browser);
+  const manifestPath = resolve(manifestDir, HOST_NAME + '.json');
+
+  console.log('Platform: ' + platform());
+  console.log('');
+  console.log('Host script:');
+  console.log('  Path: ' + hostPath);
+  console.log('  Installed: ' + (existsSync(hostPath) ? 'Yes' : 'No'));
+  console.log('');
+  console.log('Native Messaging manifest:');
+  console.log('  Path: ' + manifestPath);
+  if (existsSync(manifestPath)) {
+    try {
+      const content = JSON.parse(readFileSync(manifestPath, 'utf8'));
+      console.log('  Name: ' + content.name);
+      console.log('  Path: ' + content.path);
+      console.log('  Allowed: ' + JSON.stringify(content.allowed_origins || content.allowed_extensions || []));
+    } catch (e) {
+      console.log('  (invalid JSON)');
+    }
+  } else {
+    console.log('  Installed: No');
+  }
+
+  if (platform() === 'win32') {
+    const regKey = getRegistryKey(browser);
+    console.log('');
+    console.log('Registry:');
+    if (regKey) {
+      try {
+        const out = execSync('reg query "' + regKey + '" /ve', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+        console.log('  Key: ' + regKey);
+        console.log('  ' + out.trim().split('\n').pop());
+      } catch {
+        console.log('  Not found: ' + regKey);
+      }
+    }
+  }
+}
+
+export { parseArgs };
+
+export function install(args) {
+  console.log('Installing Hupilot Shell Native Host...');
+  args = parseArgs(args);
+
+  const installDir = getHostInstallDir();
+  const hostPath = copyHostScript(installDir);
+  console.log('Copied host script to: ' + hostPath);
+
+  const wrapperPath = createWrapper(hostPath);
+  console.log('Created wrapper: ' + wrapperPath);
+
+  const manifestPath = writeManifest(args, wrapperPath);
+
+  if (platform() === 'win32') {
+    writeWindowsRegistry(args.browser, manifestPath);
+  }
+
+  console.log('');
+  console.log('Installation complete! Restart your browser to activate.');
+  console.log('Then in Hupilot settings, click "Test Connection" to verify.');
+}
+
+export function status(args) {
+  getHostStatus(args.browser || 'chrome');
+}
+
+export function uninstall(args) {
+  const browser = args.browser || 'chrome';
+  console.log('Uninstalling Hupilot Shell Native Host...');
+
+  removeManifest(browser);
+  if (platform() === 'win32') removeWindowsRegistry(browser);
+
+  const installDir = getHostInstallDir();
+  try {
+    rmSync(installDir, { recursive: true, force: true });
+    console.log('Removed: ' + installDir);
+  } catch {
+    console.log('Not found: ' + installDir);
+  }
+
+  console.log('Uninstall complete.');
+}

package/native/hupilot-shell-host.mjs

@@ -0,0 +1,426 @@
+import { spawn, execFileSync } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { homedir, platform, tmpdir, hostname, arch, release as osRelease, type as osType, version as osVersion } from 'node:os';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const MCP_PROTOCOL_VERSION = '2025-06-18';
+const DEFAULT_TIMEOUT_MS = 120000;
+const MAX_OUTPUT_BYTES = 128000;
+const DEFAULT_PYTHON_TIMEOUT_MS = 10000;
+const MAX_PYTHON_TIMEOUT_MS = 30000;
+const MAX_OUTPUT_CHARS = 50000;
+
+const TOOL_DEFINITIONS = [
+  {
+    name: 'shell_status',
+    description: 'Report host health, platform, shell, and environment information.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+  },
+  {
+    name: 'shell_exec',
+    description: 'Execute a command in the system shell and return 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.' },
+        timeout_ms: { type: 'integer', minimum: 1000, maximum: 600000, description: 'Timeout in ms. Default 120000.' },
+      },
+      required: ['command'],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: 'python_exec',
+    description: 'Execute short Python code for calculation, data processing, and analysis.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        code: { type: 'string', description: 'Python code to execute.' },
+        timeout_ms: { type: 'integer', minimum: 1000, maximum: 30000, description: 'Timeout in ms. Default 10000.' },
+      },
+      required: ['code'],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: 'local_folder_pick',
+    description: 'Open the operating system folder picker and return the selected absolute path.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        title: { type: 'string', description: 'Optional prompt shown in the native folder picker.' },
+      },
+      additionalProperties: false,
+    },
+  },
+];
+
+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.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('[hupilot-shell] 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) { messageResolve(EOF); messageResolve = null; }
+});
+process.stdin.on('error', () => {
+  stdinEnded = true;
+  if (messageResolve) { messageResolve(EOF); messageResolve = null; }
+});
+
+function writeMessage(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);
+  });
+}
+
+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 } : {}) } };
+}
+
+function handleInitialize(id) {
+  return jsonRpcResult(id, {
+    protocolVersion: MCP_PROTOCOL_VERSION,
+    capabilities: { tools: {} },
+    serverInfo: { name: 'hupilot-shell', version: '1.0.0' },
+    instructions: 'Hupilot shell execution host. Use shell_exec for local commands, python_exec for Python code, local_folder_pick to select folders.',
+  });
+}
+
+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() }],
+    });
+  }
+
+  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.' }] });
+    }
+    const cwd = typeof args.cwd === 'string' && args.cwd.trim() ? args.cwd.trim() : homedir();
+    const timeoutMs = typeof args.timeout_ms === 'number' && args.timeout_ms >= 1000
+      ? Math.min(args.timeout_ms, 600000) : DEFAULT_TIMEOUT_MS;
+    try {
+      const result = await execCommand(command, cwd, timeoutMs);
+      const output = formatOutput(result);
+      return jsonRpcResult(id, {
+        content: [{ type: 'text', text: output }],
+        isError: result.exitCode !== 0,
+      });
+    } catch (err) {
+      return jsonRpcResult(id, { isError: true, content: [{ type: 'text', text: err.message }] });
+    }
+  }
+
+  if (name === 'python_exec') {
+    const code = args.code;
+    if (typeof code !== 'string' || code.trim().length === 0) {
+      return jsonRpcResult(id, { isError: true, content: [{ type: 'text', text: 'code is required.' }] });
+    }
+    const timeoutMs = typeof args.timeout_ms === 'number' && args.timeout_ms >= 1000
+      ? Math.min(args.timeout_ms, MAX_PYTHON_TIMEOUT_MS) : DEFAULT_PYTHON_TIMEOUT_MS;
+    try {
+      const result = await execPython(code, timeoutMs);
+      return jsonRpcResult(id, {
+        content: [{ type: 'text', text: result.output }],
+        isError: result.exitCode !== 0,
+      });
+    } catch (err) {
+      return jsonRpcResult(id, { isError: true, content: [{ type: 'text', text: err.message }] });
+    }
+  }
+
+  if (name === 'local_folder_pick') {
+    try {
+      const selectedPath = pickLocalFolder(args.title || '选择文件夹');
+      return jsonRpcResult(id, {
+        content: [{ type: 'text', text: 'Selected folder: ' + selectedPath }],
+      });
+    } catch (err) {
+      return jsonRpcResult(id, { isError: true, content: [{ type: 'text', text: err.message }] });
+    }
+  }
+
+  return jsonRpcError(id, -32602, 'Unknown tool: ' + name);
+}
+
+function execCommand(command, cwd, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const isWin = platform() === 'win32';
+    const shellBin = isWin ? 'powershell.exe' : (process.env.SHELL || '/bin/sh');
+    const shellArgs = isWin
+      ? ['-NoLogo', '-NoProfile', '-NonInteractive', '-Command', command]
+      : ['-c', command];
+
+    const child = spawn(shellBin, shellArgs, {
+      cwd,
+      env: process.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 formatOutput(result) {
+  const parts = [];
+  if (result.exitCode === -1 && result.timedOut) {
+    parts.push('[TIMEOUT] Command exceeded time limit');
+  }
+  if (result.exitCode !== 0) parts.push('[exit ' + result.exitCode + ']');
+  if (result.truncated) parts.push('[output truncated]');
+  if (result.stdout) parts.push(result.stdout.substring(0, MAX_OUTPUT_CHARS));
+  if (result.stderr) parts.push('STDERR: ' + result.stderr.substring(0, 2000));
+  return parts.join('\n') || '(no output)';
+}
+
+function execPython(code, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const pythonCmd = findPython();
+    if (!pythonCmd) {
+      return reject(new Error('No local Python interpreter found. Install Python and ensure it is in PATH.'));
+    }
+    const tmpDir = mkdtempSync(join(tmpdir(), 'hupilot-python-'));
+    const scriptPath = join(tmpDir, 'script.py');
+    writeFileSync(scriptPath, code, 'utf8');
+
+    try {
+      const output = execFileSync(pythonCmd, [scriptPath], {
+        encoding: 'utf8',
+        timeout: timeoutMs,
+        maxBuffer: MAX_OUTPUT_BYTES,
+        windowsHide: true,
+      });
+      rmSync(tmpDir, { recursive: true, force: true });
+      resolve({ exitCode: 0, output: output || '(no output)' });
+    } catch (err) {
+      rmSync(tmpDir, { recursive: true, force: true });
+      if (err.status !== undefined) {
+        resolve({ exitCode: err.status, output: err.stdout || '' + (err.stderr ? '\nSTDERR:\n' + err.stderr : '') });
+      } else {
+        reject(new Error('Python execution failed: ' + err.message));
+      }
+    }
+  });
+}
+
+function findPython() {
+  const candidates = ['python3', 'python'];
+  for (const cmd of candidates) {
+    try {
+      execFileSync(cmd, ['--version'], { encoding: 'utf8', timeout: 3000, windowsHide: true });
+      return cmd;
+    } catch (e) {}
+  }
+  return null;
+}
+
+function pickLocalFolder(title) {
+  const os = platform();
+  if (os === 'win32') {
+    const script = [
+      'Add-Type -AssemblyName System.Windows.Forms',
+      '$dialog = New-Object System.Windows.Forms.FolderBrowserDialog',
+      '$dialog.Description = \'' + title.replace(/'/g, "''") + '\'',
+      '$dialog.ShowNewFolderButton = $false',
+      'if ($dialog.ShowDialog() -eq [System.Windows.Forms.DialogResult]::OK) {',
+      '  [Console]::Out.Write($dialog.SelectedPath)',
+      '} else {',
+      '  [Environment]::Exit(2)',
+      '}',
+    ].join('; ');
+    try {
+      return execFileSync('powershell.exe', ['-NoProfile', '-STA', '-Command', script], {
+        encoding: 'utf8',
+        timeout: 120000,
+        windowsHide: false,
+      }).trim();
+    } catch (err) {
+      if (err.status === 2) throw new Error('Folder selection was cancelled.');
+      throw new Error('Failed to open folder picker: ' + err.message);
+    }
+  }
+  if (os === 'darwin') {
+    try {
+      return execFileSync('osascript', ['-e', 'set chosenFolder to choose folder with prompt "' + title + '"' + "\nreturn POSIX path of chosenFolder"], {
+        encoding: 'utf8',
+        timeout: 120000,
+      }).trim();
+    } catch (err) {
+      throw new Error('Folder selection was cancelled.');
+    }
+  }
+  if (os === 'linux') {
+    try {
+      return execFileSync('zenity', ['--file-selection', '--directory', '--title', title], {
+        encoding: 'utf8',
+        timeout: 120000,
+      }).trim();
+    } catch (err) {
+      try {
+        return execFileSync('kdialog', ['--getexistingdirectory', homedir(), '--title', title], {
+          encoding: 'utf8',
+          timeout: 120000,
+        }).trim();
+      } catch (e2) {
+        throw new Error('Folder selection cancelled or picker unavailable. Install zenity or kdialog.');
+      }
+    }
+  }
+  throw new Error('Unsupported platform: ' + os);
+}
+
+async function handleMessage(request) {
+  if (!request || request.jsonrpc !== '2.0' || typeof request.method !== 'string') {
+    await writeMessage(jsonRpcError(null, -32600, 'Invalid JSON-RPC request.'));
+    return;
+  }
+
+  const id = request.id ?? null;
+  let response;
+
+  switch (request.method) {
+    case 'initialize':
+      response = handleInitialize(id);
+      break;
+    case 'tools/list':
+      response = handleListTools(id);
+      break;
+    case 'tools/call':
+      response = await handleCallTool(id, request.params);
+      break;
+    default:
+      response = jsonRpcError(id, -32601, 'Unsupported method: ' + request.method);
+  }
+
+  await writeMessage(response);
+}
+
+async function main() {
+  while (true) {
+    let request;
+    try {
+      request = await readMessage();
+    } catch {
+      break;
+    }
+    if (request === EOF) break;
+    try {
+      await handleMessage(request);
+    } catch (err) {
+      process.stderr.write('[hupilot-shell] Error: ' + (err.message || err) + '\n');
+      await writeMessage(jsonRpcError(null, -32603, err.message || 'Internal error'));
+    }
+  }
+}
+
+main().catch((err) => {
+  process.stderr.write('[hupilot-shell] Fatal: ' + (err.message || err) + '\n');
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "hupilot-shell-host",
+  "version": "1.0.0",
+  "description": "Native Messaging host for Hupilot - local command execution and file access",
+  "type": "module",
+  "private": false,
+  "bin": {
+    "hupilot-shell-host": "bin/hupilot-shell-host.mjs"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "native/",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}