mcp-for-i 0.1.0

package/dist/controlplane/index.js

@@ -0,0 +1,120 @@
+#!/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;
+}

package/dist/controlplane/runtimeService.js

@@ -0,0 +1,263 @@
+import { spawn } from "child_process";
+import fs from "fs/promises";
+import path from "path";
+import { fileURLToPath } from "url";
+import { AUTOSTART_TASK_NAME, configureWindowsAutostart, getControlPlaneUrl, getWindowsAutostartStatus, isControlPlaneRunning, removeWindowsAutostart } from "./autostart.js";
+export class RuntimeService {
+    rootDir;
+    state = {
+        install: makeJob("install"),
+        updateMcp: makeJob("updateMcp"),
+        updateSkills: makeJob("updateSkills"),
+        setupAutostart: makeJob("setupAutostart"),
+        removeAutostart: makeJob("removeAutostart")
+    };
+    constructor(rootDir) {
+        this.rootDir = rootDir;
+    }
+    getStatus() {
+        return this.state;
+    }
+    async installOrRepair() {
+        return this.runJob("install", async (push) => {
+            await this.runNpm(["install"], this.rootDir, push);
+            await this.runNpm(["run", "build"], this.rootDir, push);
+        });
+    }
+    async updateMcp() {
+        return this.runJob("updateMcp", async (push) => {
+            await this.runCommand("git", ["pull", "--ff-only"], this.rootDir, push);
+            await this.runNpm(["install"], this.rootDir, push);
+            await this.runNpm(["run", "build"], this.rootDir, push);
+        });
+    }
+    async updateSkills(options) {
+        return this.runJob("updateSkills", async (push) => {
+            const repoUrl = sanitizeRepoUrl(options?.repoUrl) || process.env.MCP_FOR_I_SKILLS_REPO || DEFAULT_SKILLS_REPO;
+            const branch = sanitizeBranch(options?.branch) || process.env.MCP_FOR_I_SKILLS_BRANCH || "main";
+            const skillsDir = path.join(this.rootDir, "skills");
+            const hasSkills = await pathExists(skillsDir);
+            push(`Using skills repository: ${repoUrl} (${branch})`);
+            if (!hasSkills) {
+                await this.runCommand("git", ["clone", "--depth", "1", "--branch", branch, repoUrl, skillsDir], this.rootDir, push);
+                return;
+            }
+            const skillsGit = path.join(skillsDir, ".git");
+            if (await pathExists(skillsGit)) {
+                const currentRemote = await this.getGitRemoteUrl(skillsDir, push);
+                if (currentRemote && currentRemote !== repoUrl) {
+                    push(`Switching skills remote from ${currentRemote} to ${repoUrl}`);
+                    await this.runCommand("git", ["remote", "set-url", "origin", repoUrl], skillsDir, push);
+                }
+                await this.runCommand("git", ["fetch", "origin", branch], skillsDir, push);
+                await this.runCommand("git", ["checkout", branch], skillsDir, push);
+                await this.runCommand("git", ["pull", "--ff-only", "origin", branch], skillsDir, push);
+                return;
+            }
+            const backupDir = `${skillsDir}.backup-${Date.now()}`;
+            push(`Existing skills directory is not a git repository. Backing it up to ${backupDir}`);
+            await fs.rename(skillsDir, backupDir);
+            try {
+                await this.runCommand("git", ["clone", "--depth", "1", "--branch", branch, repoUrl, skillsDir], this.rootDir, push);
+            }
+            catch (error) {
+                push("Clone failed. Restoring previous skills directory.");
+                await safeRename(backupDir, skillsDir);
+                throw error;
+            }
+        });
+    }
+    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 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 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 runJob(kind, fn) {
+        const current = this.state[kind];
+        if (current.status === "running") {
+            return current;
+        }
+        const job = makeJob(kind);
+        job.status = "running";
+        job.startedAt = new Date().toISOString();
+        this.state[kind] = job;
+        const push = (line) => {
+            job.output.push(line);
+            if (job.output.length > 300) {
+                job.output.splice(0, job.output.length - 300);
+            }
+        };
+        try {
+            await fn(push);
+            job.status = "success";
+        }
+        catch (err) {
+            job.status = "failed";
+            job.error = err?.message || String(err);
+            push(`ERROR: ${job.error}`);
+        }
+        finally {
+            job.finishedAt = new Date().toISOString();
+        }
+        return job;
+    }
+    runCommand(command, args, cwd, push) {
+        return new Promise((resolve, reject) => {
+            push(`$ ${command} ${args.join(" ")}`);
+            const child = spawn(command, args, {
+                cwd,
+                shell: process.platform === "win32"
+            });
+            child.stdout.on("data", chunk => push(String(chunk).trimEnd()));
+            child.stderr.on("data", chunk => push(String(chunk).trimEnd()));
+            child.on("error", reject);
+            child.on("exit", code => {
+                if (code === 0) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`Command failed (${code}): ${command} ${args.join(" ")}`));
+                }
+            });
+        });
+    }
+    async runNpm(args, cwd, push) {
+        const npm = await resolveNpmLaunch();
+        if (npm.mode === "node-cli") {
+            await this.runCommand(process.execPath, [npm.path, ...args], cwd, push);
+            return;
+        }
+        await this.runCommand(npm.path, args, cwd, push);
+    }
+    async getGitRemoteUrl(cwd, push) {
+        try {
+            const lines = [];
+            await this.runCommandCapture("git", ["remote", "get-url", "origin"], cwd, line => {
+                push(line);
+                lines.push(line);
+            });
+            const value = lines.join("\n").trim();
+            return value || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    runCommandCapture(command, args, cwd, push) {
+        return new Promise((resolve, reject) => {
+            push(`$ ${command} ${args.join(" ")}`);
+            const child = spawn(command, args, {
+                cwd,
+                shell: process.platform === "win32"
+            });
+            child.stdout.on("data", chunk => push(String(chunk).trimEnd()));
+            child.stderr.on("data", chunk => push(String(chunk).trimEnd()));
+            child.on("error", reject);
+            child.on("exit", code => {
+                if (code === 0) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`Command failed (${code}): ${command} ${args.join(" ")}`));
+                }
+            });
+        });
+    }
+}
+function makeJob(id) {
+    return {
+        id,
+        status: "idle",
+        output: []
+    };
+}
+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 };
+    return { mode: "command", path: process.platform === "win32" ? "npm.cmd" : "npm" };
+}
+function sanitizeRepoUrl(value) {
+    if (!value)
+        return undefined;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return undefined;
+    return trimmed;
+}
+function sanitizeBranch(value) {
+    if (!value)
+        return undefined;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return undefined;
+    return trimmed;
+}
+async function safeRename(from, to) {
+    try {
+        await fs.rename(from, to);
+    }
+    catch {
+        // best-effort rollback
+    }
+}
+const DEFAULT_SKILLS_REPO = "https://github.com/ashishthomas-pcr/mcp-for-i-skills.git";
+async function pathExists(target) {
+    try {
+        await fs.access(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/controlplane/server.js

@@ -0,0 +1,180 @@
+import http from "http";
+import { URL } from "url";
+import { ConfigStore } from "../config/store.js";
+import { isKeychainAvailable } from "../security/credentialStore.js";
+import { ConnectionService } from "./connectionService.js";
+import { RuntimeService } from "./runtimeService.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";
+    const port = normalizePort(opts?.port || Number(process.env.MCP_FOR_I_CONTROL_PORT || 3980));
+    const rootDir = opts?.rootDir || process.cwd();
+    const store = new ConfigStore();
+    const connections = new ConnectionService(store);
+    const runtime = new RuntimeService(rootDir);
+    const server = http.createServer(async (req, res) => {
+        try {
+            await routeRequest(req, res, { connections, runtime });
+        }
+        catch (err) {
+            sendJson(res, 500, { error: err?.message || String(err) });
+        }
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(port, host, () => resolve());
+    });
+    return {
+        host,
+        port,
+        close: () => new Promise((resolve, reject) => {
+            server.close(err => (err ? reject(err) : resolve()));
+        })
+    };
+}
+async function routeRequest(req, res, services) {
+    const method = req.method || "GET";
+    const url = new URL(req.url || "/", "http://127.0.0.1");
+    const pathname = url.pathname;
+    if (method === "GET" && pathname === "/") {
+        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+        res.end(renderControlPlaneHtml());
+        return;
+    }
+    if (method === "GET" && pathname === "/api/health") {
+        sendJson(res, 200, { ok: true, keychainAvailable: await isKeychainAvailable() });
+        return;
+    }
+    if (method === "GET" && pathname === "/api/runtime/status") {
+        sendJson(res, 200, { jobs: services.runtime.getStatus() });
+        return;
+    }
+    if (method === "POST" && pathname === "/api/runtime/install") {
+        const job = await services.runtime.installOrRepair();
+        sendJson(res, 202, { job });
+        return;
+    }
+    if (method === "POST" && pathname === "/api/runtime/update/mcp") {
+        const job = await services.runtime.updateMcp();
+        sendJson(res, 202, { job });
+        return;
+    }
+    if (method === "POST" && pathname === "/api/runtime/update/skills") {
+        const body = await readJson(req);
+        const job = await services.runtime.updateSkills({
+            repoUrl: typeof body.repoUrl === "string" ? body.repoUrl : undefined,
+            branch: typeof body.branch === "string" ? body.branch : undefined
+        });
+        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 });
+        return;
+    }
+    if (method === "POST" && pathname === "/api/connections") {
+        const body = await readJson(req);
+        const created = await services.connections.add(body);
+        sendJson(res, 201, { connection: created });
+        return;
+    }
+    const matchConn = pathname.match(/^\/api\/connections\/([^/]+)$/);
+    if (matchConn) {
+        const name = decodeURIComponent(matchConn[1]);
+        if (method === "GET") {
+            const connection = await services.connections.get(name);
+            if (!connection) {
+                sendJson(res, 404, { error: `Connection ${name} not found` });
+            }
+            else {
+                sendJson(res, 200, { connection });
+            }
+            return;
+        }
+        if (method === "PUT") {
+            const body = await readJson(req);
+            const updated = await services.connections.update(name, body);
+            sendJson(res, 200, { connection: updated });
+            return;
+        }
+        if (method === "DELETE") {
+            await services.connections.delete(name);
+            sendNoContent(res);
+            return;
+        }
+    }
+    const matchRename = pathname.match(/^\/api\/connections\/([^/]+)\/rename$/);
+    if (matchRename && method === "POST") {
+        const oldName = decodeURIComponent(matchRename[1]);
+        const body = await readJson(req);
+        const newName = String(body.newName || "").trim();
+        if (!newName) {
+            sendJson(res, 400, { error: "newName is required" });
+            return;
+        }
+        const renamed = await services.connections.rename(oldName, newName);
+        sendJson(res, 200, { connection: renamed });
+        return;
+    }
+    const matchPwd = pathname.match(/^\/api\/connections\/([^/]+)\/password$/);
+    if (matchPwd && method === "POST") {
+        const name = decodeURIComponent(matchPwd[1]);
+        const body = await readJson(req);
+        const password = String(body.password || "");
+        if (!password) {
+            sendJson(res, 400, { error: "password is required" });
+            return;
+        }
+        await services.connections.setConnectionPassword(name, password);
+        sendNoContent(res);
+        return;
+    }
+    sendJson(res, 404, { error: "Not found" });
+}
+function sendJson(res, status, data) {
+    res.writeHead(status, {
+        "Content-Type": "application/json; charset=utf-8",
+        "Cache-Control": "no-store"
+    });
+    res.end(JSON.stringify(data));
+}
+function sendNoContent(res) {
+    res.writeHead(204);
+    res.end();
+}
+async function readJson(req) {
+    const chunks = [];
+    for await (const chunk of req) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    const raw = Buffer.concat(chunks).toString("utf8");
+    if (!raw.trim())
+        return {};
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        throw new Error("Invalid JSON body");
+    }
+}
+function normalizePort(port) {
+    if (!Number.isFinite(port) || port <= 0 || port > 65535)
+        return 3980;
+    return Math.floor(port);
+}