deel-local-cli 1.5.7 → 1.6.0

package/src/safety/guard.js

@@ -2,7 +2,7 @@
 // 승인 프롬프트를 안 쓰는 대신 (1) 작업 범위 밖은 못 건드리고
 // (2) 되돌릴 수 없는 명령만 막는다. 나머지는 전부 통과시킨다.
 import { resolve, relative, isAbsolute, sep, dirname, basename } from 'node:path';
-import { realpathSync } from 'node:fs';
+import { realpathSync, existsSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { 내부살림 } from '../tools/fsutil.js';
 
@@ -68,6 +68,13 @@ function 진짜자리(p) {
   return p;
 }
 
+/** `/c/Users/…` → `C:/Users/…`. 윈도우에서만, 드라이브 글자 한 자짜리 첫 칸만. */
+export function MSYS풀기(p) {
+  if (process.platform !== 'win32') return p;
+  const m = /^\/([a-zA-Z])(\/|$)/.exec(p);
+  return m ? `${m[1].toUpperCase()}:${p.slice(2) || '/'}` : p;
+}
+
 // 작업 범위 — deel 를 띄운 폴더. 그 밖은 읽기도 쓰기도 막는다.
 export function makeScope(root) {
   const base = resolve(root);
@@ -78,7 +85,10 @@ export function makeScope(root) {
     root: base,
     resolve(p) {
       if (!p || typeof p !== 'string') throw new ScopeError('경로가 비었습니다');
-      const abs = isAbsolute(p) ? resolve(p) : resolve(base, p);
+      // Git Bash 꼴 절대 경로(/c/Users/…)는 윈도우에서 C:\Users\… 다. 안 풀면 지금
+      // 드라이브 밑의 \c\Users\… 로 읽혀, 안에 있는 파일이 '범위 밖' 으로 막힌다.
+      const 경로 = MSYS풀기(p);
+      const abs = isAbsolute(경로) ? resolve(경로) : resolve(base, 경로);
       if (밖(base, abs)) throw new ScopeError(`작업 범위 밖입니다: ${p}\n  범위: ${base}`);
       // 글자로는 안인데 링크를 따라가면 밖인 자리. 정션 하나로 울타리가 열린다.
       //
@@ -102,7 +112,8 @@ export function makeScope(root) {
 
 // 되돌릴 수 없는 것만 막는다. 목록이 길어지면 도구가 쓸모없어진다.
 const BLOCKED = [
-  { re: /\brm\s+(-[a-z]*[rR][a-z]*f|-[a-z]*f[a-z]*[rR])\b[^|;&]*\s(\/|~|\$HOME)\s*$/i, why: '뿌리 폴더를 통째로 지우려 합니다' },
+  // `/c` · `/c/` 는 Git Bash 에서 C:\ 다 — 윈도우에서 bash 를 쓰게 되면서 닿게 된 자리.
+  { re: /\brm\s+(-[a-z]*[rR][a-z]*f|-[a-z]*f[a-z]*[rR])\b[^|;&]*\s(\/|\/[a-z]\/?|~|\$HOME)\s*$/i, why: '뿌리 폴더를 통째로 지우려 합니다' },
   { re: /\b(mkfs|fdisk|diskpart)\b/i, why: '디스크를 초기화하는 명령입니다' },
   { re: /\bformat\s+[a-z]:/i, why: '드라이브를 포맷하는 명령입니다' },
   // 윈도우 짝을 빠뜨리면 안 된다 — deel 은 윈도우에서 주로 돈다.
@@ -204,6 +215,73 @@ function 자리표풀기(s) {
     .replace(/\$\{?HOME\}?|%USERPROFILE%|\$\{?USERPROFILE\}?/gi, homedir());
 }
 
+/**
+ * 이 낱말은 경로가 아니라 **코드 조각**인가.
+ *
+ * ── 왜 필요한가 ─────────────────────────────────────────────────────────
+ *
+ * 여기 오는 것은 셸 명령줄인데, 모델은 그 안에 자바스크립트를 통째로 넣는다
+ * (`node -e "…"` · `node - <<'NODE'`). 그러면 코드 안의 슬래시가 전부 경로로
+ * 보인다. 실제로 이렇게 막혔다 —
+ *
+ *   ▶ Bash(node - <<'NODE' const fs=require('fs'); …)
+ *     └ 막힘 — 작업 범위 밖입니다: /data:image\/[\s\S]*?base64,[^"']+/g,'data:…'
+ *   ▶ Bash(node -e "…")
+ *     └ 막힘 — 작업 범위 밖입니다: /div
+ *
+ * 앞엣것은 정규식 리터럴이고 뒤엣것은 `</div>` 가 잘려 온 것이다. 둘 다 파일과
+ * 아무 상관이 없는데 명령 **전체**가 거절됐다. 모델은 왜 막혔는지 모르니
+ * 따옴표만 바꿔 가며 대여섯 번을 다시 시도했다 — 한 요청이 몇 분씩 길어진 것의
+ * 큰 몫이 이것이었다.
+ *
+ * ── 울타리를 얼마나 무르게 하나 ─────────────────────────────────────────
+ *
+ * 여기서 넘긴 낱말은 검사를 안 받는다. 그래서 넘기는 기준을 좁게 잡는다 —
+ * **실수로 밖을 건드리는** 경로는 `/Users/남/것` 처럼 평범하게 생겼지, 정규식
+ * 메타문자나 따옴표를 달고 오지 않는다. 반대로 일부러 뚫으려는 사람은 이
+ * 검사가 있든 없든 `cd ..` 나 `$(…)` 로 지나간다 — 이건 원래 사고를 막는
+ * 턱이지 봉인이 아니다(파일 도구 쪽 울타리는 그대로다).
+ *
+ * 글로브(`*` `?`)는 일부러 안 넘긴다. `rm /Users/남/*` 은 진짜 경로이고,
+ * 그건 계속 걸려야 한다.
+ */
+export function 코드조각인가(낱말) {
+  // 따옴표가 낱말 **안**에 섞였다 = 코드를 가운데서 자른 것이다.
+  // 파일 이름에 따옴표를 쓰는 사람은 없다시피 하고, 있어도 셸에서 못 쓴다.
+  if (/["'`]/.test(낱말)) return true;
+
+  // `/` 로 시작하는데 정규식 메타문자가 들어 있다 = 정규식 리터럴.
+  // 진짜 경로에는 이런 글자가 거의 안 들어간다.
+  if (낱말.startsWith('/') && /[\\[\](){}|^$+]/.test(낱말)) return true;
+
+  /*
+   * 빗금만 남은 조각.
+   *
+   * `s.replace(/<\/div>/g, '')` 한 줄이 `/` · `\/div` · `/g,` 셋으로 잘린다
+   * (낱말 나누기가 `<` `>` 를 경계로 쓴다). 그중 `/` 는 뿌리 폴더로 풀려서
+   * **작업 범위 밖**이 되고, 그 한 조각 때문에 명령 전체가 거절됐다.
+   *
+   * 뿌리를 통째로 미는 명령이 걱정이라면 그건 여기 몫이 아니다 —
+   * `rm -rf /` 는 checkCommand 의 BLOCKED 가 따로, 더 확실하게 잡는다.
+   */
+  if (/^[/\\]+$/.test(낱말)) return true;
+  // 빗금을 백슬래시로 흘린 것(`\/div`)도 정규식이지 경로가 아니다.
+  if (낱말.includes('\\/')) return true;
+
+  /*
+   * 한 마디짜리 절대 경로(`/div`)는 **디스크에 있을 때만** 본다.
+   *
+   * `</div>` `<br/>` 같은 태그가 잘려 오면 이 꼴이 된다. 그런 이름의 최상위
+   * 폴더는 없다. 반대로 `/tmp` `/etc` 는 실제로 있으므로 그대로 검사한다 —
+   * 없다고 다 넘기면 `mkdir /남의것` 이 지나가지만, 그건 변경성 명령이라
+   * checkCommand 가 따로 잡는다.
+   */
+  if (/^\/[^/\\]+$/.test(낱말)) {
+    try { return !existsSync(낱말); } catch { return true; }
+  }
+  return false;
+}
+
 /** 명령줄에서 경로처럼 보이는 낱말만 골라낸다. */
 export function 경로낱말(cmd) {
   const out = [];
@@ -224,6 +302,7 @@ export function 경로낱말(cmd) {
     // 남은 자리표가 있으면(우리가 못 푼 것) 어디로 갈지 모르니 검사하지 않는다.
     // 여기서 억지로 풀면 엉뚱한 자리를 막게 된다.
     if (/[$%]/.test(풀린)) continue;
+    if (코드조각인가(풀린)) continue;
     out.push(풀린);
   }
   return out;

package/src/safety/keystore.js

@@ -0,0 +1,237 @@
+// 게이트웨이 열쇠를 어디에 어떻게 두나.
+//
+// ── 왜 필요한가 ────────────────────────────────────────────────────────
+//
+// 지금까지 열쇠는 `~/.deel/config.json` 에 **글자 그대로** 있었다. 저장할 때
+// `chmod 600` 을 걸긴 하는데, 그건 NTFS 에서 아무 일도 안 한다 — 윈도우 권한은
+// ACL 로 정해지고 chmod 는 조용히 무시된다. 그러니까 "본인만 읽게 잠갔다" 는
+// 우리 말이 윈도우에서는 사실이 아니었다. 백업 도구·동기화 폴더·화면 공유,
+// 아무거나 하나면 열쇠가 그대로 나간다.
+//
+// 사내 심사에서 제일 먼저 나오는 질문이 "열쇠는 어디에 어떻게 보관됩니까" 다.
+// 그 답이 "홈 폴더에 평문" 이면 그 자리에서 끝난다.
+//
+// ── 무엇을 쓰나 ────────────────────────────────────────────────────────
+//
+//   윈도우  DPAPI (ProtectedData, CurrentUser). 이 PC 의 **이 계정**만 푼다.
+//           다른 계정으로 복사해 가면 못 푼다. 키를 우리가 따로 안 만들어도 된다.
+//   맥      로그인 키체인 (security add-generic-password).
+//   그 밖   그대로 파일 + 0600. 거짓말은 안 한다 — 화면과 심사서에 그렇게 적는다.
+//
+// ── 지키는 것 ──────────────────────────────────────────────────────────
+//
+// **열쇠는 명령줄에 안 올린다.** 언제나 stdin 으로 넣는다. 명령줄은 같은 PC 의
+// 다른 사용자도 프로세스 목록으로 볼 수 있고, 셸 기록에도 남는다. (엑셀 암호를
+// 다룰 때 정해 둔 규칙과 같다.)
+//
+// 오갈 때는 base64 로만 주고받는다. 콘솔 인코딩이 무엇이든 글자가 안 상한다 —
+// CP949 콘솔에서 UTF-8 열쇠를 그냥 흘려보내면 조용히 다른 글자가 된다.
+//
+// 못 잠그면 **잠근 척하지 않는다.** 실패를 삼키고 평문으로 두면, 사람은 잠긴
+// 줄 알고 그 파일을 아무 데나 둔다. 그게 안 잠그는 것보다 나쁘다.
+import { spawnSync } from 'node:child_process';
+import { userInfo } from 'node:os';
+import { join } from 'node:path';
+
+/** 잠긴 값의 꼴. `dpapi:<base64>` · `keychain:<이름>` */
+const 꼴 = /^(dpapi|keychain):(.*)$/s;
+
+/** 키체인에 넣을 때 쓰는 이름. 사람이 키체인 앱에서 찾아 지울 수 있어야 한다. */
+export const 키체인이름 = 'deel-gateway-key';
+
+let 마지막탈 = null;
+/** 마지막으로 잠그거나 풀다 난 탈. 화면·심사서가 읽는다. */
+export function 열쇠탈() { return 마지막탈; }
+
+/** 이 값이 우리가 잠근 것인가. 평문 열쇠와 헷갈리면 안 된다. */
+export function 잠긴것인가(값) { return 꼴.test(String(값 ?? '')); }
+
+/** 윈도우 파워셸의 자리. PATH 를 안 믿는다 — 같은 이름의 다른 것이 앞에 있을 수 있다. */
+function 파워셸() {
+  const 뿌리 = process.env.SystemRoot || 'C:\\Windows';
+  return join(뿌리, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe');
+}
+
+/**
+ * 파워셸을 부른다. 명령은 -EncodedCommand 로 넣는다.
+ *
+ * 따옴표를 하나도 안 쓰게 되므로 cmd 가 중간에서 글자를 바꿀 자리가 없다.
+ * 열쇠는 여기 안 실린다 — 자료는 stdin 으로만 간다.
+ */
+let 마지막인자 = null;
+/**
+ * 마지막으로 바깥 명령에 넘긴 **명령줄**. stdin 은 여기 안 남는다.
+ *
+ * "열쇠를 명령줄에 안 올린다" 는 말은 지켜야 뜻이 있고, 지켜지는지 밖에서
+ * 볼 수 있어야 한다. 그래서 실제로 넘긴 인자를 그대로 남긴다 — 검사가
+ * 이걸 읽고 열쇠가 섞였는지 본다.
+ */
+export function 마지막명령줄() { return 마지막인자; }
+
+function 파워셸실행(스크립트, 입력) {
+  const enc = Buffer.from(스크립트, 'utf16le').toString('base64');
+  마지막인자 = [파워셸(), '-NoProfile', '-NonInteractive', '-EncodedCommand', enc];
+  const r = spawnSync(파워셸(), ['-NoProfile', '-NonInteractive', '-EncodedCommand', enc], {
+    input: 입력,
+    encoding: 'utf8',
+    windowsHide: true,
+    timeout: 20000,
+  });
+  if (r.error) return { ok: false, out: '', err: r.error.message };
+  return { ok: r.status === 0, out: (r.stdout ?? '').trim(), err: (r.stderr ?? '').trim() };
+}
+
+const 잠그는스크립트 = `
+$ErrorActionPreference = 'Stop'
+Add-Type -AssemblyName System.Security
+$b = [Convert]::FromBase64String([Console]::In.ReadToEnd().Trim())
+$p = [Security.Cryptography.ProtectedData]::Protect($b, $null, 'CurrentUser')
+[Console]::Out.Write([Convert]::ToBase64String($p))
+`;
+
+const 푸는스크립트 = `
+$ErrorActionPreference = 'Stop'
+Add-Type -AssemblyName System.Security
+$b = [Convert]::FromBase64String([Console]::In.ReadToEnd().Trim())
+$u = [Security.Cryptography.ProtectedData]::Unprotect($b, $null, 'CurrentUser')
+[Console]::Out.Write([Convert]::ToBase64String($u))
+`;
+
+/** 맥 키체인. 넣을 때도 명령줄에 안 올린다 — `security -i` 는 명령을 stdin 으로 받는다. */
+function 키체인넣기(글) {
+  const 계정 = userInfo().username;
+  // 값 자체는 base64 로 넣는다. 키체인 도구가 줄바꿈·따옴표를 만나면 거기서 끊긴다.
+  const 값 = Buffer.from(글, 'utf8').toString('base64');
+  const 명령 = `add-generic-password -a ${계정} -s ${키체인이름} -w ${값} -U\n`;
+  마지막인자 = ['security', '-i'];
+  const r = spawnSync('security', ['-i'], { input: 명령, encoding: 'utf8', timeout: 20000 });
+  if (r.error) return { ok: false, err: r.error.message };
+  return { ok: r.status === 0, err: (r.stderr ?? '').trim() };
+}
+
+function 키체인읽기() {
+  const 계정 = userInfo().username;
+  마지막인자 = ['security', 'find-generic-password', '-a', 계정, '-s', 키체인이름, '-w'];
+  const r = spawnSync('security', ['find-generic-password', '-a', 계정, '-s', 키체인이름, '-w'], {
+    encoding: 'utf8', timeout: 20000,
+  });
+  if (r.error) return { ok: false, text: '', err: r.error.message };
+  if (r.status !== 0) return { ok: false, text: '', err: (r.stderr ?? '').trim() || '키체인에 없습니다' };
+  try {
+    return { ok: true, text: Buffer.from((r.stdout ?? '').trim(), 'base64').toString('utf8') };
+  } catch (err) {
+    return { ok: false, text: '', err: err.message };
+  }
+}
+
+/**
+ * 이 PC 에서 잠글 수 있나.
+ *
+ * @returns {{되나: boolean, 방식: 'dpapi'|'keychain'|'파일', 왜: string}}
+ */
+export function 쓸수있나() {
+  // 꺼 뒀으면 켜져 있는 척하지 않는다. 이 값을 화면 문구도 그대로 쓰기 때문에,
+  // 여기서 거짓으로 답하면 "다음 저장 때 잠급니다" 라고 해 놓고 안 잠근다.
+  if (process.env.DEEL_KEYSTORE === 'off') {
+    return { 되나: false, 방식: '파일', 왜: 'DEEL_KEYSTORE=off 로 꺼 두었습니다' };
+  }
+  if (process.platform === 'win32') {
+    const r = 파워셸실행('[Console]::Out.Write("ok")', '');
+    if (r.ok && r.out === 'ok') return { 되나: true, 방식: 'dpapi', 왜: '' };
+    return { 되나: false, 방식: '파일', 왜: r.err || '파워셸을 못 돌렸습니다 (정책으로 막혔을 수 있습니다)' };
+  }
+  if (process.platform === 'darwin') {
+    const r = spawnSync('security', ['-h'], { encoding: 'utf8', timeout: 10000 });
+    if (!r.error) return { 되나: true, 방식: 'keychain', 왜: '' };
+    return { 되나: false, 방식: '파일', 왜: 'security 명령을 못 찾았습니다' };
+  }
+  return { 되나: false, 방식: '파일', 왜: '이 운영체제에서는 파일 권한(0600)으로만 둡니다' };
+}
+
+/**
+ * 잠근다. 못 잠그면 null 을 준다 — **잠근 척하지 않는다.**
+ *
+ * @param {string} 글  평문 열쇠
+ * @returns {string|null} `dpapi:…` · `keychain:…` 또는 null
+ */
+export function 잠그기(글) {
+  const 값 = String(글 ?? '');
+  if (!값) return null;
+  마지막탈 = null;
+
+  if (process.platform === 'win32') {
+    const r = 파워셸실행(잠그는스크립트, Buffer.from(값, 'utf8').toString('base64'));
+    if (r.ok && r.out) return `dpapi:${r.out}`;
+    마지막탈 = `열쇠를 못 잠갔습니다 — ${r.err || '파워셸이 답을 안 줬습니다'}`;
+    return null;
+  }
+  if (process.platform === 'darwin') {
+    const r = 키체인넣기(값);
+    if (r.ok) return `keychain:${키체인이름}`;
+    마지막탈 = `열쇠를 키체인에 못 넣었습니다 — ${r.err || 'security 가 실패했습니다'}`;
+    return null;
+  }
+  return null;
+}
+
+/**
+ * 푼다.
+ *
+ * 못 풀 때가 진짜 있다 — 설정 파일만 다른 PC 로 옮겼거나, 계정을 바꿨거나,
+ * 윈도우 프로필을 다시 만든 경우다. 그때 빈 글자만 돌려주면 사람은 401 만
+ * 보고 게이트웨이를 의심한다. 그래서 왜인지를 남긴다.
+ *
+ * @returns {{ok: boolean, text: string, why: string}}
+ */
+export function 풀기(태그) {
+  const m = 꼴.exec(String(태그 ?? ''));
+  if (!m) return { ok: false, text: '', why: '잠긴 열쇠가 아닙니다' };
+  const [, 갈래, 값] = m;
+  마지막탈 = null;
+
+  if (갈래 === 'dpapi') {
+    if (process.platform !== 'win32') {
+      마지막탈 = '이 열쇠는 윈도우에서 잠근 것이라 여기서는 못 풉니다 — deel setup 으로 다시 넣으세요.';
+      return { ok: false, text: '', why: 마지막탈 };
+    }
+    const r = 파워셸실행(푸는스크립트, 값);
+    if (r.ok && r.out) {
+      try { return { ok: true, text: Buffer.from(r.out, 'base64').toString('utf8'), why: '' }; }
+      catch { /* 아래로 */ }
+    }
+    마지막탈 = '잠근 열쇠를 못 풉니다 — 이 PC 의 이 계정에서 잠근 것만 풀립니다. deel setup 으로 다시 넣으세요.';
+    return { ok: false, text: '', why: 마지막탈 };
+  }
+
+  if (갈래 === 'keychain') {
+    if (process.platform !== 'darwin') {
+      마지막탈 = '이 열쇠는 맥 키체인에 있습니다 — 여기서는 못 읽습니다. deel setup 으로 다시 넣으세요.';
+      return { ok: false, text: '', why: 마지막탈 };
+    }
+    const r = 키체인읽기();
+    if (r.ok) return { ok: true, text: r.text, why: '' };
+    마지막탈 = `키체인에서 열쇠를 못 읽었습니다 — ${r.err}`;
+    return { ok: false, text: '', why: 마지막탈 };
+  }
+
+  return { ok: false, text: '', why: '모르는 잠금 방식입니다' };
+}
+
+/** 화면·심사서에 그대로 쓰는 한 줄. 되는 척도 안 되는 척도 안 한다. */
+export function 보관방식(값 = null) {
+  if (값 && 잠긴것인가(값)) {
+    return 값.startsWith('dpapi:')
+      ? 'DPAPI — 이 PC 의 이 계정만 풉니다'
+      : '맥 키체인 — 이 계정의 로그인 키체인에 있습니다';
+  }
+  const 쓸수 = 쓸수있나();
+  if (값) {
+    // 평문인데 잠글 수는 있는 상태. 다음 저장에서 잠긴다.
+    return 쓸수.되나
+      ? `파일에 평문 — 다음 저장 때 ${쓸수.방식 === 'dpapi' ? 'DPAPI' : '키체인'} 로 잠급니다`
+      : `파일에 평문 + 권한 0600 — ${쓸수.왜}`;
+  }
+  if (process.platform === 'win32') return 'DPAPI (윈도우) · 저장된 열쇠 없음';
+  if (process.platform === 'darwin') return '맥 키체인 · 저장된 열쇠 없음';
+  return '파일 권한 0600 · 저장된 열쇠 없음';
+}

package/src/safety/network.js

@@ -20,13 +20,32 @@ export class NetBlocked extends Error {
   }
 }
 
-const LOCAL = new Set(['localhost', '127.0.0.1', '::1', '0.0.0.0', '[::1]']);
+const LOCAL = new Set(['localhost', '127.0.0.1', '::1', '0.0.0.0', '::']);
 
-export const isLocalHost = (h) => LOCAL.has(String(h).toLowerCase()) ||
-  /^127\./.test(h) ||
-  /^10\./.test(h) ||
-  /^192\.168\./.test(h) ||
-  /^172\.(1[6-9]|2\d|3[01])\./.test(h);
+/*
+ * 이 컴퓨터·사내망 주소인가. WebFetch 가 안 읽을 곳, 오프라인 잠금이 그래도 열어 줄 곳.
+ *
+ * 글자만 보면 빠져나가는 철자가 있었다 — `localhost.`(끝에 점)와 `[::ffff:127.0.0.1]`
+ * (IPv4 를 IPv6 에 싼 것)은 둘 다 127.0.0.1 에 붙는데 '바깥' 으로 읽혔다. 되돌림이
+ * 그리로 가면 사내 서비스를 읽게 된다. 그래서 먼저 철자를 편다: 끝 점을 떼고, 대괄호를
+ * 벗기고, ::ffff: 로 싼 IPv4 는 점 네 개 꼴로 되돌린 뒤 본다.
+ * 169.254.* (링크 로컬 — 클라우드 메타데이터가 여기 산다)와 IPv6 의 fe80:: · fc00::/7 도
+ * 이 컴퓨터·사내망으로 친다.
+ */
+export const isLocalHost = (h) => {
+  let s = String(h ?? '').trim().toLowerCase().replace(/\.$/, '').replace(/^\[|\]$/g, '');
+  if (s.startsWith('::ffff:')) {
+    const 뒤 = s.slice(7);
+    const hex = /^([0-9a-f]{1,4}):([0-9a-f]{1,4})$/.exec(뒤);
+    s = hex
+      ? [hex[1], hex[2]].flatMap((x) => { const n = parseInt(x, 16); return [n >> 8, n & 255]; }).join('.')
+      : 뒤;
+  }
+  if (LOCAL.has(s)) return true;
+  if (/^(127|10|0)\./.test(s) || /^192\.168\./.test(s) || /^172\.(1[6-9]|2\d|3[01])\./.test(s) || /^169\.254\./.test(s)) return true;
+  if (/^fe[89ab][0-9a-f]:/.test(s) || /^f[cd][0-9a-f]{2}:/.test(s)) return true;
+  return false;
+};
 
 function originOf(url) {
   const u = new URL(url);
@@ -42,32 +61,74 @@ const gate = {
   enforced: true,
 };
 
-/** 모델 연결 주소를 허용 목록에 올린다. 이전에 올린 것은 지운다. */
+/*
+ * 모델 연결 주소를 허용 목록에 올린다. **이전에 올린 것은 지운다.**
+ *
+ * 여럿을 한 번에 줄 수 있다. 다만 그건 "하나씩 더 쌓는" 길이 아니다 — 부르는
+ * 쪽이 지금 열려 있어야 할 것 **전부**를 한 번에 말하는 것이다. 쌓는 길을
+ * 내주면 여기저기서 한 줄씩 더하다가 자물쇠가 자물쇠가 아니게 된다.
+ *
+ * 여럿이 필요한 자리는 하나다. 사람이 스킴을 안 적은 주소를 넣었을 때,
+ * 자리마다 기본으로 붙이는 스킴이 달라서(로컬은 http, Azure 는 https) 둘 다
+ * 열어 둬야 우리가 만든 주소를 우리 자물쇠가 막지 않는다. 호스트는 사람이
+ * 적어 넣은 그 하나뿐이라 넓어지는 것이 아니다.
+ */
 export function allowEndpoint(baseUrl) {
   gate.allow.clear();
-  if (baseUrl) gate.allow.add(originOf(baseUrl));
+  for (const u of Array.isArray(baseUrl) ? baseUrl : [baseUrl]) {
+    if (u) gate.allow.add(originOf(u));
+  }
   return [...gate.allow];
 }
 
 /** 잠깐 한 곳을 더 연다. 되돌리는 함수를 준다 — 반드시 finally 에서 부른다. */
+/*
+ * 잠깐 연다. 돌려주는 함수로 닫는다.
+ *
+ * 같은 집을 여럿이 겹쳐 열 수 있다 — WebFetch 다섯 개가 한 집에 줄을 서면
+ * 첫 것이 닫을 때 나머지 넷이 막히면 안 된다. 그래서 센다. 마지막이 닫을 때만
+ * 정말 닫고, 원래(allowEndpoint 로) 열려 있던 집은 끝까지 안 닫는다.
+ */
+const 잠깐연것 = new Map();   // origin → { n, 원래 }
 export function allowTemporarily(url) {
   const o = originOf(url);
-  const had = gate.allow.has(o);
+  const 칸 = 잠깐연것.get(o) ?? { n: 0, 원래: gate.allow.has(o) };
+  칸.n += 1;
+  잠깐연것.set(o, 칸);
   gate.allow.add(o);
-  return () => { if (!had) gate.allow.delete(o); };
+  let 닫았나 = false;
+  return () => {
+    if (닫았나) return;   // 두 번 닫아도 남의 몫을 닫지 않는다
+    닫았나 = true;
+    칸.n -= 1;
+    if (칸.n > 0) return;
+    잠깐연것.delete(o);
+    if (!칸.원래) gate.allow.delete(o);
+  };
 }
 
 export function setOffline(on) { gate.offline = !!on; return gate.offline; }
 export function isOffline() { return gate.offline; }
 export function allowed() { return [...gate.allow]; }
 export function contacted() { return gate.log.slice(); }
-export function resetNet() { gate.allow.clear(); gate.log.length = 0; gate.offline = false; }
+export function resetNet() { gate.allow.clear(); 잠깐연것.clear(); gate.log.length = 0; gate.offline = false; 마지막경유 = null; }
+
+/*
+ * 거쳐 간 프록시.
+ *
+ * 프록시는 허용 목록에 오르는 자리가 아니다 — 목적지는 여전히 그 한 자리이고,
+ * 프록시는 거기까지 가는 **길**이다. 그래도 패킷이 실제로 닿는 첫 기계는 프록시라서,
+ * 심사서와 화면에는 "이 프록시를 거친다" 가 적혀야 한다. 어디를 거쳤는지 여기 남긴다.
+ */
+let 마지막경유 = null;
+export function 프록시경유() { return 마지막경유; }
 
 /**
  * 이 주소로 나가도 되는가. 안 되면 던진다.
  * 통과한 것은 기록에 남는다 — "무엇이 어디로 갔나" 를 나중에 보여 주기 위해서다.
+ * @param {string|null} 거쳐  이 요청이 거칠 프록시 주소. 없으면 직접 간다.
  */
-export function checkUrl(url) {
+export function checkUrl(url, 거쳐 = null) {
   let u;
   try { u = new URL(url); } catch { throw new NetBlocked(url, '주소 형식이 아닙니다.'); }
 
@@ -89,7 +150,8 @@ export function checkUrl(url) {
   }
 
   const seen = gate.log.find((x) => x.origin === origin);
-  if (seen) seen.n++;
-  else gate.log.push({ origin, n: 1, local });
+  if (seen) { seen.n++; if (거쳐) seen.via = 거쳐; }
+  else gate.log.push({ origin, n: 1, local, via: 거쳐 ?? null });
+  if (거쳐) 마지막경유 = { url: 거쳐 };
   return true;
 }