deel-local-cli 0.5.0 → 0.8.0

package/src/agent/store.js

@@ -0,0 +1,193 @@
+// 대화를 파일에 남겨 두고, 껐다 켜도 이어서 하게 한다.
+//
+// 왜 필요한가:
+//   터미널을 실수로 닫거나, 컴퓨터가 재부팅되거나, 긴 작업 중 자리를 뜨는 일은 늘 있다.
+//   그때 대화가 통째로 날아가면 모델이 알아낸 것·정한 것이 전부 사라진다.
+//   다시 설명하는 비용이 실제 작업보다 큰 경우도 많다.
+//
+// 어디에 두나:
+//   작업 폴더의 .deel/sessions/<id>.jsonl — 그 폴더의 일은 그 폴더에 남긴다.
+//   .gitignore 에 .deel/ 이 들어 있어 깃에 올라가지 않는다.
+//
+// 왜 jsonl 인가:
+//   한 줄에 한 메시지씩 이어 붙이기만 하면 된다. 도중에 프로그램이 죽어도
+//   마지막 줄까지는 성하다. 통째로 다시 쓰는 방식이면 그 순간 파일이 깨진다.
+import {
+  existsSync, mkdirSync, readdirSync, readFileSync,
+  appendFileSync, writeFileSync, statSync, rmSync,
+} from 'node:fs';
+import { join } from 'node:path';
+
+export const sessionsDir = (root) => join(root, '.deel', 'sessions');
+
+// 사람이 읽을 수 있고 정렬하면 시간순인 id.
+export function newId(at = new Date()) {
+  const p = (n, w = 2) => String(n).padStart(w, '0');
+  return `${at.getFullYear()}${p(at.getMonth() + 1)}${p(at.getDate())}`
+    + `-${p(at.getHours())}${p(at.getMinutes())}${p(at.getSeconds())}`;
+}
+
+/**
+ * 아직 안 쓰인 id 를 고른다.
+ *
+ * id 가 초 단위라서, 창을 두 개 거의 동시에 열면 같은 id 가 나온다.
+ * 그러면 서로 다른 두 대화가 한 파일에 섞여 들어가고 되살릴 때 뒤엉킨다.
+ * 이미 있는 이름이면 뒤에 번호를 붙여 피한다.
+ */
+export function freeId(dir, at = new Date()) {
+  const base = newId(at);
+  if (!existsSync(join(dir, `${base}.jsonl`))) return base;
+  for (let n = 2; n < 1000; n++) {
+    const id = `${base}-${n}`;
+    if (!existsSync(join(dir, `${id}.jsonl`))) return id;
+  }
+  return `${base}-${process.pid}`;
+}
+
+export class Store {
+  constructor(root, id = null) {
+    this.root = root;
+    this.dir = sessionsDir(root);
+    this.auto = id == null;      // 우리가 지은 이름인가 (그러면 겹칠 때 바꿔도 된다)
+    this.#use(id ?? freeId(this.dir));
+    this.opened = false;
+  }
+
+  #use(id) {
+    this.id = id;
+    this.file = join(this.dir, `${id}.jsonl`);
+  }
+
+  #open() {
+    if (this.opened) return;
+    mkdirSync(this.dir, { recursive: true });
+    this.opened = true;
+  }
+
+  /**
+   * 첫 줄은 머리글 — 어떤 모델·어떤 폴더에서 한 대화인지.
+   *
+   * 'wx' 로 만든다: 이미 있으면 실패한다. 이름을 확인하고 만드는 사이에
+   * 다른 창이 같은 이름을 채 갔을 수 있어서, 그때는 다른 이름으로 옮겨 간다.
+   * 사용자가 --resume 으로 이름을 준 경우에는 옮기지 않고 그 파일에 이어 쓴다.
+   */
+  begin(meta) {
+    this.#open();
+    const head = JSON.stringify({ t: 'meta', at: new Date().toISOString(), ...meta }) + '\n';
+    for (let tries = 0; tries < 50; tries++) {
+      try {
+        writeFileSync(this.file, head, { encoding: 'utf8', flag: 'wx' });
+        return this;
+      } catch (err) {
+        if (err?.code !== 'EEXIST') return this;   // 못 적어도 대화는 계속돼야 한다
+        if (!this.auto) return this;               // 이어쓰기 — 이미 있는 게 맞다
+        this.#use(freeId(this.dir));               // 누가 채 갔다. 옆자리로.
+      }
+    }
+    return this;
+  }
+
+  #write(obj) {
+    try { appendFileSync(this.file, JSON.stringify(obj) + '\n', 'utf8'); }
+    catch { /* 기록에 실패해도 대화는 계속돼야 한다 */ }
+  }
+
+  // 메시지 하나를 덧붙인다. 대화가 진행되는 대로 즉시 남긴다.
+  append(msg) {
+    this.#open();
+    this.#write({ t: 'msg', m: msg });
+  }
+
+  // 압축이 일어나면 이력이 통째로 바뀐다. 그때는 새로 적는다.
+  replace(messages, note = '압축') {
+    this.#open();
+    const meta = this.readMeta() ?? {};
+    const lines = [JSON.stringify({ t: 'meta', at: new Date().toISOString(), ...meta })];
+    lines.push(JSON.stringify({ t: 'note', at: new Date().toISOString(), note }));
+    for (const m of messages) lines.push(JSON.stringify({ t: 'msg', m }));
+    try { writeFileSync(this.file, lines.join('\n') + '\n', 'utf8'); } catch {}
+  }
+
+  readMeta() {
+    if (!existsSync(this.file)) return null;
+    try {
+      const first = readFileSync(this.file, 'utf8').split('\n', 1)[0];
+      const j = JSON.parse(first);
+      return j.t === 'meta' ? j : null;
+    } catch { return null; }
+  }
+
+  // 저장된 대화를 읽어 온다. 깨진 줄은 건너뛴다 — 도중에 죽었을 수 있다.
+  load() {
+    if (!existsSync(this.file)) return { meta: null, messages: [] };
+    let meta = null;
+    const messages = [];
+    for (const line of readFileSync(this.file, 'utf8').split('\n')) {
+      if (!line.trim()) continue;
+      let j;
+      try { j = JSON.parse(line); } catch { continue; }
+      if (j.t === 'meta') meta = j;
+      else if (j.t === 'msg' && j.m) messages.push(j.m);
+    }
+    return { meta, messages };
+  }
+}
+
+// 사람에게 보여줄 첫 마디. 이게 목록에서 대화를 알아보는 유일한 단서다.
+function firstAsk(messages) {
+  const m = messages.find((x) => x.role === 'user' && typeof x.content === 'string'
+    && x.content.trim() && !x.content.startsWith('['));
+  return m ? m.content.replace(/\s+/g, ' ').trim() : '(빈 대화)';
+}
+
+/**
+ * 이 폴더에 남아 있는 대화 목록. 최근 것이 위로.
+ */
+export function list(root, { limit = 20 } = {}) {
+  const dir = sessionsDir(root);
+  if (!existsSync(dir)) return [];
+  const out = [];
+  for (const name of readdirSync(dir)) {
+    if (!name.endsWith('.jsonl')) continue;
+    const id = name.slice(0, -6);
+    const file = join(dir, name);
+    let st;
+    try { st = statSync(file); } catch { continue; }
+    const { meta, messages } = new Store(root, id).load();
+    if (!messages.length) continue;
+    out.push({
+      id,
+      file,
+      at: st.mtime,
+      bytes: st.size,
+      model: meta?.model ?? '?',
+      turns: messages.filter((m) => m.role === 'user').length,
+      messages: messages.length,
+      first: firstAsk(messages),
+    });
+  }
+  return out.sort((a, b) => b.at - a.at).slice(0, limit);
+}
+
+export function remove(root, id) {
+  const f = join(sessionsDir(root), `${id}.jsonl`);
+  if (!existsSync(f)) return { error: `그런 대화가 없습니다: ${id}` };
+  rmSync(f, { force: true });
+  return { removed: id };
+}
+
+/** 가장 최근 대화. --continue 가 집어 오는 것. */
+export function latest(root) {
+  return list(root, { limit: 1 })[0] ?? null;
+}
+
+/**
+ * 오래된 것은 정리한다. 안 그러면 폴더가 끝없이 자란다.
+ * 최근 keep 개는 무조건 남기고, 그보다 오래되고 days 를 넘긴 것만 지운다.
+ */
+export function prune(root, { keep = 30, days = 30 } = {}) {
+  const all = list(root, { limit: 1000 });
+  const 자를것 = all.slice(keep).filter((s) => (Date.now() - s.at.getTime()) > days * 86400000);
+  for (const s of 자를것) { try { rmSync(s.file, { force: true }); } catch {} }
+  return 자를것.length;
+}

package/src/backend/adapter.js

@@ -1,6 +1,6 @@
 // 규격 차이(OpenAI 호환 / Ollama)를 여기 한 곳에서만 흡수한다.
 // 진단(probe)과 에이전트 루프가 같은 함수를 쓴다.
-import { req, headersFor, serverMessage } from './http.js';
+import { req, headersFor, serverMessage, Aborted } from './http.js';
 
 export function endpoint(shape) {
   return shape === 'ollama' ? '/api/chat' : '/chat/completions';
@@ -88,6 +88,7 @@ export async function chat(conn, opts) {
     headers: headersFor(conn.auth, conn.key ?? ''),
     body,
     timeout: opts.timeout ?? 300000,
+    signal: opts.signal ?? null,
   });
   if (!r.ok) throw new Error(serverMessage(r));
   return extractMessage(conn.kind, r.json);
@@ -102,6 +103,7 @@ export async function* chatStream(conn, opts) {
     body,
     timeout: opts.timeout ?? 300000,
     stream: true,
+    signal: opts.signal ?? null,
   });
   if (!r.ok || !r.res?.body) throw new Error(r.error ?? `HTTP ${r.status}`);
 
@@ -111,7 +113,15 @@ export async function* chatStream(conn, opts) {
   let buf = '';
 
   while (true) {
-    const { done, value } = await reader.read();
+    // 사용자가 끊었으면 흘러오는 것을 더 받지 않는다. 읽던 연결도 닫는다.
+    if (opts.signal?.aborted) {
+      try { await reader.cancel(); } catch {}
+      throw new Aborted();
+    }
+    let done;
+    let value;
+    try { ({ done, value } = await reader.read()); }
+    catch (err) { if (opts.signal?.aborted) throw new Aborted(); throw err; }
     if (done) break;
     buf += dec.decode(value, { stream: true });
 

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}`; } },
@@ -14,14 +18,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 +42,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/scan.js

@@ -0,0 +1,162 @@
+// 이 PC 에 떠 있는 로컬 모델 서버를 전부 찾는다.
+//
+// 로컬 런타임은 하나만 쓰지 않는다. Ollama 로 작은 모델을 돌리면서
+// LM Studio 로 큰 모델을 띄워 두는 식이 흔하다. 그래서 하나만 물어보지 않고
+// 알려진 자리를 한꺼번에 두드려서 있는 대로 다 등록해 둔다.
+//
+// 두드리는 곳은 전부 이 컴퓨터(127.0.0.1) 다. 바깥으로 나가지 않는다.
+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`;
+};
+
+// 살아 있는지부터 짧게 본다. 죽은 포트에서 오래 기다리면 훑기가 하염없이 느려진다.
+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,
+  };
+}
+
+async function probeOpenAI(origin, timeout, key) {
+  for (const base of [`${origin}/v1`, origin]) {
+    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 } = {}) {
+  const list = [...KNOWN];
+  for (const p of ports) if (!list.some((x) => x.port === p)) list.push({ port: p, hint: '직접 지정' });
+
+  const jobs = list.map(async ({ port, hint }) => {
+    const origin = `http://${host}:${port}`;
+    // 훑는 동안만 그 자리를 연다. 끝나면 바로 닫아서 자물쇠를 원래대로 둔다.
+    const close = allowTemporarily(origin);
+    let hit;
+    let runtime;
+    try {
+      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);
+  // 모델이 많은 쪽을 위로. 잠긴 것은 아래로.
+  return found.sort((a, b) => (a.locked ? 1 : 0) - (b.locked ? 1 : 0) || b.models.length - a.models.length || a.port - b.port);
+}
+
+// 찾은 것을 설정 프로필 모양으로 바꾼다. 같은 자리가 이미 있으면 그걸 되쓴다.
+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;
+}