claude-code-session-manager 0.104.2 → 0.105.0

package/src/main/lib/cleanEnv.cjs

@@ -11,8 +11,21 @@ const SECRET_KEY_RE = /^(?:.*_)?(TOKEN|API_?KEY|SECRET|PASSWORD|AUTHORIZATION|CO
  * so pty.cjs and pluginInstall.cjs can't drift (one of them was missing
  * /opt/homebrew and broke plugin install on Apple Silicon).
  */
-function userBinDirs() {
-  const home = os.homedir();
+function userBinDirs(opts) {
+  const platform = (opts && opts.platform) || process.platform;
+  if (platform === 'win32') {
+    const env = (opts && opts.env) || process.env;
+    const w = path.win32;
+    const dirs = [];
+    if (env.USERPROFILE) dirs.push(w.join(env.USERPROFILE, '.local', 'bin'));
+    if (env.APPDATA) dirs.push(w.join(env.APPDATA, 'npm'));
+    if (env.ProgramFiles) {
+      dirs.push(w.join(env.ProgramFiles, 'Git', 'cmd'));
+      dirs.push(w.join(env.ProgramFiles, 'nodejs'));
+    }
+    return dirs;
+  }
+  const home = (opts && opts.homedir) || os.homedir();
   return [
     path.join(home, '.claude', 'local'),
     path.join(home, '.local', 'bin'),
@@ -29,10 +42,20 @@ function userBinDirs() {
  *  value to put in a spawned child's PATH so `claude`, node, git, etc. resolve
  *  on macOS even under a stripped Finder/Dock PATH. Appended (not prepended) so
  *  a user's version manager (nvm/asdf/volta/mise) earlier in PATH still wins and
- *  isn't shadowed by /opt/homebrew. */
-function pathWithUserBins() {
-  const base = process.env.PATH || '';
-  return base ? `${base}:${userBinDirs().join(':')}` : userBinDirs().join(':');
+ *  isn't shadowed by /opt/homebrew. Windows: ';' delimiter, and PATH is read
+ *  case-insensitively (the variable is usually `Path`). */
+function pathWithUserBins(opts) {
+  const platform = (opts && opts.platform) || process.platform;
+  const env = (opts && opts.env) || process.env;
+  const win = platform === 'win32';
+  const delim = win ? ';' : ':';
+  let base = env.PATH || '';
+  if (win && !base) {
+    const key = Object.keys(env).find((k) => k.toUpperCase() === 'PATH');
+    base = (key && env[key]) || '';
+  }
+  const dirs = userBinDirs({ ...(opts || {}), platform, env }).join(delim);
+  return base && dirs ? `${base}${delim}${dirs}` : base || dirs;
 }
 
 /**

package/src/main/lib/defaultShell.cjs

@@ -0,0 +1,36 @@
+'use strict';
+
+const path = require('node:path');
+
+/**
+ * Pick the interactive shell for a terminal tab. Pure: every host fact comes in
+ * through `platform` / `env` / `exists` so it is testable for any OS.
+ *
+ * win32: PowerShell 7 (`pwsh.exe`) when found on PATH or under
+ * %ProgramFiles%\PowerShell\7, else the Windows PowerShell 5.1 that ships with
+ * every install. POSIX: `$SHELL` (or /bin/bash) as an interactive login shell.
+ *
+ * @param {{ platform: string, env: Record<string, string | undefined>, exists: (p: string) => boolean }} opts
+ * @returns {{ file: string, args: string[] }}
+ */
+function defaultShell({ platform, env, exists }) {
+  if (platform !== 'win32') {
+    return { file: env.SHELL || '/bin/bash', args: ['-il'] };
+  }
+  const w = path.win32;
+  const pathDirs = (env.PATH || env.Path || '').split(';').filter(Boolean);
+  const programFiles = env.ProgramFiles || 'C:\\Program Files';
+  const candidates = [
+    ...pathDirs.map((d) => w.join(d, 'pwsh.exe')),
+    w.join(programFiles, 'PowerShell', '7', 'pwsh.exe'),
+  ];
+  const pwsh = candidates.find((p) => exists(p));
+  if (pwsh) return { file: pwsh, args: ['-NoLogo'] };
+  const systemRoot = env.SystemRoot || env.windir || 'C:\\Windows';
+  return {
+    file: w.join(systemRoot, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe'),
+    args: ['-NoLogo'],
+  };
+}
+
+module.exports = { defaultShell };

package/src/main/lib/definitionOfDone.cjs

@@ -16,6 +16,7 @@ const { splitFrontmatter } = require('./prdFrontmatter.cjs');
 const { resolvePrdWriteDir } = require('./prdLocations.cjs');
 const schedulerPaths = require('./schedulerPaths.cjs');
 const atomicFs = require('./atomicFs.cjs');
+const { resolveSpawn } = require('./winSpawn.cjs');
 
 // Regex identifying meta/dod slugs that must NOT influence the batchKey.
 // This is the load-bearing loop-avoidance filter: when the gate job itself
@@ -771,10 +772,13 @@ function runOneGateCommand(cmd, { cwd, env }) {
     const label = cmd.argv.join(' ');
     let child;
     try {
-      child = spawn(cmd.argv[0], cmd.argv.slice(1), {
+      const childEnv = { ...env, ...cmd.env };
+      const sp = resolveSpawn(cmd.argv[0], cmd.argv.slice(1), { env: childEnv });
+      child = spawn(sp.command, sp.args, {
         cwd,
-        env: { ...env, ...cmd.env },
+        env: childEnv,
         stdio: ['ignore', 'pipe', 'pipe'],
+        ...(sp.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {}),
         // No shell:true — the sequence was tokenized by tokenizeNoShell.
       });
     } catch {

package/src/main/lib/delegationReadiness.cjs

@@ -24,6 +24,7 @@ const { writeJson, addAllowedRoot } = require('../config.cjs');
 const { cleanChildEnv, pathWithUserBins } = require('./cleanEnv.cjs');
 const { shimPath: guardShimPath, resolveShimTarget, ensureGuardShimsOrError } = require('./guardShims.cjs');
 const { resolveProjectRoot } = require('./opsOwnership.cjs');
+const { nodeShellCommand } = require('./appRuntime.cjs');
 
 const SCHEDULER_MCP_NAME = 'session-manager-scheduler';
 const DEV_PLUGIN_ENABLED_KEY = 'session-manager-dev@session-manager';
@@ -49,7 +50,14 @@ function readJsonSafe(absPath, fallback) {
   }
 }
 
-const SCHEDULER_MCP_FIX_CMD = `claude mcp add ${SCHEDULER_MCP_NAME} --scope user -- node ${SCHEDULER_MCP_SERVER_SCRIPT}`;
+/** Lazy (not a module-load constant) so tests can toggle packaged mode. */
+function schedulerMcpFixCmd() {
+  const cmd = nodeShellCommand(SCHEDULER_MCP_SERVER_SCRIPT);
+  const m = /^ELECTRON_RUN_AS_NODE=1 (.*)$/.exec(cmd);
+  return m
+    ? `claude mcp add ${SCHEDULER_MCP_NAME} --scope user -e ELECTRON_RUN_AS_NODE=1 -- ${m[1]}`
+    : `claude mcp add ${SCHEDULER_MCP_NAME} --scope user -- ${cmd}`;
+}
 
 /**
  * `ok` must mean "an agent in this project can actually reach a working
@@ -79,7 +87,7 @@ function checkSchedulerMcp({ cwd, homeDir }) {
         detail: !isAbsolute
           ? `user-scope ${SCHEDULER_MCP_NAME} registration points at a non-absolute script path (${scriptArg})`
           : `user-scope ${SCHEDULER_MCP_NAME} registration points at a script that no longer exists (${scriptArg})`,
-        fix: SCHEDULER_MCP_FIX_CMD,
+        fix: schedulerMcpFixCmd(),
       };
     }
     return {
@@ -106,7 +114,7 @@ function checkSchedulerMcp({ cwd, homeDir }) {
     label: 'Scheduler MCP server registered',
     ok: false,
     detail: `no ${SCHEDULER_MCP_NAME} entry in ~/.claude.json or ${cwd}/.mcp.json`,
-    fix: SCHEDULER_MCP_FIX_CMD,
+    fix: schedulerMcpFixCmd(),
   };
 }
 
@@ -476,7 +484,7 @@ function checkGuard(def, { cwd, homeDir = os.homedir() }) {
     detail,
     fix: ok
       ? null
-      : `Add a PreToolUse hook to ${cwd}/.claude/settings.json matching ${def.matcher} that runs node ${guardShimPath(def.scriptBasename, homeDir)}${def.nudge ? ' (a nudge, not a hard gate)' : ''}`,
+      : `Add a PreToolUse hook to ${cwd}/.claude/settings.json matching ${def.matcher} that runs ${nodeShellCommand(guardShimPath(def.scriptBasename, homeDir))}${def.nudge ? ' (a nudge, not a hard gate)' : ''}`,
     fixAction: ok ? null : def.fixActionId,
   };
 }
@@ -549,7 +557,7 @@ async function installGuard(def, { cwd, homeDir = os.homedir(), skipShimEnsure =
   }
   const settings = (existing && typeof existing === 'object' && !Array.isArray(existing)) ? existing : {};
 
-  const command = `node ${guardShimPath(def.scriptBasename, homeDir)}`;
+  const command = nodeShellCommand(guardShimPath(def.scriptBasename, homeDir));
   const hooks = (settings.hooks && typeof settings.hooks === 'object') ? settings.hooks : {};
   const preToolUse = Array.isArray(hooks.PreToolUse) ? hooks.PreToolUse.slice() : [];
 

package/src/main/lib/gitWorktree.cjs

@@ -1422,14 +1422,16 @@ async function integrateBranch({ cwd, branch, key, kind, carriedPaths, baseBranc
 
   try {
     await execGit(['merge', '--ff-only', branch], { cwd, timeout: 30_000 });
-    return { ok: true, integrated: true, fastForward: true };
+    // The branch tip we fast-forwarded to, read from the branch ref (not HEAD,
+    // which a concurrent writer may already have moved).
+    return { ok: true, integrated: true, fastForward: true, sha: await tryResolveCommit(cwd, `${branch}^{commit}`) };
   } catch {
     // Main tree advanced since the worktree branched (a sibling job/Epic
     // merged first) — a real merge commit still lands the branch's commit(s).
   }
   try {
     await execGit(['merge', '--no-ff', '--no-edit', '-m', mergeMessage, branch], { cwd, timeout: 30_000 });
-    return { ok: true, integrated: true, mergeCommit: true };
+    return { ok: true, integrated: true, mergeCommit: true, sha: await readHeadSha(cwd) };
   } catch (e) {
     const stderrText = (e && (e.stderrText || e.message)) || String(e);
     // git refuses this class of merge before ever touching MERGE_HEAD, so
@@ -1452,6 +1454,7 @@ async function integrateBranch({ cwd, branch, key, kind, carriedPaths, baseBranc
             ok: true,
             integrated: true,
             mergeCommit: true,
+            sha: await readHeadSha(cwd),
             autoResolved: 'identical_working_tree_duplicates',
             resolvedPaths: allPaths,
           };
@@ -1479,7 +1482,7 @@ async function integrateBranch({ cwd, branch, key, kind, carriedPaths, baseBranc
           await resolveByConcatenation({ cwd, paths });
           await execGit(['add', ...paths], { cwd, timeout: 30_000 });
           await execGit(['commit', '-m', mergeMessage], { cwd, timeout: 30_000 });
-          return { ok: true, integrated: true, mergeCommit: true, autoResolved: 'pure_addition_concat', resolvedPaths: paths };
+          return { ok: true, integrated: true, mergeCommit: true, sha: await readHeadSha(cwd), autoResolved: 'pure_addition_concat', resolvedPaths: paths };
         }
       } catch { /* fall through to the abort */ }
     }

package/src/main/lib/insideHome.cjs

@@ -19,7 +19,8 @@
  * resolved at startup we keep going with the literal value — boot-time
  * self-check in index.cjs surfaces that to the user.
  *
- * Linux + darwin only. No Windows path handling.
+ * win32: containment compares lower-cased, path.win32-normalized paths; UNC
+ * (`\\server\share`) and `\\?\` paths are always outside home.
  */
 'use strict';
 
@@ -52,8 +53,18 @@ function resolveTarget(p) {
   }
 }
 
-function isContained(realPath) {
-  return realPath === HOME_REAL || realPath.startsWith(HOME_REAL + path.sep);
+function isContainedWin32(target, home) {
+  // UNC and \\?\ / \\.\ prefixes can alias any location — never inside home.
+  if (/^[\\/]{2}/.test(target)) return false;
+  const strip = (v) => path.win32.normalize(v).toLowerCase().replace(/[\\/]+$/, '');
+  const t = strip(target);
+  const h = strip(home);
+  return t === h || t.startsWith(h + '\\');
+}
+
+function isContained(realPath, home = HOME_REAL, platform = process.platform) {
+  if (platform === 'win32') return isContainedWin32(realPath, home);
+  return realPath === home || realPath.startsWith(home + path.sep);
 }
 
 function assertInsideHome(p) {
@@ -88,4 +99,4 @@ function checkInsideHome(p) {
   return { ok: true, realPath };
 }
 
-module.exports = { assertInsideHome, checkInsideHome };
+module.exports = { assertInsideHome, checkInsideHome, isContained };

package/src/main/lib/killTree.cjs

@@ -0,0 +1,80 @@
+'use strict';
+
+/**
+ * killTree.cjs — cross-platform "kill this child and its descendants" plus the
+ * matching spawn options for children we intend to kill that way.
+ *
+ * POSIX: children are spawned `detached: true` so they lead their own process
+ * group, and `process.kill(-pid, sig)` signals the whole group.
+ * win32: no process groups; `taskkill /PID <pid> /T /F` kills the tree.
+ */
+
+const { execFile: nodeExecFile } = require('node:child_process');
+
+/**
+ * @typedef {object} KillTreeOpts
+ * @property {string} [platform]  defaults to process.platform
+ * @property {(pid: number, signal?: string | number) => unknown} [kill]  defaults to process.kill
+ * @property {(file: string, args: string[], options: object, cb: (err: Error | null) => void) => unknown} [execFile]
+ * @property {(msg: string) => void} [log]  receives taskkill failure messages
+ */
+
+/**
+ * Kill `pid` and its descendants. Never throws.
+ *
+ * Return contract (deliberately synchronous on every platform so POSIX callers
+ * keep their existing control flow):
+ *  - POSIX: true when a signal was delivered (group first, then the bare pid if
+ *    the group kill threw ESRCH/EPERM), false otherwise.
+ *  - win32: taskkill is started fire-and-forget and true is returned
+ *    immediately when it was launched; its eventual non-zero exit is reported
+ *    through `opts.log`, not the return value. The signal is ignored — taskkill
+ *    /F is always forceful.
+ *
+ * @param {number} pid
+ * @param {string | number} [signal]
+ * @param {KillTreeOpts} [opts]
+ * @returns {boolean}
+ */
+function killTree(pid, signal, opts = {}) {
+  const platform = opts.platform || process.platform;
+  const log = typeof opts.log === 'function' ? opts.log : () => {};
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+
+  if (platform === 'win32') {
+    const execFile = opts.execFile || nodeExecFile;
+    try {
+      execFile('taskkill', ['/PID', String(pid), '/T', '/F'], { windowsHide: true }, (err) => {
+        if (err) {
+          try { log(`[killTree] taskkill /PID ${pid} failed: ${err.message}\n`); } catch { /* log must not throw */ }
+        }
+      });
+      return true;
+    } catch (e) {
+      try { log(`[killTree] taskkill spawn failed: ${e && e.message}\n`); } catch { /* log must not throw */ }
+      return false;
+    }
+  }
+
+  const kill = opts.kill || process.kill.bind(process);
+  try { kill(-pid, signal); return true; } catch (e) {
+    const code = e && e.code;
+    if (code !== 'ESRCH' && code !== 'EPERM') return false;
+  }
+  try { kill(pid, signal); return true; } catch { return false; }
+}
+
+/**
+ * spawn() options for a child that killTree() will later kill.
+ * `detached` makes it a process-group leader on POSIX; on win32 it would open a
+ * console window unless `windowsHide` is set.
+ *
+ * @param {{ platform?: string }} [opts]
+ * @returns {{ detached: true, windowsHide?: true }}
+ */
+function detachedSpawnOpts(opts = {}) {
+  const platform = opts.platform || process.platform;
+  return platform === 'win32' ? { detached: true, windowsHide: true } : { detached: true };
+}
+
+module.exports = { killTree, detachedSpawnOpts };

package/src/main/lib/loadGate.cjs

@@ -116,6 +116,7 @@ function createLoadGate({
   auditIntervalMs = AUDIT_INTERVAL_MS,
   escalateAfterMs = JOB_OVERRUN_FLOOR_MS,
   releaseWindowMs = RELEASE_WINDOW_MS,
+  platform = process.platform,
 } = {}) {
   let lastAuditAt = null; // null = never audited; the first gated tick always audits
   let gatedSince = null;
@@ -124,6 +125,21 @@ function createLoadGate({
 
   function evaluate({ bypass = false } = {}) {
     const t = now();
+    if (platform === 'win32') {
+      // os.loadavg() is always [0,0,0] on Windows — the gate is open, not computed.
+      last = {
+        gated: false,
+        bypassed: false,
+        ratio: 0,
+        threshold: typeof threshold === 'function' ? threshold() : threshold,
+        loadavg1: null,
+        cores: cores(),
+        gatedSinceMs: 0,
+        reason: 'loadavg-unavailable-win32',
+        at: new Date(t).toISOString(),
+      };
+      return { ...last, shouldAudit: false, escalate: false };
+    }
     const [l1] = loadavg();
     const c = cores();
     const th = typeof threshold === 'function' ? threshold() : threshold;

package/src/main/lib/loginShellPath.cjs

@@ -0,0 +1,82 @@
+'use strict';
+
+const { execFile } = require('node:child_process');
+const path = require('node:path');
+
+const START = '__SM_PATH_START__';
+const END = '__SM_PATH_END__';
+const DEFAULT_TIMEOUT_MS = 3000;
+
+/**
+ * A packaged macOS app launched from Finder/Dock inherits only
+ * /usr/bin:/bin:/usr/sbin:/sbin, so nvm/asdf/volta/fnm/Homebrew installs of
+ * node, git and claude are invisible. Ask the user's login shell for its PATH.
+ * Complements cleanEnv.pathWithUserBins (fixed dirs, appended).
+ */
+
+/** @param {{shell?: string, platform?: string, timeoutMs?: number, env?: NodeJS.ProcessEnv}} [opts] */
+function resolveShell(opts) {
+  const platform = opts.platform || process.platform;
+  const env = opts.env || process.env;
+  return opts.shell || env.SHELL || (platform === 'darwin' ? '/bin/zsh' : '/bin/bash');
+}
+
+/**
+ * Login-shell PATH, or null on timeout / non-zero exit / missing markers /
+ * win32 (fail-open: callers keep their current PATH).
+ * @param {{shell?: string, platform?: string, timeoutMs?: number, env?: NodeJS.ProcessEnv}} [opts]
+ * @returns {Promise<string|null>}
+ */
+function readLoginShellPath(opts = {}) {
+  const platform = opts.platform || process.platform;
+  if (platform === 'win32') return Promise.resolve(null);
+  const shell = resolveShell(opts);
+  const cmd = `printf '%s' '${START}'; printf '%s' "$PATH"; printf '%s' '${END}'`;
+  return new Promise((resolve) => {
+    try {
+      execFile(
+        shell,
+        ['-ilc', cmd],
+        { timeout: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS, env: opts.env || process.env, encoding: 'utf8' },
+        (err, stdout) => {
+          if (err) return resolve(null);
+          const out = String(stdout || '');
+          const s = out.indexOf(START);
+          if (s < 0) return resolve(null);
+          const from = s + START.length;
+          const e = out.indexOf(END, from);
+          if (e < 0) return resolve(null);
+          resolve(out.slice(from, e));
+        },
+      );
+    } catch {
+      resolve(null);
+    }
+  });
+}
+
+/**
+ * Prepend login-shell PATH entries not already present to env.PATH
+ * (order preserved, deduped, empties dropped).
+ * @param {{shell?: string, platform?: string, timeoutMs?: number, env?: NodeJS.ProcessEnv}} [opts]
+ * @returns {Promise<{applied: boolean, added: number}>}
+ */
+async function applyLoginShellPath(opts = {}) {
+  const platform = opts.platform || process.platform;
+  if (platform === 'win32') return { applied: false, added: 0 };
+  const loginPath = await readLoginShellPath(opts);
+  if (loginPath === null) return { applied: false, added: 0 };
+  const env = opts.env || process.env;
+  const current = (env.PATH || '').split(path.delimiter).filter(Boolean);
+  const seen = new Set(current);
+  const fresh = [];
+  for (const entry of loginPath.split(path.delimiter)) {
+    if (!entry || seen.has(entry)) continue;
+    seen.add(entry);
+    fresh.push(entry);
+  }
+  if (fresh.length) env.PATH = [...fresh, ...current].join(path.delimiter);
+  return { applied: true, added: fresh.length };
+}
+
+module.exports = { readLoginShellPath, applyLoginShellPath };

package/src/main/lib/machineProfile.cjs

@@ -16,6 +16,7 @@ const os = require('node:os');
 const crypto = require('node:crypto');
 const path = require('node:path');
 const claudeBin = require('./claudeBin.cjs');
+const { isPackagedApp } = require('./appRuntime.cjs');
 
 function resolveElectronApp() {
   try {
@@ -39,12 +40,13 @@ function resolvePackageVersion() {
 }
 
 /**
- * 'npx' when the app path lives inside an npm/npx cache dir, 'dev' when
+ * 'installer' for a packaged app build, 'npx' when the app path lives inside an npm/npx cache dir, 'dev' when
  * SM_DEV is set, else 'unknown'. Injectable so tests never depend on real
  * process state.
  */
-function resolveInstallChannel({ appPath = null, devFlag = !!process.env.SM_DEV } = {}) {
+function resolveInstallChannel({ appPath = null, devFlag = !!process.env.SM_DEV, packaged } = {}) {
   if (devFlag) return 'dev';
+  if (isPackagedApp(typeof packaged === 'boolean' ? { packaged } : undefined)) return 'installer';
   if (typeof appPath === 'string' && /[\\/](\.npm|_npx|npm-cache|npx-cache)[\\/]/i.test(appPath)) {
     return 'npx';
   }

package/src/main/lib/mcpStdioServer.cjs

@@ -0,0 +1,127 @@
+/**
+ * mcpStdioServer.cjs — zero-dependency MCP server over newline-delimited
+ * JSON-RPC 2.0 on stdio. Implements only what the scheduler MCP server uses:
+ * initialize, ping, tools/list, tools/call. Stdout carries protocol messages
+ * only; diagnostics go to stderr.
+ */
+'use strict';
+
+// Copied verbatim from @modelcontextprotocol/sdk dist/cjs/types.js
+// (LATEST_PROTOCOL_VERSION first).
+const SUPPORTED_PROTOCOL_VERSIONS = ['2025-11-25', '2025-06-18', '2025-03-26', '2024-11-05', '2024-10-07'];
+
+const PARSE_ERROR = -32700;
+const METHOD_NOT_FOUND = -32601;
+const INTERNAL_ERROR = -32603;
+
+/**
+ * @param {{
+ *   name: string,
+ *   version: string,
+ *   listTools: () => any[] | Promise<any[]>,
+ *   callTool: (params: any) => Promise<any>,
+ *   input?: NodeJS.ReadableStream,
+ *   output?: NodeJS.WritableStream,
+ * }} opts
+ */
+function createStdioServer({ name, version, listTools, callTool, input = process.stdin, output = process.stdout }) {
+  let buffer = '';
+  let started = false;
+  let closed = false;
+
+  function send(msg) {
+    if (closed) return;
+    try {
+      output.write(JSON.stringify(msg) + '\n');
+    } catch (err) {
+      process.stderr.write(`[mcpStdioServer] write failed: ${err && err.message}\n`);
+    }
+  }
+
+  function sendError(id, code, message) {
+    send({ jsonrpc: '2.0', id, error: { code, message } });
+  }
+
+  async function dispatch(msg) {
+    const hasId = msg && typeof msg === 'object' && msg.id !== undefined && msg.id !== null;
+    if (!hasId) return; // notification (or unusable message): never reply
+    const { id, method, params } = msg;
+    try {
+      let result;
+      switch (method) {
+        case 'initialize': {
+          const requested = params && params.protocolVersion;
+          result = {
+            protocolVersion: SUPPORTED_PROTOCOL_VERSIONS.includes(requested) ? requested : SUPPORTED_PROTOCOL_VERSIONS[0],
+            capabilities: { tools: {} },
+            serverInfo: { name, version },
+          };
+          break;
+        }
+        case 'ping':
+          result = {};
+          break;
+        case 'tools/list':
+          result = { tools: await listTools() };
+          break;
+        case 'tools/call':
+          result = await callTool(params);
+          break;
+        default:
+          sendError(id, METHOD_NOT_FOUND, `Method not found: ${method}`);
+          return;
+      }
+      send({ jsonrpc: '2.0', id, result });
+    } catch (err) {
+      sendError(id, INTERNAL_ERROR, err && err.message ? err.message : String(err));
+    }
+  }
+
+  function handleLine(line) {
+    if (line.endsWith('\r')) line = line.slice(0, -1);
+    if (!line.trim()) return;
+    let msg;
+    try {
+      msg = JSON.parse(line);
+    } catch {
+      sendError(null, PARSE_ERROR, 'Parse error');
+      return;
+    }
+    dispatch(msg).catch((err) => {
+      process.stderr.write(`[mcpStdioServer] dispatch failed: ${err && err.message}\n`);
+    });
+  }
+
+  function onData(chunk) {
+    buffer += typeof chunk === 'string' ? chunk : chunk.toString('utf8');
+    let idx;
+    while ((idx = buffer.indexOf('\n')) !== -1) {
+      const line = buffer.slice(0, idx);
+      buffer = buffer.slice(idx + 1);
+      handleLine(line);
+    }
+  }
+
+  function onEnd() {
+    close();
+  }
+
+  function start() {
+    if (started || closed) return;
+    started = true;
+    input.on('data', onData);
+    input.on('end', onEnd);
+  }
+
+  function close() {
+    if (closed) return;
+    closed = true;
+    input.removeListener('data', onData);
+    input.removeListener('end', onEnd);
+    buffer = '';
+  }
+
+  return { start, close };
+}
+
+module.exports = { createStdioServer, SUPPORTED_PROTOCOL_VERSIONS };