deel-local-cli 1.12.0 → 1.13.1

package/src/tools/index.js

@@ -2,7 +2,7 @@
 // 그래야 그 관례로 쓰인 스킬·명령이 그대로 먹는다.
 import { writeFileSync, appendFileSync, readFileSync, existsSync, mkdirSync, statSync, renameSync, cpSync, rmSync } from 'node:fs';
 import { dirname, extname, join, relative, sep } from 'node:path';
-import { execFile } from 'node:child_process';
+import { 무리로돌리기 } from './spawn.js';
 import { globToRegex, walk, readText, readTextFull, 내부살림 } from './fsutil.js';
 import { 건너뜀말 } from './ignore.js';
 import { encode, label as encLabel, decode as decodeBytes, consoleCodepage, looksBinary } from './encoding.js';
@@ -1518,9 +1518,34 @@ export const TOOLS = {
        */
       let 건너뛴것 = 0;
       let 멈춤 = null;
+      /*
+       * ── 이 길에서도 숨을 쉬어야 한다 ────────────────────────────────────
+       *
+       * 바로 위 머리말이 「그동안 화면은 멈춰 있고 Ctrl+C 도 안 먹는다」 고
+       * 적어 뒀다. rg 를 비동기로 부르는 것으로 그걸 고쳤는데, **rg 가 없는
+       * 기계는 여기로 내려온다** — 그리고 여기는 그대로 한 덩어리였다.
+       *
+       * rg 없는 기계가 드물지 않다. 갓 띄운 리눅스 컨테이너, 회사 이미지,
+       * CI 러너가 대개 그렇다(우리 CI 도 그래서 이 자리를 재는 검사가 빨간불
+       * 이었다). 그런 곳에서 큰 폴더를 한 번 찾으면 그 몇 초 동안 상태줄도
+       * 안 돌고 ESC 도 안 먹는다. 오류가 아니라서 아무 데도 안 남고, 사람 눈에는
+       * 「가끔 멈춘다」 로만 보인다.
+       *
+       * 그래서 파일을 몇 개 볼 때마다 한 번씩 자리를 내준다. 밀린 타이머와
+       * 눌린 키가 그 틈에 처리된다. 한 번 내주는 값은 마이크로초 단위라
+       * 찾는 시간에는 거의 안 보태지고, 그 사이 파일 목록이 바뀌지도 않는다
+       * (목록은 위에서 이미 다 떠 놨다).
+       */
+      const 숨돌릴때마다 = 200;
+      let 본것 = 0;
       for (const f of files) {
         // 도중에 Ctrl+C 를 눌렀으면 여기서 그만둔다. 찾은 데까지는 준다.
         if (ctx.signal?.aborted) { 멈춤 = '중단'; break; }
+        if ((본것 += 1) % 숨돌릴때마다 === 0) {
+          await new Promise((r) => setImmediate(r));
+          // 자리를 내준 사이에 눌렸을 수 있다. 내주고 나면 다시 본다.
+          if (ctx.signal?.aborted) { 멈춤 = '중단'; break; }
+        }
         if ((f.size ?? 0) > GREP_MAX_FILE) { 건너뛴것++; continue; }
         if (안읽을확장자.test(f.rel)) { 건너뛴것++; continue; }
         let text;
@@ -1686,7 +1711,7 @@ export const TOOLS = {
         // 윈도우 명령창은 UTF-8 이 아니다. 한국어 윈도우는 CP949 로 뱉는다.
         // 이걸 utf8 이라고 하고 받으면 한글이 통째로 깨진다 — '파싱 성공' 이
         // '�Ľ� ����' 이 된다. 바이트로 받아 이 컴퓨터가 쓰는 것으로 해독한다.
-        const kid = execFile(shell.file, shell.args, {
+        const kid = 무리로돌리기(shell.file, shell.args, {
           cwd: ctx.scope.root,
           // 열쇠만 빼고 나머지는 그대로 물려준다 (backend/mcp.js 열쇠뺀환경 머리말).
           // 안 빼면 `env` 한 줄이 열쇠를 화면과 대화 기록에 그대로 싣는다.
@@ -1699,6 +1724,10 @@ export const TOOLS = {
           /*
            * 유닉스에서는 **무리를 만들어 둔다.**
            *
+           * 이 한 줄 때문에 execFile 을 안 쓴다 — 그쪽은 detached 를 spawn 에
+           * 안 넘기고 조용히 버린다(tools/spawn.js 의 무리로돌리기 머리말).
+           * 여기 이 줄이 열두 판 동안 아무 일도 안 하고 있었다.
+           *
            * 나중에 만들어 줄 방법이 없어서 띄우는 순간에 정해야 한다. 안 만들면
            * 나중에 손자를 가리킬 길이 아예 없다 — `sh -c "cd app && npm start"`
            * 처럼 복합 명령이면 sh 가 exec 로 갈아치우지 않고 fork 하므로,
@@ -1833,7 +1862,15 @@ export const TOOLS = {
              * 있다 — 검사가 쓰는 명령이 `node ticker.cjs` 하나뿐이라
              * 유닉스 sh 가 그걸 exec 로 갈아치웠고, 애초에 손자가 안 생겼다.
              */
-            무리끊기(kid.pid);
+            /*
+             * 올려치는 시간도 **부르는 쪽이 정한 것**을 쓴다.
+             *
+             * 윗 갈래(윈도우)는 더줄까 를 받아 쓰는데 여기는 안 받고 있었다.
+             * 그래서 시간 초과에서 넉넉히 주라고 4초를 넘겨도 유닉스에서는
+             * 늘 기본값 그대로였다 — 같은 판단이 두 벌로 있으면 늘 한쪽만
+             * 고쳐진다는 이야기가 이 함수 안에서 또 한 번 났다.
+             */
+            무리끊기(kid.pid, { 늦게: 더줄까 > 0 ? Math.min(더줄까, 2000) : 800 });
           }
           try { kid.kill(); } catch {}
           // 죽이라고 시켰다고 곧바로 죽는 것은 아니다. 그동안 이 프로세스가

package/src/tools/jobs.js

@@ -157,17 +157,98 @@ export function 잘렸나(err) {
  * 만들어 줄 방법은 없다 — 그래서 이 판단이 띄우는 자리와 짝을 이뤄야 한다.
  * (Bash 도구가 한동안 이 짝을 안 맞춰서, 윈도우만 고쳐지고 유닉스는 그대로였다.)
  */
+/**
+ * 그 무리가 아직 살아 있나. 죽었으면 false.
+ *
+ * 무리로 못 물어보면 **그 하나에게** 물어본다 — 위 신호주기() 와 같은 까닭이다.
+ * 무리가 없는 판에서 「무리가 없다 = 다 죽었다」 로 읽으면, 살아 있는 자식을
+ * 죽은 것으로 세고 그냥 지나간다.
+ */
+function 무리살아있나(pid) {
+  try { process.kill(-pid, 0); return true; } catch { /* 무리가 없다 */ }
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+
+/**
+ * 동기로 잠깐 쉰다.
+ *
+ * `setTimeout` 이 아니라 이걸 쓰는 까닭은 아래 무리끊기 머리말에 있다 —
+ * 이 자리는 프로그램이 끝나는 길에서도 지나가고, 그 자리에서는 비동기
+ * 일감이 하나도 안 돈다.
+ */
+function 동기로쉬기(ms) {
+  try { Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms); }
+  catch { /* SharedArrayBuffer 가 막힌 판이면 그냥 지나간다 */ }
+}
+
+/**
+ * 신호를 보낸다. **무리째 못 보내면 그 하나에게라도 보낸다.**
+ *
+ * ── 왜 두 번 시도하나 ──────────────────────────────────────────────────
+ *
+ * `-pid` 는 「그 무리 전부」 라는 뜻이고, 그 무리는 띄울 때 `detached` 로
+ * 만들어 둔 것이다. 그런데 그게 늘 있으리라 믿으면 안 된다 —
+ *
+ *   · `detached` 가 안 먹은 판 (컨테이너 안, 이상한 실행 환경)
+ *   · 이미 무리 우두머리가 죽고 남은 놈이 딴 무리로 넘어간 자리
+ *
+ * 이런 자리에서 `kill(-pid, …)` 는 ESRCH 로 튕긴다. 그러면 여태는 그
+ * 자리에서 **아무것도 안 하고 돌아갔다.** 무리로 못 보냈다는 것이 「보낼
+ * 것이 없다」 는 뜻은 아닌데, 그렇게 다뤘다. 무리로 못 보내면 적어도 우리가
+ * 아는 그 하나(자식)에게는 보낸다 — 그게 손자를 못 잡더라도, 아무것도 안
+ * 하는 것보다는 낫다.
+ *
+ * @returns {boolean} 하나라도 닿았으면 true
+ */
+function 신호주기(pid, 신호) {
+  let 닿았나 = false;
+  try { process.kill(-pid, 신호); 닿았나 = true; } catch { /* 무리가 없다 */ }
+  if (!닿았나) {
+    try { process.kill(pid, 신호); 닿았나 = true; } catch { /* 그마저 죽었다 */ }
+  }
+  return 닿았나;
+}
+
 export function 무리끊기(pid, { 곧장 = false, 늦게 = 800 } = {}) {
   if (process.platform === 'win32' || !pid) return;
   if (곧장) {
-    try { process.kill(-pid, 'SIGKILL'); } catch { /* 이미 죽음 */ }
+    신호주기(pid, 'SIGKILL');
     return;
   }
-  try { process.kill(-pid, 'SIGTERM'); } catch { /* 무리가 없거나 이미 죽음 */ }
-  try {
-    const 시계 = setTimeout(() => { try { process.kill(-pid, 'SIGKILL'); } catch { /* 죽었다 */ } }, 늦게);
-    시계.unref?.();
-  } catch { /* 끝나는 중이면 타이머를 못 건다 — 부르는 쪽이 곧장 으로 다시 온다 */ }
+  신호주기(pid, 'SIGTERM');
+
+  /*
+   * ── 올려치기를 **동기로** 한다 ────────────────────────────────────────
+   *
+   * 여기가 `setTimeout(…, 늦게).unref()` 였다. 두 가지가 어긋났다.
+   *
+   *   1. `unref()` 한 타이머는 **프로세스를 안 붙잡는다.** 시간 초과로
+   *      끊고 곧바로 끝나는 길에서는 그 타이머가 아예 안 뜬다. 즉 SIGTERM
+   *      을 무시하는 손자(제 신호 처리기를 단 dev 서버·watch 프로세스)는
+   *      그대로 살아남는다. 「죽이라고 말은 했는데 안 죽는」 자리다.
+   *   2. 부르는 쪽은 이 함수가 **돌아오면 끝난 줄로 안다.** 실제로는 아직
+   *      TERM 만 보낸 상태라, 바로 뒤에서 「진짜 멈췄나」 를 보면 살아 있다.
+   *      이 비대칭이 윈도우와 유닉스 사이에도 있었다 — 윈도우 쪽은
+   *      taskkill 을 동기로 기다린다(나무죽이기 머리말).
+   *
+   * 그래서 곱게 말한 뒤 **짧게 나눠 지켜보다가**, 그래도 살아 있으면 그
+   * 자리에서 끊는다. 얌전히 끝나는 무리는 첫 20ms 에 사라지므로 보통은
+   * 거의 안 기다린다. 안 죽는 놈에게만 `늦게` 만큼 쓴다.
+   */
+  const 조각 = 20;
+  for (let 쓴시간 = 0; 쓴시간 < 늦게; 쓴시간 += 조각) {
+    if (!무리살아있나(pid)) return;
+    동기로쉬기(조각);
+  }
+  /*
+   * 마지막 한 방은 **묻지 않고** 보낸다.
+   *
+   * 여기가 `if (무리살아있나(pid))` 였다. 그 물음은 틀릴 수 있다 — 권한이
+   * 없으면(EPERM) 살아 있는데도 「없다」 가 나오고, 그러면 안 죽이고 지나간다.
+   * 이미 죽은 것에 SIGKILL 을 보내는 값은 예외 하나뿐이고 그건 여기서 삼킨다.
+   * 안 죽은 것을 살려 보내는 값은 포트를 문 프로세스가 남는 것이다. 값이 다르다.
+   */
+  신호주기(pid, 'SIGKILL');
 }
 
 /**

package/src/tools/label.js

@@ -0,0 +1,52 @@
+// 도구 부름 한 줄을 적을 때 **무엇으로 그 부름을 알아보나.**
+//
+// ── 왜 파일 하나를 따로 두나 ────────────────────────────────────────────
+//
+// `Read` 만 적으면 열 줄이 전부 `Read` 다. 무엇을 읽었는지가 빠지면 목록을
+// 훑어보는 뜻이 없어진다. 그래서 인자에서 「이 부름을 대표하는 값」 하나를
+// 뽑아 괄호에 넣는다 — `Read(src/a.js)`.
+//
+// 그 「대표하는 값」 을 고르는 **차례**가 여태 다섯 곳에 따로 적혀 있었다:
+//
+//   src/repl.js · src/oneshot.js · src/acp/map.js · src/ui/export.js ·
+//   src/safety/audit.js
+//
+// 다섯이 조금씩 달랐다. 어떤 데는 `url` 이 있고 어떤 데는 없다. 새 도구가
+// 새 인자 이름을 쓰면 그중 한두 곳만 고쳐지고, 나머지에서는 그 도구가 **빈
+// 괄호**로 남는다 — 화면에도, 내보낸 보고서에도, 감사기록에도. 그 셋이
+// 서로 다른 말을 하기 시작하면 무엇이 맞는지 알 길이 없다.
+//
+// 목록은 여기 하나다. 부르는 쪽은 제 사정(길이 자르기·일감 번호 같은 것)만
+// 따로 얹는다.
+
+/**
+ * 이 인자가 무엇에 관한 부름인지 말해 주는 이름들. **차례가 뜻이다** —
+ * 앞엣것이 더 또렷하다.
+ *
+ *   file_path  파일을 다루는 도구 (Read·Write·Edit)
+ *   pattern    찾는 도구 (Grep·Glob)
+ *   path       폴더를 다루는 도구
+ *   url        웹을 읽는 도구
+ *   name       이름으로 부르는 것 (스킬·플러그인·MCP)
+ *   purpose/목적  하위 작업 — 무엇을 시켰는지가 곧 그 부름이다
+ *   command    셸 — 제일 뒤다. 길고, 앞엣것이 있으면 그쪽이 더 또렷하다.
+ */
+export const 이름칸들 = ['file_path', 'pattern', 'path', 'url', 'name', 'purpose', '목적'];
+
+/**
+ * 인자에서 대표하는 값 하나. 없으면 null.
+ *
+ * `command` 는 **여기서 안 본다.** 글이 길어서 부르는 쪽마다 자르는 길이가
+ * 다르고(화면은 52자, 기록은 통째로), 그 판단까지 여기서 하면 한쪽이 반드시
+ * 어색해진다. 부르는 쪽이 이 자를 먼저 물어보고, 없으면 제 방식으로 command
+ * 를 다룬다.
+ */
+export function 첫이름(인자) {
+  const a = 인자 ?? {};
+  for (const 칸 of 이름칸들) {
+    const v = a[칸];
+    if (typeof v === 'string' && v) return v;
+    if (typeof v === 'number') return String(v);
+  }
+  return null;
+}

package/src/tools/spawn.js

@@ -97,3 +97,117 @@ export function 돌려보기(이름, 인자, { timeout = 20000, maxBuffer = 32 *
     아이.on('close', (코드) => 끝내기({ error: null, status: 코드, stdout: 밖, stderr: 탈 }));
   });
 }
+
+
+/*
+ * ── `execFile` 은 `detached` 를 **버린다** ──────────────────────────────
+ *
+ * Bash 도구가 이렇게 부르고 있었다.
+ *
+ *   execFile(셸, 인자, { cwd, env, timeout, maxBuffer, detached: true, … })
+ *
+ * 그리고 그 옆에 「유닉스에서는 무리를 만들어 둔다」 는 머리말이 열두 줄
+ * 붙어 있었다. 그 줄은 **아무 일도 안 하고 있었다.** Node 의 execFile 은
+ * 받은 옵션을 spawn 에 통째로 넘기지 않는다. 제 소스에 목록이 박혀 있다 —
+ *
+ *   cwd · env · gid · shell · signal · uid ·
+ *   windowsHide · windowsVerbatimArguments
+ *
+ * `detached` 가 없다. 오타도 아니고 오류도 아니라서, 적어 둔 사람도 읽는
+ * 사람도 그게 안 걸린 줄 모른다. 리눅스 CI 가 열 판 넘게 이 자리에서
+ * 빨갰는데, 무엇이 살아남았는지를 검사가 적기 시작하고서야 보였다.
+ *
+ *   pid 6791 · pgid 1938 · ppid 1   node ticker.cjs
+ *
+ * 무리(pgid)가 제 pid 가 아니라 **검사 프로세스의 무리**였다. 즉 애초에
+ * 무리가 안 만들어졌고, `kill(-pid, …)` 는 죽일 것을 못 찾고 있었다.
+ * 죽이는 쪽을 아무리 고쳐도 안 고쳐질 자리였다.
+ *
+ * 그래서 spawn 을 바로 쓴다. execFile 이 해 주던 것(모아 담기·상한·시한·
+ * 오류 모양)은 여기서 **같은 모양으로** 해 준다 — 부르는 쪽의 판단 코드를
+ * 한 줄도 안 건드리려는 것이다. 이 파일 머리말과 같은 자세다.
+ */
+
+/**
+ * execFile 과 같은 약속으로 부르되, **무리를 진짜로 만든다.**
+ *
+ * 콜백은 execFile 의 것과 같다 — `(탈, 밖Buffer, 탈Buffer)`.
+ * 탈의 모양도 맞춘다:
+ *
+ *   못 돌렸다        탈.code = 'ENOENT' 같은 글자
+ *   출력이 넘쳤다    탈.code = 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER', 탈.killed = true
+ *   시한을 넘겼다    탈.killed = true, 탈.signal = 보낸 신호
+ *   시그널로 죽었다  탈.signal = 그 신호
+ *   0 이 아니게 끝남 탈.code = 그 숫자
+ *
+ * @returns {import('node:child_process').ChildProcess}
+ */
+export function 무리로돌리기(파일, 인자, 옵션 = {}, 끝나면 = () => {}) {
+  const {
+    cwd = undefined, env = undefined, timeout = 0, maxBuffer = 32 * 1024 * 1024,
+    windowsHide = true, windowsVerbatimArguments = false, detached = false,
+    killSignal = 'SIGTERM',
+  } = 옵션;
+
+  const 아이 = spawn(파일, 인자, {
+    cwd, env, windowsHide, windowsVerbatimArguments, detached,
+  });
+
+  const 밖조각 = [];
+  const 탈조각 = [];
+  let 밖크기 = 0;
+  let 탈크기 = 0;
+  let 끝났나 = false;
+  let 미리잡은탈 = null;
+
+  const 모으기 = (스트림, 조각들, 더할것) => {
+    조각들.push(더할것);
+    return 스트림 + 더할것.length;
+  };
+
+  const 끝내기 = (탈) => {
+    if (끝났나) return;
+    끝났나 = true;
+    clearTimeout(시계);
+    끝나면(탈 ?? null, Buffer.concat(밖조각), Buffer.concat(탈조각));
+  };
+
+  /** execFile 이 만드는 것과 같은 모양의 탈. */
+  const 탈만들기 = (글, 더할것) => Object.assign(new Error(글), 더할것);
+
+  const 넘쳤다 = () => {
+    미리잡은탈 = 탈만들기('stdout maxBuffer length exceeded',
+      { code: 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER', killed: true });
+    try { 아이.kill(killSignal); } catch { /* 이미 죽었다 */ }
+  };
+
+  아이.stdout?.on('data', (조각) => {
+    밖크기 = 모으기(밖크기, 밖조각, 조각);
+    if (밖크기 > maxBuffer && !미리잡은탈) 넘쳤다();
+  });
+  아이.stderr?.on('data', (조각) => {
+    탈크기 = 모으기(탈크기, 탈조각, 조각);
+    if (탈크기 > maxBuffer && !미리잡은탈) 넘쳤다();
+  });
+
+  /*
+   * 시한은 **마지막 그물**이다. 부르는 쪽이 제 시계로 먼저 끊는 것이 보통이고,
+   * 이건 그것마저 못 돌았을 때 선다. unref 하지 않는다 — 여기서 놓아 버리면
+   * 그물이 아니게 된다.
+   */
+  const 시계 = timeout > 0 ? setTimeout(() => {
+    미리잡은탈 = 탈만들기(`명령이 ${timeout}ms 안에 안 끝났습니다`,
+      { killed: true, signal: killSignal });
+    try { 아이.kill(killSignal); } catch { /* 이미 죽었다 */ }
+  }, timeout) : null;
+
+  아이.on('error', (탈) => 끝내기(탈));
+  아이.on('close', (코드, 신호) => {
+    if (미리잡은탈) return 끝내기(미리잡은탈);
+    if (신호) return 끝내기(탈만들기(`${신호} 시그널로 죽었습니다`, { killed: true, signal: 신호 }));
+    if (코드 !== 0) return 끝내기(탈만들기(`종료코드 ${코드}`, { code: 코드, killed: false }));
+    끝내기(null);
+  });
+
+  return 아이;
+}