deel-local-cli 1.20.13 → 2.0.1

package/src/safety/trust.js

@@ -44,18 +44,48 @@
 // `~/.deel/trusted.json` — 사용자 자리다. 프로젝트 안에 두면 저장소가 제
 // 신뢰를 제가 적는 셈이라 아무 뜻이 없다.
 import { homedir } from 'node:os';
-import { join, resolve } from 'node:path';
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { join, resolve, dirname, isAbsolute, parse as 경로쪼개기 } from 'node:path';
+import { readFileSync, writeFileSync, mkdirSync, existsSync, renameSync, rmSync, openSync, closeSync, statSync, realpathSync } from 'node:fs';
 import { c, mark } from '../ui/ansi.js';
 import { 말 } from '../i18n/index.js';
 
-function 사용자자리(env = process.env) {
-  return env.DEEL_HOME ? resolve(env.DEEL_HOME) : join(homedir(), '.deel');
+/**
+ * 글 맨 앞의 BOM(U+FEFF) 하나를 뗀다.
+ *
+ * 윈도우 파워셸 5.1 의 `Set-Content -Encoding UTF8` 은 파일 앞에 BOM 을 붙인다.
+ * 사내에서 설정을 스크립트로 까는 자리가 딱 그 명령이다. JSON.parse 는 그 한
+ * 글자에서 넘어지는데, 넘어진 뒤가 자리마다 달랐다 — 설정은 모든 명령이
+ * 종료코드 1 로 죽었고, 이 파일의 믿는 목록은 **아무 말 없이** 빈 목록이 됐다.
+ * 믿는다고 적어 둔 사람은 왜 안 믿기는지 알 길이 없다.
+ *
+ * 읽는 자리마다 따로 떼면 한 자리는 반드시 빠진다. 여기 하나를 같이 쓴다.
+ */
+export function BOM떼기(글) {
+  const s = String(글 ?? '');
+  return s.charCodeAt(0) === 0xfeff ? s.slice(1) : s;
+}
+
+/*
+ * 이 환경이 말하는 집 폴더.
+ *
+ * os.homedir() 는 **process.env 만** 본다. 그래서 env 를 따로 받은 부름(검사·훅·하위
+ * 작업)에서 아래 너무넓은자리() 는 그 env 의 USERPROFILE·HOME 으로 집을 재는데
+ * 사용자자리() 만 진짜 집을 썼다 — 가짜 집을 준 부름이 **이 PC 의 진짜 목록**을 읽고
+ * 적었다. 한 함수 안에서 집이 둘이면, 넓은지 재는 집과 적는 집이 다른 폴더가 된다.
+ * 집을 묻는 자리는 여기 하나다.
+ */
+function 집자리(env = process.env, platform = process.platform) {
+  const 차례 = platform === 'win32' ? [env.USERPROFILE, env.HOME] : [env.HOME, env.USERPROFILE];
+  return 차례.find((x) => typeof x === 'string' && x) || homedir();
+}
+
+function 사용자자리(env = process.env, platform = process.platform) {
+  return env.DEEL_HOME ? resolve(env.DEEL_HOME) : join(집자리(env, platform), '.deel');
 }
 
 /** 믿는 폴더 목록이 놓이는 자리. */
-export function 신뢰자리(env = process.env) {
-  return join(사용자자리(env), 'trusted.json');
+export function 신뢰자리(env = process.env, platform = process.platform) {
+  return join(사용자자리(env, platform), 'trusted.json');
 }
 
 /*
@@ -76,9 +106,7 @@ function 목록읽기(env) {
   const p = 신뢰자리(env);
   if (!existsSync(p)) return [];
   try {
-    const raw = JSON.parse(readFileSync(p, 'utf8'));
-    const 것들 = Array.isArray(raw) ? raw : raw?.trusted;
-    return Array.isArray(것들) ? 것들.filter((x) => typeof x === 'string') : [];
+    return 목록풀기(readFileSync(p, 'utf8'));
   } catch {
     // 못 읽으면 **아무것도 안 믿는다.** 반대로 하면 목록 파일 하나가 깨진
     // 것으로 온 폴더가 열린다. 여기서 안전한 쪽은 닫는 쪽뿐이다.
@@ -91,6 +119,52 @@ export function 믿는목록({ env = process.env } = {}) {
   return 목록읽기(env);
 }
 
+/*
+ * ── 믿으면 너무 많은 것이 같이 믿기는 자리 ─────────────────────────────
+ *
+ * 믿기는 **하위 폴더까지** 간다(아래 믿나). 저장소마다 스무 번 답하지 않게 하려는
+ * 것인데, 그 규칙이 넓은 자리에서는 거꾸로 돈다. `~` 를 믿으면 `~/src` 아래 받아 둔
+ * 남의 저장소가 **전부** 믿긴다.
+ *
+ * 막는 자리는 셋이다. 드라이브·파일시스템 뿌리, 사용자 집 폴더와 그 위, deel 설정
+ * 폴더를 품은 폴더와 그 위. 그리고 **절대 경로가 아닌 것** — `""`·`"."`·`"D:"`·`"D:foo"`
+ * 는 resolve 를 지나면 켠 자리가 되어서, 목록에 적혀 있으면 어디서 켜든 믿겼다.
+ * 드라이브의 켠 자리(`"D:"`)도 여기서 같이 걸린다. isAbsolute 는 콜론 뒤에 구분자가
+ * 없으면 절대 경로로 안 치기 때문이다 — 뒤에 무늬로 한 번 더 보던 줄은 그래서 한 번도
+ * 안 돌았고, 안 도는 규칙은 지키는 것처럼 보이기만 해서 걷어냈다.
+ *
+ * 이 자는 원래 bin/deel.js 에만 있었고 **적을 때만** 돌았다. 목록 파일에 이미
+ * `"C:\\"` 가 적혀 있으면(손으로 고쳤든, 옛 판이든, 스크립트든) 믿나() 는 그대로
+ * 믿었다. 그래서 여기 하나를 두고 적는 자리와 읽는 자리가 같이 쓴다.
+ *
+ * ── 링크를 따라가서 잰다 ──
+ *
+ * resolve 는 정션·심볼릭 링크를 안 따라간다. 집 폴더를 가리키는 `…\고리` 안에서
+ * `deel trust` 를 치면 글자가 달라 지나갔고, 믿긴 것은 고리 아래 전부 — 곧 집 폴더
+ * 전부였다. 그래서 실제 자리(realpath)로도 재고, 적힌 글자로도 잰다. 둘 중 하나라도
+ * 넓으면 넓다. 없는 자리라 실제 자리를 못 얻으면 적힌 글자로만 잰다.
+ */
+function 실제자리들(p) {
+  const 풀린 = resolve(p);
+  let 진짜 = 풀린;
+  try { 진짜 = realpathSync.native(풀린); } catch { /* 없는 자리 — 글자 그대로 잰다 */ }
+  return 진짜 === 풀린 ? [풀린] : [풀린, 진짜];
+}
+
+export function 너무넓은자리(폴더, { env = process.env, platform = process.platform } = {}) {
+  const 글 = String(폴더 ?? '');
+  if (!글 || !isAbsolute(글)) return true;   // "" · "." · "D:" · "D:foo" — resolve 를 지나면 켠 자리다
+  const 나들 = 실제자리들(글);
+  if (나들.some((p) => p === 경로쪼개기(p).root)) return true;
+  // 집 폴더는 이 환경이 말하는 것으로 잰다 (집자리 머리말 — 목록을 적는 자리와 같은 집이어야 한다).
+  const 집 = 집자리(env, platform);
+  const 품을것 = [...실제자리들(집), ...실제자리들(dirname(사용자자리(env)))].map((p) => 고른경로(p, platform));
+  return 나들.some((p) => {
+    const 나 = 고른경로(p, platform);
+    return 품을것.some((그것) => 그것 === 나 || 그것.startsWith(나 + '/'));
+  });
+}
+
 /**
  * 이 폴더의 프로젝트 설정을 믿나.
  *
@@ -103,48 +177,156 @@ export function 믿나(폴더, { env = process.env, platform = process.platform
   if (env.DEEL_TRUST_ALL === '1') return true;   // 검사·컨테이너용. 문서에 안 적는다.
   const 나 = 고른경로(폴더, platform);
   for (const 것 of 목록읽기(env)) {
+    // 목록에 적힌 넓은 자리는 읽을 때도 안 믿는다 (위 너무넓은자리 머리말).
+    // 파일은 안 고친다 — 적힌 것을 조용히 지우면 무엇이 왜 빠졌는지가 안 남는다.
+    if (너무넓은자리(것, { env, platform })) continue;
     const 그것 = 고른경로(것, platform);
     if (나 === 그것 || 나.startsWith(그것 + '/')) return true;
   }
   return false;
 }
 
+/** 목록 파일의 글을 목록으로. 못 풀면 던진다 — 던진 것을 어떻게 칠지는 부르는 쪽이 정한다. */
+function 목록풀기(글) {
+  const raw = JSON.parse(BOM떼기(글));
+  const 것들 = Array.isArray(raw) ? raw : raw?.trusted;
+  return Array.isArray(것들) ? 것들.filter((x) => typeof x === 'string') : [];
+}
+
+/*
+ * ── 열두 개를 한꺼번에 믿으면 여섯 개만 남았다 ─────────────────────────
+ *
+ * 믿기·안믿기는 「읽고 → 하나 더하고 → 통째로 쓰기」 였다. 둘이 같은 옛 목록을
+ * 읽고 각자 제 것을 더해 쓰면 **뒤에 쓴 쪽이 앞의 것을 덮는다.** 저장소 여럿을
+ * 한꺼번에 준비하는 스크립트가 딱 그렇게 부르고, 실제로 열둘을 띄워 여섯이 남았다.
+ * 적힌 줄 알았던 폴더는 조용히 안 믿긴다.
+ *
+ * 세 겹으로 막는다.
+ *   1. 잠금 파일(`trusted.json.lock`)을 `wx`(없을 때만 만들기)로 잡는다. 그건 두
+ *      프로세스가 동시에 성공할 수 없는 연산이라, 읽고-쓰는 사이에 아무도 못 낀다.
+ *      다 쓰고 나서 다시 읽어 맞추는 것만으로는 모자랐다 — 확인을 마친 **뒤에**
+ *      옛 목록을 들고 있던 쪽이 덮으면 그 확인은 아무것도 안 지킨다.
+ *   2. 쓸 때는 옆에 임시 파일로 쓰고 이름을 바꾼다. 그래야 그 사이에 믿나() 가
+ *      반쯤 쓴 파일을 읽고 「깨졌으니 아무것도 안 믿는다」 로 떨어지지 않는다.
+ *   3. 쓰는 쪽은 잠깐 못 읽은 것(윈도우에서 이름 바꾸는 순간의 EPERM)을 빈 목록으로
+ *      치지 않는다. 치면 남의 것을 다 지운 목록을 쓰게 된다. 믿나() 는 여전히
+ *      닫는 쪽(빈 목록)으로 떨어진다 — 거기서 안전한 쪽은 그쪽이다.
+ *
+ * 잠금을 쥔 채 죽은 프로세스가 있으면 영영 못 쓰게 된다. 그래서 오래된(10초)
+ * 잠금은 치운다. 믿기 한 번은 1밀리초 안쪽이라 10초짜리 진짜 잠금은 없다.
+ */
+const 잠금오래됨 = 10_000;
+const 잠금기다림 = 5_000;
+
+function 쉬기(ms) {
+  try { Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms); } catch { /* 못 쉬면 바로 다시 본다 */ }
+}
+
+/*
+ * 기다리는 시간은 부르는 쪽이 줄일 수 있다. `deel trust` 는 기본값을 쓰고, 검사는
+ * 잠금을 먼저 쥐고 짧게 기다려 본다 — 경합에 기대지 않고 「잠금을 지키나」 를 재려고.
+ */
+function 잠그고(env, 할일, 기다림 = 잠금기다림) {
+  mkdirSync(사용자자리(env), { recursive: true });
+  const 잠금 = `${신뢰자리(env)}.lock`;
+  const 끝 = Date.now() + 기다림;
+  for (;;) {
+    try {
+      closeSync(openSync(잠금, 'wx'));
+      break;
+    } catch (err) {
+      if (err?.code !== 'EEXIST' && err?.code !== 'EPERM' && err?.code !== 'EACCES') throw err;
+      try {
+        if (Date.now() - statSync(잠금).mtimeMs > 잠금오래됨) { rmSync(잠금, { force: true }); continue; }
+      } catch { /* 그 사이에 풀렸다 — 바로 다시 잡아 본다 */ }
+      if (Date.now() > 끝) throw new Error(`다른 deel 이 믿는 목록을 쓰고 있어 기다리다 그만뒀습니다 (${잠금})`);
+      쉬기(5 + Math.floor(Math.random() * 20));
+    }
+  }
+  try { return 할일(); } finally { try { rmSync(잠금, { force: true }); } catch { /* 오래되면 다음 사람이 치운다 */ } }
+}
+
+/** 쓰는 자리의 읽기. 파일이 없거나 깨졌으면 빈 목록, **잠깐 못 읽은 것은 다시 읽는다.** */
+function 쓸목록읽기(env) {
+  const p = 신뢰자리(env);
+  for (let 번 = 0; ; 번++) {
+    let 글;
+    try { 글 = readFileSync(p, 'utf8'); }
+    catch (err) {
+      if (err?.code === 'ENOENT') return [];
+      if (번 >= 20) throw err;
+      쉬기(10);
+      continue;
+    }
+    // 깨진 파일은 예전처럼 새 목록으로 덮는다. 믿나() 는 이미 그 파일을 안 믿고 있다.
+    try { return 목록풀기(글); } catch { return []; }
+  }
+}
+
 function 쓰기(것들, env) {
   const p = 신뢰자리(env);
   mkdirSync(사용자자리(env), { recursive: true });
-  writeFileSync(p, JSON.stringify({ version: 1, trusted: 것들 }, null, 2) + '\n', 'utf8');
-  return p;
+  const 임시 = `${p}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
+  writeFileSync(임시, JSON.stringify({ version: 1, trusted: 것들 }, null, 2) + '\n', 'utf8');
+  // 윈도우는 누가 그 파일을 읽는 순간 이름 바꾸기를 EPERM 으로 튕긴다. 잠깐 뒤에 된다.
+  for (let 번 = 0; ; 번++) {
+    try { renameSync(임시, p); return p; }
+    catch (err) {
+      if (번 >= 20) { try { rmSync(임시, { force: true }); } catch { /* 남아도 목록은 멀쩡하다 */ } throw err; }
+      쉬기(10);
+    }
+  }
 }
 
 /** 이 폴더를 믿는다고 적는다. */
-export function 믿기(폴더, { env = process.env, platform = process.platform } = {}) {
-  const 것들 = 목록읽기(env);
+export function 믿기(폴더, { env = process.env, platform = process.platform, 기다림 = 잠금기다림 } = {}) {
+  // 넓은 자리는 여기서도 안 적는다. `deel trust` 앞에서만 막으면 이 함수를 부르는
+  // 다른 문(스크립트·훗날의 명령)이 그대로 열려 있다. 적어 봐야 읽을 때 버려진다.
+  if (너무넓은자리(resolve(String(폴더 ?? '')), { env, platform })) {
+    return { ok: false, 넓음: true, 왜: 말('trust.refuseWide') };
+  }
   const 나 = 고른경로(폴더, platform);
-  if (것들.some((x) => 고른경로(x, platform) === 나)) return { ok: true, 이미: true, 자리: 신뢰자리(env) };
-  것들.push(resolve(String(폴더)));
-  try { return { ok: true, 이미: false, 자리: 쓰기(것들, env) }; }
-  catch (err) { return { ok: false, 왜: err?.message ?? String(err) }; }
+  try {
+    // 받아 놓고 안 넘기면 기본값(5초)을 기다린다. 짧게 기다려 보려고 준 수가 아무 일도 안 하면,
+    // 그 수를 준 쪽(검사·배치)은 잠금을 지키는지 재고 있다고 믿으면서 5초를 서 있는다.
+    return 잠그고(env, () => {
+      const 것들 = 쓸목록읽기(env);
+      if (것들.some((x) => 고른경로(x, platform) === 나)) return { ok: true, 이미: true, 자리: 신뢰자리(env) };
+      것들.push(resolve(String(폴더)));
+      return { ok: true, 이미: false, 자리: 쓰기(것들, env) };
+    }, 기다림);
+  } catch (err) { return { ok: false, 왜: err?.message ?? String(err) }; }
 }
 
 /**
  * 이 폴더를 믿는 목록에서 뺀다.
  *
- * 위 폴더를 믿어서 믿기던 것이면 못 뺀다 — 여기서 「뺐습니다」 라고 하고
- * 실제로는 위 폴더 때문에 그대로 믿기면, 그게 제일 나쁜 거짓말이다.
- * 그래서 무엇 때문에 아직 믿기는지를 돌려준다.
+ * 빼는 것은 **적힌 줄 하나**다. 위 폴더를 믿어서 믿기던 것이면 그 줄을 빼도 그대로
+ * 믿긴다 — 여기서 「뺐습니다」 만 돌려주고 말면, 그게 제일 나쁜 거짓말이다. 사람은
+ * 닫힌 줄 알고 그 폴더에서 일한다. 그래서 무엇 때문에 아직 믿기는지(위폴더)와
+ * 아직 믿기는지 그 자체(아직믿김)를 같이 돌려준다. `deel trust --off` 는 둘을 같이 찍는다.
+ *
+ * 아직 믿기는지는 **믿나() 와 같은 자로** 잰다. 목록에 적힌 넓은 자리는 믿나() 가 읽을
+ * 때 버리는데(너무넓은자리) 여기서만 세던 동안, 아무것도 안 믿기는 폴더를 두고
+ * 「위 폴더 때문에 아직 믿습니다」 라고 겁줬다 — 닫은 사람이 안 닫힌 줄 알고 찾아다닌다.
+ * 두 자리가 다른 자를 쓰면 어느 쪽이든 거짓말이 된다.
  */
 export function 안믿기(폴더, { env = process.env, platform = process.platform } = {}) {
-  const 것들 = 목록읽기(env);
   const 나 = 고른경로(폴더, platform);
-  const 남길것 = 것들.filter((x) => 고른경로(x, platform) !== 나);
-  const 뺐나 = 남길것.length !== 것들.length;
+  let 남길것;
+  let 뺐나 = false;
   let 자리 = 신뢰자리(env);
-  if (뺐나) {
-    try { 자리 = 쓰기(남길것, env); }
-    catch (err) { return { ok: false, 왜: err?.message ?? String(err) }; }
-  }
-  const 위 = 남길것.find((x) => 나.startsWith(고른경로(x, platform) + '/')) ?? null;
-  return { ok: true, 뺐나, 자리, 위폴더: 위 };
+  // 빼는 쪽도 같은 잠금을 쥔다. 믿기 사이에 끼어 옛 목록으로 덮으면 남이 방금 믿은 폴더가 사라진다.
+  try {
+    잠그고(env, () => {
+      const 것들 = 쓸목록읽기(env);
+      남길것 = 것들.filter((x) => 고른경로(x, platform) !== 나);
+      뺐나 = 남길것.length !== 것들.length;
+      if (뺐나) 자리 = 쓰기(남길것, env);
+    });
+  } catch (err) { return { ok: false, 왜: err?.message ?? String(err) }; }
+  const 위 = 남길것.find((x) => !너무넓은자리(x, { env, platform }) && 나.startsWith(고른경로(x, platform) + '/')) ?? null;
+  return { ok: true, 뺐나, 자리, 위폴더: 위, 아직믿김: 믿나(폴더, { env, platform }) };
 }
 
 /*
@@ -167,12 +349,40 @@ export function 안믿기(폴더, { env = process.env, platform = process.platfo
  * 화면에서 이 세 줄만 한국어로 남는다 — 그것도 하필 「무엇을 왜 막았나」 를
  * 설명하는 자리라, 못 읽으면 막힌 까닭을 영영 모른다.
  */
+/*
+ * ── 셋으로는 모자랐다 ──────────────────────────────────────────────────
+ *
+ * 위 셋은 저장소에 **적힌** 열쇠와 명령만 막았다. 그런데 열쇠는 저장소에 안
+ * 적어도 딸려 간다. 이 PC 프로필과 같은 id 로 `baseUrl` 한 칸만 적으면 겹치기가
+ * 칸 단위로 덮어서, **이 PC 열쇠가 저장소가 고른 주소로** 붙었다. 이 파일
+ * 머리말이 막는다고 적어 둔 그 모양이다(docs/ko/config.md 도 같은 예를 든다).
+ *
+ * 같은 부류가 넷 더 있었다 — 봉인 풀기(offline:false), 저장소 프로필로
+ * 연결 돌리기(active), 모든 요청을 가로채는 프록시(proxy), Bash 자식에게
+ * 비밀 환경변수를 도로 물려주기(셸환경), 사람만 붙이는 바깥 허가(online).
+ * 전부 넓히는 칸이다.
+ *
+ * 연결 칸과 active 는 이 PC 설정을 봐야 가를 수 있어 config.js 의 겹치기가
+ * 걷는다. 목록은 여기 한 자리에 둔다 — 화면(`deel trust --list`)과 소식이
+ * 같은 이름을 쓰게.
+ */
 export const 프로젝트금지칸 = Object.freeze([
   { 칸: 'permissions.allow', 열쇠: 'trust.why.allow' },
   { 칸: 'profiles[].apiKey', 열쇠: 'trust.why.apiKey' },
   { 칸: 'profiles[].열쇠받기', 열쇠: 'trust.why.authCmd' },
+  { 칸: 'profiles[].baseUrl·kind·auth·제공자', 열쇠: 'trust.why.connection' },
+  { 칸: 'profiles[].online', 열쇠: 'trust.why.online' },
+  // 최상위 offline 과 같은 까닭이다. 프로필 안에 적어도 봉인은 봉인이다.
+  { 칸: 'profiles[].offline', 열쇠: 'trust.why.offline' },
+  { 칸: 'active', 열쇠: 'trust.why.active' },
+  { 칸: 'offline', 열쇠: 'trust.why.offline' },
+  { 칸: 'proxy', 열쇠: 'trust.why.proxy' },
+  { 칸: '셸환경', 열쇠: 'trust.why.shellEnv' },
 ]);
 
+/** 이 PC 프로필에 겹칠 때 저장소가 못 바꾸는 칸. 바꾸면 열쇠가 딴 데로 간다. */
+export const 연결칸 = Object.freeze(['baseUrl', 'kind', 'auth', '제공자']);
+
 /**
  * 프로젝트 설정에서 못 정하는 칸을 걷어낸다.
  *
@@ -193,10 +403,48 @@ export function 프로젝트거르기(raw) {
     delete 값.permissions.allow;
     적기('permissions.allow');
   }
+  // 봉인은 켜는 것만 받는다. 끄는 것은 이 PC 가 켠 봉인을 저장소가 푸는 길이다.
+  // 글자 'true' 도 켠 것이다 (safety/runmode.js 의 봉인됐나와 같은 기준).
+  const 켠봉인 = (v) => v === true || v === 'true';
+  if (Object.prototype.hasOwnProperty.call(값, 'offline') && !켠봉인(값.offline)) {
+    delete 값.offline;
+    적기('offline');
+  }
+  if (값.proxy !== undefined) { delete 값.proxy; 적기('proxy'); }
+  // 영어 이름도 같은 칸이다(safety/shellenv.js 의 남길것읽기).
+  if (값.셸환경 !== undefined || 값.shellEnv !== undefined) {
+    delete 값.셸환경;
+    delete 값.shellEnv;
+    적기('셸환경');
+  }
+  // 목록이 아니면 겹치는 자리에서 켜자마자 터졌다. 통째로 안 읽고 그렇게 말한다.
+  // 까닭은 형제 칸과 같이 **열쇠**로 든다 — 여기만 한국어를 박아 두면 영어로 켠 사람의
+  // 화면에서 이 줄만 한글로 남는다 (바로 위 「까닭은 글이 아니라 열쇠로 든다」).
+  if (값.profiles !== undefined && !Array.isArray(값.profiles)) {
+    delete 값.profiles;
+    걸러낸것.push({ 칸: 'profiles', 열쇠: 'trust.why.profilesNotArray' });
+  }
   for (const p of Array.isArray(값.profiles) ? 값.profiles : []) {
     if (!p || typeof p !== 'object') continue;
     if (p.apiKey !== undefined) { delete p.apiKey; 적기('profiles[].apiKey'); }
-    if (p.열쇠받기 !== undefined) { delete p.열쇠받기; 적기('profiles[].열쇠받기'); }
+    // 영어 이름(authCommand)도 같은 칸이다 — safety/authcmd.js 의 받기설정이 둘 다 읽는다.
+    // 한글 이름만 걷던 동안 저장소가 영어로 적으면 명령이 그대로 돌았다.
+    if (p.열쇠받기 !== undefined || p.authCommand !== undefined) {
+      delete p.열쇠받기;
+      delete p.authCommand;
+      적기('profiles[].열쇠받기');
+    }
+    if (p.online !== undefined) { delete p.online; 적기('profiles[].online'); }
+    /*
+     * 프로필 안의 봉인도 켜는 것만 받는다.
+     *
+     * 최상위 `offline` 만 걷고 여기는 안 걷었다. 겹치기(config.js)가 프로필을 칸
+     * 단위로 덮으니, 믿는 저장소가 `{"id":"loc","offline":false}` 한 줄로 이 PC
+     * 프로필의 `offline:true` 를 풀었다 — 요청이 바깥으로 나갔고, 걷었다는 말도
+     * 없었고, `deel config explain` 은 저장소 값이 이겼다고 그렸다. releases/2.0 이
+     * 「저장소는 봉인을 못 끈다」 고 약속한 바로 그 자리다.
+     */
+    if (p.offline !== undefined && !켠봉인(p.offline)) { delete p.offline; 적기('profiles[].offline'); }
   }
   return { 값, 걸러낸것 };
 }
@@ -223,8 +471,26 @@ export function 프로젝트설정줄들(소식) {
   // 걸러냄 — 무엇을 왜 걷어냈는지까지 말한다. 개수만 말하면 사람이 제
   // 설정에서 무엇을 지워야 하는지 모른 채로 남는다.
   줄.push(`  ${mark.warn} ${말('trust.filtered')}`);
-  for (const { 칸, 열쇠 } of 소식.걸러낸것 ?? []) {
-    줄.push(`  ${c.gray('  ·')} ${c.white(칸)}  ${c.gray(말(열쇠))}`);
+  /*
+   * ── 까닭 자리가 빈 줄로 찍히고 있었다 ─────────────────────────────────
+   *
+   * 걸러낸 것은 두 자리에서 온다. 프로젝트금지칸() 은 `{칸, 열쇠}`(i18n
+   * 열쇠)를 주고, config.js 의 프로필 거르기는 `{칸, 왜}`(이미 지어 둔 말)를
+   * 준다. 여기는 `열쇠` 만 꺼내서 `말(undefined)` 을 불렀고, 그건 빈 글자다.
+   *
+   *   ⚠ 프로젝트 설정에서 걸러낸 것이 있습니다
+   *     · profiles
+   *
+   * 「id 도 name 도 없는 것 2개는 못 붙였습니다」 가 통째로 사라진 자리다.
+   * 개수도 까닭도 없으니, 적어 둔 사람은 제 설정에서 무엇을 고쳐야 하는지
+   * 모른 채 남는다 — 이 블록 바로 위 주석이 그러지 말자고 적어 둔 것이다.
+   *
+   * 검사가 못 잡은 까닭도 같다. test/trust.test.js 는 `{칸, 열쇠}` 꼴만
+   * 먹여 본다.
+   */
+  for (const { 칸, 열쇠, 왜 } of 소식.걸러낸것 ?? []) {
+    const 까닭 = 열쇠 ? 말(열쇠) : (왜 ?? '');
+    줄.push(`  ${c.gray('  ·')} ${c.white(칸)}${까닭 ? `  ${c.gray(까닭)}` : ''}`);
   }
   return 줄;
 }