mcp-for-i 0.1.13 → 0.2.0

package/dist/mcp/modules/libl.js

@@ -0,0 +1,246 @@
+import { applyLibraryList, enforceWritable, getConnectionName, json, updateConnectionSettings } from "../tools.js";
+const WRITE_ANNOTATIONS = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
+async function storedLibraryList(ctx, name, active) {
+    const stored = await ctx.store.getConnection(name);
+    if (!stored)
+        throw new Error(`Connection ${name} not found`);
+    let config = {};
+    try {
+        config = active.getConfig() || {};
+    }
+    catch {
+        config = {};
+    }
+    const list = (stored.settings?.libraryList ?? config.libraryList ?? []).map((lib) => String(lib).toUpperCase());
+    const currentLibrary = stored.settings?.currentLibrary ?? config.currentLibrary;
+    return { stored, list, currentLibrary };
+}
+/** Returns a copy of `list` with `library` moved; positions are 1-based. */
+export function moveLibrary(list, library, options) {
+    const index = list.indexOf(library);
+    if (index < 0)
+        throw new Error(`${library} is not in the library list`);
+    const hasPosition = options.position !== undefined && options.position !== null;
+    if (hasPosition === Boolean(options.direction))
+        throw new Error("Give either position or direction");
+    let target;
+    if (hasPosition) {
+        const position = Number(options.position);
+        if (!Number.isInteger(position) || position < 1)
+            throw new Error("position must be a whole number from 1");
+        target = Math.min(position, list.length) - 1;
+    }
+    else {
+        const steps = options.steps === undefined ? 1 : Number(options.steps);
+        if (!Number.isInteger(steps) || steps < 1)
+            throw new Error("steps must be a whole number from 1");
+        switch (options.direction) {
+            case "up":
+                target = Math.max(0, index - steps);
+                break;
+            case "down":
+                target = Math.min(list.length - 1, index + steps);
+                break;
+            case "top":
+                target = 0;
+                break;
+            case "bottom":
+                target = list.length - 1;
+                break;
+            default: throw new Error("direction must be up, down, top or bottom");
+        }
+    }
+    const next = list.filter((_lib, i) => i !== index);
+    next.splice(target, 0, library);
+    return next;
+}
+function requireLibraryName(conn, value, label = "library") {
+    const lib = String(value ?? "").trim().toUpperCase();
+    if (!lib)
+        throw new Error(`${label} is required`);
+    if (!conn.validQsysName(lib))
+        throw new Error(`Invalid ${label}: ${lib}`);
+    return lib;
+}
+async function move(ctx, args) {
+    const name = getConnectionName(ctx, args);
+    const active = await ctx.ensureActive(name);
+    const library = requireLibraryName(active, args?.library);
+    const { list, currentLibrary } = await storedLibraryList(ctx, name, active);
+    const next = moveLibrary(list, library, { position: args?.position, direction: args?.direction, steps: args?.steps });
+    await enforceWritable(ctx, active, "qsys.write", args);
+    await updateConnectionSettings(ctx, name, { libraryList: next });
+    const applied = args?.applyToJob ? await applyLibraryList(active, next, currentLibrary) : undefined;
+    return json({
+        library,
+        from: list.indexOf(library) + 1,
+        to: next.indexOf(library) + 1,
+        libraryList: next,
+        ...(applied?.warning ? { warning: applied.warning } : {})
+    });
+}
+/** Libraries in `names` that exist, checked with QSYS2.OBJECT_STATISTICS. */
+export async function existingLibraries(conn, names) {
+    if (names.length === 0)
+        return new Set();
+    const inList = names.map(lib => `'${lib.replace(/'/g, "''")}'`).join(", ");
+    let rows;
+    try {
+        rows = await conn.runSQL(`select OBJNAME from table(QSYS2.OBJECT_STATISTICS('QSYS', '*LIB', '*ALLSIMPLE')) X where OBJNAME in (${inList})`);
+    }
+    catch {
+        // Older releases do not know *ALLSIMPLE.
+        rows = await conn.runSQL(`select OBJNAME from table(QSYS2.OBJECT_STATISTICS('QSYS', '*LIB')) X where OBJNAME in (${inList})`);
+    }
+    return new Set(rows.map((row) => String(row.OBJNAME ?? "").trim().toUpperCase()));
+}
+async function prune(ctx, args) {
+    const name = getConnectionName(ctx, args);
+    const active = await ctx.ensureActive(name);
+    const { list, currentLibrary } = await storedLibraryList(ctx, name, active);
+    const valid = list.filter(lib => active.validQsysName(lib));
+    const invalidNames = list.filter(lib => !active.validQsysName(lib));
+    const checkNames = [...new Set([...valid, ...(currentLibrary ? [String(currentLibrary).toUpperCase()] : [])])]
+        .filter(lib => active.validQsysName(lib));
+    const existing = await existingLibraries(active, checkNames);
+    const removed = [...list.filter(lib => !existing.has(lib))];
+    const kept = list.filter(lib => existing.has(lib));
+    const currentLibraryMissing = Boolean(currentLibrary) && !existing.has(String(currentLibrary).toUpperCase());
+    const dryRun = Boolean(args?.dryRun);
+    let applied;
+    if (!dryRun && removed.length > 0) {
+        await enforceWritable(ctx, active, "qsys.write", args);
+        await updateConnectionSettings(ctx, name, { libraryList: kept });
+        if (args?.applyToJob)
+            applied = await applyLibraryList(active, kept, currentLibraryMissing ? undefined : currentLibrary);
+    }
+    return json({
+        dryRun,
+        removed,
+        ...(invalidNames.length ? { invalidNames } : {}),
+        libraryList: dryRun ? list : kept,
+        ...(dryRun ? { wouldBecome: kept } : {}),
+        currentLibrary: currentLibrary ?? null,
+        ...(currentLibraryMissing ? { warning: `Current library ${currentLibrary} does not exist; it was left unchanged. Use ibmi.libl.setCurrent.` } : {}),
+        ...(applied?.warning ? { applyWarning: applied.warning } : {})
+    });
+}
+/** Parses QSYS2.LIBRARY_LIST_INFO rows into the user portion and the current library. */
+export function libraryListFromRows(rows) {
+    const libraryList = [];
+    let currentLibrary;
+    for (const row of rows) {
+        const lib = String(row.SYSTEM_SCHEMA_NAME ?? "").trim().toUpperCase();
+        const type = String(row.TYPE ?? "").trim().toUpperCase();
+        if (!lib)
+            continue;
+        if (type === "USER" && !libraryList.includes(lib))
+            libraryList.push(lib);
+        if (type === "CURRENT")
+            currentLibrary = lib;
+    }
+    return { libraryList, currentLibrary };
+}
+async function runProfileCommand(ctx, args) {
+    const name = getConnectionName(ctx, args);
+    const active = await ctx.ensureActive(name);
+    const stored = await ctx.store.getConnection(name);
+    if (!stored)
+        throw new Error(`Connection ${name} not found`);
+    const profileName = args?.profileName ? String(args.profileName) : stored.currentProfile;
+    if (!profileName)
+        throw new Error("No active profile; pass profileName or activate a profile first");
+    const profile = (stored.profiles || []).find(item => item.name === profileName);
+    if (!profile)
+        throw new Error(`Profile ${profileName} not found`);
+    const command = String(profile.setLibraryListCommand || "").trim();
+    if (!command)
+        throw new Error(`Profile ${profileName} has no setLibraryListCommand`);
+    if (command.startsWith("?") || /[\r\n]/.test(command))
+        throw new Error("setLibraryListCommand must be a single CL command without prompting");
+    // The command runs as CL, so CL command policy applies; storing the result is a settings write.
+    await enforceWritable(ctx, active, "cl.run", { ...args, command });
+    await enforceWritable(ctx, active, "qsys.write", args);
+    // Run the command and read the resulting library list in the same database job.
+    const rows = await active.runSQL(`CALL QSYS2.QCMDEXC('${command.replace(/'/g, "''")}');\n` +
+        "select ORDINAL_POSITION, SYSTEM_SCHEMA_NAME, TYPE from QSYS2.LIBRARY_LIST_INFO order by ORDINAL_POSITION");
+    const { libraryList, currentLibrary } = libraryListFromRows(rows);
+    if (libraryList.length === 0 && !currentLibrary) {
+        throw new Error("The command ran but no library list could be read back from QSYS2.LIBRARY_LIST_INFO");
+    }
+    await updateConnectionSettings(ctx, name, { libraryList, currentLibrary });
+    if (args?.saveToProfile) {
+        await ctx.store.saveProfile(name, { ...profile, libraryList, ...(currentLibrary ? { currentLibrary } : {}) });
+    }
+    const applied = args?.applyToJob ? await applyLibraryList(active, libraryList, currentLibrary) : undefined;
+    return json({
+        profile: profileName,
+        command,
+        libraryList,
+        currentLibrary: currentLibrary ?? null,
+        savedToProfile: Boolean(args?.saveToProfile),
+        ...(applied?.warning ? { warning: applied.warning } : {})
+    });
+}
+const COMMON_PROPERTIES = {
+    connectionName: { type: "string", description: "Saved IBM i connection name." },
+    applyToJob: { type: "boolean", default: false, description: "Also run CHGLIBL/CHGCURLIB now." },
+    approve: { type: "boolean", description: "Set true to approve guarded-policy operations." }
+};
+export const liblModule = {
+    tools: [
+        {
+            name: "ibmi.libl.move",
+            description: "Move a library within the connection's library list: to a 1-based position, or up/down by steps, or to the top/bottom.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    ...COMMON_PROPERTIES,
+                    library: { type: "string" },
+                    position: { type: "number", description: "New 1-based position." },
+                    direction: { type: "string", enum: ["up", "down", "top", "bottom"] },
+                    steps: { type: "number", description: "How far to move up or down (default 1)." }
+                },
+                required: ["library"],
+                additionalProperties: false
+            },
+            annotations: WRITE_ANNOTATIONS
+        },
+        {
+            name: "ibmi.libl.prune",
+            description: "Remove libraries that no longer exist from the connection's library list (checked with QSYS2.OBJECT_STATISTICS). dryRun only reports.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    ...COMMON_PROPERTIES,
+                    dryRun: { type: "boolean", default: false }
+                },
+                additionalProperties: false
+            },
+            annotations: { ...WRITE_ANNOTATIONS, idempotentHint: true }
+        },
+        {
+            name: "ibmi.libl.runProfileCommand",
+            description: "Run a profile's setLibraryListCommand (the active profile by default) and store the resulting library list and current " +
+                "library in the connection settings. The command runs as CL, so CL command policy applies.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    ...COMMON_PROPERTIES,
+                    profileName: { type: "string", description: "Profile to use (default: the active profile)." },
+                    saveToProfile: { type: "boolean", default: false, description: "Also save the result into the profile." }
+                },
+                additionalProperties: false
+            },
+            annotations: WRITE_ANNOTATIONS
+        }
+    ],
+    handle: async (ctx, name, args) => {
+        switch (name) {
+            case "ibmi.libl.move": return move(ctx, args);
+            case "ibmi.libl.prune": return prune(ctx, args);
+            case "ibmi.libl.runProfileCommand": return runProfileCommand(ctx, args);
+        }
+        throw new Error(`Unknown tool: ${name}`);
+    }
+};

package/dist/mcp/modules/members.js

@@ -0,0 +1,171 @@
+import { Tools } from "../../ibmi/Tools.js";
+import { commandOutcome, enforceWritable, toolError } from "../tools.js";
+import { clTextValue, enforceLibraryPolicy, optionalName, refuseProtectedLibrary, requireName, runCheckedCl } from "./objects.js";
+/**
+ * Source member copy and attribute changes. Each tool passes the write gate,
+ * reports a failing CL command as a tool error, and drops the cached member
+ * snapshot for every member it may have changed.
+ */
+const CONNECTION_NAME = { type: "string", description: "Saved IBM i connection name." };
+const APPROVE = { type: "boolean", description: "Set true to approve guarded-policy operations." };
+function annotations(destructive, idempotent) {
+    return { readOnlyHint: false, destructiveHint: destructive, idempotentHint: idempotent, openWorldHint: false };
+}
+const MEMBER_PROPERTIES = {
+    library: { type: "string" },
+    sourceFile: { type: "string" },
+    member: { type: "string" }
+};
+const tools = [
+    {
+        name: "ibmi.qsys.members.copy",
+        description: "Copy a source member with CPYSRCF. The target defaults to the same library, source file and member name; " +
+            "at least one must differ. An existing target member is only replaced when replace=true.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                ...MEMBER_PROPERTIES,
+                toLibrary: { type: "string" },
+                toSourceFile: { type: "string" },
+                toMember: { type: "string" },
+                replace: { type: "boolean", description: "Replace the target member if it exists. Default false." },
+                connectionName: CONNECTION_NAME,
+                approve: APPROVE
+            },
+            required: ["library", "sourceFile", "member"],
+            additionalProperties: false
+        },
+        annotations: annotations(true, false)
+    },
+    {
+        name: "ibmi.qsys.members.changeText",
+        description: "Change a member's text description with CHGPFM TEXT(...). An empty text sets *BLANK.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                ...MEMBER_PROPERTIES,
+                text: { type: "string", description: "Up to 50 characters." },
+                connectionName: CONNECTION_NAME,
+                approve: APPROVE
+            },
+            required: ["library", "sourceFile", "member", "text"],
+            additionalProperties: false
+        },
+        annotations: annotations(false, true)
+    },
+    {
+        name: "ibmi.qsys.members.changeType",
+        description: "Change a member's source type with CHGPFM SRCTYPE(...), for example RPGLE or SQLRPGLE.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                ...MEMBER_PROPERTIES,
+                srctype: { type: "string", description: "New source type (up to 10 characters) or *NONE." },
+                connectionName: CONNECTION_NAME,
+                approve: APPROVE
+            },
+            required: ["library", "sourceFile", "member", "srctype"],
+            additionalProperties: false
+        },
+        annotations: annotations(false, true)
+    }
+];
+export function requireSourceType(value) {
+    const type = String(value ?? "").trim().toUpperCase();
+    if (!type)
+        throw new Error("srctype is required");
+    if (type !== "*NONE" && !/^[A-Z0-9#@$_.]{1,10}$/.test(type))
+        throw new Error(`Invalid srctype: ${value}`);
+    return type;
+}
+function invalidate(conn, library, sourceFile, member) {
+    if (typeof conn?.content?.invalidateMemberSnapshot === "function") {
+        conn.content.invalidateMemberSnapshot(library, sourceFile, member);
+    }
+}
+async function memberExists(conn, library, sourceFile, member) {
+    const rows = await conn.runSQL(`select SYSTEM_TABLE_MEMBER from QSYS2.SYSPARTITIONSTAT where SYSTEM_TABLE_SCHEMA = ${Tools.sqlString(library)} ` +
+        `and SYSTEM_TABLE_NAME = ${Tools.sqlString(sourceFile)} and SYSTEM_TABLE_MEMBER = ${Tools.sqlString(member)} ` +
+        `fetch first 1 rows only`);
+    return Array.isArray(rows) && rows.length > 0;
+}
+async function memberAttributes(conn, library, sourceFile, member) {
+    const rows = await conn.runSQL(`select SOURCE_TYPE, PARTITION_TEXT from QSYS2.SYSPARTITIONSTAT where SYSTEM_TABLE_SCHEMA = ${Tools.sqlString(library)} ` +
+        `and SYSTEM_TABLE_NAME = ${Tools.sqlString(sourceFile)} and SYSTEM_TABLE_MEMBER = ${Tools.sqlString(member)} ` +
+        `fetch first 1 rows only`).catch(() => []);
+    const row = Array.isArray(rows) && rows[0] ? rows[0] : {};
+    const srctype = String(row.SOURCE_TYPE ?? "").trim().toUpperCase();
+    return {
+        srctype: /^[A-Z0-9_]{1,10}$/.test(srctype) ? srctype : "",
+        text: String(row.PARTITION_TEXT ?? "").trim()
+    };
+}
+async function handle(ctx, name, args) {
+    args = args || {};
+    const conn = await ctx.ensureActive(args.connectionName);
+    await enforceWritable(ctx, conn, "qsys.write", args);
+    const library = requireName(args.library, "library");
+    const sourceFile = requireName(args.sourceFile, "sourceFile");
+    const member = requireName(args.member, "member");
+    switch (name) {
+        case "ibmi.qsys.members.copy": {
+            const toLibrary = optionalName(args.toLibrary, "toLibrary", library);
+            const toSourceFile = optionalName(args.toSourceFile, "toSourceFile", sourceFile);
+            const toMember = optionalName(args.toMember, "toMember", member);
+            if (toLibrary === library && toSourceFile === sourceFile && toMember === member) {
+                throw new Error("Copy target is the same as the source: set toLibrary, toSourceFile or toMember");
+            }
+            refuseProtectedLibrary(toLibrary, "copying members");
+            enforceLibraryPolicy(ctx, name, args, [library, toLibrary]);
+            if (args.replace !== true && await memberExists(conn, toLibrary, toSourceFile, toMember)) {
+                return toolError(`Member ${toLibrary}/${toSourceFile}(${toMember}) already exists. Pass replace=true to overwrite it.`, { library: toLibrary, sourceFile: toSourceFile, member: toMember });
+            }
+            const command = `CPYSRCF FROMFILE(${library}/${sourceFile}) TOFILE(${toLibrary}/${toSourceFile}) ` +
+                `FROMMBR(${member}) TOMBR(${toMember}) MBROPT(*REPLACE)`;
+            try {
+                const copied = await runCheckedCl(ctx, conn, args, command);
+                if (copied.code === 0) {
+                    // CPYSRCF does not carry the source type or text to a new member.
+                    const attributes = await memberAttributes(conn, library, sourceFile, member);
+                    if (attributes.srctype || attributes.text) {
+                        const change = `CHGPFM FILE(${toLibrary}/${toSourceFile}) MBR(${toMember})` +
+                            (attributes.srctype ? ` SRCTYPE(${attributes.srctype})` : "") +
+                            (attributes.text ? ` TEXT(${clTextValue(attributes.text)})` : "");
+                        const changed = await runCheckedCl(ctx, conn, args, change);
+                        if (changed.code !== 0)
+                            return commandOutcome(changed);
+                    }
+                }
+                return commandOutcome(copied);
+            }
+            finally {
+                invalidate(conn, toLibrary, toSourceFile, toMember);
+            }
+        }
+        case "ibmi.qsys.members.changeText": {
+            const text = clTextValue(args.text);
+            refuseProtectedLibrary(library, "changing members");
+            enforceLibraryPolicy(ctx, name, args, [library]);
+            try {
+                return commandOutcome(await runCheckedCl(ctx, conn, args, `CHGPFM FILE(${library}/${sourceFile}) MBR(${member}) TEXT(${text})`));
+            }
+            finally {
+                invalidate(conn, library, sourceFile, member);
+            }
+        }
+        case "ibmi.qsys.members.changeType": {
+            const srctype = requireSourceType(args.srctype);
+            refuseProtectedLibrary(library, "changing members");
+            enforceLibraryPolicy(ctx, name, args, [library]);
+            try {
+                return commandOutcome(await runCheckedCl(ctx, conn, args, `CHGPFM FILE(${library}/${sourceFile}) MBR(${member}) SRCTYPE(${srctype})`));
+            }
+            finally {
+                invalidate(conn, library, sourceFile, member);
+            }
+        }
+        default:
+            throw new Error(`Unknown tool: ${name}`);
+    }
+}
+export const membersModule = { tools, handle };