sayren 0.2.0 → 0.3.1

package/dist/index.mjs

@@ -1,28 +1,35 @@
 #!/usr/bin/env node
+import { spawn, spawnSync } from "node:child_process";
 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 { chmodSync, closeSync, existsSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { dirname, join, relative, resolve, sep } from "node:path";
-import { spawnSync } from "node:child_process";
-import { createHash } from "node:crypto";
+import { createHash, randomBytes } from "node:crypto";
+import { createServer } from "node:http";
 
 //#region package.json
-var version = "0.2.0";
+var version = "0.3.1";
 
 //#endregion
 //#region src/client.ts
 /**
 * 관리 API 클라이언트 — `@sayren/store-sdk`(계약의 원천)를 쓴다. User-Agent `sayren-cli/{버전}`은 api가 버전의 만든 경로
-* (`createdVia: CLI`)를 적는 표시다(권한과 무관하다. 에이전트 PAT면 행위자는 여전히 에이전트이고 발행은 승인 대기다).
+* (`createdVia: CLI`)를 적는 표시다(권한과 무관하다. 에이전트용 액세스 토큰이면 행위자는 여전히 에이전트이고 발행은 승인 대기다).
 * 토큰은 헤더에만 싣고 화면·로그에 찍지 않는다.
 */
 const CLI_VERSION = version;
 const CLI_USER_AGENT = `sayren-cli/${CLI_VERSION}`;
-function clientOf(auth, fetchImpl = fetch) {
+/**
+* 계정 토큰(#71)을 Bearer로, 고른 상점(`auth.storeId`)을 `X-Store-Id`로 싣는다. 401이면 `refresh`(자격 증명 파일의 refresh 회전)를
+* 한 번 부른 뒤 다시 보낸다. 토큰·상점은 함수로 읽어 갱신·선택된 값을 따라간다.
+*/
+function clientOf(auth, fetchImpl = fetch, refresh) {
 	return createStoreClient({
 		baseUrl: `${auth.apiOrigin}/v1`,
-		auth: { apiToken: auth.token },
+		accessToken: () => auth.token,
+		storeId: () => auth.storeId ?? null,
+		...refresh ? { refresh } : {},
 		fetch: (input, init) => {
 			const headers = new Headers(init?.headers);
 			headers.set("user-agent", CLI_USER_AGENT);
@@ -41,6 +48,103 @@ function detailsOf(error) {
 	return error instanceof ApiError ? error.details ?? {} : {};
 }
 
+//#endregion
+//#region ../mcp/src/account-token.ts
+/**
+* 계정 토큰(#71) — accounts가 서명한 RFC 9068 JWT access token(`typ: at+jwt`)을 알아보는 도구와 accounts 주소.
+*
+* CLI(`sayren login`)·stdio MCP·원격 게이트웨이가 같이 쓴다. **Node 전용 API를 쓰지 않는다**(게이트웨이 Worker 번들에 들어간다).
+* 계약의 원천은 비공개 패키지 `@sayren/contracts`(`accounts.ts`)다. CLI·`@sayren/mcp`는 npm에 게시되므로 그 패키지에 의존하지 않고
+* 값을 옮겨 두었다 — `account-token.test.ts`가 계약과 대조한다.
+*
+* 여기의 디코딩은 **서명을 보지 않는다**. 모양(헤더 `typ`)으로 경로를 고르고 상점 범위를 읽는 데만 쓴다. 판정은 api(매 요청 서명·폐기
+* 확인)와 게이트웨이(`apps/mcp-gateway/src/auth.ts`, JWKS 서명 확인)가 한다.
+*/
+/** JWT access token 헤더 `typ`(RFC 9068 §2.1) — 계약 `ACCOUNT_ACCESS_TOKEN_TYPE` */
+const ACCOUNT_ACCESS_TOKEN_TYPE = "at+jwt";
+const PROD_ACCOUNTS_ORIGIN = "https://accounts.sayren.app";
+const DEV_ACCOUNTS_ORIGIN = "http://localhost:4008";
+const PROD_API_ORIGIN = "https://api.sayren.app";
+const DEV_API_ORIGIN = "http://localhost:4001";
+/** CLI의 accounts 클라이언트(public, PKCE, 루프백 임의 포트, 디바이스 코드) — accounts `token-config.ts` `CLI_CLIENT_ID` */
+const CLI_CLIENT_ID = "sayren-cli";
+/** CLI 로그인 스코프 — 상점 목록·상점 정보 조회·스토어프론트(pull·deploy) */
+const CLI_LOGIN_SCOPE = "openid email offline_access stores:read store:r storefront:rw";
+/** accounts 엔드포인트(Better Auth `basePath` `/api/auth`) */
+function accountsEndpoints(accountsOrigin) {
+	const base = `${accountsOrigin.replace(/\/+$/, "")}/api/auth`;
+	return {
+		authorize: `${base}/oauth2/authorize`,
+		token: `${base}/oauth2/token`,
+		revoke: `${base}/oauth2/revoke`,
+		deviceCode: `${base}/device/code`,
+		jwks: `${base}/jwks`
+	};
+}
+/**
+* api origin에 맞는 accounts origin — 운영 api면 운영 accounts, 로컬 api(4001)면 로컬 accounts(4008). 그 밖은 모른다(null) —
+* 부르는 쪽이 명시 값(`--accounts-origin`·`SAYREN_ACCOUNTS_ORIGIN`)을 요구한다.
+*/
+function accountsOriginFor(apiOrigin) {
+	const origin = apiOrigin.replace(/\/+$/, "");
+	if (origin === PROD_API_ORIGIN) return PROD_ACCOUNTS_ORIGIN;
+	if (origin === DEV_API_ORIGIN || origin === "http://127.0.0.1:4001") return DEV_ACCOUNTS_ORIGIN;
+	return null;
+}
+function base64UrlDecode(segment) {
+	const base64 = segment.replace(/-/g, "+").replace(/_/g, "/");
+	const binary = atob(base64 + "=".repeat((4 - base64.length % 4) % 4));
+	const bytes = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+	return new TextDecoder().decode(bytes);
+}
+const JWT_RE = /^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/;
+/** 헤더·클레임을 읽는다(서명은 보지 않는다). JWT가 아니면 null */
+function decodeJwt(token) {
+	if (token.length > 8192 || !JWT_RE.test(token)) return null;
+	const [header, payload] = token.split(".");
+	try {
+		const parsedHeader = JSON.parse(base64UrlDecode(header));
+		const parsedClaims = JSON.parse(base64UrlDecode(payload));
+		if (!parsedHeader || typeof parsedHeader !== "object" || !parsedClaims || typeof parsedClaims !== "object") return null;
+		return {
+			header: parsedHeader,
+			claims: parsedClaims
+		};
+	} catch {
+		return null;
+	}
+}
+/** 계정 토큰(헤더 `typ: at+jwt`)이면 클레임, 아니면 null(서명은 보지 않는다) */
+function accountTokenClaimsOf(token) {
+	const decoded = decodeJwt(token);
+	if (!decoded || decoded.header.typ !== ACCOUNT_ACCESS_TOKEN_TYPE) return null;
+	return decoded.claims;
+}
+function isAccountToken(token) {
+	return accountTokenClaimsOf(token) !== null;
+}
+/**
+* 폐기된 옛 상점 API 토큰(`sy_pat_…`) — #71 R1 뒤 api가 받지 않는다(401 `TOKEN_TYPE_RETIRED`). 받는 쪽은 api에 보내지 않고
+* 계정 액세스 토큰을 만들라고 바로 안내한다.
+*/
+function isRetiredStorePat(token) {
+	return token.startsWith("sy_pat_");
+}
+/** 토큰의 상점 범위가 상점 하나면 그 id(헤더 없이 쓸 수 있다). 아니면 null */
+function singleStoreOf(claims) {
+	const stores = claims?.sayren_stores;
+	return Array.isArray(stores) && stores.length === 1 && typeof stores[0] === "string" ? stores[0] : null;
+}
+/** 이 상점이 토큰의 범위 안인가 */
+function storeInScope(claims, storeId) {
+	const stores = claims?.sayren_stores;
+	if (stores === "*") return true;
+	return Array.isArray(stores) && stores.includes(storeId);
+}
+/** 토큰 발급 시 선택한 상점 id 형식(관리 API `X-Store-Id`) */
+const STORE_ID_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
+
 //#endregion
 //#region ../mcp/src/mcp-json.ts
 /**
@@ -49,15 +153,17 @@ function detailsOf(error) {
 * `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). 토큰을 다른 스토어 것으로 바꿔 넣는 실수를 막는다.
+* - **토큰을 쓰지 않는다(#71)** — 항목은 주소와 `X-Store-Id`뿐이고 MCP 클라이언트가 게이트웨이의 401 + `resource_metadata`를 보고
+*   스스로 OAuth(accounts)를 한다. 계정 토큰은 폴더가 아니라 사람에게 속한다(CLI는 사용자 설정 폴더에 둔다).
+* - 폐기된 옛 API 토큰(`sy_pat_…`)이 든 `Authorization` 헤더는 쓸 때 지운다(R1 뒤 게이트웨이가 거절한다). 셀러가 직접 넣은 다른
+*   `Authorization`(계정 액세스 토큰)은 그대로 둔다.
+* - 다른 서버 항목과 `sayren` 항목의 다른 헤더는 그대로 둔다. `sayren` 항목의 `type`·`url`·상점 헤더만 바꾼다.
 */
 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`가 토큰의 스토어와 대조한다) */
+/** 관리 API의 테넌트 헤더와 같은 이름이다(게이트웨이·api가 토큰의 상점 범위와 대조한다) */
 const STORE_ID_HEADER = "X-Store-Id";
 var McpJsonError = class extends Error {
 	constructor(message) {
@@ -82,26 +188,30 @@ function headerKey(headers, name) {
 	const lower = name.toLowerCase();
 	return Object.keys(headers).find((key) => key.toLowerCase() === lower);
 }
+/** `Authorization` 헤더 값이 폐기된 옛 API 토큰(`Bearer sy_pat_…`)인가 */
+function isRetiredAuthorization(value) {
+	return typeof value === "string" && /^Bearer\s+sy_pat_/i.test(value.trim());
+}
 /**
-* `sayren` 항목을 넣거나 바꾼 `.mcp.json` 본문. `existing`이 없으면 새 파일이다.
+* `sayren` 항목을 넣거나 바꾼 `.mcp.json` 본문. `existing`이 없으면 새 파일이다. 폐기된 옛 토큰 헤더는 지운다(`removedRetiredToken`).
 * 형식이 틀린 파일은 덮어쓰지 않고 `McpJsonError`다(셀러가 손으로 쓴 다른 서버 설정을 지우지 않게).
 */
-function mergeMcpJson(existing, credentials) {
+function mergeMcpJson(existing, entry) {
 	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 storeKey = headerKey(headers, STORE_ID_HEADER);
+	if (storeKey) delete headers[storeKey];
+	const authKey = headerKey(headers, "Authorization");
+	const removedRetiredToken = !!authKey && isRetiredAuthorization(headers[authKey]);
+	if (authKey && removedRetiredToken) delete headers[authKey];
 	const next = {
 		...previous,
 		type: "http",
 		url: REMOTE_MCP_URL,
 		headers: {
-			Authorization: `Bearer ${credentials.token}`,
-			...credentials.storeId ? { [STORE_ID_HEADER]: credentials.storeId } : {},
+			...entry.storeId ? { [STORE_ID_HEADER]: entry.storeId } : {},
 			...headers
 		}
 	};
@@ -109,38 +219,30 @@ function mergeMcpJson(existing, credentials) {
 	delete next.args;
 	delete next.env;
 	servers[MCP_SERVER_NAME] = next;
-	return `${JSON.stringify({
-		...root,
-		mcpServers: servers
-	}, null, 2)}\n`;
+	return {
+		text: `${JSON.stringify({
+			...root,
+			mcpServers: servers
+		}, null, 2)}\n`,
+		removedRetiredToken
+	};
 }
-/** `sayren` 항목의 토큰·스토어. 항목·헤더가 없으면 null 값이다. 형식이 틀린 파일은 `McpJsonError` */
-function sayrenCredentialsOf(text) {
+/** `sayren` 항목의 상점(`X-Store-Id`). 항목·헤더가 없으면 null이다. 형식이 틀린 파일은 `McpJsonError` */
+function sayrenStoreIdOf(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
-	};
+	return 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`는 추적 중인 파일을 막지 못해 다음 커밋에 토큰이 실린다.
-* - 심볼릭 링크: 링크를 따라 폴더 밖 파일에 토큰을 쓰지 않는다.
+* 항목에 토큰을 쓰지 않는다(#71 R1). 심볼릭 링크는 따라가지 않는다(폴더 밖 파일을 덮지 않게).
 */
-/** 추적 중인 `.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, {
@@ -160,51 +262,767 @@ function isGitTracked(dir, name) {
 		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;
+		link = false;
+	}
+	if (link) throw new McpJsonError(`${path}가 심볼릭 링크라 쓰지 않았습니다. 링크를 지운 뒤 다시 실행하십시오`);
+	writeFileSync(path, text, { mode: 384 });
+	try {
+		chmodSync(path, 384);
+	} catch {}
+}
+/** `.mcp.json`에서 폐기된 옛 API 토큰 헤더를 지웠을 때의 안내 */
+const RETIRED_MCP_TOKEN_NOTICE = `${MCP_JSON_FILE}의 sayren 항목에서 옛 API 토큰(sy_pat_)을 지웠습니다. 옛 토큰은 더 쓸 수 없습니다 — MCP 클라이언트가 연결할 때 Sayren 계정으로 로그인합니다`;
+/**
+* `sayren` 항목을 넣는다(다른 서버는 둔다). 폐기된 옛 토큰 헤더를 지웠으면 `"retired-token-removed"`다(`RETIRED_MCP_TOKEN_NOTICE`).
+* 형식이 틀린 파일·심볼릭 링크는 `McpJsonError`다.
+*/
+function writeMcpJsonFile(dir, entry) {
+	const path = join(dir, MCP_JSON_FILE);
+	let existing = null;
+	try {
+		if (!lstatSync(path).isSymbolicLink()) existing = readFileSync(path, "utf8");
+	} catch {
+		existing = null;
+	}
+	const { text, removedRetiredToken } = mergeMcpJson(existing, entry);
+	writePrivateFile(path, text);
+	return removedRetiredToken ? "retired-token-removed" : "written";
+}
+
+//#endregion
+//#region src/config.ts
+/**
+* 설정 (2026-09-29 사용자 결정: `.sayrenrc`를 없애고 받은 폴더에 원격 MCP `.mcp.json`을 둔다)
+*
+* - `.sayren/state.json`: pull·deploy가 쓰는 비밀 아닌 상태(`storeId`·`siteId`·`baseRef`, 기본이 아닌 api 주소). `.gitignore` 대상이고
+*   올리지 않는다. `baseRef`가 deploy의 `expectedBaseRef`다(원격이 pull 이후 바뀌었으면 `SOURCE_CHANGED`).
+* - `.mcp.json`: Claude Code 형식의 `sayren` 원격 MCP 항목. 주소와 `X-Store-Id`만 있고 토큰은 없다(#71 — MCP 클라이언트가
+*   연결할 때 스스로 로그인한다). 옛 폴더의 폐기된 토큰(`sy_pat_…`) 헤더는 쓸 때 지운다. `.gitignore` 대상이고 올리지 않는다.
+* - `.env`: 스토어프론트 템플릿 개발 서버가 읽는 값(`SAYREN_API_URL`·`SAYREN_STORE_CODE`)만 둔다. 토큰을 두지 않는다.
+* - 계정 토큰은 폴더가 아니라 사람에게 속한다 — 사용자 설정 폴더의 `credentials.json`(`credentials.ts`)에 둔다.
+*
+* 토큰은 계정 토큰(accounts JWT)만 받는다. `--token` → `SAYREN_TOKEN` 환경 변수 → 자격 증명 파일(`npx sayren login`) 순서다.
+* 옛 API 토큰(`sy_pat_…`)은 R1에서 폐기되어 api에 보내지 않고 거절한다(`RETIRED_TOKEN_MESSAGE`).
+* api 주소는 `--api-origin` → `SAYREN_API_ORIGIN` → `.env`의
+* `SAYREN_API_URL` → 상태 파일 → 기본값 순서이고, 파일에서 온 기본이 아닌 주소는 확인한다(`checkAuthSources`).
+* 옛 폴더(`.sayrenrc`, `.env`의 `SAYREN_TOKEN`)는 한 번 정리한다(`migrateLegacy`).
+*/
+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";
+function parseState(text, name) {
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch {
+		throw new CliError(`${name}를 읽지 못했습니다. JSON 형식을 확인하십시오`);
+	}
+	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: raw.storeId,
+		siteId: raw.siteId,
+		baseRef: raw.baseRef,
+		...typeof raw.apiOrigin === "string" ? { apiOrigin: raw.apiOrigin } : {}
+	};
+}
+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: state.storeId,
+		siteId: state.siteId,
+		baseRef: state.baseRef
+	};
+	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` 상점(`X-Store-Id`). 파일·항목이 없으면 null이다 */
+function readMcpStoreId(dir) {
+	const text = readMcpText(dir);
+	if (text === null) return null;
+	try {
+		return sayrenStoreIdOf(text);
+	} catch (error) {
+		if (error instanceof McpJsonError) throw new CliError(error.message);
+		throw error;
+	}
+}
+/**
+* `.mcp.json`에 `sayren` 원격 MCP 항목(주소·`X-Store-Id`)을 쓴다. 다른 서버는 그대로 둔다. 파일 권한은 600이다.
+* 폐기된 옛 토큰 헤더를 지웠으면 `"retired-token-removed"`다(`RETIRED_MCP_TOKEN_NOTICE`).
+*/
+function writeMcpJson(dir, entry) {
+	try {
+		return writeMcpJsonFile(dir, entry);
+	} 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`(`sy_pat_…`)은
+* 지운다(R1 뒤 쓸 수 없다). 다른 값이 든 `SAYREN_TOKEN` 줄은 두고(CLI는 읽지 않는다) 알린다. 정리했으면 한 줄로 알린다.
+*/
+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")?.trim();
+	if (envToken !== void 0) if (!envToken || isRetiredStorePat(envToken)) {
+		updateEnvFile(dir, {}, ["SAYREN_TOKEN"]);
+		done.push(`${ENV_FILE}의 옛 SAYREN_TOKEN 삭제(옛 API 토큰은 더 쓸 수 없습니다)`);
+	} else notify(`알림: ${ENV_FILE}의 SAYREN_TOKEN은 읽지 않습니다. npx sayren login으로 로그인하거나 SAYREN_TOKEN 환경 변수로 주십시오`);
+	if (done.length > 0) {
+		const ignored = ensureGitignore(dir);
+		notify(`알림: 옛 설정을 정리했습니다 — ${done.join(", ")}${ignored.length ? ` (.gitignore에 ${ignored.join(" ")} 추가)` : ""}`);
+	}
+}
+/** `.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`에 값들을 쓴다. 다른 줄은 그대로 두고 같은 키만 바꾸거나(`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 = [];
+	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)) {
+			next.push(`${key}=${pending.get(key)}`);
+			pending.delete(key);
+			continue;
+		}
+		next.push(line);
+	}
+	while (next.length > 0 && next[next.length - 1] === "") next.pop();
+	for (const [key, value] of pending) next.push(`${key}=${value}`);
+	writePrivate(path, next.length ? `${next.join("\n")}\n` : "");
+}
+/** `.gitignore`에 꼭 있어야 하는 줄 — 원격 MCP 설정(`.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 = 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;
+}
+/** api 주소 — `--api-origin` → `SAYREN_API_ORIGIN` → `.env`의 `SAYREN_API_URL` → 상태 파일 → 기본값 */
+function resolveApiOrigin(flags, dir, state, env) {
+	const dotenv = readEnvFile(dir);
+	const picked = [
+		["flag", flags.apiOrigin?.trim()],
+		["env", env.SAYREN_API_ORIGIN?.trim()],
+		[".env", originOfStorefrontUrl(dotenv.get("SAYREN_API_URL"))],
+		["state", state?.apiOrigin]
+	].find(([, value]) => value);
+	const apiOrigin = (picked?.[1] ?? DEFAULT_API_ORIGIN).replace(/\/+$/, "");
+	assertOriginShape(apiOrigin);
+	return {
+		apiOrigin,
+		originSource: picked && apiOrigin !== DEFAULT_API_ORIGIN ? picked[0] : "default"
+	};
+}
+/** 옛 API 토큰(`sy_pat_…`)을 줬을 때의 안내 */
+const RETIRED_TOKEN_MESSAGE = "옛 API 토큰(sy_pat_)은 더 쓸 수 없습니다. npx sayren login으로 Sayren 계정에 로그인하거나, Sayren 계정 › 액세스 토큰에서 새 액세스 토큰을 만들어 쓰십시오";
+/** 계정 액세스 토큰(JWT)이 아닐 때의 안내 */
+const NOT_ACCOUNT_TOKEN_MESSAGE = "Sayren 계정 액세스 토큰이 아닙니다. npx sayren login으로 로그인하거나, Sayren 계정 › 액세스 토큰에서 만든 토큰을 쓰십시오";
+/** 계정 토큰만 받는다 — 옛 API 토큰·다른 값은 api에 보내기 전에 거절한다 */
+function assertAccountToken(token) {
+	if (isRetiredStorePat(token)) throw new CliError(RETIRED_TOKEN_MESSAGE);
+	if (!isAccountToken(token)) throw new CliError(NOT_ACCOUNT_TOKEN_MESSAGE);
+}
+/**
+* 토큰·api 주소를 정한다. `credentialToken`은 api 주소가 정해진 뒤 자격 증명 파일에서 읽는 함수다(부르는 쪽이 넣는다 — 테스트·Io의
+* env로 경로가 정해진다). 자격 증명 파일의 토큰은 만료됐을 수 있다 — 명령이 쓰기 전에 갱신한다(`readyAuth`).
+*/
+function resolveAuth(flags, dir, state, env = process.env, credentialToken = () => null) {
+	const { apiOrigin, originSource } = resolveApiOrigin(flags, dir, state, env);
+	const fromFlag = flags.token?.trim();
+	const fromEnv = env.SAYREN_TOKEN?.trim();
+	const fromCredentials = fromFlag || fromEnv ? null : credentialToken(apiOrigin);
+	const token = fromFlag || fromEnv || fromCredentials;
+	if (!token) throw new CliError("토큰이 없습니다. npx sayren login으로 Sayren 계정에 로그인하거나 SAYREN_TOKEN 환경 변수·--token으로 액세스 토큰을 주십시오");
+	assertAccountToken(token);
+	return {
+		token,
+		apiOrigin,
+		tokenSource: fromFlag ? "flag" : fromEnv ? "env" : "credentials",
+		originSource
+	};
+}
+/** 로컬 개발 주소 — 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/credentials.ts
+/**
+* 계정 토큰 자격 증명 파일(#71) — `$XDG_CONFIG_HOME/sayren/credentials.json`(macOS·Linux 기본 `~/.config/sayren/`, Windows
+* `%APPDATA%\sayren\`). 계정 토큰은 폴더가 아니라 사람에게 속하므로 프로젝트 폴더(`.mcp.json`)에 두지 않는다.
+*
+* - api origin별 한 항목: `{ accessToken, refreshToken?, expiresAt, scope, email?, accountsOrigin, kind }`.
+* - 권한 600, 심볼릭 링크 거부(#60 `writePrivateFile`), git이 추적 중인 파일에는 쓰지 않는다(dotfiles 저장소 등).
+* - 갱신은 파일 잠금(`credentials.json.lock`, O_EXCL)으로 직렬화한다 — CLI 둘이 같은 refresh를 동시에 쓰면 accounts의 재사용 감지로
+*   패밀리 전체가 폐기된다. 잠금을 얻은 뒤 파일을 다시 읽는다(그 사이 다른 프로세스가 회전했으면 그 토큰을 쓴다).
+* - 경로는 **Io의 env에서만** 정한다 — 테스트(env 없음)가 사용자의 실제 파일에 닿지 않는다.
+*/
+const CREDENTIALS_FILE = "credentials.json";
+/** 잠금이 이보다 오래됐으면 죽은 프로세스의 것으로 보고 지운다 */
+const STALE_LOCK_MS = 3e4;
+/** 잠금을 기다리는 최대 시간 */
+const LOCK_WAIT_MS = 15e3;
+/** 설정 폴더 — env에 근거가 없으면 null(자격 증명 파일을 쓰지 않는다) */
+function configDirOf(env, platform = process.platform) {
+	if (env.XDG_CONFIG_HOME?.trim()) return join(env.XDG_CONFIG_HOME.trim(), "sayren");
+	if (platform === "win32") return env.APPDATA?.trim() ? join(env.APPDATA.trim(), "sayren") : null;
+	return env.HOME?.trim() ? join(env.HOME.trim(), ".config", "sayren") : null;
+}
+function credentialsPathOf(env) {
+	const dir = configDirOf(env);
+	return dir ? join(dir, CREDENTIALS_FILE) : null;
+}
+function readFile(path) {
+	if (!existsSync(path)) return {};
+	if (lstatSync(path).isSymbolicLink()) throw new CliError(`${path}가 심볼릭 링크라 읽지 않았습니다. 링크를 지운 뒤 다시 로그인하십시오`);
+	let parsed;
+	try {
+		parsed = JSON.parse(readFileSync(path, "utf8"));
+	} catch {
+		throw new CliError(`${path}를 읽지 못했습니다. 파일을 지우고 다시 로그인하십시오`);
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+	const out = {};
+	for (const [origin, value] of Object.entries(parsed)) {
+		const entry = value;
+		if (entry && typeof entry.accessToken === "string" && typeof entry.expiresAt === "number" && typeof entry.accountsOrigin === "string" && (entry.kind === "oauth" || entry.kind === "pat")) out[origin] = entry;
+	}
+	return out;
+}
+function writeFile(path, file) {
+	const dir = dirname(path);
+	mkdirSync(dir, {
+		recursive: true,
+		mode: 448
+	});
+	if (isGitTracked(dir, CREDENTIALS_FILE)) throw new CliError(`${path}가 git에 커밋돼 있어 토큰을 쓰지 않았습니다. 추적을 해제하거나 XDG_CONFIG_HOME으로 다른 폴더를 지정하십시오`);
+	try {
+		writePrivateFile(path, `${JSON.stringify(file, null, 2)}\n`);
+	} catch (error) {
+		throw new CliError(error instanceof Error ? error.message : String(error));
+	}
+}
+function readCredential(env, apiOrigin) {
+	const path = credentialsPathOf(env);
+	if (!path) return null;
+	return readFile(path)[apiOrigin] ?? null;
+}
+function saveCredential(env, apiOrigin, entry) {
+	const path = credentialsPathOf(env);
+	if (!path) throw new CliError("자격 증명을 저장할 폴더를 정하지 못했습니다(HOME·XDG_CONFIG_HOME 없음). SAYREN_TOKEN 환경 변수로 토큰을 주십시오");
+	const file = readFile(path);
+	file[apiOrigin] = entry;
+	writeFile(path, file);
+	return path;
+}
+function deleteCredential(env, apiOrigin) {
+	const path = credentialsPathOf(env);
+	if (!path) return false;
+	const file = readFile(path);
+	if (!file[apiOrigin]) return false;
+	delete file[apiOrigin];
+	writeFile(path, file);
+	return true;
+}
+/**
+* 파일 잠금 안에서 `fn`을 부른다(O_EXCL로 잠금 파일을 만든다). 오래된 잠금(30초)은 지운다. 잠금을 못 얻으면 오류다.
+*/
+async function withCredentialLock(env, sleep, fn, now = () => Date.now()) {
+	const path = credentialsPathOf(env);
+	if (!path) return fn();
+	mkdirSync(dirname(path), {
+		recursive: true,
+		mode: 448
+	});
+	const lock = `${path}.lock`;
+	const started = now();
+	for (;;) try {
+		closeSync(openSync(lock, "wx", 384));
+		break;
+	} catch (error) {
+		if (error.code !== "EEXIST") throw error;
+		try {
+			if (now() - statSync(lock).mtimeMs > STALE_LOCK_MS) {
+				rmSync(lock, { force: true });
+				continue;
+			}
+		} catch {
+			continue;
+		}
+		if (now() - started > LOCK_WAIT_MS) throw new CliError(`다른 sayren 명령이 로그인을 갱신하고 있습니다. 잠시 뒤 다시 시도하십시오(${lock})`);
+		await sleep(200);
+	}
+	try {
+		return await fn();
+	} finally {
+		rmSync(lock, { force: true });
+	}
+}
+
+//#endregion
+//#region src/oauth.ts
+/**
+* `sayren login`의 OAuth(#71) — accounts가 발급자다. 클라이언트 `sayren-cli`(public, PKCE S256).
+*
+* - 기본은 루프백(RFC 8252 §7.3): 127.0.0.1 임의 포트에 콜백 서버를 열고 브라우저로 authorize를 연다. state가 맞는 콜백 하나만 받고,
+*   5분 안에 오지 않으면 끝낸다. 콜백 화면은 「로그인을 마쳤습니다. 터미널로 돌아가십시오.」뿐이다.
+* - 브라우저를 열 수 없으면(SSH, Linux에 DISPLAY 없음, 열기 실패) 디바이스 코드(RFC 8628)다. `interval`을 지키고 `slow_down`이면 5초 늘린다.
+* - `resource`(RFC 8707)는 api origin이다(accounts의 API 리소스 식별자와 같다). 싣지 않으면 JWT가 아닌 불투명 토큰이 온다.
+* - 토큰은 화면·로그에 찍지 않는다.
+*/
+const LOGIN_TIMEOUT_MS = 5 * 6e4;
+const CALLBACK_PAGE = "로그인을 마쳤습니다. 터미널로 돌아가십시오.";
+/** 만료 전 갱신 여유 */
+const REFRESH_SKEW_MS = 6e4;
+/** accounts origin — `--accounts-origin`·`SAYREN_ACCOUNTS_ORIGIN` → api origin에 정해진 값(운영·로컬) */
+function resolveAccountsOrigin(apiOrigin, flag, env) {
+	const explicit = (flag ?? env.SAYREN_ACCOUNTS_ORIGIN)?.trim().replace(/\/+$/, "");
+	if (explicit) {
+		assertOriginShape(explicit);
+		return new URL(explicit).origin;
+	}
+	const known = accountsOriginFor(apiOrigin);
+	if (!known) throw new CliError(`이 api 주소(${apiOrigin})의 계정 서버를 모릅니다. --accounts-origin 또는 SAYREN_ACCOUNTS_ORIGIN으로 주십시오`);
+	return known;
+}
+/** 브라우저를 열 수 없는 환경 — SSH 접속, Linux에 화면(DISPLAY·WAYLAND_DISPLAY)이 없음 */
+function headlessEnvironment(env, platform = process.platform) {
+	if (env.SSH_CONNECTION || env.SSH_TTY) return true;
+	if (platform === "linux" && !env.DISPLAY && !env.WAYLAND_DISPLAY) return true;
+	return false;
+}
+function pkcePair() {
+	const verifier = randomBytes(32).toString("base64url");
+	return {
+		verifier,
+		challenge: createHash("sha256").update(verifier).digest("base64url")
+	};
+}
+/** 토큰 요청 제한 시간 — 계정 서버가 응답하지 않아도 CLI가 멈추지 않게 */
+const TOKEN_REQUEST_TIMEOUT_MS = 1e4;
+/** accounts 토큰 엔드포인트(form). 오류는 OAuth `error` 코드를 담은 CliError */
+async function tokenRequest(io, accountsOrigin, form) {
+	let response;
+	try {
+		response = await io.fetch(accountsEndpoints(accountsOrigin).token, {
+			method: "POST",
+			headers: {
+				"content-type": "application/x-www-form-urlencoded",
+				accept: "application/json"
+			},
+			body: new URLSearchParams(form).toString(),
+			redirect: "error",
+			signal: AbortSignal.timeout(TOKEN_REQUEST_TIMEOUT_MS)
+		});
+	} catch {
+		throw new CliError("계정 서버에 연결하지 못했습니다. 네트워크를 확인하십시오");
+	}
+	const body = await response.json().catch(() => null);
+	if (response.ok && body?.access_token) return {
+		ok: true,
+		body
+	};
+	return {
+		ok: false,
+		error: body?.error ?? `http_${response.status}`,
+		description: body?.error_description
+	};
+}
+function entryOf(body, accountsOrigin, now, previous) {
+	const idClaims = body.id_token ? decodeJwt(body.id_token)?.claims : null;
+	const email = typeof idClaims?.email === "string" ? idClaims.email : previous?.email;
+	return {
+		accessToken: body.access_token,
+		...body.refresh_token ?? previous?.refreshToken ? { refreshToken: body.refresh_token ?? previous?.refreshToken } : {},
+		expiresAt: now + (body.expires_in ?? 900) * 1e3,
+		...body.scope ?? previous?.scope ? { scope: body.scope ?? previous?.scope } : {},
+		...email ? { email } : {},
+		accountsOrigin,
+		kind: "oauth"
+	};
+}
+/**
+* 127.0.0.1 임의 포트 콜백 서버. state가 맞는 `/callback` 하나를 받으면 code로 풀린다. 다른 경로·state 불일치는 거부하고 계속 기다린다
+* (다른 탭·다른 프로그램이 부른 요청으로 흐름이 끝나지 않게). error 파라미터(거부 등)면 오류로 끝난다.
+*/
+async function startLoopback(state, timeoutMs = LOGIN_TIMEOUT_MS) {
+	let resolveCode = () => {};
+	let rejectCode = () => {};
+	const code = new Promise((resolve$1, reject) => {
+		resolveCode = resolve$1;
+		rejectCode = reject;
+	});
+	const html = (text) => `<!doctype html><meta charset="utf-8"><title>Sayren CLI</title><p style="font-family:sans-serif">${text}</p>`;
+	const server = createServer((request, response) => {
+		const url = new URL(request.url ?? "/", "http://127.0.0.1");
+		if (url.pathname !== "/callback") {
+			response.writeHead(404).end();
+			return;
+		}
+		if (url.searchParams.get("state") !== state) {
+			response.writeHead(400, { "content-type": "text/html; charset=utf-8" });
+			response.end(html("로그인 요청이 맞지 않습니다. 터미널에서 다시 시작하십시오."));
+			return;
+		}
+		const error = url.searchParams.get("error");
+		const received = url.searchParams.get("code");
+		response.writeHead(error || !received ? 400 : 200, {
+			"content-type": "text/html; charset=utf-8",
+			"cache-control": "no-store"
+		});
+		if (error || !received) {
+			response.end(html("로그인을 마치지 못했습니다. 터미널을 확인하십시오."));
+			rejectCode(new CliError(error === "access_denied" ? "로그인을 거부했습니다" : `로그인을 마치지 못했습니다(${error ?? "code 없음"})`));
+			return;
+		}
+		response.end(html(CALLBACK_PAGE));
+		resolveCode(received);
+	});
+	await new Promise((resolve$1, reject) => {
+		server.once("error", reject);
+		server.listen(0, "127.0.0.1", () => resolve$1());
+	});
+	const address = server.address();
+	const port = typeof address === "object" && address ? address.port : 0;
+	const timer = setTimeout(() => rejectCode(new CliError("5분 안에 로그인을 마치지 않아 끝냈습니다. 다시 시도하십시오")), timeoutMs);
+	timer.unref?.();
+	const close = () => {
+		clearTimeout(timer);
+		server.close();
+		server.closeAllConnections?.();
+	};
+	return {
+		redirectUri: `http://127.0.0.1:${port}/callback`,
+		code,
+		close
+	};
+}
+/** 브라우저 로그인(루프백 + PKCE). 브라우저를 열지 못했으면 null(부르는 쪽이 디바이스 코드로 넘어간다) */
+async function browserLogin(io, input) {
+	if (!io.openBrowser) return null;
+	const state = randomBytes(16).toString("base64url");
+	const { verifier, challenge } = pkcePair();
+	const loopback = await startLoopback(state, input.timeoutMs);
+	try {
+		const authorize = new URL(accountsEndpoints(input.accountsOrigin).authorize);
+		authorize.search = new URLSearchParams({
+			response_type: "code",
+			client_id: CLI_CLIENT_ID,
+			redirect_uri: loopback.redirectUri,
+			scope: CLI_LOGIN_SCOPE,
+			state,
+			code_challenge: challenge,
+			code_challenge_method: "S256",
+			resource: input.apiOrigin
+		}).toString();
+		if (!await io.openBrowser(authorize.toString())) return null;
+		io.out("브라우저에서 Sayren 계정으로 로그인하십시오. 열리지 않으면 아래 주소를 여십시오:");
+		io.out(`  ${authorize.toString()}`);
+		const code = await loopback.code;
+		const now = io.now?.() ?? Date.now();
+		const result = await tokenRequest(io, input.accountsOrigin, {
+			grant_type: "authorization_code",
+			code,
+			redirect_uri: loopback.redirectUri,
+			code_verifier: verifier,
+			client_id: CLI_CLIENT_ID,
+			resource: input.apiOrigin
+		});
+		if (!result.ok) throw new CliError(`로그인을 마치지 못했습니다(${result.error})`);
+		return entryOf(result.body, input.accountsOrigin, now);
+	} finally {
+		loopback.close();
+	}
+}
+/** RFC 8628 — 주소·코드를 보이고 승인될 때까지 폴링한다 */
+async function deviceLogin(io, input) {
+	let response;
+	try {
+		response = await io.fetch(accountsEndpoints(input.accountsOrigin).deviceCode, {
+			method: "POST",
+			headers: {
+				"content-type": "application/x-www-form-urlencoded",
+				accept: "application/json"
+			},
+			body: new URLSearchParams({
+				client_id: CLI_CLIENT_ID,
+				scope: CLI_LOGIN_SCOPE,
+				resource: input.apiOrigin
+			}).toString(),
+			redirect: "error"
+		});
+	} catch {
+		throw new CliError("계정 서버에 연결하지 못했습니다. 네트워크를 확인하십시오");
+	}
+	const device = await response.json().catch(() => null);
+	if (!response.ok || !device?.device_code || !device.user_code || !device.verification_uri) throw new CliError(`기기 로그인을 시작하지 못했습니다(HTTP ${response.status})`);
+	io.out("다른 기기의 브라우저에서 아래 주소를 열고 코드를 확인하십시오:");
+	io.out(`  ${device.verification_uri}`);
+	io.out(`  코드: ${device.user_code}`);
+	const now = () => io.now?.() ?? Date.now();
+	const deadline = now() + (device.expires_in ?? 600) * 1e3;
+	let intervalMs = Math.max(1, device.interval ?? 5) * 1e3;
+	while (now() < deadline) {
+		await io.sleep(intervalMs);
+		const result = await tokenRequest(io, input.accountsOrigin, {
+			grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+			device_code: device.device_code,
+			client_id: CLI_CLIENT_ID
+		});
+		if (result.ok) return entryOf(result.body, input.accountsOrigin, now());
+		if (result.error === "authorization_pending") continue;
+		if (result.error === "slow_down") {
+			intervalMs += 5e3;
+			continue;
+		}
+		if (result.error === "access_denied") throw new CliError("기기 연결을 거부했습니다");
+		if (result.error === "expired_token") break;
+		throw new CliError(`기기 로그인을 마치지 못했습니다(${result.error})`);
+	}
+	throw new CliError("코드가 만료됐습니다. 다시 로그인하십시오");
+}
+/**
+* 쓸 수 있는 access token — 만료 60초 전이면(또는 `force`) refresh로 갱신한다. 갱신은 파일 잠금 안에서 하고, 잠금을 얻은 뒤 파일을
+* 다시 읽어 그 사이 다른 프로세스가 회전한 토큰을 쓴다. refresh가 거부되면(만료·폐기·재사용) 항목을 지우고 다시 로그인을 요구한다.
+*/
+async function freshAccessToken(io, apiOrigin, options = {}) {
+	const now = () => io.now?.() ?? Date.now();
+	const current = readCredential(io.env, apiOrigin);
+	if (!current) return null;
+	const valid = (entry) => entry.expiresAt - REFRESH_SKEW_MS > now();
+	if (!options.force && valid(current)) return current;
+	if (!current.refreshToken) {
+		if (valid(current)) return current;
+		throw new CliError("액세스 토큰이 만료됐습니다. 새 토큰을 만들거나 npx sayren login으로 다시 로그인하십시오");
+	}
+	return withCredentialLock(io.env, io.sleep, async () => {
+		const latest = readCredential(io.env, apiOrigin);
+		if (!latest) return null;
+		if (latest.accessToken !== current.accessToken && valid(latest)) return latest;
+		if (!latest.refreshToken) return valid(latest) ? latest : null;
+		const result = await tokenRequest(io, latest.accountsOrigin, {
+			grant_type: "refresh_token",
+			refresh_token: latest.refreshToken,
+			client_id: CLI_CLIENT_ID,
+			resource: apiOrigin
+		});
+		if (!result.ok) {
+			if (result.error === "invalid_grant") {
+				deleteCredential(io.env, apiOrigin);
+				throw new CliError("로그인이 만료됐습니다. npx sayren login으로 다시 로그인하십시오");
+			}
+			throw new CliError(`로그인을 갱신하지 못했습니다(${result.error})`);
+		}
+		const next = entryOf(result.body, latest.accountsOrigin, now(), latest);
+		saveCredential(io.env, apiOrigin, next);
+		return next;
+	});
+}
+/** RFC 7009 — refresh를 폐기한다(실패는 무시). public 클라이언트라 client_id만 싣는다 */
+async function revokeRefresh(io, entry) {
+	if (!entry.refreshToken) return true;
+	try {
+		return (await io.fetch(accountsEndpoints(entry.accountsOrigin).revoke, {
+			method: "POST",
+			headers: { "content-type": "application/x-www-form-urlencoded" },
+			body: new URLSearchParams({
+				token: entry.refreshToken,
+				token_type_hint: "refresh_token",
+				client_id: CLI_CLIENT_ID
+			}).toString(),
+			redirect: "error"
+		})).ok;
+	} catch {
+		return false;
 	}
-	if (link) throw new McpJsonError(`${path}가 심볼릭 링크라 쓰지 않았습니다. 링크를 지운 뒤 다시 실행하십시오`);
-	writeFileSync(path, text, { mode: 384 });
-	try {
-		chmodSync(path, 384);
-	} catch {}
+}
+
+//#endregion
+//#region src/account-auth.ts
+/**
+* 명령이 토큰을 쓰기 전 준비(#71) — 자격 증명 파일 토큰의 갱신, 계정 토큰의 상점 고르기.
+*/
+/** 자격 증명 파일에서 토큰을 읽는 함수(`resolveAuth`에 넘긴다) */
+function credentialTokenReader(env) {
+	return (apiOrigin) => readCredential(env, apiOrigin)?.accessToken ?? null;
 }
 /**
-* `sayren` 항목을 넣는다(다른 서버는 둔다). git이 추적 중인 파일이면 쓰지 않고 `"tracked"`다.
-* 형식이 틀린 파일·심볼릭 링크는 `McpJsonError`다.
+* 토큰 준비 — 자격 증명 파일 토큰이면 만료 60초 전에 갱신한다. 401 재시도용 갱신 함수를 돌려준다(자격 증명 파일 토큰만).
 */
-function writeMcpJsonFile(dir, credentials) {
-	if (isGitTracked(dir, MCP_JSON_FILE)) return "tracked";
-	const path = join(dir, MCP_JSON_FILE);
-	let existing = null;
+async function readyAuth(auth, io) {
+	if (auth.tokenSource !== "credentials") return void 0;
+	const fresh = await freshAccessToken(io, auth.apiOrigin);
+	if (!fresh) throw new CliError("로그인 정보가 없습니다. npx sayren login으로 다시 로그인하십시오");
+	auth.token = fresh.accessToken;
+	return async () => {
+		const next = await freshAccessToken(io, auth.apiOrigin, { force: true });
+		if (!next) return false;
+		auth.token = next.accessToken;
+		return true;
+	};
+}
+/**
+* 계정 토큰의 상점(`X-Store-Id`) — 후보(`--store`·`--project` 등 명령이 준 순서) → `SAYREN_STORE_ID` → 폴더의 상태·`.mcp.json` →
+* 토큰의 상점이 하나면 그 상점 → `GET /v1/me/stores`(하나면 그 상점, 여럿이면 대화형 선택, 비대화형이면 오류).
+*/
+async function selectStore(auth, client, io, candidates, folderStore = null) {
+	const claims = accountTokenClaimsOf(auth.token);
+	const explicit = [
+		...candidates,
+		io.env.SAYREN_STORE_ID?.trim(),
+		folderStore
+	].find((value) => !!value?.trim());
+	if (explicit) {
+		if (!STORE_ID_PATTERN.test(explicit)) throw new CliError(`상점 id 형식이 아닙니다: ${explicit}`);
+		if (!storeInScope(claims, explicit)) throw new CliError(`상점 ${explicit}가 이 토큰의 상점 범위 밖입니다. 그 상점이 포함되게 다시 로그인하거나(npx sayren login) 다른 토큰을 쓰십시오`);
+		auth.storeId = explicit;
+		return explicit;
+	}
+	const single = singleStoreOf(claims);
+	if (single) {
+		auth.storeId = single;
+		return single;
+	}
+	let stores;
 	try {
-		if (!lstatSync(path).isSymbolicLink()) existing = readFileSync(path, "utf8");
+		stores = (await client.auth.listMyStores()).filter((store) => storeInScope(claims, store.storeId));
 	} catch {
-		existing = null;
+		throw new CliError("상점을 고르지 못했습니다. --store <storeId> 또는 SAYREN_STORE_ID로 상점을 주십시오");
 	}
-	writePrivateFile(path, mergeMcpJson(existing, credentials));
-	return "written";
-}
+	if (stores.length === 0) throw new CliError("이 계정(토큰 범위)에 쓸 수 있는 상점이 없습니다");
+	if (stores.length === 1) {
+		auth.storeId = stores[0].storeId;
+		return auth.storeId;
+	}
+	const labels = stores.map((store) => `${store.storeId} — ${store.storeName} (${store.role})`);
+	const picked = io.select ? await io.select("상점을 고르십시오", labels) : null;
+	const index = picked ? labels.indexOf(picked) : -1;
+	if (index < 0) throw new CliError(`상점이 여럿입니다. --store <storeId> 또는 SAYREN_STORE_ID로 고르십시오:\n${labels.map((label) => `  ${label}`).join("\n")}`);
+	auth.storeId = stores[index].storeId;
+	return auth.storeId;
+}
+/** 계정 로그인 폴더의 `.mcp.json` 안내 — 토큰 없이 주소·상점만 쓴다 */
+const ACCOUNT_MCP_NOTE = `${MCP_FILE}에는 토큰을 쓰지 않았습니다 — MCP 클라이언트가 연결할 때 Sayren 계정으로 로그인합니다`;
 
 //#endregion
 //#region ../mcp/src/rules.ts
+/** 규칙의 심각도 — 없으면 `error` */
+function severityOf(rule) {
+	return rule?.severity ?? "error";
+}
 /** 문서 사이트 — `doc` 경로를 절대 주소로 만들 때 쓴다 */
 const DOCS_BASE_URL = "https://docs.sayren.app";
 const docUrl = (doc) => `${DOCS_BASE_URL}${doc}`;
@@ -221,7 +1039,7 @@ const RULES = [
 	{
 		id: "tenant-header",
 		title: "테넌트는 `X-Store-Code` 헤더로 보낸다",
-		why: "공유 API 호스트에서 스토어를 가르는 값이다. 빠지면 다른 스토어 데이터가 보이거나 404가 난다",
+		why: "공유 API 호스트에서 상점을 가르는 값이다. 빠지면 다른 상점 데이터가 보이거나 404가 난다",
 		fix: "`createStorefrontClient`에 `storeCode`를 넘긴다. SDK가 헤더를 붙인다. 서브도메인으로 서비스할 때만 생략한다",
 		example: "createStorefrontClient({ baseUrl: API_BASE_URL, storeCode: resolveStoreCode() });",
 		doc: "/guides/storefront-sdk",
@@ -302,7 +1120,7 @@ const RULES = [
 	{
 		id: "checkout-origin",
 		title: "복귀 주소는 코드에 고정하지 않고 배포된 주소(요청 origin)에서 만든다",
-		why: "주소를 코드에 고정하면 로컬·스테이징·운영 중 한 곳에서만 결제가 제대로 돌아온다. 셀러 콘솔 설정 › 결제의 결제 도메인은 선택형 허용 목록이다. 비워 두면 https 복귀 주소를 모두 받고, 등록하면 목록 밖의 복귀 주소를 서버가 거절한다",
+		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",
@@ -347,8 +1165,8 @@ const RULES = [
 	{
 		id: "buyer-signup",
 		title: "이메일·비밀번호 로그인을 받으면 가입 화면도 둔다(`auth.signUp`)",
-		why: "비밀번호 로그인만 있고 가입이 없으면 소셜 로그인을 켜지 않은 스토어에서 새 구매자가 계정을 만들 수 없다",
-		fix: "스토어 `loginMethods`에 `password`가 있으면 가입 화면을 둔다. 약관·개인정보 수집이용 동의(필수)와 마케팅 수신(선택)을 받아 서버 함수에서 `auth.signUp({ email, password, name, agreements, cartToken })`을 부르고, 받은 토큰 쌍을 HttpOnly 쿠키에 담는다",
+		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"
@@ -365,7 +1183,7 @@ const RULES = [
 	{
 		id: "analytics-start",
 		title: "방문 분석은 브라우저에서 한 번 시작한다(`@sayren/storefront-sdk/analytics`)",
-		why: "빠지면 셀러 콘솔 애널리틱스가 비어 있다. 서버 파일에서 부르면 아무것도 하지 않는다",
+		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",
@@ -388,6 +1206,16 @@ const RULES = [
 		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"
+	},
+	{
+		id: "checkout-availability",
+		title: "주문을 받지 않는 상점이면 주문 버튼을 그리지 않는다(`checkoutAvailable`)",
+		why: "결제 수단이 없거나 공개한 쇼핑몰의 실결제가 아직 열리지 않은 상점은 결제 요청이 409 `PAYMENT_NOT_CONFIGURED`다. 버튼을 그대로 두면 구매자가 담고 주문서까지 가서야 결제가 안 된다는 것을 안다",
+		fix: "`GET /store`(`api.store.get()`)의 `checkoutAvailable`이 false면 장바구니 담기·바로구매·주문 버튼과 헤더의 장바구니를 숨기고 「지금은 온라인 주문을 받지 않습니다」를 보인다. `customerCenterPhone`이 있으면 문의 전화를 함께 보인다",
+		example: "const store = await apiFor().store.get();\nif (!store.checkoutAvailable) {\n  // 주문 버튼 대신 안내\n  return <p>지금은 온라인 주문을 받지 않습니다</p>;\n}",
+		doc: "/guides/storefront-sdk",
+		templateFile: "src/lib/ordering.ts",
+		severity: "warning"
 	}
 ];
 /**
@@ -408,14 +1236,14 @@ const SERVER_FILE = /\.server\.(ts|tsx)$/;
 /** 토큰을 브라우저 저장소에 쓰는 코드 */
 const BROWSER_TOKEN_STORAGE = /(localStorage|sessionStorage)\.setItem\(\s*[`'"][^`'"]*([Tt]oken|refresh|session|sayren_member)/;
 /**
-* 직접 입력값이 새는 자리 — URL 검색 파라미터(`search`·`searchParams`), 브라우저 저장소, 콘솔.
+* 직접 입력값이 새는 자리 — 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/, "콘솔 로그"]
+	[/console\.(log|info|warn|error|debug)\([^)]*\bcustomInputs\b/, "상점 플랫폼 로그"]
 ];
 /**
 * 만들어진 프로젝트의 소스를 규칙과 대조한다. 정적 검사라 모든 문제를 잡지는 못하지만,
@@ -489,6 +1317,7 @@ function verifySources(files) {
 		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("startPayment(") && !has("checkoutAvailable")) inProject("checkout-availability", "결제를 시작하지만 `GET /store`의 `checkoutAvailable`을 읽는 코드가 없다. 주문을 받지 않는 상점에서도 주문 버튼이 보인다");
 	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\(/);
@@ -512,13 +1341,14 @@ function report(finding) {
 		example: rule?.example ?? "",
 		doc: rule?.doc ?? "",
 		docUrl: rule ? docUrl(rule.doc) : "",
-		...rule?.templateFile ? { templateFile: rule.templateFile } : {}
+		...rule?.templateFile ? { templateFile: rule.templateFile } : {},
+		severity: severityOf(rule)
 	};
 }
 /** 위반을 고치는 순서 — 에이전트가 무엇부터 할지 묻지 않게 한다 */
 function nextSteps(findings, target) {
 	if (!findings.length) return target === "remote" ? [
-		"사용자에게 콘솔 스토어프론트 공간의 [미리보기 열기]로 화면을 확인해 달라고 전한다.",
+		"사용자에게 상점 플랫폼 스토어프론트 공간의 [미리보기 열기]로 화면을 확인해 달라고 전한다.",
 		"`create_version`으로 버전을 만들고 `get_build`로 빌드 결과를 확인한다.",
 		"정적 검사가 잡지 못하는 것은 실제 결제 한 번이 잡는다. 발행 전에 테스트 결제를 권한다."
 	] : [
@@ -549,12 +1379,28 @@ function reportFromFindings(findings, checkedFiles, target = "local") {
 	const results = RULES.map((rule) => ({
 		ruleId: rule.id,
 		status: counts.has(rule.id) ? "violation" : "pass",
-		count: counts.get(rule.id) ?? 0
+		count: counts.get(rule.id) ?? 0,
+		severity: severityOf(rule)
 	}));
 	const violated = results.filter((result) => result.status === "violation").length;
 	const reported = findings.map(report);
+	const blocking = reported.filter((finding) => finding.severity === "error");
+	if (findings.length > 0 && blocking.length === 0) return {
+		ok: true,
+		checkedFiles,
+		summary: {
+			rules: RULES.length,
+			passed: RULES.length - violated,
+			violated,
+			findings: findings.length
+		},
+		results,
+		findings: reported,
+		message: `막는 위반은 없습니다. 권고 ${findings.length}건이 있습니다 — findings의 fix대로 고치기를 권합니다`,
+		nextSteps: nextSteps([], target)
+	};
 	return {
-		ok: findings.length === 0,
+		ok: blocking.length === 0,
 		checkedFiles,
 		summary: {
 			rules: RULES.length,
@@ -649,370 +1495,120 @@ function formatProblem(path) {
 }
 /** 위치 규칙: 어떤 모드로 이 경로에 닿을 수 있는가 */
 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 ../../apps/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
-/**
-* 설정 (2026-09-29 사용자 결정: `.sayrenrc`를 없애고 받은 폴더에 원격 MCP `.mcp.json`을 둔다)
-*
-* - `.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 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";
-function parseState(text, name) {
-	let parsed;
-	try {
-		parsed = JSON.parse(text);
-	} catch {
-		throw new CliError(`${name}를 읽지 못했습니다. JSON 형식을 확인하십시오`);
-	}
-	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: raw.storeId,
-		siteId: raw.siteId,
-		baseRef: raw.baseRef,
-		...typeof raw.apiOrigin === "string" ? { apiOrigin: raw.apiOrigin } : {}
-	};
-}
-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: state.storeId,
-		siteId: state.siteId,
-		baseRef: state.baseRef
-	};
-	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(" ")} 추가)` : ""}`);
+	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";
 }
-/** `.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);
+
+//#endregion
+//#region ../../apps/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;
 }
-/** `.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 = [];
-	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)) {
-			next.push(`${key}=${pending.get(key)}`);
-			pending.delete(key);
+/** 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;
 		}
-		next.push(line);
+		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()
+		});
 	}
-	while (next.length > 0 && next[next.length - 1] === "") next.pop();
-	for (const [key, value] of pending) next.push(`${key}=${value}`);
-	writePrivate(path, next.length ? `${next.join("\n")}\n` : "");
-}
-/** `.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 = 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, state, env = process.env) {
-	const dotenv = readEnvFile(dir);
-	const fromFlag = flags.token?.trim();
-	const fromEnv = env.SAYREN_TOKEN?.trim();
-	const fromFile = fromFlag || fromEnv ? null : readMcpCredentials(dir).token;
-	const token = fromFlag || fromEnv || fromFile;
-	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"))],
-		["state", state?.apiOrigin]
-	].find(([, value]) => value);
-	const apiOrigin = (picked?.[1] ?? DEFAULT_API_ORIGIN).replace(/\/+$/, "");
-	assertOriginShape(apiOrigin);
-	return {
-		token,
-		apiOrigin,
-		tokenSource: fromFlag ? "flag" : fromEnv ? "env" : "mcp",
-		originSource: picked && apiOrigin !== DEFAULT_API_ORIGIN ? picked[0] : "default"
-	};
+	return out;
 }
-/** 로컬 개발 주소 — 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}`);
+/** 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 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";
+	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/tree.ts
@@ -1170,7 +1766,7 @@ function treeFingerprint(files) {
 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 blockingRules = report$1.results.filter((result) => result.status === "violation" && result.severity !== "warning");
 	const problems = [...limitProblems(tree)];
 	const warnings = [];
 	const text = (path) => {
@@ -1262,6 +1858,26 @@ const MAX_BLOB_ROUNDS = 3;
 /** 올리기 한 번의 내용 합계 상한 — base64(×4/3)가 api 본문 8MiB 안에 든다 */
 const BLOB_BATCH_BYTES = 5 * 1024 * 1024;
 /**
+* 토큰·api 주소를 정하고(자격 증명 파일 포함) 준비한 관리 API 클라이언트 — 상점을 고른다(`candidates` 먼저).
+*/
+async function apiFor(flags, dir, state, io, candidates = []) {
+	const auth = resolveAuth(flags, dir, state, io.env, credentialTokenReader(io.env));
+	await checkAuthSources(auth, io);
+	const refresh = await readyAuth(auth, io);
+	const client = clientOf(auth, io.fetch, refresh);
+	let folderStore = state?.storeId ?? null;
+	if (!folderStore) try {
+		folderStore = readMcpStoreId(dir);
+	} catch {
+		folderStore = null;
+	}
+	await selectStore(auth, client, io, [flags.store, ...candidates], folderStore);
+	return {
+		auth,
+		client
+	};
+}
+/**
 * 토큰·api 주소 확인 — `--token`은 셸 기록·프로세스 목록에 남으니 알리고, 파일(`.env`·`.sayren/state.json`)에서 읽은 기본이 아닌 api
 * 주소는 토큰이 그곳으로 가므로 확인한다(대화형이면 묻고, 아니면 `--api-origin`·`SAYREN_API_ORIGIN`으로 명시해야 한다)
 */
@@ -1277,14 +1893,12 @@ async function pull(flags, io) {
 	const probeDir = flags.dir ? resolve(io.cwd, flags.dir) : io.cwd;
 	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 { auth, client } = await apiFor(flags, authDir, null, io, [flags.project]);
 	const hosting = await client.storefront.get();
-	if (!hosting.site) throw new CliError("이 스토어에는 호스팅 사이트가 없습니다. 셀러 콘솔 › 스토어프론트에서 사이트를 만든 뒤 다시 받으십시오");
+	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})가 다릅니다. 그 스토어에서 발급한 토큰을 쓰십시오`);
+	if (flags.project && flags.project !== source.storeId) throw new CliError(`받은 상점(${source.storeId})과 --project(${flags.project})가 다릅니다. --project 또는 SAYREN_STORE_ID를 확인하십시오`);
 	const store = {
 		storeId: source.storeId,
 		storeCode: source.storeCode
@@ -1327,7 +1941,7 @@ async function pull(flags, io) {
 	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 편집으로 한쪽 이름을 바꾼 뒤 다시 받으십시오`);
+	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");
@@ -1361,18 +1975,15 @@ async function pull(flags, io) {
 		SAYREN_STORE_CODE: store.storeCode
 	}, ["SAYREN_TOKEN"]);
 	const addedIgnore = ensureGitignore(target);
-	const written = writeMcpJson(target, {
-		token: auth.token,
-		storeId: store.storeId
-	});
+	const written = writeMcpJson(target, { storeId: store.storeId });
 	io.out(`받음 → ${relativeOf(io, target)} (${files.size}개${removed ? `, 원격에 없는 ${removed}개 지움` : ""})`);
-	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 주소·스토어 코드(개발 서버용)`);
+	if (written === "retired-token-removed") io.out(`알림: ${RETIRED_MCP_TOKEN_NOTICE}`);
+	io.out(`${MCP_FILE} 작성 — sayren 원격 MCP(${REMOTE_MCP_URL})와 상점. ${ACCOUNT_MCP_NOTE}`);
+	if (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 편집 환경이 열려 있습니다. 배포 전에 그 편집이 끝났는지 확인하십시오");
-	io.out(`\n다음:\n  cd ${relativeOf(io, target)}\n  npm install --ignore-scripts  # 의존성의 설치 스크립트를 돌리지 않습니다\n  npm run dev        # http://localhost:4010 — 운영 스토어 데이터로 동작합니다\n  npx sayren deploy  # 빌드 → 버전 → 발행`);
+	if (source.editSessionOpen) io.out("알림: 상점 플랫폼·AI 편집 환경이 열려 있습니다. 배포 전에 그 편집이 끝났는지 확인하십시오");
+	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;
 }
 async function verify(flags, io) {
@@ -1388,7 +1999,8 @@ function printChecks(tree, checks, io) {
 	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}`);
+		const label = finding.severity === "warning" ? "권고" : "위반";
+		io.out(`  · ${label} [${finding.ruleId}] ${at} — ${finding.fix}`);
 	}
 	for (const problem of checks.problems) io.out(`  · 문제 ${problem}`);
 	for (const warning of checks.warnings) io.out(`  · 경고 ${warning}`);
@@ -1404,24 +2016,22 @@ async function deploy(flags, io) {
 	if (!rc) {
 		let storeId = null;
 		try {
-			storeId = readMcpCredentials(dir).storeId;
+			storeId = readMcpStoreId(dir);
 		} 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);
+	const { client } = await apiFor(flags, dir, rc, io);
 	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 (!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 편집 포함)를 이 폴더 내용으로 덮어쓰고, 열린 편집 환경을 끕니다. 계속하시겠습니까?")) {
+		if (!await io.confirm("원격 작업 트리(상점 플랫폼·AI 편집 포함)를 이 폴더 내용으로 덮어쓰고, 열린 편집 환경을 끕니다. 계속하시겠습니까?")) {
 			io.out("취소했습니다");
 			return 1;
 		}
@@ -1433,7 +2043,7 @@ async function deploy(flags, io) {
 		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} (셀러 콘솔 › 설정 › 보안 › 승인 요청)`);
+			else io.out(`승인 요청 id: ${error.approvalId} (상점 플랫폼 › 설정 › 보안 › 승인 요청)`);
 			return EXIT_APPROVAL_PENDING;
 		}
 		throw error;
@@ -1451,7 +2061,7 @@ async function deploy(flags, io) {
 		});
 	} catch (error) {
 		const code = codeOf(error);
-		if (code === "STOREFRONT_BUILD_IN_PROGRESS") throw new CliError("이 사이트에 끝나지 않은 빌드가 있습니다(콘솔·AI 또는 다른 배포). 작업 트리는 올렸습니다 — npx sayren status로 확인한 뒤 다시 배포하십시오");
+		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;
 	}
@@ -1463,7 +2073,7 @@ async function deploy(flags, io) {
 	}
 	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}를 발행할 수 있습니다`);
+		io.out(`발행하지 않았습니다(--no-publish). 상점 플랫폼 › 스토어프론트 › 버전에서 v${created.version.number}를 발행할 수 있습니다`);
 		return 0;
 	}
 	try {
@@ -1475,10 +2085,10 @@ async function deploy(flags, io) {
 		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} (셀러 콘솔 › 설정 › 보안 › 승인 요청)`);
+			else io.out(`승인 요청 id: ${error.approvalId} (상점 플랫폼 › 설정 › 보안 › 승인 요청)`);
 			return EXIT_APPROVAL_PENDING;
 		}
-		if (codeOf(error) === "STOREFRONT_SITE_CHANGED") throw new CliError(`다른 사람이 그 사이 다른 버전을 발행했습니다. v${created.version.number}는 만들어 뒀습니다 — 콘솔에서 확인한 뒤 발행하십시오`);
+		if (codeOf(error) === "STOREFRONT_SITE_CHANGED") throw new CliError(`다른 사람이 그 사이 다른 버전을 발행했습니다. v${created.version.number}는 만들어 뒀습니다 — 상점 플랫폼에서 확인한 뒤 발행하십시오`);
 		throw error;
 	}
 }
@@ -1529,9 +2139,9 @@ async function replaceSource(client, tree, rc, force, io) {
 					dependencyWarnings: []
 				};
 			}
-			throw new CliError("원격 작업 트리가 pull 이후 바뀌었습니다(콘솔·AI 편집). 덮어쓰지 않았습니다.\n  · 원격을 받으려면: npx sayren pull --force (로컬 변경은 먼저 커밋·백업하십시오)\n  · 이 폴더 내용으로 덮어쓰려면: npx sayren deploy --force");
+			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 === "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로 중간 배포)`);
@@ -1610,9 +2220,7 @@ async function status(flags, io) {
 	const dir = resolve(io.cwd, flags.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);
+	const { client } = await apiFor(flags, dir, rc, io);
 	const hosting = await client.storefront.get();
 	const site = hosting.site;
 	if (!site) {
@@ -1632,48 +2240,116 @@ async function status(flags, io) {
 	else io.out(`  이 폴더의 기준 작업 트리 ${rc.baseRef.slice(rc.baseRef.lastIndexOf("/") + 1, -4).slice(0, 12)}`);
 	return 0;
 }
+/**
+* `sayren login`(#71) — 기본은 Sayren 계정 로그인이다(브라우저 루프백 + PKCE, 안 되면 디바이스 코드). 로그인 토큰은 사용자 설정
+* 폴더의 `credentials.json`에 둔다. `--token`·`--paste`로 계정 액세스 토큰(PAT)을 붙여 넣을 수 있다. 옛 API 토큰(`sy_pat_`)은
+* 폐기되어(R1) 거절한다.
+*/
 async function login(flags, io, readToken) {
+	const pasted = flags.token?.trim() || (flags.paste ? (await readToken())?.trim() : void 0);
+	if (flags.paste && !pasted) throw new CliError("토큰을 입력하지 않았습니다");
+	if (pasted) {
+		assertAccountToken(pasted);
+		return pasteAccountToken(flags, pasted, io);
+	}
+	return accountLogin(flags, io);
+}
+/** 브라우저(루프백) 또는 디바이스 코드로 로그인한다 */
+async function accountLogin(flags, io) {
 	const dir = resolve(io.cwd, flags.dir ?? ".");
-	const token = flags.token?.trim() || (await readToken())?.trim();
-	if (!token) throw new CliError("토큰을 입력하지 않았습니다");
-	migrateLegacy(dir, io.out);
-	const state = readState(dir);
-	const client = clientOf(resolveAuth({
-		...flags,
-		token
-	}, 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 });
-	if (writeMcpJson(dir, {
-		token,
-		storeId: expected ?? tokenStore
-	}) === "tracked") {
-		io.err(`알림: ${TRACKED_MCP_JSON_NOTICE}`);
-		return 1;
+	const state = existsSync(dir) ? readState(dir) : null;
+	const { apiOrigin } = resolveApiOrigin(flags, dir, state, io.env);
+	const input = {
+		apiOrigin,
+		accountsOrigin: resolveAccountsOrigin(apiOrigin, flags.accountsOrigin, io.env)
+	};
+	let entry = null;
+	if (!flags.device && !headlessEnvironment(io.env)) entry = await browserLogin(io, input);
+	if (!entry) {
+		if (!flags.device) io.out("브라우저를 열 수 없어 기기 코드로 로그인합니다");
+		entry = await deviceLogin(io, input);
 	}
-	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}를 더하십시오`);
+	const path = await withCredentialLock(io.env, io.sleep, async () => saveCredential(io.env, apiOrigin, entry));
+	io.out(`로그인했습니다${entry.email ? `: ${entry.email}` : ""} (${path})`);
+	await reportStores(apiOrigin, entry.accessToken, io);
+	await writeAccountMcpJson(dir, state, io);
 	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;
+/** 붙여 넣은 계정 액세스 토큰(PAT)을 자격 증명 파일에 둔다 — 갱신이 없고 만료까지 쓴다 */
+async function pasteAccountToken(flags, token, io) {
+	const dir = resolve(io.cwd, flags.dir ?? ".");
+	const state = existsSync(dir) ? readState(dir) : null;
+	const { apiOrigin } = resolveApiOrigin(flags, dir, state, io.env);
+	const claims = accountTokenClaimsOf(token);
+	const now = io.now?.() ?? Date.now();
+	if (typeof claims?.exp !== "number" || claims.exp * 1e3 <= now) throw new CliError("만료된 토큰입니다. Sayren 계정 › 액세스 토큰에서 새로 만드십시오");
+	const accountsOrigin = typeof claims.iss === "string" ? claims.iss : resolveAccountsOrigin(apiOrigin, flags.accountsOrigin, io.env);
+	const entry = {
+		accessToken: token,
+		expiresAt: claims.exp * 1e3,
+		...claims.scope ? { scope: claims.scope } : {},
+		accountsOrigin,
+		kind: claims.sayren_kind === "oauth" ? "oauth" : "pat"
+	};
+	const path = await withCredentialLock(io.env, io.sleep, async () => saveCredential(io.env, apiOrigin, entry));
+	io.out(`액세스 토큰${claims.sayren_token_name ? `(${claims.sayren_token_name})` : ""}을 저장했습니다 (${path}, 만료 ${(/* @__PURE__ */ new Date(claims.exp * 1e3)).toISOString().slice(0, 10)})`);
+	await reportStores(apiOrigin, token, io);
+	await writeAccountMcpJson(dir, state, io);
+	return 0;
+}
+/** 쓸 수 있는 상점 수 — api가 계정 토큰을 아직 받지 않거나 `stores:read`가 없으면 알리기만 한다 */
+async function reportStores(apiOrigin, token, io) {
+	const auth = {
+		token,
+		apiOrigin,
+		tokenSource: "credentials",
+		originSource: "default"
+	};
 	try {
-		return (await client.storefront.getSource()).storeId;
+		const stores = await clientOf(auth, io.fetch).auth.listMyStores();
+		const claims = accountTokenClaimsOf(token);
+		const scoped = claims?.sayren_stores === "*" || !Array.isArray(claims?.sayren_stores) ? stores : stores.filter((store) => claims.sayren_stores.includes(store.storeId));
+		io.out(`쓸 수 있는 상점 ${scoped.length}개`);
 	} catch {
-		return null;
+		io.err("알림: 상점 목록을 불러오지 못했습니다(권한 stores:read 또는 api 연결을 확인하십시오)");
+	}
+}
+/** 받은 폴더면 `.mcp.json`을 토큰 없는 항목(주소·상점)으로 맞춘다. 폐기된 옛 토큰 헤더는 지우고 알린다 */
+async function writeAccountMcpJson(dir, state, io) {
+	if (!state || !isPulledDir(dir)) return;
+	if (writeMcpJson(dir, { storeId: state.storeId }) === "retired-token-removed") io.err(`알림: ${RETIRED_MCP_TOKEN_NOTICE}`);
+	io.out(`${relativeOf(io, join(dir, MCP_FILE))} 작성 — 원격 MCP 주소와 상점. ${ACCOUNT_MCP_NOTE}`);
+}
+/** `sayren logout` — refresh를 폐기하고(실패는 알리기만) 자격 증명 파일의 항목을 지운다 */
+async function logout(flags, io) {
+	const dir = resolve(io.cwd, flags.dir ?? ".");
+	const { apiOrigin } = resolveApiOrigin(flags, dir, existsSync(dir) ? readState(dir) : null, io.env);
+	const entry = readCredential(io.env, apiOrigin);
+	if (!entry) {
+		io.out("로그인한 계정이 없습니다");
+		return 0;
 	}
+	const revoked = await revokeRefresh(io, entry);
+	await withCredentialLock(io.env, io.sleep, async () => deleteCredential(io.env, apiOrigin));
+	io.out(`로그아웃했습니다${entry.email ? `: ${entry.email}` : ""}`);
+	if (!revoked) io.err("알림: 계정 서버에서 로그인을 폐기하지 못했습니다(토큰은 이 컴퓨터에서 지웠습니다)");
+	return 0;
+}
+/** `sayren whoami` — 쓰는 토큰의 종류·계정·상점 범위 */
+async function whoami(flags, io) {
+	const dir = resolve(io.cwd, flags.dir ?? ".");
+	const auth = resolveAuth(flags, dir, existsSync(dir) ? readState(dir) : null, io.env, credentialTokenReader(io.env));
+	const refresh = await readyAuth(auth, io);
+	const client = clientOf(auth, io.fetch, refresh);
+	const claims = accountTokenClaimsOf(auth.token);
+	const entry = auth.tokenSource === "credentials" ? readCredential(io.env, auth.apiOrigin) : null;
+	const email = (await client.auth.me().catch(() => null))?.email ?? entry?.email ?? "확인 불가";
+	const kind = claims?.sayren_kind === "pat" ? "액세스 토큰" : "로그인";
+	const scope = claims?.sayren_stores === "*" ? "모든 상점" : Array.isArray(claims?.sayren_stores) ? claims.sayren_stores.join(", ") || "없음" : "확인 불가";
+	io.out(`${email} — ${kind}(${auth.tokenSource === "credentials" ? credentialsPathOf(io.env) : auth.tokenSource})`);
+	io.out(`  상점 범위 ${scope}`);
+	if (claims?.scope) io.out(`  권한 ${claims.scope}`);
+	return 0;
 }
 function relativeOf(io, path) {
 	return relative(io.cwd, path) || ".";
@@ -1684,31 +2360,42 @@ function relativeOf(io, path) {
 const USAGE = `sayren ${CLI_VERSION} — 호스팅 스토어프론트 CLI
 
 사용법:
-  npx sayren login                       # 토큰을 입력받아 .mcp.json에 저장(셸 기록에 남지 않습니다)
+  npx sayren login [--device]            # Sayren 계정으로 로그인(브라우저, 안 되면 기기 코드)
+  npx sayren login --paste               # 액세스 토큰을 입력받아 저장(셸 기록에 남지 않습니다)
+  npx sayren logout
+  npx sayren whoami
   npx sayren pull --project <storeId> [폴더] [--force [--yes]]
   npx sayren deploy [--no-publish] [--message <메모>] [--force [--yes]]
   npx sayren status
   npx sayren verify
 
 명령:
-  login    토큰을 확인하고 지금 폴더의 .mcp.json(sayren 원격 MCP 설정)에 저장합니다
-  pull     호스팅 중인 사이트의 작업 트리를 폴더(기본: 스토어 코드)로 받고 .mcp.json·.env·.sayren/state.json을 씁니다
+  login    Sayren 계정으로 로그인합니다. 로그인 토큰은 사용자 설정 폴더(~/.config/sayren/credentials.json)에 둡니다
+  logout   로그인을 폐기하고 이 컴퓨터의 토큰을 지웁니다
+  whoami   쓰는 계정·토큰 종류·상점 범위
+  pull     호스팅 중인 사이트의 작업 트리를 폴더(기본: 상점 코드)로 받고 .mcp.json·.env·.sayren/state.json을 씁니다
   deploy   로컬 검사 → 작업 트리 올리기 → 빌드 → 발행. 원격이 pull 이후 바뀌었으면 덮어쓰지 않습니다
   status   사이트·발행 버전·최근 빌드·편집 환경
   verify   로컬 규칙·경로·크기 검사(서버 빌드와 같은 규칙)
 
-토큰은 --token → SAYREN_TOKEN 환경 변수 → .mcp.json 순서로 읽습니다(API 토큰 sy_pat_…, 스코프 storefront:rw).
+토큰은 Sayren 계정 토큰만 받고 --token → SAYREN_TOKEN 환경 변수 → 로그인(credentials.json) 순서로 읽습니다.
+계정 토큰은 계정에 발급됩니다 — 상점은 --store → SAYREN_STORE_ID → 폴더 설정 순서로 고릅니다(하나면 자동).
+옛 API 토큰(sy_pat_…)은 더 쓸 수 없습니다. .mcp.json에는 토큰을 쓰지 않습니다(MCP 클라이언트가 스스로 로그인합니다).
 .mcp.json·.env·.sayren/은 .gitignore에 더하고 배포에 올리지 않습니다.
 
 옵션:
-  --project <storeId>  pull: 토큰의 스토어와 같아야 합니다
-  --dir <폴더>         작업 폴더(기본: 지금 폴더, pull은 스토어 코드)
+  --project <storeId>  pull: 받을 상점(--store와 같습니다)
+  --dir <폴더>         작업 폴더(기본: 지금 폴더, pull은 상점 코드)
   --force              pull: 같은 사이트를 받은 폴더에 원격을 다시 받습니다(지울·덮을 파일을 보여 주고 묻습니다)
                        deploy: 원격 변경·열린 편집 환경을 무시하고 덮어씁니다(확인을 묻습니다)
   --yes                --force의 확인을 묻지 않습니다(비대화형)
   --no-publish         deploy: 버전까지만 만들고 발행하지 않습니다
   --message <메모>     deploy: 버전 메모
+  --store <storeId>    다룰 상점(SAYREN_STORE_ID)
+  --device             login: 브라우저 대신 기기 코드로 로그인합니다(SSH 등)
+  --paste              login: 액세스 토큰을 입력받습니다
   --api-origin <주소>  api 주소(기본 https://api.sayren.app, SAYREN_API_ORIGIN). https만, localhost만 http
+  --accounts-origin <주소>  계정 서버 주소(기본: api 주소에 맞춘 값, SAYREN_ACCOUNTS_ORIGIN)
   --token <토큰>       토큰을 직접 줍니다. 셸 기록·프로세스 목록에 남으니 login·SAYREN_TOKEN을 권합니다
 
 종료 코드: 0 성공 · 1 실패 · 3 승인 대기(에이전트 토큰)`;
@@ -1717,14 +2404,18 @@ const VALUE_FLAGS = new Set([
 	"project",
 	"dir",
 	"message",
-	"api-origin"
+	"api-origin",
+	"store",
+	"accounts-origin"
 ]);
 const BOOL_FLAGS = new Set([
 	"force",
 	"yes",
 	"no-publish",
 	"help",
-	"version"
+	"version",
+	"device",
+	"paste"
 ]);
 function parseArgs(argv) {
 	const out = {
@@ -1768,7 +2459,14 @@ async function main(argv, io) {
 	const common = {
 		token: str(parsed.flags.token),
 		apiOrigin: str(parsed.flags["api-origin"]),
-		dir: str(parsed.flags.dir) ?? parsed.positional[0]
+		dir: str(parsed.flags.dir) ?? parsed.positional[0],
+		store: str(parsed.flags.store)
+	};
+	const loginFlags = {
+		...common,
+		device: parsed.flags.device === true,
+		paste: parsed.flags.paste === true,
+		accountsOrigin: str(parsed.flags["accounts-origin"])
 	};
 	switch (parsed.command) {
 		case "pull": return pull({
@@ -1786,7 +2484,9 @@ async function main(argv, io) {
 		}, io);
 		case "status": return status(common, io);
 		case "verify": return verify(common, io);
-		case "login": return login(common, io, () => ask("API 토큰(sy_pat_…): "));
+		case "login": return login(loginFlags, io, () => ask("액세스 토큰: "));
+		case "logout": return logout(loginFlags, io);
+		case "whoami": return whoami(common, io);
 		default: throw new CliError(`알 수 없는 명령: ${parsed.command}\n\n${USAGE}`);
 	}
 }
@@ -1812,14 +2512,49 @@ function defaultIo() {
 		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
+		pollMs: 3e3,
+		openBrowser,
+		select: stdin.isTTY ? async (question, options) => {
+			console.log(question);
+			options.forEach((option, index) => {
+				console.log(`  ${index + 1}. ${option}`);
+			});
+			const answer = Number((await ask("번호: ") ?? "").trim());
+			return Number.isInteger(answer) ? options[answer - 1] ?? null : null;
+		} : null
 	};
 }
+/** 운영체제 기본 브라우저로 연다. 열기 명령을 못 띄우면 false(로그인은 기기 코드로 넘어간다) */
+function openBrowser(url) {
+	const [command, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", [
+		"/c",
+		"start",
+		"",
+		url
+	]] : ["xdg-open", [url]];
+	return new Promise((resolve$1) => {
+		try {
+			const child = spawn(command, args, {
+				stdio: "ignore",
+				detached: true
+			});
+			child.once("error", () => resolve$1(false));
+			child.once("spawn", () => {
+				child.unref();
+				resolve$1(true);
+			});
+		} catch {
+			resolve$1(false);
+		}
+	});
+}
 /** 오류 표시 — 토큰·요청 본문은 싣지 않는다 */
 function describeError(error) {
 	if (error instanceof CliError) return error.message;
 	if (error instanceof ApiError) {
-		if (error.status === 401) return "토큰이 올바르지 않거나 만료됐습니다(401). 셀러 콘솔 › 개발자 › API 토큰을 확인하십시오";
+		if (error.status === 401 && error.code === "TOKEN_TYPE_RETIRED") return RETIRED_TOKEN_MESSAGE;
+		if (error.status === 401) return "토큰이 올바르지 않거나 만료됐습니다(401). npx sayren login으로 다시 로그인하거나 새 액세스 토큰을 쓰십시오";
+		if (error.status === 403 && error.code === "STORE_NOT_GRANTED") return "이 토큰의 상점 범위 밖입니다. 그 상점을 포함해 다시 로그인하십시오(npx sayren login)";
 		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})`;