@martinloop/mcp 0.2.0 → 0.2.7

package/dist/server-validation.js

@@ -1,19 +1,32 @@
-import { extname, isAbsolute, relative, resolve } from "node:path";
+import { existsSync, lstatSync, realpathSync } from "node:fs";
+import { dirname, extname, isAbsolute, relative, resolve } from "node:path";
 import { resolveRunsRoot } from "./vendor/core/index.js";
+import { invalidArgumentsError, invalidPathError, invalidSelectorError } from "./tools/tool-errors.js";
+export { sanitizeToolErrorMessage } from "./tools/tool-errors.js";
 export function validateToolInput(name, args) {
     switch (name) {
-        case "martin_doctor":
-            return validateDoctorInput(args);
-        case "martin_preflight":
-            return validatePreflightInput(args);
         case "martin_run":
             return validateRunInput(args);
         case "martin_inspect":
             return validateInspectInput(args);
         case "martin_status":
             return validateStatusInput(args);
+        case "martin_doctor":
+            return validateDoctorInput(args);
+        case "martin_plan":
+            return validatePlanInput(args);
+        case "martin_preflight":
+            return validatePreflightInput(args);
+        case "martin_logs":
+            return validateLogsInput(args);
+        case "martin_cancel":
+        case "martin_pause":
+        case "martin_continue":
+            return validateRunControlInput(args);
         case "martin_list_runs":
             return validateListRunsInput(args);
+        case "martin_triage_runs":
+            return validateTriageRunsInput(args);
         case "martin_get_run":
             return validateGetRunInput(args);
         case "martin_get_attempt":
@@ -21,97 +34,79 @@ export function validateToolInput(name, args) {
         case "martin_get_verification_results":
             return validateGetVerificationResultsInput(args);
         case "martin_run_dossier":
+        case "martin_dossier":
+            return validateRunDossierInput(args);
+        case "martin_eval":
+            return validateEvalInput(args);
+        case "martin_pr_summary":
             return validateRunDossierInput(args);
+        case "martin_create_pr":
+            return validateCreatePrInput(args);
+        case "martin_review_pr":
+            return validateReviewPrInput(args);
         default:
-            throw new Error(`Unknown tool: ${name}`);
+            throw invalidArgumentsError(`Unknown tool: ${name}`, "Refresh the Martin tool manifest and retry.");
     }
 }
-export function sanitizeToolErrorMessage(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return /([A-Za-z]:\\|\/|policy\.rego|policy\.wasm|\.pem|\.env)/u.test(message)
-        ? "Tool execution failed."
-        : message;
-}
-function validateDoctorInput(args) {
-    const record = requireObject(args);
-    assertAllowedKeys(record, ["workingDirectory", "runsDir", "engine"]);
-    const engine = optionalEnum(record.engine, "engine", ["claude", "codex"]);
-    return {
-        ...(record.workingDirectory !== undefined
-            ? { workingDirectory: resolveSafeRepoRoot(requireString(record.workingDirectory, "workingDirectory")) }
-            : {}),
-        ...(record.runsDir !== undefined
-            ? { runsDir: resolveSafeRunsRootPath(requireString(record.runsDir, "runsDir")) }
-            : {}),
-        ...(engine ? { engine } : {})
-    };
-}
-function validatePreflightInput(args) {
-    const record = requireObject(args);
-    assertAllowedKeys(record, [
-        "objective",
-        "workingDirectory",
-        "engine",
-        "model",
-        "maxUsd",
-        "maxIterations",
-        "maxTokens",
-        "verificationPlan",
-        "allowedPaths",
-        "deniedPaths",
-        "workspaceId",
-        "projectId"
-    ]);
-    const engine = optionalEnum(record.engine, "engine", ["claude", "codex"]);
-    return {
-        objective: requireString(record.objective, "objective"),
-        ...(record.workingDirectory !== undefined
-            ? { workingDirectory: resolveSafeRepoRoot(requireString(record.workingDirectory, "workingDirectory")) }
-            : {}),
-        ...(engine ? { engine } : {}),
-        ...optionalString(record.model, "model"),
-        ...optionalPositiveNumber(record.maxUsd, "maxUsd"),
-        ...optionalPositiveInteger(record.maxIterations, "maxIterations"),
-        ...optionalPositiveInteger(record.maxTokens, "maxTokens"),
-        ...optionalStringArrayAsObject(record.verificationPlan, "verificationPlan"),
-        ...optionalPathPatternArrayAsObject(record.allowedPaths, "allowedPaths"),
-        ...optionalPathPatternArrayAsObject(record.deniedPaths, "deniedPaths"),
-        ...optionalString(record.workspaceId, "workspaceId"),
-        ...optionalString(record.projectId, "projectId")
-    };
-}
 export function resolveSafeRepoRoot(repoRoot, workspaceRoot = process.env.MARTIN_MCP_WORKSPACE_ROOT ?? process.cwd()) {
     const baseRoot = resolve(workspaceRoot);
     const candidate = repoRoot ? resolve(baseRoot, repoRoot) : baseRoot;
-    assertPathWithinRoot(candidate, baseRoot, "workingDirectory");
+    assertPathWithinRoot(candidate, baseRoot, "workingDirectory", {
+        requireExistingCandidate: true,
+        requireExistingRoot: true
+    });
     return candidate;
 }
 export function resolveSafeRunsJsonPath(file, runsRoot = resolveRunsRoot(process.env)) {
     const baseRoot = resolve(runsRoot);
     const candidate = resolve(baseRoot, file);
-    assertPathWithinRoot(candidate, baseRoot, "file");
+    assertPathWithinRoot(candidate, baseRoot, "file", {
+        requireExistingCandidate: true,
+        requireExistingRoot: true
+    });
     const extension = extname(candidate).toLowerCase();
     if (extension !== ".json" && extension !== ".jsonl") {
-        throw new Error("Invalid file.");
+        throw invalidPathError("Invalid file.", "Point file at a loop-record.json, a legacy .jsonl file, or a run directory under the runs root.");
     }
     return candidate;
 }
 export function resolveSafeRunsPath(file, runsRoot = resolveRunsRoot(process.env)) {
     const baseRoot = resolve(runsRoot);
     const candidate = resolve(baseRoot, file);
-    assertPathWithinRoot(candidate, baseRoot, "file");
+    assertPathWithinRoot(candidate, baseRoot, "file", {
+        requireExistingCandidate: true,
+        requireExistingRoot: true
+    });
     const extension = extname(candidate).toLowerCase();
     if (extension && extension !== ".json" && extension !== ".jsonl") {
-        throw new Error("Invalid file.");
+        throw invalidPathError("Invalid file.", "Point file at a loop-record.json, a legacy .jsonl file, or a run directory under the runs root.");
     }
     return candidate;
 }
 export function resolveSafeRunsRootPath(runsRoot, fallbackRunsRoot = resolveRunsRoot(process.env)) {
     const baseRoot = resolve(fallbackRunsRoot);
     const candidate = runsRoot ? resolve(baseRoot, runsRoot) : baseRoot;
-    assertPathWithinRoot(candidate, baseRoot, "runsDir");
+    if (runsRoot && !existsSync(candidate)) {
+        if (!isAbsolute(runsRoot)) {
+            assertRawPathWithinRoot(candidate, baseRoot, "runsDir");
+        }
+        return candidate;
+    }
+    assertPathWithinRoot(candidate, baseRoot, "runsDir", {
+        requireExistingCandidate: false,
+        requireExistingRoot: false
+    });
     return candidate;
 }
+function assertRawPathWithinRoot(candidatePath, rootPath, name) {
+    const relativePath = relative(resolve(rootPath), resolve(candidatePath));
+    if (relativePath === "" || relativePath === ".") {
+        return;
+    }
+    if (relativePath.startsWith("..") || isAbsolute(relativePath)) {
+        throw invalidPathError(`Invalid ${name}.`);
+    }
+}
 export function resolveSafeLoopRecordPath(loopId, runsRoot = resolveRunsRoot(process.env)) {
     const normalizedLoopId = requireLoopId(loopId, "loopId");
     return resolveSafeRunsJsonPath(`${normalizedLoopId}/loop-record.json`, runsRoot);
@@ -127,7 +122,7 @@ export function normalizeSafePathPatterns(value, name) {
             normalized.startsWith("/") ||
             /^[A-Za-z]:\//u.test(normalized) ||
             normalized.split("/").includes("..")) {
-            throw new Error(`Invalid ${name}.`);
+            throw invalidPathError(`Invalid ${name}.`);
         }
         return normalized;
     });
@@ -139,9 +134,14 @@ function validateRunInput(args) {
         "workingDirectory",
         "engine",
         "model",
+        "context",
+        "policyPack",
         "maxUsd",
         "maxIterations",
         "maxTokens",
+        "maxMinutes",
+        "maxFilesChanged",
+        "maxCommands",
         "verificationPlan",
         "allowedPaths",
         "deniedPaths",
@@ -156,9 +156,20 @@ function validateRunInput(args) {
             : {}),
         ...(engine ? { engine } : {}),
         ...optionalString(record.model, "model"),
+        ...optionalString(record.context, "context"),
+        ...optionalEnumAsObject(record.policyPack, "policyPack", [
+            "solo-founder",
+            "startup-team",
+            "enterprise-strict",
+            "oss-maintainer",
+            "security-sensitive"
+        ]),
         ...optionalPositiveNumber(record.maxUsd, "maxUsd"),
         ...optionalPositiveInteger(record.maxIterations, "maxIterations"),
         ...optionalPositiveInteger(record.maxTokens, "maxTokens"),
+        ...optionalPositiveInteger(record.maxMinutes, "maxMinutes"),
+        ...optionalPositiveInteger(record.maxFilesChanged, "maxFilesChanged"),
+        ...optionalPositiveInteger(record.maxCommands, "maxCommands"),
         ...optionalStringArrayAsObject(record.verificationPlan, "verificationPlan"),
         ...optionalPathPatternArrayAsObject(record.allowedPaths, "allowedPaths"),
         ...optionalPathPatternArrayAsObject(record.deniedPaths, "deniedPaths"),
@@ -169,18 +180,24 @@ function validateRunInput(args) {
 function validateInspectInput(args) {
     const record = requireObject(args);
     assertAllowedKeys(record, ["file", "runsDir"]);
+    const resolvedRunsDir = record.runsDir !== undefined
+        ? resolveSafeRunsRootPath(requireString(record.runsDir, "runsDir"))
+        : undefined;
     return {
         ...(record.file !== undefined
-            ? { file: resolveSafeRunsPath(requireString(record.file, "file")) }
+            ? {
+                file: resolveSafeRunsPath(requireString(record.file, "file"), resolvedRunsDir ?? resolveRunsRoot(process.env))
+            }
             : {}),
-        ...(record.runsDir !== undefined
-            ? { runsDir: resolveSafeRunsRootPath(requireString(record.runsDir, "runsDir")) }
-            : {})
+        ...(resolvedRunsDir ? { runsDir: resolvedRunsDir } : {})
     };
 }
 function validateStatusInput(args) {
     const record = requireObject(args);
     assertAllowedKeys(record, ["loopJson", "file", "loopId", "runsDir", "latest"]);
+    const resolvedRunsDir = record.runsDir !== undefined
+        ? resolveSafeRunsRootPath(requireString(record.runsDir, "runsDir"))
+        : undefined;
     const selectors = [
         record.loopJson !== undefined ? "loopJson" : null,
         record.file !== undefined ? "file" : null,
@@ -188,113 +205,334 @@ function validateStatusInput(args) {
         record.latest !== undefined ? "latest" : null
     ].filter((value) => value !== null);
     if (selectors.length !== 1) {
-        throw new Error("Provide exactly one of loopJson, file, loopId, or latest.");
+        throw invalidSelectorError("Provide exactly one of loopJson, file, loopId, or latest.", "Choose exactly one status selector per call.");
     }
     if (record.latest !== undefined && record.latest !== true) {
-        throw new Error("Invalid latest.");
+        throw invalidArgumentsError("Invalid latest.", "latest must be the literal boolean value true.");
     }
     return {
         ...(record.loopJson !== undefined
             ? { loopJson: requireString(record.loopJson, "loopJson") }
             : {}),
         ...(record.file !== undefined
-            ? { file: resolveSafeRunsPath(requireString(record.file, "file")) }
+            ? {
+                file: resolveSafeRunsPath(requireString(record.file, "file"), resolvedRunsDir ?? resolveRunsRoot(process.env))
+            }
             : {}),
         ...(record.loopId !== undefined
-            ? { loopId: requireLoopId(record.loopId, "loopId") }
-            : {}),
-        ...(record.runsDir !== undefined
-            ? { runsDir: resolveSafeRunsRootPath(requireString(record.runsDir, "runsDir")) }
+            ? {
+                loopId: requireLoopId(record.loopId, "loopId")
+            }
             : {}),
+        ...(resolvedRunsDir ? { runsDir: resolvedRunsDir } : {}),
         ...(record.latest === true ? { latest: true } : {})
     };
 }
-function validateListRunsInput(args) {
+function validateDoctorInput(args) {
     const record = requireObject(args);
-    assertAllowedKeys(record, ["runsDir", "limit"]);
+    assertAllowedKeys(record, ["workingDirectory", "runsDir", "engine"]);
     return {
+        ...(record.workingDirectory !== undefined
+            ? { workingDirectory: resolveSafeRepoRoot(requireString(record.workingDirectory, "workingDirectory")) }
+            : {}),
         ...(record.runsDir !== undefined
             ? { runsDir: resolveSafeRunsRootPath(requireString(record.runsDir, "runsDir")) }
             : {}),
-        ...(record.limit !== undefined ? { limit: requirePositiveInteger(record.limit, "limit") } : {})
+        ...optionalEnumAsObject(record.engine, "engine", ["claude", "codex"])
     };
 }
-function validateGetRunInput(args) {
-    const record = requireObject(args);
-    assertAllowedKeys(record, ["loopId", "runsDir", "latest"]);
-    return validateRunSelector(record);
+function validatePreflightInput(args) {
+    return validateRunInput(args);
 }
-function validateGetVerificationResultsInput(args) {
-    const record = requireObject(args);
-    assertAllowedKeys(record, ["loopId", "runsDir", "latest"]);
-    return validateRunSelector(record);
+function validatePlanInput(args) {
+    return validateRunInput(args);
 }
-function validateRunDossierInput(args) {
+function validateLogsInput(args) {
     const record = requireObject(args);
-    assertAllowedKeys(record, ["loopId", "runsDir", "latest"]);
-    return validateRunSelector(record);
+    assertAllowedKeys(record, ["file", "loopId", "runsDir", "latest", "limit"]);
+    const resolvedRunsDir = record.runsDir !== undefined
+        ? resolveSafeRunsRootPath(requireString(record.runsDir, "runsDir"))
+        : undefined;
+    const selectors = [
+        record.file !== undefined ? "file" : null,
+        record.loopId !== undefined ? "loopId" : null,
+        record.latest !== undefined ? "latest" : null
+    ].filter((value) => value !== null);
+    if (selectors.length !== 1) {
+        throw invalidSelectorError("Provide exactly one of file, loopId, or latest.", "Choose exactly one run selector per call.");
+    }
+    return {
+        ...(record.file !== undefined
+            ? {
+                file: resolveSafeRunsPath(requireString(record.file, "file"), resolvedRunsDir ?? resolveRunsRoot(process.env))
+            }
+            : {}),
+        ...(record.loopId !== undefined ? { loopId: requireLoopId(record.loopId, "loopId") } : {}),
+        ...(resolvedRunsDir ? { runsDir: resolvedRunsDir } : {}),
+        ...(record.latest === true ? { latest: true } : {}),
+        ...optionalPositiveInteger(record.limit, "limit")
+    };
 }
-function validateGetAttemptInput(args) {
+function validateListRunsInput(args) {
     const record = requireObject(args);
-    assertAllowedKeys(record, ["loopId", "attemptIndex", "runsDir"]);
+    assertAllowedKeys(record, [
+        "runsDir",
+        "limit",
+        "status",
+        "lifecycleState",
+        "adapterId",
+        "model",
+        "updatedAfter"
+    ]);
     return {
-        loopId: requireLoopId(record.loopId, "loopId"),
-        attemptIndex: requirePositiveInteger(record.attemptIndex, "attemptIndex"),
         ...(record.runsDir !== undefined
             ? { runsDir: resolveSafeRunsRootPath(requireString(record.runsDir, "runsDir")) }
-            : {})
+            : {}),
+        ...optionalPositiveInteger(record.limit, "limit"),
+        ...optionalString(record.status, "status"),
+        ...optionalString(record.lifecycleState, "lifecycleState"),
+        ...optionalString(record.adapterId, "adapterId"),
+        ...optionalString(record.model, "model"),
+        ...optionalString(record.updatedAfter, "updatedAfter")
     };
 }
-function validateRunSelector(record) {
+function validateGetRunInput(args) {
+    const record = requireObject(args);
+    assertAllowedKeys(record, ["file", "loopId", "runsDir", "latest"]);
+    const resolvedRunsDir = record.runsDir !== undefined
+        ? resolveSafeRunsRootPath(requireString(record.runsDir, "runsDir"))
+        : undefined;
     const selectors = [
+        record.file !== undefined ? "file" : null,
         record.loopId !== undefined ? "loopId" : null,
         record.latest !== undefined ? "latest" : null
     ].filter((value) => value !== null);
     if (selectors.length !== 1) {
-        throw new Error("Provide exactly one of loopId or latest.");
+        throw invalidSelectorError("Provide exactly one of file, loopId, or latest.", "Choose exactly one run selector per call.");
     }
     if (record.latest !== undefined && record.latest !== true) {
-        throw new Error("Invalid latest.");
+        throw invalidArgumentsError("Invalid latest.", "latest must be the literal boolean value true.");
     }
     return {
-        ...(record.loopId !== undefined ? { loopId: requireLoopId(record.loopId, "loopId") } : {}),
-        ...(record.latest === true ? { latest: true } : {}),
+        ...(record.file !== undefined
+            ? {
+                file: resolveSafeRunsPath(requireString(record.file, "file"), resolvedRunsDir ?? resolveRunsRoot(process.env))
+            }
+            : {}),
+        ...(record.loopId !== undefined
+            ? { loopId: requireLoopId(record.loopId, "loopId") }
+            : {}),
+        ...(resolvedRunsDir ? { runsDir: resolvedRunsDir } : {}),
+        ...(record.latest === true ? { latest: true } : {})
+    };
+}
+function validateTriageRunsInput(args) {
+    const record = requireObject(args);
+    assertAllowedKeys(record, [
+        "runsDir",
+        "limit",
+        "status",
+        "lifecycleState",
+        "adapterId",
+        "model",
+        "updatedAfter",
+        "includeHealthy"
+    ]);
+    return {
         ...(record.runsDir !== undefined
             ? { runsDir: resolveSafeRunsRootPath(requireString(record.runsDir, "runsDir")) }
-            : {})
+            : {}),
+        ...optionalPositiveInteger(record.limit, "limit"),
+        ...optionalString(record.status, "status"),
+        ...optionalString(record.lifecycleState, "lifecycleState"),
+        ...optionalString(record.adapterId, "adapterId"),
+        ...optionalString(record.model, "model"),
+        ...optionalString(record.updatedAfter, "updatedAfter"),
+        ...optionalBoolean(record.includeHealthy, "includeHealthy")
+    };
+}
+function validateGetAttemptInput(args) {
+    const record = requireObject(args);
+    assertAllowedKeys(record, ["file", "loopId", "runsDir", "attemptIndex"]);
+    const resolvedRunsDir = record.runsDir !== undefined
+        ? resolveSafeRunsRootPath(requireString(record.runsDir, "runsDir"))
+        : undefined;
+    const selectors = [
+        record.file !== undefined ? "file" : null,
+        record.loopId !== undefined ? "loopId" : null
+    ].filter((value) => value !== null);
+    if (selectors.length !== 1) {
+        throw invalidSelectorError("Provide exactly one of file or loopId.", "Choose exactly one run selector per call.");
+    }
+    return {
+        ...(record.file !== undefined
+            ? {
+                file: resolveSafeRunsPath(requireString(record.file, "file"), resolvedRunsDir ?? resolveRunsRoot(process.env))
+            }
+            : {}),
+        ...(record.loopId !== undefined
+            ? { loopId: requireLoopId(record.loopId, "loopId") }
+            : {}),
+        ...(resolvedRunsDir ? { runsDir: resolvedRunsDir } : {}),
+        ...optionalPositiveInteger(record.attemptIndex, "attemptIndex")
+    };
+}
+function validateGetVerificationResultsInput(args) {
+    const record = requireObject(args);
+    assertAllowedKeys(record, ["file", "loopId", "runsDir"]);
+    const resolvedRunsDir = record.runsDir !== undefined
+        ? resolveSafeRunsRootPath(requireString(record.runsDir, "runsDir"))
+        : undefined;
+    const selectors = [
+        record.file !== undefined ? "file" : null,
+        record.loopId !== undefined ? "loopId" : null
+    ].filter((value) => value !== null);
+    if (selectors.length !== 1) {
+        throw invalidSelectorError("Provide exactly one of file or loopId.", "Choose exactly one run selector per call.");
+    }
+    return {
+        ...(record.file !== undefined
+            ? {
+                file: resolveSafeRunsPath(requireString(record.file, "file"), resolvedRunsDir ?? resolveRunsRoot(process.env))
+            }
+            : {}),
+        ...(record.loopId !== undefined
+            ? { loopId: requireLoopId(record.loopId, "loopId") }
+            : {}),
+        ...(resolvedRunsDir ? { runsDir: resolvedRunsDir } : {})
+    };
+}
+function validateRunDossierInput(args) {
+    const record = requireObject(args);
+    assertAllowedKeys(record, ["file", "loopId", "runsDir", "latest", "format"]);
+    const base = validateGetRunInput(args);
+    return {
+        ...base,
+        ...optionalEnumAsObject(record.format, "format", ["json", "md", "github-pr"])
+    };
+}
+function validateEvalInput(args) {
+    return validateGetRunInput(args);
+}
+function validateRunControlInput(args) {
+    const record = requireObject(args);
+    assertAllowedKeys(record, ["file", "loopId", "runsDir", "latest", "reason", "requestedBy"]);
+    const base = validateGetRunInput(args);
+    return {
+        ...base,
+        ...optionalString(record.reason, "reason"),
+        ...optionalString(record.requestedBy, "requestedBy")
+    };
+}
+function validateCreatePrInput(args) {
+    const record = requireObject(args);
+    assertAllowedKeys(record, ["file", "loopId", "runsDir", "latest", "format", "title", "base", "execute"]);
+    const base = validateRunDossierInput(args);
+    return {
+        ...base,
+        ...optionalString(record.title, "title"),
+        ...optionalString(record.base, "base"),
+        ...optionalBoolean(record.execute, "execute")
+    };
+}
+function validateReviewPrInput(args) {
+    const record = requireObject(args);
+    assertAllowedKeys(record, ["file", "loopId", "runsDir", "latest", "format", "prBody"]);
+    const base = validateRunDossierInput(args);
+    return {
+        ...base,
+        ...optionalString(record.prBody, "prBody")
     };
 }
 function requireObject(value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
-        throw new Error("Tool arguments must be an object.");
+        throw invalidArgumentsError("Tool arguments must be an object.");
     }
     return value;
 }
 function assertAllowedKeys(record, allowed) {
     const unknownKeys = Object.keys(record).filter((key) => !allowed.includes(key));
     if (unknownKeys.length > 0) {
-        throw new Error(`Unknown arguments: ${unknownKeys.join(", ")}`);
+        throw invalidArgumentsError(`Unknown arguments: ${unknownKeys.join(", ")}`);
     }
 }
-function assertPathWithinRoot(candidatePath, rootPath, name) {
-    const relativePath = relative(rootPath, candidatePath);
+function assertPathWithinRoot(candidatePath, rootPath, name, options = {}) {
+    assertNoSymbolicLinkSegments(candidatePath, name, rootPath);
+    const canonicalRoot = canonicalizePath(rootPath, name, options.requireExistingRoot ?? false);
+    const canonicalCandidate = canonicalizePath(candidatePath, name, options.requireExistingCandidate ?? false);
+    const relativePath = relative(canonicalRoot, canonicalCandidate);
     if (relativePath === "" || relativePath === ".") {
         return;
     }
     if (relativePath.startsWith("..") || isAbsolute(relativePath)) {
-        throw new Error(`Invalid ${name}.`);
+        throw invalidPathError(`Invalid ${name}.`);
+    }
+}
+function assertNoSymbolicLinkSegments(pathValue, name, stopAtPath) {
+    const stopAt = stopAtPath ? resolve(stopAtPath) : undefined;
+    let current = resolve(pathValue);
+    while (true) {
+        if (existsSync(current)) {
+            try {
+                const stats = lstatSync(current);
+                if (stats.isSymbolicLink()) {
+                    throw invalidPathError(`Invalid ${name}.`);
+                }
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    throw error;
+                }
+                throw invalidPathError(`Invalid ${name}.`);
+            }
+        }
+        if (stopAt && relative(stopAt, current) === "") {
+            break;
+        }
+        const parent = dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+}
+function canonicalizePath(pathValue, name, requireExisting) {
+    const resolvedPath = resolve(pathValue);
+    if (!existsSync(resolvedPath)) {
+        if (requireExisting) {
+            throw invalidPathError(`Invalid ${name}.`);
+        }
+        return resolvedPath;
+    }
+    try {
+        const stats = lstatSync(resolvedPath);
+        if (stats.isSymbolicLink()) {
+            throw invalidPathError(`Invalid ${name}.`);
+        }
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw error;
+        }
+        throw invalidPathError(`Invalid ${name}.`);
+    }
+    try {
+        return realpathSync.native(resolvedPath);
+    }
+    catch {
+        throw invalidPathError(`Invalid ${name}.`);
     }
 }
 function requireString(value, name) {
     if (typeof value !== "string" || value.trim().length === 0) {
-        throw new Error(`Invalid ${name}.`);
+        throw invalidArgumentsError(`Invalid ${name}.`);
     }
     return value.trim();
 }
 function requireLoopId(value, name) {
     const loopId = requireString(value, name);
     if (!/^[A-Za-z0-9._-]+$/u.test(loopId)) {
-        throw new Error(`Invalid ${name}.`);
+        throw invalidPathError(`Invalid ${name}.`, "loopId may only include letters, numbers, dots, underscores, and hyphens.");
     }
     return loopId;
 }
@@ -309,7 +547,7 @@ function optionalPositiveNumber(value, name) {
         return {};
     }
     if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
-        throw new Error(`Invalid ${name}.`);
+        throw invalidArgumentsError(`Invalid ${name}.`);
     }
     return { [name]: value };
 }
@@ -317,20 +555,35 @@ function optionalPositiveInteger(value, name) {
     if (value === undefined) {
         return {};
     }
-    return { [name]: requirePositiveInteger(value, name) };
-}
-function requirePositiveInteger(value, name) {
     if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
-        throw new Error(`Invalid ${name}.`);
+        throw invalidArgumentsError(`Invalid ${name}.`);
     }
-    return value;
+    return { [name]: value };
+}
+function optionalNonNegativeInteger(value, name) {
+    if (value === undefined) {
+        return {};
+    }
+    if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+        throw invalidArgumentsError(`Invalid ${name}.`);
+    }
+    return { [name]: value };
+}
+function optionalBoolean(value, name) {
+    if (value === undefined) {
+        return {};
+    }
+    if (typeof value !== "boolean") {
+        throw invalidArgumentsError(`Invalid ${name}.`);
+    }
+    return { [name]: value };
 }
 function optionalStringArray(value, name) {
     if (value === undefined) {
         return undefined;
     }
     if (!Array.isArray(value)) {
-        throw new Error(`Invalid ${name}.`);
+        throw invalidArgumentsError(`Invalid ${name}.`);
     }
     return value.map((item) => requireString(item, name));
 }
@@ -347,8 +600,11 @@ function optionalEnum(value, name, allowed) {
         return undefined;
     }
     if (typeof value !== "string" || !allowed.includes(value)) {
-        throw new Error(`Invalid ${name}.`);
+        throw invalidArgumentsError(`Invalid ${name}.`);
     }
     return value;
 }
-//# sourceMappingURL=server-validation.js.map
+function optionalEnumAsObject(value, name, allowed) {
+    const enumValue = optionalEnum(value, name, allowed);
+    return enumValue ? { [name]: enumValue } : {};
+}