@wrongstack/core 0.297.0 → 0.298.1

package/dist/design/index.js

@@ -35,6 +35,20 @@ import * as fs2 from "node:fs/promises";
 import * as path2 from "node:path";
 import { fileURLToPath } from "node:url";
 
+// src/skills/frontmatter.ts
+function stripFrontmatter(raw) {
+  const text = normalizeLineEndings(raw);
+  if (!text.startsWith("---")) return text;
+  const end = text.indexOf("\n---", 4);
+  if (end === -1) return text;
+  let body = text.slice(end + 4);
+  if (body.startsWith("\n")) body = body.slice(1);
+  return body;
+}
+function normalizeLineEndings(s) {
+  return s.replace(/\r\n?/g, "\n");
+}
+
 // src/utils/wstack-paths.ts
 import { createHash } from "node:crypto";
 import * as fs from "node:fs";
@@ -167,14 +181,6 @@ function resolveWstackPaths(opts) {
 var KIT_FILE = "KIT.md";
 var TOKENS_FILE = "tokens.json";
 var FOUNDATIONS_ID = "_foundations";
-function stripFrontmatter(raw) {
-  if (!raw.startsWith("---")) return raw;
-  const end = raw.indexOf("\n---", 4);
-  if (end === -1) return raw;
-  let body = raw.slice(end + 4);
-  if (body.startsWith("\n")) body = body.slice(1);
-  return body;
-}
 function parseList(value) {
   const trimmed = value.trim();
   const inner = trimmed.startsWith("[") && trimmed.endsWith("]") ? trimmed.slice(1, -1) : trimmed;
@@ -1298,6 +1304,38 @@ function materializeTokens(opts) {
   }
   return { path: opts.outPath?.trim() || DEFAULT_PATHS[stack], content, format };
 }
+async function resolveMaterializeTarget(resultPath, projectRoot) {
+  const fs4 = await import("node:fs/promises");
+  const path4 = await import("node:path");
+  const resolveReal = async (p) => {
+    const resolved = path4.resolve(p);
+    let probe = resolved;
+    const missing = [];
+    for (; ; ) {
+      try {
+        return path4.resolve(await fs4.realpath(probe), ...missing);
+      } catch (err) {
+        if (err.code === "ENOENT") {
+          const parent = path4.dirname(probe);
+          if (parent === probe) return resolved;
+          missing.unshift(path4.basename(probe));
+          probe = parent;
+          continue;
+        }
+        return resolved;
+      }
+    }
+  };
+  const root = await resolveReal(projectRoot);
+  const absResolved = path4.isAbsolute(resultPath) ? path4.resolve(resultPath) : path4.resolve(path4.join(projectRoot, resultPath));
+  const absParent = await resolveReal(path4.dirname(absResolved));
+  const abs = path4.join(absParent, path4.basename(absResolved));
+  const rel = path4.relative(root, abs);
+  if (rel.startsWith("..") || path4.isAbsolute(rel)) {
+    throw new Error(`design: materialize path "${resultPath}" would escape the project root`);
+  }
+  return abs;
+}
 
 // src/execution/design-tune.ts
 var RADIUS_KEYS = ["radius-none", "radius-sm", "radius-md", "radius-lg", "radius-xl"];
@@ -1403,6 +1441,7 @@ export {
   recordKitChoice,
   recordOverrides,
   resolveBundledDesignKitsDir,
+  resolveMaterializeTarget,
   resolveSemanticTune,
   runDesignVerify,
   setActiveKit,

package/dist/execution/design-materialize.d.ts

@@ -29,4 +29,26 @@ export declare function materializeTokens(opts: {
     kitId: string;
     outPath?: string | undefined;
 }): MaterializeResult;
+/**
+ * Resolve a `materializeTokens` result path to an absolute destination pinned
+ * inside `projectRoot`, or throw if it would escape.
+ *
+ * WS-021/052: `materializeTokens` returns `outPath` verbatim, and each caller
+ * was responsible for containing it. The LLM-tool path in
+ * `packages/tools/src/design.ts` was hardened for issue #249; the WebSocket
+ * handler (`design.materialize`) and the two slash-command paths were not — so
+ * a payload-supplied `out` of `../../../.wrongstack/profiles/default/config.json`
+ * reached `fs.writeFile` unchecked. One shared resolver so a fix cannot land on
+ * one of three sites again.
+ *
+ * Symlinks are resolved before the check (a `/tmp` that is really
+ * `/private/tmp`, a bind mount, or an attacker-planted link would otherwise
+ * smuggle a path past a plain prefix test). The destination usually does not
+ * exist yet, so the parent is realpath'd and the basename re-joined.
+ *
+ * On Windows `path.join(absoluteA, absoluteB)` concatenates literally rather
+ * than collapsing onto the drive root, so an absolute result path is treated as
+ * absolute instead of as a join input — matching the tools-side behaviour.
+ */
+export declare function resolveMaterializeTarget(resultPath: string, projectRoot: string): Promise<string>;
 //# sourceMappingURL=design-materialize.d.ts.map