mcp-for-i 0.1.11 → 0.1.13

package/dist/controlplane/commands.js

@@ -0,0 +1,109 @@
+import { startControlPlaneServer } from "./server.js";
+import { openUrl } from "./platform.js";
+import { getControlPlaneUrl } from "./serverShared.js";
+import { disableBackgroundService, enableBackgroundService, ensureControlPlaneRunning, getServiceStatus } from "./serviceManager.js";
+export async function runControlCommand(args, options) {
+    const stderr = options.stderr || process.stderr;
+    const command = normalizeCommand(args, options.defaultCommand || "serve");
+    const scriptPath = options.scriptPath;
+    const nodePath = options.nodePath || process.execPath;
+    switch (command) {
+        case "serve":
+            await serve(stderr);
+            return;
+        case "status":
+            await printStatus(stderr, scriptPath, nodePath);
+            return;
+        case "open":
+            await openControlUi(stderr, scriptPath, nodePath);
+            return;
+        case "enable":
+            await enableService(stderr, scriptPath, nodePath);
+            return;
+        case "disable":
+            await disableService(stderr, scriptPath, nodePath);
+            return;
+        case "help":
+        default:
+            printHelp(stderr);
+            return;
+    }
+}
+async function serve(stderr) {
+    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);
+    }
+    catch (err) {
+        if (err?.code === "EADDRINUSE") {
+            const url = getControlPlaneUrl();
+            stderr.write(`mcp-for-i control plane already running at ${url}\n`);
+            process.exit(0);
+        }
+        throw err;
+    }
+}
+async function printStatus(stderr, scriptPath, nodePath) {
+    const url = getControlPlaneUrl();
+    const status = await getServiceStatus(scriptPath, nodePath);
+    stderr.write(`Control plane URL: ${url}\n`);
+    stderr.write(`Platform: ${status.label} (${status.arch})\n`);
+    stderr.write(`Running: ${status.running ? "yes" : "no"}\n`);
+    stderr.write(`Background service: ${status.enabled ? "enabled" : "disabled"} via ${status.managedBy}\n`);
+    if (status.target)
+        stderr.write(`Target: ${status.target}\n`);
+    if (status.detail)
+        stderr.write(`Detail: ${status.detail}\n`);
+}
+async function openControlUi(stderr, scriptPath, nodePath) {
+    const url = getControlPlaneUrl();
+    const result = await ensureControlPlaneRunning(scriptPath, nodePath);
+    if (result.started) {
+        stderr.write(`Started control plane at ${url}\n`);
+    }
+    try {
+        await openUrl(url);
+        stderr.write(`Opening ${url}\n`);
+    }
+    catch {
+        stderr.write(`Control plane is running at ${url}\n`);
+    }
+}
+async function enableService(stderr, scriptPath, nodePath) {
+    const status = await enableBackgroundService(scriptPath, nodePath);
+    await ensureControlPlaneRunning(scriptPath, nodePath);
+    stderr.write(`Enabled background service via ${status.managedBy}\n`);
+    if (status.target)
+        stderr.write(`Target: ${status.target}\n`);
+    if (status.detail)
+        stderr.write(`Detail: ${status.detail}\n`);
+}
+async function disableService(stderr, scriptPath, nodePath) {
+    const status = await disableBackgroundService(scriptPath, nodePath);
+    stderr.write(`Disabled background service (${status.managedBy})\n`);
+    if (status.target)
+        stderr.write(`Target: ${status.target}\n`);
+}
+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(`  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`);
+    stderr.write(`  help       Show this help text\n`);
+}
+function normalizeCommand(args, fallback) {
+    const first = (args[0] || fallback).toLowerCase();
+    if (!first || first === "start")
+        return fallback;
+    if (first === "--help" || first === "-h")
+        return "help";
+    return first;
+}

package/dist/controlplane/index.js

@@ -1,120 +1,7 @@
 #!/usr/bin/env node
-import { startControlPlaneServer } from "./server.js";
-import { spawn } from "child_process";
 import { fileURLToPath } from "url";
-import { AUTOSTART_TASK_NAME, configureWindowsAutostart, getControlPlaneUrl, getWindowsAutostartStatus, isControlPlaneRunning, removeWindowsAutostart } from "./autostart.js";
-const command = normalizeCommand(process.argv.slice(2));
-switch (command) {
-    case "serve":
-        await serve();
-        break;
-    case "setup":
-        await setupAutostart();
-        break;
-    case "status":
-        await printStatus();
-        break;
-    case "remove":
-    case "uninstall":
-        await removeAutostart();
-        break;
-    case "open":
-        await openUi();
-        break;
-    case "help":
-    default:
-        printHelp();
-        break;
-}
-async function serve() {
-    try {
-        const server = await startControlPlaneServer();
-        process.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);
-    }
-    catch (err) {
-        if (err?.code === "EADDRINUSE") {
-            const url = getControlPlaneUrl();
-            process.stderr.write(`mcp-for-i control plane already running at ${url}\n`);
-            process.exit(0);
-        }
-        throw err;
-    }
-}
-async function setupAutostart() {
-    if (process.platform !== "win32") {
-        process.stderr.write("Autostart setup is currently implemented for Windows only.\n");
-        process.stderr.write(`Run manually with: mcp-for-i-control serve\n`);
-        return;
-    }
-    const scriptPath = fileURLToPath(import.meta.url);
-    await configureWindowsAutostart(scriptPath, process.execPath);
-    process.stderr.write(`Autostart configured (${AUTOSTART_TASK_NAME}).\n`);
-    process.stderr.write(`Control plane URL: ${getControlPlaneUrl()}\n`);
-}
-async function removeAutostart() {
-    if (process.platform !== "win32") {
-        process.stderr.write("Autostart removal is currently implemented for Windows only.\n");
-        return;
-    }
-    try {
-        await removeWindowsAutostart();
-        process.stderr.write(`Autostart removed (${AUTOSTART_TASK_NAME}).\n`);
-    }
-    catch (err) {
-        const msg = err?.message || String(err);
-        if (msg.includes("cannot find the file specified") || msg.includes("ERROR: The system cannot find")) {
-            process.stderr.write(`Autostart task not found (${AUTOSTART_TASK_NAME}).\n`);
-            return;
-        }
-        throw err;
-    }
-}
-async function printStatus() {
-    const url = getControlPlaneUrl();
-    const running = await isControlPlaneRunning(url);
-    process.stderr.write(`Control plane URL: ${url}\n`);
-    process.stderr.write(`Running: ${running ? "yes" : "no"}\n`);
-    if (process.platform === "win32") {
-        const auto = await getWindowsAutostartStatus();
-        process.stderr.write(`Autostart task: ${auto.installed ? "installed" : "not installed"}\n`);
-        if (auto.state) {
-            process.stderr.write(`Autostart state: ${auto.state}\n`);
-        }
-    }
-    else {
-        process.stderr.write("Autostart task: platform not managed by this command\n");
-    }
-}
-async function openUi() {
-    const url = getControlPlaneUrl();
-    if (process.platform === "win32") {
-        spawn("cmd", ["/c", "start", "", url], { detached: true, stdio: "ignore" }).unref();
-    }
-    else if (process.platform === "darwin") {
-        spawn("open", [url], { detached: true, stdio: "ignore" }).unref();
-    }
-    else {
-        spawn("xdg-open", [url], { detached: true, stdio: "ignore" }).unref();
-    }
-    process.stderr.write(`Opening ${url}\n`);
-}
-function printHelp() {
-    process.stderr.write(`mcp-for-i-control commands:\n`);
-    process.stderr.write(`  serve      Start control plane server (foreground)\n`);
-    process.stderr.write(`  setup      Configure autostart at login and launch now\n`);
-    process.stderr.write(`  status     Show running/autostart status\n`);
-    process.stderr.write(`  remove     Remove autostart configuration\n`);
-    process.stderr.write(`  open       Open UI URL in default browser\n`);
-}
-function normalizeCommand(args) {
-    const first = (args[0] || "serve").toLowerCase();
-    if (!first || first === "start")
-        return "serve";
-    return first;
-}
+import { runControlCommand } from "./commands.js";
+await runControlCommand(process.argv.slice(2), {
+    defaultCommand: "serve",
+    scriptPath: fileURLToPath(import.meta.url)
+});

package/dist/controlplane/platform.js

@@ -0,0 +1,79 @@
+import os from "os";
+import { spawn } from "child_process";
+export function detectWsl(platform = process.platform, release = os.release(), env = process.env) {
+    if (platform !== "linux")
+        return false;
+    if (env.WSL_DISTRO_NAME || env.WSL_INTEROP)
+        return true;
+    return /microsoft/i.test(release);
+}
+export function getPlatformDescriptor(platform = process.platform, arch = process.arch, release = os.release(), env = process.env) {
+    const isWsl = detectWsl(platform, release, env);
+    return {
+        platform,
+        arch,
+        isWsl,
+        label: describePlatform(platform, isWsl)
+    };
+}
+export function getOpenUrlCommands(url, descriptor = getPlatformDescriptor()) {
+    if (descriptor.platform === "win32") {
+        return [
+            { command: "rundll32.exe", args: ["url.dll,FileProtocolHandler", url] },
+            { command: "explorer.exe", args: [url] }
+        ];
+    }
+    if (descriptor.platform === "darwin") {
+        return [{ command: "open", args: [url] }];
+    }
+    if (descriptor.isWsl) {
+        return [
+            { command: "wslview", args: [url] },
+            { command: "explorer.exe", args: [url] },
+            { command: "xdg-open", args: [url] }
+        ];
+    }
+    return [
+        { command: "xdg-open", args: [url] },
+        { command: "gio", args: ["open", url] }
+    ];
+}
+export async function openUrl(url, descriptor = getPlatformDescriptor()) {
+    const candidates = getOpenUrlCommands(url, descriptor);
+    let lastError;
+    for (const candidate of candidates) {
+        try {
+            await spawnDetached(candidate.command, candidate.args);
+            return candidate.command;
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+        }
+    }
+    throw lastError || new Error(`No browser launcher available for ${descriptor.label}`);
+}
+function spawnDetached(command, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            detached: true,
+            stdio: "ignore",
+            windowsHide: true
+        });
+        child.once("error", reject);
+        child.once("spawn", () => {
+            child.unref();
+            resolve();
+        });
+    });
+}
+function describePlatform(platform, isWsl) {
+    if (platform === "win32")
+        return "Windows";
+    if (platform === "darwin")
+        return "macOS";
+    if (isWsl)
+        return "Linux (WSL)";
+    if (platform === "linux")
+        return "Linux";
+    return platform;
+}

package/dist/controlplane/runtimeService.js

@@ -3,15 +3,15 @@ import fs from "fs/promises";
 import os from "os";
 import path from "path";
 import { fileURLToPath } from "url";
-import { AUTOSTART_TASK_NAME, configureWindowsAutostart, getControlPlaneUrl, getWindowsAutostartStatus, isControlPlaneRunning, removeWindowsAutostart } from "./autostart.js";
+import { getPlatformDescriptor } from "./platform.js";
+import { disableBackgroundService, enableBackgroundService, getServiceStatus } from "./serviceManager.js";
 export class RuntimeService {
     rootDir;
     state = {
-        install: makeJob("install"),
         updateMcp: makeJob("updateMcp"),
         updateSkills: makeJob("updateSkills"),
-        setupAutostart: makeJob("setupAutostart"),
-        removeAutostart: makeJob("removeAutostart")
+        enableService: makeJob("enableService"),
+        disableService: makeJob("disableService")
     };
     constructor(rootDir) {
         this.rootDir = rootDir;
@@ -68,17 +68,6 @@ export class RuntimeService {
             skills
         };
     }
-    async installOrRepair() {
-        return this.runJob("install", async (push) => {
-            const mode = await this.detectExecutionMode(push);
-            if (mode === "git-checkout") {
-                await this.runNpm(["install"], this.rootDir, push);
-                await this.buildIfPresent(push);
-                return;
-            }
-            await this.runGlobalPackageUpdate(push, "install");
-        });
-    }
     async updateMcp() {
         return this.runJob("updateMcp", async (push) => {
             const mode = await this.detectExecutionMode(push);
@@ -135,57 +124,33 @@ export class RuntimeService {
             }
         });
     }
-    async setupAutostart() {
-        return this.runJob("setupAutostart", async (push) => {
-            if (process.platform !== "win32") {
-                throw new Error("Autostart setup is currently supported on Windows only.");
-            }
-            const scriptPath = path.join(path.dirname(fileURLToPath(import.meta.url)), "index.js");
-            await configureWindowsAutostart(scriptPath, process.execPath);
-            push(`Autostart configured (${AUTOSTART_TASK_NAME}).`);
-            push(`Control plane URL: ${getControlPlaneUrl()}`);
-        });
+    async getEnvironmentInfo() {
+        return {
+            ...getPlatformDescriptor(),
+            commandMode: "portable",
+            updateMode: await this.detectExecutionModeQuiet()
+        };
     }
-    async removeAutostart() {
-        return this.runJob("removeAutostart", async (push) => {
-            if (process.platform !== "win32") {
-                throw new Error("Autostart removal is currently supported on Windows only.");
-            }
-            try {
-                await removeWindowsAutostart();
-                push(`Autostart removed (${AUTOSTART_TASK_NAME}).`);
-            }
-            catch (err) {
-                const msg = err?.message || String(err);
-                if (msg.includes("cannot find the file specified") || msg.includes("ERROR: The system cannot find")) {
-                    push(`Autostart task not found (${AUTOSTART_TASK_NAME}).`);
-                    return;
-                }
-                throw err;
-            }
+    async getServiceStatus() {
+        return getServiceStatus(this.getControlPlaneScriptPath(), process.execPath);
+    }
+    async enableService() {
+        return this.runJob("enableService", async (push) => {
+            const status = await enableBackgroundService(this.getControlPlaneScriptPath(), process.execPath);
+            push(`Enabled background service via ${status.managedBy}.`);
+            if (status.target)
+                push(`Target: ${status.target}`);
+            if (status.detail)
+                push(status.detail);
         });
     }
-    async getAutostartStatus() {
-        const url = getControlPlaneUrl();
-        const running = await isControlPlaneRunning(url);
-        if (process.platform !== "win32") {
-            return {
-                platform: process.platform,
-                running,
-                controlPlaneUrl: url,
-                supported: false,
-                installed: false
-            };
-        }
-        const task = await getWindowsAutostartStatus();
-        return {
-            platform: process.platform,
-            running,
-            controlPlaneUrl: url,
-            supported: true,
-            installed: task.installed,
-            state: task.state
-        };
+    async disableService() {
+        return this.runJob("disableService", async (push) => {
+            const status = await disableBackgroundService(this.getControlPlaneScriptPath(), process.execPath);
+            push(`Disabled background service (${status.managedBy}).`);
+            if (status.target)
+                push(`Target: ${status.target}`);
+        });
     }
     async runJob(kind, fn) {
         const current = this.state[kind];
@@ -221,7 +186,8 @@ export class RuntimeService {
             push(`$ ${command} ${args.join(" ")}`);
             const child = spawn(command, args, {
                 cwd,
-                shell: process.platform === "win32"
+                shell: shouldUseShell(command),
+                windowsHide: true
             });
             child.stdout.on("data", chunk => push(String(chunk).trimEnd()));
             child.stderr.on("data", chunk => push(String(chunk).trimEnd()));
@@ -258,7 +224,8 @@ export class RuntimeService {
             push(`$ ${command} ${args.join(" ")}`);
             const child = spawn(command, args, {
                 cwd,
-                shell: process.platform === "win32"
+                shell: shouldUseShell(command),
+                windowsHide: true
             });
             const lines = [];
             child.stdout.on("data", chunk => {
@@ -327,7 +294,7 @@ export class RuntimeService {
         return normalizedRoot.includes(marker);
     }
     async scheduleWindowsSelfUpdate(push, action) {
-        const controlPlaneScript = path.join(path.dirname(fileURLToPath(import.meta.url)), "index.js");
+        const controlPlaneScript = this.getControlPlaneScriptPath();
         const jobId = `${Date.now()}-${process.pid}`;
         const logPath = path.join(os.tmpdir(), `${PACKAGE_NAME}-${action}-${jobId}.log`);
         const scriptPath = path.join(os.tmpdir(), `${PACKAGE_NAME}-${action}-${jobId}.cmd`);
@@ -436,7 +403,8 @@ export class RuntimeService {
         return new Promise((resolve, reject) => {
             const child = spawn(command, args, {
                 cwd,
-                shell: process.platform === "win32"
+                shell: shouldUseShell(command),
+                windowsHide: true
             });
             const stdout = [];
             const stderr = [];
@@ -454,6 +422,9 @@ export class RuntimeService {
             });
         });
     }
+    getControlPlaneScriptPath() {
+        return path.join(path.dirname(fileURLToPath(import.meta.url)), "index.js");
+    }
 }
 function makeJob(id) {
     return {
@@ -466,9 +437,20 @@ async function resolveNpmLaunch() {
     if (process.env.npm_execpath && await pathExists(process.env.npm_execpath)) {
         return { mode: "node-cli", path: process.env.npm_execpath };
     }
-    const guessed = path.resolve(process.execPath, "..", "..", "lib", "node_modules", "npm", "bin", "npm-cli.js");
-    if (await pathExists(guessed))
-        return { mode: "node-cli", path: guessed };
+    const npmCliCandidates = process.platform === "win32"
+        ? [
+            path.join(path.dirname(process.execPath), "node_modules", "npm", "bin", "npm-cli.js"),
+            path.join(path.dirname(process.execPath), "..", "node_modules", "npm", "bin", "npm-cli.js")
+        ]
+        : [
+            path.resolve(process.execPath, "..", "..", "lib", "node_modules", "npm", "bin", "npm-cli.js"),
+            path.resolve(process.execPath, "..", "..", "..", "lib", "node_modules", "npm", "bin", "npm-cli.js")
+        ];
+    for (const candidate of npmCliCandidates) {
+        if (await pathExists(candidate)) {
+            return { mode: "node-cli", path: candidate };
+        }
+    }
     return { mode: "command", path: process.platform === "win32" ? "npm.cmd" : "npm" };
 }
 function sanitizeRepoUrl(value) {
@@ -506,3 +488,8 @@ async function pathExists(target) {
         return false;
     }
 }
+function shouldUseShell(command) {
+    if (process.platform !== "win32")
+        return false;
+    return /\.(cmd|bat)$/i.test(path.basename(command));
+}

package/dist/controlplane/server.js

@@ -5,9 +5,10 @@ import path from "path";
 import { URL } from "url";
 import { fileURLToPath } from "url";
 import { ConfigStore, getConfigDir } from "../config/store.js";
-import { isKeychainAvailable } from "../security/credentialStore.js";
+import { getCredentialStoreStatus } from "../security/credentialStore.js";
 import { ConnectionService } from "./connectionService.js";
 import { RuntimeService } from "./runtimeService.js";
+import { ClientIntegrationService } from "./clientIntegrationService.js";
 import { renderControlPlaneHtml } from "./ui.js";
 export async function startControlPlaneServer(opts) {
     const host = opts?.host || process.env.MCP_FOR_I_CONTROL_HOST || "127.0.0.1";
@@ -16,9 +17,10 @@ export async function startControlPlaneServer(opts) {
     const store = new ConfigStore();
     const connections = new ConnectionService(store);
     const runtime = new RuntimeService(rootDir);
+    const clients = new ClientIntegrationService(rootDir);
     const server = http.createServer(async (req, res) => {
         try {
-            await routeRequest(req, res, { store, connections, runtime });
+            await routeRequest(req, res, { store, connections, runtime, clients });
         }
         catch (err) {
             sendJson(res, 500, { error: err?.message || String(err) });
@@ -46,7 +48,8 @@ async function routeRequest(req, res, services) {
         return;
     }
     if (method === "GET" && pathname === "/api/health") {
-        sendJson(res, 200, { ok: true, keychainAvailable: await isKeychainAvailable() });
+        const credentialStore = await getCredentialStoreStatus();
+        sendJson(res, 200, { ok: true, keychainAvailable: credentialStore.keychainAvailable, credentialStore });
         return;
     }
     if (method === "GET" && pathname === "/api/settings") {
@@ -97,8 +100,39 @@ async function routeRequest(req, res, services) {
         sendJson(res, 200, versions);
         return;
     }
-    if (method === "POST" && pathname === "/api/runtime/install") {
-        const job = await services.runtime.installOrRepair();
+    if (method === "GET" && pathname === "/api/runtime/environment") {
+        const environment = await services.runtime.getEnvironmentInfo();
+        sendJson(res, 200, { environment });
+        return;
+    }
+    if (method === "GET" && pathname === "/api/service/status") {
+        const status = await services.runtime.getServiceStatus();
+        sendJson(res, 200, { status });
+        return;
+    }
+    if (method === "GET" && pathname === "/api/clients") {
+        const targets = await services.clients.listTargets();
+        sendJson(res, 200, { targets });
+        return;
+    }
+    if (method === "POST" && pathname === "/api/clients/install") {
+        const body = await readJson(req);
+        const id = String(body.id || "").trim();
+        if (!id) {
+            sendJson(res, 400, { error: "id is required" });
+            return;
+        }
+        const result = await services.clients.installTarget(id);
+        sendJson(res, 200, { result });
+        return;
+    }
+    if (method === "POST" && pathname === "/api/service/enable") {
+        const job = await services.runtime.enableService();
+        sendJson(res, 202, { job });
+        return;
+    }
+    if (method === "POST" && pathname === "/api/service/disable") {
+        const job = await services.runtime.disableService();
         sendJson(res, 202, { job });
         return;
     }
@@ -116,21 +150,6 @@ async function routeRequest(req, res, services) {
         sendJson(res, 202, { job });
         return;
     }
-    if (method === "GET" && pathname === "/api/runtime/autostart/status") {
-        const status = await services.runtime.getAutostartStatus();
-        sendJson(res, 200, { status });
-        return;
-    }
-    if (method === "POST" && pathname === "/api/runtime/autostart/setup") {
-        const job = await services.runtime.setupAutostart();
-        sendJson(res, 202, { job });
-        return;
-    }
-    if (method === "POST" && pathname === "/api/runtime/autostart/remove") {
-        const job = await services.runtime.removeAutostart();
-        sendJson(res, 202, { job });
-        return;
-    }
     if (method === "GET" && pathname === "/api/connections") {
         const list = await services.connections.list();
         sendJson(res, 200, { connections: list });

package/dist/controlplane/serverShared.js

@@ -0,0 +1,18 @@
+export function getControlPlaneUrl() {
+    const host = process.env.MCP_FOR_I_CONTROL_HOST || "127.0.0.1";
+    const portRaw = Number(process.env.MCP_FOR_I_CONTROL_PORT || 3980);
+    const port = Number.isFinite(portRaw) && portRaw > 0 && portRaw <= 65535 ? Math.floor(portRaw) : 3980;
+    return `http://${host}:${port}`;
+}
+export async function isControlPlaneRunning(baseUrl = getControlPlaneUrl()) {
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 1500);
+        const res = await fetch(`${baseUrl}/api/health`, { signal: controller.signal });
+        clearTimeout(timeout);
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}