mcp-for-i 0.1.4 → 0.1.5

package/dist/controlplane/runtimeService.js

@@ -19,6 +19,55 @@ export class RuntimeService {
     getStatus() {
         return this.state;
     }
+    async getVersions(options) {
+        const mode = await this.detectExecutionModeQuiet();
+        const checkedAt = new Date().toISOString();
+        const mcpInstalled = await this.readLocalPackageVersion(this.rootDir);
+        const mcpLatest = await this.readLatestPublishedVersion();
+        const mcpStatus = mcpInstalled && mcpLatest
+            ? (mcpInstalled === mcpLatest ? "latest" : "update-available")
+            : "unknown";
+        const configuredRepo = sanitizeRepoUrl(options?.repoUrl) || process.env.MCP_FOR_I_SKILLS_REPO || DEFAULT_SKILLS_REPO;
+        const configuredBranch = sanitizeBranch(options?.branch) || process.env.MCP_FOR_I_SKILLS_BRANCH || "main";
+        const skillsDir = path.join(this.rootDir, "skills");
+        const skillsGit = path.join(skillsDir, ".git");
+        const skills = {
+            configuredRepo,
+            configuredBranch,
+            status: "not-installed"
+        };
+        if (await pathExists(skillsDir)) {
+            if (await pathExists(skillsGit)) {
+                const localRepo = await this.getGitRemoteUrlQuiet(skillsDir);
+                const localBranch = await this.getGitBranchQuiet(skillsDir);
+                const localCommit = await this.getGitCommitQuiet(skillsDir, true);
+                const latestCommit = await this.getRemoteBranchCommitQuiet(configuredRepo, configuredBranch, true);
+                skills.localRepo = localRepo;
+                skills.localBranch = localBranch;
+                skills.localCommit = localCommit;
+                skills.latestCommit = latestCommit;
+                if (localCommit && latestCommit) {
+                    skills.status = localCommit === latestCommit ? "latest" : "update-available";
+                }
+                else {
+                    skills.status = "unknown";
+                }
+            }
+            else {
+                skills.status = "unknown";
+            }
+        }
+        return {
+            checkedAt,
+            mcp: {
+                source: mode,
+                installedVersion: mcpInstalled,
+                latestVersion: mcpLatest,
+                status: mcpStatus
+            },
+            skills
+        };
+    }
     async installOrRepair() {
         return this.runJob("install", async (push) => {
             const mode = await this.detectExecutionMode(push);
@@ -239,6 +288,10 @@ export class RuntimeService {
         push("No git checkout found. Falling back to npm-based package management.");
         return "package-install";
     }
+    async detectExecutionModeQuiet() {
+        const gitDir = path.join(this.rootDir, ".git");
+        return await pathExists(gitDir) ? "git-checkout" : "package-install";
+    }
     async buildIfPresent(push) {
         const tsconfigPath = path.join(this.rootDir, "tsconfig.json");
         if (!await pathExists(tsconfigPath)) {
@@ -304,6 +357,103 @@ export class RuntimeService {
         push("Control plane will stop briefly, then restart automatically.");
         push(`Background update log: ${logPath}`);
     }
+    async readLocalPackageVersion(cwd) {
+        try {
+            const packagePath = path.join(cwd, "package.json");
+            const raw = await fs.readFile(packagePath, "utf8");
+            const parsed = JSON.parse(raw);
+            return typeof parsed.version === "string" ? parsed.version : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async readLatestPublishedVersion() {
+        try {
+            const output = await this.runNpmCapture(["view", PACKAGE_NAME, "version", "--json"], this.rootDir);
+            const parsed = JSON.parse(output || "null");
+            if (typeof parsed === "string")
+                return parsed.trim();
+            if (parsed && typeof parsed.version === "string")
+                return parsed.version.trim();
+            return undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async getGitBranchQuiet(cwd) {
+        try {
+            const branch = await this.runCommandCaptureSilent("git", ["rev-parse", "--abbrev-ref", "HEAD"], cwd);
+            return branch || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async getGitCommitQuiet(cwd, short = false) {
+        try {
+            const args = short ? ["rev-parse", "--short", "HEAD"] : ["rev-parse", "HEAD"];
+            const commit = await this.runCommandCaptureSilent("git", args, cwd);
+            return commit || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async getGitRemoteUrlQuiet(cwd) {
+        try {
+            const value = await this.runCommandCaptureSilent("git", ["remote", "get-url", "origin"], cwd);
+            return value || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async getRemoteBranchCommitQuiet(repoUrl, branch, short = false) {
+        try {
+            const out = await this.runCommandCaptureSilent("git", ["ls-remote", repoUrl, branch], this.rootDir);
+            const firstLine = out.split(/\r?\n/).find(Boolean);
+            if (!firstLine)
+                return undefined;
+            const [hash] = firstLine.trim().split(/\s+/);
+            if (!hash)
+                return undefined;
+            return short ? hash.slice(0, 7) : hash;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async runNpmCapture(args, cwd) {
+        const npm = await resolveNpmLaunch();
+        if (npm.mode === "node-cli") {
+            return this.runCommandCaptureSilent(process.execPath, [npm.path, ...args], cwd);
+        }
+        return this.runCommandCaptureSilent(npm.path, args, cwd);
+    }
+    runCommandCaptureSilent(command, args, cwd) {
+        return new Promise((resolve, reject) => {
+            const child = spawn(command, args, {
+                cwd,
+                shell: process.platform === "win32"
+            });
+            const stdout = [];
+            const stderr = [];
+            child.stdout.on("data", chunk => stdout.push(String(chunk)));
+            child.stderr.on("data", chunk => stderr.push(String(chunk)));
+            child.on("error", reject);
+            child.on("exit", code => {
+                if (code === 0) {
+                    resolve(stdout.join("").trim());
+                }
+                else {
+                    const errText = stderr.join("").trim();
+                    reject(new Error(errText || `Command failed (${code}): ${command} ${args.join(" ")}`));
+                }
+            });
+        });
+    }
 }
 function makeJob(id) {
     return {

package/dist/controlplane/server.js

@@ -52,6 +52,14 @@ async function routeRequest(req, res, services) {
         sendJson(res, 200, { jobs: services.runtime.getStatus() });
         return;
     }
+    if (method === "GET" && pathname === "/api/runtime/versions") {
+        const versions = await services.runtime.getVersions({
+            repoUrl: url.searchParams.get("repoUrl") || undefined,
+            branch: url.searchParams.get("branch") || undefined
+        });
+        sendJson(res, 200, versions);
+        return;
+    }
     if (method === "POST" && pathname === "/api/runtime/install") {
         const job = await services.runtime.installOrRepair();
         sendJson(res, 202, { job });