deel-local-cli 1.8.0 → 1.12.0

package/src/pack/sbom.js

@@ -25,6 +25,8 @@
 // 적어 둔 칸이 다 있는지 본다.
 import { randomUUID } from 'node:crypto';
 import { 보관방식 } from '../safety/keystore.js';
+import { 언어 } from '../i18n/index.js';
+import { specEn, egressEn, keyStorageEn, auditLogEn, specSummaryEn } from './sheet.en.js';
 
 /** 우리가 내놓는 SBOM 규격. 스캐너가 이 숫자를 보고 읽는 법을 정한다. */
 export const CDX판 = '1.5';
@@ -41,7 +43,7 @@ export const CDX판 = '1.5';
  * @param {Date}   o.at        만든 때 (검사가 고정할 수 있게)
  * @param {string} o.serial    문서 일련번호 (검사가 고정할 수 있게)
  */
-export function sbom(a, { at = new Date(), serial = null } = {}) {
+export function sbom(a, { at = new Date(), serial = null, lang = 언어() } = {}) {
   const purl = `pkg:npm/${a.name}@${a.version}`;
   const 본체 = {
     type: 'application',
@@ -50,7 +52,11 @@ export function sbom(a, { at = new Date(), serial = null } = {}) {
     version: a.version,
     purl,
     licenses: a.license ? [{ license: { id: a.license } }] : [],
-    description: '로컬 모델·사내 게이트웨이 전용 코딩 에이전트 CLI',
+    // SBOM 은 남에게 내는 서류다. 화면을 영어로 켜 둔 사람이 한국어 설명이
+    // 박힌 문서를 심사에 낼 수는 없다.
+    description: lang === 'ko'
+      ? '로컬 모델·사내 게이트웨이 전용 코딩 에이전트 CLI'
+      : 'A coding agent CLI for local models and in-house gateways',
   };
 
   return {
@@ -208,7 +214,20 @@ export function 감사명세() {
 /**
  * 세 가지를 한 덩이로. zip 에 이대로 들어간다.
  */
-export function 심사명세(a, { at = new Date() } = {}) {
+export function 심사명세(a, { at = new Date(), lang = 언어() } = {}) {
+  /*
+   * 한국어가 아니면 영어 서류를 낸다 (pack/sheet.en.js).
+   *
+   * 열쇠 이름까지 영어라야 뜻이 있다. 값만 옮기고 열쇠를 `통신`·`감사기록`
+   * 으로 두면, 스캐너에 넣는 사람이 무엇이 무엇인지 못 읽는다 — 반쯤 옮긴
+   * 서류는 안 옮긴 것보다 나쁘다.
+   *
+   * 일본어·중국어도 영어로 간다. i18n 의 물러날곳(ja→en→ko)과 같은 규칙이다.
+   */
+  if (lang !== 'ko') {
+    const 자리 = (id) => (a.calls?.[id] ?? []).map((x) => `${x.file}:${x.line}`);
+    return specEn(a, at, egressEn(자리, a), keyStorageEn(보관방식(null, { lang: 'en' })), auditLogEn());
+  }
   return {
     만든것: a.name,
     판: a.version,
@@ -231,9 +250,16 @@ export function 심사명세(a, { at = new Date() } = {}) {
   };
 }
 
-/** 사람이 읽을 짧은 요약. 화면에 찍는 자리에서 쓴다. */
+/**
+ * 사람이 읽을 짧은 요약. 화면에 찍는 자리에서 쓴다.
+ *
+ * 어느 말로 쓸지를 **명세 자체를 보고** 정한다. 언어() 를 여기서 또 물으면,
+ * 명세를 만든 뒤에 말이 바뀐 자리에서 요약만 딴 말이 된다 — 그러면 읽을 수
+ * 없는 열쇠에서 값을 꺼내려다 전부 0 으로 찍힌다.
+ */
 export function 명세요약(명세) {
   const m = 명세 ?? {};
+  if (!m.파일 && m.files) return specSummaryEn(m);
   return [
     `SBOM 부품     ${(m.파일?.length ?? 0).toLocaleString()}개 (전부 SHA-256 붙임)`,
     `의존성        ${(m.의존성?.dependencies?.length ?? 0)}개 · 설치 스크립트 ${(m.의존성?.설치스크립트?.length ?? 0)}개`,

package/src/pack/selfpack.js

@@ -12,6 +12,8 @@ import { join, dirname, relative } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { makeZip } from './zip.js';
 import { sbom, 심사명세 } from './sbom.js';
+import { 언어 } from '../i18n/index.js';
+import { reviewSheetEn, readMeEn } from './sheet.en.js';
 
 export const repoRoot = () => join(dirname(fileURLToPath(import.meta.url)), '..', '..');
 
@@ -127,7 +129,10 @@ export function audit(root = repoRoot()) {
 
 const 줄 = (n = 74) => '-'.repeat(n);
 
-export function reviewSheet(a, at) {
+export function reviewSheet(a, at, { lang = 언어() } = {}) {
+  // 한국어가 아니면 영어 서류 (pack/sheet.en.js). 같은 audit() 을 쓴다 —
+  // 말이 달라도 숫자가 달라지면 그건 서류가 거짓말을 하는 것이다.
+  if (lang !== 'ko') return reviewSheetEn(a, at, PROBES);
   const L = [];
   L.push('deel 사내 반입 심사 자료');
   L.push(줄());
@@ -221,10 +226,11 @@ export function reviewSheet(a, at) {
 /**
  * 심사서 + 소스를 zip 하나로 묶는다.
  */
-export function packSelf(outFile, { root = repoRoot(), at = new Date() } = {}) {
+export function packSelf(outFile, { root = repoRoot(), at = new Date(), lang = 언어() } = {}) {
   const a = audit(root);
   const stamp = at.toISOString().replace('T', ' ').slice(0, 19);
-  const sheet = reviewSheet(a, stamp);
+  const sheet = reviewSheet(a, stamp, { lang });
+  const 한국어 = lang === 'ko';
 
   /*
    * 사람이 읽는 것 하나, 기계가 읽는 것 둘.
@@ -233,10 +239,20 @@ export function packSelf(outFile, { root = repoRoot(), at = new Date() } = {}) {
    * 취약점 목록을 뽑고, 운영팀은 감사기록 사양을 보고 SIEM 수집 규칙을 짠다.
    * 사람이 읽는 글은 그 어느 쪽에도 못 들어간다 — 그래서 셋을 다 넣는다.
    */
+  /*
+   * 파일 이름도 같이 옮긴다.
+   *
+   * 안이 영어인데 이름이 `반입심사서.txt` 면, 받은 사람은 열기 전에 무엇인지
+   * 모르고 메일에 첨부하면 이름이 깨져서 온다. 서류의 이름은 서류의 일부다.
+   */
+  const 이름 = 한국어
+    ? { 심사서: '반입심사서.txt', 명세: '심사명세.json', 안내: '읽어주세요.txt' }
+    : { 심사서: 'import-review.txt', 명세: 'audit-spec.json', 안내: 'READ-ME-FIRST.txt' };
+
   const entries = [
-    { name: '반입심사서.txt', data: Buffer.from(sheet, 'utf8'), mtime: at },
-    { name: 'sbom.cdx.json', data: Buffer.from(JSON.stringify(sbom(a, { at }), null, 2), 'utf8'), mtime: at },
-    { name: '심사명세.json', data: Buffer.from(JSON.stringify(심사명세(a, { at }), null, 2), 'utf8'), mtime: at },
+    { name: 이름.심사서, data: Buffer.from(sheet, 'utf8'), mtime: at },
+    { name: 'sbom.cdx.json', data: Buffer.from(JSON.stringify(sbom(a, { at, lang }), null, 2), 'utf8'), mtime: at },
+    { name: 이름.명세, data: Buffer.from(JSON.stringify(심사명세(a, { at, lang }), null, 2), 'utf8'), mtime: at },
   ];
   for (const f of a.files) {
     entries.push({
@@ -247,8 +263,8 @@ export function packSelf(outFile, { root = repoRoot(), at = new Date() } = {}) {
     });
   }
   entries.push({
-    name: '읽어주세요.txt',
-    data: Buffer.from([
+    name: 이름.안내,
+    data: 한국어 ? Buffer.from([
       'deel — 로컬 모델·사내 게이트웨이 코딩 에이전트',
       '',
       '쓰는 법 (설치 절차 없음)',
@@ -265,7 +281,7 @@ export function packSelf(outFile, { root = repoRoot(), at = new Date() } = {}) {
       '',
       '  세 파일 모두 소스를 훑어 자동으로 만든 것입니다. 손으로 적은 값이 아닙니다.',
       '',
-    ].join('\n'), 'utf8'),
+    ].join('\n'), 'utf8') : Buffer.from(readMeEn(), 'utf8'),
     mtime: at,
   });
 

package/src/pack/sheet.en.js

@@ -0,0 +1,288 @@
+// 반입 심사 서류의 영어판.
+//
+// ── 왜 번역표가 아니라 딴 파일인가 ──────────────────────────────────────
+//
+// 화면 말은 열쇠 하나에 한 문장이라 i18n 표가 맞다(src/i18n). 이건 다르다.
+// **서류**다. 한 장이 통째로 하나의 글이고, 절 이름·차례·줄맞춤이 같이
+// 뜻을 만든다. 그걸 열쇠 이백 개로 쪼개 두면, 고칠 때마다 두 파일을 오가며
+// 짜맞춰야 하고 결국 한쪽만 고친 서류가 나간다.
+//
+// 이 저장소는 이미 같은 판단을 한 번 했다 — README.md 와 README.ko.md 를
+// 갈라 뒀다. 서류는 서류대로 통째로 쓰는 편이 읽기도 고치기도 낫다.
+//
+// ── 대신 어긋나지 않게 검사한다 ─────────────────────────────────────────
+//
+// 갈라 두면 한쪽만 고치는 날이 온다. 그래서 test/packlang.test.js 가 두 판의
+// **모양**을 견준다 — 절 수, 실린 파일 수, 통신 갈래 수. 글은 달라도 되지만
+// 사실이 달라지면 그건 서류가 거짓말을 하는 것이다.
+//
+// ── 지어내지 않는다 ────────────────────────────────────────────────────
+//
+// 여기 적히는 값은 전부 selfpack.js 의 audit() 이 소스를 훑어 얻은 것이다.
+// 한국어판과 같은 자료를 쓴다. 영어판이라고 다른 숫자가 나오면 안 된다.
+
+const rule = (n = 74) => '-'.repeat(n);
+
+/** 소스를 훑는 자리들. 한국어판 PROBES 와 같은 차례여야 한다. */
+const PROBE_LABELS = {
+  net: { label: 'Network requests', note: 'Only to the address you entered in setup (through HTTPS_PROXY when one is set)' },
+  exec: { label: 'External commands', note: 'Commands you or the model asked for, plus git when installing a plugin' },
+  listen: { label: 'Listening ports', note: 'Should be none' },
+  eval: { label: 'String evaluation', note: 'Should be none' },
+};
+
+/**
+ * 사람이 읽는 심사서 — 영어판.
+ *
+ * @param {object} a       selfpack.js 의 audit()
+ * @param {string} at      만든 시각
+ * @param {Array}  probes  selfpack.js 의 PROBES (차례를 그대로 따른다)
+ */
+export function reviewSheetEn(a, at, probes) {
+  const L = [];
+  L.push('deel — security review package');
+  L.push(rule());
+  L.push(`Name          ${a.name}`);
+  L.push(`Version       ${a.version}`);
+  L.push(`License       ${a.license}`);
+  L.push(`Runtime       Node ${a.node} (standard library only)`);
+  L.push(`Generated     ${at}`);
+  L.push('');
+
+  L.push('1. Third-party dependencies');
+  L.push(rule());
+  L.push(`   dependencies       ${a.deps.length}${a.deps.length ? '  ' + a.deps.join(', ') : '   <- no third-party code is shipped'}`);
+  L.push(`   devDependencies    ${a.devDeps.length}`);
+  L.push(`   external imports   ${a.외부모듈.length}${a.외부모듈.length ? '' : '   <- only node: builtins and its own files'}`);
+  for (const x of a.외부모듈) L.push(`       ${x}`);
+  L.push('');
+
+  L.push('2. Code that runs on install');
+  L.push(rule());
+  L.push(a.lifecycle.length
+    ? `   Present: ${a.lifecycle.join(', ')}   <- needs review`
+    : '   None   <- no preinstall / install / postinstall / prepare');
+  L.push('   Unzip and run `node bin/deel.js`. There is no install step.');
+  L.push('');
+
+  L.push('3. Every outbound call site (found by scanning the source)');
+  L.push(rule());
+  for (const p of probes) {
+    const hits = a.calls[p.id];
+    const w = PROBE_LABELS[p.id] ?? { label: p.id, note: '' };
+    L.push(`   [${w.label}]  ${hits.length}   ${w.note}`);
+    for (const h of hits) L.push(`       ${h.file}:${h.line}   ${h.text}`);
+    if (!hits.length) L.push('       (none)');
+  }
+  L.push('');
+  L.push('   Note: no endpoint is hard-coded in the source. deel only uses the address you');
+  L.push('     entered in setup.  Config file: ~/.deel/config.json  (or DEEL_API_KEY)');
+  L.push('');
+
+  L.push('3-1. Four separate outbound lanes that never mix');
+  L.push(rule());
+  L.push('   [A] Model gateway - the only lane that carries your source code');
+  L.push('       - Address: the single endpoint chosen in deel setup');
+  L.push('       - That one address is the entire allow-list. Switch models and the old one closes.');
+  L.push('       - src/safety/network.js checks every request. If the address is not on the');
+  L.push('         list, the request is never built.');
+  L.push('       - With HTTPS_PROXY (or proxy in the config) the call goes **through** that');
+  L.push('         proxy (CONNECT tunnel). The destination stays the same single address, and');
+  L.push('         the proxy in use is printed at startup and in /status. Requests to this');
+  L.push('         machine (127.*, localhost) never go through the proxy.');
+  L.push('');
+  L.push('   [B] Web reading (WebFetch tool) - fetch only');
+  L.push('       - GET only. No request body, so source and conversation cannot leave this way.');
+  L.push('       - This machine and private ranges (127.*, 10.*, 192.168.*, 172.16-31.*) are refused.');
+  L.push('       - The lane opens only while the tool runs and closes immediately after.');
+  L.push('       - Every address visited is written to the audit log.');
+  L.push('');
+  L.push('   [C] Plugin install (github) - only when you type /plugin install');
+  L.push('       - Open only while that command runs.');
+  L.push('');
+  L.push('   [D] MCP servers - separate child processes, someone else\'s program');
+  L.push('       - Off by default. A server runs only if you list it in .deel/mcp.json.');
+  L.push('       - Unlike A/B/C we cannot see which sockets that server opens. So instead of');
+  L.push('         filtering its requests, --offline does not start the server at all.');
+  L.push('');
+  L.push('   Starting with --offline blocks [B], [C] and [D]; traffic stays on this machine.');
+  L.push('   (Verified by the network / web / mcp checks in npm test - 123 assertions.)');
+  L.push('');
+
+  L.push('4. Skills and plugins');
+  L.push(rule());
+  L.push('   This package contains no skills and no plugins.');
+  L.push('   It only reads ~/.claude, ~/.deel and the project folder on the machine it runs on.');
+  L.push('   (Verified by the no-bundle check in npm test.)');
+  L.push('');
+
+  L.push(`5. ${a.files.length} files shipped - SHA-256`);
+  L.push(rule());
+  const w = Math.max(...a.files.map((f) => f.path.length));
+  for (const f of a.files) {
+    L.push(`   ${f.path.padEnd(w)}  ${String(f.bytes).padStart(7)}B  ${f.sha}`);
+  }
+  L.push('');
+  L.push('   Verify these yourself with:');
+  L.push('     sha256sum <file>                   (Linux, macOS)');
+  L.push('     certutil -hashfile <file> SHA256   (Windows)');
+  L.push('');
+  return L.join('\n');
+}
+
+/** zip 맨 앞에 넣는 안내 — 영어판. */
+export function readMeEn() {
+  return [
+    'deel - a coding agent CLI for local models and in-house gateways',
+    '',
+    'How to run it (there is no install step)',
+    '  1. Unzip this archive anywhere.',
+    '  2. Check that Node 20 or newer is present:  node -v',
+    '  3. Choose a connection:                     node deel/bin/deel.js setup',
+    '  4. Start talking:                           node deel/bin/deel.js',
+    '',
+    'For the security reviewer',
+    '  import-review.txt  The review package in prose: dependencies, install scripts,',
+    '                     every network call site, and a SHA-256 for each file.',
+    '  sbom.cdx.json      SBOM (CycloneDX 1.5). Feed it straight to your scanner.',
+    '  audit-spec.json    Egress list, audit-log specification, file hashes - machine readable.',
+    '',
+    '  All three are generated by scanning the source. None of it is written by hand.',
+    '',
+  ].join('\n');
+}
+
+/**
+ * 심사명세 — 영어판.
+ *
+ * 한국어판(sbom.js 의 심사명세)과 **같은 자료, 같은 차례**다. 열쇠 이름까지
+ * 영어라야 뜻이 있다 — 스캐너에 넣는 사람이 `통신` 을 읽을 수는 없다.
+ */
+export function specEn(a, at, 통신, 열쇠, 감사) {
+  return {
+    product: a.name,
+    version: a.version,
+    license: a.license,
+    runtime: `Node ${a.node} (standard library only)`,
+    generated: at.toISOString(),
+    dependencies: {
+      dependencies: a.deps,
+      devDependencies: a.devDeps,
+      installScripts: a.lifecycle,
+      externalImportsInSource: a.외부모듈,
+      summary: a.deps.length === 0 && a.외부모듈.length === 0
+        ? 'No third-party code is bundled. Only node: builtins and its own files are imported.'
+        : 'External modules are present - review the list above.',
+    },
+    egress: 통신,
+    keyStorage: 열쇠,
+    auditLog: 감사,
+    files: a.files.map((f) => ({ path: f.path, bytes: f.bytes, sha256: f.sha })),
+  };
+}
+
+/** 나가는 길 — 영어판. 자리(소스 줄 번호)는 부르는 쪽이 넣어 준다. */
+export function egressEn(자리, a) {
+  return {
+    lanes: [
+      {
+        lane: 'Model gateway',
+        when: 'On every turn you type',
+        where: 'The single address chosen in deel setup',
+        what: 'The conversation, and the file contents the model read',
+        control: 'src/safety/network.js checks the allow-list on every request. If the address is not listed, the request is never built.',
+        proxy: 'With HTTPS_PROXY (or proxy in the config) the call goes through that proxy (CONNECT tunnel). The destination allow-list is unchanged, and addresses on this machine bypass the proxy.',
+        source: 자리('net'),
+      },
+      {
+        lane: 'Web reading (WebFetch)',
+        when: 'Only when the model calls that tool',
+        where: 'An address the model chose. This machine and private ranges are refused',
+        what: 'Nothing - GET only, so no request body is sent',
+        control: 'Blocked entirely under --offline.',
+        source: 자리('net'),
+      },
+      {
+        lane: 'Plugin install',
+        when: 'Only when you type /plugin install',
+        where: 'github.com',
+        what: 'Nothing',
+        control: 'Blocked entirely under --offline.',
+        source: 자리('net'),
+      },
+    ],
+    listeningPorts: {
+      count: (a.calls?.listen ?? []).length,
+      use: 'Only /preview, which serves the page you just built. It binds to 127.0.0.1 and closes when the command ends.',
+      source: 자리('listen'),
+    },
+    externalCommands: {
+      count: (a.calls?.exec ?? []).length,
+      use: 'Commands you or the model asked for, starting MCP servers, and git when installing a plugin.',
+      source: 자리('exec'),
+    },
+    stringEvaluation: {
+      count: (a.calls?.eval ?? []).length,
+      use: 'Should be none.',
+      source: 자리('eval'),
+    },
+    whenOffline: [
+      'Web reading (WebFetch) is blocked.',
+      'Plugin install is blocked.',
+      'MCP servers are not started - we cannot control where a child process connects.',
+      'The model gateway still works. If that address is on this machine, nothing leaves it at all.',
+    ],
+  };
+}
+
+/** 열쇠 보관 — 영어판. 이 PC 에서 실제로 쓰는 방식은 부르는 쪽이 넣어 준다. */
+export function keyStorageEn(이PC에서) {
+  return {
+    where: 'profiles[].apiKey in ~/.deel/config.json (or DEEL_HOME)',
+    onThisMachine: 이PC에서,
+    methods: [
+      { os: 'Windows', how: 'DPAPI ProtectedData (CurrentUser) - only this account on this machine can unseal it. Copying the file elsewhere does not help.' },
+      { os: 'macOS', how: 'Login keychain (security add-generic-password)' },
+      { os: 'Other', how: 'File mode 0600. There is no OS keystore, so we say so plainly.' },
+    ],
+    howItIsPassed: 'The key never appears on a command line - it is always passed over stdin, so another user on the same machine cannot read it from the process list.',
+    avoidTheFile: 'Set DEEL_API_KEY (or DEEL_KEY_<profile>) and nothing is written to the file at all. The environment variable wins over the file.',
+    disable: 'DEEL_KEYSTORE=off - no OS keystore, file permissions only.',
+  };
+}
+
+/** 감사기록 사양 — 영어판. */
+export function auditLogEn() {
+  return {
+    location: '<workdir>/.deel/audit.jsonl',
+    format: 'JSON Lines (UTF-8, one record per line)',
+    growth: 'Append only. Records are never edited or removed.',
+    retention: 'deel never deletes it. Set retention according to your own policy.',
+    everyLine: [
+      { field: 'at', meaning: 'When (ISO 8601, UTC)' },
+      { field: 'session', meaning: 'Which conversation - an id derived from the start time' },
+      { field: 'kind', meaning: 'Record type - see below' },
+    ],
+    kinds: [
+      { kind: 'turn', meaning: 'Something the user asked for', fields: ['text'], note: 'First 500 characters only' },
+      { kind: 'tool', meaning: 'A tool call', fields: ['tool', 'target', 'ok', 'note'], note: 'target is a file path, a command, or a search pattern' },
+      { kind: 'blocked', meaning: 'Something a safety check refused', fields: ['why', 'what'], note: 'The refused command is kept verbatim' },
+      { kind: 'undo', meaning: 'A rollback', fields: ['files', 'turns'] },
+    ],
+    neverRecorded: [
+      'Keys and passwords. Neither apiKey from the config nor a spreadsheet password reaches the log.',
+      'Whole file contents. What was touched is recorded; what was written is not.',
+      'Model replies. Those live in the session transcript (.deel/sessions) instead.',
+    ],
+  };
+}
+
+/** 사람이 읽을 짧은 요약 — 영어판. */
+export function specSummaryEn(m = {}) {
+  return [
+    `SBOM components  ${(m.files?.length ?? 0).toLocaleString()} (each with SHA-256)`,
+    `Dependencies     ${(m.dependencies?.dependencies?.length ?? 0)} - install scripts ${(m.dependencies?.installScripts?.length ?? 0)}`,
+    `Egress lanes     ${(m.egress?.lanes?.length ?? 0)} - listening ports ${(m.egress?.listeningPorts?.count ?? 0)}`,
+    `Audit records    ${(m.auditLog?.kinds?.length ?? 0)} kinds - ${m.auditLog?.location ?? ''}`,
+  ].join('\n');
+}

package/src/pack/tar.js

@@ -1,6 +1,7 @@
 // tar 읽기. GitHub 가 주는 tarball 을 풀기 위한 최소 구현.
 // git 이 없는 기기에서도 플러그인을 받을 수 있어야 해서 필요하다.
 import { gunzipSync } from 'node:zlib';
+import { resolve, sep } from 'node:path';
 
 const BLOCK = 512;
 
@@ -15,12 +16,43 @@ function octal(buf, off, len) {
   return s ? parseInt(s, 8) : 0;
 }
 
+/*
+ * ── 작게 받아서 크게 푸는 묶음(압축 폭탄) ───────────────────────────────
+ *
+ * 받는 쪽(plugins/manage.js)은 **압축된** 크기를 64MB 로 막는다. 그런데
+ * 0 으로만 채운 파일은 천 배 넘게 줄어든다 — 64MB 짜리 하나가 풀면 수십 GB 다.
+ * gunzipSync 는 그걸 통째로 메모리에 올리므로, 화면에는 아무 말도 안 남고
+ * 프로세스가 그대로 죽는다. 사용자가 보는 것은 「플러그인을 깔아 줘」 라고
+ * 시킨 뒤 deel 이 사라진 것뿐이다 — 하던 대화까지 같이.
+ *
+ * 그래서 **푼 크기**에도 상한을 둔다. 256MB 로 잡은 까닭은 받는 상한의 네 배라서다.
+ * 플러그인은 글과 스크립트 묶음이라 서너 배까지는 부푼다. 그보다 더 부푸는 것은
+ * 플러그인이 아니라 폭탄으로 본다.
+ */
+export const 푼것상한 = 256 * 1024 * 1024;
+
 /**
  * gzip 된 tar 를 풀어 파일 목록을 돌려준다.
+ * @param {Buffer} gz
+ * @param {object} o
+ * @param {number} o.상한 푼 크기 상한. 검사가 작은 값으로 부르려고 열어 뒀다 —
+ *   256MB 를 진짜로 만들어 재면 그 검사 하나가 기계를 잡아먹는다.
  * @returns {Array<{name:string, data:Buffer, mode:number}>}
  */
-export function untargz(gz) {
-  const buf = gunzipSync(gz);
+export function untargz(gz, { 상한 = 푼것상한 } = {}) {
+  let buf;
+  try {
+    buf = gunzipSync(gz, { maxOutputLength: 상한 });
+  } catch (err) {
+    // 조용히 죽는 대신 왜 안 되는지 말한다. 이 말은 install 이 그대로 화면에 올린다.
+    if (err?.code === 'ERR_BUFFER_TOO_LARGE') {
+      // MB 로만 적으면 작은 상한이 「0MB」 가 된다 — 사람에게 아무 말도 안 하는 숫자다.
+      const 상한말 = 상한 >= 1024 * 1024 ? `${Math.round(상한 / 1024 / 1024)}MB` : `${Math.round(상한 / 1024)}KB`;
+      throw new Error(`푼 크기가 상한(${상한말})을 넘습니다`
+        + ' — 압축만 작고 풀면 몇 GB 가 되는 묶음입니다. 저장소가 맞는지 확인하세요.');
+    }
+    throw err;
+  }
   const out = [];
   let pos = 0;
   let longName = null;
@@ -67,3 +99,34 @@ export function stripTop(files) {
   if (!files.every((f) => f.name.startsWith(first + '/'))) return files;
   return files.map((f) => ({ ...f, name: f.name.slice(first.length + 1) }));
 }
+
+/**
+ * 이 이름이 풀 폴더 **안쪽**을 가리키나.
+ *
+ * ── 왜 있어야 하나 ──────────────────────────────────────────────────────
+ *
+ * tar 안의 이름은 **남이 적은 글자**다. 우리가 만든 것이 아니다. 그걸 그대로
+ * join(dest, name) 에 넣으면 `../../../..` 하나로 폴더 밖에 파일을 쓴다.
+ * 받는 쪽이 mkdirSync(recursive) 까지 해 주므로 없는 폴더도 만들어 가며 나간다.
+ *
+ *   name: '../../../../윗동네에쓰기.txt'
+ *   dest: C:\Users\누군가\.deel\plugins\x
+ *   →    C:\Users\윗동네에쓰기.txt
+ *
+ * 이 프로그램이 파는 문장이 「작업 폴더 밖은 안 만진다」 인데, 플러그인을
+ * 받는 길에는 그 문장을 지키는 코드가 한 줄도 없었다. 여기서 막는다 —
+ * 푸는 자리마다 따로 적으면 언젠가 한 곳이 빠진다.
+ *
+ * 절대경로·드라이브 문자도 같이 걸린다. resolve 는 절대경로를 만나면 뿌리를
+ * 통째로 갈아 치우므로, 그 결과가 뿌리로 시작하지 않는다.
+ */
+export function 안쪽인가(뿌리, 이름) {
+  const 뿌리절대 = resolve(String(뿌리 ?? ''));
+  const 갈곳 = resolve(뿌리절대, String(이름 ?? ''));
+  return 갈곳 === 뿌리절대 || 갈곳.startsWith(뿌리절대 + sep);
+}
+
+/** 풀 폴더 밖을 가리키는 것만 골라 준다. 하나라도 있으면 그 묶음은 안 푼다. */
+export function 밖을가리키는것(뿌리, files) {
+  return (files ?? []).filter((f) => !안쪽인가(뿌리, f?.name));
+}

package/src/plugins/manage.js

@@ -9,7 +9,7 @@ import {
   existsSync, mkdirSync, writeFileSync, readFileSync, rmSync,
   readdirSync, statSync,
 } from 'node:fs';
-import { untargz, stripTop } from '../pack/tar.js';
+import { untargz, stripTop, 밖을가리키는것 } from '../pack/tar.js';
 import { makeZip } from '../pack/zip.js';
 import { allowTemporarily, isOffline, NetBlocked } from '../safety/network.js';
 import { 원시요청, 몸읽기 } from '../backend/http.js';
@@ -54,6 +54,45 @@ function run(cmd, args, opts = {}) {
   });
 }
 
+/**
+ * 받은 묶음을 폴더에 푼다.
+ *
+ * ── 왜 따로 떼어 놨나 ───────────────────────────────────────────────────
+ *
+ * 이 몇 줄이 **남이 준 글자로 디스크에 파일을 쓰는 자리**다. 이 프로그램에서
+ * 제일 조심해야 하는 대목인데, fetchInto 안에 묻혀 있어서 검사가 한 번도 안
+ * 지나갔다. 거기까지 가려면 진짜로 네트워크에서 tarball 을 받아야 했기 때문이다.
+ *
+ * 그래서 「받는 일」 과 「푸는 일」 을 갈랐다. 푸는 일은 이제 파일 목록만 주면
+ * 그대로 재 볼 수 있다 — 남이 노리고 만든 묶음을 먹여 보는 것을 포함해서.
+ *
+ * ── 무엇을 막나 ─────────────────────────────────────────────────────────
+ *
+ * tar 안의 이름은 남이 적은 글자다. `../../../..` 하나면 플러그인 폴더 밖에
+ * 파일을 쓴다. 아래 mkdirSync 가 recursive 라 없는 폴더까지 만들어 가며 나간다.
+ * 이 프로그램이 파는 문장이 「작업 폴더 밖은 안 만진다」 인데, 플러그인을 받는
+ * 이 길에만 그 문장을 지키는 코드가 없었다.
+ *
+ * 나쁜 것만 골라 버리지 않고 **묶음째 거절한다.** 밖을 가리키는 이름이 든
+ * 묶음은 실수가 아니라 노린 것이고, 나머지를 풀어 줄 까닭이 없다.
+ * 그리고 **rmSync 앞에서** 막는다 — 거절할 묶음 때문에 이미 깔린 것을
+ * 지워 버리면 안 된다.
+ */
+export function 묶음풀기(dest, files) {
+  if (!files?.length) return { error: '받은 묶음이 비어 있습니다' };
+  const 밖엣것 = 밖을가리키는것(dest, files);
+  if (밖엣것.length) {
+    return { error: `묶음 안에 플러그인 폴더 밖을 가리키는 이름이 있습니다 — 풀지 않았습니다: ${밖엣것[0].name}` };
+  }
+  rmSync(dest, { recursive: true, force: true });
+  for (const f of files) {
+    const p = join(dest, f.name);
+    mkdirSync(dirname(p), { recursive: true });
+    writeFileSync(p, f.data);
+  }
+  return { 푼것: files.length };
+}
+
 // 받는 방법 두 가지. git 이 있으면 clone, 없으면 tarball 을 내려받아 푼다.
 async function fetchInto(spec, dest, onStep) {
   if (await has('git')) {
@@ -96,14 +135,12 @@ async function fetchInto(spec, dest, onStep) {
       for (const 닫기 of 열어둔) 닫기();
     }
     if (!gz) return { error: '받은 묶음이 너무 큽니다 (64MB 넘음) — 플러그인 저장소가 맞는지 확인하세요' };
-    const files = stripTop(untargz(gz));
-    if (!files.length) return { error: '받은 묶음이 비어 있습니다' };
-    rmSync(dest, { recursive: true, force: true });
-    for (const f of files) {
-      const p = join(dest, f.name);
-      mkdirSync(dirname(p), { recursive: true });
-      writeFileSync(p, f.data);
-    }
+    // 받는 크기만 막으면 압축 폭탄에 그대로 당한다 (pack/tar.js 푼것상한 머리말).
+    // 던지는 것을 여기서 받아 화면에 올린다 — 안 받으면 명령이 통째로 죽는다.
+    let 푼것;
+    try { 푼것 = 묶음풀기(dest, stripTop(untargz(gz))); }
+    catch (err) { return { error: `받은 묶음을 풀지 못했습니다 — ${String(err?.message ?? err)}` }; }
+    if (푼것.error) return { error: 푼것.error };
     return { how: 'tarball', branch };
   }
   return { error: '받지 못했습니다 — 저장소 주소나 가지 이름을 확인하세요' };

package/src/providers/bedrock.js

@@ -57,6 +57,23 @@ export const 제공자 = {
       `https://bedrock-runtime.${r}.amazonaws.com/v1`,
       `https://bedrock-runtime.${r}.amazonaws.com/openai/v1`,
       `https://bedrock-mantle.${r}.api.aws/v1`,
+      /*
+       * mantle 의 **Anthropic Messages 창구**.
+       *
+       * 위 셋은 전부 OpenAI 호환 창구다. 그 길로 가면 캐시 표식을 붙일 자리가
+       * 없어서(backend/cachemark.js) 서버가 알아서 잡아 주는 앞머리 말고는
+       * 캐시가 안 걸린다 — 대화가 자랄수록 그만큼 매번 다시 나간다.
+       *
+       * 이 창구는 Anthropic 규격이라 표식을 정식으로 받는다. 생각도
+       * adaptive 로 켤 수 있다. 인증은 Bedrock API 키를 Bearer 로 준다
+       * (문서: inference-messages-api). 그래서 detect 가 이 주소에서는
+       * Bearer 도 같이 두드린다.
+       *
+       * **뒤에 둔다.** 앞의 셋으로 이미 잘 쓰고 있는 사람의 설치가 이 줄
+       * 하나로 다른 창구로 옮겨 가면 안 된다. 골라서 쓰고 싶은 사람은
+       * 주소를 직접 적으면 된다 (docs/ko/models.md).
+       */
+      `https://bedrock-mantle.${r}.api.aws/anthropic/v1`,
     ];
   },