deel-local-cli 2.1.3 → 2.1.5

package/README.ko.md

@@ -323,7 +323,7 @@ deel --offline
 무엇이 어디로 갈 수 있는지는 켤 때 화면 맨 위에 늘 적혀 있습니다.
 
 ```
- deel 2.1.3  ⌂ 이 안
+ deel 2.1.5  ⌂ 이 안
  보냄    이 컴퓨터 안 127.0.0.1:11434  ← 여기 말고는 어디로도 안 갑니다
 ```
 
@@ -369,10 +369,12 @@ deel setup
 ```
 1. 열쇠만 있습니다 — 어디 것인지 찾아 드립니다   빈칸 1개
 2. 주소를 직접 넣기 (사내 게이트웨이 · 로컬)      빈칸 2개
-3. OpenAI (GPT)                                  빈칸 1개
-4. Anthropic (Claude)                            빈칸 1개
-5. Google (Gemini)                               빈칸 1개
-6. AWS Bedrock                                   빈칸 2개
+3. 브라우저로 로그인 — OpenRouter                 빈칸 0개
+4. OpenAI (GPT)                                  빈칸 1개
+5. Anthropic (Claude)                            빈칸 1개
+6. Google (Gemini)                               빈칸 1개
+7. OpenRouter (Claude · GPT · Grok · Kimi …)     빈칸 1개
+8. AWS Bedrock                                   빈칸 2개
 ```
 
 1번이 핵심입니다. 열쇠 앞머리로 어디 것인지 짚어서 **한 곳만** 묻습니다.
@@ -387,6 +389,12 @@ deel setup
 서버로 갑니다. 401 이 오고 끝이지만 **열쇠는 이미 갔습니다.** 그래서 모르는
 열쇠는 짐작하지 않고 사람에게 묻습니다.
 
+**3번은 열쇠를 안 넣습니다** (2.1.4). 브라우저가 열리고 OpenRouter 에 로그인하면 그 계정에
+`deel` 이름의 열쇠가 생기고, deel 이 그것을 받아 잠가 둡니다. 열쇠 하나로 Claude · GPT · Grok · Kimi
+를 다 쓰고 쓴 만큼 그 계정에서 빠집니다. SSH 처럼 브라우저가 다른 기기에 있으면
+`deel setup --no-browser` — 링크를 아무 기기에서 열고 뜬 코드를 붙여 넣습니다. Claude · Codex 구독
+로그인을 빌려 쓰지는 않습니다 — 그 로그인은 그 회사 도구용이라 남의 도구가 쓰면 어느 날 막힙니다.
+
 Bedrock 은 리전을 고릅니다 — 서울(`ap-northeast-2`) 포함 다섯 곳과 「직접 입력」.
 Claude 는 몸통 규격이 달라서 여섯 자리를 따로 흡수했습니다
 ([1.7.0 릴리스 노트](docs/ko/releases/1.x.md#170)).
@@ -1333,7 +1341,9 @@ zip 은 진짜 `unzip` 으로, tar 는 진짜 `tar` 가 만든 것을 읽혀 교
 
 | 판 | 무엇이 바뀌었나 |
 |---|---|
-| **[2.1.3](docs/ko/releases/2.1.md#213)** | 제품 기능 — 도구를 글로 부르는 모델도 알아듣고, `deel run --continue`·`--resume`·`--events` 와 결과의 바뀐 파일(`files`)이 생겼고, git 저장소면 스크립트가 바꾼 것도 `/undo` 로 돌아가고, 언어 서버 없이도 문법을 보고, Outline 이 많이 불리는 파일부터 싣고, MCP 가 주소로 붙어 자료 · 프롬프트까지 씁니다 |
+| **[2.1.5](docs/ko/releases/2.1.md#215)** | 급한 보안 수정 — 셸 명령이 작업 폴더 밖으로 새던 자리를 막았습니다. 빗금 없는 `..`(`find .. -delete` · `rd /s /q ..`) · `$PWD` · `%CD%` · `$OLDPWD` · 먼저 옮긴 적 없는 `cd -` · `C:..` · 파워셸의 다른 이름(`ri` · `del` …) |
+| [2.1.4](docs/ko/releases/2.1.md#214) | 브라우저로 로그인 — `deel setup` 3번이 열쇠 없이 OpenRouter 계정 로그인(OAuth PKCE)으로 붙습니다. 열쇠 하나로 Claude · GPT · Grok · Kimi. SSH 는 `--no-browser`, `sk-or-` 열쇠를 알아보고, 긴 모델 목록은 이름으로 좁힙니다 |
+| [2.1.3](docs/ko/releases/2.1.md#213) | 제품 기능 — 도구를 글로 부르는 모델도 알아듣고, `deel run --continue`·`--resume`·`--events` 와 결과의 바뀐 파일(`files`)이 생겼고, git 저장소면 스크립트가 바꾼 것도 `/undo` 로 돌아가고, 언어 서버 없이도 문법을 보고, Outline 이 많이 불리는 파일부터 싣고, MCP 가 주소로 붙어 자료 · 프롬프트까지 씁니다 |
 | [2.1.2](docs/ko/releases/2.1.md#212) | 정책 · 작은 공백 · 속도 — confirm 이 읽기만 하지 않는 MCP 도구를 묻고, 에디터(ACP) 세션은 16개를 넘으면 내려놓았다가 다음 말에 되살리고, `--check-rounds`·`--check-timeout` 과 과제별 검사 설정이 `deel eval` 에 생겼고, 시작 때 읽는 파일이 164개에서 18개로 줄었습니다 |
 | [2.1.1](docs/ko/releases/2.1.md#211) | 전체 검수에서 나온 것 — 한 칸 위를 물으면 `config explain` 이 열쇠를 보였고, 웹훅 주소·Sentry DSN 이 셸 환경 거르기와 가리기를 둘 다 지났고, `kill` 로 strict 를 지나 Jobs 서버를 껐고, Def·Refs 가 EUC-KR 을 못 읽었습니다 · `deel eval` 고침 |
 | [2.1.0](docs/ko/releases/2.1.md#210) | 맡기면 멈추지 않고, 묻게 하면 diff 를 보여 줍니다 — 「다 됐다」 는 검사가 정합니다(`check`) · 얼마나 해내나는 골든셋으로 잽니다(`deel eval`) · 관리 정책 `"approval"` 로 회사가 승인 바닥을 겁니다 |

package/README.md

@@ -396,7 +396,7 @@ deel --offline
 The destination is printed at the top of every session:
 
 ```
- deel 2.1.3  ⌂ inside
+ deel 2.1.5  ⌂ inside
  Sends to this machine 127.0.0.1:11434  ← nowhere else
 ```
 
@@ -443,10 +443,12 @@ Instead of asking for a URL, it asks **where you're connecting**.
 ```
 1. I only have a key — I'll figure out where it goes    1 blank
 2. Enter an address (corporate gateway · local)          2 blanks
-3. OpenAI (GPT)                                          1 blank
-4. Anthropic (Claude)                                    1 blank
-5. Google (Gemini)                                       1 blank
-6. AWS Bedrock                                           2 blanks
+3. Log in with a browser — OpenRouter                    0 blanks
+4. OpenAI (GPT)                                          1 blank
+5. Anthropic (Claude)                                    1 blank
+6. Google (Gemini)                                       1 blank
+7. OpenRouter (Claude · GPT · Grok · Kimi …)             1 blank
+8. AWS Bedrock                                           2 blanks
 ```
 
 Option 1 is the point — the key prefix decides which single vendor is asked.
@@ -461,6 +463,13 @@ Probing vendors one by one would send an Anthropic key to OpenAI's server and
 then to Google's. You get a 401 and stop — but **the key has already left.**
 So an unrecognized key is never guessed at; you are asked.
 
+**Option 3 takes no key at all** (2.1.4). A browser opens; log in to OpenRouter and a key named
+`deel` is created on that account, which deel receives and locks away. One key covers Claude, GPT,
+Grok and Kimi, billed to that account as you use it. If the browser is on another machine (SSH),
+use `deel setup --no-browser` — open the link anywhere and paste the code it shows. deel does not
+borrow a Claude or Codex subscription login: those belong to the vendors' own tools, and a
+third-party tool riding on them gets cut off one day.
+
 Bedrock asks for a region — five including Seoul (`ap-northeast-2`), plus
 "enter it yourself." Claude has a different wire shape, absorbed in six places
 ([1.7.0 release notes](docs/en/releases/1.x.md#170)).
@@ -1415,7 +1424,9 @@ so one run tells you everything.
 
 | Version | What changed |
 |---|---|
-| **[2.1.3](docs/en/releases/2.1.md#213)** | Product features — models that write tool calls as text are understood, `deel run --continue`/`--resume`/`--events` and changed `files` in the result, `/undo` brings back what a script changed in a git repository, a syntax check without a language server, Outline loads the most imported files first, and MCP attaches by URL with resources and prompts |
+| **[2.1.5](docs/en/releases/2.1.md#215)** | Urgent security fix — shell commands could reach outside the working folder. Now blocked: a bare `..` (`find .. -delete`, `rd /s /q ..`), `$PWD`, `%CD%`, `$OLDPWD`, a `cd -` with no earlier move, `C:..`, and PowerShell aliases (`ri`, `del` …) |
+| [2.1.4](docs/en/releases/2.1.md#214) | Log in with a browser — `deel setup` option 3 connects to OpenRouter by logging in (OAuth PKCE), no key to paste; one key for Claude, GPT, Grok and Kimi. `--no-browser` for SSH, `sk-or-` keys recognized, and long model lists narrow by name |
+| [2.1.3](docs/en/releases/2.1.md#213) | Product features — models that write tool calls as text are understood, `deel run --continue`/`--resume`/`--events` and changed `files` in the result, `/undo` brings back what a script changed in a git repository, a syntax check without a language server, Outline loads the most imported files first, and MCP attaches by URL with resources and prompts |
 | [2.1.2](docs/en/releases/2.1.md#212) | Policy, small gaps and speed — confirm asks before MCP tools that are not read-only, editor (ACP) sessions past 16 are let go and brought back on the next message, `--check-rounds`/`--check-timeout` and per-task check settings in `deel eval`, and startup reads 18 files instead of 164 |
 | [2.1.1](docs/en/releases/2.1.md#211) | From a full review — `config explain` one level up showed keys, webhook URLs and Sentry DSNs passed both the shell-env filter and masking, `kill` stopped a Jobs server past strict, Def/Refs could not read EUC-KR, and `deel eval` fixes |
 | [2.1.0](docs/en/releases/2.1.md#210) | Hand it off and it keeps going; make it ask and it shows the diff — a check decides when it is done (`check`), a golden set measures how much gets done (`deel eval`), and `"approval"` in the managed policy lets a company set an approval floor |

package/bin/deel.js

@@ -619,6 +619,8 @@ async function runSbom(flags) {
 const BOOL = new Set([
   'help', 'version', 'offline', 'online', 'continue', 'json', 'quiet', 'yes',
   'no-tui', 'tui', 'all', 'no-hooks',
+  // setup --no-browser — 브라우저로 로그인할 때 콜백 대신 코드를 붙여 넣는다 (2.1.4 · providers/login.js).
+  'no-browser',
   /*
    * `hard` 가 여기 빠져 있었다. 그래서 `deel reset --hard all --yes` 는
    * `--hard` 가 뒤의 `all` 을 제 값으로 삼켰다 — 지울 갈래가 사라지니 화면은
@@ -789,7 +791,11 @@ function help() {
   say(`    ${c.cyan('deel run "<시킬 말>"')}        한 번만 돌고 끝내기 (스크립트·배치용)`);
   say(`    ${c.cyan('deel scan')}                   이 PC 에 떠 있는 로컬 서버 전부 찾기`);
   say(`    ${c.cyan('deel sessions')}               이 폴더에 남아 있는 대화 목록`);
-  say(`    ${c.cyan('deel setup')}                  연결 설정 (주소·키·모델)`);
+  say(`    ${c.cyan('deel setup')}                  연결 설정 (주소·키·모델 · 브라우저로 로그인)`);
+  // 새 줄은 두 말로 적는다 — 영어 도움말에 한국어 줄을 더 늘리지 않는다 (아래 영어 대목 머리말).
+  say(언어() === 'ko'
+    ? `    ${c.cyan('deel setup --no-browser')}     로그인 코드를 붙여 넣기 ${c.gray('(SSH · 브라우저가 다른 기기에 있을 때)')}`
+    : `    ${c.cyan('deel setup --no-browser')}     Paste the login code instead ${c.gray('(SSH · browser on another machine)')}`);
   say(`    ${c.cyan('deel status')}                 연결 상태 보기`);
   say(`    ${c.cyan('deel diagnose')}               저장된 연결로 진단 다시 돌리기`);
   say(`    ${c.cyan('deel reset')}                  설정·기억·기록 지우기 ${c.gray('(그냥 치면 보여만 줍니다)')}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deel-local-cli",
-  "version": "2.1.3",
+  "version": "2.1.5",
   "description": "A coding-agent CLI that runs on local models and private gateways. Zero dependencies, Node 20+.",
   "type": "module",
   "license": "MIT",

package/src/completion.js

@@ -108,6 +108,7 @@ export const 깃발들 = [
   { 이름: '--tui', 뜻: '입력 상자를 켠다', en: 'force the input box on', 값: false },
   { 이름: '--no-tui', 뜻: '입력 상자 없이 줄 화면으로', en: 'plain line output, no input box', 값: false },
   { 이름: '--no-hooks', 뜻: '이번 판만 훅을 끄고 돌린다', en: 'run this once with hooks off', 값: false },
+  { 이름: '--no-browser', 뜻: 'setup: 로그인 코드를 붙여 넣는다 (SSH)', en: 'setup: paste the login code instead (SSH)', 값: false },
   { 이름: '--continue', 뜻: '지난 대화 이어서', en: 'continue the last conversation', 값: null },
   { 이름: '--resume', 뜻: '고른 대화 이어서', en: 'resume a chosen conversation', 값: null },
   { 이름: '--version', 뜻: '판 번호', en: 'version number', 값: false },

package/src/login.js

@@ -0,0 +1,268 @@
+/*
+ * 브라우저로 로그인 — 열쇠를 붙여 넣지 않고 계정으로 받아 온다 (2.1.4).
+ *
+ * 제공자 데이터에 `링크로그인: { 여는곳, 바꾸는곳, 열쇠이름 }` 이 있으면 이 흐름을 탄다
+ * (지금은 openrouter.js 하나). OAuth PKCE 한 바퀴다:
+ *
+ *   1. 검증자(무작위 32바이트)를 짓고, 그 sha256 을 도전으로 싣은 로그인 주소를 브라우저로 연다.
+ *   2. 로그인이 끝나면 로그인 쪽이 코드를 준다 — 이 PC 의 콜백 문으로, 또는 화면에 (원격).
+ *   3. 코드 + 검증자를 바꾸는곳에 POST 하면 열쇠가 온다.
+ *
+ * ── 열쇠는 우리만 받을 수 있다 ─────────────────────────────────────────
+ *
+ * 코드만으로는 열쇠가 안 나온다 — 검증자가 있어야 한다. 검증자는 브라우저·콜백 길로는 한 번도
+ * 안 지나고(그 길로 가는 것은 해시인 도전뿐), 교환 창구에 HTTPS 로 한 번 직접 간다. 다른
+ * 프로그램이나 웹 페이지가 콜백에 제 코드를 끼워 넣어도, 그 코드를 낸 도전은 우리 것이 아니라
+ * 교환에서 403 이다. 콜백 길도 판마다 새로 지은 16바이트라 밖에서 맞혀 부를 수가 없다.
+ *
+ * ── 나가는 문 ───────────────────────────────────────────────────────────
+ *
+ * 우리가 직접 나가는 것은 **교환 POST 한 번**이다. http.js 의 req() — 나가는 문 하나 — 로 가고,
+ * 자물쇠는 그 동안만 바꾸는곳 하나를 연다(allowTemporarily). 로그인 화면은 사람의 브라우저가
+ * 연다. 봉인(offline)이면 둘 다 안 한다 — 브라우저도 안 열고 묻지도 않는다.
+ */
+import { createServer } from 'node:http';
+import { randomBytes, createHash } from 'node:crypto';
+import { req, serverMessage } from './backend/http.js';
+import { allowTemporarily } from './safety/network.js';
+import { 바깥인가 } from './safety/runmode.js';
+import { 브라우저로 } from './ui/browser.js';
+import { ask } from './ui/prompt.js';
+import { say, c, clip } from './ui/ansi.js';
+
+/** 코드는 10분 뒤 만료된다(OpenRouter). 그 절반을 기다린다. */
+export const 기다림기본 = 5 * 60_000;
+
+/** PKCE 한 쌍. 검증자는 RFC 7636 글자(base64url) 43자, 도전은 그 sha256 의 base64url. */
+export function PKCE만들기() {
+  const 검증자 = randomBytes(32).toString('base64url');
+  const 도전 = createHash('sha256').update(검증자).digest('base64url');
+  return { 검증자, 도전 };
+}
+
+/**
+ * 브라우저가 이 PC 에 없을 것 같은가.
+ *
+ * SSH 로 들어왔거나, 리눅스인데 화면(X · Wayland)이 없으면 그렇다고 본다 — 컨테이너·원격 서버.
+ * 그때는 콜백 문을 열어 봐야 브라우저가 못 닿으므로, 로그인 쪽이 코드를 화면에 띄우게 하고
+ * 사람이 붙여 넣는다. WSL 은 윈도 브라우저가 localhost 로 닿으므로 이 자리로 친다.
+ *
+ * 틀려도 갇히지 않는다: 이 자리로 잘못 봤으면 `deel setup --no-browser` 로 붙여넣기 길을 간다.
+ * 원격으로 잘못 봤으면 붙여넣기 길이 어디서나 되므로 코드만 옮기면 된다.
+ */
+export function 원격인가(env = process.env, platform = process.platform) {
+  if (env.SSH_CONNECTION || env.SSH_CLIENT || env.SSH_TTY) return true;
+  if (platform === 'linux' && !env.DISPLAY && !env.WAYLAND_DISPLAY && !env.WSL_DISTRO_NAME) return true;
+  return false;
+}
+
+/**
+ * 사람이 붙여 넣은 것에서 코드를 꺼낸다. 못 꺼내면 null.
+ *
+ * 코드만 붙여도, 주소창의 주소를 통째로(`…?code=…`) 붙여도 된다. 주소 속 코드는 퍼센트
+ * 인코딩돼 있으므로 풀어서 준다 — 안 풀면 `%2B` 가 그대로 가서 403 이다.
+ */
+export function 코드꺼내기(글) {
+  const s = String(글 ?? '').trim();
+  if (!s) return null;
+  // 조각(#) 뒤에 실려 오는 꼴도 받는다.
+  const 걸림 = /(?:^|[?&#\s])code=([^&#\s]+)/.exec(s);
+  if (걸림) {
+    let 코드;
+    try { 코드 = decodeURIComponent(걸림[1]); } catch { return null; }
+    return 코드 && !/[\s\x00-\x1f]/.test(코드) ? 코드 : null;
+  }
+  // 코드 없이 온 주소·문장은 코드가 아니다(로그인 쪽 주소를 잘못 붙였거나, 거절하고 돌아온 주소).
+  // `=` 는 받는다 — base64 패딩이 붙은 코드가 있다.
+  return /^[^\s/:?&#]+$/.test(s) ? s : null;
+}
+
+/*
+ * ── 콜백 문: 127.0.0.1 과 ::1 에 같은 포트로 ────────────────────────────
+ *
+ * 콜백 주소는 `localhost` 다(OpenRouter 가 아무 포트나 받는 이름). 브라우저는 그것을 127.0.0.1
+ * 로도 ::1 로도 풀 수 있어서 둘 다에 듣는다. 같은 포트의 ::1 을 **남이 쥐고 있으면** 그 포트는
+ * 버리고 새로 고른다 — 안 그러면 ::1 로 푼 브라우저가 코드를 그 남에게 넘기고, 우리는 5분을
+ * 기다리다 끝난다(2.1.4 Gemini 검토). IPv6 가 아예 없는 기계는 127.0.0.1 하나로 간다.
+ */
+function 듣기(서버, 포트, 호스트) {
+  return new Promise((풀기, 버리기) => {
+    const 탈 = (e) => { 서버.off('listening', 됨); 버리기(e); };
+    // 듣기 시작한 뒤의 서버 오류(받기 중 EMFILE 따위)는 삼킨다 — 받이가 없으면 프로세스가 죽는다.
+    // 로그인은 기다림이 끝나면 저절로 실패로 끝난다.
+    const 됨 = () => { 서버.off('error', 탈); 서버.on('error', () => {}); 풀기(); };
+    서버.once('error', 탈);
+    서버.once('listening', 됨);
+    서버.listen(포트, 호스트);
+  });
+}
+/*
+ * 닫는다. 쉬는 연결(브라우저가 미리 열어 둔 것)은 바로 닫고, 아직 답을 보내는 연결은 조금 기다렸다가
+ * 끊는다 — 답이 나가기 전에 끊으면 브라우저에는 「로그인됐습니다」 대신 연결 끊김이 뜬다.
+ */
+function 다닫기(서버들) {
+  return Promise.all(서버들.map((s) => new Promise((풀기) => {
+    try {
+      s.close(() => 풀기());
+      s.closeIdleConnections?.();
+      setTimeout(() => s.closeAllConnections?.(), 1000).unref();
+    } catch { 풀기(); }
+  })));
+}
+
+/** @returns {Promise<{포트: number, 귀들: number, 닫기: () => Promise<void>}>} */
+export async function 콜백귀열기(처리, { 첫포트 = 0, 시도 = 8 } = {}) {
+  let 포트 = 첫포트;
+  for (let n = 0; n < 시도; n++) {
+    const 넷 = createServer(처리);
+    try { await 듣기(넷, 포트, '127.0.0.1'); } catch { 포트 = 0; continue; }
+    const p = 넷.address().port;
+    const 여섯 = createServer(처리);
+    let 탈 = null;
+    try { await 듣기(여섯, p, '::1'); } catch (e) { 탈 = e; }
+    if (!탈) return { 포트: p, 귀들: 2, 닫기: () => 다닫기([넷, 여섯]) };
+    if (탈.code === 'EADDRINUSE') { await 다닫기([넷]); 포트 = 0; continue; }
+    return { 포트: p, 귀들: 1, 닫기: () => 다닫기([넷]) };
+  }
+  const 넷 = createServer(처리);
+  await 듣기(넷, 0, '127.0.0.1');
+  return { 포트: 넷.address().port, 귀들: 1, 닫기: () => 다닫기([넷]) };
+}
+
+// 브라우저에 돌려줄 한 쪽. 코드는 안 싣는다. 이 쪽 주소에 코드가 있으므로 남에게 안 넘기고
+// (no-referrer) 어디에도 안 남긴다(no-store). 밖의 것을 하나도 안 불러온다.
+function 쪽보내기(res, 됐나) {
+  const 몸 = `<!doctype html><html lang="ko"><meta charset="utf-8"><title>deel</title>`
+    + `<h1>${됐나 ? '로그인됐습니다' : '로그인이 안 됐습니다'}</h1>`
+    + `<p>${됐나 ? '터미널로 돌아가세요. 이 창은 닫아도 됩니다.' : '터미널로 돌아가 다시 해 보세요.'}</p></html>`;
+  const buf = Buffer.from(몸, 'utf8');
+  res.writeHead(됐나 ? 200 : 400, {
+    'content-type': 'text/html; charset=utf-8',
+    'content-length': buf.length,
+    'cache-control': 'no-store',
+    'referrer-policy': 'no-referrer',
+    'content-security-policy': "default-src 'none'",
+    connection: 'close',
+  });
+  res.end(buf);
+}
+
+const 이름만 = (제공자) => String(제공자?.이름 ?? '').replace(/\s*\(.*\)\s*$/, '') || '로그인';
+
+/**
+ * 로그인해서 열쇠를 받아 온다. 던지지 않는다.
+ *
+ * @param 제공자  `링크로그인` 칸이 있는 제공자
+ * @param o.봉인  offline 이 켜져 있나. 켜져 있고 로그인 창구가 바깥이면 아무것도 안 한다.
+ * @param o.원격  브라우저가 이 PC 에 없나 — 그러면 콜백 대신 코드를 붙여 넣게 한다.
+ * @param o.열기  주소를 브라우저로 여는 것 (검사가 브라우저 흉내로 갈아 끼운다)
+ * @param o.받기  한 줄 묻기 (붙여넣기 길)
+ * @returns {Promise<{ok: true, 열쇠: string} | {ok: false, 까닭: string}>}
+ */
+export async function 링크로그인(제공자, {
+  봉인 = false, 원격 = 원격인가(), 열기 = 브라우저로, 받기 = (물음) => ask(물음), 기다림 = 기다림기본, 말 = say,
+} = {}) {
+  const 곳 = 제공자?.링크로그인;
+  if (!곳?.여는곳 || !곳?.바꾸는곳) return { ok: false, 까닭: '이 제공자는 브라우저 로그인을 열지 않습니다.' };
+  if (봉인 && (바깥인가(곳.여는곳) || 바깥인가(곳.바꾸는곳))) {
+    return { ok: false, 까닭: '봉인되어 있어 로그인하러 나가지 않습니다 — 관리 정책이나 설정에 offline 이 켜져 있습니다.' };
+  }
+
+  const { 검증자, 도전 } = PKCE만들기();
+  const 로그인주소 = (콜백) => {
+    const u = new URL(곳.여는곳);
+    if (콜백) u.searchParams.set('callback_url', 콜백);
+    u.searchParams.set('code_challenge', 도전);
+    u.searchParams.set('code_challenge_method', 'S256');
+    if (곳.열쇠이름) u.searchParams.set('key_label', 곳.열쇠이름);
+    return u.href;
+  };
+  const 누구 = 이름만(제공자);
+
+  let 코드;
+  if (원격) {
+    // 콜백 없이 가면 로그인 쪽이 코드를 화면에 띄운다. 어느 기기의 브라우저로 열어도 된다.
+    말('');
+    말(`  ${c.gray(`아래 주소를 아무 기기의 브라우저로 여세요. ${누구} 에 로그인하면 코드가 뜹니다.`)}`);
+    말(`    ${로그인주소(null)}`);
+    말('');
+    const 받은것 = await 받기('로그인 뒤 뜬 코드 (주소째 붙여도 됩니다)');
+    코드 = 코드꺼내기(받은것);
+    if (!코드) {
+      return {
+        ok: false,
+        까닭: String(받은것 ?? '').trim()
+          ? '붙여 넣은 것에서 코드를 못 찾았습니다 — 로그인 뒤 화면에 뜬 코드만, 또는 code= 가 든 주소를 넣으세요.'
+          : '코드가 비었습니다 — 아무것도 안 바꿨습니다.',
+      };
+    }
+  } else {
+    const 비밀길 = `/deel-${randomBytes(16).toString('hex')}`;
+    let 알리기 = null;
+    const 돌아옴 = new Promise((풀기) => { 알리기 = 풀기; });
+    const 처리 = (rq, rs) => {
+      let u = null;
+      try { u = new URL(rq.url, 'http://localhost'); } catch { /* 아래에서 404 */ }
+      if (rq.method !== 'GET' || u?.pathname !== 비밀길) {
+        rs.writeHead(404, { 'content-type': 'text/plain; charset=utf-8', connection: 'close' });
+        rs.end('not found');
+        return;
+      }
+      const 받은코드 = u.searchParams.get('code');
+      // 쪽이 다 나간 뒤에 받는다 — 받자마자 문을 닫으면 쪽이 끊긴다.
+      // 처음 온 것 하나만 받는다 — 새로고침·미리 불러오기로 두 번 와도 약속은 한 번만 풀린다.
+      rs.once('finish', () => 알리기(받은코드 ? { 코드: 받은코드 } : { 오류: u.searchParams.get('error') || '코드 없이 돌아왔습니다' }));
+      쪽보내기(rs, !!받은코드);
+    };
+    let 귀;
+    try { 귀 = await 콜백귀열기(처리); }
+    catch (e) { return { ok: false, 까닭: `로그인을 받을 문을 못 열었습니다 — ${e?.message ?? e}. deel setup --no-browser 로 해 보세요.` }; }
+    let 타이머 = null;
+    try {
+      const 주소 = 로그인주소(`http://localhost:${귀.포트}${비밀길}`);
+      말('');
+      말(`  ${c.gray(`브라우저에서 ${누구} 로그인을 엽니다. 안 열리면 이 주소를 여세요:`)}`);
+      말(`    ${주소}`);
+      말(`  ${c.gray(`로그인을 기다립니다 (${Math.max(1, Math.round(기다림 / 60000))}분 · 그만두려면 Ctrl+C).`)}`);
+      말(`  ${c.gray('브라우저가 다른 기기에 있으면 Ctrl+C 뒤')} ${c.cyan('deel setup --no-browser')}`);
+      try { 열기(주소); } catch { /* 주소는 화면에 있다 */ }
+      const 결과 = await Promise.race([
+        돌아옴,
+        new Promise((풀기) => { 타이머 = setTimeout(() => 풀기({ 시간: true }), 기다림); }),
+      ]);
+      if (결과.시간) {
+        return { ok: false, 까닭: '로그인이 안 돌아와 기다리는 시간이 지났습니다 — 아무것도 안 바꿨습니다. 다시 하려면 deel setup' };
+      }
+      if (!결과.코드) return { ok: false, 까닭: `로그인하고 돌아오지 않았습니다 — ${clip(String(결과.오류), 120)}` };
+      코드 = 결과.코드;
+    } finally {
+      clearTimeout(타이머);
+      await 귀.닫기();
+    }
+  }
+
+  // ── 코드 → 열쇠 ────────────────────────────────────────────────────────
+  let r;
+  const 닫기 = allowTemporarily(곳.바꾸는곳);
+  try {
+    r = await req(곳.바꾸는곳, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: { code: 코드, code_verifier: 검증자, code_challenge_method: 'S256' },
+      timeout: 20000,
+    });
+  } catch (e) {
+    // 자물쇠(NetBlocked)·끊음만 던진다. 통신 실패는 r.ok=false 로 온다.
+    return { ok: false, 까닭: `열쇠로 못 바꿨습니다 — ${e?.message ?? e}` };
+  } finally {
+    닫기();
+  }
+  if (!r.ok) {
+    return { ok: false, 까닭: `열쇠로 못 바꿨습니다 (${r.status ? `HTTP ${r.status}` : '안 닿음'}) — ${clip(serverMessage(r).replace(/\s+/g, ' '), 160)}` };
+  }
+  const 열쇠 = r.json?.key;
+  if (typeof 열쇠 !== 'string' || !열쇠 || /\s/.test(열쇠)) {
+    return { ok: false, 까닭: `로그인은 됐는데 열쇠가 안 왔습니다 — ${누구} 쪽 답이 뜻밖의 꼴입니다. 열쇠를 직접 붙여 넣어 주세요.` };
+  }
+  return { ok: true, 열쇠 };
+}

package/src/preview/serve.js

@@ -27,7 +27,6 @@
 import { createServer } from 'node:http';
 import { createReadStream, statSync, existsSync, readdirSync, watch, realpathSync, openSync, readSync, closeSync } from 'node:fs';
 import { join, extname, relative, sep, isAbsolute, basename } from 'node:path';
-import { spawn } from 'node:child_process';
 import { 내부살림 } from '../tools/fsutil.js';
 import { detect } from '../tools/encoding.js';
 
@@ -541,33 +540,5 @@ function 목록주기(abs, 뿌리, res) {
   res.end(buf);
 }
 
-/**
- * 기본 브라우저로 연다.
- *
- * 실패해도 조용히 넘어간다 — 주소는 이미 화면에 찍혀 있으므로 손으로 열면 된다.
- * 여기서 오류를 띄우면 '띄우기는 됐는데 실패한 것처럼' 보인다.
- */
-export function 브라우저로(url) {
-  /*
-   * 열면 안 되는 자리가 있다.
-   *
-   * 검사가 돌 때마다 진짜 브라우저 창이 뜨면 사람 화면이 난장판이 된다.
-   * 파이프로 넘길 때(로그·캡처)도 열 이유가 없다 — 볼 사람이 없다.
-   * 상자 검사는 isTTY 를 거짓말하게 만들어 자식을 띄우므로, TTY 만 봐서는
-   * 못 막는다. 그래서 env 로도 막을 수 있게 뒀고 검사 돌리개가 그걸 켠다.
-   */
-  if (process.env.DEEL_NO_OPEN) return false;
-  if (!process.stdout.isTTY) return false;
-  try {
-    const [cmd, args] = process.platform === 'win32'
-      // start 는 cmd 안엣말이다. 첫 따옴표 한 쌍은 창 제목 자리라 비워 둬야 한다.
-      ? ['cmd', ['/d', '/s', '/c', 'start', '', url]]
-      : process.platform === 'darwin' ? ['open', [url]] : ['xdg-open', [url]];
-    const kid = spawn(cmd, args, { stdio: 'ignore', detached: process.platform !== 'win32', windowsHide: true });
-    kid.on('error', () => { /* 없으면 그만 */ });
-    kid.unref();
-    return true;
-  } catch {
-    return false;
-  }
-}
+// 기본 브라우저로 여는 것은 ui/browser.js 로 옮겼다 — 로그인(2.1.4)도 같은 문을 쓴다.
+export { 브라우저로 } from '../ui/browser.js';

package/src/providers/custom.js

@@ -3,7 +3,7 @@
  *
  * ── 이게 목록의 주인공이다 ─────────────────────────────────────────────
  *
- * 앞의 넷은 「못 외우는 주소를 대신 적어 둔 메모」 다. 이 다섯째가 진짜로
+ * 앞의 다섯은 「못 외우는 주소를 대신 적어 둔 메모」 다. 이 여섯째가 진짜로
  * 하는 일이고, 화면에서도 위쪽에 둔다.
  *
  * 회사마다 규격도 도메인도 다르다. 명단에 없는 회사가 안 되는 것처럼 보이면

package/src/providers/index.js

@@ -39,11 +39,12 @@
 import { 제공자 as openai } from './openai.js';
 import { 제공자 as anthropic } from './anthropic.js';
 import { 제공자 as gemini } from './gemini.js';
+import { 제공자 as openrouter } from './openrouter.js';
 import { 제공자 as bedrock } from './bedrock.js';
 import { 제공자 as 직접 } from './custom.js';
 
 /** 화면에 보일 차례. 「직접 넣기」 는 언제나 목록에 있고, 화면에서는 위에 둔다. */
-export const 제공자들 = [openai, anthropic, gemini, bedrock, 직접];
+export const 제공자들 = [openai, anthropic, gemini, openrouter, bedrock, 직접];
 
 /** id 로 하나 집는다. 모르면 null — 지어내지 않는다. */
 export function 제공자고르기(id) {

package/src/providers/openrouter.js

@@ -0,0 +1,62 @@
+/*
+ * OpenRouter — 열쇠 하나로 여러 회사 모델 (Claude · GPT · Grok · Kimi …) (2.1.4).
+ *
+ * 규격은 OpenAI 호환이라 여기도 데이터 한 장이다. 다른 제공자와 다른 칸은 하나 —
+ * **`링크로그인`** 이다.
+ *
+ * ── 열쇠를 안 넣고 계정으로 받는다 ─────────────────────────────────────
+ *
+ * 「API 키 말고, 링크 타고 로그인하면 바로 쓰게」 가 사람들이 오래 바란 것이다. Claude·Codex 의
+ * 구독 로그인을 가져다 쓰는 길은 **안 간다** — 그 로그인은 그 회사 도구용이고, 남의 도구가 쓰면
+ * 약관에 걸리거나 어느 날 막힌다. 그러면 사람은 이유도 모르고 못 쓰게 된다.
+ *
+ * OpenRouter 는 제 계정으로 **열쇠를 내주는 로그인**(OAuth PKCE)을 공식으로 연다
+ * (https://openrouter.ai/docs/use-cases/oauth-pkce). 브라우저에서 로그인하면 그 계정에 열쇠가
+ * 하나 생기고, 우리는 그것을 받아 사람이 붙여 넣은 열쇠와 똑같이 잠가 둔다. 쓴 만큼 그 계정에서
+ * 빠진다. 받은 열쇠는 https://openrouter.ai/keys 에 「deel」 이름으로 보이고 거기서 지울 수 있다.
+ *
+ * 로그인 흐름은 src/login.js 가 한다. 여기에는 **주소만** 적는다 — 이 칸이 있는 제공자는
+ * 누구든 같은 흐름을 탄다. 코드 분기가 아니라 데이터다(providers/index.js 머리말).
+ */
+export const 제공자 = {
+  id: 'openrouter',
+  이름: 'OpenRouter (Claude · GPT · Grok · Kimi …)',
+  한줄: '열쇠 하나로 여러 회사 모델. 브라우저로 로그인하면 열쇠를 안 넣어도 됩니다.',
+
+  규격: 'openai',
+  인증: 'bearer',
+  주소들: () => ['https://openrouter.ai/api/v1'],
+  리전들: null,
+
+  규격됐나: true,
+  빈칸: ['열쇠 또는 로그인'],
+  열쇠받는곳: 'https://openrouter.ai/keys',
+
+  /*
+   * `sk-or-v1-…`. openai 의 `sk-` 보다 길어서 이긴다(index.js 의 어디것일까) — 짧은 쪽이 먼저
+   * 집으면 OpenRouter 열쇠가 api.openai.com 으로 간다.
+   */
+  키앞머리: [/^sk-or-v1-/, /^sk-or-/],
+
+  // 로그인 창구. 1단계는 브라우저가 열고, 2단계(코드 → 열쇠)는 우리가 한 번 POST 한다.
+  링크로그인: {
+    여는곳: 'https://openrouter.ai/auth',
+    바꾸는곳: 'https://openrouter.ai/api/v1/auth/keys',
+    열쇠이름: 'deel',
+  },
+
+  // 단가는 모델마다 다르고 자주 바뀐다. 아는 척하지 않는다(openai.js 의 요금 머리말).
+  요금: {},
+  요금기준: null,
+  요금표주소: 'https://openrouter.ai/models',
+
+  오류읽기({ status, 서버말 }) {
+    if (status === 402) {
+      return '이 계정에 크레딧이 없습니다 — https://openrouter.ai/settings/credits 에서 채우거나, 이름이 :free 로 끝나는 모델을 고르세요.';
+    }
+    if (status === 404 && /no endpoints|not a valid model|model/i.test(서버말)) {
+      return '그 모델을 지금 받아 주는 곳이 없습니다 — 이름이 틀렸거나 내려간 모델입니다. https://openrouter.ai/models 에서 보세요.';
+    }
+    return null;
+  },
+};

package/src/safety/guard.js

@@ -351,7 +351,13 @@ const BLOCKED = [
      * 우리는 「빗금으로 **끝나는** 것」 만 뿌리로 봤다. 위 rm 규칙은 이미
      * 뿌리목표 로 별을 받고 있었다. 한쪽만 받으면 그건 규칙이 아니라 우연이다.
      */
-    re: new RegExp(String.raw`Remove-Item\b(?=[^|;&]*\s-r[a-z]*\b)[^|;&]*\s${윈뿌리목표}(?=\s|$)`, 'i'),
+    /*
+     * 파워셸의 **다른 이름**도 같은 명령이다 (2.1.5 · 2.0.0 울타리 역공격에서 남김).
+     * `ri` · `rd` · `rmdir` · `del` · `erase` 는 파워셸에서 전부 Remove-Item 이다. 위 rd · del 규칙은
+     * cmd 의 `/s` · `/q` 만 보고, 여기는 긴 이름만 봐서 `ri -Recurse -Force C:\` 가 이 목록을 지나갔다
+     * (checkPaths 가 범위 밖으로 막아 줘서 여태 새지는 않았다 — 이 목록은 그와 따로 서는 겹이다).
+     */
+    re: new RegExp(String.raw`(?<![\w-])(?:Remove-Item|ri|rd|rmdir|del|erase)\b(?=[^|;&]*\s-r[a-z]*\b)[^|;&]*\s${윈뿌리목표}(?=\s|$)`, 'i'),
     why: '드라이브나 집 폴더를 통째로 지웁니다',
   },
   /*
@@ -560,7 +566,11 @@ export function checkPaths(cmd, scope) {
     if (봐주는자리(t)) continue;
     // cd 가 가리킨 자리는 위에서 **옮겨 간 자리 기준**으로 이미 봤다. 여기서
     // 또 보면 뿌리 기준으로 풀려서 `cd src/a && cd ../..` 가 밖으로 읽힌다.
-    if (옮긴자리.has(t)) continue;
+    //
+    // 본 **횟수만큼만** 건너뛴다 (2.1.5). 글자로 건너뛰었더니, 빗금 없는 `..` 를 자리로 치자마자
+    // `cd src; cd ..; find .. -delete` 의 뒤 `..` 가 앞 cd 의 `..` 덕에 검사를 비켰다.
+    const 남은번 = 옮긴자리.get(t) ?? 0;
+    if (남은번 > 0) { 옮긴자리.set(t, 남은번 - 1); continue; }
     // 어디인지 모르는 이전 폴더는 밖으로 본다 (경로낱말 의 `~-` 머리말).
     if (/^~-(?=[/\\]|$)/.test(t)) {
       throw new ScopeError(`\`~-\` 는 셸의 이전 폴더(OLDPWD)라 어디인지 알 수 없어 작업 범위 밖으로 봅니다: ${t}`
@@ -620,6 +630,25 @@ function 자리표풀기(s) {
      * 따로 본다 — 어디인지 모르는 자리라 풀 값이 없다.)
      */
     .replace(/^~\+(?=[/\\]|$)/, '.')
+    /*
+     * `$PWD` · `%CD%` 도 **지금 폴더**다 — `~+` 와 같은 대접 (2.1.5).
+     *
+     * 자리표가 든 낱말은 아래 경로낱말() 이 「못 푼 것」 으로 보고 자리 검사를 건너뛴다. 이 둘은
+     * 값을 아는데도(셸은 작업 폴더에서 뜬다) 모르는 것으로 쳐서 그대로 새었다 —
+     *
+     *     rm -rf ../옆프로젝트          막힘
+     *     rm -rf $PWD/../옆프로젝트     통과 ←  같은 폴더
+     *     rd /s /q %CD%\..             통과 ←  작업 폴더의 부모 통째로
+     *
+     * 파워셸은 이름의 크기를 안 가려서(`$pwd`) 크기를 안 본다. 따옴표에 싼 `$(pwd)` 도 같은 값이다
+     * (안 싼 것은 괄호에서 잘려 `/../x` 가 절대경로로 걸린다). 파워셸의 `$pwd.Path` · `$pwd.ProviderPath`,
+     * 링크를 푼 `$(pwd -P)`, 옛 꼴 `` `pwd` `` 도 같은 자리다(Gemini 리뷰 — 넷 다 새고 있었다).
+     */
+    .replace(/^(?:\$\{PWD\}|\$PWD(?:\.(?:Provider)?Path)?|%CD%|\$\(pwd(?:\s+-[LP])?\)|`pwd(?:\s+-[LP])?`)(?=[/\\]|$)/i, '.')
+    /*
+     * `$OLDPWD` 는 `~-` 와 같은 자리(이전 폴더)다 — 어디인지 모르니 `~-` 로 바꿔 같은 길로 막는다.
+     */
+    .replace(/^(?:\$\{OLDPWD\}|\$OLDPWD)(?=[/\\]|$)/i, '~-')
     /*
      * `~이름` 은 **그 사람의 집**이다 (사냥5 R5-M1).
      *
@@ -938,6 +967,29 @@ export function 봐주는자리(경로) {
 // (`git commit --message=../notes` · `git log --format=%h/%s`). curl 의 `--data=@파일` 은 파일을 읽으니 안 뺀다.
 const 글받는옵션 = /^(?:message|format|pretty|title|body|subject|description|grep|author|committer|label|comment|notes?)$/i;
 
+/*
+ * ── 빗금 없는 `..` 도 자리다 (2.1.5) ────────────────────────────────────
+ *
+ * 자리로 치는 것은 빗금이 든 낱말과 드라이브 한 칸(`C:`)뿐이었다. 그래서 **부모 폴더 그 자체**가
+ * 후보에도 못 들었다. 기본(auto) 모드에서는 셸 명령을 안 묻고 이 울타리가 마지막 문인데 —
+ *
+ *     rm -rf ../*                 막힘
+ *     find .. -delete             통과 ←  작업 폴더의 부모가 통째로 비었다 (재 봤다)
+ *     rd /s /q ..                 통과 ←  cmd
+ *     Remove-Item -Recurse ..     통과 ←  파워셸
+ *     git -C .. clean -fdx        통과 ←
+ *     tar czf o.tgz ..            통과 ←  작업 폴더가 집 바로 밑이면 ~/.ssh 까지 묶여 읽힌다
+ *
+ * GNU rm 은 `..` 를 스스로 거절해서(`rm -rf ..`) 여태 안 보였을 뿐이다. find · cmd · 파워셸 · git 은
+ * 안 거절한다. 드라이브의 **지금 폴더 기준** 꼴(`C:..` · `C:.`)도 같다 — 윈도에서 `C:..` 는 그
+ * 드라이브의 지금 폴더의 부모다.
+ *
+ * `..` 가 **가운데** 든 것(`HEAD..main` · `{1..5}`)은 부모가 아니다. 낱말 **전체**가 `..` 일 때만.
+ */
+function 자리꼴인가(s) {
+  return s.includes('/') || s.includes('\\') || s === '..' || /^[a-zA-Z]:(?:\.{1,2})?$/.test(s);
+}
+
 /** 명령줄에서 경로처럼 보이는 낱말만 골라낸다. */
 export function 경로낱말(cmd) {
   const out = [];
@@ -1034,7 +1086,7 @@ export function 경로낱말(cmd) {
      */
     if (/^~-(?=[/\\]|$)/.test(풀린)) { out.push(풀린); continue; }
     const 살림이름 = 풀린 === '.deel' || 풀린.toLowerCase() === '.deel';
-    const 경로같나 = 풀린.includes('/') || 풀린.includes('\\') || /^[a-zA-Z]:$/.test(풀린) || 살림이름;
+    const 경로같나 = 자리꼴인가(풀린) || 살림이름;
     if (!경로같나) continue;
     /*
      * 남은 자리표가 있으면(우리가 못 푼 것) **어디로 갈지 모른다.** 울타리
@@ -1083,7 +1135,7 @@ export function 경로낱말(cmd) {
     if (!/["'`]/.test(날것)) continue;                     // 따옴표가 없으면 위에서 이미 봤다
     const 뗀것 = 자리표풀기(날것.replace(/["'`]/g, ''));
     if (!뗀것 || 뗀것.startsWith('-')) continue;
-    if (!뗀것.includes('/') && !뗀것.includes('\\')) continue;
+    if (!자리꼴인가(뗀것)) continue;
     if (/[$%]/.test(뗀것)) { if (내부살림(뗀것)) out.push(뗀것); continue; }
     if (코드조각인가(뗀것)) continue;
     if (!out.includes(뗀것)) out.push(뗀것);
@@ -1159,7 +1211,8 @@ function 낱말들(마디) {
 function 갈자리(뒤) {
   for (const w of 뒤) {
     if (!w.글) continue;
-    if (w.글.startsWith('-')) continue;
+    // `-` 하나는 옵션이 아니라 이전 폴더다 (2.1.5). 옵션으로 건너뛰어 `cd - && rm -rf *` 가 안 보였다.
+    if (w.글.startsWith('-') && w.글 !== '-') continue;
     if (/^\/d$/i.test(w.글)) continue;
     return w.글;
   }
@@ -1169,15 +1222,23 @@ function 갈자리(뒤) {
 /**
  * 폴더를 옮기는 명령을 따라가며, 옮겨 간 자리가 울타리 안인지 본다.
  *
- * @returns {Set<string>} 여기서 이미 본 cd 목적지들. 부르는 쪽은 이걸 두 번
- *   보지 않는다 — 뿌리 기준으로 다시 풀면 `cd src/a && cd ../..` 가 밖이 된다.
+ * @returns {Map<string, number>} 여기서 이미 본 cd 목적지와 그 횟수. 부르는 쪽은 그만큼은
+ *   두 번 보지 않는다 — 뿌리 기준으로 다시 풀면 `cd src/a && cd ../..` 가 밖이 된다.
  */
-function 폴더옮김검사(cmd, scope, 시작 = null, 깊이 = 0, 본것 = new Set()) {
+function 폴더옮김검사(cmd, scope, 시작 = null, 깊이 = 0, 본것 = new Map()) {
   let 여기 = 시작 ?? scope.root;
   const 쌓은것 = [];
+  // 이 명령 안에서 cd 로 떠나온 자리. `cd -` 가 가는 곳이다 — 없으면 셸이 물려받은 OLDPWD 라 모른다.
+  let 이전 = null;
+  // 어디인지 모르는 자리로 옮겼으면 그 적은 글자(`-` · `~-` · `$OLDPWD`). 뒤에 명령이 오면 막는다.
+  let 모르는자리 = null;
   for (const 마디 of 마디들(cmd)) {
     const 낱말 = 낱말들(마디);
     if (!낱말.length) continue;
+    if (모르는자리 != null) {
+      throw new ScopeError(`\`cd ${모르는자리}\` 는 셸의 이전 폴더(OLDPWD)로 가는데 어디인지 알 수 없어, 그 뒤 명령을 작업 범위 밖에서 도는 것으로 봅니다`
+        + `\n  이 명령 안에 있습니다: ${cmd.slice(0, 120)}`);
+    }
     /*
      * ── cmd 에서 `cd..` 는 `cd ..` 다 (사냥8) ────────────────────────────
      *
@@ -1214,25 +1275,53 @@ function 폴더옮김검사(cmd, scope, 시작 = null, 깊이 = 0, 본것 = new
       for (const w of 낱말.slice(1)) if (w.쌌나) 폴더옮김검사(w.글, scope, 여기, 깊이 + 1, 본것);
       continue;
     }
-    if (되돌리기.test(첫)) { 여기 = 쌓은것.pop() ?? 여기; continue; }
+    if (되돌리기.test(첫)) {
+      const 꺼낸 = 쌓은것.pop();
+      if (꺼낸 != null) { 이전 = 여기; 여기 = 꺼낸; }
+      continue;
+    }
     if (!폴더옮김.test(첫)) continue;
 
     const 목적 = 붙은목적 ?? 갈자리(낱말.slice(1));
-    // 인자 없는 cd(집으로) · `cd -`(직전 자리) 는 어디로 가는지 여기서 모른다.
-    // 모르는 것을 막으면 멀쩡한 명령이 죽는다.
-    if (목적 == null || 목적 === '-') continue;
+    // 인자 없는 cd 는 셸마다 뜻이 다르다(bash 는 집 · cmd 는 지금 자리를 찍기만). 모르는 것을
+    // 막으면 멀쩡한 명령이 죽는다.
+    if (목적 == null) continue;
     const 풀린 = 자리표풀기(목적);
+    /*
+     * ── `cd -` · `cd ~-` · `cd $OLDPWD` 는 이전 폴더로 간다 (2.1.5) ─────────────
+     *
+     * 이 명령 안에서 먼저 옮겼으면 그 떠나온 자리다 — `cd src && make && cd -` 는 뿌리로 돌아온다.
+     * 먼저 옮긴 적이 없으면 셸이 물려받은 OLDPWD 라 어디인지 모른다. 여태 `cd -` 를 건너뛰어
+     * `cd - && rm -rf *` 가 그냥 지나갔다. 그 **뒤에 오는 명령**을 밖에서 도는 것으로 본다 —
+     * `cd -` 하나만 있는 것은 옮기고 끝이라 그대로 둔다(아래 모르는자리).
+     *
+     * 그 **아래**(`cd ~-/sub` · `cd $OLDPWD/sub`)도 같은 자리에서 시작한다 — `^~-$` 로 딱 그 꼴만 봤더니
+     * 아래로 붙인 것은 작업 폴더 밑의 `./~-/sub` 라는 이름으로 읽혀 지나갔다(Gemini 리뷰).
+     */
+    const 이전아래 = /^~-(?=[/\\]|$)/.test(풀린);
+    if (목적 === '-' || 이전아래) {
+      // 경로낱말 은 `~-`(· `$OLDPWD`)를 밖으로 올린다. 여기서 풀어 준 것은 checkPaths 가 한 번 비킨다.
+      본것.set(풀린, (본것.get(풀린) ?? 0) + 1);
+      if (이전 == null) { 모르는자리 = 목적; continue; }
+      if (목적 === '-' || 풀린 === '~-') { [여기, 이전] = [이전, 여기]; continue; }
+      // 이전 폴더 아래로 — 아래의 범위 검사를 그대로 받는다.
+    }
     // 못 푼 자리표가 남아 있으면(`$BUILD_DIR`) 역시 어디로 갈지 모른다.
     if (/[$%]/.test(풀린)) continue;
 
-    const 열린 = MSYS풀기(풀린);
-    const abs = isAbsolute(열린) ? resolve(열린) : resolve(여기, 열린);
-    본것.add(풀린);
+    const 열린 = MSYS풀기(이전아래 ? 풀린.replace(/^~-[/\\]*/, '') : 풀린);
+    const abs = isAbsolute(열린) ? resolve(열린) : resolve(이전아래 ? 이전 : 여기, 열린);
+    /*
+     * 비킬 낱말로 적는 것은 **따로 선 목적지**뿐이다. `cd..` 처럼 붙여 쓴 것은 경로낱말 에 `..` 로 안
+     * 나오므로, 적어 두면 남은 한 번이 뒤의 딴 `..` 를 비켜 준다 — `cd src && cd.. && find .. -delete`
+     * (Gemini 리뷰). 이전아래 는 위에서 이미 적었다.
+     */
+    if (!붙은목적 && !이전아래) 본것.set(풀린, (본것.get(풀린) ?? 0) + 1);
 
     // 프로그램이 있는 자리로 들어가는 것은 자료를 만지는 일이 아니다.
     // 푼 값이 아니라 **적힌 글자**로 본다 — 윈도우에서 resolve('/usr/bin') 은
     // `C:\usr\bin` 이 되어 목록에 안 걸린다 (checkPaths 도 낱말로 본다).
-    if (봐주는자리(풀린)) { 여기 = abs; continue; }
+    if (봐주는자리(풀린)) { 이전 = 여기; 여기 = abs; continue; }
     try { scope.resolve(abs); }
     catch (e) {
       if (e instanceof ScopeError) {
@@ -1251,6 +1340,7 @@ function 폴더옮김검사(cmd, scope, 시작 = null, 깊이 = 0, 본것 = new
     if (이유) throw new BlockedError(`${이유}\n  이 명령 안에 있습니다: ${cmd.slice(0, 120)}`);
 
     if (/^(pushd|push-location)$/i.test(첫)) 쌓은것.push(여기);
+    이전 = 여기;
     여기 = abs;
   }
   return 본것;

package/src/setup.js

@@ -14,6 +14,7 @@ import { allowEndpoint } from './safety/network.js';
 import { 인증서설정, 인증서등록 } from './backend/clientcert.js';
 import { 바깥인가, 봉인됐나 } from './safety/runmode.js';
 import { 제공자들, 제공자고르기, 어디것일까, 주소후보, 막힌까닭, 열쇠다듬기 } from './providers/index.js';
+import { 링크로그인, 원격인가 } from './login.js';
 import { writeFileSync } from 'node:fs';
 
 // 머리 한 줄은 ui/banner.js 에 있다 — 진입점이 이 파일(40개를 끌고 온다) 없이 쓰게 (2.1.2).
@@ -126,14 +127,38 @@ async function connect(url, key, { 조용히 = false, 제공자: 어디 = null }
   return found;
 }
 
+// 한 화면에 보이는 모델 수. 넘으면 이름으로 좁히고, 목록 끝에 「직접 입력」 을 둔다.
+const 모델한화면 = 40;
+
 async function chooseModel(found) {
   if (!found.models.length) {
     say('');
     say(`  ${mark.warn} ${c.yellow('모델 목록을 못 받았습니다.')} ${c.gray('이름을 직접 넣어 주세요.')}`);
     return (await ask('모델 이름')).trim();
   }
-  const items = found.models.slice(0, 40).map((m) => ({ label: m.id, note: m.note ?? '' }));
+  /*
+   * ── 목록이 길면 이름으로 좁힌다 (2.1.4) ─────────────────────────────────
+   *
+   * 앞 40개만 보여 주고 끝이었다. 사내 게이트웨이는 그걸로 됐는데 OpenRouter 는 모델이 수백 개라,
+   * 쓰려는 모델이 41번째 뒤에 있으면 **고를 길이 없었다.** 이름 일부로 좁히고, 그래도 없으면
+   * 목록 끝의 「직접 입력」 으로 빠진다 — 목록은 낡고, 빠져나갈 구멍은 늘 둔다(리전 고르기와 같다).
+   */
+  let 후보 = found.models;
+  const 길다 = 후보.length > 모델한화면;
+  if (길다) {
+    say('');
+    say(`  ${c.gray(`모델이 ${후보.length}개입니다. 이름 일부로 좁힙니다 (예: claude · gpt · llama). 비우면 앞 ${모델한화면}개.`)}`);
+    const 찾을말 = (await ask('찾을 이름')).trim().toLowerCase();
+    if (찾을말) {
+      const 걸린것 = 후보.filter((m) => String(m.id).toLowerCase().includes(찾을말));
+      if (걸린것.length) 후보 = 걸린것;
+      else say(`  ${mark.warn} ${c.yellow(`「${찾을말}」 이 든 모델 이름이 없습니다 — 맞는 모델이 없습니다.`)} ${c.gray(`앞 ${모델한화면}개를 보여 드립니다.`)}`);
+    }
+  }
+  const items = 후보.slice(0, 모델한화면).map((m) => ({ label: m.id, note: m.note ?? '' }));
+  if (길다) items.push({ label: '직접 입력', note: '목록에 없는 이름', 직접: true });
   const i = await pick('사용할 모델', items);
+  if (items[i].직접) return (await ask('모델 이름')).trim();
   return items[i].label;
 }
 
@@ -181,12 +206,20 @@ export async function runProbe(conn, { out = null, 봉인 = false } = {}) {
  * 「직접 넣기」 를 목록 위쪽에 둔다. 목록이 지원 명단처럼 보이면, 거기 없는
  * 회사는 안 되는 줄 알고 돌아선다 (providers/index.js 머리말).
  *
+ * 넷째 갈래 — **브라우저로 로그인** (2.1.4). 빈칸 0개다. 열쇠를 안 넣고 계정으로 받아 온다
+ * (src/login.js). 번호는 셋째에 둔다: 1·2 는 손에 익은 번호라 안 옮긴다.
+ *
+ * @param o.봉인  offline 이 켜져 있나 — 로그인은 여기서 바깥으로 나가므로 여기서 거른다
+ * @param o.원격  브라우저를 이 PC 에서 못 여나 (`--no-browser` · SSH)
  * @returns {{제공자, 주소들: string[], 열쇠: string, 이름: string} | null}
  */
-async function 붙일곳고르기() {
+async function 붙일곳고르기({ 봉인 = false, 원격 = false } = {}) {
+  // 링크로 로그인하는 첫 제공자. 데이터에 그 칸이 있는 곳이면 누구든 같은 흐름을 탄다.
+  const 로그인곳 = 제공자들.find((p) => p.링크로그인);
   const 목록 = [
     { id: '열쇠먼저', label: '열쇠만 있습니다 — 어디 것인지 알아봐 주세요', note: '빈칸 1개' },
     { id: 'custom', label: '주소를 직접 넣기', note: '사내 게이트웨이 · 목록에 없는 곳' },
+    ...(로그인곳 ? [{ id: '링크로그인', label: `브라우저로 로그인 — ${로그인곳.이름}`, note: '빈칸 0개 · 열쇠를 안 넣습니다' }] : []),
     ...제공자들.filter((p) => p.id !== 'custom').map((p) => ({
       id: p.id,
       label: p.이름,
@@ -217,6 +250,8 @@ async function 붙일곳고르기() {
       const 나머지 = 제공자들.map((p) => ({ label: p.이름, note: p.한줄 }));
       제공자 = 제공자들[await pick('어디 열쇠인가요?', 나머지, { def: 0 })];
     }
+  } else if (고른.id === '링크로그인') {
+    제공자 = 로그인곳;
   } else {
     제공자 = 제공자고르기(고른.id);
   }
@@ -281,9 +316,23 @@ async function 붙일곳고르기() {
   }
 
   // ── 열쇠 ─────────────────────────────────────────────────────────────
-  if (!열쇠) {
+  //
+  // 로그인이 되는 곳은 열쇠를 비워 두면 로그인으로 간다 — 벤더 목록에서 골랐어도 같다.
+  if (!열쇠 && 고른.id !== '링크로그인') {
     if (제공자.열쇠받는곳) say(`  ${c.gray('열쇠 받는 곳')} ${c.cyan(제공자.열쇠받는곳)}`);
-    열쇠 = 열쇠다듬기(await ask('API 키', { mask: true }));
+    열쇠 = 열쇠다듬기(await ask('API 키' + (제공자.링크로그인 ? ' (비우면 브라우저로 로그인)' : ''), { mask: true }));
+  }
+  if (!열쇠 && 제공자.링크로그인) {
+    const 받은것 = await 링크로그인(제공자, { 봉인, 원격 });
+    if (!받은것.ok) {
+      say('');
+      say(`  ${mark.no} ${c.yellow(받은것.까닭)}`);
+      say('');
+      return null;
+    }
+    열쇠 = 받은것.열쇠;
+    // 받은 열쇠는 화면에 안 적는다. 어디에 어떻게 잠갔는지는 저장한 뒤에 말한다.
+    say(`  ${mark.ok} ${c.green('로그인했습니다 — 열쇠를 받았습니다.')} ${c.gray('화면에 안 적고, 저장할 때 잠가 둡니다.')}`);
   }
 
   const 기본이름 = 제공자.id === 'custom' ? '사내게이트웨이' : 제공자.이름;
@@ -343,7 +392,14 @@ async function 설정받기(flags = {}) {
   // 주소를 손으로 치게 만드는 것은 우리 잘못이다.
   say(`  ${c.gray('이 PC 에 로컬 모델이 떠 있다면')} ${c.cyan('deel scan --save')} ${c.gray('가 빈칸 없이 찾아 줍니다.')}`);
 
-  const 고른것 = await 붙일곳고르기();
+  /*
+   * 봉인 판정은 **붙일 곳을 고르기 전에** 한다 (2.1.4). 브라우저로 로그인하는 갈래는 고르는
+   * 자리 안에서 바깥으로 나가기 때문이다 — 뒤에서 재면 이미 나간 뒤다. 판정은 깃발과 처음 읽은
+   * 설정만 보므로 앞으로 옮겨도 값이 같다.
+   */
+  const 봉인 = 봉인됐나({ 깃발: flags?.offline, prof: null, cfg: 첫설정 });
+
+  const 고른것 = await 붙일곳고르기({ 봉인, 원격: flags?.['no-browser'] === true || 원격인가() });
   if (!고른것) return 1;
   const { 제공자: 붙일곳, 주소들, 열쇠: key, 이름: name } = 고른것;
 
@@ -363,7 +419,7 @@ async function 설정받기(flags = {}) {
   // 적어 둔 봉인만 걸리고, 사람이 그 자리에서 친 `deel setup --offline` 은 안 걸렸다.
   // 깃발을 믿고 사내 게이트웨이 주소를 넣은 사람은 방금 적은 열쇠까지 실어 보낸 셈이 된다.
   // (diagnose 는 같은 판에서 `깃발: flags.offline` 을 넘긴다 — 두 문이 갈려 있었다.)
-  const 봉인 = 봉인됐나({ 깃발: flags?.offline, prof: null, cfg: 첫설정 });
+  // 판정 자체는 위에서 했다 — 로그인 갈래가 고르는 자리에서 나가기 때문이다.
   const 두드릴것 = 봉인
     ? 주소들.filter((u) => !바깥인가(/^https?:\/\//i.test(u) ? u : `http://${u}`))
     : 주소들;

package/src/ui/browser.js

@@ -0,0 +1,81 @@
+/*
+ * 기본 브라우저로 주소 하나를 연다.
+ *
+ * 미리보기(preview/serve.js)만 쓰던 것을 여기로 뺐다 — 2.1.4 의 「브라우저로 로그인」 도 같은
+ * 문을 쓴다. 미리보기 서버를 통째로 끌고 오지 않게 따로 둔다.
+ */
+import { spawn } from 'node:child_process';
+
+/**
+ * 이 판에서 브라우저를 여는 명령. 못 넘길 주소면 null.
+ *
+ * @returns {[string, string[], object] | null}  [명령, 인자, spawn 에 더할 설정]
+ *
+ * ── 윈도는 주소를 따옴표로 싼다 (2.1.4) ─────────────────────────────────
+ *
+ * `cmd /c start "" <url>` 에서 cmd 는 따옴표 밖의 `&` 를 **명령 구분자**로 먹는다. 미리보기 주소
+ * (`http://127.0.0.1:포트/`)에는 `&` 가 없어 여태 몰랐다. 로그인 주소에는 셋이 있어서 브라우저에는
+ * `?callback_url=…` 까지만 가고, 나머지는 명령으로 돌려진다. Node 는 빈칸 없는 인자를 안 싸므로
+ * 우리가 싸고, 그 따옴표를 Node 가 `\"` 로 다시 망치지 않게 그대로 넘긴다(windowsVerbatimArguments).
+ * 따옴표가 든 주소는 그 울타리를 스스로 깨므로 **안 넘긴다** — URL 이 만든 주소에는 따옴표가
+ * `%22` 로 들어 있어 이 경우는 사람이 지어낸 글뿐이다.
+ *
+ * `rundll32 url.dll,FileProtocolHandler` 로 cmd 를 비켜 가는 길도 있지만 사내 보안 정책(AppLocker ·
+ * EDR)이 그 호출을 막는 일이 흔하다 — 2.1.4 Gemini 검토.
+ */
+export function 여는명령(url, platform = process.platform, env = process.env) {
+  const 주소 = String(url ?? '');
+  if (platform === 'win32') {
+    if (/["\r\n]/.test(주소)) return null;
+    if (cmd가펼치나(주소, env)) return null;
+    // start 는 cmd 안엣말이다. 첫 따옴표 한 쌍은 창 제목 자리라 비워 둬야 한다.
+    return ['cmd', ['/d', '/s', '/c', 'start', '""', `"${주소}"`], { windowsVerbatimArguments: true }];
+  }
+  return [platform === 'darwin' ? 'open' : 'xdg-open', [주소], {}];
+}
+
+/*
+ * cmd 는 **따옴표 안에서도** `%이름%` 을 그 값으로 바꾼다. 따옴표로 `&` 는 막았지만 이것은 못 막고,
+ * 명령 줄에서는 `%` 를 가릴 방법도 없다. 그래서 펼쳐질 자리가 있으면 안 넘긴다 — 주소는 화면에
+ * 찍혀 있으니 손으로 열면 된다. 환경에 없는 cmd 의 동적 변수(`%cd%` · `%random%` …)도 센다
+ * (2.1.4 Gemini 리뷰). 퍼센트 인코딩 사이(`%3A%2F`)는 그런 이름이 없어서 그대로 간다.
+ */
+const cmd동적 = ['cd', 'date', 'time', 'random', 'errorlevel', 'cmdextversion', 'cmdcmdline', 'highestnumanodenumber', '__appdir__', '__cd__'];
+function cmd가펼치나(주소, env) {
+  const 이름들 = new Set([...Object.keys(env ?? {}).map((k) => k.toLowerCase()), ...cmd동적]);
+  // 겹쳐서 본다 — `%a%b%` 는 a 도 b 도 이름 자리다.
+  for (const m of 주소.matchAll(/%(?=([^%]+)%)/g)) {
+    if (이름들.has(m[1].toLowerCase())) return true;
+  }
+  return false;
+}
+
+/**
+ * 기본 브라우저로 연다. 열러 갔으면 true.
+ *
+ * 실패해도 조용히 넘어간다 — 주소는 이미 화면에 찍혀 있으므로 손으로 열면 된다.
+ * 여기서 오류를 띄우면 '띄우기는 됐는데 실패한 것처럼' 보인다.
+ */
+export function 브라우저로(url) {
+  /*
+   * 열면 안 되는 자리가 있다.
+   *
+   * 검사가 돌 때마다 진짜 브라우저 창이 뜨면 사람 화면이 난장판이 된다.
+   * 파이프로 넘길 때(로그·캡처)도 열 이유가 없다 — 볼 사람이 없다.
+   * 상자 검사는 isTTY 를 거짓말하게 만들어 자식을 띄우므로, TTY 만 봐서는
+   * 못 막는다. 그래서 env 로도 막을 수 있게 뒀고 검사 돌리개가 그걸 켠다.
+   */
+  if (process.env.DEEL_NO_OPEN) return false;
+  if (!process.stdout.isTTY) return false;
+  const 명령 = 여는명령(url);
+  if (!명령) return false;
+  try {
+    const [cmd, args, 덤] = 명령;
+    const kid = spawn(cmd, args, { stdio: 'ignore', detached: process.platform !== 'win32', windowsHide: true, ...덤 });
+    kid.on('error', () => { /* 없으면 그만 */ });
+    kid.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}