mcp-for-i 0.1.0 → 0.1.2

package/README.md

@@ -1,30 +1,41 @@
 # MCP-for-i
 
-Local MCP server for IBM i, mirroring core Code for IBM i capabilities. See `docs/` for setup and usage.
+`mcp-for-i` is a local MCP server + control plane for IBM i workflows. It provides secure connection onboarding, keychain-backed credentials, runtime update controls, and IBM i tools for agent-driven operations.
 
-## Install As CLI Package
+## Install
 
-Install globally:
+Install globally from npm:
 
 ```bash
 npm i -g mcp-for-i
 ```
 
-Run control-plane UI server:
+Verify commands:
+
+```bash
+mcp-for-i --help
+mcp-for-i-control help
+```
+
+## Quick Start
+
+1. Start the local control plane:
 
 ```bash
 mcp-for-i-control serve
 ```
 
-Then open:
+2. Open the UI at:
 
 ```text
 http://127.0.0.1:3980
 ```
 
-### Background Startup (Windows)
+3. Add IBM i connection profiles in the UI. Passwords are stored in the OS keychain, not plain config.
+
+## Background Startup (Windows)
 
-Configure autostart at login and launch now:
+Enable startup at login:
 
 ```bash
 mcp-for-i-control setup
@@ -36,18 +47,72 @@ Check status:
 mcp-for-i-control status
 ```
 
-Disable autostart:
+Disable startup:
 
 ```bash
 mcp-for-i-control remove
 ```
 
-## Control Plane UI
+## Update and Version Management
 
-Run the local onboarding/control UI:
+Update to latest globally:
 
 ```bash
+npm i -g mcp-for-i@latest
+```
+
+Install a specific version:
+
+```bash
+npm i -g mcp-for-i@0.1.1
+```
+
+Rollback example:
+
+```bash
+npm i -g mcp-for-i@0.1.0
+```
+
+Check current installed version:
+
+```bash
+mcp-for-i --version
+```
+
+## Control Plane Runtime Actions
+
+In the UI, runtime buttons behave as follows:
+
+- `Install/Repair MCP`
+  - If running from a git checkout: runs local dependency repair/build.
+  - If running as npm-installed package: runs global npm install/repair for latest package.
+- `Update MCP`
+  - If running from a git checkout: pulls latest changes from `origin/<current-branch>`, then installs/builds.
+  - If running as npm-installed package: upgrades global npm package to latest.
+  - On Windows global installs, update runs in a detached updater and briefly restarts control plane to avoid file-lock (`EBUSY`) errors.
+- `Update Skills`
+  - Pulls/clones the configured skills repository and branch into the local `skills` directory.
+
+## Development (Git Checkout)
+
+For contributors working from source:
+
+```bash
+npm install
+npm run build
+npm test
 npm run start:controlplane
 ```
 
-Then open `http://127.0.0.1:3980`.
+## Security Model
+
+- Credential-bearing direct tool arguments are blocked for connection creation/update flows.
+- Passwords are stored in keychain when available.
+- Control plane is local-first (`127.0.0.1` by default).
+- Guarded policy profile is the default for operational safety.
+
+## Links
+
+- Main repo: [ashishthomas2202/mcp-for-i](https://github.com/ashishthomas2202/mcp-for-i)
+- Skills repo: [ashishthomas2202/mcp-for-i-skills](https://github.com/ashishthomas2202/mcp-for-i-skills)
+- Docs: `docs/`

package/dist/controlplane/autostart.js

@@ -1,4 +1,7 @@
 import { spawn } from "child_process";
+import fs from "fs/promises";
+import os from "os";
+import path from "path";
 export const AUTOSTART_TASK_NAME = "mcp-for-i-controlplane";
 export function getControlPlaneUrl() {
     const host = process.env.MCP_FOR_I_CONTROL_HOST || "127.0.0.1";
@@ -20,74 +23,58 @@ export async function isControlPlaneRunning(baseUrl = getControlPlaneUrl()) {
 }
 export async function configureWindowsAutostart(scriptPath, nodePath = process.execPath) {
     assertWindowsPlatform();
-    const taskCmd = `"${nodePath}" "${scriptPath}" serve`;
-    await runCommand("schtasks", [
-        "/Create",
-        "/F",
-        "/SC",
-        "ONLOGON",
-        "/RL",
-        "LIMITED",
-        "/TN",
-        AUTOSTART_TASK_NAME,
-        "/TR",
-        taskCmd
-    ]);
-    await runCommand("schtasks", ["/Run", "/TN", AUTOSTART_TASK_NAME]);
+    const startupScriptPath = getWindowsStartupScriptPath();
+    await fs.mkdir(path.dirname(startupScriptPath), { recursive: true });
+    const command = `${quoteForWindowsCommand(nodePath)} ${quoteForWindowsCommand(scriptPath)} serve`;
+    const startupScript = [
+        "@echo off",
+        "setlocal",
+        `start \"\" /MIN ${command}`,
+        "exit /b 0"
+    ].join("\r\n");
+    await fs.writeFile(startupScriptPath, startupScript, "utf8");
+    spawn(nodePath, [scriptPath, "serve"], {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true
+    }).unref();
 }
 export async function removeWindowsAutostart() {
     assertWindowsPlatform();
-    await runCommand("schtasks", ["/Delete", "/TN", AUTOSTART_TASK_NAME, "/F"]);
+    const startupScriptPath = getWindowsStartupScriptPath();
+    await fs.rm(startupScriptPath, { force: true });
 }
 export async function getWindowsAutostartStatus() {
     assertWindowsPlatform();
+    const startupScriptPath = getWindowsStartupScriptPath();
     try {
-        const output = await runCommandCapture("schtasks", ["/Query", "/TN", AUTOSTART_TASK_NAME, "/FO", "LIST"]);
-        const lower = output.toLowerCase();
-        const hasTask = lower.includes("taskname:");
-        const stateLine = output
-            .split(/\r?\n/)
-            .find(line => line.trim().toLowerCase().startsWith("status:"));
+        const stat = await fs.stat(startupScriptPath);
         return {
-            installed: hasTask,
-            state: stateLine ? stateLine.split(":").slice(1).join(":").trim() : undefined,
-            raw: output
+            installed: true,
+            state: "startup-script",
+            raw: startupScriptPath,
+            updatedAt: stat.mtime.toISOString()
         };
     }
     catch {
         return {
             installed: false,
             state: undefined,
-            raw: ""
+            raw: startupScriptPath,
+            updatedAt: undefined
         };
     }
 }
-export async function runCommand(command, args) {
-    await runCommandCapture(command, args);
-}
-export async function runCommandCapture(command, args) {
-    return await new Promise((resolve, reject) => {
-        const child = spawn(command, args, { shell: process.platform === "win32" });
-        let output = "";
-        child.stdout.on("data", chunk => {
-            output += String(chunk);
-        });
-        child.stderr.on("data", chunk => {
-            output += String(chunk);
-        });
-        child.on("error", reject);
-        child.on("exit", code => {
-            if (code === 0) {
-                resolve(output.trim());
-            }
-            else {
-                reject(new Error(output.trim() || `Command failed (${code}): ${command} ${args.join(" ")}`));
-            }
-        });
-    });
+function getWindowsStartupScriptPath() {
+    const appData = process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming");
+    return path.join(appData, "Microsoft", "Windows", "Start Menu", "Programs", "Startup", `${AUTOSTART_TASK_NAME}.cmd`);
 }
 function assertWindowsPlatform() {
     if (process.platform !== "win32") {
         throw new Error("This autostart operation is currently supported on Windows only.");
     }
 }
+function quoteForWindowsCommand(value) {
+    const escaped = value.replaceAll(`"`, `""`);
+    return `"${escaped}"`;
+}

package/dist/controlplane/runtimeService.js

@@ -1,5 +1,6 @@
 import { spawn } from "child_process";
 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";
@@ -20,15 +21,33 @@ export class RuntimeService {
     }
     async installOrRepair() {
         return this.runJob("install", async (push) => {
-            await this.runNpm(["install"], this.rootDir, push);
-            await this.runNpm(["run", "build"], this.rootDir, 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) => {
-            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);
+            const mode = await this.detectExecutionMode(push);
+            if (mode === "git-checkout") {
+                const branch = await this.getGitCurrentBranch(this.rootDir, push);
+                if (branch) {
+                    await this.runCommand("git", ["fetch", "origin", branch], this.rootDir, push);
+                    await this.runCommand("git", ["pull", "--ff-only", "origin", branch], this.rootDir, push);
+                }
+                else {
+                    push("Could not determine current branch. Using plain fast-forward pull.");
+                    await this.runCommand("git", ["pull", "--ff-only"], this.rootDir, push);
+                }
+                await this.runNpm(["install"], this.rootDir, push);
+                await this.buildIfPresent(push);
+                return;
+            }
+            await this.runGlobalPackageUpdate(push, "update");
         });
     }
     async updateSkills(options) {
@@ -178,12 +197,7 @@ export class RuntimeService {
     }
     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();
+            const value = await this.runCommandCapture("git", ["remote", "get-url", "origin"], cwd, push);
             return value || undefined;
         }
         catch {
@@ -197,12 +211,19 @@ export class RuntimeService {
                 cwd,
                 shell: process.platform === "win32"
             });
-            child.stdout.on("data", chunk => push(String(chunk).trimEnd()));
+            const lines = [];
+            child.stdout.on("data", chunk => {
+                const line = String(chunk).trimEnd();
+                if (!line)
+                    return;
+                lines.push(line);
+                push(line);
+            });
             child.stderr.on("data", chunk => push(String(chunk).trimEnd()));
             child.on("error", reject);
             child.on("exit", code => {
                 if (code === 0) {
-                    resolve();
+                    resolve(lines.join("\n").trim());
                 }
                 else {
                     reject(new Error(`Command failed (${code}): ${command} ${args.join(" ")}`));
@@ -210,6 +231,80 @@ export class RuntimeService {
             });
         });
     }
+    async detectExecutionMode(push) {
+        const gitDir = path.join(this.rootDir, ".git");
+        if (await pathExists(gitDir)) {
+            return "git-checkout";
+        }
+        push("No git checkout found. Falling back to npm-based package management.");
+        return "package-install";
+    }
+    async buildIfPresent(push) {
+        const tsconfigPath = path.join(this.rootDir, "tsconfig.json");
+        if (!await pathExists(tsconfigPath)) {
+            push("Skipping build: tsconfig.json not found.");
+            return;
+        }
+        await this.runNpm(["run", "build"], this.rootDir, push);
+    }
+    async getGitCurrentBranch(cwd, push) {
+        try {
+            const name = await this.runCommandCapture("git", ["rev-parse", "--abbrev-ref", "HEAD"], cwd, push);
+            const branch = name.trim();
+            if (!branch || branch === "HEAD") {
+                return undefined;
+            }
+            return branch;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async runGlobalPackageUpdate(push, action) {
+        if (process.platform === "win32" && this.isLikelyGlobalInstall()) {
+            await this.scheduleWindowsSelfUpdate(push, action);
+            return;
+        }
+        push(`Running global ${action} for ${PACKAGE_NAME}@latest`);
+        await this.runNpm(["install", "-g", `${PACKAGE_NAME}@latest`], this.rootDir, push);
+    }
+    isLikelyGlobalInstall() {
+        const normalizedRoot = path.normalize(this.rootDir).toLowerCase();
+        const marker = `${path.sep}node_modules${path.sep}${PACKAGE_NAME}`.toLowerCase();
+        return normalizedRoot.includes(marker);
+    }
+    async scheduleWindowsSelfUpdate(push, action) {
+        const npm = await resolveNpmLaunch();
+        const controlPlaneScript = path.join(path.dirname(fileURLToPath(import.meta.url)), "index.js");
+        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`);
+        const installCommand = npm.mode === "node-cli"
+            ? `"${process.execPath}" "${npm.path}" install -g ${PACKAGE_NAME}@latest`
+            : `"${npm.path}" install -g ${PACKAGE_NAME}@latest`;
+        const script = [
+            "@echo off",
+            "setlocal",
+            `set \"LOG_PATH=${logPath}\"`,
+            `echo [${new Date().toISOString()}] Scheduled ${action}>>\"%LOG_PATH%\"`,
+            "timeout /t 2 /nobreak >nul",
+            `taskkill /PID ${process.pid} /F >nul 2>nul`,
+            `${installCommand} >>\"%LOG_PATH%\" 2>&1`,
+            "if errorlevel 1 goto :end",
+            `start \"\" \"${process.execPath}\" \"${controlPlaneScript}\" serve`,
+            ":end",
+            `echo [${new Date().toISOString()}] Finished ${action}>>\"%LOG_PATH%\"`,
+            "del \"%~f0\" >nul 2>nul"
+        ].join("\r\n");
+        await fs.writeFile(scriptPath, script, "utf8");
+        spawn("cmd.exe", ["/d", "/s", "/c", scriptPath], {
+            detached: true,
+            stdio: "ignore"
+        }).unref();
+        push(`Scheduled self-${action} in background to avoid Windows file-lock errors.`);
+        push("Control plane will stop briefly, then restart automatically.");
+        push(`Background update log: ${logPath}`);
+    }
 }
 function makeJob(id) {
     return {
@@ -251,7 +346,8 @@ async function safeRename(from, to) {
         // best-effort rollback
     }
 }
-const DEFAULT_SKILLS_REPO = "https://github.com/ashishthomas-pcr/mcp-for-i-skills.git";
+const DEFAULT_SKILLS_REPO = "https://github.com/ashishthomas2202/mcp-for-i-skills.git";
+const PACKAGE_NAME = "mcp-for-i";
 async function pathExists(target) {
     try {
         await fs.access(target);

package/dist/controlplane/server.js

@@ -1,5 +1,8 @@
 import http from "http";
+import fs from "fs";
+import path from "path";
 import { URL } from "url";
+import { fileURLToPath } from "url";
 import { ConfigStore } from "../config/store.js";
 import { isKeychainAvailable } from "../security/credentialStore.js";
 import { ConnectionService } from "./connectionService.js";
@@ -8,7 +11,7 @@ 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 rootDir = opts?.rootDir || process.env.MCP_FOR_I_ROOT_DIR || getDefaultRootDir();
     const store = new ConfigStore();
     const connections = new ConnectionService(store);
     const runtime = new RuntimeService(rootDir);
@@ -178,3 +181,11 @@ function normalizePort(port) {
         return 3980;
     return Math.floor(port);
 }
+function getDefaultRootDir() {
+    const runtimeRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+    const packageJsonPath = path.join(runtimeRoot, "package.json");
+    if (fs.existsSync(packageJsonPath)) {
+        return runtimeRoot;
+    }
+    return process.cwd();
+}

package/dist/controlplane/ui.js

@@ -380,7 +380,7 @@ export function renderControlPlaneHtml() {
       <div class="grid-2">
         <div class="field">
           <label>Skills Repo URL</label>
-          <input id="skillsRepoUrl" placeholder="https://github.com/ashishthomas-pcr/mcp-for-i-skills.git" />
+          <input id="skillsRepoUrl" placeholder="https://github.com/ashishthomas2202/mcp-for-i-skills.git" />
         </div>
         <div class="field">
           <label>Skills Branch</label>
@@ -389,7 +389,7 @@ export function renderControlPlaneHtml() {
       </div>
       <div class="actions">
         <button id="installBtn" type="button">Install/Repair MCP</button>
-        <button id="updateMcpBtn" class="secondary" type="button">Update MCP from GitHub</button>
+        <button id="updateMcpBtn" class="secondary" type="button">Update MCP</button>
         <button id="updateSkillsBtn" class="secondary" type="button">Update Skills</button>
         <button id="refreshStatusBtn" class="secondary" type="button">Refresh Status</button>
         <button id="setupAutostartBtn" class="secondary" type="button">Enable Background Startup</button>
@@ -398,7 +398,9 @@ export function renderControlPlaneHtml() {
       </div>
       <div id="autostartInfo" class="hint">Startup status: checking...</div>
       <div id="logs" class="logs">No jobs yet.</div>
-      <div class="hint">Actions stream logs live. Skills update can clone or pull from the repo and branch shown above.</div>
+      <div class="hint">Install/Repair uses local git checkout when available, otherwise global npm install. Update MCP follows the same mode.</div>
+      <div class="hint">Windows global updates may briefly restart the local control-plane service.</div>
+      <div class="hint">Skills update can clone or pull from the repo and branch shown above.</div>
     </section>
 
     <section class="card" style="grid-column: 1 / -1;">
@@ -424,7 +426,7 @@ export function renderControlPlaneHtml() {
     const THEME_KEY = "mcp_for_i_theme";
     const SKILLS_REPO_KEY = "mcp_for_i_skills_repo";
     const SKILLS_BRANCH_KEY = "mcp_for_i_skills_branch";
-    const DEFAULT_SKILLS_REPO = "https://github.com/ashishthomas-pcr/mcp-for-i-skills.git";
+    const DEFAULT_SKILLS_REPO = "https://github.com/ashishthomas2202/mcp-for-i-skills.git";
     const DEFAULT_SKILLS_BRANCH = "main";
 
     const state = {

package/dist/index.js

@@ -6,7 +6,7 @@ import { getTools, handleTool } from "./mcp/tools.js";
 import { McpContext } from "./mcp/context.js";
 import { log } from "./mcp/logger.js";
 import { validateToolInput } from "./mcp/validation.js";
-const server = new Server({ name: "mcp-for-i", version: "0.1.0" }, { capabilities: { tools: {} } });
+const server = new Server({ name: "mcp-for-i", version: "0.1.2" }, { capabilities: { tools: {} } });
 const ctx = new McpContext();
 const tools = getTools();
 const toolMap = new Map(tools.map(tool => [tool.name, tool]));

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "mcp-for-i",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "private": false,
   "description": "Local MCP server and control plane for IBM i workflows",
   "type": "module",
-  "homepage": "https://github.com/ashishthomas-pcr/mcp-for-i",
+  "homepage": "https://github.com/ashishthomas2202/mcp-for-i",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/ashishthomas-pcr/mcp-for-i.git"
+    "url": "git+https://github.com/ashishthomas2202/mcp-for-i.git"
   },
   "bugs": {
-    "url": "https://github.com/ashishthomas-pcr/mcp-for-i/issues"
+    "url": "https://github.com/ashishthomas2202/mcp-for-i/issues"
   },
   "files": [
     "dist",