sayren 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1507 @@
+#!/usr/bin/env node
+import { stdin, stdout } from "node:process";
+import { createInterface } from "node:readline/promises";
+import { ApiError, ApprovalPendingError, STOREFRONT_BUILD_TERMINAL_STATUSES, STOREFRONT_SOURCE_BLOB_BATCH_MAX, createStoreClient, normalizeStorefrontPath } from "@sayren/store-sdk";
+import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join, relative, resolve, sep } from "node:path";
+import { createHash } from "node:crypto";
+
+//#region package.json
+var version = "0.1.0";
+
+//#endregion
+//#region src/client.ts
+/**
+* 관리 API 클라이언트 — `@sayren/store-sdk`(계약의 원천)를 쓴다. User-Agent `sayren-cli/{버전}`은 api가 버전의 만든 경로
+* (`createdVia: CLI`)를 적는 표시다(권한과 무관하다. 에이전트 PAT면 행위자는 여전히 에이전트이고 발행은 승인 대기다).
+* 토큰은 헤더에만 싣고 화면·로그에 찍지 않는다.
+*/
+const CLI_VERSION = version;
+const CLI_USER_AGENT = `sayren-cli/${CLI_VERSION}`;
+function clientOf(auth, fetchImpl = fetch) {
+	return createStoreClient({
+		baseUrl: `${auth.apiOrigin}/v1`,
+		auth: { apiToken: auth.token },
+		fetch: (input, init) => {
+			const headers = new Headers(init?.headers);
+			headers.set("user-agent", CLI_USER_AGENT);
+			return fetchImpl(input, {
+				...init,
+				headers
+			});
+		}
+	});
+}
+/** 오류 코드 — `ApiError`가 아니면 null */
+function codeOf(error) {
+	return error instanceof ApiError ? error.code : null;
+}
+function detailsOf(error) {
+	return error instanceof ApiError ? error.details ?? {} : {};
+}
+
+//#endregion
+//#region ../mcp/src/rules.ts
+/** 문서 사이트 — `doc` 경로를 절대 주소로 만들 때 쓴다 */
+const DOCS_BASE_URL = "https://docs.sayren.app";
+const docUrl = (doc) => `${DOCS_BASE_URL}${doc}`;
+const RULES = [
+	{
+		id: "server-only-env",
+		title: "`process.env`는 `*.server.ts`에만 두고 서버 함수 안에서 읽는다",
+		why: "브라우저 번들에 들어가면 `process is not defined`로 그 화면 모듈이 통째로 깨진다. 결제 화면에서 터지면 결제가 시작조차 안 된다",
+		fix: "`process.env`를 읽는 줄을 `*.server.ts`로 옮기고, 화면에 필요한 값은 서버 함수(loader)가 내려준다. 브라우저 파일에서는 그 값을 인자로 받는다",
+		example: "// src/lib/config.server.ts\nexport const API_BASE_URL = process.env.SAYREN_API_URL ?? \"\";\n\n// 화면은 loader가 내려준 값을 쓴다\nconst getConfig = createServerFn().handler(() => ({ apiBaseUrl: API_BASE_URL }));",
+		doc: "/guides/mcp-customize",
+		templateFile: "src/lib/config.server.ts"
+	},
+	{
+		id: "tenant-header",
+		title: "테넌트는 `X-Store-Code` 헤더로 보낸다",
+		why: "공유 API 호스트에서 스토어를 가르는 값이다. 빠지면 다른 스토어 데이터가 보이거나 404가 난다",
+		fix: "`createStorefrontClient`에 `storeCode`를 넘긴다. SDK가 헤더를 붙인다. 서브도메인으로 서비스할 때만 생략한다",
+		example: "createStorefrontClient({ baseUrl: API_BASE_URL, storeCode: resolveStoreCode() });",
+		doc: "/guides/storefront-sdk",
+		templateFile: "src/lib/api.server.ts"
+	},
+	{
+		id: "no-module-token",
+		title: "토큰을 모듈 전역에 담지 않는다",
+		why: "서버 렌더는 요청을 공유한다. 전역에 담으면 다른 구매자의 요청에 토큰이 섞인다",
+		fix: "토큰은 요청마다 읽는다. 서버 함수 안에서 `readToken()`으로 받아 API 클라이언트에 넘기고, 모듈 변수에 저장하지 않는다",
+		example: "const load = createServerFn().handler(async () => {\n  const api = apiFor({ accessToken: readToken() }); // 요청마다 읽는다\n  return api.orders.list();\n});",
+		doc: "/guides/storefront-auth",
+		templateFile: "src/lib/session.server.ts"
+	},
+	{
+		id: "loader-first",
+		title: "데이터는 라우트 loader에서 받는다(서버 함수 `createServerFn`, TanStack Query면 `ensureQueryData`)",
+		why: "클라이언트에서 다시 받으면 첫 화면이 비고 검색 노출이 죽는다. SSR을 끄지 않는다. TanStack Query의 `useQuery`만 쓰면 서버 렌더에는 데이터가 없다",
+		fix: "화면마다 `createFileRoute(...)({ loader })`를 두고 loader가 서버 함수를 부른다. TanStack Query를 쓰면 loader가 `context.queryClient.ensureQueryData(queryOptions)`로 미리 받고 화면은 같은 queryOptions로 `useSuspenseQuery`를 부른다(`setupRouterSsrQueryIntegration`이 캐시를 HTML에 싣는다). `useEffect`에서 처음 데이터를 받지 않는다",
+		example: "const load = createServerFn().handler(() => apiFor().catalog.searchProducts({ size: 24 }));\nconst productsQuery = () => queryOptions({ queryKey: [\"products\"], queryFn: () => load() });\nexport const Route = createFileRoute(\"/products/\")({\n  loader: ({ context }) => context.queryClient.ensureQueryData(productsQuery()),\n  component: Products, // 화면: useSuspenseQuery(productsQuery())\n});",
+		doc: "/guides/mcp-customize",
+		templateFile: "src/routes/products.index.tsx"
+	},
+	{
+		id: "payment-browser-launch",
+		title: "결제창은 브라우저에서 `@sayren/storefront-sdk/payments`로 연다(`start` 또는 `open`)",
+		why: "결제창은 결제 서비스 주소를 브라우저 창으로 여는 일이다. 서버 파일에서 부르면 아무것도 열리지 않고 결제가 시작되지 않는다. 결제 시작(`startPayment`)은 서버 함수, 결제창은 브라우저다",
+		fix: "결제 모듈 import를 서버 파일에서 지우고 컴포넌트(클릭 핸들러·effect)로 옮긴다. 서버 함수는 `checkout.startPayment`로 결제 시작 값만 만들어 내려주고, 그 값을 브라우저에서 `payments.open()`에 넘긴다",
+		example: "// 서버 함수: 결제 시작(토큰은 서버에만)\nconst start = await api.checkout.startPayment(checkoutId, { option, returnUrl });\n\n// 브라우저: 결제창 열기\nconst payments = paymentsFor(config);\nawait payments.open(paymentStartSchema.parse(JSON.parse(start)), { window });",
+		doc: "/guides/checkout-flow",
+		templateFile: "src/lib/payments.ts"
+	},
+	{
+		id: "payment-popup-prepare",
+		title: "결제 시작이 서버 함수를 거치면 클릭 시점에 `payments.prepareWindow()`로 창을 먼저 연다",
+		why: "팝업은 사용자 클릭에서 동기로 열어야 차단되지 않는다. 서버 응답을 기다린 뒤 열면 브라우저가 막아 결제가 시작되지 않는다",
+		fix: "클릭 핸들러 첫 줄에서 `payments.prepareWindow()`로 빈 창을 열고, 서버 함수가 끝나면 그 핸들을 `payments.open(start, { window })`에 넘긴다. 결제 시작이 실패하면 `window.close()`로 닫는다",
+		example: "const paymentWindow = payments.prepareWindow(); // 클릭 시점에 먼저 연다\nconst { start, error } = await startPayment({ data });\nif (!start) {\n  paymentWindow.close();\n  return;\n}\nawait payments.open(parsed, { window: paymentWindow });",
+		doc: "/guides/checkout-flow",
+		templateFile: "src/routes/checkout.index.tsx"
+	},
+	{
+		id: "payment-return-route",
+		title: "결제 복귀 화면에서 `payments.result()`로 결과를 읽는다",
+		why: "모바일·팝업 차단은 리다이렉트 결제다. 결제 서비스가 복귀 주소로 돌려보내므로 복귀 화면이 결제 상태를 확인하지 않으면 결제한 구매자가 결과를 볼 수 없다",
+		fix: "복귀 주소의 경로(`/checkout/return`)에 화면을 만들고 effect에서 `payments.result(window.location.href)`를 부른다. 주소의 `sayrenPaymentId`는 지우지 않는다(SDK가 읽는다)",
+		example: "useEffect(() => {\n  void payments.result(window.location.href).then((result) => {\n    if (result.status === \"COMPLETED\") navigate({ to: \"/checkout/complete\", search: { orderId: result.orderId } });\n  });\n}, []);",
+		doc: "/guides/checkout-flow",
+		templateFile: "src/routes/checkout.return.tsx"
+	},
+	{
+		id: "payment-processing-status",
+		title: "결과 확인 중(`PROCESSING`)이면 결제 상태를 다시 조회한다",
+		why: "결과를 아직 모를 때 실패로 안내하면 구매자가 다시 결제해 이중 결제가 난다. 확정될 때까지 `payments.result()`·`payments.getStatus()`로 확인한다",
+		fix: "`PROCESSING`은 실패로 다루지 않는다. 안내 문구를 띄운 채 몇 초 간격으로 다시 조회하고, 그래도 모르면 주문 내역을 확인하라고 안내한다(재결제 버튼을 주지 않는다)",
+		example: "if (result.status === \"PROCESSING\") {\n  setView({ kind: \"processing\" }); // 실패로 단정하지 않는다\n  await new Promise((r) => setTimeout(r, 2000));\n  const next = await payments.getStatus(result.paymentId);\n}",
+		doc: "/guides/checkout-flow",
+		templateFile: "src/routes/checkout.return.tsx"
+	},
+	{
+		id: "payment-amounts-final",
+		title: "결제 시작 응답의 `amounts`를 확정 금액으로 반영한다",
+		why: "주문서를 만들 때는 배송지를 몰라 제주·도서산간 추가 배송비가 빠져 있다. 결제 시작 응답이 보낸 배송지로 배송비를 다시 계산한 확정 금액이라, 화면에 반영하지 않으면 결제창 금액과 화면 금액이 어긋난다",
+		fix: "`payments.open()`에 넘기기 전에 결제 시작 값의 `amounts`·`delivery`로 화면 금액을 갱신한다",
+		example: "const paymentStart = paymentStartSchema.parse(JSON.parse(start));\n// 확정 금액 — 서버가 보낸 배송지로 배송비를 다시 계산했다\nsetQuote({ amounts: paymentStart.amounts, delivery: paymentStart.delivery });\nawait payments.open(paymentStart, { window: paymentWindow });",
+		doc: "/guides/shipping-fees",
+		templateFile: "src/routes/checkout.index.tsx"
+	},
+	{
+		id: "payment-retry",
+		title: "결제가 실패·취소되면 같은 결제를 다른 결제 옵션으로 다시 시도하게 한다(`payments.retry`)",
+		why: "카드 거절·결제창 닫기 뒤에 주문서를 처음부터 다시 쓰게 하면 구매자가 이탈한다. 같은 결제에서 다른 결제사·결제수단으로 바꾸는 길이 있어야 한다",
+		fix: "복귀 화면의 실패·취소 결과(`CANCELED`·`FAILED`)에서 결제 옵션 목록을 보여 주고, 누르면 클릭 핸들러에서 `payments.retry(result.paymentId, { option })`를 부른다. 옵션은 주문서가 결제창을 열기 전에 결제 id별로 남겨 둔다",
+		example: "if (result.status === \"FAILED\" || result.status === \"CANCELED\") {\n  // 버튼 클릭 핸들러에서 바로 부른다 — 팝업은 클릭 시점에 열어야 한다\n  await payments.retry(result.paymentId, { option });\n}",
+		doc: "/guides/checkout-flow",
+		templateFile: "src/routes/checkout.return.tsx"
+	},
+	{
+		id: "checkout-origin",
+		title: "복귀 주소는 코드에 고정하지 않고 배포된 주소(요청 origin)에서 만든다",
+		why: "주소를 코드에 고정하면 로컬·스테이징·운영 중 한 곳에서만 결제가 제대로 돌아온다. 셀러 콘솔 설정 › 결제의 결제 도메인은 선택형 허용 목록이다. 비워 두면 https 복귀 주소를 모두 받고, 등록하면 목록 밖의 복귀 주소를 서버가 거절한다",
+		fix: "서버 함수에서 `getRequestUrl()`의 origin으로 복귀 주소를 만든다. 결제 도메인을 등록해 두었다면 배포 도메인도 목록에 넣는다(테스트 결제는 localhost가 항상 허용된다)",
+		example: "const returnUrl = new URL(PAYMENT_RETURN_PATH, new URL(getRequestUrl()).origin);\nawait api.checkout.startPayment(checkoutId, { option, returnUrl: returnUrl.toString() });",
+		doc: "/guides/payment-settings",
+		templateFile: "src/routes/checkout.index.tsx"
+	},
+	{
+		id: "delivery-quote-preview",
+		title: "우편번호를 받으면 `checkout.quoteDelivery`로 배송비를 다시 계산해 보여 준다",
+		why: "주문서의 배송비는 배송지를 모르는 값이다. 미리 보여 주지 않으면 결제 버튼의 금액과 결제창 금액이 달라져 구매자가 결제를 중단한다",
+		fix: "우편번호 입력이 끝나면(blur) 서버 함수로 `checkout.quoteDelivery(checkoutId, { zipCode })`를 부르고 응답의 `amounts`·`delivery`로 화면 금액을 갱신한다. 주문서를 바꾸지 않는 읽기 계산이다",
+		example: "const quote = await api.checkout.quoteDelivery(checkoutId, { zipCode });\nsetQuote(quote); // amounts.totalAmount · delivery.remoteSurcharge를 화면에 쓴다",
+		doc: "/guides/shipping-fees",
+		templateFile: "src/routes/checkout.index.tsx"
+	},
+	{
+		id: "buyer-token-cookie",
+		title: "구매자 토큰 쌍은 서버에서 HttpOnly 쿠키에 담는다",
+		why: "브라우저 JS나 `localStorage`에 둔 토큰은 스크립트 하나로 새 나간다. 리프레시 토큰이 새면 그 구매자 계정으로 계속 로그인된다",
+		fix: "로그인·가입·소셜 콜백을 서버 함수·서버 라우트에서 처리하고 받은 토큰 쌍을 `httpOnly` 쿠키 하나에 담는다. 브라우저 저장소에 토큰을 쓰지 않고, 인증 모듈(`@sayren/storefront-sdk/auth`)은 `*.server.ts`에서만 만든다. 프로덕션에서는 쿠키 이름에 `__Host-` 접두사를 붙이고 `secure`·`path: \"/\"`로 쓴다(`Domain`은 주지 않는다). 같은 상위 도메인의 다른 사이트가 심은 쿠키로 세션이 바뀌지 않는다",
+		example: "// 프로덕션은 __Host- 접두사 — Secure·Path=/·Domain 없음일 때만 브라우저가 받는다\nconst name = import.meta.env.PROD ? \"__Host-sayren_member\" : \"sayren_member\";\nsetCookie(name, JSON.stringify({ accessToken, refreshToken, expiresAt }), {\n  httpOnly: true,\n  sameSite: \"lax\",\n  path: \"/\",\n  secure: import.meta.env.PROD,\n});",
+		doc: "/guides/storefront-auth",
+		templateFile: "src/lib/cookies.server.ts"
+	},
+	{
+		id: "buyer-session-refresh",
+		title: "액세스 토큰은 만료 전에 리프레시 토큰으로 갱신한다",
+		why: "액세스 토큰은 30분이다. 갱신하지 않으면 구매자가 장바구니·주문서에서 갑자기 로그아웃된다. 리프레시 토큰은 한 번 쓰면 폐기되므로 같은 토큰으로 동시에 갱신하면 늦은 쪽이 401을 받는다",
+		fix: "전역 요청 미들웨어에서 요청마다 만료를 보고 만료 1분 전이면 `auth.refresh(refreshToken)`로 새 쌍을 받아 쿠키를 갈아 끼운다. 같은 리프레시 토큰의 동시 갱신은 프로세스 안에서 한 번으로 모은다. 401이면 쿠키를 지우고, 네트워크 오류·5xx면 지우지 않는다",
+		example: "if (stored.expiresAt - 60_000 <= Date.now()) {\n  const tokens = await refreshOnce(stored.refreshToken); // 같은 토큰은 한 번만\n  writeSession(tokens);\n}",
+		doc: "/guides/storefront-auth",
+		templateFile: "src/lib/session.server.ts"
+	},
+	{
+		id: "buyer-reconsent",
+		title: "`reconsentRequired`가 true면 재동의를 받는다",
+		why: "약관·개인정보 처리방침이 개정되면 이전 동의는 최신본 동의가 아니다. 화면이 재동의를 받지 않으면 동의 이력이 최신본으로 남지 않는다",
+		fix: "`member.consents()`(또는 `member.me()`)의 `reconsentRequired`를 읽어 true면 개정된 문서 링크와 재동의 버튼을 보여 주고, 누르면 `member.updateConsents({ terms: true, privacy: true })`를 부른다",
+		example: "const consents = await api.member.consents();\nif (consents.reconsentRequired) {\n  // 개정 문서 링크(currentDocumentUrl)를 보여 주고 동의를 받는다\n  await api.member.updateConsents({ terms: true, privacy: true });\n}",
+		doc: "/guides/storefront-auth",
+		templateFile: "src/routes/account.tsx"
+	},
+	{
+		id: "buyer-signup",
+		title: "이메일·비밀번호 로그인을 받으면 가입 화면도 둔다(`auth.signUp`)",
+		why: "비밀번호 로그인만 있고 가입이 없으면 소셜 로그인을 켜지 않은 스토어에서 새 구매자가 계정을 만들 수 없다",
+		fix: "스토어 `loginMethods`에 `password`가 있으면 가입 화면을 둔다. 약관·개인정보 수집이용 동의(필수)와 마케팅 수신(선택)을 받아 서버 함수에서 `auth.signUp({ email, password, name, agreements, cartToken })`을 부르고, 받은 토큰 쌍을 HttpOnly 쿠키에 담는다",
+		example: "const tokens = await authFor().signUp({\n  email, password, name,\n  agreements: { terms: true, privacy: true, marketing },\n  cartToken: readCartToken() ?? undefined, // 비회원 장바구니를 합친다\n});\nsignIn(tokens);",
+		doc: "/guides/storefront-auth",
+		templateFile: "src/routes/signup.tsx"
+	},
+	{
+		id: "buyer-signout",
+		title: "로그아웃은 서버에서 리프레시 토큰을 폐기하고 쿠키를 지운다(`auth.signOut`)",
+		why: "쿠키만 지우면 새 나간 리프레시 토큰이 14일 동안 계속 살아 있다. 로그아웃 화면이 없으면 공용 기기에서 계정을 닫을 방법이 없다",
+		fix: "계정 화면에 로그아웃을 두고, 서버 함수에서 `auth.signOut(accessToken)`을 부른 뒤 세션 쿠키를 지운다. 탈퇴(`auth.withdraw`)도 같은 화면에 둔다",
+		example: "const logout = createServerFn({ method: \"POST\" }).handler(async () => {\n  const accessToken = readToken();\n  if (accessToken) await authFor().signOut(accessToken).catch(() => undefined);\n  clearSessionCookie();\n});",
+		doc: "/guides/storefront-auth",
+		templateFile: "src/routes/account.tsx"
+	},
+	{
+		id: "analytics-start",
+		title: "방문 분석은 브라우저에서 한 번 시작한다(`@sayren/storefront-sdk/analytics`)",
+		why: "빠지면 셀러 콘솔 애널리틱스가 비어 있다. 서버 파일에서 부르면 아무것도 하지 않는다",
+		fix: "루트 컴포넌트의 effect에서 `createAnalytics`를 한 번 부르고(설정은 loader가 내려준다), 화면은 그 인스턴스의 `track`으로 행동을 남긴다. 장바구니·결제 시작·구매는 서버가 기록하므로 보내지 않는다",
+		example: "import { createAnalytics } from \"@sayren/storefront-sdk/analytics\";\n\nuseEffect(() => {\n  startAnalytics({ apiBaseUrl, storeCode, debug }); // 브라우저에서 한 번\n}, []);",
+		doc: "/guides/storefront-analytics",
+		templateFile: "src/lib/analytics.ts"
+	},
+	{
+		id: "analytics-ids",
+		title: "서버의 API 클라이언트에 방문 식별 쿠키를 싣는다(`analyticsIdsFromCookie`)",
+		why: "빠지면 장바구니·결제 시작·구매가 방문과 이어지지 않아 퍼널과 유입별 매출에서 빠진다",
+		fix: "서버 함수에서 API 클라이언트를 만들 때 요청 쿠키를 `analyticsIdsFromCookie`로 풀어 함께 넘긴다",
+		example: "createStorefrontClient({\n  baseUrl: API_BASE_URL,\n  storeCode: resolveStoreCode(),\n  ...analyticsIdsFromCookie(getRequestHeader(\"cookie\")),\n});",
+		doc: "/guides/storefront-analytics",
+		templateFile: "src/lib/api.server.ts"
+	},
+	{
+		id: "custom-input-private",
+		title: "직접 입력값은 서버 함수 본문으로만 보낸다(URL·브라우저 저장소·로그 금지)",
+		why: "각인 문구·선물 메시지 같은 직접 입력값에는 이름·연락처 같은 개인정보가 섞인다. URL 검색 파라미터에 실으면 방문 기록·서버 접근 로그·리퍼러로 새고, 브라우저 저장소에 두면 같은 기기의 다른 사람이 읽는다",
+		fix: "담기·바로구매는 서버 함수 본문으로 `customInputs`를 보낸다. 바로구매처럼 주문서 진입 조건을 들고 다녀야 하면 URL에는 표시(`direct=1`)만 두고 값은 서버가 짧게 사는 HttpOnly 쿠키에 담은 뒤 주문서를 만들면 지운다. `localStorage`·`sessionStorage`·`console.log`에 입력값을 쓰지 않는다",
+		example: "// 서버 함수 본문으로 보낸다\nawait addToCart({ data: { productId, optionId, quantity, addons, customInputs } });\n\n// 바로구매 — 값은 HttpOnly 쿠키, 주소에는 표시만\nwriteDirectLine(line); // 서버 함수 안\nnavigate({ to: \"/checkout\", search: { direct: 1, productId } });",
+		doc: "/guides/product-options",
+		templateFile: "src/lib/direct-checkout.server.ts"
+	}
+];
+/**
+* 주석을 걷어낸다 — 규칙을 설명하는 주석이 위반으로 잡히지 않게 한다.
+* 줄 번호를 알려 주려면 줄 수가 보존돼야 해서 블록 주석은 개행만 남긴다.
+*/
+function stripComments(source) {
+	return source.replace(/\/\*[\s\S]*?\*\//g, (block) => block.replace(/[^\n]/g, " ")).replace(/(^|[^:])\/\/[^\n]*/g, "$1 ");
+}
+/** 패턴이 처음 걸린 줄 번호(1부터). 없으면 undefined */
+function lineOf(content, pattern) {
+	const match = new RegExp(pattern.source, pattern.flags.replace(/[gy]/g, "")).exec(content);
+	if (!match) return void 0;
+	return content.slice(0, match.index).split("\n").length;
+}
+const CLIENT_FILE = /\.(ts|tsx)$/;
+const SERVER_FILE = /\.server\.(ts|tsx)$/;
+/** 토큰을 브라우저 저장소에 쓰는 코드 */
+const BROWSER_TOKEN_STORAGE = /(localStorage|sessionStorage)\.setItem\(\s*[`'"][^`'"]*([Tt]oken|refresh|session|sayren_member)/;
+/**
+* 직접 입력값이 새는 자리 — URL 검색 파라미터(`search`·`searchParams`), 브라우저 저장소, 콘솔.
+* 같은 식 안에서 `customInputs`가 보일 때만 잡는다.
+*/
+const CUSTOM_INPUT_LEAKS = [
+	[/search\s*[:=]\s*\{\{?[^}]*\bcustomInputs\b/, "URL 검색 파라미터"],
+	[/searchParams\.(set|append)\([^)]*\bcustomInputs\b/, "URL 검색 파라미터"],
+	[/(localStorage|sessionStorage)\.setItem\([^)]*\bcustomInputs\b/, "브라우저 저장소"],
+	[/console\.(log|info|warn|error|debug)\([^)]*\bcustomInputs\b/, "콘솔 로그"]
+];
+/**
+* 만들어진 프로젝트의 소스를 규칙과 대조한다. 정적 검사라 모든 문제를 잡지는 못하지만,
+* 여기 있는 것들은 실제로 반복해서 깨지는 것들이다.
+*/
+function verifySources(files) {
+	const findings = [];
+	const cleaned = files.map((file) => ({
+		path: file.path,
+		content: stripComments(file.content)
+	}));
+	const has = (needle) => cleaned.some((file) => file.content.includes(needle));
+	const matches = (pattern) => cleaned.find((file) => pattern.test(file.content));
+	/** 파일 한 곳의 위반. `at`이 있으면 그 패턴이 걸린 줄을 싣는다 */
+	const inFile = (ruleId, file, detail, at) => {
+		findings.push({
+			ruleId,
+			file: file.path,
+			line: at ? lineOf(file.content, at) : void 0,
+			detail
+		});
+	};
+	/** 프로젝트 전체를 보고 판정한 위반 — 고칠 자리는 규칙의 `templateFile`이 알려 준다 */
+	const inProject = (ruleId, detail) => {
+		findings.push({
+			ruleId,
+			file: "(프로젝트 전체)",
+			detail
+		});
+	};
+	for (const file of cleaned) {
+		if (!CLIENT_FILE.test(file.path)) continue;
+		const isServer = SERVER_FILE.test(file.path) || /\/(server|\.server)\//.test(file.path);
+		const env = /process\.env\.[A-Z_]/;
+		if (!isServer && env.test(file.content)) inFile("server-only-env", file, "브라우저로 갈 수 있는 파일에서 process.env를 읽는다. `*.server.ts`로 옮긴다", env);
+		if (/createStorefrontClient\(/.test(file.content) && !/storeCode/.test(file.content)) inFile("tenant-header", file, "API 클라이언트를 만들 때 storeCode를 주지 않는다", /createStorefrontClient\(/);
+		const moduleToken = /^(const|let)\s+\w*[Tt]oken\s*=\s*["'`]|^let\s+[\w$]*[Tt]oken\b/m;
+		if (moduleToken.test(file.content)) inFile("no-module-token", file, "토큰처럼 보이는 값을 모듈 전역에 두었다", moduleToken);
+		const paymentsImport = /@sayren\/storefront-sdk\/payments/;
+		if (isServer && paymentsImport.test(file.content)) inFile("payment-browser-launch", file, "서버 파일에서 결제 모듈을 쓴다. 결제창(`start`·`open`)과 복귀 처리(`result`)는 브라우저(컴포넌트·effect)에서 부른다", paymentsImport);
+		const authFactory = /createStorefrontAuth\(/;
+		if (!isServer && authFactory.test(file.content)) inFile("buyer-token-cookie", file, "브라우저로 갈 수 있는 파일에서 인증 모듈을 만든다. 토큰 쌍이 브라우저 JS에 노출된다 — `*.server.ts`로 옮기고 HttpOnly 쿠키에 담는다", authFactory);
+		if (BROWSER_TOKEN_STORAGE.test(file.content)) inFile("buyer-token-cookie", file, "토큰을 브라우저 저장소(localStorage·sessionStorage)에 쓴다. 서버에서 HttpOnly 쿠키에 담는다", BROWSER_TOKEN_STORAGE);
+		const cookieWrite = /setCookie\(/;
+		if (cookieWrite.test(file.content) && /refreshToken/.test(file.content) && !/httpOnly/.test(file.content)) inFile("buyer-token-cookie", file, "토큰 쌍을 쿠키에 담는데 `httpOnly`가 없다. 브라우저 JS가 읽을 수 있다", cookieWrite);
+		const cookieDomain = /\bdomain\s*:/;
+		if (cookieWrite.test(file.content) && cookieDomain.test(file.content)) inFile("buyer-token-cookie", file, "서버 쿠키에 `domain`을 준다. 호스트 전용 쿠키로 두고(`domain` 생략) 프로덕션은 `__Host-` 접두사를 붙인다", cookieDomain);
+		for (const [pattern, where] of CUSTOM_INPUT_LEAKS) if (pattern.test(file.content)) {
+			inFile("custom-input-private", file, `직접 입력값(\`customInputs\`)을 ${where}에 싣는다. 서버 함수 본문으로 보내고, 바로구매는 HttpOnly 쿠키에 둔다`, pattern);
+			break;
+		}
+		const analyticsFactory = /createAnalytics\(/;
+		if (isServer && analyticsFactory.test(file.content)) inFile("analytics-start", file, "서버 파일에서 방문 분석을 시작한다. 서버에서는 아무것도 하지 않으니 브라우저(effect)에서 부른다", analyticsFactory);
+		if (isServer && /createStorefrontClient\(/.test(file.content) && !/analyticsIdsFromCookie|visitorId/.test(file.content)) inFile("analytics-ids", file, "서버 API 클라이언트에 방문 식별자가 없다. `...analyticsIdsFromCookie(request.headers.get(\"cookie\"))`를 넘긴다", /createStorefrontClient\(/);
+	}
+	if (has("startPayment(") && !has("@sayren/storefront-sdk/payments")) inProject("payment-browser-launch", "결제를 시작하지만 `@sayren/storefront-sdk/payments`로 결제창을 여는 코드가 없다");
+	const opensPayment = matches(/\bpayments\.open\(|\.open\(\s*(start|paymentStart)\b/);
+	if (opensPayment && !has("prepareWindow(")) inFile("payment-popup-prepare", opensPayment, "받아 둔 결제 시작 값으로 결제창을 열지만 클릭 시점에 `payments.prepareWindow()`로 창을 먼저 여는 코드가 없다", /\bpayments\.open\(|\.open\(\s*(start|paymentStart)\b/);
+	if (opensPayment && !/amounts/.test(opensPayment.content)) inFile("payment-amounts-final", opensPayment, "결제창을 열지만 결제 시작 응답의 `amounts`(확정 금액)를 화면에 반영하지 않는다", /\bpayments\.open\(/);
+	const fixedReturnUrl = matches(/returnUrl\s*[:=]\s*["'`]https?:\/\//);
+	if (fixedReturnUrl) inFile("checkout-origin", fixedReturnUrl, "복귀 주소를 고정 문자열로 두었다. 배포된 주소(요청 origin)에서 만든다", /returnUrl\s*[:=]\s*["'`]https?:\/\//);
+	if (has("startPayment(") && !has(".result(")) inProject("payment-return-route", "결제 복귀 화면에서 `payments.result()`를 부르는 코드가 없다");
+	if (has(".result(") && !matches(/\bpayments\.retry\(|\.retry\(\s*[\w.]*paymentId\b/)) inProject("payment-retry", "결제 복귀 화면에서 실패·취소 뒤 `payments.retry()`로 다른 결제 옵션을 다시 시도하는 코드가 없다");
+	if (has(".result(") && !has("PROCESSING")) inProject("payment-processing-status", "결과 확인 중(`PROCESSING`)일 때 결제 상태를 다시 조회하는 코드가 없다");
+	if (has("startPayment(") && has("zipCode") && !has("quoteDelivery(")) inProject("delivery-quote-preview", "배송지 우편번호를 받지만 `checkout.quoteDelivery`로 배송비를 다시 계산하는 코드가 없다");
+	if (has("createStorefrontAuth(")) {
+		const cookieFiles = cleaned.filter((file) => /setCookie\(/.test(file.content));
+		if (cookieFiles.length > 0 && !cookieFiles.some((file) => /httpOnly\s*:\s*true/.test(file.content))) inProject("buyer-token-cookie", "구매자 로그인을 쓰는데 서버 쿠키를 `httpOnly: true`로 쓰는 코드가 없다. 토큰 쌍이 브라우저 JS에 노출된다");
+		if (!has(".refresh(")) inProject("buyer-session-refresh", "로그인은 하지만 액세스 토큰을 갱신하는 코드가 없다(`auth.refresh(refreshToken)`)");
+		if (has(".session(") && !has(".signUp(")) inProject("buyer-signup", "이메일·비밀번호 로그인(`auth.session`)은 있지만 가입(`auth.signUp`)을 부르는 코드가 없다");
+		if (!matches(/\b(auth|authFor\(\))\.signOut\(|\.signOut\(\s*accessToken\b/)) inProject("buyer-signout", "로그아웃에서 리프레시 토큰을 폐기하는 코드가 없다(`auth.signOut(accessToken)`)");
+		if (!has("reconsentRequired")) inProject("buyer-reconsent", "재동의가 필요한 구매자를 처리하는 코드가 없다(`reconsentRequired`)");
+	}
+	if (has("createStorefrontClient(") && !has("@sayren/storefront-sdk/analytics")) inProject("analytics-start", "방문 분석을 시작하는 코드가 없다. `@sayren/storefront-sdk/analytics`의 createAnalytics를 브라우저에서 한 번 부른다");
+	const clientQuery = matches(/\buse(Suspense)?Query\(/);
+	if (clientQuery && !has("ensureQueryData(") && !has("prefetchQuery(")) inFile("loader-first", clientQuery, "TanStack Query로 데이터를 받지만 loader에서 `queryClient.ensureQueryData`로 미리 받는 코드가 없다. 서버 렌더에 데이터가 빠진다", /\buse(Suspense)?Query\(/);
+	if (has("createStorefrontClient(") && !has("loader")) inProject("loader-first", "loader에서 데이터를 받는 코드가 없다. 클라이언트 전용으로 그리면 SSR이 죽는다");
+	return findings;
+}
+
+//#endregion
+//#region ../mcp/src/verify-report.ts
+const ruleOf = (ruleId) => RULES.find((rule) => rule.id === ruleId);
+function report(finding) {
+	const rule = ruleOf(finding.ruleId);
+	return {
+		ruleId: finding.ruleId,
+		rule: rule?.title ?? finding.ruleId,
+		file: finding.file,
+		...finding.line === void 0 ? {} : { line: finding.line },
+		detail: finding.detail,
+		cause: rule?.why ?? "",
+		fix: rule?.fix ?? "",
+		example: rule?.example ?? "",
+		doc: rule?.doc ?? "",
+		docUrl: rule ? docUrl(rule.doc) : "",
+		...rule?.templateFile ? { templateFile: rule.templateFile } : {}
+	};
+}
+/** 위반을 고치는 순서 — 에이전트가 무엇부터 할지 묻지 않게 한다 */
+function nextSteps(findings, target) {
+	if (!findings.length) return target === "remote" ? [
+		"사용자에게 콘솔 스토어프론트 공간의 [미리보기 열기]로 화면을 확인해 달라고 전한다.",
+		"`create_version`으로 버전을 만들고 `get_build`로 빌드 결과를 확인한다.",
+		"정적 검사가 잡지 못하는 것은 실제 결제 한 번이 잡는다. 발행 전에 테스트 결제를 권한다."
+	] : [
+		"개발 서버를 띄워 홈에 상품이 보이는지 확인한다.",
+		"테스트 결제로 주문을 한 번 만들어 주문 완료 화면까지 간다.",
+		"정적 검사가 잡지 못하는 것은 실제 결제 한 번이 잡는다."
+	];
+	const files = [...new Set(findings.map((finding) => finding.templateFile).filter(Boolean))];
+	const templateHint = target === "remote" ? `손대지 않아야 하는 파일을 고친 결과일 수 있다 — ${files.join(", ")}을(를) \`read_file\`로 읽어 규칙의 \`example\`과 대조하고 되돌린다.` : `손대지 않아야 하는 파일을 고친 결과일 수 있다 — \`get_template_file\`로 ${files.join(", ")}의 원본을 받아 대조한다.`;
+	return [
+		"위반마다 `fix`대로 고친다. `file`·`line`이 고칠 자리이고 `example`이 옳은 쪽 코드다.",
+		...files.length ? [templateHint] : [],
+		target === "remote" ? "고친 뒤 `verify_site`를 다시 부른다. 위반이 남으면 버전 빌드가 규칙 단계(`VERIFY`)에서 실패한다." : "고친 뒤 `verify_storefront`를 다시 부른다.",
+		"규칙 배경이 더 필요하면 위반의 `docUrl` 문서를 읽는다."
+	];
+}
+/** 소스를 규칙과 대조해 고칠 수 있는 보고서로 만든다 */
+function buildReport(files, target = "local") {
+	return reportFromFindings(verifySources(files), files.length, target);
+}
+/**
+* 이미 찾은 위반으로 보고서를 만든다. 원격은 api가 작업 트리에서 `verifySources`를 돌려 위반만 돌려주고, 원인·수정
+* 방법·예시는 이 패키지의 규칙 정의로 채운다.
+*/
+function reportFromFindings(findings, checkedFiles, target = "local") {
+	const counts = /* @__PURE__ */ new Map();
+	for (const finding of findings) counts.set(finding.ruleId, (counts.get(finding.ruleId) ?? 0) + 1);
+	const results = RULES.map((rule) => ({
+		ruleId: rule.id,
+		status: counts.has(rule.id) ? "violation" : "pass",
+		count: counts.get(rule.id) ?? 0
+	}));
+	const violated = results.filter((result) => result.status === "violation").length;
+	const reported = findings.map(report);
+	return {
+		ok: findings.length === 0,
+		checkedFiles,
+		summary: {
+			rules: RULES.length,
+			passed: RULES.length - violated,
+			violated,
+			findings: findings.length
+		},
+		results,
+		findings: reported,
+		message: findings.length ? `규칙 ${RULES.length}개 중 ${violated}개를 어겼습니다(위반 ${findings.length}건). 아래 findings의 fix대로 고친 뒤 다시 검사해주십시오` : `규칙 ${RULES.length}개를 모두 지켰습니다. 정적 검사가 잡지 못하는 것이 있으니 직접 띄워 결제까지 한 번 해보십시오`,
+		nextSteps: nextSteps(reported, target)
+	};
+}
+
+//#endregion
+//#region ../hosting-sandbox/src/hash.ts
+const strictUtf8 = new TextDecoder("utf-8", {
+	fatal: true,
+	ignoreBOM: true
+});
+/** 유효한 UTF-8이면 문자열, 아니면 null */
+function asUtf8(bytes) {
+	try {
+		return strictUtf8.decode(bytes);
+	} catch {
+		return null;
+	}
+}
+
+//#endregion
+//#region ../hosting-sandbox/src/verify.ts
+/**
+* 규칙 검증. 원천은 `@sayren/mcp`의 규칙(apps/mcp/src/rules.ts)과 보고서(verify-report.ts)다 — stdio `verify_storefront`와
+* 같은 함수를 Worker가 직접 돌린다(컨테이너가 필요 없다). 대상은 stdio와 같은 소스 확장자다.
+*/
+const SOURCE_RE = /\.(ts|tsx|js|jsx)$/;
+function verifyTree(files) {
+	return buildReport([...files].filter(([path]) => SOURCE_RE.test(path)).sort(([a], [b]) => a < b ? -1 : 1).flatMap(([path, bytes]) => {
+		const content = asUtf8(bytes);
+		return content === null ? [] : [{
+			path,
+			content
+		}];
+	}), "remote");
+}
+
+//#endregion
+//#region ../hosting-sandbox/src/paths.ts
+const MAX_FILE_BYTES = 1024 * 1024;
+const MAX_TREE_BYTES = 20 * 1024 * 1024;
+const MAX_TREE_FILES = 2e3;
+const MAX_PATH_LENGTH = 256;
+const MAX_DEPTH = 16;
+const SEGMENT_RE = /^[A-Za-z0-9$_.()[\]@+=,-]+$/;
+/** 어디에 있든 금지 — 설치물·산출물·캐시·VCS */
+const FORBIDDEN_SEGMENTS = new Set([
+	"node_modules",
+	"dist",
+	".tanstack",
+	".git",
+	".wrangler",
+	".output",
+	".nitro",
+	".vinxi"
+]);
+/** 쓸 수 있는 루트 파일 */
+const WRITABLE_ROOT_FILES = new Set([
+	"README.md",
+	"tsconfig.json",
+	"vite.config.ts",
+	"vitest.config.ts",
+	"biome.json",
+	".gitignore"
+]);
+/** 읽기만 되는 루트 파일 — 의존성은 전용 경로로만 바꾼다(레지스트리 프록시와 잠금 파일을 함께 맞춘다) */
+const READONLY_ROOT_FILES = new Set(["package.json", "pnpm-lock.yaml"]);
+const WRITABLE_DIRS = new Set(["src", "public"]);
+/** 형식·금지 세그먼트만 본다(위치 규칙은 보지 않는다). 통과하면 null, 아니면 이유 */
+function formatProblem(path) {
+	if (typeof path !== "string" || path.length === 0) return "empty";
+	if (path.length > MAX_PATH_LENGTH) return "too-long";
+	if (path.startsWith("/")) return "absolute";
+	const segments = path.split("/");
+	if (segments.length > MAX_DEPTH) return "too-deep";
+	for (const seg of segments) {
+		if (seg === "" || seg === "." || seg === "..") return "dot-segment";
+		if (!SEGMENT_RE.test(seg)) return "characters";
+		if (FORBIDDEN_SEGMENTS.has(seg)) return "forbidden-segment";
+		if (seg.startsWith(".env")) return "env-file";
+	}
+	return null;
+}
+/** 위치 규칙: 어떤 모드로 이 경로에 닿을 수 있는가 */
+function accessOf(path) {
+	if (formatProblem(path) !== null) return null;
+	const segments = path.split("/");
+	const [first] = segments;
+	if (!first) return null;
+	if (segments.length === 1) {
+		if (WRITABLE_ROOT_FILES.has(first)) return "write";
+		if (READONLY_ROOT_FILES.has(first)) return "read";
+		return null;
+	}
+	if (!WRITABLE_DIRS.has(first)) return null;
+	if (segments.some((s) => s.startsWith("."))) return null;
+	return "write";
+}
+
+//#endregion
+//#region ../hosting-sandbox/src/tar.ts
+const BLOCK = 512;
+const enc = new TextEncoder();
+const dec = new TextDecoder();
+function readString(buf, offset, length) {
+	let end = offset;
+	while (end < offset + length && buf[end] !== 0) end++;
+	return dec.decode(buf.subarray(offset, end));
+}
+function readOctal(buf, offset, length) {
+	const s = readString(buf, offset, length).trim();
+	if (!s) return 0;
+	if (!/^[0-7]+$/.test(s)) throw new Error("tar 숫자 필드 형식 오류");
+	return Number.parseInt(s, 8);
+}
+function parsePax(text) {
+	const out = {};
+	let i = 0;
+	while (i < text.length) {
+		const sp = text.indexOf(" ", i);
+		if (sp < 0) break;
+		const len = Number(text.slice(i, sp));
+		if (!Number.isInteger(len) || len <= 0) break;
+		const record = text.slice(sp + 1, i + len - 1);
+		const eq = record.indexOf("=");
+		if (eq > 0) out[record.slice(0, eq)] = record.slice(eq + 1);
+		i += len;
+	}
+	return out;
+}
+/** tar 바이트 → 일반 파일 항목. `maxBytes`는 풀어낸 파일 합계 상한(압축 폭탄 방어) */
+function readTar(buf, maxBytes = Number.POSITIVE_INFINITY) {
+	const out = [];
+	let off = 0;
+	let longName = null;
+	let paxPath = null;
+	let total = 0;
+	while (off + BLOCK <= buf.length) {
+		const h = buf.subarray(off, off + BLOCK);
+		if (h.every((b) => b === 0)) break;
+		const size = readOctal(h, 124, 12);
+		const type = String.fromCharCode(h[156] ?? 0);
+		const dataStart = off + BLOCK;
+		const dataEnd = dataStart + size;
+		if (dataEnd > buf.length) throw new Error("tar가 잘렸습니다");
+		const data = buf.subarray(dataStart, dataEnd);
+		off = dataStart + Math.ceil(size / BLOCK) * BLOCK;
+		if (type === "L") {
+			longName = readString(data, 0, data.length);
+			continue;
+		}
+		if (type === "x") {
+			paxPath = parsePax(dec.decode(data)).path ?? null;
+			continue;
+		}
+		if (type === "g") continue;
+		let path = longName ?? paxPath;
+		longName = null;
+		paxPath = null;
+		if (path === null) {
+			const name = readString(h, 0, 100);
+			const prefix = readString(h, 345, 155);
+			path = prefix ? `${prefix}/${name}` : name;
+		}
+		if (type !== "0" && type !== "\0") continue;
+		while (path.startsWith("./")) path = path.slice(2);
+		if (!path) continue;
+		total += size;
+		if (total > maxBytes) throw new Error("tar 합계가 상한을 넘습니다");
+		out.push({
+			path,
+			bytes: data.slice()
+		});
+	}
+	return out;
+}
+/** gunzip. 풀린 크기가 `maxBytes`를 넘으면 멈춘다 */
+async function gunzip(bytes, maxBytes) {
+	const reader = new Blob([bytes]).stream().pipeThrough(new DecompressionStream("gzip")).getReader();
+	const chunks = [];
+	let total = 0;
+	for (;;) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		total += value.length;
+		if (total > maxBytes) {
+			await reader.cancel();
+			throw new Error("압축을 푼 크기가 상한을 넘습니다");
+		}
+		chunks.push(value);
+	}
+	const out = new Uint8Array(total);
+	let off = 0;
+	for (const c of chunks) {
+		out.set(c, off);
+		off += c.length;
+	}
+	return out;
+}
+
+//#endregion
+//#region src/config.ts
+/**
+* 설정 — 우선순위는 플래그 > 환경 변수(`SAYREN_TOKEN`·`SAYREN_API_ORIGIN`) > `.env` > `.sayrenrc`다.
+*
+* - `.sayrenrc`: pull이 만든다. 비밀이 없어 커밋해도 된다(`storeId`·`siteId`·`baseRef`, 기본이 아닌 api 주소).
+*   **토큰을 두지 않는다** — 읽을 때 `token` 같은 필드가 있으면 무시하고 경고한다.
+* - `.env`: 토큰(`SAYREN_TOKEN`)과 스토어프론트 템플릿이 읽는 값(`SAYREN_API_URL`·`SAYREN_STORE_CODE`). `.gitignore` 대상이다.
+*   템플릿은 `SAYREN_TOKEN`만 서버 코드 환경에 싣지 않는다(vite.config.ts).
+*/
+const RC_FILE = ".sayrenrc";
+const ENV_FILE = ".env";
+const DEFAULT_API_ORIGIN = "https://api.sayren.app";
+const RC_KEYS = [
+	"storeId",
+	"siteId",
+	"baseRef",
+	"apiOrigin"
+];
+function readRc(dir) {
+	const path = join(dir, RC_FILE);
+	if (!existsSync(path)) return null;
+	let parsed;
+	try {
+		parsed = JSON.parse(readFileSync(path, "utf8"));
+	} catch {
+		throw new CliError(`${RC_FILE}를 읽지 못했습니다. JSON 형식을 확인하십시오`);
+	}
+	if (!parsed || typeof parsed !== "object") throw new CliError(`${RC_FILE} 형식이 아닙니다`);
+	const rc = parsed;
+	for (const key of Object.keys(rc)) if (!RC_KEYS.includes(key)) console.warn(`경고: ${RC_FILE}의 ${key}는 쓰지 않습니다(토큰은 .env에 두십시오)`);
+	if (typeof rc.storeId !== "string" || typeof rc.siteId !== "string" || typeof rc.baseRef !== "string") throw new CliError(`${RC_FILE}에 storeId·siteId·baseRef가 없습니다. npx sayren pull로 다시 받으십시오`);
+	return {
+		storeId: rc.storeId,
+		siteId: rc.siteId,
+		baseRef: rc.baseRef,
+		...typeof rc.apiOrigin === "string" ? { apiOrigin: rc.apiOrigin } : {}
+	};
+}
+function writeRc(dir, rc) {
+	const out = {
+		storeId: rc.storeId,
+		siteId: rc.siteId,
+		baseRef: rc.baseRef
+	};
+	if (rc.apiOrigin && rc.apiOrigin !== DEFAULT_API_ORIGIN) out.apiOrigin = rc.apiOrigin;
+	writeFileSync(join(dir, RC_FILE), `${JSON.stringify(out, null, 2)}\n`);
+}
+/** `.env` 읽기 — `KEY=VALUE` 줄만(따옴표는 벗긴다). 없으면 빈 값 */
+function readEnvFile(dir) {
+	const path = join(dir, ENV_FILE);
+	const out = /* @__PURE__ */ new Map();
+	if (!existsSync(path)) return out;
+	for (const line of readFileSync(path, "utf8").split(/\r?\n/)) {
+		const m = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)\s*$/.exec(line);
+		if (!m?.[1]) continue;
+		let value = m[2] ?? "";
+		if (/^(['"]).*\1$/.test(value)) value = value.slice(1, -1);
+		out.set(m[1], value);
+	}
+	return out;
+}
+/** `.env`에 값들을 쓴다 — 다른 줄은 그대로 두고 같은 키만 바꾼다. 파일 권한은 600이다(토큰) */
+function updateEnvFile(dir, values) {
+	const path = join(dir, ENV_FILE);
+	const lines = existsSync(path) ? readFileSync(path, "utf8").split(/\r?\n/) : [];
+	const pending = new Map(Object.entries(values));
+	const next = lines.map((line) => {
+		const key = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/.exec(line)?.[1];
+		if (key && pending.has(key)) {
+			const value = pending.get(key);
+			pending.delete(key);
+			return `${key}=${value}`;
+		}
+		return line;
+	});
+	while (next.length > 0 && next[next.length - 1] === "") next.pop();
+	for (const [key, value] of pending) next.push(`${key}=${value}`);
+	writeFileSync(path, `${next.join("\n")}\n`, { mode: 384 });
+	try {
+		chmodSync(path, 384);
+	} catch {}
+}
+/** `.gitignore`에 `.env`가 없으면 더한다. 더했으면 true */
+function ensureGitignore(dir) {
+	const path = join(dir, ".gitignore");
+	const text = existsSync(path) ? readFileSync(path, "utf8") : "";
+	const lines = text.split(/\r?\n/).map((line) => line.trim());
+	if (lines.includes(".env") || lines.includes(".env*") || lines.includes("/.env")) return false;
+	writeFileSync(path, `${text}${text && !text.endsWith("\n") ? "\n" : ""}.env\n`);
+	return true;
+}
+/** 스토어프론트 API 주소(`…/storefront/v1`)에서 api origin을 읽는다 */
+function originOfStorefrontUrl(url) {
+	if (!url) return null;
+	return /^(https?:\/\/[^/]+)\/storefront\/v1\/?$/.exec(url.trim())?.[1] ?? null;
+}
+function resolveAuth(flags, dir, rc, env = process.env) {
+	const dotenv = readEnvFile(dir);
+	const fromFlag = flags.token?.trim();
+	const fromEnv = env.SAYREN_TOKEN?.trim();
+	const fromFile = dotenv.get("SAYREN_TOKEN")?.trim();
+	const token = fromFlag || fromEnv || fromFile;
+	if (!token) throw new CliError("토큰이 없습니다. --token으로 주거나 SAYREN_TOKEN 환경 변수·.env에 넣으십시오(셀러 콘솔 › 개발자 › API 토큰, 스코프 storefront:rw)");
+	const picked = [
+		["flag", flags.apiOrigin?.trim()],
+		["env", env.SAYREN_API_ORIGIN?.trim()],
+		[".env", originOfStorefrontUrl(dotenv.get("SAYREN_API_URL"))],
+		["rc", rc?.apiOrigin]
+	].find(([, value]) => value);
+	const apiOrigin = (picked?.[1] ?? DEFAULT_API_ORIGIN).replace(/\/+$/, "");
+	assertOriginShape(apiOrigin);
+	return {
+		token,
+		apiOrigin,
+		tokenSource: fromFlag ? "flag" : fromEnv ? "env" : ".env",
+		originSource: picked && apiOrigin !== DEFAULT_API_ORIGIN ? picked[0] : "default"
+	};
+}
+/** 로컬 개발 주소 — http를 받는다 */
+const LOOPBACK = new Set([
+	"localhost",
+	"127.0.0.1",
+	"[::1]"
+]);
+/** api 주소 형식 — https만 받는다(토큰을 싣고 보낸다). localhost·127.0.0.1만 http 예외다 */
+function assertOriginShape(origin) {
+	let url;
+	try {
+		url = new URL(origin);
+	} catch {
+		throw new CliError(`api 주소 형식이 아닙니다: ${origin}`);
+	}
+	const loopback = LOOPBACK.has(url.hostname);
+	if (url.protocol !== "https:" && !(loopback && url.protocol === "http:")) throw new CliError(`api 주소는 https여야 합니다(localhost만 http 예외): ${origin}. 토큰이 이 주소로 갑니다`);
+}
+/** 사용자에게 보여 줄 오류 — 스택 없이 문장만 찍고 종료 코드 1로 끝난다 */
+var CliError = class extends Error {
+	constructor(message, exitCode = 1) {
+		super(message);
+		this.exitCode = exitCode;
+		this.name = "CliError";
+	}
+};
+
+//#endregion
+//#region src/tree.ts
+/** 걸어 들어가지 않는 폴더 — 설치물·산출물·캐시·VCS(경로 규칙이 어차피 막는다. 크기 때문에 읽지도 않는다) */
+const SKIP_DIRS = new Set([
+	"node_modules",
+	"dist",
+	".output",
+	".tanstack",
+	".git",
+	".wrangler",
+	".nitro",
+	".vinxi",
+	".turbo",
+	".cache"
+]);
+const sha256Hex = (bytes) => createHash("sha256").update(bytes).digest("hex");
+function collectTree(root) {
+	const files = [];
+	const skipped = [];
+	const walk = (dir) => {
+		for (const entry of readdirSync(dir, { withFileTypes: true })) {
+			const full = join(dir, entry.name);
+			const rel = normalizeStorefrontPath(relative(root, full).split(sep).join("/"));
+			if (entry.isDirectory()) {
+				if (SKIP_DIRS.has(entry.name)) continue;
+				walk(full);
+				continue;
+			}
+			if (entry.isSymbolicLink() || !entry.isFile()) {
+				skipped.push(rel);
+				continue;
+			}
+			if (accessOf(rel) === null) {
+				skipped.push(rel);
+				continue;
+			}
+			const bytes = new Uint8Array(readFileSync(full));
+			files.push({
+				path: rel,
+				bytes,
+				hash: sha256Hex(bytes)
+			});
+		}
+	};
+	walk(root);
+	files.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+	return {
+		files,
+		skipped: skipped.sort(),
+		totalBytes: files.reduce((s, f) => s + f.bytes.length, 0)
+	};
+}
+/** 크기 한도 — 서버와 같다(파일 1MiB, 전체 20MiB·2,000개) */
+function limitProblems(tree) {
+	const out = [];
+	for (const file of tree.files) if (file.bytes.length > MAX_FILE_BYTES) out.push(`${file.path}: 파일 하나는 1MiB까지입니다(${formatBytes(file.bytes.length)})`);
+	if (tree.totalBytes > MAX_TREE_BYTES) out.push(`작업 트리 전체가 20MiB를 넘습니다(${formatBytes(tree.totalBytes)})`);
+	if (tree.files.length > MAX_TREE_FILES) out.push(`파일이 ${MAX_TREE_FILES.toLocaleString()}개를 넘습니다(${tree.files.length}개)`);
+	return out;
+}
+function formatBytes(n) {
+	if (n < 1024) return `${n}B`;
+	if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)}KiB`;
+	return `${(n / 1024 / 1024).toFixed(1)}MiB`;
+}
+/** 내려받은 압축 파일(tar.gz)을 푼다 — 작업 트리 경로 규칙 안의 파일만 */
+async function unpackArchive(tgz) {
+	const tar = await gunzip(tgz, MAX_TREE_BYTES * 2 + 4 * 1024 * 1024);
+	const out = /* @__PURE__ */ new Map();
+	for (const entry of readTar(tar, MAX_TREE_BYTES * 2)) if (accessOf(entry.path) !== null) out.set(entry.path, entry.bytes);
+	return out;
+}
+/** 로컬 작업 트리(경로 규칙 안)와 받은 파일의 차이 — 지울 것(원격에 없음)·덮을 것(내용이 다름) */
+function diffLocal(root, files) {
+	const remove = [];
+	const overwrite = [];
+	if (!existsSync(root)) return {
+		remove,
+		overwrite
+	};
+	for (const local of collectTree(root).files) {
+		const remote = files.get(local.path);
+		if (!remote) remove.push(local.path);
+		else if (sha256Hex(remote) !== local.hash) overwrite.push(local.path);
+	}
+	return {
+		remove,
+		overwrite
+	};
+}
+/** 대소문자만 다른 경로 — 대소문자를 가리지 않는 파일 시스템(macOS·Windows 기본)에서 한 파일로 겹친다 */
+function caseCollisions(paths) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const path of paths) {
+		const key = path.toLowerCase();
+		groups.set(key, [...groups.get(key) ?? [], path]);
+	}
+	return [...groups.values()].filter((group) => group.length > 1);
+}
+/** 링크인가(끊긴 링크 포함). 없으면 false */
+function isLink(path) {
+	try {
+		return lstatSync(path).isSymbolicLink();
+	} catch {
+		return false;
+	}
+}
+/**
+* 받은 파일을 폴더에 쓰고 `remove`를 지운다. 경로 규칙 밖(`.env`·`node_modules` 등)은 건드리지 않는다. 링크를 따라 폴더 밖에 쓰지
+* 않는다 — 대상이 링크면(끊긴 링크 포함) 지우고 쓰고, 상위 폴더가 링크면 거부한다.
+*/
+function writeTree(root, files, remove = []) {
+	const base = resolve(root);
+	const safeTarget = (path) => {
+		const target = resolve(base, path);
+		if (!target.startsWith(`${base}${sep}`)) throw new CliError(`작업 트리 밖 경로입니다: ${path}`);
+		let dir = dirname(target);
+		while (dir.startsWith(`${base}${sep}`)) {
+			if (isLink(dir)) throw new CliError(`상위 폴더가 링크라 쓰지 않았습니다: ${relative(base, dir)}`);
+			dir = dirname(dir);
+		}
+		return target;
+	};
+	for (const path of remove) rmSync(safeTarget(path), { force: true });
+	for (const [path, bytes] of files) {
+		const target = safeTarget(path);
+		mkdirSync(dirname(target), { recursive: true });
+		if (isLink(target)) rmSync(target);
+		writeFileSync(target, bytes);
+	}
+}
+/** 트리 지문 — 경로 오름차순 `{path}\t{sha256}\n`의 SHA-256(서버 `treeSha256`과 같은 정의) */
+function treeFingerprint(files) {
+	const input = [...files].sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0).map((file) => `${file.path}\t${file.hash}\n`).join("");
+	return sha256Hex(new TextEncoder().encode(input));
+}
+
+//#endregion
+//#region src/checks.ts
+function runLocalChecks(tree) {
+	const map = new Map(tree.files.map((file) => [file.path, file.bytes]));
+	const report$1 = verifyTree(map);
+	const blockingRules = report$1.results.filter((result) => result.status === "violation");
+	const problems = [...limitProblems(tree)];
+	const warnings = [];
+	const text = (path) => {
+		const bytes = map.get(path);
+		return bytes ? new TextDecoder().decode(bytes) : null;
+	};
+	const packageJson = text("package.json");
+	const lock = text("pnpm-lock.yaml");
+	if (packageJson && lock) {
+		const drift = lockDrift(packageJson, lock);
+		if (drift.length) warnings.push(`package.json의 의존성이 pnpm-lock.yaml과 다릅니다(${drift.slice(0, 5).join(", ")}). 호스팅 빌드는 pnpm-lock.yaml대로 설치하므로 pnpm install로 잠금 파일을 갱신하십시오`);
+	} else if (packageJson && !lock) warnings.push("pnpm-lock.yaml이 없습니다. 호스팅 빌드의 설치가 실패할 수 있습니다");
+	return {
+		report: report$1,
+		blockingRules,
+		problems,
+		warnings
+	};
+}
+const DEPENDENCY_FIELDS = [
+	"dependencies",
+	"devDependencies",
+	"optionalDependencies",
+	"peerDependencies"
+];
+/** `package.json`의 의존성 선언(이름 → 지정자). 읽지 못하면 null */
+function declaredDependencies(packageJson) {
+	let parsed;
+	try {
+		parsed = JSON.parse(packageJson);
+	} catch {
+		return null;
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+	const out = /* @__PURE__ */ new Map();
+	for (const field of DEPENDENCY_FIELDS) {
+		const section = parsed[field];
+		if (!section || typeof section !== "object") continue;
+		for (const [name, spec] of Object.entries(section)) out.set(name, typeof spec === "string" ? spec : "");
+	}
+	return out;
+}
+/**
+* `package.json`의 선언과 잠금 파일(v9) `importers: .:`의 선언이 다른 이름. 호스팅 빌드는 `--frozen-lockfile`이라 어긋나면 설치에서
+* 실패한다. npm으로 의존성을 더하면 `package-lock.json`만 바뀌어 이렇게 된다.
+*/
+function lockDrift(packageJson, lock) {
+	const declared = declaredDependencies(packageJson);
+	if (!declared) return [];
+	const locked = lockImporterSpecifiers(lock);
+	if (!locked) return [];
+	const drift = /* @__PURE__ */ new Set();
+	for (const [name, spec] of declared) if (locked.get(name) !== spec) drift.add(name);
+	for (const name of locked.keys()) if (!declared.has(name)) drift.add(name);
+	return [...drift].sort();
+}
+/** 잠금 파일 `importers: .:`의 이름 → specifier. 읽지 못하면 null */
+function lockImporterSpecifiers(lock) {
+	const lines = lock.split(/\r?\n/);
+	const start = lines.findIndex((line) => line === "importers:");
+	if (start < 0) return null;
+	const out = /* @__PURE__ */ new Map();
+	let inRoot = false;
+	let current = null;
+	for (const line of lines.slice(start + 1)) {
+		if (/^\S/.test(line)) break;
+		if (/^ {2}\S/.test(line)) {
+			inRoot = /^ {2}\.:\s*$/.test(line);
+			continue;
+		}
+		if (!inRoot) continue;
+		const name = /^ {6}'?([^'\s][^']*?)'?:\s*$/.exec(line);
+		if (name?.[1]) {
+			current = name[1];
+			continue;
+		}
+		const spec = /^ {8}specifier:\s*'?(.*?)'?\s*$/.exec(line);
+		if (spec && current) out.set(current, spec[1] ?? "");
+	}
+	return out;
+}
+
+//#endregion
+//#region src/commands.ts
+/** 종료 코드 — 0 성공 · 1 실패 · 3 발행이 승인 대기(에이전트 토큰) */
+const EXIT_APPROVAL_PENDING = 3;
+/** 빠진 내용을 다시 올리는 최대 횟수 */
+const MAX_BLOB_ROUNDS = 3;
+/** 올리기 한 번의 내용 합계 상한 — base64(×4/3)가 api 본문 8MiB 안에 든다 */
+const BLOB_BATCH_BYTES = 5 * 1024 * 1024;
+/**
+* 토큰·api 주소 확인 — `--token`은 셸 기록·프로세스 목록에 남으니 알리고, 파일(`.env`·`.sayrenrc`)에서 읽은 기본이 아닌 api 주소는 토큰이
+* 그곳으로 가므로 확인한다(대화형이면 묻고, 아니면 `--api-origin`·`SAYREN_API_ORIGIN`으로 명시해야 한다)
+*/
+async function checkAuthSources(auth, io) {
+	if (auth.tokenSource === "flag") io.err("경고: --token은 셸 기록·프로세스 목록에 남습니다. 다음부터는 npx sayren login 또는 SAYREN_TOKEN 환경 변수를 쓰십시오");
+	if (auth.originSource !== ".env" && auth.originSource !== "rc") return;
+	const from = auth.originSource === ".env" ? ".env의 SAYREN_API_URL" : RC_FILE;
+	io.err(`경고: 기본이 아닌 api 주소(${auth.apiOrigin})를 ${from}에서 읽었습니다. 토큰이 이 주소로 갑니다`);
+	if (!io.confirm) throw new CliError(`파일에서 읽은 api 주소는 확인이 필요합니다. 맞으면 --api-origin ${auth.apiOrigin}으로 명시하십시오`);
+	if (!await io.confirm(`${auth.apiOrigin}으로 보내겠습니까?`)) throw new CliError("취소했습니다");
+}
+async function pull(flags, io) {
+	const probeDir = flags.dir ? resolve(io.cwd, flags.dir) : io.cwd;
+	const auth = resolveAuth(flags, existsSync(probeDir) ? probeDir : io.cwd, null, io.env);
+	await checkAuthSources(auth, io);
+	const client = clientOf(auth, io.fetch);
+	const hosting = await client.storefront.get();
+	if (!hosting.site) throw new CliError("이 스토어에는 호스팅 사이트가 없습니다. 셀러 콘솔 › 스토어프론트에서 사이트를 만든 뒤 다시 받으십시오");
+	if (!hosting.editingEnabled) throw new CliError("지금은 스토어프론트 소스를 받을 수 없습니다(편집 기능이 꺼져 있습니다)");
+	const source = await client.storefront.getSource();
+	if (flags.project && flags.project !== source.storeId) throw new CliError(`토큰의 스토어(${source.storeId})와 --project(${flags.project})가 다릅니다. 그 스토어에서 발급한 토큰을 쓰십시오`);
+	const store = {
+		storeId: source.storeId,
+		storeCode: source.storeCode
+	};
+	const defaultDir = store.storeCode || source.siteId;
+	const target = !flags.dir && existsSync(join(io.cwd, RC_FILE)) ? io.cwd : resolve(io.cwd, flags.dir ?? defaultDir);
+	const existing = existsSync(target) ? readdirSync(target) : [];
+	if (existing.length > 0) {
+		if (!flags.force) throw new CliError(`폴더가 비어 있지 않습니다: ${relativeOf(io, target)}. 같은 사이트를 받은 폴더면 --force로 원격 작업 트리를 다시 받을 수 있습니다`);
+		let rc = null;
+		try {
+			rc = readRc(target);
+		} catch {
+			rc = null;
+		}
+		if (!rc || rc.siteId !== source.siteId) throw new CliError(`${relativeOf(io, target)}는 이 사이트(${source.siteId})를 받은 폴더가 아닙니다(${RC_FILE} 없음 또는 다른 사이트). 빈 폴더를 지정하십시오`);
+	}
+	io.out(`작업 트리 받기 — ${source.files}개 파일, ${formatBytes(source.bytes)} (압축 ${formatBytes(source.archive.bytes)})`);
+	const chunks = [];
+	for (let part = 0; part < source.archive.parts; part += 1) {
+		const piece = await client.storefront.getSourceArchive({
+			sourceRef: source.sourceRef,
+			part
+		});
+		chunks.push(Buffer.from(piece.content, "base64"));
+	}
+	const tgz = new Uint8Array(Buffer.concat(chunks));
+	if (sha256Hex(tgz) !== source.archive.sha256) throw new CliError("받은 압축 파일이 손상됐습니다. 다시 시도하십시오");
+	const files = await unpackArchive(tgz);
+	const collisions = caseCollisions(files.keys());
+	if (collisions.length > 0) throw new CliError(`대소문자만 다른 경로가 있어 받지 않았습니다(대소문자를 가리지 않는 파일 시스템에서 겹칩니다): ${collisions.map((group) => group.join(" · ")).join(", ")}. 콘솔·AI 편집으로 한쪽 이름을 바꾼 뒤 다시 받으십시오`);
+	const diff = diffLocal(target, files);
+	if (existing.length > 0) {
+		const watched = diff.overwrite.filter((path) => path === "package.json" || path === "vite.config.ts");
+		for (const path of watched) io.out(`알림: 원격의 ${path}가 이 폴더와 다릅니다. 설치 전에 내용을 확인하십시오(npm install --ignore-scripts 권장)`);
+		if (diff.remove.length + diff.overwrite.length > 0) {
+			io.out(`원격 작업 트리로 바꿉니다 — 지울 파일 ${diff.remove.length}개, 덮어쓸 파일 ${diff.overwrite.length}개`);
+			for (const path of diff.remove.slice(0, 20)) io.out(`  - ${path}`);
+			if (diff.remove.length > 20) io.out(`  … 외 ${diff.remove.length - 20}개`);
+			for (const path of diff.overwrite.slice(0, 20)) io.out(`  ~ ${path}`);
+			if (diff.overwrite.length > 20) io.out(`  … 외 ${diff.overwrite.length - 20}개`);
+			if (!flags.yes) {
+				if (!io.confirm) throw new CliError("로컬 파일을 지우거나 덮어씁니다. 확인할 수 없는 환경이면 --yes를 함께 주십시오");
+				if (!await io.confirm("계속하시겠습니까?")) {
+					io.out("취소했습니다");
+					return 1;
+				}
+			}
+		}
+	}
+	mkdirSync(target, { recursive: true });
+	writeTree(target, files, existing.length > 0 ? diff.remove : []);
+	const removed = existing.length > 0 ? diff.remove.length : 0;
+	writeRc(target, {
+		storeId: store.storeId,
+		siteId: source.siteId,
+		baseRef: source.sourceRef,
+		...auth.apiOrigin !== DEFAULT_API_ORIGIN ? { apiOrigin: auth.apiOrigin } : {}
+	});
+	updateEnvFile(target, {
+		SAYREN_TOKEN: auth.token,
+		SAYREN_API_URL: `${auth.apiOrigin}/storefront/v1`,
+		SAYREN_STORE_CODE: store.storeCode
+	});
+	const addedIgnore = ensureGitignore(target);
+	io.out(`받음 → ${relativeOf(io, target)} (${files.size}개${removed ? `, 원격에 없는 ${removed}개 지움` : ""})`);
+	io.out(`${RC_FILE} 작성 — 사이트 ${source.siteId}. 커밋해도 됩니다(비밀 없음)`);
+	io.out(`${ENV_FILE} 작성 — 토큰과 스토어프론트 API 주소. 커밋하지 마십시오${addedIgnore ? "(.gitignore에 더했습니다)" : ""}`);
+	if (source.editSessionOpen) io.out("알림: 콘솔·AI 편집 환경이 열려 있습니다. 배포 전에 그 편집이 끝났는지 확인하십시오");
+	warnTokenLoading(target, io);
+	io.out(`\n다음:\n  cd ${relativeOf(io, target)}\n  npm install --ignore-scripts  # 의존성의 설치 스크립트를 돌리지 않습니다\n  npm run dev        # http://localhost:4010 — 운영 스토어 데이터로 동작합니다\n  npx sayren deploy  # 빌드 → 버전 → 발행`);
+	return 0;
+}
+/**
+* 옛 템플릿의 vite.config.ts는 `.env`의 `SAYREN_*`를 모두 서버 코드 환경에 싣는다 — 토큰(`SAYREN_TOKEN`)도 실린다.
+* 브라우저 번들에는 들어가지 않지만 서버 코드가 읽을 수 있으므로 알린다(새 템플릿은 토큰을 빼고 싣는다).
+*/
+function warnTokenLoading(dir, io) {
+	const path = join(dir, "vite.config.ts");
+	if (!existsSync(path)) return;
+	const text = readFileSync(path, "utf8");
+	if (text.includes("\"SAYREN_\"") && !text.includes("SAYREN_TOKEN")) io.out("알림: vite.config.ts가 .env의 SAYREN_TOKEN까지 개발 서버 환경에 싣습니다. 서버 코드에서 process.env.SAYREN_TOKEN을 읽지 마십시오(최신 템플릿은 싣지 않습니다)");
+}
+async function verify(flags, io) {
+	const dir = resolve(io.cwd, flags.dir ?? ".");
+	const tree = collectTree(dir);
+	if (tree.files.length === 0) throw new CliError(`작업 트리 파일이 없습니다: ${relativeOf(io, dir)}`);
+	const checks = runLocalChecks(tree);
+	printChecks(tree, checks, io);
+	return checks.blockingRules.length === 0 && checks.problems.length === 0 ? 0 : 1;
+}
+function printChecks(tree, checks, io) {
+	const { report: report$1 } = checks;
+	io.out(`로컬 검사 — 파일 ${tree.files.length}개(${formatBytes(tree.totalBytes)}), 규칙 ${report$1.summary.passed}/${report$1.summary.rules} 통과`);
+	for (const finding of report$1.findings) {
+		const at = finding.line ? `${finding.file}:${finding.line}` : finding.file;
+		io.out(`  · 위반 [${finding.ruleId}] ${at} — ${finding.fix}`);
+	}
+	for (const problem of checks.problems) io.out(`  · 문제 ${problem}`);
+	for (const warning of checks.warnings) io.out(`  · 경고 ${warning}`);
+	const secrets = tree.skipped.filter((path) => /(^|\/)\.env|(^|\/)\.sayrenrc$/.test(path));
+	if (secrets.length) io.out(`  · 올리지 않음(비밀): ${secrets.join(", ")}`);
+	const others = tree.skipped.filter((path) => !secrets.includes(path));
+	if (others.length) io.out(`  · 올리지 않음(작업 트리 밖): ${others.slice(0, 8).join(", ")}${others.length > 8 ? ` 외 ${others.length - 8}개` : ""}`);
+}
+async function deploy(flags, io) {
+	const dir = resolve(io.cwd, flags.dir ?? ".");
+	const rc = readRc(dir);
+	if (!rc) throw new CliError(`${RC_FILE}가 없습니다. 먼저 npx sayren pull로 사이트 소스를 받으십시오`);
+	const auth = resolveAuth(flags, dir, rc, io.env);
+	await checkAuthSources(auth, io);
+	const client = clientOf(auth, io.fetch);
+	const tree = collectTree(dir);
+	const checks = runLocalChecks(tree);
+	printChecks(tree, checks, io);
+	if (checks.blockingRules.length > 0 || checks.problems.length > 0) throw new CliError("로컬 검사를 통과하지 못해 배포하지 않았습니다. 위 항목을 고친 뒤 다시 시도하십시오");
+	const site = (await client.storefront.get()).site;
+	if (!site || site.siteId !== rc.siteId) throw new CliError(`이 폴더의 사이트(${rc.siteId})가 스토어의 지금 사이트와 다릅니다. npx sayren pull로 다시 받으십시오`);
+	if (flags.force && !flags.yes) {
+		if (!io.confirm) throw new CliError("--force는 원격 작업 트리를 덮어씁니다. 확인할 수 없는 환경이면 --yes를 함께 주십시오");
+		if (!await io.confirm("원격 작업 트리(콘솔·AI 편집 포함)를 이 폴더 내용으로 덮어쓰고, 열린 편집 환경을 끕니다. 계속하시겠습니까?")) {
+			io.out("취소했습니다");
+			return 1;
+		}
+	}
+	let replaced;
+	try {
+		replaced = await replaceSource(client, tree, rc, flags.force === true, io);
+	} catch (error) {
+		if (error instanceof ApprovalPendingError) {
+			io.out("작업 트리 바꾸기는 승인이 필요합니다(에이전트 토큰이 package.json·vite.config.ts를 바꿉니다). 승인된 뒤 npx sayren deploy를 다시 돌리면 빌드·발행합니다");
+			if (error.approval.approvalUrl) io.out(`승인 요청: ${error.approval.approvalUrl}`);
+			else io.out(`승인 요청 id: ${error.approvalId} (셀러 콘솔 › 설정 › 보안 › 승인 요청)`);
+			return EXIT_APPROVAL_PENDING;
+		}
+		throw error;
+	}
+	writeRc(dir, {
+		...rc,
+		baseRef: replaced.sourceRef
+	});
+	io.out(replaced.changed ? `작업 트리 올림 — ${replaced.files}개 파일${replaced.endedEditSession ? "(열린 편집 환경을 껐습니다)" : ""}` : "작업 트리가 원격과 같습니다 — 그대로 빌드합니다");
+	let created;
+	try {
+		created = await client.storefront.createVersion({
+			...flags.message ? { message: flags.message } : {},
+			expectedSourceRef: replaced.sourceRef
+		});
+	} catch (error) {
+		const code = codeOf(error);
+		if (code === "STOREFRONT_BUILD_IN_PROGRESS") throw new CliError("이 사이트에 끝나지 않은 빌드가 있습니다(콘솔·AI 또는 다른 배포). 작업 트리는 올렸습니다 — npx sayren status로 확인한 뒤 다시 배포하십시오");
+		if (code === "SOURCE_CHANGED") throw new CliError("올린 직후 다른 편집이 끼어 버전을 만들지 않았습니다. npx sayren pull --force로 받아 합친 뒤 다시 배포하십시오");
+		throw error;
+	}
+	io.out(`버전 v${created.version.number} 빌드 시작`);
+	const build = await waitBuild(client, created.build, io);
+	if (build.status !== "SUCCEEDED") {
+		printBuildFailure(build, io);
+		return 1;
+	}
+	io.out(`빌드 성공 — v${created.version.number}${build.durationMs ? ` (${Math.round(build.durationMs / 1e3)}초)` : ""}`);
+	if (flags.publish === false) {
+		io.out(`발행하지 않았습니다(--no-publish). 콘솔 › 스토어프론트 › 버전에서 v${created.version.number}를 발행할 수 있습니다`);
+		return 0;
+	}
+	try {
+		const published = await client.storefront.publish(created.version.versionId, { expectedPublishedVersionId: site.publishedVersion?.versionId ?? null });
+		io.out(`발행 — v${created.version.number} → ${published.url}`);
+		io.out("반영까지 1분 안팎이 걸립니다");
+		return 0;
+	} catch (error) {
+		if (error instanceof ApprovalPendingError) {
+			io.out(`발행은 승인이 필요합니다(에이전트 토큰). 셀러가 승인하면 v${created.version.number}가 발행됩니다`);
+			if (error.approval.approvalUrl) io.out(`승인 요청: ${error.approval.approvalUrl}`);
+			else io.out(`승인 요청 id: ${error.approvalId} (셀러 콘솔 › 설정 › 보안 › 승인 요청)`);
+			return EXIT_APPROVAL_PENDING;
+		}
+		if (codeOf(error) === "STOREFRONT_SITE_CHANGED") throw new CliError(`다른 사람이 그 사이 다른 버전을 발행했습니다. v${created.version.number}는 만들어 뒀습니다 — 콘솔에서 확인한 뒤 발행하십시오`);
+		throw error;
+	}
+}
+async function replaceSource(client, tree, rc, force, io) {
+	const files = tree.files.map((file) => ({
+		path: file.path,
+		hash: file.hash,
+		size: file.bytes.length
+	}));
+	const textOf = (path) => {
+		const file = tree.files.find((f) => f.path === path);
+		return file ? new TextDecoder().decode(file.bytes) : void 0;
+	};
+	const packageJson = textOf("package.json");
+	const lockfile = textOf("pnpm-lock.yaml");
+	const body = {
+		...force ? { endEditSession: true } : { expectedBaseRef: rc.baseRef },
+		files,
+		...packageJson === void 0 ? {} : { packageJson },
+		...lockfile === void 0 ? {} : { lockfile }
+	};
+	let uploads = 0;
+	for (;;) try {
+		const result = await client.storefront.replaceSource(body);
+		for (const warning of result.dependencyWarnings) io.out(`  · 의존성 경고 ${findingLine(warning)}`);
+		return result;
+	} catch (error) {
+		const code = codeOf(error);
+		const details = detailsOf(error);
+		if (code === "SOURCE_BLOBS_MISSING" && uploads < MAX_BLOB_ROUNDS) {
+			await uploadBlobs(client, tree, new Set(Array.isArray(details.hashes) ? details.hashes : []), io);
+			uploads += 1;
+			continue;
+		}
+		if (code === "SOURCE_BLOBS_MISSING") throw new CliError("파일 내용을 올렸지만 서버가 찾지 못했습니다. 잠시 뒤 다시 배포하십시오");
+		if (code === "SOURCE_CHANGED") {
+			const remote = await client.storefront.getSource().catch(() => null);
+			if (remote && remote.treeSha256 === treeFingerprint(files)) {
+				io.out("원격 작업 트리가 이미 이 폴더와 같습니다 — 기준을 맞추고 이어서 빌드합니다");
+				return {
+					sourceRef: remote.sourceRef,
+					previousRef: remote.sourceRef,
+					treeSha256: remote.treeSha256,
+					files: remote.files,
+					bytes: remote.bytes,
+					changed: false,
+					endedEditSession: false,
+					dependencyWarnings: []
+				};
+			}
+			throw new CliError("원격 작업 트리가 pull 이후 바뀌었습니다(콘솔·AI 편집). 덮어쓰지 않았습니다.\n  · 원격을 받으려면: npx sayren pull --force (로컬 변경은 먼저 커밋·백업하십시오)\n  · 이 폴더 내용으로 덮어쓰려면: npx sayren deploy --force");
+		}
+		if (code === "EDIT_SESSION_OPEN") throw new CliError("콘솔·AI 편집 환경이 열려 있어 올리지 않았습니다. 편집을 끝낸 뒤 다시 시도하거나 --force로 편집 환경을 끄고 진행하십시오");
+		if (code === "DEPENDENCY_REJECTED") throw new CliError(`쓸 수 없는 npm 의존성이 있어 올리지 않았습니다.\n${(Array.isArray(details.rejected) ? details.rejected : []).map((item) => `  · ${findingLine(item)}`).join("\n")}`);
+		if (code === "DEPENDENCY_CHECK_UNAVAILABLE") throw new CliError("의존성 확인을 지금 할 수 없습니다. 잠시 뒤 다시 시도하십시오");
+		if (code === "SOURCE_TOO_MANY_NEW_FILES") throw new CliError(`한 번에 올릴 수 있는 새 파일은 ${String(details.max ?? 800)}개까지입니다. 파일을 나눠 여러 번 배포하십시오(--no-publish로 중간 배포)`);
+		if (code === "INVALID_FILE_PATH") throw new CliError(`올릴 수 없는 경로입니다: ${String(details.path ?? "")}`);
+		throw error;
+	}
+}
+const REASON_LABEL = {
+	DENYLISTED: "거절 목록",
+	ADVISORY: "보안 권고",
+	MALWARE: "악성 패키지",
+	INVALID_MANIFEST: "선언 오류",
+	INSTALL_SCRIPT: "설치 스크립트",
+	UNSUPPORTED_SOURCE: "지원하지 않는 설치 경로",
+	BUNDLED_DEPENDENCIES: "묶인 의존성"
+};
+/** `name@version — 사유: 설명` */
+function findingLine(item) {
+	return `${item.version ? `${item.name}@${item.version}` : String(item.name ?? "")} — ${item.reason ? REASON_LABEL[item.reason] ?? item.reason : ""}${item.detail ? `: ${item.detail}` : ""}`;
+}
+async function uploadBlobs(client, tree, hashes, io) {
+	const seen = /* @__PURE__ */ new Set();
+	const pending = tree.files.filter((file) => {
+		if (!hashes.has(file.hash) || seen.has(file.hash)) return false;
+		seen.add(file.hash);
+		return true;
+	});
+	let batch = [];
+	let bytes = 0;
+	let sent = 0;
+	const flush = async () => {
+		if (batch.length === 0) return;
+		await client.storefront.uploadSourceBlobs({ blobs: batch.map((file) => ({
+			hash: file.hash,
+			content: Buffer.from(file.bytes).toString("base64")
+		})) });
+		sent += batch.length;
+		batch = [];
+		bytes = 0;
+	};
+	for (const file of pending) {
+		if (batch.length >= STOREFRONT_SOURCE_BLOB_BATCH_MAX || bytes + file.bytes.length > BLOB_BATCH_BYTES) await flush();
+		batch.push(file);
+		bytes += file.bytes.length;
+	}
+	await flush();
+	io.out(`바뀐 파일 ${sent}개 올림`);
+}
+async function waitBuild(client, initial, io) {
+	const started = Date.now();
+	let build = initial;
+	let printed = 0;
+	for (;;) {
+		for (const stage of build.stages.slice(printed)) io.out(`  ${stage.ok ? "✓" : "✗"} ${stage.stage} ${(stage.durationMs / 1e3).toFixed(1)}초`);
+		printed = build.stages.length;
+		if (STOREFRONT_BUILD_TERMINAL_STATUSES.includes(build.status)) return build;
+		if (Date.now() - started > io.buildTimeoutMs) throw new CliError(`빌드가 ${Math.round(io.buildTimeoutMs / 6e4)}분 안에 끝나지 않았습니다. npx sayren status로 결과를 확인하십시오`);
+		await io.sleep(io.pollMs);
+		build = await client.storefront.getBuild(build.buildId);
+	}
+}
+function printBuildFailure(build, io) {
+	io.err(`빌드 실패 — ${build.failureStage ?? "알 수 없는 단계"}${build.errorCode ? ` (${build.errorCode})` : ""}`);
+	if (build.failureStage === "DEPENDENCIES") io.err("  npm 의존성 검사에서 막혔습니다. 아래 사유의 패키지를 빼거나 바꾼 뒤 다시 배포하십시오");
+	for (const finding of build.verify?.findings ?? []) {
+		const at = finding.line ? `${finding.file}:${finding.line}` : finding.file;
+		io.err(`  · [${finding.ruleId}] ${at} — ${finding.fix}`);
+	}
+	if (build.logTail) {
+		io.err("로그 꼬리:");
+		for (const line of build.logTail.trimEnd().split("\n").slice(-40)) io.err(`  ${line}`);
+	}
+}
+async function status(flags, io) {
+	const dir = resolve(io.cwd, flags.dir ?? ".");
+	const rc = readRc(dir);
+	const auth = resolveAuth(flags, dir, rc, io.env);
+	await checkAuthSources(auth, io);
+	const client = clientOf(auth, io.fetch);
+	const hosting = await client.storefront.get();
+	const site = hosting.site;
+	if (!site) {
+		io.out("호스팅 사이트가 없습니다");
+		return 0;
+	}
+	io.out(`사이트 ${site.siteId} — ${site.url}`);
+	io.out(`  상태 ${site.status} · 공개 ${site.visibility} · 반영 ${site.provisioning.status}`);
+	const published = site.publishedVersion;
+	io.out(published ? `  발행 v${published.number} (${published.createdVia ?? published.createdByType}${published.publishedAt ? `, ${published.publishedAt}` : ""})` : "  발행 버전 없음");
+	if (hosting.editingEnabled) {
+		const [builds, editing] = await Promise.all([client.storefront.listBuilds({ limit: 3 }), client.storefront.getEditing()]);
+		for (const build of builds) io.out(`  빌드 v${build.versionNumber} ${build.status}${build.failureStage ? ` (${build.failureStage})` : ""} ${build.queuedAt}`);
+		io.out(`  편집 환경 ${editing.session ? `열림(${editing.session.status})` : "닫힘"}`);
+	}
+	if (rc) if (rc.siteId !== site.siteId) io.out(`  이 폴더의 사이트(${rc.siteId})는 지금 사이트가 아닙니다 — 다시 받으십시오`);
+	else io.out(`  이 폴더의 기준 작업 트리 ${rc.baseRef.slice(rc.baseRef.lastIndexOf("/") + 1, -4).slice(0, 12)}`);
+	return 0;
+}
+async function login(flags, io, readToken) {
+	const dir = resolve(io.cwd, flags.dir ?? ".");
+	const token = flags.token?.trim() || (await readToken())?.trim();
+	if (!token) throw new CliError("토큰을 입력하지 않았습니다");
+	const hosting = await clientOf(resolveAuth({
+		...flags,
+		token
+	}, dir, readRc(dir), io.env), io.fetch).storefront.get();
+	mkdirSync(dir, { recursive: true });
+	updateEnvFile(dir, { SAYREN_TOKEN: token });
+	const addedIgnore = ensureGitignore(dir);
+	io.out(`토큰을 확인하고(사이트 ${hosting.site?.hostname ?? "없음"}) ${relativeOf(io, join(dir, ENV_FILE))}에 저장했습니다${addedIgnore ? "(.gitignore에 .env를 더했습니다)" : ""}`);
+	return 0;
+}
+function relativeOf(io, path) {
+	return relative(io.cwd, path) || ".";
+}
+
+//#endregion
+//#region src/index.ts
+const USAGE = `sayren ${CLI_VERSION} — 호스팅 스토어프론트 CLI
+
+사용법:
+  npx sayren login                       # 토큰을 입력받아 .env에 저장(셸 기록에 남지 않습니다)
+  npx sayren pull --project <storeId> [폴더] [--force [--yes]]
+  npx sayren deploy [--no-publish] [--message <메모>] [--force [--yes]]
+  npx sayren status
+  npx sayren verify
+
+명령:
+  login    토큰을 확인하고 지금 폴더의 .env에 저장합니다
+  pull     호스팅 중인 사이트의 작업 트리를 폴더(기본: 스토어 코드)로 받고 .sayrenrc·.env를 씁니다
+  deploy   로컬 검사 → 작업 트리 올리기 → 빌드 → 발행. 원격이 pull 이후 바뀌었으면 덮어쓰지 않습니다
+  status   사이트·발행 버전·최근 빌드·편집 환경
+  verify   로컬 규칙·경로·크기 검사(서버 빌드와 같은 규칙)
+
+토큰은 SAYREN_TOKEN 환경 변수 → .env 순서로 읽습니다(API 토큰 sy_pat_…, 스코프 storefront:rw).
+
+옵션:
+  --project <storeId>  pull: 토큰의 스토어와 같아야 합니다
+  --dir <폴더>         작업 폴더(기본: 지금 폴더, pull은 스토어 코드)
+  --force              pull: 같은 사이트를 받은 폴더에 원격을 다시 받습니다(지울·덮을 파일을 보여 주고 묻습니다)
+                       deploy: 원격 변경·열린 편집 환경을 무시하고 덮어씁니다(확인을 묻습니다)
+  --yes                --force의 확인을 묻지 않습니다(비대화형)
+  --no-publish         deploy: 버전까지만 만들고 발행하지 않습니다
+  --message <메모>     deploy: 버전 메모
+  --api-origin <주소>  api 주소(기본 https://api.sayren.app, SAYREN_API_ORIGIN). https만, localhost만 http
+  --token <토큰>       토큰을 직접 줍니다. 셸 기록·프로세스 목록에 남으니 login·SAYREN_TOKEN을 권합니다
+
+종료 코드: 0 성공 · 1 실패 · 3 승인 대기(에이전트 토큰)`;
+const VALUE_FLAGS = new Set([
+	"token",
+	"project",
+	"dir",
+	"message",
+	"api-origin"
+]);
+const BOOL_FLAGS = new Set([
+	"force",
+	"yes",
+	"no-publish",
+	"help",
+	"version"
+]);
+function parseArgs(argv) {
+	const out = {
+		command: null,
+		positional: [],
+		flags: {}
+	};
+	for (let i = 0; i < argv.length; i += 1) {
+		const arg = argv[i];
+		if (arg === "-h") out.flags.help = true;
+		else if (arg === "-v") out.flags.version = true;
+		else if (arg.startsWith("--")) {
+			const body = arg.slice(2);
+			const eq = body.indexOf("=");
+			const name = eq < 0 ? body : body.slice(0, eq);
+			const inline = eq < 0 ? void 0 : body.slice(eq + 1);
+			if (VALUE_FLAGS.has(name)) {
+				const value = inline ?? argv[++i];
+				if (value === void 0 || value.startsWith("--")) throw new CliError(`--${name}에 값이 필요합니다`);
+				out.flags[name] = value;
+			} else if (BOOL_FLAGS.has(name)) out.flags[name] = true;
+			else throw new CliError(`알 수 없는 옵션: --${name}\n\n${USAGE}`);
+		} else if (!out.command) out.command = arg;
+		else out.positional.push(arg);
+	}
+	return out;
+}
+function str(value) {
+	return typeof value === "string" ? value : void 0;
+}
+async function main(argv, io) {
+	const parsed = parseArgs(argv);
+	if (parsed.flags.version) {
+		io.out(CLI_VERSION);
+		return 0;
+	}
+	if (!parsed.command || parsed.flags.help || parsed.command === "help") {
+		io.out(USAGE);
+		return parsed.command || parsed.flags.help ? 0 : 1;
+	}
+	const common = {
+		token: str(parsed.flags.token),
+		apiOrigin: str(parsed.flags["api-origin"]),
+		dir: str(parsed.flags.dir) ?? parsed.positional[0]
+	};
+	switch (parsed.command) {
+		case "pull": return pull({
+			...common,
+			project: str(parsed.flags.project),
+			force: parsed.flags.force === true,
+			yes: parsed.flags.yes === true
+		}, io);
+		case "deploy": return deploy({
+			...common,
+			force: parsed.flags.force === true,
+			yes: parsed.flags.yes === true,
+			publish: parsed.flags["no-publish"] !== true,
+			message: str(parsed.flags.message)
+		}, io);
+		case "status": return status(common, io);
+		case "verify": return verify(common, io);
+		case "login": return login(common, io, () => ask("API 토큰(sy_pat_…): "));
+		default: throw new CliError(`알 수 없는 명령: ${parsed.command}\n\n${USAGE}`);
+	}
+}
+async function ask(question) {
+	if (!stdin.isTTY) return null;
+	const rl = createInterface({
+		input: stdin,
+		output: stdout
+	});
+	try {
+		return await rl.question(question);
+	} finally {
+		rl.close();
+	}
+}
+function defaultIo() {
+	return {
+		cwd: process.cwd(),
+		env: process.env,
+		fetch: (input, init) => fetch(input, init),
+		out: (line) => console.log(line),
+		err: (line) => console.error(line),
+		confirm: stdin.isTTY ? async (question) => /^(y|yes|예|네)$/i.test((await ask(`${question} (y/N) `) ?? "").trim()) : null,
+		sleep: (ms) => new Promise((resolve$1) => setTimeout(resolve$1, ms)),
+		buildTimeoutMs: 20 * 6e4,
+		pollMs: 3e3
+	};
+}
+/** 오류 표시 — 토큰·요청 본문은 싣지 않는다 */
+function describeError(error) {
+	if (error instanceof CliError) return error.message;
+	if (error instanceof ApiError) {
+		if (error.status === 401) return "토큰이 올바르지 않거나 만료됐습니다(401). 셀러 콘솔 › 개발자 › API 토큰을 확인하십시오";
+		if (error.status === 403 && error.code === "INSUFFICIENT_SCOPE") return "토큰에 storefront:rw 스코프가 없습니다. 스코프를 더한 토큰을 쓰십시오";
+		if (error.code === "TOO_MANY_REQUESTS") return "요청이 너무 많습니다. 잠시 뒤 다시 시도하십시오";
+		return `${error.message} (${error.code}, HTTP ${error.status})`;
+	}
+	if (error instanceof TypeError && /fetch failed/.test(error.message)) return "api에 연결하지 못했습니다. 네트워크와 --api-origin을 확인하십시오";
+	return error instanceof Error ? error.message : String(error);
+}
+if (process.argv[1] && /sayren|index\.(m?js|ts)$/.test(process.argv[1]) && !process.env.VITEST) {
+	const io = defaultIo();
+	main(process.argv.slice(2), io).then((code) => process.exit(code)).catch((error) => {
+		io.err(`오류: ${describeError(error)}`);
+		process.exit(error instanceof CliError ? error.exitCode : 1);
+	});
+}
+
+//#endregion
+export { defaultIo, describeError, main, parseArgs };