@dollhousemcp/mcp-server 2.0.37 → 2.0.39

package/dist/generated/version.d.ts

@@ -2,8 +2,8 @@
  * Auto-generated file - DO NOT EDIT
  * Generated at build time by scripts/generate-version.js
  */
-export declare const PACKAGE_VERSION = "2.0.37";
-export declare const BUILD_TIMESTAMP = "2026-07-04T17:06:33.872Z";
+export declare const PACKAGE_VERSION = "2.0.39";
+export declare const BUILD_TIMESTAMP = "2026-07-31T16:08:01.942Z";
 export declare const BUILD_TYPE: 'npm' | 'git';
 export declare const PACKAGE_NAME = "@dollhousemcp/mcp-server";
 //# sourceMappingURL=version.d.ts.map

package/dist/generated/version.js

@@ -2,8 +2,8 @@
  * Auto-generated file - DO NOT EDIT
  * Generated at build time by scripts/generate-version.js
  */
-export const PACKAGE_VERSION = '2.0.37';
-export const BUILD_TIMESTAMP = '2026-07-04T17:06:33.872Z';
+export const PACKAGE_VERSION = '2.0.39';
+export const BUILD_TIMESTAMP = '2026-07-31T16:08:01.942Z';
 export const BUILD_TYPE = 'npm';
 export const PACKAGE_NAME = '@dollhousemcp/mcp-server';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9nZW5lcmF0ZWQvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFFSCxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsUUFBUSxDQUFDO0FBQ3hDLE1BQU0sQ0FBQyxNQUFNLGVBQWUsR0FBRywwQkFBMEIsQ0FBQztBQUMxRCxNQUFNLENBQUMsTUFBTSxVQUFVLEdBQWtCLEtBQUssQ0FBQztBQUMvQyxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsMEJBQTBCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEF1dG8tZ2VuZXJhdGVkIGZpbGUgLSBETyBOT1QgRURJVFxuICogR2VuZXJhdGVkIGF0IGJ1aWxkIHRpbWUgYnkgc2NyaXB0cy9nZW5lcmF0ZS12ZXJzaW9uLmpzXG4gKi9cblxuZXhwb3J0IGNvbnN0IFBBQ0tBR0VfVkVSU0lPTiA9ICcyLjAuMzcnO1xuZXhwb3J0IGNvbnN0IEJVSUxEX1RJTUVTVEFNUCA9ICcyMDI2LTA3LTA0VDE3OjA2OjMzLjg3MlonO1xuZXhwb3J0IGNvbnN0IEJVSUxEX1RZUEU6ICducG0nIHwgJ2dpdCcgPSAnbnBtJztcbmV4cG9ydCBjb25zdCBQQUNLQUdFX05BTUUgPSAnQGRvbGxob3VzZW1jcC9tY3Atc2VydmVyJztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9nZW5lcmF0ZWQvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFFSCxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsUUFBUSxDQUFDO0FBQ3hDLE1BQU0sQ0FBQyxNQUFNLGVBQWUsR0FBRywwQkFBMEIsQ0FBQztBQUMxRCxNQUFNLENBQUMsTUFBTSxVQUFVLEdBQWtCLEtBQUssQ0FBQztBQUMvQyxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsMEJBQTBCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEF1dG8tZ2VuZXJhdGVkIGZpbGUgLSBETyBOT1QgRURJVFxuICogR2VuZXJhdGVkIGF0IGJ1aWxkIHRpbWUgYnkgc2NyaXB0cy9nZW5lcmF0ZS12ZXJzaW9uLmpzXG4gKi9cblxuZXhwb3J0IGNvbnN0IFBBQ0tBR0VfVkVSU0lPTiA9ICcyLjAuMzknO1xuZXhwb3J0IGNvbnN0IEJVSUxEX1RJTUVTVEFNUCA9ICcyMDI2LTA3LTMxVDE2OjA4OjAxLjk0MlonO1xuZXhwb3J0IGNvbnN0IEJVSUxEX1RZUEU6ICducG0nIHwgJ2dpdCcgPSAnbnBtJztcbmV4cG9ydCBjb25zdCBQQUNLQUdFX05BTUUgPSAnQGRvbGxob3VzZW1jcC9tY3Atc2VydmVyJztcbiJdfQ==

package/dist/utils/pathSecurity.d.ts

@@ -3,7 +3,50 @@
  * directory. This is separator-aware, so sibling paths such as `/tmp/base2`
  * are not treated as children of `/tmp/base`. Existing symlinked base paths
  * and symlinked descendants under the base are rejected because writes would
- * follow them outside the lexical containment boundary.
+ * follow them outside the lexical containment boundary. A base that does not
+ * exist yet is vetted through its nearest existing ancestor: if that ancestor
+ * is a symlink, the recursive mkdir/write that follows would be redirected
+ * outside the intended tree, so it is rejected too (#2342).
+ *
+ * CONTRACT (#2344): the base's own ancestry can only be best-effort vetted
+ * here — a symlink whose target pre-contains matching subdirectories is not
+ * detectable without a caller-known boundary (see nearestExistingAncestorStats
+ * for why walking every ancestor false-positives on system symlinks). Do NOT
+ * pass user-controlled base paths directly to this function: vet them first
+ * with vetOutputBase(), which contains them canonically against an anchor and
+ * returns the canonical base to use here. Every current caller does this.
  */
 export declare function resolvePathWithinBase(baseDir: string, ...segments: string[]): string;
+/**
+ * Canonical (realpath) form of a path that may not fully exist yet: the
+ * deepest existing ancestor is resolved through every symlink, and the
+ * not-yet-created suffix is appended unchanged. This answers "where would a
+ * recursive mkdir/write on this path REALLY land?" — which per-component
+ * lstat checks cannot, because lstat resolves intermediate symlinks and only
+ * reports on the final component (#2344).
+ */
+export declare function canonicalizePath(inputPath: string): string;
+/**
+ * Vets a user-supplied output base for CLI writes and returns the canonical
+ * path all subsequent writes should use (#2344).
+ *
+ * Two regimes, split by what the user lexically named:
+ *
+ *  - Base inside the anchor (relative outputs like the './anthropic-skills'
+ *    default): the canonical base must stay inside the canonical anchor.
+ *    A symlink that redirects it elsewhere — including one whose target
+ *    already contains matching subdirectories, the case per-component lstat
+ *    checks miss — is rejected. Comparing in canonical space means system
+ *    links above the anchor (macOS /tmp -> /private/tmp) never false-positive.
+ *
+ *  - Base outside the anchor (explicit absolute or ../ outputs): the user
+ *    named that destination, so there is no boundary to defend. Instead of
+ *    guessing intent, the real destination is disclosed via `onDisclose`
+ *    whenever it differs from the lexical path, and the canonical path is
+ *    returned so what was vetted is what gets written.
+ */
+export declare function vetOutputBase(baseDir: string, options?: {
+    anchor?: string;
+    onDisclose?: (canonicalBase: string) => void;
+}): string;
 //# sourceMappingURL=pathSecurity.d.ts.map

package/dist/utils/pathSecurity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pathSecurity.d.ts","sourceRoot":"","sources":["../../src/utils/pathSecurity.ts"],"names":[],"mappings":"AAqCA;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,CA4BpF"}
+{"version":3,"file":"pathSecurity.d.ts","sourceRoot":"","sources":["../../src/utils/pathSecurity.ts"],"names":[],"mappings":"AAkFA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,CA4BpF;AASD;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAsB1D;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,CAAC,aAAa,EAAE,MAAM,KAAK,IAAI,CAAA;CAAE,GAC1E,MAAM,CA0BR"}

package/dist/utils/pathSecurity.js

@@ -1,21 +1,65 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
+function isMissingPathError(error) {
+    const code = typeof error === 'object' && error !== null && 'code' in error
+        ? error.code
+        : undefined;
+    return code === 'ENOENT' || code === 'ENOTDIR';
+}
+/**
+ * lstat of the deepest ancestor of `startPath` that exists, or null when
+ * nothing up to the filesystem root exists. Used to vet paths that will be
+ * created later: their containment depends on the directory they will be
+ * created inside.
+ *
+ * KNOWN LIMIT (#2344): this stops at the first ancestor lstat can see, and
+ * lstat resolves intermediate symlinks — so a symlink whose target already
+ * contains a matching subdirectory is reported as a plain directory and the
+ * symlink component itself is never inspected. Walking every lexical ancestor
+ * instead is not an option: system symlinks (macOS /tmp -> /private/tmp,
+ * /var -> /private/var) sit above every temp path and would false-positive.
+ * Full protection needs a caller-known boundary, which is exactly what
+ * vetOutputBase() provides — see the contract note on resolvePathWithinBase.
+ */
+function nearestExistingAncestorStats(startPath) {
+    let previous = startPath;
+    let current = path.dirname(startPath);
+    while (current !== previous) {
+        try {
+            return fs.lstatSync(current);
+        }
+        catch (error) {
+            if (!isMissingPathError(error)) {
+                throw error;
+            }
+        }
+        previous = current;
+        current = path.dirname(current);
+    }
+    return null;
+}
 function assertNotSymlink(pathToCheck, message) {
+    let stats;
     try {
-        const stats = fs.lstatSync(pathToCheck);
-        if (stats.isSymbolicLink()) {
-            throw new Error(message);
-        }
+        stats = fs.lstatSync(pathToCheck);
     }
     catch (error) {
-        const code = typeof error === 'object' && error !== null && 'code' in error
-            ? error.code
-            : undefined;
-        if (code === 'ENOENT' || code === 'ENOTDIR') {
+        if (isMissingPathError(error)) {
+            // The path does not exist yet, so it will be created by a later
+            // mkdir/write. That is only safe if the directory it gets created
+            // inside is real: a symlinked existing ancestor would redirect the
+            // recursive create outside the containment boundary (#2342).
+            const ancestorStats = nearestExistingAncestorStats(pathToCheck);
+            if (ancestorStats?.isSymbolicLink()) {
+                throw new Error(message);
+            }
             return;
         }
         throw error;
     }
+    if (stats.isSymbolicLink()) {
+        throw new Error(message);
+    }
 }
 function assertNoSymlinkedDescendants(resolvedBase, resolvedTarget) {
     const relativePath = path.relative(resolvedBase, resolvedTarget);
@@ -36,7 +80,18 @@ function assertNoSymlinkedDescendants(resolvedBase, resolvedTarget) {
  * directory. This is separator-aware, so sibling paths such as `/tmp/base2`
  * are not treated as children of `/tmp/base`. Existing symlinked base paths
  * and symlinked descendants under the base are rejected because writes would
- * follow them outside the lexical containment boundary.
+ * follow them outside the lexical containment boundary. A base that does not
+ * exist yet is vetted through its nearest existing ancestor: if that ancestor
+ * is a symlink, the recursive mkdir/write that follows would be redirected
+ * outside the intended tree, so it is rejected too (#2342).
+ *
+ * CONTRACT (#2344): the base's own ancestry can only be best-effort vetted
+ * here — a symlink whose target pre-contains matching subdirectories is not
+ * detectable without a caller-known boundary (see nearestExistingAncestorStats
+ * for why walking every ancestor false-positives on system symlinks). Do NOT
+ * pass user-controlled base paths directly to this function: vet them first
+ * with vetOutputBase(), which contains them canonically against an anchor and
+ * returns the canonical base to use here. Every current caller does this.
  */
 export function resolvePathWithinBase(baseDir, ...segments) {
     if (!baseDir || typeof baseDir !== 'string') {
@@ -63,4 +118,83 @@ export function resolvePathWithinBase(baseDir, ...segments) {
     }
     throw new Error('Resolved path escapes the base directory');
 }
-//# sourceMappingURL=data:application/json;base64,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
+/** True when a base-relative path points outside the base. */
+function escapesBase(relativePath) {
+    return relativePath === '..'
+        || relativePath.startsWith('..' + path.sep)
+        || path.isAbsolute(relativePath);
+}
+/**
+ * Canonical (realpath) form of a path that may not fully exist yet: the
+ * deepest existing ancestor is resolved through every symlink, and the
+ * not-yet-created suffix is appended unchanged. This answers "where would a
+ * recursive mkdir/write on this path REALLY land?" — which per-component
+ * lstat checks cannot, because lstat resolves intermediate symlinks and only
+ * reports on the final component (#2344).
+ */
+export function canonicalizePath(inputPath) {
+    const resolved = path.resolve(inputPath);
+    const missing = [];
+    let current = resolved;
+    for (;;) {
+        try {
+            const canonical = fs.realpathSync(current);
+            return missing.length ? path.join(canonical, ...missing) : canonical;
+        }
+        catch (error) {
+            if (!isMissingPathError(error)) {
+                throw error;
+            }
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            // Nothing on the chain exists (should not happen for absolute paths —
+            // the root exists — but keep a lexical fallback rather than throwing).
+            return missing.length ? path.join(current, ...missing) : current;
+        }
+        missing.unshift(path.basename(current));
+        current = parent;
+    }
+}
+/**
+ * Vets a user-supplied output base for CLI writes and returns the canonical
+ * path all subsequent writes should use (#2344).
+ *
+ * Two regimes, split by what the user lexically named:
+ *
+ *  - Base inside the anchor (relative outputs like the './anthropic-skills'
+ *    default): the canonical base must stay inside the canonical anchor.
+ *    A symlink that redirects it elsewhere — including one whose target
+ *    already contains matching subdirectories, the case per-component lstat
+ *    checks miss — is rejected. Comparing in canonical space means system
+ *    links above the anchor (macOS /tmp -> /private/tmp) never false-positive.
+ *
+ *  - Base outside the anchor (explicit absolute or ../ outputs): the user
+ *    named that destination, so there is no boundary to defend. Instead of
+ *    guessing intent, the real destination is disclosed via `onDisclose`
+ *    whenever it differs from the lexical path, and the canonical path is
+ *    returned so what was vetted is what gets written.
+ */
+export function vetOutputBase(baseDir, options) {
+    if (!baseDir || typeof baseDir !== 'string') {
+        throw new TypeError('Base directory must be a non-empty string');
+    }
+    if (baseDir.includes('\0')) {
+        throw new Error('Path segment contains a null byte');
+    }
+    const resolvedAnchor = path.resolve(options?.anchor ?? process.cwd());
+    const resolvedBase = path.resolve(baseDir);
+    const canonicalBase = canonicalizePath(resolvedBase);
+    if (!escapesBase(path.relative(resolvedAnchor, resolvedBase))) {
+        const canonicalAnchor = canonicalizePath(resolvedAnchor);
+        if (escapesBase(path.relative(canonicalAnchor, canonicalBase))) {
+            throw new Error(`Output path resolves outside the working directory through a symbolic link (real destination: ${canonicalBase})`);
+        }
+        return canonicalBase;
+    }
+    if (canonicalBase !== resolvedBase) {
+        options?.onDisclose?.(canonicalBase);
+    }
+    return canonicalBase;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pathSecurity.js","sourceRoot":"","sources":["../../src/utils/pathSecurity.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'node:fs';\nimport * as path from 'node:path';\n\nfunction isMissingPathError(error: unknown): boolean {\n  const code = typeof error === 'object' && error !== null && 'code' in error\n    ? (error as NodeJS.ErrnoException).code\n    : undefined;\n  return code === 'ENOENT' || code === 'ENOTDIR';\n}\n\n/**\n * lstat of the deepest ancestor of `startPath` that exists, or null when\n * nothing up to the filesystem root exists. Used to vet paths that will be\n * created later: their containment depends on the directory they will be\n * created inside.\n *\n * KNOWN LIMIT (#2344): this stops at the first ancestor lstat can see, and\n * lstat resolves intermediate symlinks — so a symlink whose target already\n * contains a matching subdirectory is reported as a plain directory and the\n * symlink component itself is never inspected. Walking every lexical ancestor\n * instead is not an option: system symlinks (macOS /tmp -> /private/tmp,\n * /var -> /private/var) sit above every temp path and would false-positive.\n * Full protection needs a caller-known boundary, which is exactly what\n * vetOutputBase() provides — see the contract note on resolvePathWithinBase.\n */\nfunction nearestExistingAncestorStats(startPath: string): fs.Stats | null {\n  let previous = startPath;\n  let current = path.dirname(startPath);\n  while (current !== previous) {\n    try {\n      return fs.lstatSync(current);\n    } catch (error) {\n      if (!isMissingPathError(error)) {\n        throw error;\n      }\n    }\n    previous = current;\n    current = path.dirname(current);\n  }\n  return null;\n}\n\nfunction assertNotSymlink(pathToCheck: string, message: string): void {\n  let stats: fs.Stats;\n  try {\n    stats = fs.lstatSync(pathToCheck);\n  } catch (error) {\n    if (isMissingPathError(error)) {\n      // The path does not exist yet, so it will be created by a later\n      // mkdir/write. That is only safe if the directory it gets created\n      // inside is real: a symlinked existing ancestor would redirect the\n      // recursive create outside the containment boundary (#2342).\n      const ancestorStats = nearestExistingAncestorStats(pathToCheck);\n      if (ancestorStats?.isSymbolicLink()) {\n        throw new Error(message);\n      }\n      return;\n    }\n    throw error;\n  }\n  if (stats.isSymbolicLink()) {\n    throw new Error(message);\n  }\n}\n\nfunction assertNoSymlinkedDescendants(resolvedBase: string, resolvedTarget: string): void {\n  const relativePath = path.relative(resolvedBase, resolvedTarget);\n  if (!relativePath) {\n    return;\n  }\n\n  let currentPath = resolvedBase;\n  for (const segment of relativePath.split(path.sep)) {\n    if (!segment) {\n      continue;\n    }\n\n    currentPath = path.join(currentPath, segment);\n    assertNotSymlink(currentPath, 'Path segment resolves through a symbolic link');\n  }\n}\n\n/**\n * Resolve a target path and verify that it remains inside the intended base\n * directory. This is separator-aware, so sibling paths such as `/tmp/base2`\n * are not treated as children of `/tmp/base`. Existing symlinked base paths\n * and symlinked descendants under the base are rejected because writes would\n * follow them outside the lexical containment boundary. A base that does not\n * exist yet is vetted through its nearest existing ancestor: if that ancestor\n * is a symlink, the recursive mkdir/write that follows would be redirected\n * outside the intended tree, so it is rejected too (#2342).\n *\n * CONTRACT (#2344): the base's own ancestry can only be best-effort vetted\n * here — a symlink whose target pre-contains matching subdirectories is not\n * detectable without a caller-known boundary (see nearestExistingAncestorStats\n * for why walking every ancestor false-positives on system symlinks). Do NOT\n * pass user-controlled base paths directly to this function: vet them first\n * with vetOutputBase(), which contains them canonically against an anchor and\n * returns the canonical base to use here. Every current caller does this.\n */\nexport function resolvePathWithinBase(baseDir: string, ...segments: string[]): string {\n  if (!baseDir || typeof baseDir !== 'string') {\n    throw new TypeError('Base directory must be a non-empty string');\n  }\n\n  for (const segment of segments) {\n    if (typeof segment !== 'string') {\n      throw new TypeError('Path segments must be strings');\n    }\n    if (segment.includes('\\0')) {\n      throw new Error('Path segment contains a null byte');\n    }\n  }\n\n  const resolvedBase = path.resolve(baseDir);\n  const resolvedTarget = path.resolve(resolvedBase, ...segments);\n  const relativePath = path.relative(resolvedBase, resolvedTarget);\n  const isTraversal = relativePath === '..'\n    || relativePath.startsWith('..' + path.sep)\n    || path.isAbsolute(relativePath);\n\n  if (!isTraversal) {\n    assertNotSymlink(resolvedBase, 'Base directory resolves through a symbolic link');\n    assertNoSymlinkedDescendants(resolvedBase, resolvedTarget);\n    return resolvedTarget;\n  }\n\n  throw new Error('Resolved path escapes the base directory');\n}\n\n/** True when a base-relative path points outside the base. */\nfunction escapesBase(relativePath: string): boolean {\n  return relativePath === '..'\n    || relativePath.startsWith('..' + path.sep)\n    || path.isAbsolute(relativePath);\n}\n\n/**\n * Canonical (realpath) form of a path that may not fully exist yet: the\n * deepest existing ancestor is resolved through every symlink, and the\n * not-yet-created suffix is appended unchanged. This answers \"where would a\n * recursive mkdir/write on this path REALLY land?\" — which per-component\n * lstat checks cannot, because lstat resolves intermediate symlinks and only\n * reports on the final component (#2344).\n */\nexport function canonicalizePath(inputPath: string): string {\n  const resolved = path.resolve(inputPath);\n  const missing: string[] = [];\n  let current = resolved;\n  for (;;) {\n    try {\n      const canonical = fs.realpathSync(current);\n      return missing.length ? path.join(canonical, ...missing) : canonical;\n    } catch (error) {\n      if (!isMissingPathError(error)) {\n        throw error;\n      }\n    }\n    const parent = path.dirname(current);\n    if (parent === current) {\n      // Nothing on the chain exists (should not happen for absolute paths —\n      // the root exists — but keep a lexical fallback rather than throwing).\n      return missing.length ? path.join(current, ...missing) : current;\n    }\n    missing.unshift(path.basename(current));\n    current = parent;\n  }\n}\n\n/**\n * Vets a user-supplied output base for CLI writes and returns the canonical\n * path all subsequent writes should use (#2344).\n *\n * Two regimes, split by what the user lexically named:\n *\n *  - Base inside the anchor (relative outputs like the './anthropic-skills'\n *    default): the canonical base must stay inside the canonical anchor.\n *    A symlink that redirects it elsewhere — including one whose target\n *    already contains matching subdirectories, the case per-component lstat\n *    checks miss — is rejected. Comparing in canonical space means system\n *    links above the anchor (macOS /tmp -> /private/tmp) never false-positive.\n *\n *  - Base outside the anchor (explicit absolute or ../ outputs): the user\n *    named that destination, so there is no boundary to defend. Instead of\n *    guessing intent, the real destination is disclosed via `onDisclose`\n *    whenever it differs from the lexical path, and the canonical path is\n *    returned so what was vetted is what gets written.\n */\nexport function vetOutputBase(\n  baseDir: string,\n  options?: { anchor?: string; onDisclose?: (canonicalBase: string) => void },\n): string {\n  if (!baseDir || typeof baseDir !== 'string') {\n    throw new TypeError('Base directory must be a non-empty string');\n  }\n  if (baseDir.includes('\\0')) {\n    throw new Error('Path segment contains a null byte');\n  }\n\n  const resolvedAnchor = path.resolve(options?.anchor ?? process.cwd());\n  const resolvedBase = path.resolve(baseDir);\n  const canonicalBase = canonicalizePath(resolvedBase);\n\n  if (!escapesBase(path.relative(resolvedAnchor, resolvedBase))) {\n    const canonicalAnchor = canonicalizePath(resolvedAnchor);\n    if (escapesBase(path.relative(canonicalAnchor, canonicalBase))) {\n      throw new Error(\n        `Output path resolves outside the working directory through a symbolic link (real destination: ${canonicalBase})`,\n      );\n    }\n    return canonicalBase;\n  }\n\n  if (canonicalBase !== resolvedBase) {\n    options?.onDisclose?.(canonicalBase);\n  }\n  return canonicalBase;\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dollhousemcp/mcp-server",
-  "version": "2.0.37",
+  "version": "2.0.39",
   "description": "DollhouseMCP - A Model Context Protocol (MCP) server that enables dynamic AI persona management from markdown files, allowing Claude and other compatible AI assistants to activate and switch between different behavioral personas.",
   "type": "module",
   "main": "dist/index.js",

package/server.json

@@ -3,7 +3,7 @@
   "name": "io.github.DollhouseMCP/mcp-server",
   "title": "DollhouseMCP",
   "description": "OSS to create Personas, Skills, Templates, Agents, and Memories to customize your AI experience.",
-  "version": "2.0.37",
+  "version": "2.0.39",
   "homepage": "https://dollhousemcp.com",
   "repository": {
     "type": "git",
@@ -29,7 +29,7 @@
     {
       "registryType": "npm",
       "identifier": "@dollhousemcp/mcp-server",
-      "version": "2.0.37",
+      "version": "2.0.39",
       "transport": {
         "type": "stdio"
       }