smart-terminal-mcp 1.2.10 → 1.2.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smart-terminal-mcp",
-  "version": "1.2.10",
+  "version": "1.2.12",
   "description": "MCP PTY server providing AI agents with real interactive terminal access",
   "type": "module",
   "main": "src/index.js",
@@ -10,7 +10,7 @@
   "scripts": {
     "start": "node src/index.js",
     "test": "node --test",
-    "stable": "npm dist-tag add smart-terminal-mcp@1.2.0 stable"
+    "stable": "npm dist-tag add smart-terminal-mcp@1.2.9 stable"
   },
   "keywords": [
     "mcp",

package/src/command-runner.js

@@ -116,6 +116,9 @@ export async function runCommand({
 
         if (signal) result.signal = signal;
         if (maxOutputExceeded) result.maxOutputExceeded = true;
+        if (successExitCode === null && exitCode !== 0 && exitCode !== null) {
+          result.exitCodeIgnored = true;
+        }
         if (shouldIncludeSuccessChecks({ successExitCode, successFile })) {
           result.checks = checks.details;
         }
@@ -229,6 +232,14 @@ function buildSpawnPlan({ cmd, args, cwd }) {
   }
 
   const resolvedCommand = resolveWindowsCommand(cmd, cwd);
+
+  // When the caller explicitly invokes cmd.exe with /c (e.g. for shell
+  // built-ins like `for /f`), join the trailing args into a single verbatim
+  // command string so cmd.exe interprets them correctly.
+  if (isExplicitCmdExeCall(resolvedCommand ?? cmd, args)) {
+    return buildCmdExePlan(args);
+  }
+
   if (!resolvedCommand || !isWindowsBatchCommand(resolvedCommand)) {
     return {
       command: resolvedCommand ?? cmd,
@@ -244,6 +255,37 @@ function buildSpawnPlan({ cmd, args, cwd }) {
   };
 }
 
+function isExplicitCmdExeCall(resolved, args) {
+  const comSpec = (process.env.ComSpec || 'cmd.exe').toLowerCase();
+  const name = resolved.toLowerCase();
+  if (name !== comSpec && name !== 'cmd' && name !== 'cmd.exe') return false;
+  return args.some((a) => a.toLowerCase() === '/c');
+}
+
+function buildCmdExePlan(args) {
+  const comSpec = process.env.ComSpec || 'cmd.exe';
+
+  // Collect any flags before /c (e.g. /d, /s) and the command body after /c.
+  const prefixFlags = [];
+  let commandBody = '';
+  let foundSlashC = false;
+  for (let i = 0; i < args.length; i++) {
+    if (!foundSlashC && args[i].toLowerCase() === '/c') {
+      foundSlashC = true;
+      // Everything after /c is the shell command – join into one string.
+      commandBody = args.slice(i + 1).join(' ');
+      break;
+    }
+    prefixFlags.push(args[i]);
+  }
+
+  return {
+    command: comSpec,
+    args: [...prefixFlags, '/s', '/c', `"${commandBody}"`],
+    windowsVerbatimArguments: true,
+  };
+}
+
 function resolveWindowsCommand(cmd, cwd) {
   const pathExts = getWindowsPathExtensions();
   if (looksLikePath(cmd)) {

package/src/session-manager.js

@@ -1,15 +1,24 @@
 import { randomUUID } from 'node:crypto';
+import { stat } from 'node:fs/promises';
+import { resolve as resolvePath } from 'node:path';
+import { platform } from 'node:os';
 import { PtySession } from './pty-session.js';
-import { detectShell } from './shell-detector.js';
+import { detectShell, isAvailable } from './shell-detector.js';
 
 const DEFAULT_TTL_MS = 30 * 60 * 1000; // 30 minutes
 const MAX_SESSIONS = 10;
 const CLEANUP_INTERVAL_MS = 60 * 1000; // Check every minute
+const CWD_ERROR_MESSAGES = {
+  EACCES: 'Permission denied',
+  ENOENT: 'Path does not exist',
+  ENOTDIR: 'A component of the path is not a directory',
+};
 
 export class SessionManager {
-  constructor() {
+  constructor({ SessionClass = PtySession } = {}) {
     /** @type {Map<string, PtySession>} */
     this._sessions = new Map();
+    this._SessionClass = SessionClass;
     this._cleanupTimer = setInterval(() => this._cleanupExpired(), CLEANUP_INTERVAL_MS);
     // Don't keep process alive just for cleanup
     this._cleanupTimer.unref();
@@ -31,18 +40,19 @@ export class SessionManager {
       throw new Error(`Maximum ${MAX_SESSIONS} concurrent sessions reached. Stop an existing session first.`);
     }
 
+    const resolvedCwd = await resolveSessionCwd(cwd);
     const detected = detectShell();
-    const resolvedShell = shell || detected.shell;
+    const resolvedShell = shell ? resolveUserShell(shell) : detected.shell;
     const shellArgs = shell ? [] : detected.args;
 
     const id = randomUUID().slice(0, 8);
-    const session = new PtySession({
+    const session = new this._SessionClass({
       id,
       shell: resolvedShell,
       shellArgs,
       cols,
       rows,
-      cwd: cwd || process.cwd(),
+      cwd: resolvedCwd,
       name,
       env,
     });
@@ -112,6 +122,57 @@ export class SessionManager {
   }
 }
 
+const WINDOWS_SHELL_EXTENSIONS = ['.exe', '.cmd', '.bat'];
+
+/**
+ * Validate and resolve a user-provided shell name.
+ * On Windows, tries appending common extensions if the bare name isn't found.
+ * @param {string} shell
+ * @returns {string} The resolved shell name
+ */
+function resolveUserShell(shell) {
+  if (isAvailable(shell)) return shell;
+
+  // On Windows, try appending .exe etc. so "pwsh" resolves to "pwsh.exe"
+  if (platform() === 'win32' && !shell.includes('.')) {
+    for (const ext of WINDOWS_SHELL_EXTENSIONS) {
+      const candidate = `${shell}${ext}`;
+      if (isAvailable(candidate)) return candidate;
+    }
+  }
+
+  const detected = detectShell();
+  throw new Error(
+    `Shell "${shell}" not found. The auto-detected shell is "${detected.shell}". ` +
+    'Omit the shell parameter to use auto-detection, or provide the full path to the shell executable.',
+  );
+}
+
+export async function resolveSessionCwd(cwd) {
+  const resolvedCwd = resolvePath(cwd ?? process.cwd());
+
+  let stats;
+  try {
+    stats = await stat(resolvedCwd);
+  } catch (err) {
+    throw new Error(`Invalid cwd "${resolvedCwd}": ${formatCwdError(err)}`);
+  }
+
+  if (!stats.isDirectory()) {
+    throw new Error(`Invalid cwd "${resolvedCwd}": Path is not a directory.`);
+  }
+
+  return resolvedCwd;
+}
+
+function formatCwdError(err) {
+  const hint = CWD_ERROR_MESSAGES[err?.code];
+  if (hint) {
+    return `${hint} (${err.code})`;
+  }
+  return err?.message ?? String(err);
+}
+
 function log(msg) {
   process.stderr.write(`[smart-terminal-mcp] ${msg}\n`);
 }

package/src/shell-detector.js

@@ -6,7 +6,7 @@ import { platform } from 'node:os';
  * @param {string} exe
  * @returns {boolean}
  */
-function isAvailable(exe) {
+export function isAvailable(exe) {
   try {
     const cmd = platform() === 'win32' ? 'where' : 'which';
     execFileSync(cmd, [exe], { stdio: 'ignore', timeout: 5000 });

package/src/tools.js

@@ -69,15 +69,27 @@ export function registerTools(server, manager) {
       env: z.record(z.string()).optional().describe('Environment variables'),
     },
     async ({ shell, cols, rows, cwd, name, env }) => {
-      const session = await manager.create({ shell, cols, rows, cwd, name, env });
-      const banner = await session.waitForBanner();
-      return jsonContent({
-        sessionId: session.id,
-        shell: session.shell,
-        shellType: session.shellType,
-        cwd: session.cwd,
-        banner: banner || '(no banner)',
-      });
+      let session;
+      try {
+        session = await manager.create({ shell, cols, rows, cwd, name, env });
+        const banner = await session.waitForBanner();
+        return jsonContent({
+          sessionId: session.id,
+          shell: session.shell,
+          shellType: session.shellType,
+          cwd: session.cwd,
+          banner: banner || '(no banner)',
+        });
+      } catch (err) {
+        if (session?.id && typeof manager.stop === 'function') {
+          try {
+            manager.stop(session.id);
+          } catch {
+            // Preserve the original startup failure.
+          }
+        }
+        throw err;
+      }
     }
   );
 

package/test/session-manager.test.js

@@ -0,0 +1,89 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join, resolve as resolvePath } from 'node:path';
+import { SessionManager, resolveSessionCwd } from '../src/session-manager.js';
+
+test('resolveSessionCwd returns an absolute directory path', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'smart-terminal-mcp-'));
+
+  try {
+    const resolved = await resolveSessionCwd(tempDir);
+    assert.equal(resolved, resolvePath(tempDir));
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test('SessionManager.create rejects invalid cwd before creating a session', async () => {
+  let constructed = 0;
+  class FakeSession {
+    constructor() {
+      constructed++;
+    }
+  }
+
+  const manager = new SessionManager({ SessionClass: FakeSession });
+  const missingDir = join(tmpdir(), `smart-terminal-mcp-missing-${Date.now()}`);
+
+  try {
+    await assert.rejects(
+      () => manager.create({ cwd: missingDir }),
+      (error) => {
+        assert.match(error.message, /^Invalid cwd ".+": Path does not exist \(ENOENT\)$/);
+        return true;
+      }
+    );
+    assert.equal(constructed, 0);
+    assert.equal(manager.list().length, 0);
+  } finally {
+    manager.destroyAll();
+  }
+});
+
+test('SessionManager.create rejects unknown shell before creating a session', async () => {
+  let constructed = 0;
+  class FakeSession {
+    constructor() {
+      constructed++;
+    }
+  }
+
+  const manager = new SessionManager({ SessionClass: FakeSession });
+
+  try {
+    await assert.rejects(
+      () => manager.create({ shell: 'nonexistent-shell-abc123' }),
+      (error) => {
+        assert.match(error.message, /Shell "nonexistent-shell-abc123" not found/);
+        return true;
+      }
+    );
+    assert.equal(constructed, 0);
+    assert.equal(manager.list().length, 0);
+  } finally {
+    manager.destroyAll();
+  }
+});
+
+test('SessionManager.create rejects file cwd values', async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), 'smart-terminal-mcp-'));
+  const filePath = join(tempDir, 'not-a-directory.txt');
+  await writeFile(filePath, 'hello');
+
+  const manager = new SessionManager({
+    SessionClass: class FakeSession { },
+  });
+
+  try {
+    await assert.rejects(
+      () => manager.create({ cwd: filePath }),
+      /Path is not a directory/
+    );
+    assert.equal(manager.list().length, 0);
+  } finally {
+    manager.destroyAll();
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});

package/test/tools.test.js

@@ -111,6 +111,66 @@ test('tool schemas keep agent-friendly default output sizes', () => {
   });
 });
 
+test('terminal_start returns compact session metadata', async () => {
+  const server = createFakeServer();
+  const createCalls = [];
+  const manager = {
+    create: async (opts) => {
+      createCalls.push(opts);
+      return {
+        id: 's1',
+        shell: 'pwsh.exe',
+        shellType: 'powershell',
+        cwd: 'C:/repo',
+        waitForBanner: async () => 'PowerShell 7',
+      };
+    },
+  };
+
+  registerTools(server, manager);
+
+  const result = await server.tools.get('terminal_start').handler({
+    cols: 140,
+    rows: 40,
+    cwd: 'C:/repo',
+    name: 'smc-verify',
+  });
+
+  assert.deepEqual(createCalls, [{ cols: 140, rows: 40, cwd: 'C:/repo', name: 'smc-verify', shell: undefined, env: undefined }]);
+  assert.deepEqual(JSON.parse(result.content[0].text), {
+    sessionId: 's1',
+    shell: 'pwsh.exe',
+    shellType: 'powershell',
+    cwd: 'C:/repo',
+    banner: 'PowerShell 7',
+  });
+});
+
+test('terminal_start stops a created session when banner startup fails', async () => {
+  const server = createFakeServer();
+  const stopCalls = [];
+  const manager = {
+    create: async () => ({
+      id: 's1',
+      cwd: 'C:/repo',
+      waitForBanner: async () => {
+        throw new Error('banner failed');
+      },
+    }),
+    stop: (sessionId) => {
+      stopCalls.push(sessionId);
+    },
+  };
+
+  registerTools(server, manager);
+
+  await assert.rejects(
+    () => server.tools.get('terminal_start').handler({}),
+    /banner failed/
+  );
+  assert.deepEqual(stopCalls, ['s1']);
+});
+
 test('terminal_run forwards summary mode for concise output', async () => {
   const server = createFakeServer();
   const lookupCommand = process.platform === 'win32' ? 'where' : 'which';