deel-local-cli 0.5.0

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "deel-local-cli",
+  "version": "0.5.0",
+  "description": "로컬 모델·사내 게이트웨이 전용 코딩 에이전트 CLI — 외부 의존성 0개 / Zero-dependency coding agent CLI for local LLMs and private gateways",
+  "type": "module",
+  "license": "MIT",
+  "bin": {
+    "deel": "bin/deel.js"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md",
+    "README.en.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "cli",
+    "coding-agent",
+    "local-llm",
+    "ollama",
+    "lm-studio",
+    "openai-compatible",
+    "offline",
+    "air-gapped",
+    "zero-dependency",
+    "agent"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jysvai/deel-local-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/jysvai/deel-local-cli/issues"
+  },
+  "homepage": "https://github.com/jysvai/deel-local-cli#readme",
+  "scripts": {
+    "start": "node bin/deel.js",
+    "setup": "node bin/deel.js setup",
+    "diagnose": "node bin/deel.js diagnose",
+    "chat": "node bin/deel.js",
+    "test": "node test/smoke.js && node test/loop.test.js && node test/edit-bench.js",
+    "bench": "node test/edit-bench.js",
+    "demo": "node test/demo.js",
+    "check": "node --check bin/deel.js && node --check src/repl.js && node --check src/commands.js && node --check src/agent/loop.js && node --check src/agent/session.js && node --check src/backend/adapter.js && node --check src/tools/index.js && node --check src/tools/fsutil.js && node --check src/tools/edit-match.js && node --check src/skills/discover.js && node --check src/safety/guard.js && node --check src/safety/undo.js && node --check src/safety/audit.js && node --check src/setup.js && node --check src/report.js && node --check src/config.js && node --check src/backend/probe.js && node --check src/backend/detect.js && node --check src/backend/http.js && node --check src/ui/ansi.js && node --check src/ui/prompt.js && node --check src/ui/spinner.js && echo OK"
+  },
+  "dependencies": {},
+  "devDependencies": {}
+}

package/src/agent/loop.js

@@ -0,0 +1,125 @@
+// 에이전트 루프. 모델 → 도구 → 결과 → 모델 을 답이 나올 때까지 돈다.
+// 화면에 그릴 것은 이벤트로 흘려보낸다 — 화면 코드와 섞지 않는다.
+import { chat, chatStream, assistantMessage, toolMessage } from '../backend/adapter.js';
+import { toolSchemas, runTool, TOOLS } from '../tools/index.js';
+import { isMutating } from '../safety/guard.js';
+
+// think 값을 규격에 맞게. 'off' 는 사고를 끈다.
+function thinkFor(conn, level) {
+  if (level === 'off') return conn.kind === 'ollama' ? false : undefined;
+  return level;
+}
+
+export async function* run(session, ctx, userText) {
+  session.push({ role: 'user', content: userText });
+  ctx.audit.turn(userText);
+  ctx.history.nextTurn();
+
+  const conn = session.conn;
+  const tools = toolSchemas(null, { hasSkills: (session.skills?.length ?? 0) > 0 });
+  const attempted = new Set();   // 같은 변경성 명령을 두 번 실행하지 않기 위한 기록
+  let steps = 0;
+
+  while (steps < session.maxSteps) {
+    steps++;
+    const opts = {
+      messages: session.wire(),
+      tools,
+      think: thinkFor(conn, session.think),
+      maxTokens: 4096,
+    };
+
+    let msg;
+    try {
+      if (conn.streaming) {
+        for await (const ev of chatStream(conn, opts)) {
+          if (ev.type === 'done') msg = ev.message;
+          else yield ev;
+        }
+      } else {
+        yield { type: 'waiting' };
+        msg = await chat(conn, opts);
+        if (msg.thinking) yield { type: 'thinking', text: msg.thinking };
+        if (msg.content) yield { type: 'content', text: msg.content };
+      }
+    } catch (err) {
+      yield { type: 'error', text: err.message };
+      return;
+    }
+
+    session.usage.in += msg.usage?.in ?? 0;
+    session.usage.out += msg.usage?.out ?? 0;
+    session.usage.calls++;
+
+    session.push(assistantMessage(conn.kind, msg));
+
+    if (!msg.toolCalls?.length) {
+      yield { type: 'done', steps, text: msg.content };
+      return;
+    }
+
+    // 도구를 순서대로 실행한다.
+    for (const call of msg.toolCalls) {
+      if (!TOOLS[call.name]) {
+        session.push(toolMessage(conn.kind, {
+          callId: call.id, name: call.name,
+          content: `모르는 도구입니다. 쓸 수 있는 것: ${Object.keys(TOOLS).join(', ')}`,
+        }));
+        yield { type: 'tool', name: call.name, args: call.args, result: { error: '모르는 도구' } };
+        continue;
+      }
+
+      // 변경성 명령은 실패해도 다시 실행하지 않는다 — 두 번 돌면 사고다.
+      if (call.name === 'Bash' && isMutating(call.args?.command)) {
+        const key = String(call.args.command).trim();
+        if (attempted.has(key)) {
+          const note = '같은 변경성 명령을 다시 실행하지 않습니다. 두 번 실행되면 사고가 납니다.';
+          session.push(toolMessage(conn.kind, { callId: call.id, name: call.name, content: note }));
+          yield { type: 'tool', name: call.name, args: call.args, result: { error: note } };
+          continue;
+        }
+        attempted.add(key);
+      }
+
+      // 모드에 따라 물어본다. 기본(auto)은 안 묻고 되돌리기로 대응한다.
+      const needsOk = session.mode === 'strict'
+        ? ['Write', 'Edit', 'Bash'].includes(call.name)
+        : session.mode === 'confirm'
+          ? (call.name === 'Bash' && isMutating(call.args?.command))
+          : false;
+      if (needsOk && ctx.confirm) {
+        const ok = await ctx.confirm(call.name, call.args);
+        if (!ok) {
+          const note = '사용자가 거부했습니다. 다른 방법을 찾거나 이유를 물어보세요.';
+          session.push(toolMessage(conn.kind, { callId: call.id, name: call.name, content: note }));
+          yield { type: 'tool', name: call.name, args: call.args, result: { error: '거부됨' } };
+          continue;
+        }
+      }
+
+      yield { type: 'tool_start', name: call.name, args: call.args };
+      const t0 = Date.now();
+      const result = await runTool(call.name, call.args, ctx);
+      const ms = Date.now() - t0;
+      session.usage.ms += ms;
+
+      if (call.name === 'Read' && result.content) session.noteRead(call.args.file_path, result.content);
+
+      session.push(toolMessage(conn.kind, {
+        callId: call.id,
+        name: call.name,
+        content: result.error ? `오류: ${result.error}` : result.content ?? '',
+      }));
+      yield { type: 'tool', name: call.name, args: call.args, result, ms };
+    }
+
+    // 컨텍스트가 차오르면 오래된 대화를 줄인다.
+    const b = session.breakdown();
+    if (b.used > b.total * 0.8) {
+      const dropped = session.trim();
+      if (dropped) yield { type: 'trimmed', dropped };
+    }
+  }
+
+  yield { type: 'limit', steps };
+}

package/src/agent/session.js

@@ -0,0 +1,136 @@
+// 대화 상태와 컨텍스트 셈. /context 가 보여주는 숫자가 여기서 나온다.
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+// 토큰 추정 — 정확한 토크나이저 없이 대략만 센다.
+// 한글은 글자당 약 1토큰, 영문·코드는 약 4글자당 1토큰으로 본다.
+export function estimateTokens(text) {
+  const s = String(text ?? '');
+  let cjk = 0;
+  for (const ch of s) {
+    const cp = ch.codePointAt(0);
+    if ((cp >= 0xac00 && cp <= 0xd7a3) || (cp >= 0x3040 && cp <= 0x30ff) || (cp >= 0x4e00 && cp <= 0x9fff)) cjk++;
+  }
+  const rest = s.length - cjk;
+  return Math.ceil(cjk + rest / 3.6);
+}
+
+const BASE_RULES = `너는 deel 다. 사용자의 작업 폴더 안에서 코드를 읽고 고치는 도구다.
+
+원칙:
+- 추측하지 말고 도구로 확인한다. 파일을 고치기 전에는 반드시 Read 로 읽는다.
+- Edit 의 old_string 은 공백과 들여쓰기까지 파일과 정확히 같아야 한다. 짧게 자르지 말고 앞뒤로 넉넉히 포함한다.
+- 한 번에 하나씩 고치고, 고친 뒤에는 무엇을 왜 고쳤는지 한 줄로 말한다.
+- 명령 실행이 필요하면 Bash 를 쓴다. 되돌릴 수 없는 명령은 막히니 다른 방법을 찾는다.
+- 사용자에게 답할 때는 한국어로, 짧게. 코드를 통째로 붙여넣지 말고 무엇이 달라졌는지 말한다.`;
+
+export class Session {
+  constructor(conn, { root, mode = 'auto', think = 'medium', maxSteps = 24 } = {}) {
+    this.conn = conn;
+    this.root = root;
+    this.mode = mode;
+    this.think = think;
+    this.maxSteps = maxSteps;
+    this.messages = [];
+    this.filesRead = new Map();   // 경로 → 추정 토큰
+    this.skills = [];             // 켜질 때 이 PC 에서 찾은 것들
+    this.commands = [];
+    this.plugins = [];
+    this.maxSkillsListed = 40;    // 프롬프트에 올릴 최대 개수
+    this.maxSkillDesc = 140;      // 설명 한 줄 최대 길이
+    this.usage = { in: 0, out: 0, calls: 0, ms: 0 };
+    this.startedAt = Date.now();
+    this.rules = this.#loadRules();
+  }
+
+  #loadRules() {
+    for (const name of ['DEEL.md', 'CLAUDE.md', 'AGENTS.md']) {
+      const p = join(this.root, name);
+      if (existsSync(p)) {
+        try { return { name, text: readFileSync(p, 'utf8').slice(0, 20000) }; } catch {}
+      }
+    }
+    return null;
+  }
+
+  systemPrompt() {
+    const parts = [BASE_RULES];
+    parts.push(`\n작업 폴더: ${this.root}\n이 폴더 밖의 파일은 읽지도 쓰지도 못한다.`);
+    if (this.rules) parts.push(`\n--- ${this.rules.name} (사용자 규칙, 위 원칙보다 우선) ---\n${this.rules.text}`);
+    const listed = this.listedSkills();
+    if (listed.length) {
+      parts.push(
+        '\n--- 쓸 수 있는 스킬 ---\n' +
+        '필요한 것이 있으면 Skill 도구로 이름을 불러 본문을 받아라. 없으면 그냥 진행해라.\n' +
+        listed.map((s) => `- ${s.name}: ${s.description.slice(0, this.maxSkillDesc)}`).join('\n')
+      );
+      const rest = this.skills.filter((s) => s.enabled).length - listed.length;
+      if (rest > 0) parts.push(`(그 밖에 ${rest}개가 더 있으나 자리가 모자라 안 실었다.)`);
+    }
+    return parts.join('\n');
+  }
+
+  // 프롬프트에 실제로 올릴 스킬: 가까운 자리(프로젝트 > 사용자 > 플러그인) 순으로 상한까지.
+  listedSkills() {
+    const rank = { project: 0, user: 1, plugin: 2 };
+    return this.skills
+      .filter((s) => s.enabled)
+      .slice()
+      .sort((a, b) => (rank[a.source] ?? 3) - (rank[b.source] ?? 3))
+      .slice(0, this.maxSkillsListed);
+  }
+
+  push(msg) { this.messages.push(msg); return this; }
+  clear() { this.messages = []; this.filesRead.clear(); return this; }
+
+  noteRead(path, text) { this.filesRead.set(path, estimateTokens(text)); }
+
+  // 모델에 실제로 보낼 배열.
+  wire() {
+    return [{ role: 'system', content: this.systemPrompt() }, ...this.messages];
+  }
+
+  // /context 가 그릴 내역.
+  breakdown() {
+    const sys = estimateTokens(BASE_RULES) + estimateTokens(`작업 폴더: ${this.root}`);
+    const rules = this.rules ? estimateTokens(this.rules.text) : 0;
+    const listed = this.listedSkills();
+    const skills = listed.length
+      ? estimateTokens(listed.map((s) => `${s.name}: ${s.description.slice(0, this.maxSkillDesc)}`).join('\n'))
+      : 0;
+
+    let history = 0;
+    let files = 0;
+    for (const m of this.messages) {
+      const t = estimateTokens(typeof m.content === 'string' ? m.content : JSON.stringify(m.content ?? ''))
+        + estimateTokens(JSON.stringify(m.tool_calls ?? ''));
+      if (m.role === 'tool') files += t; else history += t;
+    }
+
+    const rows = [
+      { label: '시스템 프롬프트', n: sys },
+      { label: this.rules ? `규칙 (${this.rules.name})` : '규칙 (없음)', n: rules },
+      { label: `스킬 목록 (${listed.length}/${this.skills.length}개)`, n: skills },
+      { label: '대화 이력', n: history },
+      { label: `도구 결과 (파일 ${this.filesRead.size}개)`, n: files },
+    ];
+    const used = rows.reduce((a, r) => a + r.n, 0);
+    const total = this.conn.ctx ?? 32768;
+    return { rows, used, total, left: Math.max(0, total - used) };
+  }
+
+  // 오래된 대화를 잘라낸다. 앞의 2턴과 최근 절반만 남긴다.
+  trim() {
+    if (this.messages.length < 12) return 0;
+    const keepHead = 2;
+    const keepTail = Math.floor(this.messages.length / 2);
+    const dropped = this.messages.length - keepHead - keepTail;
+    if (dropped <= 0) return 0;
+    this.messages = [
+      ...this.messages.slice(0, keepHead),
+      { role: 'user', content: `(앞선 대화 ${dropped}개를 줄였습니다. 필요하면 파일을 다시 읽으세요.)` },
+      ...this.messages.slice(-keepTail),
+    ];
+    return dropped;
+  }
+}

package/src/backend/adapter.js

@@ -0,0 +1,173 @@
+// 규격 차이(OpenAI 호환 / Ollama)를 여기 한 곳에서만 흡수한다.
+// 진단(probe)과 에이전트 루프가 같은 함수를 쓴다.
+import { req, headersFor, serverMessage } from './http.js';
+
+export function endpoint(shape) {
+  return shape === 'ollama' ? '/api/chat' : '/chat/completions';
+}
+
+export function buildBody(shape, { model, messages, tools, stream, json, think, maxTokens = 4096 }) {
+  if (shape === 'ollama') {
+    const body = { model, messages, stream: !!stream, options: { num_predict: maxTokens } };
+    if (tools?.length) body.tools = tools;
+    if (json) body.format = json;
+    if (think !== undefined) body.think = think;
+    return body;
+  }
+  const body = { model, messages, stream: !!stream, max_tokens: maxTokens };
+  if (tools?.length) { body.tools = tools; body.tool_choice = 'auto'; }
+  if (json) {
+    body.response_format = { type: 'json_schema', json_schema: { name: 'out', schema: json, strict: true } };
+  }
+  if (think !== undefined && think !== false) body.reasoning_effort = think;
+  return body;
+}
+
+export function extractMessage(shape, json) {
+  if (shape === 'ollama') {
+    const m = json?.message ?? {};
+    return {
+      content: m.content ?? '',
+      thinking: m.thinking ?? '',
+      toolCalls: normalizeCalls(m.tool_calls ?? []),
+      usage: { in: json?.prompt_eval_count ?? 0, out: json?.eval_count ?? 0 },
+      stopped: json?.done_reason ?? null,
+    };
+  }
+  const m = json?.choices?.[0]?.message ?? {};
+  return {
+    content: m.content ?? '',
+    thinking: m.reasoning_content ?? '',
+    toolCalls: normalizeCalls(m.tool_calls ?? []),
+    usage: { in: json?.usage?.prompt_tokens ?? 0, out: json?.usage?.completion_tokens ?? 0 },
+    stopped: json?.choices?.[0]?.finish_reason ?? null,
+  };
+}
+
+// 도구 호출을 한 가지 모양으로 맞춘다: { id, name, args(객체) }
+function normalizeCalls(list) {
+  return list.map((tc, i) => {
+    const fn = tc.function ?? tc;
+    let args = fn.arguments ?? fn.args ?? {};
+    if (typeof args === 'string') {
+      try { args = JSON.parse(args); } catch { args = { _raw: args }; }
+    }
+    return { id: tc.id ?? `call_${i + 1}`, name: fn.name, args };
+  });
+}
+
+// 대화 이력에 되돌려 넣을 메시지 만들기 — 규격마다 모양이 다르다.
+export function assistantMessage(shape, { content = '', thinking = '', toolCalls = [] }) {
+  if (shape === 'ollama') {
+    const m = { role: 'assistant', content };
+    if (thinking) m.thinking = thinking;
+    if (toolCalls.length) m.tool_calls = toolCalls.map((t) => ({ function: { name: t.name, arguments: t.args } }));
+    return m;
+  }
+  const m = { role: 'assistant', content: content || null };
+  if (toolCalls.length) {
+    m.tool_calls = toolCalls.map((t) => ({
+      id: t.id, type: 'function',
+      function: { name: t.name, arguments: JSON.stringify(t.args) },
+    }));
+  }
+  return m;
+}
+
+export function toolMessage(shape, { callId, name, content }) {
+  return shape === 'ollama'
+    ? { role: 'tool', tool_name: name, content: String(content) }
+    : { role: 'tool', tool_call_id: callId, content: String(content) };
+}
+
+// 한 번에 받기.
+export async function chat(conn, opts) {
+  const body = buildBody(conn.kind, { model: conn.model, ...opts });
+  const r = await req(`${conn.base}${endpoint(conn.kind)}`, {
+    method: 'POST',
+    headers: headersFor(conn.auth, conn.key ?? ''),
+    body,
+    timeout: opts.timeout ?? 300000,
+  });
+  if (!r.ok) throw new Error(serverMessage(r));
+  return extractMessage(conn.kind, r.json);
+}
+
+// 흘려 받기. { type:'thinking'|'content', text } 를 내보내고 마지막에 { type:'done', message } 를 준다.
+export async function* chatStream(conn, opts) {
+  const body = buildBody(conn.kind, { model: conn.model, ...opts, stream: true });
+  const r = await req(`${conn.base}${endpoint(conn.kind)}`, {
+    method: 'POST',
+    headers: headersFor(conn.auth, conn.key ?? ''),
+    body,
+    timeout: opts.timeout ?? 300000,
+    stream: true,
+  });
+  if (!r.ok || !r.res?.body) throw new Error(r.error ?? `HTTP ${r.status}`);
+
+  const acc = { content: '', thinking: '', toolCalls: [], usage: { in: 0, out: 0 }, stopped: null };
+  const reader = r.res.body.getReader();
+  const dec = new TextDecoder();
+  let buf = '';
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buf += dec.decode(value, { stream: true });
+
+    // OpenAI 는 SSE(data: ...), Ollama 는 줄바꿈 JSON. 둘 다 줄 단위로 처리된다.
+    let nl;
+    while ((nl = buf.indexOf('\n')) >= 0) {
+      const line = buf.slice(0, nl).trim();
+      buf = buf.slice(nl + 1);
+      if (!line) continue;
+      const payload = line.startsWith('data:') ? line.slice(5).trim() : line;
+      if (payload === '[DONE]') continue;
+      let obj;
+      try { obj = JSON.parse(payload); } catch { continue; }
+      for (const ev of absorb(conn.kind, obj, acc)) yield ev;
+    }
+  }
+  yield { type: 'done', message: acc };
+}
+
+// 조각 하나를 누적하고, 화면에 흘릴 것만 내보낸다.
+function absorb(shape, obj, acc) {
+  const out = [];
+  if (shape === 'ollama') {
+    const m = obj.message ?? {};
+    if (m.thinking) { acc.thinking += m.thinking; out.push({ type: 'thinking', text: m.thinking }); }
+    if (m.content) { acc.content += m.content; out.push({ type: 'content', text: m.content }); }
+    if (m.tool_calls?.length) acc.toolCalls.push(...normalizeCalls(m.tool_calls));
+    if (obj.done) {
+      acc.usage = { in: obj.prompt_eval_count ?? 0, out: obj.eval_count ?? 0 };
+      acc.stopped = obj.done_reason ?? 'stop';
+    }
+    return out;
+  }
+  const d = obj.choices?.[0]?.delta ?? {};
+  if (d.reasoning_content) { acc.thinking += d.reasoning_content; out.push({ type: 'thinking', text: d.reasoning_content }); }
+  if (d.content) { acc.content += d.content; out.push({ type: 'content', text: d.content }); }
+  if (d.tool_calls?.length) mergeDeltaCalls(acc, d.tool_calls);
+  if (obj.usage) acc.usage = { in: obj.usage.prompt_tokens ?? 0, out: obj.usage.completion_tokens ?? 0 };
+  const fin = obj.choices?.[0]?.finish_reason;
+  if (fin) acc.stopped = fin;
+  return out;
+}
+
+// OpenAI 스트리밍은 도구 호출 인자를 글자 단위로 쪼개 보낸다. 인덱스별로 이어 붙인다.
+function mergeDeltaCalls(acc, deltas) {
+  acc._raw ??= [];
+  for (const d of deltas) {
+    const i = d.index ?? 0;
+    acc._raw[i] ??= { id: d.id, name: '', args: '' };
+    if (d.id) acc._raw[i].id = d.id;
+    if (d.function?.name) acc._raw[i].name += d.function.name;
+    if (d.function?.arguments) acc._raw[i].args += d.function.arguments;
+  }
+  acc.toolCalls = acc._raw.filter(Boolean).map((c, i) => {
+    let args = {};
+    try { args = c.args ? JSON.parse(c.args) : {}; } catch { args = { _raw: c.args }; }
+    return { id: c.id ?? `call_${i + 1}`, name: c.name, args };
+  });
+}

package/src/backend/detect.js

@@ -0,0 +1,75 @@
+// 주소만 받아서 "이 서버가 무슨 규격이고 인증을 어떻게 받는지" 알아낸다.
+import { req, headersFor, AUTH_STYLES, serverMessage } from './http.js';
+
+// 사람이 대충 적은 주소를 시도해볼 후보들로 넓힌다.
+export function candidates(input) {
+  let u = String(input).trim().replace(/\s+/g, '');
+  if (!/^https?:\/\//i.test(u)) u = 'http://' + u;
+  u = u.replace(/\/+$/, '');
+  const out = [];
+  const push = (x) => { if (x && !out.includes(x)) out.push(x); };
+
+  if (/\/v\d+$/.test(u)) push(u);                 // .../v1 을 직접 준 경우
+  else { push(u + '/v1'); push(u); push(u + '/openai/v1'); }
+  return out;
+}
+
+// OpenAI 호환인지 확인 (GET {base}/models)
+async function tryOpenAI(base, key) {
+  for (const style of AUTH_STYLES) {
+    if (style.id !== 'none' && !key) continue;
+    if (style.id === 'none' && key) { /* 키를 줬어도 인증 없는 서버일 수 있으니 마지막에 본다 */ }
+    const r = await req(`${base}/models`, { headers: headersFor(style.id, key), timeout: 12000 });
+    if (r.ok && r.json) {
+      const list = r.json.data ?? r.json.models ?? [];
+      if (Array.isArray(list)) {
+        return { kind: 'openai', base, auth: style.id, models: normalizeModels(list), ms: r.ms };
+      }
+    }
+    // 401/403 이면 규격은 맞고 인증만 틀린 것 — 다음 방식으로 계속.
+    if (r.status && ![401, 403, 0, 404].includes(r.status)) {
+      return { kind: 'openai', base, auth: style.id, models: [], ms: r.ms, warn: serverMessage(r) };
+    }
+  }
+  return null;
+}
+
+// Ollama 자체 규격인지 확인
+async function tryOllama(origin) {
+  const v = await req(`${origin}/api/version`, { timeout: 8000 });
+  if (!v.ok || !v.json?.version) return null;
+  const tags = await req(`${origin}/api/tags`, { timeout: 12000 });
+  const models = (tags.json?.models ?? []).map((m) => ({
+    id: m.name ?? m.model,
+    note: m.details?.parameter_size ? `${m.details.parameter_size} · ${fmtSize(m.size)}` : fmtSize(m.size),
+  }));
+  return { kind: 'ollama', base: origin, auth: 'none', models, version: v.json.version, ms: v.ms };
+}
+
+function fmtSize(bytes) {
+  if (!bytes) return '';
+  const gb = bytes / 1024 ** 3;
+  return gb >= 1 ? `${gb.toFixed(1)}GB` : `${Math.round(bytes / 1024 ** 2)}MB`;
+}
+
+function normalizeModels(list) {
+  return list
+    .map((m) => (typeof m === 'string' ? { id: m } : { id: m.id ?? m.name ?? m.model, note: m.owned_by ?? '' }))
+    .filter((m) => m.id);
+}
+
+export async function detect(input, key) {
+  const tried = [];
+  const origin = String(input).trim().replace(/\/+$/, '').replace(/\/v\d+$/, '');
+
+  // Ollama 를 먼저 본다 — 로컬이면 대개 이쪽이고 확인이 빠르다.
+  const oll = await tryOllama(/^https?:\/\//i.test(origin) ? origin : 'http://' + origin);
+  if (oll) return { ...oll, tried };
+
+  for (const base of candidates(input)) {
+    tried.push(base);
+    const hit = await tryOpenAI(base, key);
+    if (hit) return { ...hit, tried };
+  }
+  return { kind: null, tried };
+}

package/src/backend/http.js

@@ -0,0 +1,60 @@
+// HTTP 한 겹. 시간 제한과 오류 정규화만 담당한다.
+
+export const AUTH_STYLES = [
+  { id: 'bearer', label: 'Authorization: Bearer', apply: (h, k) => { h['Authorization'] = `Bearer ${k}`; } },
+  { id: 'x-api-key', label: 'x-api-key', apply: (h, k) => { h['x-api-key'] = k; } },
+  { id: 'api-key', label: 'api-key (Azure 계열)', apply: (h, k) => { h['api-key'] = k; } },
+  { id: 'none', label: '인증 없음', apply: () => {} },
+];
+
+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];
+  if (key) style.apply(h, key);
+  return h;
+}
+
+export async function req(url, { method = 'GET', headers = {}, body, timeout = 20000, stream = false } = {}) {
+  const started = Date.now();
+  try {
+    const res = await fetch(url, {
+      method,
+      headers,
+      body: body === undefined ? undefined : JSON.stringify(body),
+      signal: AbortSignal.timeout(timeout),
+      redirect: 'follow',
+    });
+    const ms = Date.now() - started;
+    if (stream) return { ok: res.ok, status: res.status, res, ms };
+
+    const text = await res.text();
+    let json = null;
+    try { json = JSON.parse(text); } catch {}
+    return { ok: res.ok, status: res.status, json, text, ms, headers: res.headers };
+  } catch (err) {
+    const ms = Date.now() - started;
+    return { ok: false, status: 0, error: normalizeError(err), ms };
+  }
+}
+
+function normalizeError(err) {
+  const m = String(err?.message ?? err);
+  if (err?.name === 'TimeoutError' || /timed? ?out/i.test(m)) return '시간 초과 — 응답이 없습니다';
+  if (/ENOTFOUND|getaddrinfo/i.test(m)) return '주소를 찾을 수 없습니다 (DNS)';
+  if (/ECONNREFUSED/i.test(m)) return '연결이 거부되었습니다 (서버가 꺼져 있거나 포트가 다릅니다)';
+  if (/ECONNRESET/i.test(m)) return '연결이 끊겼습니다';
+  if (/certificate|SELF_SIGNED|UNABLE_TO_VERIFY/i.test(m)) return '인증서 문제 — 사내 인증서라면 NODE_EXTRA_CA_CERTS 가 필요합니다';
+  if (/fetch failed/i.test(m)) return '연결 실패 — 주소·포트·프록시를 확인하세요';
+  return m;
+}
+
+// 서버가 준 오류 본문에서 사람이 읽을 문장만 뽑는다.
+export function serverMessage(r) {
+  if (r.error) return r.error;
+  const j = r.json;
+  const cand = j?.error?.message ?? j?.error ?? j?.message ?? j?.detail;
+  if (typeof cand === 'string') return cand;
+  if (cand) return JSON.stringify(cand).slice(0, 200);
+  if (r.text) return String(r.text).replace(/\s+/g, ' ').slice(0, 200);
+  return `HTTP ${r.status}`;
+}