deel-local-cli 0.5.0 → 0.9.0

package/src/backend/http.js

@@ -1,4 +1,8 @@
-// HTTP 한 겹. 시간 제한과 오류 정규화만 담당한다.
+// HTTP 한 겹. 시간 제한과 오류 정규화, 그리고 나가도 되는 곳인지 확인한다.
+//
+// 이 파일이 프로그램에서 바깥으로 나가는 유일한 문이다.
+// 나가기 전에 반드시 safety/network.js 의 문지기에게 물어본다.
+import { checkUrl, NetBlocked } from '../safety/network.js';
 
 export const AUTH_STYLES = [
   { id: 'bearer', label: 'Authorization: Bearer', apply: (h, k) => { h['Authorization'] = `Bearer ${k}`; } },
@@ -7,6 +11,29 @@ export const AUTH_STYLES = [
   { id: 'none', label: '인증 없음', apply: () => {} },
 ];
 
+/**
+ * 열어 둔 연결을 닫는다. 프로그램을 끝내기 직전에 부른다.
+ *
+ * fetch 는 연결을 재사용하려고 소켓을 살려 둔다(keep-alive). 그래서 할 일이
+ * 끝나도 프로세스가 저절로 안 끝난다. 예전에는 그걸 process.exit() 으로
+ * 잘라 냈는데, 윈도우에서 닫는 중인 핸들을 두고 끊으면 libuv 가 abort 한다.
+ *
+ *   Assertion failed: !(handle->flags & UV_HANDLE_CLOSING), src\win\async.c
+ *
+ * 실제로 `deel scan` 이 결과를 다 찍고 나서 이렇게 죽었다. 화면에는 정상으로
+ * 보이는데 종료코드는 3221226505(0xC0000409) 였다.
+ *
+ * 그래서 잘라 내는 대신 닫는다. 이 자리는 Node 내부 이름이라 없을 수도 있으므로,
+ * 없으면 조용히 넘어간다 — 그때는 부르는 쪽의 시간제한이 받아 준다.
+ */
+export function closeConnections() {
+  try {
+    const d = globalThis[Symbol.for('undici.globalDispatcher.1')];
+    if (d && typeof d.close === 'function') return d.close().catch(() => {});
+  } catch { /* 없으면 그만 */ }
+  return Promise.resolve();
+}
+
 export function headersFor(authStyle, key, extra = {}) {
   const h = { 'Content-Type': 'application/json', Accept: 'application/json', ...extra };
   const style = AUTH_STYLES.find((s) => s.id === authStyle) ?? AUTH_STYLES[0];
@@ -14,14 +41,19 @@ export function headersFor(authStyle, key, extra = {}) {
   return h;
 }
 
-export async function req(url, { method = 'GET', headers = {}, body, timeout = 20000, stream = false } = {}) {
+export async function req(url, { method = 'GET', headers = {}, body, timeout = 20000, stream = false, signal = null } = {}) {
   const started = Date.now();
   try {
+    checkUrl(url);   // 허용된 자리가 아니면 여기서 끝난다. 본문은 만들어지지도 않는다.
+    // 시간 초과와 '사용자가 Ctrl+C' 를 둘 다 듣는다. 둘 중 먼저 오는 쪽이 끊는다.
+    const sig = signal
+      ? (AbortSignal.any ? AbortSignal.any([AbortSignal.timeout(timeout), signal]) : signal)
+      : AbortSignal.timeout(timeout);
     const res = await fetch(url, {
       method,
       headers,
       body: body === undefined ? undefined : JSON.stringify(body),
-      signal: AbortSignal.timeout(timeout),
+      signal: sig,
       redirect: 'follow',
     });
     const ms = Date.now() - started;
@@ -33,10 +65,19 @@ export async function req(url, { method = 'GET', headers = {}, body, timeout = 2
     return { ok: res.ok, status: res.status, json, text, ms, headers: res.headers };
   } catch (err) {
     const ms = Date.now() - started;
+    // 막힌 것은 통신 실패와 다르다. 조용히 넘기면 자물쇠가 있는지도 모른다.
+    if (err instanceof NetBlocked) throw err;
+    // 사용자가 끊은 것도 실패가 아니다. 오류 화면을 띄우면 안 된다.
+    if (signal?.aborted) throw new Aborted();
     return { ok: false, status: 0, error: normalizeError(err), ms };
   }
 }
 
+// 사용자가 Ctrl+C 로 끊었다는 뜻. 통신 오류와 구분하려고 따로 둔다.
+export class Aborted extends Error {
+  constructor() { super('사용자가 중단했습니다'); this.name = 'Aborted'; }
+}
+
 function normalizeError(err) {
   const m = String(err?.message ?? err);
   if (err?.name === 'TimeoutError' || /timed? ?out/i.test(m)) return '시간 초과 — 응답이 없습니다';

package/src/backend/probe.js

@@ -5,6 +5,7 @@
 //   warn 되긴 하는데 조건이 붙음
 //   skip 앞 검사가 실패해 확인 불가
 import { req, headersFor, serverMessage } from './http.js';
+import { probeCtx } from './ctxsize.js';
 
 const READ_TOOL = {
   type: 'function',
@@ -146,7 +147,7 @@ export async function probe(conn, onStep = () => {}) {
     label: '시스템 메시지',
     status: sys.ok ? (sysHit ? 'ok' : 'warn') : 'no',
     detail: sys.ok
-      ? sysHit ? '지시를 따름' : '전달은 되나 모델이 잘 안 따름 — 규칙·스킬이 약하게 먹습니다'
+      ? sysHit ? '지시를 따름' : '전달은 되나 모델이 잘 안 따름 — 규칙·스킬이 약하게 적용됩니다'
       : serverMessage(sys),
     ms: sys.ms,
   });
@@ -330,26 +331,26 @@ export async function probe(conn, onStep = () => {}) {
   facts.think = differs;
 
   // 8. 컨텍스트 길이 — 파일을 몇 개까지 한 번에 읽힐 수 있느냐.
-  let ctx = null;
-  let ctxNote = '';
-  if (shape === 'ollama') {
-    const show = await req(`${base}/api/show`, { method: 'POST', headers: H(), body: { model }, timeout: 20000 });
-    const info = show.json?.model_info ?? {};
-    const k = Object.keys(info).find((x) => /context_length/.test(x));
-    if (k) { ctx = info[k]; ctxNote = '모델 정보에서 읽음'; }
-  } else {
-    const m = await req(`${base}/models/${encodeURIComponent(model)}`, { headers: H(), timeout: 15000 });
-    ctx = m.json?.context_window ?? m.json?.max_context_length ?? m.json?.context_length ?? null;
-    if (ctx) ctxNote = '모델 정보에서 읽음';
-  }
+  //
+  // 한 자리만 보지 않는다. 서버마다 이름도 자리도 다르다 (ctxsize.js 참고).
+  // 여기서 작게 잡으면 프로그램 전체가 작아진다 — 답 길이 상한까지 이 값에서 나온다.
+  const 길이 = await probeCtx({ kind: shape, base, auth, key, model });
+  const ctx = 길이.value;
   add({
     id: 'ctx',
     label: '컨텍스트 길이',
     status: ctx ? 'ok' : 'warn',
-    detail: ctx ? `${ctx.toLocaleString()} 토큰 (${ctxNote})` : '서버가 알려주지 않음 — 설정에서 직접 지정합니다',
+    detail: ctx
+      ? `${ctx.toLocaleString()} 토큰 (${길이.source ?? '모델 정보'}에서 읽음)`
+        + (길이.max && 길이.loaded && 길이.max > 길이.loaded
+          ? ` · 이 모델은 ${길이.max.toLocaleString()} 까지 되는데 지금 ${길이.loaded.toLocaleString()} 로 올려 두셨습니다`
+          : '')
+      : '서버가 알려주지 않음 — /ctx 로 직접 지정하세요',
     ms: 0,
   });
   facts.ctx = ctx;
+  facts.ctxMax = 길이.max ?? null;
+  facts.ctxLoaded = 길이.loaded ?? null;
 
   return { facts, results };
 }

package/src/backend/scan.js

@@ -0,0 +1,256 @@
+// 이 PC 에 떠 있는 로컬 모델 서버를 전부 찾는다.
+//
+// 로컬 런타임은 하나만 쓰지 않는다. Ollama 로 작은 모델을 돌리면서
+// LM Studio 로 큰 모델을 띄워 두는 식이 흔하다. 그래서 하나만 물어보지 않고
+// 알려진 자리를 한꺼번에 두드려서 있는 대로 다 등록해 둔다.
+//
+// 두드리는 곳은 전부 이 컴퓨터(127.0.0.1) 다. 바깥으로 나가지 않는다.
+import { execFileSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { req, headersFor } from './http.js';
+import { allowTemporarily } from '../safety/network.js';
+
+// 포트는 겹칠 수 있다(llama.cpp 와 LocalAI 가 둘 다 8080). 그래서 포트로 단정하지 않고
+// 응답을 보고 정한다. 아래 이름은 '그 포트에서 흔한 것' 이라는 힌트일 뿐이다.
+export const KNOWN = [
+  { port: 11434, hint: 'Ollama' },
+  { port: 1234, hint: 'LM Studio' },
+  { port: 8080, hint: 'llama.cpp · LocalAI' },
+  { port: 8000, hint: 'vLLM · SGLang' },
+  { port: 1337, hint: 'Jan' },
+  { port: 5001, hint: 'KoboldCpp' },
+  { port: 5000, hint: 'text-generation-webui · TabbyAPI' },
+  { port: 4891, hint: 'GPT4All' },
+  { port: 9997, hint: 'Xinference' },
+  { port: 11435, hint: 'Ollama (두 번째)' },
+  { port: 8081, hint: 'llama.cpp (두 번째)' },
+  { port: 3000, hint: 'Open WebUI · LiteLLM' },
+  { port: 4000, hint: 'LiteLLM' },
+];
+
+const fmtSize = (bytes) => {
+  if (!bytes) return '';
+  const gb = bytes / 1024 ** 3;
+  return gb >= 1 ? `${gb.toFixed(1)}GB` : `${Math.round(bytes / 1024 ** 2)}MB`;
+};
+
+/**
+ * 이 컴퓨터에서 실제로 듣고 있는 TCP 포트.
+ *
+ * 왜 필요한가:
+ *   알려진 자리 13곳만 두드리면, 직접 세운 프록시나 사내 게이트웨이를 못 찾는다.
+ *   그런 것들은 아무 포트나 쓴다. "안 잡히는데요" 의 대부분이 이 경우다.
+ *
+ *   그래서 운영체제에게 물어본다. 이미 열려 있는 걸 아는 포트라서 두드려도
+ *   기다릴 일이 없다 — 죽은 포트를 찍는 것보다 오히려 빠르다.
+ *
+ * 못 물어봐도 그냥 넘어간다. 알려진 자리 훑기는 그대로 되기 때문이다.
+ */
+export function listeningPorts({ timeout = 4000 } = {}) {
+  const 명령 = process.platform === 'win32'
+    ? { file: 'netstat.exe', args: ['-ano', '-p', 'TCP'] }
+    : process.platform === 'darwin'
+      ? { file: 'netstat', args: ['-an', '-p', 'tcp'] }
+      : { file: 'ss', args: ['-H', '-ltn'] };
+
+  let out = '';
+  try {
+    out = execFileSync(명령.file, 명령.args, { timeout, encoding: 'latin1', windowsHide: true, stdio: ['ignore', 'pipe', 'ignore'] });
+  } catch {
+    // 리눅스에 ss 가 없을 수 있다. 그때는 커널이 직접 알려주는 표를 읽는다.
+    if (process.platform === 'linux') return procNetTcp();
+    return [];
+  }
+
+  const 포트 = new Set();
+  for (const line of out.split(/\r?\n/)) {
+    if (!/LISTEN/i.test(line)) continue;
+    // 주소는 `0.0.0.0:8080` `[::]:8080` `*.8080` 중 하나로 온다.
+    const m = line.match(/[\s[](?:[\d.]+|::[\da-f:%]*|\*)[\]]?[:.](\d{1,5})\s/i)
+      ?? line.match(/:(\d{1,5})\s/);
+    const p = Number(m?.[1]);
+    if (p > 0 && p < 65536) 포트.add(p);
+  }
+  return [...포트].sort((a, b) => a - b);
+}
+
+function procNetTcp() {
+  const 포트 = new Set();
+  for (const f of ['/proc/net/tcp', '/proc/net/tcp6']) {
+    let text;
+    try { text = readFileSync(f, 'utf8'); } catch { continue; }
+    for (const line of text.split('\n').slice(1)) {
+      const col = line.trim().split(/\s+/);
+      if (col.length < 4) continue;
+      if (col[3] !== '0A') continue;              // 0A = LISTEN
+      const p = parseInt(col[1].split(':')[1], 16);
+      if (p > 0 && p < 65536) 포트.add(p);
+    }
+  }
+  return [...포트].sort((a, b) => a - b);
+}
+
+// 살아 있는지부터 짧게 본다. 죽은 포트에서 오래 기다리면 훑기가 하염없이 느려진다.
+async function probeOllama(origin, timeout) {
+  const v = await req(`${origin}/api/version`, { timeout });
+  if (!v.ok || !v.json?.version) return null;
+  const tags = await req(`${origin}/api/tags`, { timeout: timeout * 2 });
+  return {
+    kind: 'ollama',
+    runtime: 'Ollama',
+    version: v.json.version,
+    base: origin,
+    auth: 'none',
+    models: (tags.json?.models ?? []).map((m) => ({
+      id: m.name ?? m.model,
+      note: [m.details?.parameter_size, fmtSize(m.size)].filter(Boolean).join(' · '),
+    })),
+    ms: v.ms,
+  };
+}
+
+// OpenAI 호환 서버가 놓일 수 있는 자리들.
+//
+// 대부분은 `/v1` 이다. 그런데 사내 게이트웨이나 직접 세운 프록시는 앞에 뭔가를
+// 더 붙이는 경우가 많다 — 라우터 뒤에 붙이거나 여러 서비스를 한 포트에 모을 때
+// 그렇게 된다. 그래서 흔한 모양 몇 가지를 더 본다.
+// 죽은 포트에서는 첫 요청이 바로 실패하므로 훑는 시간에는 거의 영향이 없다.
+const BASES = ['/v1', '', '/api/v1', '/openai/v1', '/api', '/llm/v1', '/proxy/v1'];
+
+async function probeOpenAI(origin, timeout, key) {
+  for (const base of BASES.map((b) => `${origin}${b}`)) {
+    const r = await req(`${base}/models`, { headers: headersFor(key ? 'bearer' : 'none', key), timeout });
+    if (!r.ok || !r.json) {
+      // 규격은 맞는데 키가 없어 막힌 경우 — 서버가 있다는 사실은 알려 준다.
+      if (r.status === 401 || r.status === 403) {
+        return { kind: 'openai', runtime: null, base, auth: null, models: [], locked: true, ms: r.ms };
+      }
+      continue;
+    }
+    const list = r.json.data ?? r.json.models ?? [];
+    if (!Array.isArray(list)) continue;
+    return {
+      kind: 'openai',
+      runtime: null,
+      base,
+      auth: key ? 'bearer' : 'none',
+      models: list
+        .map((m) => (typeof m === 'string' ? { id: m } : { id: m.id ?? m.name ?? m.model, note: m.owned_by ?? '' }))
+        .filter((m) => m.id),
+      ms: r.ms,
+    };
+  }
+  return null;
+}
+
+// 어떤 런타임인지 티 나는 자국을 찾는다. 못 찾으면 포트 힌트로 적고 '추정' 이라고 밝힌다.
+async function fingerprint(origin, hit, timeout) {
+  if (hit.runtime) return hit.runtime;
+  const props = await req(`${origin}/props`, { timeout });          // llama.cpp
+  if (props.ok && props.json?.default_generation_settings) return 'llama.cpp';
+  const lms = await req(`${origin}/api/v0/models`, { timeout });    // LM Studio
+  if (lms.ok && Array.isArray(lms.json?.data)) return 'LM Studio';
+  const ver = await req(`${origin}/version`, { timeout });          // vLLM
+  if (ver.ok && ver.json?.version) return 'vLLM';
+  return null;
+}
+
+/**
+ * 이 PC 를 훑는다.
+ * @param {object} o
+ * @param {string} o.host      기본 127.0.0.1
+ * @param {number[]} o.ports   더 볼 포트
+ * @param {number} o.timeout   포트 하나당 기다릴 시간(ms)
+ * @param {(x)=>void} o.onFind 하나 찾을 때마다 알림
+ */
+export async function scanLocal({ host = '127.0.0.1', ports = [], timeout = 1200, key = '', onFind, listening = true, maxListening = 80 } = {}) {
+  const list = [...KNOWN];
+  for (const p of ports) if (!list.some((x) => x.port === p)) list.push({ port: p, hint: '직접 지정' });
+
+  // 이 컴퓨터에서 실제로 듣고 있는 포트도 같이 본다.
+  // 직접 세운 프록시는 알려진 자리에 없기 때문이다. 이 PC 안에서만 한다 —
+  // 남의 컴퓨터 포트를 훑는 것은 이 도구가 할 일이 아니다.
+  const 잘린것 = [];
+  if (listening && (host === '127.0.0.1' || host === 'localhost' || host === '::1')) {
+    const 열린것 = listeningPorts().filter((p) => !list.some((x) => x.port === p));
+    const 볼것 = 열린것.slice(0, maxListening);
+    if (열린것.length > 볼것.length) 잘린것.push(...열린것.slice(maxListening));
+    // 이름표는 '무엇인지' 를 적어야 한다. 어느 런타임인지 못 알아보면
+    // 규격만이라도 적어 준다 — '열려 있는 자리' 는 사용자에게 아무 정보가 아니다.
+    for (const p of 볼것) list.push({ port: p, hint: 'OpenAI 호환 서버' });
+  }
+
+  const jobs = list.map(async ({ port, hint }) => {
+    const origin = `http://${host}:${port}`;
+    // 훑는 동안만 그 자리를 연다. 끝나면 바로 닫아서 자물쇠를 원래대로 둔다.
+    const close = allowTemporarily(origin);
+    let hit;
+    let runtime;
+    try {
+      // 먼저 'HTTP 로 말은 하는가' 만 짧게 본다.
+      //
+      // 이게 없으면 열려 있지만 HTTP 가 아닌 자리(파일 공유, RPC 같은)에서
+      // 요청마다 시간 초과를 기다리게 된다. 자리 하나에 여러 길을 보므로
+      // 그 기다림이 곱해져서, 훑기가 몇 초가 아니라 몇 분이 된다.
+      //
+      // 상태 0 은 '아무 답도 못 받았다' 는 뜻이다. 연결이 거절됐거나,
+      // 열려 있어도 HTTP 로 답하지 않는 자리다. 둘 다 여기서 접는다.
+      const 인사 = await req(`${origin}/`, { timeout: Math.min(timeout, 800) });
+      if (인사.status === 0) return null;
+
+      hit = await probeOllama(origin, timeout);
+      if (!hit) hit = await probeOpenAI(origin, timeout, key);
+      if (!hit) return null;
+      runtime = await fingerprint(origin, hit, timeout);
+    } finally { close(); }
+    const found = {
+      ...hit,
+      port,
+      host,
+      runtime: runtime ?? hint,
+      guessed: !runtime && hit.kind !== 'ollama',
+      hint,
+    };
+    onFind?.(found);
+    return found;
+  });
+
+  const found = (await Promise.all(jobs)).filter(Boolean);
+  // 모델이 많은 쪽을 위로. 잠긴 것은 아래로.
+  found.sort((a, b) => (a.locked ? 1 : 0) - (b.locked ? 1 : 0) || b.models.length - a.models.length || a.port - b.port);
+  // 몇 자리를 안 봤는지 알려 준다. 조용히 자르면 '다 봤다' 로 읽힌다.
+  found.훑은자리 = list.length;
+  found.안본자리 = 잘린것;
+  return found;
+}
+
+// 찾은 것을 설정 프로필 모양으로 바꾼다. 같은 자리가 이미 있으면 그걸 되쓴다.
+export function toProfiles(found, existing = []) {
+  const out = [];
+  for (const f of found) {
+    for (const m of f.models.length ? f.models : [{ id: null }]) {
+      if (!m.id) continue;
+      const id = `${slugRuntime(f.runtime)}-${String(m.id).replace(/[^a-zA-Z0-9._-]+/g, '-')}`.slice(0, 60).toLowerCase();
+      const prev = existing.find((p) => p.baseUrl === f.base && p.model === m.id);
+      out.push({
+        id: prev?.id ?? id,
+        name: `${f.runtime} · ${m.id}`,
+        kind: f.kind,
+        baseUrl: f.base,
+        auth: f.auth ?? 'none',
+        model: m.id,
+        apiKey: prev?.apiKey ?? '',
+        ctx: prev?.ctx ?? null,
+        streaming: prev?.streaming ?? true,
+        tools: prev?.tools ?? false,
+        json: prev?.json ?? false,
+        think: prev?.think ?? false,
+        note: m.note ?? '',
+        local: true,
+      });
+    }
+  }
+  return out;
+}
+
+const slugRuntime = (r) => String(r ?? 'local').split(/[\s·]+/)[0].toLowerCase().replace(/[^a-z0-9]+/g, '');

package/src/backend/scanui.js

@@ -0,0 +1,147 @@
+// deel scan — 이 PC 의 로컬 모델 서버를 훑어 보여 주고, 원하면 전부 등록한다.
+import { c, say, rule, pad, mark, clip, width } from '../ui/ansi.js';
+import { pick } from '../ui/prompt.js';
+import { spin } from '../ui/spinner.js';
+import { scanLocal, toProfiles, KNOWN } from './scan.js';
+import { load, save, upsert } from '../config.js';
+
+// 코딩 에이전트로 쓰려면 도구 호출이 되어야 한다. 진단 전이라 확실히는 모르니,
+// 이름에 드러난 단서로 짐작해서 권한다. 틀릴 수 있다는 것을 문구에 밝힌다.
+const 도구잘함 = /(qwen|llama-?3|llama3|mistral|devstral|hermes|command-?r|firefunction|granite|gpt-?oss|glm|kimi|minimax|seed-?oss)/i;
+const 코딩 = /(cod(e|er|ing)|devstral|starcoder|deepseek|qwen.*cod|granite.*cod)/i;
+const 작음 = /(0\.5b|1\.5b|1b|2b|3b|tiny|mini|small)/i;
+
+function recommend(found) {
+  const all = [];
+  for (const f of found) for (const m of f.models) all.push({ ...f, model: m.id, note: m.note ?? '' });
+  if (!all.length) return null;
+
+  const 점수 = (x) => {
+    let s = 0;
+    if (코딩.test(x.model)) s += 3;
+    if (도구잘함.test(x.model)) s += 2;
+    if (!작음.test(x.model)) s += 1;          // 너무 작으면 도구 호출을 잘 못 한다
+    if (x.kind === 'ollama') s += 1;          // 규격이 확실히 확인된 쪽
+    return s;
+  };
+  const best = all.map((x) => ({ x, s: 점수(x) })).sort((a, b) => b.s - a.s)[0];
+  if (!best || best.s < 2) return null;
+
+  const 이유 = [];
+  if (코딩.test(best.x.model)) 이유.push('코딩용 모델');
+  if (도구잘함.test(best.x.model)) 이유.push('도구 호출을 잘하는 계열');
+  if (작음.test(best.x.model)) 이유.push(c.yellow('다만 작은 모델이라 도구 호출이 불안할 수 있습니다'));
+  이유.push(c.gray('실제로 되는지는 deel diagnose 로 확인하세요'));
+  return { ...best.x, why: 이유.join(' · ') };
+}
+
+export async function runScan(flags = {}) {
+  const host = flags.host ? String(flags.host) : '127.0.0.1';
+  const ports = String(flags.ports ?? '')
+    .split(/[,\s]+/).map((x) => parseInt(x, 10)).filter(Boolean);
+  const timeout = flags.timeout ? parseInt(String(flags.timeout), 10) : 1200;
+
+  say('');
+  rule('로컬 모델 서버 훑기', 74);
+  say(`  ${c.gray(`${host} 의 알려진 자리 ${KNOWN.length + ports.length}곳을 두드립니다. 바깥으로는 나가지 않습니다.`)}`);
+  say('');
+
+  const s = spin('찾는 중…');
+  const found = await scanLocal({ host, ports, timeout, key: flags.key ? String(flags.key) : '' });
+  s.stop(`  ${found.length ? mark.ok : mark.warn} ${found.length}곳 찾음`);
+  say('');
+
+  if (!found.length) {
+    say(`  ${c.gray('떠 있는 로컬 서버가 없습니다.')}`);
+    say('');
+    say(`  ${c.gray('확인해 볼 것')}`);
+    say(`    ${c.gray('· Ollama 를 켰나요?')}          ${c.cyan('ollama serve')}`);
+    say(`    ${c.gray('· LM Studio 의 로컬 서버를 켰나요?')} ${c.gray('(Developer → Start Server)')}`);
+    say(`    ${c.gray('· 다른 포트를 쓴다면')}          ${c.cyan('deel scan --ports 9000,9100')}`);
+    say('');
+    return 0;
+  }
+
+  // ── 찾은 것 표로 ─────────────────────────────────────────────────────
+  const wRun = Math.max(10, ...found.map((f) => width(f.runtime)));
+  for (const f of found) {
+    const 자리 = `${f.host}:${f.port}`;
+    const 규격 = f.kind === 'ollama' ? 'Ollama 규격' : 'OpenAI 호환';
+    const 표시 = f.guessed ? c.gray(' (추정)') : '';
+    say(`  ${c.hcyan('◆')} ${c.bold(pad(f.runtime, wRun))}${표시}  ${c.gray(pad(자리, 22))}${c.gray(pad(규격, 14))}${c.gray(f.ms + 'ms')}`);
+    if (f.locked) {
+      say(`      ${c.yellow('키가 필요합니다')} ${c.gray('— deel scan --key <키> 로 다시 훑어 보세요')}`);
+      continue;
+    }
+    if (!f.models.length) {
+      say(`      ${c.gray('모델이 하나도 없습니다 — 런타임에서 먼저 모델을 받아 두세요')}`);
+      continue;
+    }
+    for (const m of f.models.slice(0, 12)) {
+      say(`      ${c.gray('·')} ${pad(clip(m.id, 40), 42)}${c.gray(m.note ?? '')}`);
+    }
+    if (f.models.length > 12) say(`      ${c.gray(`… 그 밖에 ${f.models.length - 12}개`)}`);
+  }
+  say('');
+
+  const 모델수 = found.reduce((n, f) => n + f.models.length, 0);
+  say(`  ${c.gray('합계')}  서버 ${c.bold(String(found.length))}곳 · 모델 ${c.bold(String(모델수))}개`);
+  say('');
+
+  // ── 추천 ─────────────────────────────────────────────────────────────
+  // 도구 호출이 되는 모델이라야 코딩 에이전트로 쓸 수 있다. 이름으로 짐작해 권한다.
+  const 추천 = recommend(found);
+  if (추천) {
+    say(`  ${c.hgreen('추천')}  ${c.bold(추천.runtime)} ${c.gray('·')} ${c.bold(추천.model)}`);
+    say(`        ${c.gray(추천.why)}`);
+    say('');
+  }
+
+  // ── 등록 ─────────────────────────────────────────────────────────────
+  if (!flags.save && !flags.pick) {
+    say(`  ${c.gray('전부 등록하려면')}   ${c.cyan('deel scan --save')}`);
+    say(`  ${c.gray('골라서 등록하려면')} ${c.cyan('deel scan --pick')}`);
+    say(`  ${c.gray('등록 뒤에는 대화 중')} ${c.cyan('/model')} ${c.gray('로 바꿔 씁니다.')}`);
+    say('');
+    return 0;
+  }
+
+  const cfg = load();
+  let profiles = toProfiles(found, cfg.profiles);
+
+  // 골라 담기 — 사용자가 쓸 것만 등록한다.
+  if (flags.pick && profiles.length > 1) {
+    const items = profiles.map((p) => ({
+      label: `${pad(clip(p.name, 44), 46)}${c.gray(p.note ?? '')}`,
+      note: 추천 && p.model === 추천.model && p.baseUrl.includes(String(추천.port)) ? '추천' : '',
+    }));
+    const i = await pick('어느 것을 쓰시겠습니까', items, {
+      def: Math.max(0, profiles.findIndex((p) => 추천 && p.model === 추천.model)),
+    });
+    profiles = [profiles[i]];
+    cfg.active = null;   // 고른 것을 지금 쓰는 것으로
+  }
+  if (!profiles.length) {
+    say(`  ${mark.warn} 등록할 모델이 없습니다.`);
+    say('');
+    return 1;
+  }
+  let 새로 = 0;
+  for (const p of profiles) {
+    if (!cfg.profiles.some((x) => x.baseUrl === p.baseUrl && x.model === p.model)) 새로++;
+    upsert(cfg, p);
+  }
+  if (!cfg.active) cfg.active = profiles[0].id;
+  const at = save(cfg);
+
+  say(`  ${mark.ok} ${profiles.length}개 등록 ${c.gray(`(새로 ${새로}개)`)}`);
+  say(`     ${c.gray(at)}`);
+  say('');
+  say(`  ${c.gray('지금 쓰는 것')}  ${c.bold(cfg.profiles.find((x) => x.id === cfg.active)?.name ?? cfg.active)}`);
+  say(`  ${c.gray('바꾸려면 대화 중')} ${c.cyan('/model')}`);
+  say('');
+  say(`  ${c.gray('도구 호출·스트리밍이 되는지는 아직 확인 전입니다.')}`);
+  say(`  ${c.gray('쓸 모델을 고른 뒤')} ${c.cyan('deel diagnose')} ${c.gray('를 한 번 돌리세요.')}`);
+  say('');
+  return 0;
+}