sayren 0.1.0 → 0.3.0

package/dist/index.mjs

@@ -1,27 +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 { createHash } from "node:crypto";
+import { createHash, randomBytes } from "node:crypto";
+import { createServer } from "node:http";
 
 //#region package.json
-var version = "0.1.0";
+var version = "0.3.0";
 
 //#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);
@@ -40,8 +48,981 @@ 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
+/**
+* 셀러 프로젝트의 `.mcp.json`(Claude Code 형식) — 원격 MCP(`mcp.sayren.app`)에 붙는 `sayren` 항목을 만들고 읽는다.
+*
+* `npx sayren pull`·`login`(packages/cli)과 `sayren-mcp create`가 같은 함수로 쓴다. 파일 입출력은 부르는 쪽이 하고 여기는 문자열만
+* 다룬다 — 게이트웨이(Worker)가 헤더 이름을 이 파일에서 가져가므로 Node 전용 API를 쓰지 않는다.
+*
+* - **토큰을 쓰지 않는다(#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가 토큰의 스토어 범위와 대조한다) */
+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);
+}
+/** `Authorization` 헤더 값이 폐기된 옛 API 토큰(`Bearer sy_pat_…`)인가 */
+function isRetiredAuthorization(value) {
+	return typeof value === "string" && /^Bearer\s+sy_pat_/i.test(value.trim());
+}
+/**
+* `sayren` 항목을 넣거나 바꾼 `.mcp.json` 본문. `existing`이 없으면 새 파일이다. 폐기된 옛 토큰 헤더는 지운다(`removedRetiredToken`).
+* 형식이 틀린 파일은 덮어쓰지 않고 `McpJsonError`다(셀러가 손으로 쓴 다른 서버 설정을 지우지 않게).
+*/
+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 } : {};
+	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: {
+			...entry.storeId ? { [STORE_ID_HEADER]: entry.storeId } : {},
+			...headers
+		}
+	};
+	delete next.command;
+	delete next.args;
+	delete next.env;
+	servers[MCP_SERVER_NAME] = next;
+	return {
+		text: `${JSON.stringify({
+			...root,
+			mcpServers: servers
+		}, null, 2)}\n`,
+		removedRetiredToken
+	};
+}
+/** `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 storeKey = headerKey(headers, STORE_ID_HEADER);
+	const store = storeKey ? headers[storeKey] : void 0;
+	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 없음)다.
+* 항목에 토큰을 쓰지 않는다(#71 R1). 심볼릭 링크는 따라가지 않는다(폴더 밖 파일을 덮지 않게).
+*/
+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;
+}
+/** 심볼릭 링크면 쓰지 않는다(링크를 따라 폴더 밖 파일을 덮지 않게). 권한은 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 {}
+}
+/** `.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;
+	}
+}
+
+//#endregion
+//#region src/account-auth.ts
+/**
+* 명령이 토큰을 쓰기 전 준비(#71) — 자격 증명 파일 토큰의 갱신, 계정 토큰의 스토어 고르기.
+*/
+/** 자격 증명 파일에서 토큰을 읽는 함수(`resolveAuth`에 넘긴다) */
+function credentialTokenReader(env) {
+	return (apiOrigin) => readCredential(env, apiOrigin)?.accessToken ?? null;
+}
+/**
+* 토큰 준비 — 자격 증명 파일 토큰이면 만료 60초 전에 갱신한다. 401 재시도용 갱신 함수를 돌려준다(자격 증명 파일 토큰만).
+*/
+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 {
+		stores = (await client.auth.listMyStores()).filter((store) => storeInScope(claims, store.storeId));
+	} catch {
+		throw new CliError("스토어를 고르지 못했습니다. --store <storeId> 또는 SAYREN_STORE_ID로 스토어를 주십시오");
+	}
+	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}`;
@@ -225,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"
 	}
 ];
 /**
@@ -326,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\(/);
@@ -349,7 +1341,8 @@ 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)
 	};
 }
 /** 위반을 고치는 순서 — 에이전트가 무엇부터 할지 묻지 않게 한다 */
@@ -386,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,
@@ -407,7 +1416,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 +1431,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 +1448,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 +1510,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();
@@ -602,152 +1611,21 @@ async function gunzip(bytes, maxBytes) {
 }
 
 //#endregion
-//#region src/config.ts
+//#region src/tree.ts
 /**
-* 설정 — 우선순위는 플래그 > 환경 변수(`SAYREN_TOKEN`·`SAYREN_API_ORIGIN`) > `.env` > `.sayrenrc`다.
-*
-* - `.sayrenrc`: pull이 만든다. 비밀이 없어 커밋해도 된다(`storeId`·`siteId`·`baseRef`, 기본이 아닌 api 주소).
-*   **토큰을 두지 않는다** — 읽을 때 `token` 같은 필드가 있으면 무시하고 경고한다.
-* - `.env`: 토큰(`SAYREN_TOKEN`)과 스토어프론트 템플릿이 읽는 값(`SAYREN_API_URL`·`SAYREN_STORE_CODE`). `.gitignore` 대상이다.
-*   템플릿은 `SAYREN_TOKEN`만 서버 코드 환경에 싣지 않는다(vite.config.ts).
+* 로컬 작업 트리 — 서버 작업 트리와 **같은 경로 규칙**(편집 Sandbox `paths.ts`의 `accessOf`)으로 고른다. `src/**`·`public/**`·루트 설정
+* 파일·`package.json`·`pnpm-lock.yaml`만 올리고, `.env*`·`.mcp.json`·`.sayren/`·`node_modules`·`dist`·`package-lock.json` 등은 올리지 않는다.
+* 비밀·로컬 상태 파일(`isNeverUpload`)은 서버 경로 규칙과 별개로 CLI가 먼저 막는다 — 서버 규칙이 넓어져도 토큰을 올리지 않게.
 */
-const RC_FILE = ".sayrenrc";
-const ENV_FILE = ".env";
-const DEFAULT_API_ORIGIN = "https://api.sayren.app";
-const RC_KEYS = [
-	"storeId",
-	"siteId",
-	"baseRef",
-	"apiOrigin"
-];
-function readRc(dir) {
-	const path = join(dir, RC_FILE);
-	if (!existsSync(path)) return null;
-	let parsed;
-	try {
-		parsed = JSON.parse(readFileSync(path, "utf8"));
-	} catch {
-		throw new CliError(`${RC_FILE}를 읽지 못했습니다. JSON 형식을 확인하십시오`);
-	}
-	if (!parsed || typeof parsed !== "object") throw new CliError(`${RC_FILE} 형식이 아닙니다`);
-	const rc = parsed;
-	for (const key of Object.keys(rc)) if (!RC_KEYS.includes(key)) console.warn(`경고: ${RC_FILE}의 ${key}는 쓰지 않습니다(토큰은 .env에 두십시오)`);
-	if (typeof rc.storeId !== "string" || typeof rc.siteId !== "string" || typeof rc.baseRef !== "string") throw new CliError(`${RC_FILE}에 storeId·siteId·baseRef가 없습니다. npx sayren pull로 다시 받으십시오`);
-	return {
-		storeId: rc.storeId,
-		siteId: rc.siteId,
-		baseRef: rc.baseRef,
-		...typeof rc.apiOrigin === "string" ? { apiOrigin: rc.apiOrigin } : {}
-	};
-}
-function writeRc(dir, rc) {
-	const out = {
-		storeId: rc.storeId,
-		siteId: rc.siteId,
-		baseRef: rc.baseRef
-	};
-	if (rc.apiOrigin && rc.apiOrigin !== DEFAULT_API_ORIGIN) out.apiOrigin = rc.apiOrigin;
-	writeFileSync(join(dir, RC_FILE), `${JSON.stringify(out, null, 2)}\n`);
-}
-/** `.env` 읽기 — `KEY=VALUE` 줄만(따옴표는 벗긴다). 없으면 빈 값 */
-function readEnvFile(dir) {
-	const path = join(dir, ENV_FILE);
-	const out = /* @__PURE__ */ new Map();
-	if (!existsSync(path)) return out;
-	for (const line of readFileSync(path, "utf8").split(/\r?\n/)) {
-		const m = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)\s*$/.exec(line);
-		if (!m?.[1]) continue;
-		let value = m[2] ?? "";
-		if (/^(['"]).*\1$/.test(value)) value = value.slice(1, -1);
-		out.set(m[1], value);
-	}
-	return out;
-}
-/** `.env`에 값들을 쓴다 — 다른 줄은 그대로 두고 같은 키만 바꾼다. 파일 권한은 600이다(토큰) */
-function updateEnvFile(dir, values) {
-	const path = join(dir, ENV_FILE);
-	const lines = existsSync(path) ? readFileSync(path, "utf8").split(/\r?\n/) : [];
-	const pending = new Map(Object.entries(values));
-	const next = lines.map((line) => {
-		const key = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/.exec(line)?.[1];
-		if (key && pending.has(key)) {
-			const value = pending.get(key);
-			pending.delete(key);
-			return `${key}=${value}`;
-		}
-		return line;
-	});
-	while (next.length > 0 && next[next.length - 1] === "") next.pop();
-	for (const [key, value] of pending) next.push(`${key}=${value}`);
-	writeFileSync(path, `${next.join("\n")}\n`, { mode: 384 });
-	try {
-		chmodSync(path, 384);
-	} catch {}
-}
-/** `.gitignore`에 `.env`가 없으면 더한다. 더했으면 true */
-function ensureGitignore(dir) {
-	const path = join(dir, ".gitignore");
-	const text = existsSync(path) ? readFileSync(path, "utf8") : "";
-	const lines = text.split(/\r?\n/).map((line) => line.trim());
-	if (lines.includes(".env") || lines.includes(".env*") || lines.includes("/.env")) return false;
-	writeFileSync(path, `${text}${text && !text.endsWith("\n") ? "\n" : ""}.env\n`);
-	return true;
-}
-/** 스토어프론트 API 주소(`…/storefront/v1`)에서 api origin을 읽는다 */
-function originOfStorefrontUrl(url) {
-	if (!url) return null;
-	return /^(https?:\/\/[^/]+)\/storefront\/v1\/?$/.exec(url.trim())?.[1] ?? null;
-}
-function resolveAuth(flags, dir, rc, env = process.env) {
-	const dotenv = readEnvFile(dir);
-	const fromFlag = flags.token?.trim();
-	const fromEnv = env.SAYREN_TOKEN?.trim();
-	const fromFile = dotenv.get("SAYREN_TOKEN")?.trim();
-	const token = fromFlag || fromEnv || fromFile;
-	if (!token) throw new CliError("토큰이 없습니다. --token으로 주거나 SAYREN_TOKEN 환경 변수·.env에 넣으십시오(셀러 콘솔 › 개발자 › API 토큰, 스코프 storefront:rw)");
-	const picked = [
-		["flag", flags.apiOrigin?.trim()],
-		["env", env.SAYREN_API_ORIGIN?.trim()],
-		[".env", originOfStorefrontUrl(dotenv.get("SAYREN_API_URL"))],
-		["rc", rc?.apiOrigin]
-	].find(([, value]) => value);
-	const apiOrigin = (picked?.[1] ?? DEFAULT_API_ORIGIN).replace(/\/+$/, "");
-	assertOriginShape(apiOrigin);
-	return {
-		token,
-		apiOrigin,
-		tokenSource: fromFlag ? "flag" : fromEnv ? "env" : ".env",
-		originSource: picked && apiOrigin !== DEFAULT_API_ORIGIN ? picked[0] : "default"
-	};
-}
-/** 로컬 개발 주소 — http를 받는다 */
-const LOOPBACK = new Set([
-	"localhost",
-	"127.0.0.1",
-	"[::1]"
-]);
-/** api 주소 형식 — https만 받는다(토큰을 싣고 보낸다). localhost·127.0.0.1만 http 예외다 */
-function assertOriginShape(origin) {
-	let url;
-	try {
-		url = new URL(origin);
-	} catch {
-		throw new CliError(`api 주소 형식이 아닙니다: ${origin}`);
-	}
-	const loopback = LOOPBACK.has(url.hostname);
-	if (url.protocol !== "https:" && !(loopback && url.protocol === "http:")) throw new CliError(`api 주소는 https여야 합니다(localhost만 http 예외): ${origin}. 토큰이 이 주소로 갑니다`);
+/**
+* 어떤 경우에도 올리지 않는 파일 — `.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";
 }
-/** 사용자에게 보여 줄 오류 — 스택 없이 문장만 찍고 종료 코드 1로 끝난다 */
-var CliError = class extends Error {
-	constructor(message, exitCode = 1) {
-		super(message);
-		this.exitCode = exitCode;
-		this.name = "CliError";
-	}
-};
-
-//#endregion
-//#region src/tree.ts
 /** 걸어 들어가지 않는 폴더 — 설치물·산출물·캐시·VCS(경로 규칙이 어차피 막는다. 크기 때문에 읽지도 않는다) */
 const SKIP_DIRS = new Set([
 	"node_modules",
@@ -778,7 +1656,7 @@ function collectTree(root) {
 				skipped.push(rel);
 				continue;
 			}
-			if (accessOf(rel) === null) {
+			if (isNeverUpload(rel) || accessOf(rel) === null) {
 				skipped.push(rel);
 				continue;
 			}
@@ -888,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) => {
@@ -980,43 +1858,75 @@ 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 주소를 정하고(자격 증명 파일 포함) 준비한 관리 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`으로 명시해야 한다)
 */
 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);
-	await checkAuthSources(auth, io);
-	const client = clientOf(auth, io.fetch);
+	const authDir = existsSync(probeDir) ? probeDir : io.cwd;
+	migrateLegacy(authDir, io.out);
+	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.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
 	};
 	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 +1964,28 @@ 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, { 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 === "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 편집 환경이 열려 있습니다. 배포 전에 그 편집이 끝났는지 확인하십시오");
-	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);
@@ -1097,22 +1999,30 @@ 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}`);
-	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로 사이트 소스를 받으십시오`);
-	const auth = resolveAuth(flags, dir, rc, io.env);
-	await checkAuthSources(auth, io);
-	const client = clientOf(auth, io.fetch);
+	migrateLegacy(dir, io.out);
+	const rc = readState(dir);
+	if (!rc) {
+		let storeId = null;
+		try {
+			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 { client } = await apiFor(flags, dir, rc, io);
 	const tree = collectTree(dir);
 	const checks = runLocalChecks(tree);
 	printChecks(tree, checks, io);
@@ -1138,7 +2048,7 @@ async function deploy(flags, io) {
 		}
 		throw error;
 	}
-	writeRc(dir, {
+	writeState(dir, {
 		...rc,
 		baseRef: replaced.sourceRef
 	});
@@ -1245,6 +2155,7 @@ const REASON_LABEL = {
 	MALWARE: "악성 패키지",
 	INVALID_MANIFEST: "선언 오류",
 	INSTALL_SCRIPT: "설치 스크립트",
+	INSTALL_CONFIG: "설치 방식 필드",
 	UNSUPPORTED_SOURCE: "지원하지 않는 설치 경로",
 	BUNDLED_DEPENDENCIES: "묶인 의존성"
 };
@@ -1307,10 +2218,9 @@ function printBuildFailure(build, io) {
 }
 async function status(flags, io) {
 	const dir = resolve(io.cwd, flags.dir ?? ".");
-	const rc = readRc(dir);
-	const auth = resolveAuth(flags, dir, rc, io.env);
-	await checkAuthSources(auth, io);
-	const client = clientOf(auth, io.fetch);
+	migrateLegacy(dir, io.out);
+	const rc = readState(dir);
+	const { client } = await apiFor(flags, dir, rc, io);
 	const hosting = await client.storefront.get();
 	const site = hosting.site;
 	if (!site) {
@@ -1330,18 +2240,115 @@ 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 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 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;
+}
+/** 붙여 넣은 계정 액세스 토큰(PAT)을 자격 증명 파일에 둔다 — 갱신이 없고 만료까지 쓴다 */
+async function pasteAccountToken(flags, token, io) {
 	const dir = resolve(io.cwd, flags.dir ?? ".");
-	const token = flags.token?.trim() || (await readToken())?.trim();
-	if (!token) throw new CliError("토큰을 입력하지 않았습니다");
-	const hosting = await clientOf(resolveAuth({
-		...flags,
-		token
-	}, dir, readRc(dir), io.env), io.fetch).storefront.get();
-	mkdirSync(dir, { recursive: true });
-	updateEnvFile(dir, { SAYREN_TOKEN: token });
-	const addedIgnore = ensureGitignore(dir);
-	io.out(`토큰을 확인하고(사이트 ${hosting.site?.hostname ?? "없음"}) ${relativeOf(io, join(dir, ENV_FILE))}에 저장했습니다${addedIgnore ? "(.gitignore에 .env를 더했습니다)" : ""}`);
+	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 {
+		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 {
+		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) {
@@ -1353,30 +2360,42 @@ function relativeOf(io, path) {
 const USAGE = `sayren ${CLI_VERSION} — 호스팅 스토어프론트 CLI
 
 사용법:
-  npx sayren login                       # 토큰을 입력받아 .env에 저장(셸 기록에 남지 않습니다)
+  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    토큰을 확인하고 지금 폴더의 .env에 저장합니다
-  pull     호스팅 중인 사이트의 작업 트리를 폴더(기본: 스토어 코드)로 받고 .sayrenrc·.env를 씁니다
+  login    Sayren 계정으로 로그인합니다. 로그인 토큰은 사용자 설정 폴더(~/.config/sayren/credentials.json)에 둡니다
+  logout   로그인을 폐기하고 이 컴퓨터의 토큰을 지웁니다
+  whoami   쓰는 계정·토큰 종류·스토어 범위
+  pull     호스팅 중인 사이트의 작업 트리를 폴더(기본: 스토어 코드)로 받고 .mcp.json·.env·.sayren/state.json을 씁니다
   deploy   로컬 검사 → 작업 트리 올리기 → 빌드 → 발행. 원격이 pull 이후 바뀌었으면 덮어쓰지 않습니다
   status   사이트·발행 버전·최근 빌드·편집 환경
   verify   로컬 규칙·경로·크기 검사(서버 빌드와 같은 규칙)
 
-토큰은 SAYREN_TOKEN 환경 변수 → .env 순서로 읽습니다(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: 토큰의 스토어와 같아야 합니다
+  --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 승인 대기(에이전트 토큰)`;
@@ -1385,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 = {
@@ -1436,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({
@@ -1454,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}`);
 	}
 }
@@ -1480,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})`;