mcp-for-i 0.1.13 → 0.2.0

package/dist/mcp/modules/compile.js

@@ -0,0 +1,515 @@
+import fs from "fs/promises";
+import path from "path";
+import { CompileTools } from "../../ibmi/CompileTools.js";
+import { Variables } from "../../ibmi/variables.js";
+import { Tools } from "../../ibmi/Tools.js";
+import { parseEvfevent } from "../../ibmi/evfevent.js";
+import { actionCommandGuard, clampNumber, enforceWritable, guardLocalPath, handleTool, json, jsonError, mapActionExecution, normalizeSpoolEntry, normalizeSpoolLine, requireQsysName, resolveAction } from "../tools.js";
+/** Variables an action may use that this server can leave unset for a target. */
+const TARGET_VARIABLES = [
+    "RELATIVEPATH", "FULLPATH", "FILEDIR", "PARENT", "BASENAME", "NAME", "NAMEL", "EXT", "EXTL",
+    "OPENLIB", "OPENLIBL", "OPENSPF", "OPENSPFL", "OPENMBR", "OPENMBRL", "SRCFILE", "SRCLIB", "SRCPF",
+    "LIBRARY", "CURLIB", "BUILDLIB", "LIBLS", "WORKDIR", "HOME", "BRANCH", "USERNAME", "HOST"
+];
+/** Object parameters that name the object a compile creates. */
+const OBJECT_PARAMETERS = ["PGM", "MODULE", "OBJ", "SRVPGM", "CMD", "FILE", "MENU", "PNLGRP", "QRY", "TBL"];
+/** Split a member target such as LIB/FILE/MBR, LIB/FILE/MBR.TYPE or /QSYS.LIB/LIB.LIB/FILE.FILE/MBR.MBR. */
+export function parseMemberTargetPath(value) {
+    const text = String(value ?? "").trim();
+    if (!text)
+        return {};
+    const qsys = text.match(/^\/QSYS\.LIB\/([^/]+)\.LIB\/([^/]+)\.FILE\/([^/]+)\.MBR$/i);
+    if (qsys)
+        return { library: qsys[1], sourceFile: qsys[2], member: qsys[3] };
+    const parts = text.replace(/^\/+/, "").split("/");
+    if (parts.length === 3) {
+        const [library, sourceFile, last] = parts;
+        const dot = last.lastIndexOf(".");
+        return dot > 0
+            ? { library, sourceFile, member: last.substring(0, dot), extension: last.substring(dot + 1) }
+            : { library, sourceFile, member: last };
+    }
+    if (parts.length === 1) {
+        const dot = text.lastIndexOf(".");
+        return dot > 0 ? { member: text.substring(0, dot), extension: text.substring(dot + 1) } : { member: text };
+    }
+    return {};
+}
+/** Build the variables for a member or streamfile target, as Code for IBM i does. */
+export async function buildActionTarget(conn, args, remoteWorkspace) {
+    const config = conn.getConfig();
+    const curlib = String(config.currentLibrary || "QGPL").toUpperCase();
+    const targetType = String(args?.targetType || "");
+    if (targetType === "member") {
+        const parsed = parseMemberTargetPath(args.targetPath);
+        const lib = requireQsysName(conn, args.library || parsed.library, "library");
+        const src = requireQsysName(conn, args.sourceFile || parsed.sourceFile, "sourceFile");
+        const mbr = requireQsysName(conn, args.member || parsed.member, "member");
+        let ext = String(args.extension || parsed.extension || "").trim();
+        if (!ext && conn.content?.getMemberInfo) {
+            try {
+                ext = String((await conn.content.getMemberInfo(lib, src, mbr))?.extension || "");
+            }
+            catch {
+                ext = "";
+            }
+        }
+        if (ext && !/^[A-Za-z0-9#@$_]{1,10}$/.test(ext))
+            throw new Error(`Invalid extension: ${ext}`);
+        const env = {
+            "&OPENLIB": lib,
+            "&OPENLIBL": lib.toLowerCase(),
+            "&OPENSPF": src,
+            "&OPENSPFL": src.toLowerCase(),
+            "&OPENMBR": mbr,
+            "&OPENMBRL": mbr.toLowerCase(),
+            "&EXT": ext.toUpperCase(),
+            "&EXTL": ext.toLowerCase(),
+            "&NAME": mbr,
+            "&NAMEL": mbr.toLowerCase(),
+            "&BASENAME": ext ? `${mbr}.${ext.toUpperCase()}` : mbr,
+            "&LIBRARY": lib,
+            "&SRCLIB": lib,
+            "&SRCPF": src,
+            "&SRCFILE": `${lib}/${src}`,
+            "&FULLPATH": `/QSYS.LIB/${lib}.LIB/${src}.FILE/${mbr}.MBR`
+        };
+        return {
+            targetType: "member",
+            displayPath: `${lib}/${src}/${mbr}${ext ? `.${ext.toUpperCase()}` : ""}`,
+            env,
+            evfLibrary: lib,
+            evfMember: mbr,
+            library: lib,
+            sourceFile: src,
+            member: mbr
+        };
+    }
+    if (targetType === "streamfile") {
+        const target = CompileTools.validateStreamfilePath(args.targetPath);
+        const cwd = args.cwd
+            ? CompileTools.validateStreamfilePath(args.cwd).replace(/(.)\/+$/, "$1")
+            : remoteWorkspace || String(config.homeDirectory || "").replace(/(.)\/+$/, "$1") || undefined;
+        const base = path.posix.basename(target);
+        const dot = base.lastIndexOf(".");
+        const name = dot > 0 ? base.substring(0, dot) : base;
+        const ext = dot > 0 ? base.substring(dot + 1) : "";
+        const dir = path.posix.dirname(target);
+        const relative = cwd && (target === cwd || target.startsWith(`${cwd === "/" ? "" : cwd}/`))
+            ? path.posix.relative(cwd, target)
+            : target;
+        const env = {
+            "&FULLPATH": target,
+            "&FILEDIR": dir,
+            "&PARENT": path.posix.basename(dir),
+            "&RELATIVEPATH": relative || target,
+            "&BASENAME": base,
+            "{filename}": base,
+            "&NAME": name,
+            "&NAMEL": name.toLowerCase(),
+            "&EXT": ext,
+            "&EXTL": ext.toLowerCase(),
+            "&SRCLIB": curlib,
+            "&SRCPF": "QTMPSRC",
+            "&SRCFILE": `${curlib}/QTMPSRC`
+        };
+        return {
+            targetType: "streamfile",
+            displayPath: target,
+            env,
+            cwd,
+            evfLibrary: curlib,
+            evfMember: name.toUpperCase()
+        };
+    }
+    if (targetType === "file") {
+        throw new Error("Local file actions are not supported in this MCP server (use streamfile or member).");
+    }
+    throw new Error("targetType must be member or streamfile");
+}
+/** Refuse a command that still holds a target variable this target did not set. */
+export function assertNoUnresolvedVariables(command, targetType) {
+    const left = new Set();
+    for (const match of command.matchAll(/&([A-Za-z]+)(?![A-Za-z0-9_#@$])/g)) {
+        const name = match[1].toUpperCase();
+        if (TARGET_VARIABLES.includes(name))
+            left.add(`&${name}`);
+    }
+    if (left.size > 0) {
+        throw new Error(`Action uses ${Array.from(left).join(", ")}, which is not set for ${targetType} targets`);
+    }
+}
+/** Find the object a compile command creates, for the EVFEVENT lookup. */
+export function findCompiledObject(command, currentLibrary) {
+    const firstLine = String(command || "").split(/\r?\n/).find(line => /\*EVENTF/i.test(line)) || String(command || "");
+    // The first object parameter in the command is the object it creates
+    // (CRTCMD CMD(...) PGM(...) creates the command, not the program).
+    const match = firstLine.match(new RegExp(`\\b(?:${OBJECT_PARAMETERS.join("|")})\\(\\s*(?:([^\\s/()]+)\\/)?([^\\s/()]+)\\s*\\)`, "i"));
+    if (match) {
+        let library = (match[1] || "*LIBL").toUpperCase();
+        if (library === "*CURLIB" || library === "*LIBL")
+            library = currentLibrary.toUpperCase();
+        return { library, object: match[2].toUpperCase() };
+    }
+    return undefined;
+}
+/** Read LIB/EVFEVENT(member) through a QTEMP alias and parse it. */
+export async function readEvfeventMember(conn, library, member) {
+    const lib = requireQsysName(conn, library, "EVFEVENT library");
+    const mbr = requireQsysName(conn, member, "EVFEVENT member");
+    try {
+        const rows = await conn.runSQL(`create or replace alias QTEMP.MCP_EVFEVENT for "${lib}"."EVFEVENT"("${mbr}");\n` +
+            // EVFEVENT is CCSID 65535, so the bytes come back raw unless cast to EBCDIC text.
+            `select rtrim(cast(E.EVFEVENT as varchar(400) ccsid 37)) as EVFEVENT from QTEMP.MCP_EVFEVENT as E order by rrn(E)`);
+        const lines = (rows || []).map(row => {
+            const value = row.EVFEVENT ?? Object.values(row)[0];
+            return String(value ?? "");
+        });
+        return { library: lib, member: mbr, found: true, records: lines.length, result: parseEvfevent(lines) };
+    }
+    catch (err) {
+        return { library: lib, member: mbr, found: false, error: err?.message || String(err) };
+    }
+}
+const TIMESTAMP_PATTERN = /^\d{4}-\d{2}-\d{2}[- T]\d{2}[.:]\d{2}[.:]\d{2}(?:\.\d{1,12})?$/;
+/**
+ * Fetch the most recent compile listing: a spooled file named after the
+ * object, else QSYSPRT, else QPJOBLOG, owned by the user and created at or
+ * after `since`.
+ */
+export async function fetchCompileListing(conn, options) {
+    const object = requireQsysName(conn, options.objectName, "objectName");
+    const user = requireQsysName(conn, options.userName || conn.currentUser, "userName");
+    const since = options.since ? String(options.since).trim() : "";
+    if (since && !TIMESTAMP_PATTERN.test(since))
+        throw new Error(`Invalid since timestamp: ${options.since}`);
+    const maxLines = clampNumber(options.maxLines, 2000, 1, 20000);
+    const names = Array.from(new Set([object, "QSYSPRT", "QPJOBLOG"]));
+    const where = [
+        `user_name = ${Tools.sqlString(user)}`,
+        `spooled_file_name in (${names.map(n => Tools.sqlString(n)).join(", ")})`,
+        ...(since ? [`create_timestamp >= timestamp(${Tools.sqlString(since)})`] : [])
+    ].join(" and ");
+    const order = `order by case spooled_file_name ${names.map((n, i) => `when ${Tools.sqlString(n)} then ${i}`).join(" ")} else 9 end, create_timestamp desc fetch first 1 rows only`;
+    let entry;
+    let lastError;
+    for (const view of ["qsys2.output_queue_entries_basic", "qsys2.output_queue_entries"]) {
+        try {
+            const rows = await conn.runSQL(`select * from ${view} where ${where} ${order}`);
+            entry = rows?.[0] ? normalizeSpoolEntry(rows[0]) : undefined;
+            lastError = undefined;
+            break;
+        }
+        catch (err) {
+            lastError = err;
+        }
+    }
+    if (lastError)
+        return { found: false, error: lastError?.message || String(lastError) };
+    if (!entry || !entry.jobName || !entry.spooledFileName)
+        return { found: false };
+    const number = entry.spooledFileNumber ?? 1;
+    const rows = await conn.runSQL(`select ordinal_position, spooled_data from table(qsys2.display_spooled_file_data(` +
+        `${Tools.sqlString(entry.jobName)}, ${Tools.sqlString(entry.spooledFileName)}, ${Number(number)})) ` +
+        `order by ordinal_position fetch first ${maxLines + 1} rows only`);
+    const lines = (rows || []).map((row) => normalizeSpoolLine(row).text);
+    return {
+        found: true,
+        jobName: entry.jobName,
+        spooledFileName: entry.spooledFileName,
+        spooledFileNumber: entry.spooledFileNumber,
+        createdAt: entry.createdAt,
+        lines: lines.slice(0, maxLines),
+        truncated: lines.length > maxLines
+    };
+}
+async function remoteTimestamp(conn) {
+    try {
+        const rows = await conn.runSQL(`select varchar(current timestamp) as TS from sysibm.sysdummy1`);
+        const value = String(rows?.[0]?.TS ?? "").trim();
+        return TIMESTAMP_PATTERN.test(value) ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function mergeEvfResults(results) {
+    if (results.length === 0)
+        return undefined;
+    if (results.length === 1)
+        return results[0];
+    const diagnostics = results.flatMap(r => r.diagnostics);
+    const files = new Map();
+    for (const group of results.flatMap(r => r.files)) {
+        const existing = files.get(group.file);
+        if (!existing) {
+            files.set(group.file, { ...group, errors: [...group.errors], counts: { ...group.counts } });
+            continue;
+        }
+        existing.errors.push(...group.errors);
+        existing.counts.errors += group.counts.errors;
+        existing.counts.warnings += group.counts.warnings;
+        existing.counts.infos += group.counts.infos;
+    }
+    return {
+        timestamp: results.find(r => r.timestamp)?.timestamp,
+        processors: results.reduce((sum, r) => sum + r.processors, 0),
+        files: Array.from(files.values()),
+        diagnostics,
+        summary: {
+            total: diagnostics.length,
+            errors: diagnostics.filter(d => d.severity === "ERROR").length,
+            warnings: diagnostics.filter(d => d.severity === "WARN").length,
+            infos: diagnostics.filter(d => d.severity === "INFO").length,
+            highestSeverity: diagnostics.reduce((max, d) => Math.max(max, d.severityLevel), 0)
+        },
+        unparsedLines: results.reduce((sum, r) => sum + r.unparsedLines, 0)
+    };
+}
+async function listLocalFilesRecursive(root) {
+    const stat = await fs.stat(root).catch(() => undefined);
+    if (!stat)
+        return [];
+    if (stat.isFile())
+        return [root];
+    const out = [];
+    for (const entry of await fs.readdir(root, { withFileTypes: true })) {
+        const full = path.join(root, entry.name);
+        if (entry.isDirectory())
+            out.push(...await listLocalFilesRecursive(full));
+        else if (entry.isFile())
+            out.push(full);
+    }
+    return out;
+}
+async function postDownload(ctx, conn, entries, remoteBase, localBase) {
+    const outcomes = [];
+    for (const rawEntry of entries) {
+        const entry = String(rawEntry || "").trim();
+        if (!entry)
+            continue;
+        let remotePath = "";
+        try {
+            const relative = !entry.startsWith("/");
+            if (relative && !remoteBase)
+                throw new Error("a relative postDownload path needs cwd or remoteWorkspace");
+            remotePath = relative ? path.posix.join(remoteBase, entry) : entry;
+            remotePath = CompileTools.validateStreamfilePath(remotePath.replace(/(.)\/+$/, "$1"));
+            const localRelative = relative ? entry.replace(/\/+$/, "") : path.posix.basename(remotePath);
+            if (localRelative.split("/").some(part => part === ".."))
+                throw new Error("postDownload path must not contain '..'");
+            const localPath = await guardLocalPath(ctx, path.join(localBase, ...localRelative.split("/")), "write");
+            const isDirectory = (await conn.sendCommand({ command: `test -d ${Tools.escapePath(remotePath)}` }))?.code === 0;
+            if (isDirectory) {
+                await fs.mkdir(localPath, { recursive: true });
+                await conn.client.getDirectory(localPath, remotePath, { recursive: true, concurrency: 5 });
+            }
+            else {
+                await fs.mkdir(path.dirname(localPath), { recursive: true });
+                await conn.client.getFile(localPath, remotePath);
+            }
+            outcomes.push({ remotePath, localPath, kind: isDirectory ? "directory" : "file", ok: true });
+        }
+        catch (err) {
+            outcomes.push({ remotePath: remotePath || entry, ok: false, error: err?.message || String(err) });
+        }
+    }
+    return outcomes;
+}
+function formatCommandOutput(command, result) {
+    return [
+        `Command: ${command}`,
+        `Exit code: ${result?.code}`,
+        "",
+        "STDOUT:",
+        String(result?.stdout || ""),
+        "",
+        "STDERR:",
+        String(result?.stderr || ""),
+        ""
+    ].join("\n");
+}
+/** ibmi.actions.run: run an action against a member or streamfile and collect its errors. */
+export async function runActionTool(ctx, args) {
+    const conn = await ctx.ensureActive(args?.connectionName);
+    await enforceWritable(ctx, conn, "qsys.write", args);
+    const action = await resolveAction(ctx, args);
+    if (!action)
+        throw new Error("Action not found");
+    const targetType = String(args?.targetType || "");
+    if (action.type && action.type !== targetType && targetType !== "file") {
+        throw new Error(`Action "${action.name}" runs against ${action.type} targets, not ${targetType} targets`);
+    }
+    const remoteWorkspace = args?.remoteWorkspace
+        ? CompileTools.validateStreamfilePath(args.remoteWorkspace).replace(/(.)\/+$/, "$1")
+        : undefined;
+    const target = await buildActionTarget(conn, args, remoteWorkspace);
+    const config = conn.getConfig();
+    const curlib = String(config.currentLibrary || "QGPL").toUpperCase();
+    // deployFirst: push the local workspace before running (streamfile targets).
+    let deploy;
+    if (action.deployFirst && target.targetType === "streamfile") {
+        if (args?.localWorkspace) {
+            if (!remoteWorkspace)
+                throw new Error("remoteWorkspace is required with localWorkspace");
+            const deployResult = await handleTool(ctx, "ibmi.deploy.sync", {
+                connectionName: args.connectionName,
+                approve: args.approve,
+                localPath: args.localWorkspace,
+                remotePath: remoteWorkspace,
+                overwrite: true
+            });
+            deploy = deployResult?.structuredContent?.data;
+            if (deployResult?.isError) {
+                return jsonError(`Deploy before "${action.name}" failed; the action was not run`, { action: action.name, deploy });
+            }
+        }
+        else {
+            deploy = { skipped: true, reason: "deployFirst is set but no localWorkspace was given" };
+        }
+    }
+    const listingSince = args?.includeListing ? await remoteTimestamp(conn) : undefined;
+    const guard = actionCommandGuard(ctx, action.environment, args);
+    const commandResult = await CompileTools.runCommand(conn, {
+        command: action.command,
+        environment: action.environment,
+        env: target.env,
+        cwd: target.cwd
+    }, {
+        commandConfirm: async (expanded) => {
+            assertNoUnresolvedVariables(expanded, target.targetType);
+            return guard(expanded);
+        }
+    });
+    const expandedCommand = String(commandResult.command || action.command);
+    const payload = mapActionExecution(action, target.targetType, target.displayPath, commandResult);
+    if (target.cwd)
+        payload.cwd = target.cwd;
+    if (deploy !== undefined)
+        payload.deploy = deploy;
+    // EVFEVENT from the object's library, as written by OPTION(*EVENTF).
+    const evfResults = [];
+    const environment = action.environment || "ile";
+    if (environment === "ile" && /\*EVENTF\b/i.test(expandedCommand)) {
+        const object = findCompiledObject(expandedCommand, curlib);
+        const library = String(args?.evfeventLibrary || object?.library || target.evfLibrary).toUpperCase();
+        const member = String(args?.evfeventMember || object?.object || target.evfMember).toUpperCase();
+        if (conn.validQsysName(library) && conn.validQsysName(member)) {
+            const read = await readEvfeventMember(conn, library, member);
+            payload.evfevent = { library: read.library, member: read.member, found: read.found, records: read.records, error: read.error };
+            if (read.result)
+                evfResults.push(read.result);
+        }
+        else {
+            payload.evfevent = { library, member, found: false, error: "EVFEVENT library or member is not a valid object name" };
+        }
+    }
+    // postDownload: copy build outputs back to the local workspace.
+    const downloads = (action.postDownload || []).filter(Boolean);
+    if (downloads.length > 0) {
+        const localBase = args?.downloadTo || args?.localWorkspace;
+        if (!localBase) {
+            payload.postDownload = { skipped: true, reason: "postDownload is set but neither downloadTo nor localWorkspace was given" };
+        }
+        else {
+            const base = await guardLocalPath(ctx, localBase, "write");
+            const outcomes = await postDownload(ctx, conn, downloads, target.cwd || remoteWorkspace, base);
+            payload.postDownload = outcomes;
+            for (const outcome of outcomes) {
+                if (!outcome.ok || !outcome.localPath || !/\.evfevent/i.test(outcome.remotePath))
+                    continue;
+                for (const file of await listLocalFilesRecursive(outcome.localPath)) {
+                    try {
+                        evfResults.push(parseEvfevent(await fs.readFile(file, "utf8")));
+                    }
+                    catch {
+                        // Not readable as text: skip it.
+                    }
+                }
+            }
+        }
+    }
+    const evf = mergeEvfResults(evfResults);
+    if (evf) {
+        payload.errors = evf.files;
+        payload.errorSummary = evf.summary;
+        if (payload.ok && evf.summary.errors > 0)
+            payload.status = "warning";
+    }
+    if (args?.includeListing) {
+        const object = findCompiledObject(expandedCommand, curlib);
+        const objectName = object?.object || target.evfMember;
+        try {
+            payload.listing = conn.validQsysName(objectName)
+                ? await fetchCompileListing(conn, { objectName, since: listingSince, maxLines: args?.listingMaxLines })
+                : { found: false, error: `No valid object name for the listing: ${objectName}` };
+        }
+        catch (err) {
+            payload.listing = { found: false, error: err?.message || String(err) };
+        }
+    }
+    // outputToFile: save the command output locally.
+    if (action.outputToFile) {
+        try {
+            let outputPath = new Variables(undefined, target.env).expand(action.outputToFile);
+            if (/^&LOCAL\b/i.test(outputPath) || !path.isAbsolute(outputPath)) {
+                if (!args?.localWorkspace)
+                    throw new Error("a relative outputToFile path needs localWorkspace");
+                outputPath = path.join(args.localWorkspace, outputPath.replace(/^&LOCAL[\\/]?/i, ""));
+            }
+            const resolved = await guardLocalPath(ctx, outputPath, "write");
+            await fs.mkdir(path.dirname(resolved), { recursive: true });
+            await fs.writeFile(resolved, formatCommandOutput(expandedCommand, commandResult), "utf8");
+            payload.outputFile = resolved;
+        }
+        catch (err) {
+            payload.outputFile = { ok: false, error: err?.message || String(err) };
+        }
+    }
+    if (!payload.ok) {
+        const errorCount = evf?.summary.errors || 0;
+        const firstError = evf?.diagnostics.find(d => d.severity === "ERROR");
+        const detail = firstError
+            ? `${errorCount} error(s); first: ${firstError.msgid} line ${firstError.line}: ${firstError.text}`
+            : (Array.isArray(payload.diagnostics) ? payload.diagnostics.find((d) => d.severity === "ERROR")?.message : undefined)
+                || String(commandResult.stderr || commandResult.stdout || "").trim().split(/\r?\n/)[0] || `exit ${commandResult.code}`;
+        return jsonError(`Action "${action.name}" failed (${detail})`, payload);
+    }
+    return json(payload);
+}
+export const compileModule = {
+    tools: [
+        {
+            name: "ibmi.compile.listing",
+            description: "Read the most recent compile listing for an object: the newest spooled file named after the object " +
+                "(falling back to QSYSPRT, then QPJOBLOG) owned by the user, optionally created at or after a timestamp.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    connectionName: { type: "string", description: "Saved IBM i connection name." },
+                    objectName: { type: "string", description: "Object (program, module, file) the compile created." },
+                    userName: { type: "string", description: "Spooled file owner. Defaults to the connection user." },
+                    since: { type: "string", description: "Only listings created at or after this IBM i timestamp (YYYY-MM-DD-HH.MM.SS[.ffffff])." },
+                    maxLines: { type: "number", description: "Maximum listing lines to return (default 2000)." }
+                },
+                required: ["objectName"],
+                additionalProperties: false
+            },
+            annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+        }
+    ],
+    async handle(ctx, name, args) {
+        if (name !== "ibmi.compile.listing")
+            throw new Error(`Unknown tool: ${name}`);
+        const conn = await ctx.ensureActive(args?.connectionName);
+        const listing = await fetchCompileListing(conn, {
+            objectName: args?.objectName,
+            userName: args?.userName,
+            since: args?.since,
+            maxLines: args?.maxLines
+        });
+        if (listing.error)
+            return jsonError(`Could not read the compile listing: ${listing.error}`, listing);
+        return json(listing);
+    }
+};

package/dist/mcp/modules/ifsOps.js

@@ -0,0 +1,123 @@
+import { Tools } from "../../ibmi/Tools.js";
+import { assertSafeIfsTargetPath, checkResourcePolicy, normalizeIfsPath } from "../policy.js";
+import { commandOutcome, enforceWritable, resolveIfsWriteOperation, toolError } from "../tools.js";
+/**
+ * IFS copy and move. Paths are checked like ibmi.ifs.delete (no root,
+ * top-level or system directories, no '..' or wildcards), against the path
+ * policy, and are single-quoted for the shell. An existing destination is
+ * only overwritten when overwrite=true.
+ */
+const CONNECTION_NAME = { type: "string", description: "Saved IBM i connection name." };
+const APPROVE = { type: "boolean", description: "Set true to approve guarded-policy operations." };
+const ANNOTATIONS = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
+const tools = [
+    {
+        name: "ibmi.ifs.copy",
+        description: "Copy an IFS file with cp, or a directory tree with recursive=true (cp -R). " +
+            "Refuses an existing destination unless overwrite=true (an existing directory then receives the copy inside it).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                sourcePath: { type: "string", description: "Absolute IFS path to copy." },
+                destinationPath: { type: "string", description: "Absolute IFS path to create." },
+                recursive: { type: "boolean", description: "Copy a directory and everything under it." },
+                overwrite: { type: "boolean", description: "Allow an existing destination. Default false." },
+                connectionName: CONNECTION_NAME,
+                approve: APPROVE
+            },
+            required: ["sourcePath", "destinationPath"],
+            additionalProperties: false
+        },
+        annotations: ANNOTATIONS
+    },
+    {
+        name: "ibmi.ifs.move",
+        description: "Move or rename an IFS file or directory with mv. " +
+            "Refuses an existing destination unless overwrite=true (an existing directory then receives the entry inside it).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                sourcePath: { type: "string", description: "Absolute IFS path to move." },
+                destinationPath: { type: "string", description: "Absolute IFS path to move it to." },
+                overwrite: { type: "boolean", description: "Allow an existing destination. Default false." },
+                connectionName: CONNECTION_NAME,
+                approve: APPROVE
+            },
+            required: ["sourcePath", "destinationPath"],
+            additionalProperties: false
+        },
+        annotations: ANNOTATIONS
+    }
+];
+/** Basic checks for a path that is only read (a non-recursive copy source). */
+function requireReadablePath(value, operation) {
+    const raw = String(value ?? "").trim();
+    if (!raw)
+        throw new Error(`${operation} refused: sourcePath is empty`);
+    if (/[\0\r\n]/.test(raw))
+        throw new Error(`${operation} refused: path contains control characters`);
+    if (!raw.startsWith("/"))
+        throw new Error(`${operation} refused: path must be absolute`);
+    if (raw.split(/[\\/]/).some(segment => segment === ".."))
+        throw new Error(`${operation} refused: path must not contain '..'`);
+    if (/[*?[\]]/.test(raw))
+        throw new Error(`${operation} refused: wildcards are not allowed`);
+    const normalized = normalizeIfsPath(raw);
+    if (normalized === "/")
+        throw new Error(`${operation} refused: cannot copy the root directory`);
+    return normalized;
+}
+function enforcePathPolicy(ctx, toolName, args, paths) {
+    const policy = ctx.getPolicy(args?.connectionName);
+    for (const ifsPath of paths) {
+        const reason = checkResourcePolicy(policy, toolName, { path: ifsPath });
+        if (reason)
+            throw new Error(`Blocked by policy: ${toolName} (${reason})`);
+    }
+}
+function refuseSameOrNested(source, destination, operation) {
+    const src = source.toLowerCase();
+    const dest = destination.toLowerCase();
+    if (src === dest)
+        throw new Error(`${operation} refused: sourcePath and destinationPath are the same`);
+    if (dest.startsWith(`${src}/`))
+        throw new Error(`${operation} refused: destinationPath is inside sourcePath`);
+}
+async function pathExists(conn, ifsPath) {
+    const res = await conn.sendCommand({ command: `test -e ${Tools.shellQuote(ifsPath)}` });
+    return res?.code === 0;
+}
+async function handle(ctx, name, args) {
+    args = args || {};
+    const conn = await ctx.ensureActive(args.connectionName);
+    const operation = name.replace(/^ibmi\./, "");
+    const destination = assertSafeIfsTargetPath(args.destinationPath, operation, "write to");
+    const source = name === "ibmi.ifs.move" || args.recursive
+        ? assertSafeIfsTargetPath(args.sourcePath, operation, name === "ibmi.ifs.move" ? "move" : "recursively copy")
+        : requireReadablePath(args.sourcePath, operation);
+    refuseSameOrNested(source, destination, operation);
+    await enforceWritable(ctx, conn, resolveIfsWriteOperation(destination), args);
+    if (name === "ibmi.ifs.move")
+        await enforceWritable(ctx, conn, "ifs.delete", args);
+    enforcePathPolicy(ctx, name, args, [source, destination]);
+    if (args.overwrite !== true && await pathExists(conn, destination)) {
+        return toolError(`${destination} already exists. Pass overwrite=true to replace it or copy into it.`, {
+            sourcePath: source,
+            destinationPath: destination
+        });
+    }
+    let command;
+    switch (name) {
+        case "ibmi.ifs.copy":
+            command = `cp ${args.recursive ? "-R " : ""}${Tools.shellQuote(source)} ${Tools.shellQuote(destination)}`;
+            break;
+        case "ibmi.ifs.move":
+            command = `mv ${Tools.shellQuote(source)} ${Tools.shellQuote(destination)}`;
+            break;
+        default:
+            throw new Error(`Unknown tool: ${name}`);
+    }
+    const res = await conn.sendCommand({ command });
+    return commandOutcome({ ...res, ok: res?.code === 0, command, sourcePath: source, destinationPath: destination });
+}
+export const ifsOpsModule = { tools, handle };

package/dist/mcp/modules/index.js

@@ -0,0 +1,38 @@
+import { objectsModule } from "./objects.js";
+import { membersModule } from "./members.js";
+import { ifsOpsModule } from "./ifsOps.js";
+import { bulkMembersModule } from "./bulkMembers.js";
+import { compareModule } from "./compare.js";
+import { inspectModule } from "./inspect.js";
+import { compileModule } from "./compile.js";
+import { changedLinesModule } from "./changedLines.js";
+import { liblModule } from "./libl.js";
+import { systemModule } from "./system.js";
+import { tn5250Module } from "./tn5250.js";
+// Feature modules register here, one import and one array entry each.
+export const toolModules = [objectsModule, membersModule, ifsOpsModule, bulkMembersModule, compareModule, inspectModule, compileModule, systemModule, changedLinesModule, liblModule, tn5250Module];
+export function findToolModule(name) {
+    return toolModules.find(module => module.tools.some(tool => tool.name === name));
+}
+/** Arguments with module-specific secrets removed, ready for generic redaction. */
+export function redactModuleArgs(ctx, name, args) {
+    const module = findToolModule(name);
+    if (!module?.redactArgs)
+        return args;
+    try {
+        return module.redactArgs(ctx, name, args);
+    }
+    catch {
+        return args;
+    }
+}
+export function notifyModulesOfDisconnect(connectionName) {
+    for (const module of toolModules) {
+        try {
+            module.onDisconnect?.(connectionName);
+        }
+        catch {
+            // a module's cleanup must not break disconnecting
+        }
+    }
+}