mcp-for-i 0.1.0

package/README.md

@@ -0,0 +1,53 @@
+# MCP-for-i
+
+Local MCP server for IBM i, mirroring core Code for IBM i capabilities. See `docs/` for setup and usage.
+
+## Install As CLI Package
+
+Install globally:
+
+```bash
+npm i -g mcp-for-i
+```
+
+Run control-plane UI server:
+
+```bash
+mcp-for-i-control serve
+```
+
+Then open:
+
+```text
+http://127.0.0.1:3980
+```
+
+### Background Startup (Windows)
+
+Configure autostart at login and launch now:
+
+```bash
+mcp-for-i-control setup
+```
+
+Check status:
+
+```bash
+mcp-for-i-control status
+```
+
+Disable autostart:
+
+```bash
+mcp-for-i-control remove
+```
+
+## Control Plane UI
+
+Run the local onboarding/control UI:
+
+```bash
+npm run start:controlplane
+```
+
+Then open `http://127.0.0.1:3980`.

package/dist/config/store.js

@@ -0,0 +1,365 @@
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+import { setPassword } from "../security/credentialStore.js";
+const defaultSettings = {
+    readOnlyMode: false,
+    tempLibrary: "ILEDITOR",
+    tempDir: "/tmp",
+    autoClearTempData: true,
+    sourceFileCCSID: "*FILE",
+    sqlJobCcsid: 1208,
+    enableSourceDates: true,
+    homeDirectory: ".",
+    libraryList: [],
+    currentLibrary: "",
+    customVariables: [],
+    objectFilters: [],
+    ifsShortcuts: [],
+    debugPort: 8005,
+    debugSepPort: 8008
+};
+export class ConfigStore {
+    configDir;
+    configPath;
+    data = null;
+    saveQueue = Promise.resolve();
+    constructor() {
+        this.configDir = getConfigDir();
+        this.configPath = path.join(this.configDir, "config.json");
+    }
+    async load() {
+        await ensureDir(this.configDir);
+        let loadedFromDisk = true;
+        try {
+            const raw = await fs.readFile(this.configPath, "utf8");
+            this.data = JSON.parse(raw);
+        }
+        catch {
+            loadedFromDisk = false;
+            this.data = { connections: [], settings: defaultSettings, actions: [] };
+        }
+        const migrated = await migrateConfigFile(this.data);
+        this.data = migrated.config;
+        if (!loadedFromDisk || migrated.changed) {
+            await this.save();
+        }
+        return this.data;
+    }
+    async save() {
+        if (!this.data)
+            await this.load();
+        const payload = JSON.stringify(this.data, null, 2);
+        await this.enqueueSave(async () => {
+            const tempPath = `${this.configPath}.${process.pid}.${Date.now()}.tmp`;
+            await writeFileWithRetry(tempPath, payload);
+            try {
+                await fs.rename(tempPath, this.configPath);
+            }
+            catch {
+                await writeFileWithRetry(this.configPath, payload);
+                await fs.rm(tempPath, { force: true });
+            }
+        });
+    }
+    async listConnections() {
+        const cfg = await this.load();
+        return cfg.connections;
+    }
+    async getConnection(name) {
+        const cfg = await this.load();
+        return cfg.connections.find(c => c.name === name);
+    }
+    async upsertConnection(connection) {
+        const cfg = await this.load();
+        const sanitized = await sanitizeConnection(connection);
+        const idx = cfg.connections.findIndex(c => c.name === sanitized.name);
+        if (idx >= 0) {
+            cfg.connections[idx] = { ...cfg.connections[idx], ...sanitized };
+        }
+        else {
+            cfg.connections.push(sanitized);
+        }
+        await this.save();
+    }
+    async deleteConnection(name) {
+        const cfg = await this.load();
+        cfg.connections = cfg.connections.filter(c => c.name !== name);
+        await this.save();
+    }
+    async getSettings() {
+        const cfg = await this.load();
+        return cfg.settings;
+    }
+    async updateSettings(update) {
+        const cfg = await this.load();
+        cfg.settings = { ...cfg.settings, ...update };
+        await this.save();
+    }
+    async listActions() {
+        const cfg = await this.load();
+        return cfg.actions || [];
+    }
+    async upsertAction(action) {
+        const cfg = await this.load();
+        const idx = cfg.actions.findIndex(a => a.name === action.name);
+        if (idx >= 0)
+            cfg.actions[idx] = action;
+        else
+            cfg.actions.push(action);
+        await this.save();
+    }
+    async deleteAction(name) {
+        const cfg = await this.load();
+        cfg.actions = cfg.actions.filter(a => a.name !== name);
+        await this.save();
+    }
+    async listProfiles(connectionName) {
+        const conn = await this.getConnection(connectionName);
+        return conn?.profiles || [];
+    }
+    async saveProfile(connectionName, profile) {
+        const conn = await this.getConnection(connectionName);
+        if (!conn)
+            throw new Error(`Connection ${connectionName} not found`);
+        const profiles = conn.profiles || [];
+        const idx = profiles.findIndex(p => p.name === profile.name);
+        if (idx >= 0)
+            profiles[idx] = profile;
+        else
+            profiles.push(profile);
+        conn.profiles = profiles;
+        await this.upsertConnection(conn);
+    }
+    async deleteProfile(connectionName, profileName) {
+        const conn = await this.getConnection(connectionName);
+        if (!conn)
+            throw new Error(`Connection ${connectionName} not found`);
+        conn.profiles = (conn.profiles || []).filter(p => p.name !== profileName);
+        if (conn.currentProfile === profileName) {
+            conn.currentProfile = undefined;
+        }
+        await this.upsertConnection(conn);
+    }
+    async setCurrentProfile(connectionName, profileName) {
+        const conn = await this.getConnection(connectionName);
+        if (!conn)
+            throw new Error(`Connection ${connectionName} not found`);
+        conn.currentProfile = profileName;
+        await this.upsertConnection(conn);
+    }
+    enqueueSave(operation) {
+        this.saveQueue = this.saveQueue.then(operation, operation);
+        return this.saveQueue;
+    }
+}
+export function getConfigDir() {
+    const platform = process.platform;
+    if (platform === "win32") {
+        return path.join(process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming"), "mcp-for-i");
+    }
+    if (platform === "darwin") {
+        return path.join(os.homedir(), "Library", "Application Support", "mcp-for-i");
+    }
+    return path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config"), "mcp-for-i");
+}
+async function migrateConfigFile(input) {
+    let changed = false;
+    const root = isPlainObject(input) ? input : {};
+    if (!isPlainObject(input))
+        changed = true;
+    const settings = normalizeSettings(root.settings);
+    changed = changed || settings.changed;
+    const actions = normalizeActions(root.actions);
+    changed = changed || actions.changed;
+    const normalizedConnections = await normalizeConnections(root.connections);
+    changed = changed || normalizedConnections.changed;
+    return {
+        changed,
+        config: {
+            connections: normalizedConnections.connections,
+            settings: settings.value,
+            actions: actions.value
+        }
+    };
+}
+async function normalizeConnections(value) {
+    if (!Array.isArray(value)) {
+        return { connections: [], changed: true };
+    }
+    let changed = false;
+    const seenNames = new Set();
+    const connections = [];
+    for (const [index, entry] of value.entries()) {
+        if (!isPlainObject(entry)) {
+            changed = true;
+            continue;
+        }
+        let name = toNonEmptyString(entry.name) || toNonEmptyString(entry.id);
+        if (!name) {
+            const user = toNonEmptyString(entry.username);
+            const host = toNonEmptyString(entry.host);
+            if (user && host) {
+                name = `${user}@${host}`;
+            }
+            else if (host) {
+                name = host;
+            }
+            else {
+                name = `connection-${index + 1}`;
+            }
+            changed = true;
+        }
+        const uniqueName = uniqueConnectionName(name, seenNames);
+        if (uniqueName !== name)
+            changed = true;
+        seenNames.add(uniqueName);
+        const password = toNonEmptyString(entry.password);
+        if (password) {
+            await setPassword(uniqueName, password);
+            changed = true;
+        }
+        const host = toNonEmptyString(entry.host) || "";
+        const username = toNonEmptyString(entry.username) || "";
+        const port = normalizePort(entry.port);
+        const privateKeyPath = toNonEmptyString(entry.privateKeyPath);
+        const settings = isPlainObject(entry.settings) ? entry.settings : undefined;
+        const profiles = Array.isArray(entry.profiles) ? entry.profiles : undefined;
+        const currentProfile = toNonEmptyString(entry.currentProfile);
+        const policy = normalizePolicy(entry.policy);
+        const keepaliveInterval = normalizeOptionalNumber(entry.keepaliveInterval);
+        const readyTimeout = normalizeOptionalNumber(entry.readyTimeout);
+        const sshDebug = typeof entry.sshDebug === "boolean" ? entry.sshDebug : undefined;
+        const normalized = {
+            name: uniqueName,
+            host,
+            port,
+            username
+        };
+        if (privateKeyPath)
+            normalized.privateKeyPath = privateKeyPath;
+        if (settings)
+            normalized.settings = settings;
+        if (profiles)
+            normalized.profiles = profiles;
+        if (currentProfile)
+            normalized.currentProfile = currentProfile;
+        if (policy)
+            normalized.policy = policy;
+        if (keepaliveInterval !== undefined)
+            normalized.keepaliveInterval = keepaliveInterval;
+        if (readyTimeout !== undefined)
+            normalized.readyTimeout = readyTimeout;
+        if (sshDebug !== undefined)
+            normalized.sshDebug = sshDebug;
+        if (JSON.stringify(normalized) !== JSON.stringify(entry)) {
+            changed = true;
+        }
+        connections.push(normalized);
+    }
+    return { connections, changed };
+}
+function normalizeSettings(value) {
+    if (!isPlainObject(value)) {
+        return { value: { ...defaultSettings }, changed: true };
+    }
+    const merged = { ...defaultSettings, ...value };
+    const changed = JSON.stringify(merged) !== JSON.stringify(value);
+    return { value: merged, changed };
+}
+function normalizeActions(value) {
+    if (!Array.isArray(value)) {
+        return { value: [], changed: true };
+    }
+    const filtered = value.filter(isPlainObject);
+    const changed = filtered.length !== value.length;
+    return { value: filtered, changed };
+}
+function normalizePolicy(value) {
+    if (!isPlainObject(value))
+        return undefined;
+    const profile = value.profile;
+    const normalizedProfile = profile === "read-only" || profile === "power-user" || profile === "guarded" ? profile : "guarded";
+    const policy = { ...value, profile: normalizedProfile };
+    if (!Array.isArray(policy.requireApprovalFor))
+        delete policy.requireApprovalFor;
+    if (!Array.isArray(policy.allowCommands))
+        delete policy.allowCommands;
+    if (!Array.isArray(policy.denyCommands))
+        delete policy.denyCommands;
+    if (!Array.isArray(policy.allowLibraries))
+        delete policy.allowLibraries;
+    if (!Array.isArray(policy.denyLibraries))
+        delete policy.denyLibraries;
+    if (!Array.isArray(policy.allowPaths))
+        delete policy.allowPaths;
+    if (!Array.isArray(policy.denyPaths))
+        delete policy.denyPaths;
+    return policy;
+}
+async function sanitizeConnection(connection) {
+    const raw = connection;
+    const password = toNonEmptyString(raw.password);
+    if (password) {
+        await setPassword(connection.name, password);
+    }
+    const { password: _password, storePassword: _storePassword, ...rest } = raw;
+    const normalizedPort = normalizePort(rest.port);
+    return {
+        ...rest,
+        port: normalizedPort
+    };
+}
+function uniqueConnectionName(baseName, seen) {
+    if (!seen.has(baseName))
+        return baseName;
+    let suffix = 2;
+    let candidate = `${baseName}-${suffix}`;
+    while (seen.has(candidate)) {
+        suffix += 1;
+        candidate = `${baseName}-${suffix}`;
+    }
+    return candidate;
+}
+function normalizePort(value) {
+    const port = Number(value);
+    if (!Number.isFinite(port) || port <= 0 || port > 65535) {
+        return 22;
+    }
+    return Math.floor(port);
+}
+function normalizeOptionalNumber(value) {
+    const n = Number(value);
+    if (!Number.isFinite(n))
+        return undefined;
+    return Math.floor(n);
+}
+function toNonEmptyString(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function ensureDir(dir) {
+    await fs.mkdir(dir, { recursive: true });
+}
+async function writeFileWithRetry(filePath, content, retries = 5, delayMs = 40) {
+    for (let attempt = 0; attempt <= retries; attempt++) {
+        try {
+            await fs.writeFile(filePath, content, "utf8");
+            return;
+        }
+        catch (err) {
+            const transient = err?.code === "EBUSY" || err?.code === "EPERM";
+            if (!transient || attempt === retries)
+                throw err;
+            await wait(delayMs * (attempt + 1));
+        }
+    }
+}
+async function wait(ms) {
+    await new Promise(resolve => setTimeout(resolve, ms));
+}

package/dist/controlplane/autostart.js

@@ -0,0 +1,93 @@
+import { spawn } from "child_process";
+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";
+    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;
+    }
+}
+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]);
+}
+export async function removeWindowsAutostart() {
+    assertWindowsPlatform();
+    await runCommand("schtasks", ["/Delete", "/TN", AUTOSTART_TASK_NAME, "/F"]);
+}
+export async function getWindowsAutostartStatus() {
+    assertWindowsPlatform();
+    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:"));
+        return {
+            installed: hasTask,
+            state: stateLine ? stateLine.split(":").slice(1).join(":").trim() : undefined,
+            raw: output
+        };
+    }
+    catch {
+        return {
+            installed: false,
+            state: undefined,
+            raw: ""
+        };
+    }
+}
+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 assertWindowsPlatform() {
+    if (process.platform !== "win32") {
+        throw new Error("This autostart operation is currently supported on Windows only.");
+    }
+}

package/dist/controlplane/connectionService.js

@@ -0,0 +1,79 @@
+import { deletePassword, getPassword, setPassword } from "../security/credentialStore.js";
+export class ConnectionService {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    async list() {
+        return this.store.listConnections();
+    }
+    async get(name) {
+        return this.store.getConnection(name);
+    }
+    async add(input) {
+        await this.store.upsertConnection({
+            name: input.name,
+            host: input.host,
+            port: input.port || 22,
+            username: input.username,
+            privateKeyPath: input.privateKeyPath,
+            settings: input.settings,
+            policy: input.policy
+        });
+        if (input.storePassword && input.password) {
+            await setPassword(input.name, input.password);
+        }
+        return this.get(input.name);
+    }
+    async update(name, input) {
+        const existing = await this.store.getConnection(name);
+        if (!existing)
+            throw new Error(`Connection ${name} not found`);
+        const next = {
+            ...existing,
+            host: input.host ?? existing.host,
+            port: input.port ?? existing.port,
+            username: input.username ?? existing.username,
+            privateKeyPath: input.privateKeyPath ?? existing.privateKeyPath,
+            settings: input.settings ?? existing.settings,
+            policy: input.policy ?? existing.policy
+        };
+        await this.store.upsertConnection(next);
+        if (input.storePassword && input.password) {
+            await setPassword(name, input.password);
+        }
+        return this.get(name);
+    }
+    async rename(oldName, newName) {
+        if (oldName === newName) {
+            return this.get(oldName);
+        }
+        const existing = await this.store.getConnection(oldName);
+        if (!existing)
+            throw new Error(`Connection ${oldName} not found`);
+        if (await this.store.getConnection(newName)) {
+            throw new Error(`Connection ${newName} already exists`);
+        }
+        await this.store.upsertConnection({
+            ...existing,
+            name: newName
+        });
+        await this.store.deleteConnection(oldName);
+        const password = await getPassword(oldName);
+        if (password) {
+            await setPassword(newName, password);
+        }
+        await deletePassword(oldName);
+        return this.get(newName);
+    }
+    async delete(name) {
+        await this.store.deleteConnection(name);
+        await deletePassword(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);
+    }
+}