sparkle-design-cli 2.0.7-beta.8 → 2.0.7-rc.2

package/lib/font-manager.js

@@ -5,7 +5,15 @@
 
 import fs from 'fs';
 import path from 'path';
-import { REGEX, COMMENTS, IMPORTS, MESSAGES, GLOBALS_CSS_CANDIDATES } from './constants.js';
+import {
+  REGEX,
+  COMMENTS,
+  IMPORTS,
+  MESSAGES,
+  GLOBALS_CSS_CANDIDATES,
+  VITE_CONFIG_FILES,
+} from './constants.js';
+import { assertSafeRelativePath } from './path-utils.js';
 
 /**
  * sparkle-design.css からフォントの@import文を抽出する
@@ -74,13 +82,17 @@ function createCustomCssImportBlock(customCssPath, globalsPath) {
     return '';
   }
 
-  // custom-css パスは sparkle.config.json からの相対パス（= プロジェクトルートからの相対パス）
-  // globals.css からの相対パスに変換
+  // `custom-css` は `sparkle.config.json` の `extend.custom-css` から来る
+  // ユーザー入力。globals-path と同様に path traversal / shell metacharacter
+  // の混入を弾く。検証を通過した上で entry CSS からの相対 path に変換する。
+  // en: Validate the user-supplied custom-css path before embedding it in
+  // the generated `@import` statement.
+  assertSafeRelativePath(customCssPath, 'custom-css');
+
   const globalsDir = path.dirname(globalsPath);
   const absoluteCustomPath = path.resolve(process.cwd(), customCssPath);
   let relativePath = path.relative(globalsDir, absoluteCustomPath).split(path.sep).join('/');
 
-  // 相対パスが ./ で始まらない場合は付与
   if (!relativePath.startsWith('.')) {
     relativePath = `./${relativePath}`;
   }
@@ -277,15 +289,39 @@ export function updateGlobalsWithFonts(
     // 2. 既存のimportを削除
     globalsContent = removeExistingImports(globalsContent);
 
-    // 3. Tailwind import の位置を見つける
-    const tailwindInfo = findTailwindImport(globalsContent);
+    // 3. Tailwind import の位置を見つける。無ければ先頭に自動で prepend する。
+    //    ここで silent に失敗すると `create-vite` 等が生成した既存 index.css に
+    //    `@import "tailwindcss"` が無いプロジェクトで setup が no-op に終わり、
+    //    AI が後から手書きで import を補うが `@source` を知らず落とす、という
+    //    連鎖的な崩れが起きていた（beta.8 試用で確認）。canonical な import を
+    //    自動投入することでその連鎖を根絶する。
+    // en: If `@import "tailwindcss"` is missing from an existing entry CSS
+    // (e.g. untouched `create-vite` default), auto-prepend it instead of
+    // silently warning. Without this recovery, the whole patch becomes a no-op
+    // and AI ends up hand-writing imports without `@source`, producing drifted
+    // output (observed in beta.8 user testing).
+    let tailwindInfo = findTailwindImport(globalsContent);
     if (!tailwindInfo) {
-      // 表示はプロジェクト相対パスにする。絶対パスだと「どのファイルをいじるのか」
-      // が一目で分かりにくく、リポジトリ間で絶対パスが変わるので diff も読みにくい。
-      // en: Show the project-relative path so it's obvious which file to edit.
       const displayPath = path.relative(process.cwd(), globalsPath) || globalsPath;
-      console.warn(MESSAGES.TAILWIND_NOT_FOUND(displayPath));
-      return { status: 'failed', reason: 'tailwind-import-missing' };
+      console.warn(
+        `⚠️  ${displayPath} に \`@import "tailwindcss";\` が見つからなかったため先頭に追記します（canonical な Tailwind v4 entry point にするため）。`
+      );
+      globalsContent = `${IMPORTS.TAILWIND}\n${globalsContent}`;
+      tailwindInfo = findTailwindImport(globalsContent);
+      if (!tailwindInfo) {
+        // prepend したのに正規表現で拾えないのは `REGEX.TAILWIND_IMPORT` が
+        // 想定と違う（= コードの不整合）。コメントどおり fail-loud にする。
+        // warn 止まりだと generate 完了扱いで exit 0 になり、ユーザーは
+        // patch が壊れていることに気付けない。strict 以外でも throw する。
+        // en: Coded as fail-loud per the comment. A warn-only return lets
+        // generate finish with exit 0 which hides the breakage.
+        console.error(MESSAGES.TAILWIND_NOT_FOUND(displayPath));
+        const err = new Error(
+          `tailwind import を prepend 後も検出できませんでした。REGEX.TAILWIND_IMPORT の不整合か globals.css の書き込み失敗の可能性があります: ${displayPath}`
+        );
+        err.code = 'E_TAILWIND_IMPORT_PREPEND_FAILED';
+        throw err;
+      }
     }
 
     // 4. importブロックを生成（フォント @import は SparkleHead に移行したため生成しない）
@@ -308,26 +344,25 @@ export function updateGlobalsWithFonts(
     console.log(MESSAGES.GLOBALS_UPDATED(globalsPath));
     return { status: 'updated' };
   } catch (error) {
+    // `E_UNSAFE_RELATIVE_PATH`（custom-css の path traversal 等）や
+    // `E_TAILWIND_IMPORT_PREPEND_FAILED`（内部不整合）は silent fallback
+    // させず上流に伝播させる。これらは設定や状態の問題なので、write-error
+    // として status: failed で丸めてしまうと manageFontImports の上流
+    // catch では普通の write-error と区別できなくなる。
+    // en: Propagate codes that must never be silently downgraded. Generic
+    // write errors still go through the failed-return path.
+    if (
+      error.code === 'E_UNSAFE_RELATIVE_PATH' ||
+      error.code === 'E_TAILWIND_IMPORT_PREPEND_FAILED'
+    ) {
+      throw error;
+    }
     console.error(MESSAGES.GLOBALS_UPDATE_FAILED(error.message));
     return { status: 'failed', reason: `write-error: ${error.code ?? error.message}` };
   }
 }
 
-// Vite プロジェクト判定用の config 候補。setup.js 側の `VITE_CONFIG_FILES` と
-// 同じ対象を見る必要がある（判定ロジックが分かれると scaffold と generate で
-// 挙動が食い違う）。
-// en: Vite config candidates used for project detection. Must stay in sync with
-// setup.js's VITE_CONFIG_FILES so scaffold and generate agree on the layout.
-const VITE_CONFIG_FILES = [
-  'vite.config.ts',
-  'vite.config.js',
-  'vite.config.mjs',
-  'vite.config.cjs',
-  'vite.config.mts',
-  'vite.config.cts',
-];
-
-function isViteProject(cwd) {
+export function isViteProject(cwd) {
   return VITE_CONFIG_FILES.some((name) => fs.existsSync(path.join(cwd, name)));
 }
 
@@ -409,6 +444,15 @@ function resolveGlobalsPath(sparkleDesignPath, explicitGlobalsPath = null) {
   const dir = path.dirname(sparkleDesignPath);
 
   if (explicitGlobalsPath) {
+    // `--globals-path` CLI 引数 / `extend.globals-path` config 値はユーザー
+    // 由来のため、path traversal（`../../etc/passwd` 等）や shell メタ文字
+    // を弾く検証を通してから resolve する。共有リポジトリ経由で悪意ある
+    // config が入ったとき、teammate の fs 上で任意ファイルが書き換えられる
+    // supply-chain 型の attack を防ぐ。
+    // en: Validate user-supplied globals-path against traversal / shell
+    // metacharacters before resolving, to prevent config-injection abuse in
+    // shared repositories.
+    assertSafeRelativePath(explicitGlobalsPath, 'globals-path');
     const resolved = path.resolve(process.cwd(), explicitGlobalsPath);
     if (fs.existsSync(resolved)) {
       return { path: resolved, source: 'explicit' };
@@ -451,11 +495,22 @@ function resolveGlobalsPath(sparkleDesignPath, explicitGlobalsPath = null) {
   const candidates = isViteProject(cwd)
     ? GLOBALS_CSS_CANDIDATES.slice().sort((a, b) => vitePriority(a) - vitePriority(b))
     : GLOBALS_CSS_CANDIDATES;
+  // 2-a) まず既知候補の中で `@import "tailwindcss"` を持つファイルを探す。
+  //       持っているファイルが第一候補（canonical Tailwind entry CSS）。
+  // 2-b) 2-a で見つからなかった場合、`@import` 無しで既存の候補ファイルが
+  //       あればそれを拾う（Vite の `create-vite` 直後のように entry CSS は
+  //       あるが Tailwind 未設定のプロジェクト）。これで上流の
+  //       `updateGlobalsWithFonts` が auto-prepend で tailwind import を
+  //       補えるため、silent に no-op 終了する回帰を避けられる（beta.8 で再現）。
+  // en: First pick candidates that already contain `@import "tailwindcss"`.
+  // If none match, fall back to the first existing candidate anyway so the
+  // upstream patcher can auto-prepend the canonical tailwind import. Without
+  // this fallback, a Vite project created by `create-vite` with an untouched
+  // `src/index.css` would cause setup to end as a silent no-op.
+  let fallbackExistingPath = null;
   for (const candidate of candidates) {
     const absolute = path.resolve(cwd, candidate);
     if (!fs.existsSync(absolute)) continue;
-    // 自身（sparkle-design.css）は除外
-    // en: Skip sparkle-design.css itself just in case a candidate points at it.
     if (path.resolve(absolute) === path.resolve(sparkleDesignPath)) continue;
     try {
       const content = fs.readFileSync(absolute, 'utf8');
@@ -463,6 +518,9 @@ function resolveGlobalsPath(sparkleDesignPath, explicitGlobalsPath = null) {
         console.log(`📝 Tailwind エントリポイントを検出しました（project root）: ${candidate}`);
         return { path: absolute, source: 'project' };
       }
+      if (!fallbackExistingPath) {
+        fallbackExistingPath = { path: absolute, candidate };
+      }
     } catch (err) {
       // ENOENT 系は existsSync で既に弾いているので、ここに来るのは権限不足や
       // ディレクトリ衝突などデバッグ価値のあるケース。silent に消さずに理由を出す。
@@ -474,6 +532,13 @@ function resolveGlobalsPath(sparkleDesignPath, explicitGlobalsPath = null) {
     }
   }
 
+  if (fallbackExistingPath) {
+    console.log(
+      `📝 Tailwind import 未設定の既存 entry CSS を検出しました（project root）: ${fallbackExistingPath.candidate}。後続処理で \`@import "tailwindcss";\` を自動追記します。`
+    );
+    return { path: fallbackExistingPath.path, source: 'existing-no-tailwind' };
+  }
+
   // 3. デフォルト: sparkle-design.css と同じディレクトリの globals.css
   // en: Last resort — a globals.css next to sparkle-design.css.
   const defaultPath = path.join(dir, 'globals.css');
@@ -591,7 +656,17 @@ export function manageFontImports(
     // strict モード、または明示指定された globals path の not-found は
     // ユーザーが必ず気付くべきなので非 strict でも再 throw する。
     // en: Always re-throw explicit --globals-path typos; respect strict for the rest.
-    if (strict || error.code === 'E_EXPLICIT_GLOBALS_PATH_NOT_FOUND') {
+    // 以下の code は strict 有無に関わらず常に throw：
+    //   - E_EXPLICIT_GLOBALS_PATH_NOT_FOUND: 明示指定の typo
+    //   - E_UNSAFE_RELATIVE_PATH: globals-path / custom-css の path traversal
+    //   - E_TAILWIND_IMPORT_PREPEND_FAILED: 内部不整合（fail-loud）
+    // en: Always propagate these so silent misconfigurations never survive.
+    if (
+      strict ||
+      error.code === 'E_EXPLICIT_GLOBALS_PATH_NOT_FOUND' ||
+      error.code === 'E_UNSAFE_RELATIVE_PATH' ||
+      error.code === 'E_TAILWIND_IMPORT_PREPEND_FAILED'
+    ) {
       throw error;
     }
     return { status: 'failed', reason: `manage-error: ${error.code ?? error.message}` };

package/lib/generate-css.js

@@ -21,6 +21,7 @@ import {
   extractFontImports,
   removeFontImportsFromCSS,
   updateGlobalsWithFonts,
+  isViteProject,
 } from './font-manager.js';
 
 /**
@@ -42,15 +43,50 @@ function resolveExtend(config, configPath = null) {
     const baseDir = configPath ? path.dirname(path.resolve(configPath)) : process.cwd();
     const extendPath = path.resolve(baseDir, extend);
 
+    // 以前は try/catch で「読めなければ extend ごと無かったことにして続行」
+    // していたが、それだと `extend.globals-path` / `extend.source-packages`
+    // / `extend.fonts` のうち 1 つでも失敗すると全部が silent に無視される。
+    // 後段で Vite の entry CSS が想定と違う場所に patch される等の副作用に
+    // 繋がるため、必ず throw する。`bin/sparkle-design.js` の outer catch が
+    // 拾って exit 1 に昇格させる。
+    // en: Previously a failed extend file silently fell back to the base
+    // config, which hid typos / syntax errors and cascaded into wrong
+    // entry-CSS targets downstream. Always throw; the bin-level catch
+    // turns this into exit 1.
+    let content;
     try {
-      const content = fs.readFileSync(extendPath, 'utf8');
-      extend = JSON.parse(content);
-      console.log(`✅ extend ファイルを読み込みました: ${extendPath}`);
+      content = fs.readFileSync(extendPath, 'utf8');
     } catch (error) {
-      console.error(`❌ extend ファイルの読み込みに失敗しました: ${extendPath} (${error.message})`);
-      const { extend: _, ...rest } = config;
-      return rest;
+      const err = new Error(
+        `extend ファイルを読み込めませんでした: ${extendPath} (${error.code ?? error.message})`
+      );
+      err.code = 'E_EXTEND_FILE_READ_FAILED';
+      throw err;
+    }
+    try {
+      extend = JSON.parse(content, (key, value) => {
+        // Prototype pollution 対策: `__proto__` / `constructor` / `prototype` を drop
+        // en: Strip prototype-pollution keys.
+        if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
+          return undefined;
+        }
+        return value;
+      });
+    } catch (error) {
+      const err = new Error(
+        `extend ファイルの JSON parse に失敗しました: ${extendPath} (${error.message})`
+      );
+      err.code = 'E_EXTEND_FILE_PARSE_FAILED';
+      throw err;
     }
+    if (typeof extend !== 'object' || extend === null || Array.isArray(extend)) {
+      const err = new Error(
+        `extend ファイルの中身は object である必要があります: ${extendPath}`
+      );
+      err.code = 'E_EXTEND_FILE_INVALID_SHAPE';
+      throw err;
+    }
+    console.log(`✅ extend ファイルを読み込みました: ${extendPath}`);
   }
 
   // extend の値を config にマージ（extend 内のフィールドが優先）
@@ -83,27 +119,81 @@ function dedupeFontImports(cssContent) {
     .join('\n');
 }
 
+// Google Fonts に登録可能な family 名の安全な文字集合。英数字・スペース・
+// ハイフン・アンダースコア（実際の Google Fonts ライブラリのほとんどを
+// カバー）に限定。config 由来のため `'` / `;` / `}` / `*` / 改行が入ると
+// 生成された CSS に `@import "http://attacker/"` のような injection が
+// 通ってしまう。sparkle-variables で扱う Theme Settings プラグインの
+// 選択肢集合を超える family 名はそもそも入らない想定なので、範囲を
+// 狭く取ってよい（beyond-allowlist な family は後で緩和できる）。
+// en: Restricted charset to prevent CSS injection via config-sourced font
+// family names. Matches Google Fonts' actual naming conventions.
+const FONT_FAMILY_SAFE = /^[A-Za-z0-9 _-]{1,64}$/;
+const NPM_PACKAGE_SAFE = /^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/i;
+
+function assertSafeFontFamily(family, label) {
+  if (typeof family !== 'string' || !FONT_FAMILY_SAFE.test(family)) {
+    const err = new Error(
+      `${label} に不正な文字が含まれています (${JSON.stringify(family)}). 英数字・スペース・ハイフン・アンダースコアのみ許可。`
+    );
+    err.code = 'E_UNSAFE_FONT_FAMILY';
+    throw err;
+  }
+}
+
+function assertSafeFontWeights(weights, label) {
+  if (!Array.isArray(weights)) {
+    const err = new Error(`${label} は配列である必要があります`);
+    err.code = 'E_UNSAFE_FONT_WEIGHTS';
+    throw err;
+  }
+  for (const w of weights) {
+    if (!Number.isInteger(w) || w < 1 || w > 1000) {
+      const err = new Error(
+        `${label} の値は 1..1000 の整数である必要があります (${JSON.stringify(w)})`
+      );
+      err.code = 'E_UNSAFE_FONT_WEIGHTS';
+      throw err;
+    }
+  }
+}
+
+function assertSafePackageName(name, label) {
+  if (typeof name !== 'string' || !NPM_PACKAGE_SAFE.test(name)) {
+    const err = new Error(`${label} は有効な npm パッケージ名ではありません (${JSON.stringify(name)})`);
+    err.code = 'E_UNSAFE_PACKAGE_NAME';
+    throw err;
+  }
+}
+
 /**
- * fonts セクションのエントリを正規化する
+ * fonts セクションのエントリを正規化する。検証失敗は上流に throw する（silent
+ * にデフォルト値にフォールバックしない — 無効値はユーザーに気付かせる）。
  * @param {string|Array<string|{family:string, weights?:number[]}>} entry
+ * @param {string} label エラーメッセージ用ラベル（例: 'font-pro'）
  * @returns {{family:string, weights:number[]}[]}
  */
-function normalizeFontsEntry(entry) {
+function normalizeFontsEntry(entry, label = 'font') {
   if (!entry) {
     return [];
   }
+  const validate = (family, weights) => {
+    assertSafeFontFamily(family, `${label}.family`);
+    assertSafeFontWeights(weights, `${label}.weights`);
+    return { family, weights };
+  };
   if (typeof entry === 'string') {
-    return [{ family: entry, weights: FONT_DEFAULTS.WEIGHTS }];
+    return [validate(entry, FONT_DEFAULTS.WEIGHTS)];
   }
   if (Array.isArray(entry)) {
     return entry.map((item) => {
       if (typeof item === 'string') {
-        return { family: item, weights: FONT_DEFAULTS.WEIGHTS };
+        return validate(item, FONT_DEFAULTS.WEIGHTS);
       }
-      return { family: item.family, weights: item.weights || FONT_DEFAULTS.WEIGHTS };
+      return validate(item.family, item.weights || FONT_DEFAULTS.WEIGHTS);
     });
   }
-  return [{ family: entry.family, weights: entry.weights || FONT_DEFAULTS.WEIGHTS }];
+  return [validate(entry.family, entry.weights || FONT_DEFAULTS.WEIGHTS)];
 }
 
 /**
@@ -115,13 +205,13 @@ function normalizeFontsEntry(entry) {
 function resolveFontConfig(config) {
   if (config.fonts) {
     return {
-      pro: normalizeFontsEntry(config.fonts.pro || config['font-pro']),
-      mono: normalizeFontsEntry(config.fonts.mono || config['font-mono']),
+      pro: normalizeFontsEntry(config.fonts.pro || config['font-pro'], 'fonts.pro'),
+      mono: normalizeFontsEntry(config.fonts.mono || config['font-mono'], 'fonts.mono'),
     };
   }
   return {
-    pro: normalizeFontsEntry(config['font-pro']),
-    mono: normalizeFontsEntry(config['font-mono']),
+    pro: normalizeFontsEntry(config['font-pro'], 'font-pro'),
+    mono: normalizeFontsEntry(config['font-mono'], 'font-mono'),
   };
 }
 
@@ -374,6 +464,20 @@ function processTemplate(template, config, grayMapping, radiusMapping, colors) {
   processedCSS = processedCSS.replace(/\{\{FONT_FAMILY_MONO\}\}/g, monoFamilyValue);
 
   // 5. 基本的な設定値による置換（オブジェクト・配列・拡張フィールドはスキップ）
+  // 置換対象 key は想定される sparkle.config.json の一群（primary / radius /
+  // font-pro / font-mono 等）に限定しておくと、将来 config に追加された field
+  // が template に漏れ出すリスクと、`key.toUpperCase()` が regex メタ文字
+  // （`.` `*` `?` 等）を含んでいた場合に `new RegExp(placeholder, 'g')` が
+  // wildcard として広く置換してしまう L-2 型の regex injection 両方を防げる。
+  // en: Restrict replacement to a whitelist of known config keys so unknown /
+  // adversarial keys cannot smuggle regex metacharacters into the template.
+  const TEMPLATE_KEY_ALLOWLIST = new Set([
+    'primary',
+    'radius',
+    'font-pro',
+    'font-mono',
+  ]);
+  const ALPHANUMERIC_KEY = /^[a-z0-9-]+$/;
   Object.entries(config).forEach(([key, value]) => {
     // 配列・オブジェクト・拡張フィールドはスキップ
     if (
@@ -387,15 +491,27 @@ function processTemplate(template, config, grayMapping, radiusMapping, colors) {
     ) {
       return;
     }
-    // 通常のプレースホルダー（CSS用 - スペースはそのまま）
+    // 未知 key は置換しない。また念のため英数 + ハイフン以外が含まれて
+    // いるキーも拒否（regex injection の 2 段目防御）。
+    // en: Reject unknown keys and keys with non-alphanumeric chars.
+    if (!TEMPLATE_KEY_ALLOWLIST.has(key) || !ALPHANUMERIC_KEY.test(key)) {
+      return;
+    }
+    // `String.prototype.replace` は第 2 引数が string のとき `$&` / `$'` /
+    // `$\`` / `$1` などを特別扱いして展開するため、ユーザー値が `$&` を
+    // 含んでいるとテンプレート内の別箇所が意図せず重複挿入される。callback
+    // 形式で渡すことで特別展開を無効化する（M-1 defensive fix）。
+    // en: Use the callback form of replace() to disable `$`-special
+    // replacements and treat the value as a literal.
+    const literalValue = String(value);
     const placeholder = `{{${key.toUpperCase().replace('-', '_')}}}`;
-    processedCSS = processedCSS.replace(new RegExp(placeholder, 'g'), value);
+    processedCSS = processedCSS.replace(new RegExp(placeholder, 'g'), () => literalValue);
 
     // フォントファミリーの場合はURL用のプレースホルダーも生成（スペースを+に置き換え）
     if (key.toLowerCase().includes('font')) {
       const urlPlaceholder = `{{${key.toUpperCase().replace('-', '_')}_URL}}`;
-      const urlValue = value.replace(/\s+/g, '+');
-      processedCSS = processedCSS.replace(new RegExp(urlPlaceholder, 'g'), urlValue);
+      const urlValue = literalValue.replace(/\s+/g, '+');
+      processedCSS = processedCSS.replace(new RegExp(urlPlaceholder, 'g'), () => urlValue);
     }
   });
 
@@ -441,22 +557,49 @@ const KNOWN_DESIGN_SYSTEM_PACKAGES = ['@goodpatch/sparkle-design-internal'];
  * en: Scan package.json and surface source-packages when a design-system package is present.
  */
 function detectSourcePackagesFromPackageJson(cwd = process.cwd()) {
+  // package.json が存在しないプロジェクト（稀だが想定はする）は null を返して
+  // 「design system パッケージ検出なし」として扱う。一方で「ファイルはあるが
+  // parse エラー / 権限エラー」は silent null にせず throw に昇格させる。
+  // 以前は全エラーを `catch {}` で握り潰していたため、package.json の JSON
+  // 破損で `@source` が silent に未生成になり、Tailwind スキャンが空になって
+  // class が効かないという silent 回帰に繋がっていた（beta.7 の silent drop
+  // と同系統）。
+  // en: ENOENT → null (no package.json; no sparkle detection). Other errors
+  // → throw so they surface instead of turning into `@source` drops.
+  const pkgPath = path.join(cwd, 'package.json');
+  let raw;
   try {
-    const pkg = JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8'));
-    const deps = { ...(pkg.dependencies ?? {}), ...(pkg.devDependencies ?? {}) };
-
-    const hasDefault = Object.prototype.hasOwnProperty.call(deps, 'sparkle-design');
-    const extras = KNOWN_DESIGN_SYSTEM_PACKAGES.filter((name) =>
-      Object.prototype.hasOwnProperty.call(deps, name)
+    raw = fs.readFileSync(pkgPath, 'utf8');
+  } catch (error) {
+    if (error.code === 'ENOENT') return null;
+    throw new Error(
+      `package.json の読み込みに失敗しました: ${pkgPath} (${error.code ?? error.message})`
     );
+  }
+  let pkg;
+  try {
+    // Prototype pollution 対策（L-1）: `__proto__` / `constructor` / `prototype` を drop
+    // en: Strip prototype-pollution keys at parse time.
+    pkg = JSON.parse(raw, (key, value) => {
+      if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
+        return undefined;
+      }
+      return value;
+    });
+  } catch (error) {
+    throw new Error(`package.json の JSON parse に失敗しました: ${pkgPath} (${error.message})`);
+  }
+  const deps = { ...(pkg.dependencies ?? {}), ...(pkg.devDependencies ?? {}) };
 
-    if (hasDefault || extras.length > 0) {
-      return extras;
-    }
-    return null;
-  } catch {
-    return null;
+  const hasDefault = Object.prototype.hasOwnProperty.call(deps, 'sparkle-design');
+  const extras = KNOWN_DESIGN_SYSTEM_PACKAGES.filter((name) =>
+    Object.prototype.hasOwnProperty.call(deps, name)
+  );
+
+  if (hasDefault || extras.length > 0) {
+    return extras;
   }
+  return null;
 }
 
 function writeCSS(cssContent, outputPath = null) {
@@ -540,10 +683,14 @@ export function generateCSS(
   // する。Vite は <head> が index.html 側にあるため、React コンポーネントの
   // SparkleHead を挟めない。managed block でマーカー間だけを管理し、既存の
   // head 内容は非破壊に保つ。
-  // en: Vite ships its <head> in index.html, outside React's reach, so mirror
-  // the SparkleHead link tags into a managed block there.
+  // en: Inject only when confirmed Vite — other frameworks shipping an
+  // index.html (Astro / Remix / plain SPA) must not receive Sparkle's
+  // managed block.
   const cwdForHtml = process.cwd();
-  if (fs.existsSync(path.resolve(cwdForHtml, 'index.html'))) {
+  if (
+    isViteProject(cwdForHtml) &&
+    fs.existsSync(path.resolve(cwdForHtml, 'index.html'))
+  ) {
     const htmlResult = upsertViteIndexHtmlFonts(cwdForHtml, resolvedFonts);
     if (htmlResult.status === 'created' || htmlResult.status === 'updated') {
       const displayPath = path.relative(cwdForHtml, htmlResult.path) || htmlResult.path;
@@ -551,9 +698,19 @@ export function generateCSS(
         `✅ index.html の Sparkle フォント <link> ブロックを${htmlResult.status === 'created' ? '挿入' : '更新'}しました: ${displayPath}`
       );
     } else if (htmlResult.status === 'failed') {
-      console.warn(
-        `⚠️  index.html への Sparkle フォント <link> 挿入に失敗しました (${htmlResult.reason})。手動で <head> 内に SparkleHead.tsx 相当の <link> タグを追加してください。`
+      // `no-head-close-tag` は index.html が壊れている事実上の user error。
+      // silent warn ではなく error として出し、strict / no-head-close-tag
+      // のときは throw に昇格させる。read-error も同様。
+      // en: A failed injection signals either a malformed index.html or a
+      // permission problem — surface it loudly rather than no-op silently.
+      console.error(
+        `❌ index.html への Sparkle フォント <link> 挿入に失敗しました (reason: ${htmlResult.reason})。index.html の <head>...</head> が正しいか確認してください。対象: ${path.resolve(cwdForHtml, 'index.html')}`
       );
+      if (Boolean(options.strict) || htmlResult.reason === 'no-head-close-tag') {
+        throw new Error(
+          `index.html への font link 挿入失敗 (${htmlResult.reason})。--strict または no-head-close-tag の場合は exit 1 で停止します。`
+        );
+      }
     }
   }
 
@@ -567,6 +724,17 @@ export function generateCSS(
   console.log(MESSAGES.FONT_MANAGEMENT_START);
   const detectedPackages = detectSourcePackagesFromPackageJson();
   const explicitPackages = 'source-packages' in config ? config['source-packages'] || [] : null;
+  // 明示指定側はユーザー由来なので、npm package name の安全な charset に
+  // 限定する。不正値（`a"; body{...}` のような CSS injection 等）は吐かない。
+  // 自動検出側は `package.json` の `dependencies` key（npm 自身が validate
+  // 済み）なので追加 validation は不要。
+  // en: Validate user-supplied source-packages entries; detected ones come
+  // from npm-validated package.json keys.
+  if (Array.isArray(explicitPackages)) {
+    for (const pkg of explicitPackages) {
+      assertSafePackageName(pkg, 'extend.source-packages');
+    }
+  }
   const sourcePackages =
     detectedPackages !== null || explicitPackages !== null
       ? [...new Set([...(detectedPackages ?? []), ...(explicitPackages ?? [])])]

package/lib/path-utils.js

@@ -0,0 +1,66 @@
+import path from 'path';
+
+// setup.js 側と共通の「unsafe な shell メタ文字や quote」を弾く pattern。
+// config 由来や CLI 引数の相対 path に対して path traversal / shell injection
+// 対策として使う。
+// en: Shared unsafe-character pattern. Keeps in sync with setup.js's internal
+// usage; any new call site should reuse this helper rather than re-implement.
+const UNSAFE_CHARS = /[\s"'`;$&|<>()[\]{}\\]/;
+
+/**
+ * path の区切りを POSIX (`/`) に揃える。Windows / POSIX 両環境で相対 path の
+ * 表示や `@import` path 生成に使う。
+ * en: Normalize OS path separators to POSIX `/`.
+ */
+export function toPosixPath(p) {
+  return p.split(path.sep).join('/');
+}
+
+/**
+ * ユーザー入力の相対 path を検証し、検証済みの POSIX 相対 path を返す。
+ *
+ * 検証内容:
+ * - 空文字 / 空白のみ → throw
+ * - 絶対パス → throw（user config に絶対パスを書かせるとプロジェクト外書き込みが許される）
+ * - shell メタ文字を含む → throw（hook command 文字列や script に埋まると injection になる）
+ * - 正規化後に `../` から始まる = プロジェクト root を escape → throw
+ *
+ * 既存の `setup.js:normalizePath` から「相対 path validation 部分だけ」抜き
+ * 出した軽量版。`fs.existsSync` 等のファイル I/O は行わない（呼び出し側が
+ * それぞれの context で存在チェックする）。
+ *
+ * en: Validate a user-supplied relative path and return the normalized POSIX
+ * form. Fails loud on traversal / shell metacharacters / absolute paths.
+ * Unlike setup.js:normalizePath, this does not touch the filesystem.
+ *
+ * @param {string} inputPath
+ * @param {string} label エラーメッセージ用ラベル
+ * @returns {string} 正規化された POSIX 相対 path
+ */
+export function assertSafeRelativePath(inputPath, label) {
+  const tagged = (message) => {
+    const err = new Error(message);
+    err.code = 'E_UNSAFE_RELATIVE_PATH';
+    return err;
+  };
+  if (typeof inputPath !== 'string') {
+    throw tagged(`${label} must be a string (got ${typeof inputPath})`);
+  }
+  const trimmed = inputPath.trim();
+  if (!trimmed) {
+    throw tagged(`${label} is empty`);
+  }
+  if (path.isAbsolute(trimmed)) {
+    throw tagged(`${label} must be relative to the project root: ${trimmed}`);
+  }
+  if (UNSAFE_CHARS.test(trimmed)) {
+    throw tagged(
+      `${label} contains unsupported characters: ${trimmed}. Use a simple relative path.`
+    );
+  }
+  const normalized = path.posix.normalize(trimmed.replace(/\\/g, '/'));
+  if (normalized.startsWith('../')) {
+    throw tagged(`${label} must stay inside the project root: ${trimmed}`);
+  }
+  return normalized;
+}