@simplysm/sd-cli 14.0.45 → 14.0.46

package/src/deps/server-externals/server-production-files.ts

@@ -2,6 +2,7 @@ import type { ServerBuildInfo } from "../../workers/server-build.worker";
 import path from "path";
 import fs from "fs";
 import YAML from "yaml";
+import TOML from "smol-toml";
 import { cpx } from "@simplysm/core-node";
 import { consola } from "consola";
 import { collectAllDependencyExternals } from "../../esbuild/esbuild-config";
@@ -110,9 +111,10 @@ export function generateProductionFiles(
     let nodeVersion = "20";
     if (fs.existsSync(rootMiseTomlPath)) {
       const miseContent = fs.readFileSync(rootMiseTomlPath, "utf-8");
-      const match = /node\s*=\s*"([^"]+)"/.exec(miseContent);
-      if (match != null) {
-        nodeVersion = match[1];
+      // mise.toml은 저장소에서 관리되는 설정 파일이므로, 파싱 실패 시 폴백하지 않고 예외를 전파하여 설정 오류를 즉시 드러낸다.
+      const miseConfig = TOML.parse(miseContent) as { tools?: { node?: string } };
+      if (miseConfig.tools?.node != null) {
+        nodeVersion = miseConfig.tools.node;
       }
     }
     fs.writeFileSync(path.join(distDir, "mise.toml"), `[tools]\nnode = "${nodeVersion}"\n`);

package/src/esbuild/esbuild-config.ts

@@ -4,6 +4,7 @@ import fs from "fs/promises";
 import { createRequire } from "module";
 import type esbuild from "esbuild";
 import { consola } from "consola";
+import { addJsExtensionToImports } from "../utils/output-path-rewriter";
 
 const logger = consola.withTag("sd:cli:esbuild-config");
 
@@ -19,13 +20,7 @@ export async function writeChangedOutputFiles(outputFiles: esbuild.OutputFile[])
   await Promise.all(
     outputFiles.map(async (file) => {
       const finalText = file.path.endsWith(".js")
-        ? file.text.replace(
-            /((?:from|import)\s*["'])(\.\.?\/[^"']*?)(["'])/g,
-            (_match, prefix: string, importPath: string, suffix: string) => {
-              if (/\.(js|mjs|cjs|json|css|wasm|node)$/i.test(importPath)) return _match;
-              return `${prefix}${importPath}.js${suffix}`;
-            },
-          )
+        ? addJsExtensionToImports(file.text)
         : file.text;
 
       try {

package/src/esbuild/esbuild-worker-plugin.ts

@@ -1,27 +1,144 @@
 import path from "path";
 import fs from "fs";
 import type esbuild from "esbuild";
+import * as acorn from "acorn";
+import * as walk from "acorn-walk";
+
+//#region AST 기반 Worker 패턴 탐지
 
 /**
- * Worker/SharedWorker + new URL + import.meta.url 패턴을 감지하는 정규식.
- *
- * 캡처 그룹:
- * - Group 1: `Worker` 또는 `SharedWorker`
- * - Group 2: URL 경로 (예: `"./worker.ts"`)
- * - Group 3: 옵션 객체 (예: `{ type: "module" }`) — 없으면 undefined
+ * AST에서 탐지된 Worker 패턴 하나를 나타낸다.
  */
-const WORKER_PATTERN =
-  /\bnew\s+(Worker|SharedWorker)\s*\(\s*new\s+URL\s*\(\s*["']([^"']+)["']\s*,\s*import\.meta\.url\s*\)\s*(?:,\s*(\{[^}]*\}))?\s*\)/g;
+export interface WorkerMatch {
+  type: "browser" | "node";
+  /** 전체 표현식의 start/end (치환 범위) */
+  start: number;
+  end: number;
+  /** Worker/SharedWorker 이름 (browser만) */
+  workerType?: string;
+  /** URL 경로 문자열 값 */
+  urlPath: string;
+  /** 옵션 객체의 원본 소스 텍스트 (browser만, 없으면 undefined) */
+  existingOpts?: string;
+}
+
+/**
+ * MemberExpression이 import.meta.url인지 확인한다.
+ */
+function isImportMetaUrl(node: any): boolean {
+  return (
+    node.type === "MemberExpression" &&
+    node.object.type === "MetaProperty" &&
+    node.object.meta.name === "import" &&
+    node.object.property.name === "meta" &&
+    node.property.type === "Identifier" &&
+    node.property.name === "url"
+  );
+}
 
 /**
- * Node.js import.meta.resolve 패턴을 감지하는 정규식.
- * 상대 경로(./ 또는 ../)만 감지 — 절대 모듈 경로("some-package")는 무시.
+ * acorn AST를 사용하여 소스 코드에서 Worker/SharedWorker 및 import.meta.resolve 패턴을 탐지한다.
  *
- * 캡처 그룹:
- * - Group 1: 상대 경로 (예: `"../workers/service-protocol.worker"`)
+ * 정규식과 달리 주석, 문자열 리터럴 내부의 패턴을 오탐하지 않는다.
+ * 파싱 실패 시 빈 배열을 반환한다.
  */
-const NODE_WORKER_PATTERN =
-  /\bimport\.meta\.resolve\s*\(\s*["'](\.\.?\/[^"']+)["']\s*\)/g;
+export function findWorkerPatterns(content: string): WorkerMatch[] {
+  let ast: acorn.Node;
+  try {
+    ast = acorn.parse(content, {
+      ecmaVersion: "latest",
+      sourceType: "module",
+    });
+  } catch {
+    return [];
+  }
+
+  const matches: WorkerMatch[] = [];
+
+  walk.simple(ast, {
+    NewExpression(node: any) {
+      // new Worker(new URL("path", import.meta.url), opts?)
+      // new SharedWorker(new URL("path", import.meta.url), opts?)
+      if (
+        node.callee.type !== "Identifier" ||
+        (node.callee.name !== "Worker" && node.callee.name !== "SharedWorker")
+      ) {
+        return;
+      }
+
+      const args = node.arguments;
+      if (args.length < 1) return;
+
+      const urlArg = args[0];
+      if (
+        urlArg.type !== "NewExpression" ||
+        urlArg.callee.type !== "Identifier" ||
+        urlArg.callee.name !== "URL"
+      ) {
+        return;
+      }
+
+      const urlArgs = urlArg.arguments;
+      if (urlArgs.length < 2) return;
+
+      // 첫 번째 인자: 문자열 리터럴 (경로)
+      if (urlArgs[0].type !== "Literal" || typeof urlArgs[0].value !== "string") return;
+
+      // 두 번째 인자: import.meta.url
+      if (!isImportMetaUrl(urlArgs[1])) return;
+
+      const match: WorkerMatch = {
+        type: "browser",
+        start: node.start,
+        end: node.end,
+        workerType: node.callee.name,
+        urlPath: urlArgs[0].value,
+      };
+
+      // 옵션 객체 (두 번째 인자)
+      if (args.length >= 2) {
+        match.existingOpts = content.slice(args[1].start, args[1].end);
+      }
+
+      matches.push(match);
+    },
+
+    CallExpression(node: any) {
+      // import.meta.resolve("./relative-path")
+      const callee = node.callee;
+      if (
+        callee.type !== "MemberExpression" ||
+        callee.object.type !== "MetaProperty" ||
+        callee.object.meta.name !== "import" ||
+        callee.object.property.name !== "meta" ||
+        callee.property.type !== "Identifier" ||
+        callee.property.name !== "resolve"
+      ) {
+        return;
+      }
+
+      const args = node.arguments;
+      if (args.length < 1) return;
+
+      if (args[0].type !== "Literal" || typeof args[0].value !== "string") return;
+
+      const urlPath = args[0].value as string;
+      // 상대 경로만 처리
+      if (!urlPath.startsWith("./") && !urlPath.startsWith("../")) return;
+
+      matches.push({
+        type: "node",
+        start: node.start,
+        end: node.end,
+        urlPath,
+      });
+    },
+  });
+
+  return matches.sort((a, b) => a.start - b.start);
+}
+
+//#endregion
 
 /**
  * Worker 번들 빌드 결과를 포함하는 transform 결과.
@@ -94,20 +211,46 @@ export function transformWorkerPatterns(
   filePath: string,
   build: esbuild.PluginBuild,
 ): TransformWorkerResult | undefined {
-  // 빠른 사전 필터
-  const hasBrowserWorker = content.includes("Worker") && WORKER_PATTERN.test(content);
-  if (hasBrowserWorker) WORKER_PATTERN.lastIndex = 0;
-
-  const hasNodeWorker =
-    content.includes("import.meta.resolve") && NODE_WORKER_PATTERN.test(content);
-  if (hasNodeWorker) NODE_WORKER_PATTERN.lastIndex = 0;
-
-  if (!hasBrowserWorker && !hasNodeWorker) {
+  // 빠른 사전 필터 — AST 파싱 전에 키워드 존재 여부로 걸러냄 (원본 TS content 기준)
+  if (!content.includes("Worker") && !content.includes("import.meta.resolve")) {
     return undefined;
   }
 
   const errors: esbuild.PartialMessage[] = [];
   const warnings: esbuild.PartialMessage[] = [];
+
+  // TS(.ts/.cts/.mts)는 JS로 변환한 후 AST 파싱. acorn은 TS 구문을 처리하지 못하므로
+  // import type, 타입 어노테이션 등이 있으면 파싱 실패로 Worker 패턴이 조용히 누락된다.
+  let effectiveContent = content;
+  if (/\.[cm]?ts$/.test(filePath)) {
+    try {
+      const transformed = build.esbuild.transformSync(content, {
+        loader: "ts",
+        sourcemap: false,
+      });
+      effectiveContent = transformed.code;
+      warnings.push(...transformed.warnings);
+    } catch (e) {
+      const failure = e as {
+        errors?: esbuild.PartialMessage[];
+        warnings?: esbuild.PartialMessage[];
+      };
+      return {
+        contents: content,
+        errors: failure.errors ?? [
+          { text: `TS transform failed: ${String(e)}`, location: null },
+        ],
+        warnings: failure.warnings ?? [],
+      };
+    }
+  }
+
+  // AST 기반 패턴 탐지 (변환된 JS 기준)
+  const matches = findWorkerPatterns(effectiveContent);
+  if (matches.length === 0) {
+    return undefined;
+  }
+
   const allOutputFiles: esbuild.OutputFile[] = [];
   let mergedMetafile: esbuild.Metafile | undefined;
 
@@ -170,42 +313,49 @@ export function transformWorkerPatterns(
     return path.relative(outdir, workerCodeFile.path).replaceAll("\\", "/");
   }
 
-  let transformed = content;
-
-  // 1. 브라우저 Worker 패턴 처리 (new Worker(new URL("path", import.meta.url)))
-  if (hasBrowserWorker) {
-    transformed = transformed.replace(
-      WORKER_PATTERN,
-      (match, workerType: string, urlPath: string, existingOpts?: string) => {
-        const fullWorkerPath = path.resolve(containingDir, urlPath);
-        const workerCodePath = processWorkerBundle(fullWorkerPath, "browser");
-        if (workerCodePath == null) return match;
-
-        const optsStr = existingOpts != null ? existingOpts : '{ type: "module" }';
-        return `new ${workerType}(new URL("${workerCodePath}", import.meta.url), ${optsStr})`;
-      },
-    );
+  // 정방향 chunks 패턴으로 치환 (esbuild-postcss-plugin.ts 동일 패턴)
+  const replacements: Array<{ start: number; end: number; text: string }> = [];
+
+  for (const match of matches) {
+    if (match.type === "browser") {
+      const fullWorkerPath = path.resolve(containingDir, match.urlPath);
+      const workerCodePath = processWorkerBundle(fullWorkerPath, "browser");
+      if (workerCodePath == null) continue;
+
+      const optsStr = match.existingOpts ?? '{ type: "module" }';
+      replacements.push({
+        start: match.start,
+        end: match.end,
+        text: `new ${match.workerType}(new URL("${workerCodePath}", import.meta.url), ${optsStr})`,
+      });
+    } else {
+      const fullWorkerPath = path.resolve(containingDir, match.urlPath);
+      const workerCodePath = processWorkerBundle(
+        fullWorkerPath,
+        build.initialOptions.platform ?? "browser",
+      );
+      if (workerCodePath == null) continue;
+
+      replacements.push({
+        start: match.start,
+        end: match.end,
+        text: `new URL("${workerCodePath}", import.meta.url).href`,
+      });
+    }
   }
 
-  // 2. Node.js import.meta.resolve 패턴 처리
-  if (hasNodeWorker) {
-    transformed = transformed.replace(
-      NODE_WORKER_PATTERN,
-      (match, resolvePath: string) => {
-        const fullWorkerPath = path.resolve(containingDir, resolvePath);
-        const workerCodePath = processWorkerBundle(
-          fullWorkerPath,
-          build.initialOptions.platform ?? "browser",
-        );
-        if (workerCodePath == null) return match;
-
-        return `new URL("${workerCodePath}", import.meta.url).href`;
-      },
-    );
+  // chunks 조립 (변환된 JS 기준 — 매치의 start/end는 effectiveContent 오프셋)
+  const chunks: string[] = [];
+  let cursor = 0;
+  for (const rep of replacements) {
+    chunks.push(effectiveContent.slice(cursor, rep.start));
+    chunks.push(rep.text);
+    cursor = rep.end;
   }
+  chunks.push(effectiveContent.slice(cursor));
 
   return {
-    contents: transformed,
+    contents: chunks.join(""),
     errors,
     warnings,
     workerOutputFiles: allOutputFiles.length > 0 ? allOutputFiles : undefined,
@@ -241,9 +391,12 @@ export function createWorkerBundlePlugin(): esbuild.Plugin {
           });
         }
 
+        // TS(.ts/.cts/.mts)는 transformWorkerPatterns 내부에서 JS로 변환되어 반환되므로
+        // loader는 "js". .tsx/.jsx는 변환하지 않으므로 esbuild가 JSX를 처리하도록 "tsx".
+        const isJsx = /\.[cm]?tsx$/.test(args.path) || args.path.endsWith(".jsx");
         return {
           contents: result.contents,
-          loader: /\.[cm]?tsx?$/.test(args.path) ? ("ts" as const) : ("js" as const),
+          loader: isJsx ? ("tsx" as const) : ("js" as const),
           errors: result.errors.length > 0 ? result.errors : undefined,
           warnings: result.warnings.length > 0 ? result.warnings : undefined,
         };

package/src/utils/output-path-rewriter.ts

@@ -1,39 +1,87 @@
 import path from "path";
 import { pathx } from "@simplysm/core-node";
+import { init, parse } from "es-module-lexer";
+
+await init;
+
+const KNOWN_JS_EXTENSIONS = /\.(js|mjs|cjs|json|css|scss|wasm|node)$/i;
+
+/**
+ * es-module-lexer의 import에서 specifier 내용의 시작/끝 위치를 반환한다.
+ *
+ * static import (d === -1): s..e가 따옴표 없는 specifier 내용
+ * dynamic import (d >= 0): s..e가 따옴표를 포함한 문자열 리터럴
+ */
+function getSpecifierRange(imp: { s: number; e: number; d: number }): [number, number] {
+  if (imp.d >= 0) {
+    return [imp.s + 1, imp.e - 1];
+  }
+  return [imp.s, imp.e];
+}
 
 /**
  * ESM 출력에서 확장자가 없는 상대 import/export 경로에 .js 확장자를 추가한다.
  *
- * 매칭: from "./foo", import("./bar"), from "../baz"
+ * es-module-lexer를 사용하여 import/export specifier 위치를 정확히 파악한다.
+ * 주석, 문자열 리터럴 내부의 패턴은 무시된다.
+ *
+ * 매칭: from "./foo", import("./bar"), from "../baz", export { x } from "./qux"
  * 스킵: bare 지정자("lodash"), 이미 알려진 확장자로 끝나는 경로 (.js, .json, .css 등)
  */
 export function addJsExtensionToImports(text: string): string {
-  return text.replace(
-    /((?:from|import)\s*(?:\(\s*)?["'])(\.\.?\/[^"']*?)(["'](?:\s*\))?)/g,
-    (_match, prefix: string, importPath: string, suffix: string) => {
-      if (/\.(js|mjs|cjs|json|css|scss|wasm|node)$/i.test(importPath)) return _match;
-      return `${prefix}${importPath}.js${suffix}`;
-    },
-  );
+  const [imports] = parse(text);
+  if (imports.length === 0) return text;
+
+  // 역순으로 치환하여 위치 밀림 방지
+  const sorted = [...imports].sort((a, b) => b.s - a.s);
+  let result = text;
+
+  for (const imp of sorted) {
+    const specifier = imp.n;
+    if (specifier == null) continue;
+    if (!specifier.startsWith("./") && !specifier.startsWith("../")) continue;
+    if (KNOWN_JS_EXTENSIONS.test(specifier)) continue;
+
+    const [start, end] = getSpecifierRange(imp);
+    result = result.slice(0, start) + specifier + ".js" + result.slice(end);
+  }
+
+  return result;
 }
 
 /**
  * emit된 JS 텍스트에서 상대 .scss import를 .css로 변환한다.
  * 변환된 텍스트와 원본 .scss import 경로 목록을 반환한다.
  *
- * 매칭: import "./foo.scss", import("./bar.scss"), from "../baz.scss"
+ * es-module-lexer를 사용하여 import specifier 위치를 정확히 파악한다.
  * 상대 import(./ 또는 ../ 시작)만 처리한다.
  */
 export function rewriteScssImports(text: string): { text: string; scssImports: string[] } {
+  const [imports] = parse(text);
+  if (imports.length === 0) return { text, scssImports: [] };
+
   const scssImports: string[] = [];
-  const rewritten = text.replace(
-    /((?:from|import)\s*(?:\(\s*)?["'])(\.\.?\/[^"']*?)(\.scss)(["'](?:\s*\))?)/g,
-    (_match, prefix: string, importBase: string, _ext: string, suffix: string) => {
-      scssImports.push(`${importBase}.scss`);
-      return `${prefix}${importBase}.css${suffix}`;
-    },
-  );
-  return { text: rewritten, scssImports };
+
+  // 역순으로 치환하여 위치 밀림 방지
+  const sorted = [...imports].sort((a, b) => b.s - a.s);
+  let result = text;
+
+  for (const imp of sorted) {
+    const specifier = imp.n;
+    if (specifier == null) continue;
+    if (!specifier.startsWith("./") && !specifier.startsWith("../")) continue;
+    if (!specifier.endsWith(".scss")) continue;
+
+    scssImports.push(specifier);
+    const newSpec = specifier.slice(0, -5) + ".css";
+    const [start, end] = getSpecifierRange(imp);
+    result = result.slice(0, start) + newSpec + result.slice(end);
+  }
+
+  // 역순으로 수집되었으므로 원래 순서로 복원
+  scssImports.reverse();
+
+  return { text: result, scssImports };
 }
 
 /**

package/tests/deps/server-externals/mise-toml-parse-intent.verify.md

@@ -0,0 +1,16 @@
+# mise.toml 파싱 실패 시 명시적 크래시 의도 — LLM 검증
+
+대상: `packages/sd-cli/src/deps/server-externals/server-production-files.ts` `generateProductionFiles()` 내 `TOML.parse(miseContent)` 호출부
+
+근거: `.tasks/260417132441_review-regex-to-parser/1.3-toml-parse-intent-comment.md`
+
+## 검증 항목
+
+- [x] **WHY 주석 존재**: `server-production-files.ts:114`에 `// mise.toml은 저장소에서 관리되는 설정 파일이므로, 파싱 실패 시 폴백하지 않고 예외를 전파하여 설정 오류를 즉시 드러낸다.` 주석이 `TOML.parse(miseContent)` 호출(`:115`) 직전에 존재함을 확인
+- [x] **명시적 크래시 의도 서술**: 주석이 "저장소에서 관리되는 설정 파일", "폴백하지 않고", "예외를 전파", "설정 오류를 즉시 드러낸다" 표현을 모두 포함하여 wbs에 명시된 WHY를 서술
+- [x] **WHAT 서술 지양**: "TOML을 파싱한다" 같은 코드 재서술이 아니라, 폴백을 의도적으로 하지 않는 이유(설정 오류 즉시 노출)를 설명
+- [x] **try-catch 미추가**: `:109-121` 블록 전체에 try 키워드 없음을 확인 — 파싱 예외는 상위로 전파됨
+- [x] **주석 스타일**: `//` 한 줄 주석 (JSDoc 아님)
+- [x] **주석 언어**: 한국어
+- [x] **기타 코드 미변경**: `git diff server-production-files.ts` 결과 라인 114의 주석 추가 1줄 외 변경 없음 (아래 명령 실행 결과 참조)
+- [x] **기존 테스트 통과**: `pnpm exec vitest run --project node packages/sd-cli/tests/workers/server-build-worker.spec.ts` 25/25 통과, 특히 `generates dist/mise.toml when packageManager=mise` 테스트(TOML.parse 경로 실행)가 통과하여 파싱 로직 회귀 없음을 확인. 참고: 전체 sd-cli 테스트(`packages/sd-cli/tests/`)에서 1건 실패(`esbuild-worker-plugin.acc.spec.ts:143`)가 있으나 이는 Feature 1.1 영역이며 본 Feature 1.3 변경(주석 1줄 추가)과 무관