mcp-for-i 0.1.13 → 0.3.0

package/dist/controlplane/clientIntegrationService.js

@@ -1,4 +1,5 @@
-import fs from "fs/promises";
+import fs from "fs";
+import fsp from "fs/promises";
 import os from "os";
 import path from "path";
 import { spawn } from "child_process";
@@ -229,7 +230,7 @@ export class ClientIntegrationService {
     async isCodeConfigured() {
         const userConfigPath = getVsCodeUserMcpPath();
         try {
-            const raw = await fs.readFile(userConfigPath, "utf8");
+            const raw = await fsp.readFile(userConfigPath, "utf8");
             const parsed = JSON.parse(raw);
             if (Array.isArray(parsed?.servers)) {
                 return parsed.servers.some((entry) => entry?.name === SERVER_NAME);
@@ -263,10 +264,88 @@ async function commandExists(command) {
     const result = await runCommand(command, ["--help"]);
     return result.ok;
 }
-async function runCommand(command, args) {
+/**
+ * Finds a command on PATH the way cmd.exe does (PATHEXT order). Returns the
+ * full path, or undefined when nothing matches.
+ */
+export function resolveWindowsCommand(command, env = process.env) {
+    const pathExt = (env.PATHEXT || ".COM;.EXE;.BAT;.CMD")
+        .split(";")
+        .map(ext => ext.trim().toLowerCase())
+        .filter(Boolean);
+    const hasExt = pathExt.includes(path.extname(command).toLowerCase());
+    const candidates = hasExt ? [command] : pathExt.map(ext => command + ext);
+    const isPath = command.includes("/") || command.includes("\\");
+    const dirs = isPath
+        ? [""]
+        : String(env.PATH || env.Path || "").split(";").map(dir => dir.trim().replace(/^"(.*)"$/, "$1")).filter(Boolean);
+    for (const dir of dirs) {
+        for (const candidate of candidates) {
+            const full = dir ? path.join(dir, candidate) : candidate;
+            try {
+                if (fs.statSync(full).isFile())
+                    return full;
+            }
+            catch {
+                // not here
+            }
+        }
+    }
+    return undefined;
+}
+const CMD_META = /([()\][%!^"`<>&|;, *?])/g;
+/** Quotes one argument for cmd.exe, following the MSVCRT argv rules. */
+export function escapeCmdArgument(value, doubleEscapeMeta) {
+    let arg = String(value);
+    // Double the backslashes that precede a quote, then escape the quote.
+    arg = arg.replace(/(\\*)"/g, '$1$1\\"');
+    // Double trailing backslashes so they do not escape the closing quote.
+    arg = arg.replace(/(\\*)$/, "$1$1");
+    arg = `"${arg}"`;
+    arg = arg.replace(CMD_META, "^$1");
+    // .cmd shims re-parse their arguments (%*), so they need a second pass.
+    if (doubleEscapeMeta)
+        arg = arg.replace(CMD_META, "^$1");
+    return arg;
+}
+/**
+ * Builds how to start a command. On Windows, npm-installed CLIs (codex,
+ * claude, code) are .cmd shims that only start through cmd.exe, so they are
+ * resolved via PATHEXT and launched with every argument escaped. The
+ * arguments are fixed by this module, never taken from a request.
+ */
+export function buildSpawnSpec(command, args, platform = process.platform, env = process.env) {
+    if (platform !== "win32") {
+        return { file: command, args, windowsVerbatimArguments: false };
+    }
+    const resolved = resolveWindowsCommand(command, env);
+    if (!resolved)
+        return undefined;
+    if (!/\.(cmd|bat)$/i.test(resolved)) {
+        return { file: resolved, args, windowsVerbatimArguments: false };
+    }
+    const commandLine = [
+        resolved.replace(CMD_META, "^$1"),
+        ...args.map(arg => escapeCmdArgument(arg, true))
+    ].join(" ");
+    return {
+        file: env.ComSpec || env.COMSPEC || "cmd.exe",
+        args: ["/d", "/s", "/c", `"${commandLine}"`],
+        windowsVerbatimArguments: true
+    };
+}
+export async function runCommand(command, args, env = process.env) {
     return new Promise(resolve => {
-        const child = spawn(command, args, {
+        const spec = buildSpawnSpec(command, args, process.platform, env);
+        if (!spec) {
+            resolve({ ok: false, stdout: "", stderr: `${command} was not found on PATH` });
+            return;
+        }
+        const child = spawn(spec.file, spec.args, {
+            env,
             windowsHide: true,
+            windowsVerbatimArguments: spec.windowsVerbatimArguments,
+            timeout: 120000,
             stdio: ["ignore", "pipe", "pipe"]
         });
         const stdout = [];

package/dist/controlplane/commands.js

@@ -1,7 +1,7 @@
 import { startControlPlaneServer } from "./server.js";
 import { openUrl } from "./platform.js";
 import { getControlPlaneUrl } from "./serverShared.js";
-import { disableBackgroundService, enableBackgroundService, ensureControlPlaneRunning, getServiceStatus } from "./serviceManager.js";
+import { disableBackgroundService, enableBackgroundService, ensureControlPlaneRunning, getServiceStatus, stopControlPlane } from "./serviceManager.js";
 export async function runControlCommand(args, options) {
     const stderr = options.stderr || process.stderr;
     const command = normalizeCommand(args, options.defaultCommand || "serve");
@@ -17,6 +17,13 @@ export async function runControlCommand(args, options) {
         case "open":
             await openControlUi(stderr, scriptPath, nodePath);
             return;
+        case "stop":
+            await stop(stderr, scriptPath, nodePath);
+            return;
+        case "restart":
+            await stop(stderr, scriptPath, nodePath);
+            await openControlUi(stderr, scriptPath, nodePath, false);
+            return;
         case "enable":
             await enableService(stderr, scriptPath, nodePath);
             return;
@@ -29,25 +36,52 @@ export async function runControlCommand(args, options) {
             return;
     }
 }
+/**
+ * Runs the control plane in the foreground. Resolves only after the server has
+ * stopped listening, so a caller that exits when this returns keeps it alive.
+ */
 async function serve(stderr) {
+    let server;
     try {
-        const server = await startControlPlaneServer();
-        stderr.write(`mcp-for-i control plane running at http://${server.host}:${server.port}\n`);
-        const shutdown = async () => {
-            await server.close();
-            process.exit(0);
-        };
-        process.on("SIGINT", shutdown);
-        process.on("SIGTERM", shutdown);
+        server = await startControlPlaneServer();
     }
     catch (err) {
         if (err?.code === "EADDRINUSE") {
             const url = getControlPlaneUrl();
             stderr.write(`mcp-for-i control plane already running at ${url}\n`);
-            process.exit(0);
+            return;
         }
         throw err;
     }
+    stderr.write(`mcp-for-i control plane running at ${getControlPlaneUrl()}\n`);
+    const shutdown = () => {
+        server.close().catch(() => undefined);
+    };
+    process.once("SIGINT", shutdown);
+    process.once("SIGTERM", shutdown);
+    await server.closed;
+    if (await server.shutdownRequested) {
+        stderr.write("mcp-for-i control plane stopped\n");
+        // Background timers (update checks, client probes) must not keep a stopped server's process alive.
+        process.exit(0);
+    }
+}
+async function stop(stderr, scriptPath, nodePath) {
+    const url = getControlPlaneUrl();
+    const result = await stopControlPlane(scriptPath, nodePath);
+    if (!result.wasRunning) {
+        stderr.write(`Control plane is not running at ${url}\n`);
+    }
+    else if (result.stopped) {
+        stderr.write(`Stopped control plane at ${url}\n`);
+    }
+    else {
+        stderr.write(`Control plane at ${url} did not stop: ${result.detail || "it is still answering"}\n`);
+        process.exitCode = 1;
+    }
+    if (result.serviceEnabled) {
+        stderr.write(`The background service is still enabled (${result.managedBy}), so it starts again at the next login. Run "mcp-for-i control disable" to turn that off.\n`);
+    }
 }
 async function printStatus(stderr, scriptPath, nodePath) {
     const url = getControlPlaneUrl();
@@ -61,12 +95,17 @@ async function printStatus(stderr, scriptPath, nodePath) {
     if (status.detail)
         stderr.write(`Detail: ${status.detail}\n`);
 }
-async function openControlUi(stderr, scriptPath, nodePath) {
+async function openControlUi(stderr, scriptPath, nodePath, openBrowser = true) {
     const url = getControlPlaneUrl();
     const result = await ensureControlPlaneRunning(scriptPath, nodePath);
     if (result.started) {
         stderr.write(`Started control plane at ${url}\n`);
     }
+    if (!openBrowser) {
+        if (!result.started)
+            stderr.write(`Control plane is running at ${url}\n`);
+        return;
+    }
     try {
         await openUrl(url);
         stderr.write(`Opening ${url}\n`);
@@ -94,6 +133,8 @@ function printHelp(stderr) {
     stderr.write(`mcp-for-i-control commands:\n`);
     stderr.write(`  serve      Start control plane server in the foreground\n`);
     stderr.write(`  open       Start control plane in the background if needed, then open UI\n`);
+    stderr.write(`  stop       Stop the running control plane\n`);
+    stderr.write(`  restart    Stop the control plane, then start it again in the background\n`);
     stderr.write(`  status     Show running and background-service status\n`);
     stderr.write(`  enable     Enable background service for this platform\n`);
     stderr.write(`  disable    Disable background service for this platform\n`);

package/dist/controlplane/connectionService.js

@@ -1,16 +1,96 @@
 import { deletePassword, getPassword, setPassword } from "../security/credentialStore.js";
+import { ControlPlaneError } from "./errors.js";
+import { testConnection } from "./connectionTest.js";
+/** True when host, port or username differ (host compared case-insensitively). */
+export function connectionEndpointChanged(before, after) {
+    const host = (value) => String(value ?? "").trim().toLowerCase();
+    const port = (value) => Number(value || 22);
+    const user = (value) => String(value ?? "").trim().toUpperCase();
+    return host(before.host) !== host(after.host)
+        || port(before.port) !== port(after.port)
+        || user(before.username) !== user(after.username);
+}
 export class ConnectionService {
     store;
-    constructor(store) {
+    runTest;
+    /** Last test result per saved connection, kept in memory only. */
+    lastTests = new Map();
+    /** Endpoints with a test in progress, so a double click signs on once. */
+    running = new Set();
+    constructor(store, runTest = testConnection) {
         this.store = store;
+        this.runTest = runTest;
     }
     async list() {
-        return this.store.listConnections();
+        const list = await this.store.listConnections();
+        return list.map(conn => {
+            const lastTest = this.lastTests.get(conn.name);
+            return lastTest ? { ...conn, lastTest } : conn;
+        });
+    }
+    /** Tests a saved connection with its stored details and password. */
+    async testSaved(name) {
+        const stored = await this.store.getConnection(name);
+        if (!stored)
+            throw new ControlPlaneError(404, `Connection ${name} not found`);
+        const password = await getPassword(name).catch(() => undefined);
+        const result = await this.guardedTest({
+            host: stored.host,
+            port: stored.port,
+            username: stored.username,
+            password: password || undefined,
+            privateKeyPath: stored.privateKeyPath
+        });
+        this.lastTests.set(name, result);
+        return result;
+    }
+    /**
+     * Tests details that may not be saved yet (the add and edit form). A saved
+     * password is only used for the same host, port and user it was saved for.
+     */
+    async testDetails(input) {
+        const host = typeof input?.host === "string" ? input.host.trim() : "";
+        const username = typeof input?.username === "string" ? input.username.trim() : "";
+        if (!host || !username)
+            throw new ControlPlaneError(400, "host and username are required");
+        const port = Number(input.port || 22);
+        let password = typeof input.password === "string" && input.password ? input.password : undefined;
+        const name = typeof input.name === "string" ? input.name.trim() : "";
+        const stored = name ? await this.store.getConnection(name) : undefined;
+        if (!password && stored && !connectionEndpointChanged(stored, { host, port, username })) {
+            password = (await getPassword(name).catch(() => undefined)) || undefined;
+        }
+        const privateKeyPath = typeof input.privateKeyPath === "string" && input.privateKeyPath.trim()
+            ? input.privateKeyPath.trim()
+            : undefined;
+        return this.guardedTest({ host, port, username, password, privateKeyPath });
+    }
+    async guardedTest(target) {
+        const key = [target.host.trim().toLowerCase(), Number(target.port || 22), target.username.trim().toUpperCase()].join("|");
+        if (this.running.has(key)) {
+            throw new ControlPlaneError(409, "A test of this connection is already running");
+        }
+        this.running.add(key);
+        try {
+            return await this.runTest(target);
+        }
+        finally {
+            this.running.delete(key);
+        }
     }
     async get(name) {
         return this.store.getConnection(name);
     }
     async add(input) {
+        const name = typeof input?.name === "string" ? input.name.trim() : "";
+        if (!name || !input.host || !input.username) {
+            throw new ControlPlaneError(400, "name, host and username are required");
+        }
+        // Adding must never overwrite an existing entry: that would let a caller
+        // repoint a connection without the checks in update().
+        if (await this.store.getConnection(input.name)) {
+            throw new ControlPlaneError(409, `Connection ${input.name} already exists`);
+        }
         await this.store.upsertConnection({
             name: input.name,
             host: input.host,
@@ -28,7 +108,7 @@ export class ConnectionService {
     async update(name, input) {
         const existing = await this.store.getConnection(name);
         if (!existing)
-            throw new Error(`Connection ${name} not found`);
+            throw new ControlPlaneError(404, `Connection ${name} not found`);
         const next = {
             ...existing,
             host: input.host ?? existing.host,
@@ -38,9 +118,28 @@ export class ConnectionService {
             settings: input.settings ? { ...(existing.settings || {}), ...input.settings } : existing.settings,
             policy: input.policy ?? existing.policy
         };
+        // A saved password must never follow the connection to a different
+        // endpoint or user. Changing host, port or username therefore needs the
+        // password in the same request.
+        const endpointChanged = connectionEndpointChanged(existing, next);
+        const newPassword = typeof input.password === "string" && input.password ? input.password : undefined;
+        if (endpointChanged && !newPassword && await getPassword(name)) {
+            throw new ControlPlaneError(400, "Changing host, port or username requires entering the password again in the same request");
+        }
         await this.store.upsertConnection(next);
-        if (input.storePassword && input.password) {
-            await setPassword(name, input.password);
+        // An earlier result says nothing about new details or a new password.
+        if (endpointChanged || newPassword || next.privateKeyPath !== existing.privateKeyPath) {
+            this.lastTests.delete(name);
+        }
+        if (newPassword && (input.storePassword || endpointChanged)) {
+            if (input.storePassword === false) {
+                // The caller does not want it stored; drop the old one so it is not
+                // sent to the new endpoint.
+                await deletePassword(name);
+            }
+            else {
+                await setPassword(name, newPassword);
+            }
         }
         return this.get(name);
     }
@@ -64,16 +163,22 @@ export class ConnectionService {
             await setPassword(newName, password);
         }
         await deletePassword(oldName);
+        const lastTest = this.lastTests.get(oldName);
+        this.lastTests.delete(oldName);
+        if (lastTest)
+            this.lastTests.set(newName, lastTest);
         return this.get(newName);
     }
     async delete(name) {
         await this.store.deleteConnection(name);
         await deletePassword(name);
+        this.lastTests.delete(name);
     }
     async setConnectionPassword(name, password) {
         const existing = await this.store.getConnection(name);
         if (!existing)
             throw new Error(`Connection ${name} not found`);
         await setPassword(name, password);
+        this.lastTests.delete(name);
     }
 }