sayren 0.1.0 → 0.2.0

package/dist/index.mjs

@@ -4,10 +4,11 @@ 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 { spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
 
 //#region package.json
-var version = "0.1.0";
+var version = "0.2.0";
 
 //#endregion
 //#region src/client.ts
@@ -40,6 +41,168 @@ function detailsOf(error) {
 	return error instanceof ApiError ? error.details ?? {} : {};
 }
 
+//#endregion
+//#region ../mcp/src/mcp-json.ts
+/**
+* 셀러 프로젝트의 `.mcp.json`(Claude Code 형식) — 원격 MCP(`mcp.sayren.app`)에 붙는 `sayren` 항목을 만들고 읽는다.
+*
+* `npx sayren pull`·`login`(packages/cli)과 `sayren-mcp create`가 같은 함수로 쓴다. 파일 입출력은 부르는 쪽이 하고 여기는 문자열만
+* 다룬다 — 게이트웨이(Worker)가 헤더 이름을 이 파일에서 가져가므로 Node 전용 API를 쓰지 않는다.
+*
+* - 토큰 값을 파일에 그대로 쓴다(2026-09-29 사용자 결정). 그래서 `.mcp.json`은 `.gitignore` 대상이고 배포에 올리지 않는다.
+* - 다른 서버 항목과 `sayren` 항목의 다른 헤더는 그대로 둔다. `sayren` 항목의 `type`·`url`·토큰·스토어 헤더만 바꾼다.
+* - 스토어 헤더(`X-Store-Id`)는 게이트웨이가 토큰의 스토어와 대조한다(다르면 403). 토큰을 다른 스토어 것으로 바꿔 넣는 실수를 막는다.
+*/
+const MCP_JSON_FILE = ".mcp.json";
+const MCP_SERVER_NAME = "sayren";
+/** 원격 MCP 주소. 게이트웨이는 운영 api 하나만 바라본다 — 다른 api 주소를 쓰는 폴더도 이 주소를 쓴다 */
+const REMOTE_MCP_URL = "https://mcp.sayren.app/mcp";
+/** 관리 API의 테넌트 헤더와 같은 이름이다(api `StoreTokenGuard`가 토큰의 스토어와 대조한다) */
+const STORE_ID_HEADER = "X-Store-Id";
+var McpJsonError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "McpJsonError";
+	}
+};
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function parse(text) {
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch {
+		throw new McpJsonError(`${MCP_JSON_FILE}를 읽지 못했습니다. JSON 형식을 확인하십시오`);
+	}
+	if (!isObject(parsed)) throw new McpJsonError(`${MCP_JSON_FILE} 형식이 아닙니다`);
+	if (parsed.mcpServers !== void 0 && !isObject(parsed.mcpServers)) throw new McpJsonError(`${MCP_JSON_FILE}의 mcpServers가 객체가 아닙니다`);
+	return parsed;
+}
+/** 대소문자를 가리지 않고 헤더 키를 찾는다 */
+function headerKey(headers, name) {
+	const lower = name.toLowerCase();
+	return Object.keys(headers).find((key) => key.toLowerCase() === lower);
+}
+/**
+* `sayren` 항목을 넣거나 바꾼 `.mcp.json` 본문. `existing`이 없으면 새 파일이다.
+* 형식이 틀린 파일은 덮어쓰지 않고 `McpJsonError`다(셀러가 손으로 쓴 다른 서버 설정을 지우지 않게).
+*/
+function mergeMcpJson(existing, credentials) {
+	const root = existing?.trim() ? parse(existing) : {};
+	const servers = isObject(root.mcpServers) ? { ...root.mcpServers } : {};
+	const previous = isObject(servers[MCP_SERVER_NAME]) ? servers[MCP_SERVER_NAME] : {};
+	const headers = isObject(previous.headers) ? { ...previous.headers } : {};
+	for (const name of ["Authorization", STORE_ID_HEADER]) {
+		const key = headerKey(headers, name);
+		if (key) delete headers[key];
+	}
+	const next = {
+		...previous,
+		type: "http",
+		url: REMOTE_MCP_URL,
+		headers: {
+			Authorization: `Bearer ${credentials.token}`,
+			...credentials.storeId ? { [STORE_ID_HEADER]: credentials.storeId } : {},
+			...headers
+		}
+	};
+	delete next.command;
+	delete next.args;
+	delete next.env;
+	servers[MCP_SERVER_NAME] = next;
+	return `${JSON.stringify({
+		...root,
+		mcpServers: servers
+	}, null, 2)}\n`;
+}
+/** `sayren` 항목의 토큰·스토어. 항목·헤더가 없으면 null 값이다. 형식이 틀린 파일은 `McpJsonError` */
+function sayrenCredentialsOf(text) {
+	const root = parse(text);
+	const entry = (isObject(root.mcpServers) ? root.mcpServers : {})[MCP_SERVER_NAME];
+	const headers = isObject(entry) && isObject(entry.headers) ? entry.headers : {};
+	const authKey = headerKey(headers, "Authorization");
+	const storeKey = headerKey(headers, STORE_ID_HEADER);
+	const auth = authKey ? headers[authKey] : void 0;
+	const match = typeof auth === "string" ? /^Bearer\s+(\S+)\s*$/i.exec(auth) : null;
+	const store = storeKey ? headers[storeKey] : void 0;
+	return {
+		token: match?.[1] ?? null,
+		storeId: typeof store === "string" && store.trim() ? store.trim() : null
+	};
+}
+
+//#endregion
+//#region ../mcp/src/mcp-json-file.ts
+/**
+* `.mcp.json` 파일 쓰기(Node) — `sayren` CLI(packages/cli)와 `sayren-mcp create`가 같이 쓴다. 형식은 `mcp-json.ts`(Node 없음)다.
+*
+* 토큰을 파일에 그대로 쓰므로 두 경우에는 쓰지 않는다.
+* - git이 추적 중인 `.mcp.json`(팀이 커밋해 둔 설정): `.gitignore`는 추적 중인 파일을 막지 못해 다음 커밋에 토큰이 실린다.
+* - 심볼릭 링크: 링크를 따라 폴더 밖 파일에 토큰을 쓰지 않는다.
+*/
+/** 추적 중인 `.mcp.json`에 쓰지 않았을 때의 안내 */
+const TRACKED_MCP_JSON_NOTICE = `${MCP_JSON_FILE}가 git에 커밋돼 있어 토큰을 쓰지 않았습니다. 토큰을 파일에 두지 않으려면 SAYREN_TOKEN 환경 변수로 주십시오. 파일에 두려면 git rm --cached ${MCP_JSON_FILE}로 추적을 해제하고 .gitignore에 더한 뒤 다시 실행하십시오`;
+function git(dir, args) {
+	if (!existsSync(dir)) return null;
+	const result = spawnSync("git", args, {
+		cwd: dir,
+		stdio: "ignore",
+		timeout: 1e4
+	});
+	if (result.error || result.status === null) return null;
+	return result.status;
+}
+/** git이 이 파일을 추적하는가. git이 없거나 저장소가 아니면 false */
+function isGitTracked(dir, name) {
+	return git(dir, [
+		"ls-files",
+		"--error-unmatch",
+		"--",
+		name
+	]) === 0;
+}
+/** git이 이 파일을 무시하는가. git이 없거나 저장소가 아니면 null */
+function isGitIgnored(dir, name) {
+	const status$1 = git(dir, [
+		"check-ignore",
+		"-q",
+		"--",
+		name
+	]);
+	if (status$1 === 0) return true;
+	if (status$1 === 1) return false;
+	return null;
+}
+/** 심볼릭 링크면 쓰지 않는다(링크를 따라 폴더 밖 파일을 덮지 않게). 권한은 600이다 */
+function writePrivateFile(path, text) {
+	let link = false;
+	try {
+		link = lstatSync(path).isSymbolicLink();
+	} catch {
+		link = false;
+	}
+	if (link) throw new McpJsonError(`${path}가 심볼릭 링크라 쓰지 않았습니다. 링크를 지운 뒤 다시 실행하십시오`);
+	writeFileSync(path, text, { mode: 384 });
+	try {
+		chmodSync(path, 384);
+	} catch {}
+}
+/**
+* `sayren` 항목을 넣는다(다른 서버는 둔다). git이 추적 중인 파일이면 쓰지 않고 `"tracked"`다.
+* 형식이 틀린 파일·심볼릭 링크는 `McpJsonError`다.
+*/
+function writeMcpJsonFile(dir, credentials) {
+	if (isGitTracked(dir, MCP_JSON_FILE)) return "tracked";
+	const path = join(dir, MCP_JSON_FILE);
+	let existing = null;
+	try {
+		if (!lstatSync(path).isSymbolicLink()) existing = readFileSync(path, "utf8");
+	} catch {
+		existing = null;
+	}
+	writePrivateFile(path, mergeMcpJson(existing, credentials));
+	return "written";
+}
+
 //#endregion
 //#region ../mcp/src/rules.ts
 /** 문서 사이트 — `doc` 경로를 절대 주소로 만들 때 쓴다 */
@@ -407,7 +570,7 @@ function reportFromFindings(findings, checkedFiles, target = "local") {
 }
 
 //#endregion
-//#region ../hosting-sandbox/src/hash.ts
+//#region ../../apps/hosting-sandbox/src/hash.ts
 const strictUtf8 = new TextDecoder("utf-8", {
 	fatal: true,
 	ignoreBOM: true
@@ -422,9 +585,9 @@ function asUtf8(bytes) {
 }
 
 //#endregion
-//#region ../hosting-sandbox/src/verify.ts
+//#region ../../apps/hosting-sandbox/src/verify.ts
 /**
-* 규칙 검증. 원천은 `@sayren/mcp`의 규칙(apps/mcp/src/rules.ts)과 보고서(verify-report.ts)다 — stdio `verify_storefront`와
+* 규칙 검증. 원천은 `@sayren/mcp`의 규칙(packages/mcp/src/rules.ts)과 보고서(verify-report.ts)다 — stdio `verify_storefront`와
 * 같은 함수를 Worker가 직접 돌린다(컨테이너가 필요 없다). 대상은 stdio와 같은 소스 확장자다.
 */
 const SOURCE_RE = /\.(ts|tsx|js|jsx)$/;
@@ -439,7 +602,7 @@ function verifyTree(files) {
 }
 
 //#endregion
-//#region ../hosting-sandbox/src/paths.ts
+//#region ../../apps/hosting-sandbox/src/paths.ts
 const MAX_FILE_BYTES = 1024 * 1024;
 const MAX_TREE_BYTES = 20 * 1024 * 1024;
 const MAX_TREE_FILES = 2e3;
@@ -501,7 +664,7 @@ function accessOf(path) {
 }
 
 //#endregion
-//#region ../hosting-sandbox/src/tar.ts
+//#region ../../apps/hosting-sandbox/src/tar.ts
 const BLOCK = 512;
 const enc = new TextEncoder();
 const dec = new TextDecoder();
@@ -604,50 +767,135 @@ async function gunzip(bytes, maxBytes) {
 //#endregion
 //#region src/config.ts
 /**
-* 설정 — 우선순위는 플래그 > 환경 변수(`SAYREN_TOKEN`·`SAYREN_API_ORIGIN`) > `.env` > `.sayrenrc`다.
+* 설정 (2026-09-29 사용자 결정: `.sayrenrc`를 없애고 받은 폴더에 원격 MCP `.mcp.json`을 둔다)
 *
-* - `.sayrenrc`: pull이 만든다. 비밀이 없어 커밋해도 된다(`storeId`·`siteId`·`baseRef`, 기본이 아닌 api 주소).
-*   **토큰을 두지 않는다** — 읽을 때 `token` 같은 필드가 있으면 무시하고 경고한다.
-* - `.env`: 토큰(`SAYREN_TOKEN`)과 스토어프론트 템플릿이 읽는 값(`SAYREN_API_URL`·`SAYREN_STORE_CODE`). `.gitignore` 대상이다.
-*   템플릿은 `SAYREN_TOKEN`만 서버 코드 환경에 싣지 않는다(vite.config.ts).
+* - `.sayren/state.json`: pull·deploy가 쓰는 비밀 아닌 상태(`storeId`·`siteId`·`baseRef`, 기본이 아닌 api 주소). `.gitignore` 대상이고
+*   올리지 않는다. `baseRef`가 deploy의 `expectedBaseRef`다(원격이 pull 이후 바뀌었으면 `SOURCE_CHANGED`).
+* - `.mcp.json`: Claude Code 형식의 `sayren` 원격 MCP 항목. **토큰이 여기 있다**(Authorization 헤더). `.gitignore` 대상이고 올리지 않는다.
+* - `.env`: 스토어프론트 템플릿 개발 서버가 읽는 값(`SAYREN_API_URL`·`SAYREN_STORE_CODE`)만 둔다. 토큰을 두지 않는다.
+*
+* 토큰은 `--token` → `SAYREN_TOKEN` 환경 변수 → `.mcp.json` 순서다. api 주소는 `--api-origin` → `SAYREN_API_ORIGIN` → `.env`의
+* `SAYREN_API_URL` → 상태 파일 → 기본값 순서이고, 파일에서 온 기본이 아닌 주소는 확인한다(`checkAuthSources`).
+* 옛 폴더(`.sayrenrc`, `.env`의 `SAYREN_TOKEN`)는 한 번 옮긴다(`migrateLegacy`).
 */
-const RC_FILE = ".sayrenrc";
+const STATE_DIR = ".sayren";
+const STATE_FILE = `${STATE_DIR}/state.json`;
+/** 옛 상태 파일(0.1.x) — 읽어서 옮기고 지운다 */
+const LEGACY_RC_FILE = ".sayrenrc";
 const ENV_FILE = ".env";
+const MCP_FILE = MCP_JSON_FILE;
 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;
+function parseState(text, name) {
 	let parsed;
 	try {
-		parsed = JSON.parse(readFileSync(path, "utf8"));
+		parsed = JSON.parse(text);
 	} catch {
-		throw new CliError(`${RC_FILE}를 읽지 못했습니다. JSON 형식을 확인하십시오`);
+		throw new CliError(`${name}를 읽지 못했습니다. 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로 다시 받으십시오`);
+	if (!parsed || typeof parsed !== "object") throw new CliError(`${name} 형식이 아닙니다`);
+	const raw = parsed;
+	if (typeof raw.storeId !== "string" || typeof raw.siteId !== "string" || typeof raw.baseRef !== "string") throw new CliError(`${name}에 storeId·siteId·baseRef가 없습니다. npx sayren pull로 다시 받으십시오`);
 	return {
-		storeId: rc.storeId,
-		siteId: rc.siteId,
-		baseRef: rc.baseRef,
-		...typeof rc.apiOrigin === "string" ? { apiOrigin: rc.apiOrigin } : {}
+		storeId: raw.storeId,
+		siteId: raw.siteId,
+		baseRef: raw.baseRef,
+		...typeof raw.apiOrigin === "string" ? { apiOrigin: raw.apiOrigin } : {}
 	};
 }
-function writeRc(dir, rc) {
+function readState(dir) {
+	const path = join(dir, STATE_FILE);
+	if (!existsSync(path)) return null;
+	return parseState(readFileSync(path, "utf8"), STATE_FILE);
+}
+function writeState(dir, state) {
 	const out = {
-		storeId: rc.storeId,
-		siteId: rc.siteId,
-		baseRef: rc.baseRef
+		storeId: state.storeId,
+		siteId: state.siteId,
+		baseRef: state.baseRef
 	};
-	if (rc.apiOrigin && rc.apiOrigin !== DEFAULT_API_ORIGIN) out.apiOrigin = rc.apiOrigin;
-	writeFileSync(join(dir, RC_FILE), `${JSON.stringify(out, null, 2)}\n`);
+	if (state.apiOrigin && state.apiOrigin !== DEFAULT_API_ORIGIN) out.apiOrigin = state.apiOrigin;
+	mkdirSync(join(dir, STATE_DIR), { recursive: true });
+	writeFileSync(join(dir, STATE_FILE), `${JSON.stringify(out, null, 2)}\n`);
+}
+/** 받은 폴더인가 — 상태 파일 또는 옛 `.sayrenrc`가 있다 */
+function isPulledDir(dir) {
+	return existsSync(join(dir, STATE_FILE)) || existsSync(join(dir, LEGACY_RC_FILE));
+}
+function readMcpText(dir) {
+	const path = join(dir, MCP_FILE);
+	return existsSync(path) ? readFileSync(path, "utf8") : null;
+}
+/** `.mcp.json`의 `sayren` 토큰·스토어. 파일·항목이 없으면 null 값이다 */
+function readMcpCredentials(dir) {
+	const text = readMcpText(dir);
+	if (text === null) return {
+		token: null,
+		storeId: null
+	};
+	try {
+		return sayrenCredentialsOf(text);
+	} catch (error) {
+		if (error instanceof McpJsonError) throw new CliError(error.message);
+		throw error;
+	}
+}
+/** `.mcp.json`에 `sayren` 원격 MCP 항목을 쓴다. 다른 서버는 그대로 둔다. 파일 권한은 600이다(토큰) */
+/**
+* git이 추적 중인 `.mcp.json`(팀이 커밋해 둔 설정)에는 토큰을 쓰지 않고 `"tracked"`다 — 부르는 쪽이 `TRACKED_MCP_JSON_NOTICE`로 안내한다.
+* `.gitignore`는 추적 중인 파일을 막지 못한다.
+*/
+function writeMcpJson(dir, credentials) {
+	try {
+		return writeMcpJsonFile(dir, credentials);
+	} catch (error) {
+		if (error instanceof McpJsonError) throw new CliError(`${error.message}. 고치거나 옮긴 뒤 다시 시도하십시오(덮어쓰지 않았습니다)`);
+		throw error;
+	}
+}
+/** 권한 600. 심볼릭 링크면 거부한다(링크를 따라 폴더 밖 파일을 덮지 않게) */
+function writePrivate(path, text) {
+	try {
+		writePrivateFile(path, text);
+	} catch (error) {
+		if (error instanceof McpJsonError) throw new CliError(error.message);
+		throw error;
+	}
+}
+/**
+* 0.1.x가 받은 폴더를 한 번 옮긴다. `.sayrenrc` → `.sayren/state.json`(옛 파일은 지운다), `.env`의 `SAYREN_TOKEN` → `.mcp.json`
+* (`.env`에서 그 줄을 지운다). `.mcp.json`에 이미 토큰이 있으면 그 값을 쓰고 `.env` 줄만 지운다. 옮겼으면 한 줄로 알린다.
+*/
+function migrateLegacy(dir, notify) {
+	if (!isPulledDir(dir)) return;
+	const done = [];
+	const rcPath = join(dir, LEGACY_RC_FILE);
+	if (existsSync(rcPath)) {
+		const tracked = isGitTracked(dir, LEGACY_RC_FILE);
+		const hasState = existsSync(join(dir, STATE_FILE));
+		if (!hasState) writeState(dir, parseState(readFileSync(rcPath, "utf8"), LEGACY_RC_FILE));
+		if (!tracked) {
+			rmSync(rcPath, { force: true });
+			done.push(`${LEGACY_RC_FILE} → ${STATE_FILE}`);
+		} else if (!hasState) done.push(`${LEGACY_RC_FILE} → ${STATE_FILE}(${LEGACY_RC_FILE}는 더 쓰지 않으니 커밋에서 지워도 됩니다)`);
+	}
+	const envToken = readEnvFile(dir).get("SAYREN_TOKEN");
+	if (envToken !== void 0) {
+		const current = readMcpCredentials(dir);
+		let moved = true;
+		if (envToken.trim() && !current.token) if (writeMcpJson(dir, {
+			token: envToken.trim(),
+			storeId: current.storeId ?? readState(dir)?.storeId ?? null
+		}) === "tracked") {
+			moved = false;
+			notify(`알림: ${ENV_FILE}의 SAYREN_TOKEN을 옮기지 못했습니다. ${TRACKED_MCP_JSON_NOTICE}`);
+		} else done.push(`${ENV_FILE}의 SAYREN_TOKEN → ${MCP_FILE}`);
+		else done.push(`${ENV_FILE}의 SAYREN_TOKEN 삭제(${MCP_FILE}의 토큰을 씁니다)`);
+		if (moved) updateEnvFile(dir, {}, ["SAYREN_TOKEN"]);
+	}
+	if (done.length > 0) {
+		const ignored = ensureGitignore(dir);
+		notify(`알림: 옛 설정을 옮겼습니다 — ${done.join(", ")}${ignored.length ? ` (.gitignore에 ${ignored.join(" ")} 추가)` : ""}`);
+	}
 }
 /** `.env` 읽기 — `KEY=VALUE` 줄만(따옴표는 벗긴다). 없으면 빈 값 */
 function readEnvFile(dir) {
@@ -663,60 +911,80 @@ function readEnvFile(dir) {
 	}
 	return out;
 }
-/** `.env`에 값들을 쓴다 — 다른 줄은 그대로 두고 같은 키만 바꾼다. 파일 권한은 600이다(토큰) */
-function updateEnvFile(dir, values) {
+/** `.env`에 값들을 쓴다. 다른 줄은 그대로 두고 같은 키만 바꾸거나(`values`) 지운다(`remove`). 파일 권한은 600이다 */
+function updateEnvFile(dir, values, remove = []) {
 	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 next = [];
+	for (const line of lines) {
 		const key = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/.exec(line)?.[1];
+		if (key && remove.includes(key)) continue;
 		if (key && pending.has(key)) {
-			const value = pending.get(key);
+			next.push(`${key}=${pending.get(key)}`);
 			pending.delete(key);
-			return `${key}=${value}`;
+			continue;
 		}
-		return line;
-	});
+		next.push(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 {}
+	writePrivate(path, next.length ? `${next.join("\n")}\n` : "");
 }
-/** `.gitignore`에 `.env`가 없으면 더한다. 더했으면 true */
+/** `.gitignore`에 꼭 있어야 하는 줄 — 토큰(`.mcp.json`)·개발 서버 값(`.env`)·CLI 상태(`.sayren/`) */
+const REQUIRED_IGNORES = [
+	ENV_FILE,
+	MCP_FILE,
+	`${STATE_DIR}/`
+];
+const IGNORE_ALIASES = {
+	[ENV_FILE]: [
+		".env",
+		".env*",
+		"/.env"
+	],
+	[MCP_FILE]: [".mcp.json", "/.mcp.json"],
+	[`${STATE_DIR}/`]: [
+		".sayren",
+		".sayren/",
+		"/.sayren",
+		"/.sayren/"
+	]
+};
+/** `.gitignore`에 빠진 줄(`.env`·`.mcp.json`·`.sayren/`)을 더한다. 더한 줄을 돌려준다 */
 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;
+	const lines = new Set(text.split(/\r?\n/).map((line) => line.trim()));
+	const missing = REQUIRED_IGNORES.filter((entry) => !(IGNORE_ALIASES[entry] ?? [entry]).some((alias) => lines.has(alias)));
+	if (missing.length === 0) return [];
+	writeFileSync(path, `${text}${text && !text.endsWith("\n") ? "\n" : ""}${missing.map((entry) => `${entry}\n`).join("")}`);
+	return missing;
 }
 /** 스토어프론트 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) {
+function resolveAuth(flags, dir, state, 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 fromFile = fromFlag || fromEnv ? null : readMcpCredentials(dir).token;
 	const token = fromFlag || fromEnv || fromFile;
-	if (!token) throw new CliError("토큰이 없습니다. --token으로 주거나 SAYREN_TOKEN 환경 변수·.env에 넣으십시오(셀러 콘솔 › 개발자 › API 토큰, 스코프 storefront:rw)");
+	if (!token) throw new CliError(`토큰이 없습니다. npx sayren login으로 ${MCP_FILE}에 저장하거나 SAYREN_TOKEN 환경 변수·--token으로 주십시오(셀러 콘솔 › 개발자 › 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]
+		["state", state?.apiOrigin]
 	].find(([, value]) => value);
 	const apiOrigin = (picked?.[1] ?? DEFAULT_API_ORIGIN).replace(/\/+$/, "");
 	assertOriginShape(apiOrigin);
 	return {
 		token,
 		apiOrigin,
-		tokenSource: fromFlag ? "flag" : fromEnv ? "env" : ".env",
+		tokenSource: fromFlag ? "flag" : fromEnv ? "env" : "mcp",
 		originSource: picked && apiOrigin !== DEFAULT_API_ORIGIN ? picked[0] : "default"
 	};
 }
@@ -748,6 +1016,20 @@ var CliError = class extends Error {
 
 //#endregion
 //#region src/tree.ts
+/**
+* 로컬 작업 트리 — 서버 작업 트리와 **같은 경로 규칙**(편집 Sandbox `paths.ts`의 `accessOf`)으로 고른다. `src/**`·`public/**`·루트 설정
+* 파일·`package.json`·`pnpm-lock.yaml`만 올리고, `.env*`·`.mcp.json`·`.sayren/`·`node_modules`·`dist`·`package-lock.json` 등은 올리지 않는다.
+* 비밀·로컬 상태 파일(`isNeverUpload`)은 서버 경로 규칙과 별개로 CLI가 먼저 막는다 — 서버 규칙이 넓어져도 토큰을 올리지 않게.
+*/
+/**
+* 어떤 경우에도 올리지 않는 파일 — `.env*`(개발 서버 값), `.mcp.json`(토큰), `.sayren/`(CLI 상태), 옛 `.sayrenrc`.
+* 폴더 깊이와 무관하게 이름으로 본다.
+*/
+function isNeverUpload(path) {
+	const segments = path.split("/");
+	const name = segments[segments.length - 1] ?? "";
+	return segments.some((segment) => segment.startsWith(".env") || segment === ".sayren") || name === ".mcp.json" || name === ".sayrenrc";
+}
 /** 걸어 들어가지 않는 폴더 — 설치물·산출물·캐시·VCS(경로 규칙이 어차피 막는다. 크기 때문에 읽지도 않는다) */
 const SKIP_DIRS = new Set([
 	"node_modules",
@@ -778,7 +1060,7 @@ function collectTree(root) {
 				skipped.push(rel);
 				continue;
 			}
-			if (accessOf(rel) === null) {
+			if (isNeverUpload(rel) || accessOf(rel) === null) {
 				skipped.push(rel);
 				continue;
 			}
@@ -980,20 +1262,22 @@ 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`으로 명시해야 한다)
+* 토큰·api 주소 확인 — `--token`은 셸 기록·프로세스 목록에 남으니 알리고, 파일(`.env`·`.sayren/state.json`)에서 읽은 기본이 아닌 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;
+	if (auth.originSource !== ".env" && auth.originSource !== "state") return;
+	const from = auth.originSource === ".env" ? ".env의 SAYREN_API_URL" : STATE_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);
+	const authDir = existsSync(probeDir) ? probeDir : io.cwd;
+	migrateLegacy(authDir, io.out);
+	const auth = resolveAuth(flags, authDir, null, io.env);
 	await checkAuthSources(auth, io);
 	const client = clientOf(auth, io.fetch);
 	const hosting = await client.storefront.get();
@@ -1006,17 +1290,29 @@ async function pull(flags, io) {
 		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 target = !flags.dir && isPulledDir(io.cwd) ? io.cwd : resolve(io.cwd, flags.dir ?? defaultDir);
+	if (target !== authDir) migrateLegacy(target, io.out);
 	const existing = existsSync(target) ? readdirSync(target) : [];
 	if (existing.length > 0) {
 		if (!flags.force) throw new CliError(`폴더가 비어 있지 않습니다: ${relativeOf(io, target)}. 같은 사이트를 받은 폴더면 --force로 원격 작업 트리를 다시 받을 수 있습니다`);
-		let rc = null;
+		let state = null;
 		try {
-			rc = readRc(target);
+			state = readState(target);
 		} catch {
-			rc = null;
+			state = null;
+		}
+		if (state && state.siteId !== source.siteId) throw new CliError(`${relativeOf(io, target)}는 다른 사이트(${state.siteId})를 받은 폴더입니다. 빈 폴더를 지정하십시오`);
+		if (!state) {
+			if (!flags.project) throw new CliError(`${relativeOf(io, target)}는 이 사이트(${source.siteId})를 받은 폴더가 아닙니다(${STATE_FILE} 없음). 이 사이트 소스를 clone한 폴더면 --project ${source.storeId}를 함께 주십시오. 아니면 빈 폴더를 지정하십시오`);
+			io.out(`${relativeOf(io, target)}에 ${STATE_FILE}가 없습니다. 이 폴더를 사이트 ${source.siteId}의 소스 폴더로 받아들이고 원격 작업 트리로 맞춥니다`);
+			if (!flags.yes) {
+				if (!io.confirm) throw new CliError("받은 폴더가 아닌 곳을 원격 작업 트리로 맞춥니다. 확인할 수 없는 환경이면 --yes를 함께 주십시오");
+				if (!await io.confirm("이 폴더를 이 사이트의 소스 폴더로 쓰겠습니까?")) {
+					io.out("취소했습니다");
+					return 1;
+				}
+			}
 		}
-		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 = [];
@@ -1054,36 +1350,31 @@ async function pull(flags, io) {
 	mkdirSync(target, { recursive: true });
 	writeTree(target, files, existing.length > 0 ? diff.remove : []);
 	const removed = existing.length > 0 ? diff.remove.length : 0;
-	writeRc(target, {
+	writeState(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
-	});
+	}, ["SAYREN_TOKEN"]);
 	const addedIgnore = ensureGitignore(target);
+	const written = writeMcpJson(target, {
+		token: auth.token,
+		storeId: store.storeId
+	});
 	io.out(`받음 → ${relativeOf(io, target)} (${files.size}개${removed ? `, 원격에 없는 ${removed}개 지움` : ""})`);
-	io.out(`${RC_FILE} 작성 — 사이트 ${source.siteId}. 커밋해도 됩니다(비밀 없음)`);
-	io.out(`${ENV_FILE} 작성 — 토큰과 스토어프론트 API 주소. 커밋하지 마십시오${addedIgnore ? "(.gitignore에 더했습니다)" : ""}`);
+	if (written === "tracked") io.out(`알림: ${TRACKED_MCP_JSON_NOTICE}`);
+	else io.out(`${MCP_FILE} 작성 — sayren 원격 MCP(${REMOTE_MCP_URL})와 토큰. AI 에이전트가 이 폴더에서 바로 연결합니다. 커밋하지 마십시오`);
+	if (written === "written" && auth.apiOrigin !== DEFAULT_API_ORIGIN) io.out(`알림: 원격 MCP는 운영 api(${DEFAULT_API_ORIGIN})에만 연결됩니다. ${auth.apiOrigin}의 토큰으로는 ${MCP_FILE}의 연결이 거부됩니다`);
+	io.out(`${ENV_FILE} 작성 — 스토어프론트 API 주소·스토어 코드(개발 서버용)`);
+	io.out(`${STATE_FILE} 작성 — 사이트 ${source.siteId}·받은 작업 트리${addedIgnore.length ? ` (.gitignore에 ${addedIgnore.join(" ")} 추가)` : ""}`);
 	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);
@@ -1101,15 +1392,24 @@ function printChecks(tree, checks, io) {
 	}
 	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));
+	const secrets = tree.skipped.filter(isNeverUpload);
 	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로 사이트 소스를 받으십시오`);
+	migrateLegacy(dir, io.out);
+	const rc = readState(dir);
+	if (!rc) {
+		let storeId = null;
+		try {
+			storeId = readMcpCredentials(dir).storeId;
+		} catch {
+			storeId = null;
+		}
+		throw new CliError(`${STATE_FILE}가 없습니다. 이 사이트 소스를 clone한 폴더면 npx sayren pull --force --project ${storeId ?? "<storeId>"} --dir ${relativeOf(io, dir)}로 이 폴더를 원격 작업 트리에 맞춘 뒤(로컬 변경은 먼저 커밋·백업하십시오) 다시 배포하십시오. 처음이면 npx sayren pull로 받으십시오`);
+	}
 	const auth = resolveAuth(flags, dir, rc, io.env);
 	await checkAuthSources(auth, io);
 	const client = clientOf(auth, io.fetch);
@@ -1138,7 +1438,7 @@ async function deploy(flags, io) {
 		}
 		throw error;
 	}
-	writeRc(dir, {
+	writeState(dir, {
 		...rc,
 		baseRef: replaced.sourceRef
 	});
@@ -1245,6 +1545,7 @@ const REASON_LABEL = {
 	MALWARE: "악성 패키지",
 	INVALID_MANIFEST: "선언 오류",
 	INSTALL_SCRIPT: "설치 스크립트",
+	INSTALL_CONFIG: "설치 방식 필드",
 	UNSUPPORTED_SOURCE: "지원하지 않는 설치 경로",
 	BUNDLED_DEPENDENCIES: "묶인 의존성"
 };
@@ -1307,7 +1608,8 @@ function printBuildFailure(build, io) {
 }
 async function status(flags, io) {
 	const dir = resolve(io.cwd, flags.dir ?? ".");
-	const rc = readRc(dir);
+	migrateLegacy(dir, io.out);
+	const rc = readState(dir);
 	const auth = resolveAuth(flags, dir, rc, io.env);
 	await checkAuthSources(auth, io);
 	const client = clientOf(auth, io.fetch);
@@ -1334,16 +1636,45 @@ 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({
+	migrateLegacy(dir, io.out);
+	const state = readState(dir);
+	const client = clientOf(resolveAuth({
 		...flags,
 		token
-	}, dir, readRc(dir), io.env), io.fetch).storefront.get();
+	}, dir, state, io.env), io.fetch);
+	const hosting = await client.storefront.get();
+	const expected = existsSync(dir) ? state?.storeId ?? readMcpCredentials(dir).storeId : null;
+	const tokenStore = await tokenStoreOf(client, hosting, expected !== null);
+	if (expected && tokenStore && tokenStore !== expected) throw new CliError(`토큰의 스토어(${tokenStore})가 이 폴더의 스토어(${expected})와 다릅니다. ${expected}에서 발급한 토큰을 쓰십시오(저장하지 않았습니다)`);
+	if (expected && !tokenStore) io.err(`경고: 토큰의 스토어를 확인하지 못했습니다. ${MCP_FILE}의 X-Store-Id(${expected})와 다르면 원격 MCP가 연결을 거부합니다`);
 	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를 더했습니다)" : ""}`);
+	if (writeMcpJson(dir, {
+		token,
+		storeId: expected ?? tokenStore
+	}) === "tracked") {
+		io.err(`알림: ${TRACKED_MCP_JSON_NOTICE}`);
+		return 1;
+	}
+	const addedIgnore = isPulledDir(dir) ? ensureGitignore(dir) : [];
+	io.out(`토큰을 확인하고(사이트 ${hosting.site?.hostname ?? "없음"}) ${relativeOf(io, join(dir, MCP_FILE))}에 저장했습니다(sayren 원격 MCP 설정)${addedIgnore.length ? ` (.gitignore에 ${addedIgnore.join(" ")} 추가)` : ""}`);
+	if (!isPulledDir(dir) && isGitIgnored(dir, MCP_FILE) === false) io.err(`경고: git이 ${MCP_FILE}를 무시하지 않습니다. 토큰이 들어 있으니 .gitignore에 ${MCP_FILE}를 더하십시오`);
 	return 0;
 }
+/**
+* 토큰의 스토어 — `GET /v1/store`(스코프 `store:r`)가 먼저다. 없으면(storefront 스코프만 있는 토큰) `need`일 때만 작업 트리 조회에서 읽는다
+* (그 조회는 지금 트리를 스냅샷으로 고정하므로 대조할 값이 있을 때만 부른다). 모르면 null
+*/
+async function tokenStoreOf(client, hosting, need) {
+	try {
+		return (await client.store.get()).storeId;
+	} catch {}
+	if (!need || !hosting.site || !hosting.editingEnabled) return null;
+	try {
+		return (await client.storefront.getSource()).storeId;
+	} catch {
+		return null;
+	}
+}
 function relativeOf(io, path) {
 	return relative(io.cwd, path) || ".";
 }
@@ -1353,20 +1684,21 @@ function relativeOf(io, path) {
 const USAGE = `sayren ${CLI_VERSION} — 호스팅 스토어프론트 CLI
 
 사용법:
-  npx sayren login                       # 토큰을 입력받아 .env에 저장(셸 기록에 남지 않습니다)
+  npx sayren login                       # 토큰을 입력받아 .mcp.json에 저장(셸 기록에 남지 않습니다)
   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를 씁니다
+  login    토큰을 확인하고 지금 폴더의 .mcp.json(sayren 원격 MCP 설정)에 저장합니다
+  pull     호스팅 중인 사이트의 작업 트리를 폴더(기본: 스토어 코드)로 받고 .mcp.json·.env·.sayren/state.json을 씁니다
   deploy   로컬 검사 → 작업 트리 올리기 → 빌드 → 발행. 원격이 pull 이후 바뀌었으면 덮어쓰지 않습니다
   status   사이트·발행 버전·최근 빌드·편집 환경
   verify   로컬 규칙·경로·크기 검사(서버 빌드와 같은 규칙)
 
-토큰은 SAYREN_TOKEN 환경 변수 → .env 순서로 읽습니다(API 토큰 sy_pat_…, 스코프 storefront:rw).
+토큰은 --token → SAYREN_TOKEN 환경 변수 → .mcp.json 순서로 읽습니다(API 토큰 sy_pat_…, 스코프 storefront:rw).
+.mcp.json·.env·.sayren/은 .gitignore에 더하고 배포에 올리지 않습니다.
 
 옵션:
   --project <storeId>  pull: 토큰의 스토어와 같아야 합니다

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sayren",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "description": "sayren 스토어프론트 CLI — 호스팅 중인 사이트의 소스를 내려받고(pull) 로컬에서 고친 뒤 배포(deploy)합니다",
   "bin": {
@@ -13,7 +13,7 @@
     "node": ">=20.10"
   },
   "dependencies": {
-    "@sayren/store-sdk": "^0.22.0"
+    "@sayren/store-sdk": "^0.23.0"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.5.14",