xgen-dex-cli 1.2.0

package/dist/chunks/chunk-QXSCKZEG.js

@@ -0,0 +1,4560 @@
+// ../../packages/protocol/src/client.ts
+var ApiError = class extends Error {
+  constructor(status, message, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "ApiError";
+  }
+};
+var HttpClient = class {
+  baseUrl;
+  accessToken = null;
+  fetchImpl;
+  onAuthFailure;
+  timeoutMs;
+  constructor(opts) {
+    this.baseUrl = normalizeBaseUrl(opts.baseUrl);
+    this.fetchImpl = opts.fetch ?? globalThis.fetch;
+    this.onAuthFailure = opts.onAuthFailure;
+    this.timeoutMs = opts.timeoutMs ?? 3e4;
+    if (!this.fetchImpl) {
+      throw new Error("HttpClient: no fetch implementation available");
+    }
+  }
+  setBaseUrl(baseUrl) {
+    this.baseUrl = normalizeBaseUrl(baseUrl);
+  }
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+  setToken(token) {
+    this.accessToken = token;
+  }
+  url(path) {
+    return `${this.baseUrl}${path.startsWith("/") ? path : `/${path}`}`;
+  }
+  headers(extra) {
+    const h = { ...extra };
+    if (this.accessToken) h["Authorization"] = `Bearer ${this.accessToken}`;
+    return h;
+  }
+  /** GET/POST/… returning parsed JSON. Throws ApiError on non-2xx. */
+  async json(method, path, body, opts) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), opts?.timeoutMs ?? this.timeoutMs);
+    let res;
+    try {
+      res = await this.fetchImpl(this.url(path), {
+        method,
+        headers: this.headers({
+          "Content-Type": "application/json",
+          Accept: "application/json"
+        }),
+        body: body === void 0 ? void 0 : JSON.stringify(body),
+        signal: controller.signal
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+    const text = await res.text();
+    let parsed = void 0;
+    if (text) {
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+        parsed = text;
+      }
+    }
+    if (!res.ok) {
+      if (res.status === 401 && opts?.auth !== false) this.onAuthFailure?.();
+      throw new ApiError(res.status, `${method} ${path} \u2192 ${res.status}`, parsed);
+    }
+    return parsed;
+  }
+  get(path, opts) {
+    return this.json("GET", path, void 0, opts);
+  }
+  /** Multipart upload (아바타 에셋 등). Content-Type 은 fetch 가 boundary 와
+   *  함께 자동 설정하므로 지정하지 않는다. 대용량(모델 zip) 대비 긴 타임아웃. */
+  async upload(path, form, opts) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), opts?.timeoutMs ?? 12e4);
+    let res;
+    try {
+      res = await this.fetchImpl(this.url(path), {
+        method: "POST",
+        headers: this.headers({ Accept: "application/json" }),
+        body: form,
+        signal: controller.signal
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+    const text = await res.text();
+    let parsed = void 0;
+    if (text) {
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+        parsed = text;
+      }
+    }
+    if (!res.ok) {
+      if (res.status === 401) this.onAuthFailure?.();
+      throw new ApiError(res.status, `POST ${path} \u2192 ${res.status}`, parsed);
+    }
+    return parsed;
+  }
+  post(path, body, opts) {
+    return this.json("POST", path, body, opts);
+  }
+  /**
+   * POST a JSON body and read the raw BINARY response (e.g. TTS audio bytes).
+   * Returns the bytes plus the response `Content-Type` so the caller can wrap a
+   * correctly-typed Blob (audio/wav|mpeg|ogg). Throws ApiError on non-2xx.
+   */
+  async postBinary(path, body, opts) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), opts?.timeoutMs ?? this.timeoutMs);
+    let res;
+    try {
+      res = await this.fetchImpl(this.url(path), {
+        method: "POST",
+        headers: this.headers({ "Content-Type": "application/json", Accept: "audio/*" }),
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+    if (!res.ok) {
+      if (res.status === 401) this.onAuthFailure?.();
+      const text = await res.text().catch(() => "");
+      throw new ApiError(res.status, `POST ${path} \u2192 ${res.status}`, text);
+    }
+    const ab = await res.arrayBuffer();
+    return { bytes: new Uint8Array(ab), contentType: res.headers.get("content-type") ?? "" };
+  }
+  /**
+   * GET a raw BINARY response (Teams 첨부 다운로드 등). `postBinary` 의 GET 짝.
+   *
+   * 파일명은 응답 헤더가 아니라 **호출자가 이미 아는 값**을 쓴다 —
+   * Content-Disposition 의 RFC 5987 인코딩을 여기서 되풀이 파싱할 이유가 없고,
+   * 서버도 우리가 쿼리로 넘긴 이름을 그대로 되돌려줄 뿐이다.
+   */
+  async getBinary(path, opts) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), opts?.timeoutMs ?? 12e4);
+    let res;
+    try {
+      res = await this.fetchImpl(this.url(path), {
+        method: "GET",
+        headers: this.headers({ Accept: "*/*" }),
+        signal: controller.signal
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+    if (!res.ok) {
+      if (res.status === 401) this.onAuthFailure?.();
+      const text = await res.text().catch(() => "");
+      throw new ApiError(res.status, `GET ${path} \u2192 ${res.status}`, text);
+    }
+    const ab = await res.arrayBuffer();
+    return { bytes: new Uint8Array(ab), contentType: res.headers.get("content-type") ?? "" };
+  }
+  put(path, body, opts) {
+    return this.json("PUT", path, body, opts);
+  }
+  patch(path, body, opts) {
+    return this.json("PATCH", path, body, opts);
+  }
+  /** `delete` is a reserved word in some call sites — keep the short alias. */
+  del(path, opts) {
+    return this.json("DELETE", path, void 0, opts);
+  }
+  /**
+   * Open a raw streaming POST (for SSE). Returns the Response so the caller can
+   * read `response.body` as a stream. Does NOT enforce the JSON timeout — SSE
+   * connections are long-lived (the gateway allows 1h for `/stream` paths).
+   */
+  async stream(path, body, signal) {
+    const res = await this.fetchImpl(this.url(path), {
+      method: "POST",
+      headers: this.headers({
+        "Content-Type": "application/json",
+        Accept: "text/event-stream"
+      }),
+      body: JSON.stringify(body),
+      signal
+    });
+    if (!res.ok) {
+      if (res.status === 401) this.onAuthFailure?.();
+      const text = await res.text().catch(() => "");
+      throw new ApiError(res.status, `stream ${path} \u2192 ${res.status}`, text);
+    }
+    return res;
+  }
+};
+function normalizeBaseUrl(url) {
+  return (url || "").trim().replace(/\/+$/, "");
+}
+
+// ../../packages/engine/src/errors.ts
+var DexError = class extends Error {
+  constructor(code, message, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "DexError";
+  }
+};
+function isUnauthorized(error) {
+  return error instanceof ApiError && (error.status === 401 || error.status === 403);
+}
+function publicError(error) {
+  if (error instanceof DexError) {
+    return { code: error.code, message: error.message, details: error.details };
+  }
+  if (error instanceof ApiError) {
+    return {
+      code: `http_${error.status}`,
+      message: error.message,
+      details: error.body
+    };
+  }
+  if (error instanceof Error) {
+    if (error.name === "AbortError") return { code: "cancelled", message: "\uC694\uCCAD\uC774 \uCDE8\uC18C\uB418\uC5C8\uC2B5\uB2C8\uB2E4." };
+    return { code: "internal_error", message: error.message };
+  }
+  return { code: "internal_error", message: String(error) };
+}
+
+// ../../packages/engine/src/config-store.ts
+import { chmod, mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { homedir, platform } from "node:os";
+
+// ../../packages/engine/src/local-tools-config.ts
+function defaultLocalToolsConfig() {
+  return {
+    enabled: false,
+    cwd: "",
+    timeoutMs: 12e4,
+    allowedRoots: [],
+    blockedCommands: [],
+    allowDangerous: false
+  };
+}
+var MIN_TIMEOUT = 1e3;
+var MAX_TIMEOUT = 36e5;
+function cleanList(value) {
+  if (!Array.isArray(value)) return [];
+  const out = [];
+  for (const item of value) {
+    const s = String(item ?? "").trim();
+    if (s && !out.includes(s)) out.push(s);
+  }
+  return out;
+}
+function normalizeLocalToolsConfig(value) {
+  const d = defaultLocalToolsConfig();
+  const v = value && typeof value === "object" ? value : {};
+  const timeout = Number(v.timeoutMs);
+  return {
+    enabled: v.enabled === true,
+    cwd: String(v.cwd ?? "").trim(),
+    timeoutMs: Number.isFinite(timeout) ? Math.min(MAX_TIMEOUT, Math.max(MIN_TIMEOUT, Math.round(timeout))) : d.timeoutMs,
+    allowedRoots: cleanList(v.allowedRoots),
+    blockedCommands: cleanList(v.blockedCommands),
+    allowDangerous: v.allowDangerous === true
+  };
+}
+function toShellConfig(config) {
+  return {
+    enabled: config.enabled,
+    cwd: config.cwd,
+    timeoutMs: config.timeoutMs,
+    allowedRoots: config.allowedRoots,
+    blocked: config.blockedCommands
+  };
+}
+function dangerousApprovalFromConfig(config) {
+  if (!config.allowDangerous) return void 0;
+  return async () => "session";
+}
+
+// ../../packages/engine/src/config-store.ts
+var DEFAULT_PROFILE = "default";
+function defaultConfig() {
+  return {
+    version: 1,
+    currentProfile: DEFAULT_PROFILE,
+    profiles: {},
+    localTools: defaultLocalToolsConfig()
+  };
+}
+function dataDirectory(env = process.env) {
+  if (env.DEX_CLI_HOME?.trim()) return env.DEX_CLI_HOME.trim();
+  if (platform() === "win32") return join(env.APPDATA || homedir(), "xgen-dex-cli");
+  if (platform() === "darwin") return join(homedir(), "Library", "Application Support", "xgen-dex-cli");
+  return join(env.XDG_CONFIG_HOME || join(homedir(), ".config"), "xgen-dex-cli");
+}
+function configPath(env = process.env) {
+  return join(dataDirectory(env), "config.json");
+}
+function parseConfig(raw) {
+  if (!raw || typeof raw !== "object") throw new DexError("config_invalid", "\uC124\uC815 \uD30C\uC77C\uC774 \uAC1D\uCCB4\uAC00 \uC544\uB2D9\uB2C8\uB2E4.");
+  const value = raw;
+  const profiles = {};
+  if (value.profiles && typeof value.profiles === "object") {
+    for (const [name, profile] of Object.entries(value.profiles)) {
+      if (!profile || typeof profile !== "object") continue;
+      const serverUrl = String(profile.serverUrl ?? "").trim();
+      if (serverUrl) profiles[name] = { serverUrl };
+    }
+  }
+  const localTools = normalizeLocalToolsConfig(value.localTools);
+  return {
+    version: 1,
+    currentProfile: String(value.currentProfile || DEFAULT_PROFILE),
+    profiles,
+    localTools
+  };
+}
+var FileConfigStore = class {
+  constructor(path = configPath()) {
+    this.path = path;
+  }
+  queue = Promise.resolve();
+  async read() {
+    try {
+      return parseConfig(JSON.parse(await readFile(this.path, "utf8")));
+    } catch (error) {
+      if (error.code === "ENOENT") return defaultConfig();
+      if (error instanceof DexError) throw error;
+      throw new DexError("config_invalid", `\uC124\uC815 \uD30C\uC77C\uC744 \uC77D\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${this.path}`, error);
+    }
+  }
+  async write(config) {
+    const operation = async () => {
+      await mkdir(dirname(this.path), { recursive: true, mode: 448 });
+      const temporary = `${this.path}.${process.pid}.tmp`;
+      await writeFile(temporary, `${JSON.stringify(config, null, 2)}
+`, { mode: 384 });
+      await chmod(temporary, 384);
+      await rename(temporary, this.path);
+    };
+    this.queue = this.queue.then(operation, operation);
+    await this.queue;
+  }
+};
+function validateProfileName(input) {
+  const name = input.trim();
+  if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(name)) {
+    throw new DexError(
+      "config_invalid",
+      "\uD504\uB85C\uD544 \uC774\uB984\uC740 \uC601\uBB38\uC790/\uC22B\uC790\uB85C \uC2DC\uC791\uD558\uACE0 \uC601\uBB38\uC790, \uC22B\uC790, \uC810, \uBC11\uC904, \uD558\uC774\uD508\uB9CC \uC0AC\uC6A9\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4."
+    );
+  }
+  return name;
+}
+function validateServerUrl(input) {
+  let url;
+  try {
+    url = new URL(input.trim());
+  } catch {
+    throw new DexError("config_invalid", "\uC11C\uBC84 URL\uC740 http:// \uB610\uB294 https://\uB85C \uC2DC\uC791\uD574\uC57C \uD569\uB2C8\uB2E4.");
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new DexError("config_invalid", "\uC11C\uBC84 URL\uC740 http:// \uB610\uB294 https://\uB9CC \uC0AC\uC6A9\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4.");
+  }
+  if (url.username || url.password || url.search || url.hash) {
+    throw new DexError("config_invalid", "\uC11C\uBC84 URL\uC5D0\uB294 \uC790\uACA9 \uC99D\uBA85, query, fragment\uB97C \uB123\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.");
+  }
+  return url.toString().replace(/\/$/, "");
+}
+
+// ../../packages/engine/src/dex-engine.ts
+import { randomUUID } from "node:crypto";
+
+// ../../packages/protocol/src/agent-data.ts
+function workspaceStoragePath(path) {
+  const clean = String(path ?? "").replace(/\\/g, "/").replace(/^\/+/, "");
+  return clean === "workspace" || clean.startsWith("workspace/") ? clean : `workspace/${clean}`;
+}
+var AgentDataApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  // ── 전체로그 ──────────────────────────────────────────────────
+  /** 이 에이전트의 실행 트레이스 목록(최근 50). */
+  traceList(workflowId) {
+    const params = new URLSearchParams({
+      workflow_id: workflowId,
+      page: "1",
+      page_size: "50"
+    });
+    return this.http.get(`/api/agentflow/trace/list?${params}`);
+  }
+  /** 트레이스 하나의 스팬(단계) 전부. */
+  traceDetail(traceId) {
+    return this.http.get(`/api/agentflow/trace/detail/${encodeURIComponent(traceId)}`);
+  }
+  // ── 메모리 ────────────────────────────────────────────────────
+  memoryList(workflowId) {
+    return this.http.get(
+      `/api/agentflow/geny-memory/${encodeURIComponent(workflowId)}/files`
+    );
+  }
+  /** filename 은 서버에서 `{filename:path}` — 슬래시는 살리고 세그먼트만 인코딩한다. */
+  memoryRead(workflowId, path) {
+    const fp = path.split("/").map(encodeURIComponent).join("/");
+    return this.http.get(
+      `/api/agentflow/geny-memory/${encodeURIComponent(workflowId)}/files/${fp}`
+    );
+  }
+  // ── 작업 ──────────────────────────────────────────────────────
+  tasksList(workflowId) {
+    return this.http.get(
+      `/api/agentflow/geny-tasks/${encodeURIComponent(workflowId)}`
+    );
+  }
+  /** 예약 작업(job=session_id) 1건의 실행 기록. */
+  taskRuns(workflowId, sessionId) {
+    return this.http.get(
+      `/api/agentflow/geny-tasks/${encodeURIComponent(workflowId)}/job/${encodeURIComponent(sessionId ?? "")}/runs`
+    );
+  }
+  /** 백그라운드/서브에이전트 작업(task_id) 1건의 출력. */
+  taskOutput(workflowId, runId) {
+    return this.http.get(
+      `/api/agentflow/geny-tasks/${encodeURIComponent(workflowId)}/task/${encodeURIComponent(runId)}/output`
+    );
+  }
+  // ── 세션 수명 ──────────────────────────────────────────────────
+  /** '진행 중 대화' 종료 — 서버가 들고 있는 세션 RAM(executor + 라우팅)을 회수한다.
+   *  이력은 지우지 않는다(삭제는 세션 종료이지 대화 기록 삭제가 아니다). */
+  endSession(workflowId, interactionId) {
+    return this.http.post(
+      `/api/agentflow/geny-agent/${encodeURIComponent(workflowId)}/end-session`,
+      { interaction_id: interactionId }
+    );
+  }
+  // ── 기본정보 ──────────────────────────────────────────────────
+  /** 실행 없이 재구성한 턴 프롬프트 + 도구 표면(web/connector 둘 다). */
+  basicInfo(workflowId) {
+    return this.http.get(
+      `/api/agentflow/${encodeURIComponent(workflowId)}/basic-info`
+    );
+  }
+  // ── 도구 ──────────────────────────────────────────────────────
+  toolsList(workflowId) {
+    return this.http.get(
+      `/api/agentflow/geny-tools/${encodeURIComponent(workflowId)}`
+    );
+  }
+  /** 제작 도구 하나 — 소스 코드까지. */
+  toolGet(workflowId, functionId) {
+    return this.http.get(
+      `/api/agentflow/geny-tools/${encodeURIComponent(workflowId)}/${encodeURIComponent(functionId)}?with_source=true`
+    );
+  }
+  // ── 스토리지 ──────────────────────────────────────────────────
+  /** 워크스페이스 전체(평면) 목록 — 파일/폴더 각각 한 항목. `path` 는 예약(미사용). */
+  workspaceTree(workflowId, _path) {
+    return this.http.get(
+      `/api/agentflow/geny-workspace/${encodeURIComponent(workflowId)}/storage/list`
+    );
+  }
+  /** 텍스트 파일 미리보기. 바이너리/과대 파일은 서버가 415/413 으로 거부한다. */
+  workspaceFile(workflowId, path) {
+    const params = new URLSearchParams({ path: workspaceStoragePath(path) });
+    return this.http.get(
+      `/api/agentflow/geny-workspace/${encodeURIComponent(workflowId)}/storage/text?${params}`
+    );
+  }
+  /** 원바이트 파일 읽기 — 이미지처럼 텍스트 API로 읽을 수 없는 미리보기용. */
+  workspaceBinary(workflowId, path, purpose) {
+    const encodedPath = workspaceStoragePath(path).split("/").map(encodeURIComponent).join("/");
+    const query = purpose ? `?purpose=${encodeURIComponent(purpose)}` : "";
+    return this.http.getBinary(
+      `/api/agentflow/geny-workspace/${encodeURIComponent(workflowId)}/storage-raw/${encodedPath}${query}`
+    );
+  }
+  /** Image bytes land in this agent's durable workspace before chat execution. */
+  workspaceUpload(workflowId, bytes, filename, mimeType, interactionId, attachmentId) {
+    const form = new FormData();
+    const owned = new Uint8Array(bytes);
+    form.append("file", new Blob([owned.buffer], { type: mimeType }), filename);
+    return this.http.upload(
+      `/api/agentflow/geny-workspace/${encodeURIComponent(workflowId)}/storage/upload?subdir=uploads&purpose=chat_attachment&interaction_id=${encodeURIComponent(interactionId)}&attachment_id=${encodeURIComponent(attachmentId)}`,
+      form,
+      { timeoutMs: 3e5 }
+    );
+  }
+};
+
+// ../../packages/protocol/src/agents.ts
+function mapAgent(r) {
+  return {
+    id: r.id,
+    workflowId: r.workflow_id,
+    workflowName: r.workflow_name,
+    nodeCount: r.node_count ?? 0,
+    isShared: !!r.is_shared,
+    isDeployed: !!r.is_deployed,
+    isCompleted: !!r.is_completed,
+    workflowType: r.workflow_type ?? "canvas",
+    description: r.description ?? "",
+    username: r.username ?? "",
+    fullName: r.full_name ?? "",
+    createdAt: r.created_at ?? "",
+    updatedAt: r.updated_at ?? "",
+    hasAgentGeny: !!r.has_agent_geny
+  };
+}
+var AgentsApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** Paged agent list matching the UI grid (default page_size 24). */
+  async list(query = {}) {
+    const params = new URLSearchParams();
+    params.set("page", String(query.page ?? 1));
+    params.set("page_size", String(query.pageSize ?? 24));
+    if (query.search) params.set("search", query.search);
+    if (query.status) params.set("status", query.status);
+    if (query.owner) params.set("owner", query.owner);
+    if (query.includeHarness) params.set("include_harness", "true");
+    const res = await this.http.get(`/api/agentflow/list/detail?${params}`);
+    const raw = res.items ?? res.workflows ?? [];
+    return {
+      items: raw.map(mapAgent),
+      pagination: {
+        page: res.pagination?.page ?? query.page ?? 1,
+        pageSize: res.pagination?.page_size ?? query.pageSize ?? 24,
+        totalCount: res.pagination?.total_count ?? raw.length,
+        totalPages: res.pagination?.total_pages ?? 1
+      }
+    };
+  }
+  /**
+   * Fetch every page and return the full agent list. Convenience for small
+   * accounts / pickers; bounded by `maxPages` to avoid runaway loops.
+   */
+  async listAll(query = {}, maxPages = 50) {
+    const first = await this.list({ ...query, page: 1 });
+    const all = [...first.items];
+    for (let page = 2; page <= Math.min(first.pagination.totalPages, maxPages); page++) {
+      const next = await this.list({ ...query, page });
+      all.push(...next.items);
+    }
+    return all;
+  }
+};
+
+// ../../packages/protocol/src/hash.ts
+async function subtle() {
+  const g = globalThis.crypto;
+  if (g?.subtle) return g.subtle;
+  const { webcrypto } = await import("node:crypto");
+  return webcrypto.subtle;
+}
+async function sha256Hex(plaintext) {
+  const data = new TextEncoder().encode(plaintext);
+  const digest = await (await subtle()).digest("SHA-256", data);
+  return Array.from(new Uint8Array(digest)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+// ../../packages/protocol/src/auth.ts
+var AuthApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Log in with email + plaintext password. The password is SHA-256-hex hashed
+   * before sending (the gateway compares the hash verbatim). Returns tokens +
+   * identity. Throws ApiError on bad credentials / locked / inactive account.
+   */
+  async login(email, password) {
+    const passwordHash = await sha256Hex(password);
+    const res = await this.http.post(
+      "/api/auth/login",
+      { email, password: passwordHash, token: null }
+      // login itself must not trigger the onAuthFailure hook
+    );
+    if (!res.success || !res.access_token) {
+      throw new Error(res.message || "\uB85C\uADF8\uC778\uC5D0 \uC2E4\uD328\uD588\uC2B5\uB2C8\uB2E4.");
+    }
+    return {
+      accessToken: res.access_token,
+      refreshToken: res.refresh_token ?? void 0,
+      tokenType: res.token_type ?? "bearer",
+      userId: res.user_id ?? "",
+      username: res.username ?? email
+    };
+  }
+  /** SSO login with a pre-obtained token. */
+  async loginWithToken(ssoToken) {
+    const res = await this.http.post("/api/auth/login", {
+      token: ssoToken
+    });
+    if (!res.success || !res.access_token) {
+      throw new Error(res.message || "SSO \uB85C\uADF8\uC778\uC5D0 \uC2E4\uD328\uD588\uC2B5\uB2C8\uB2E4.");
+    }
+    return {
+      accessToken: res.access_token,
+      refreshToken: res.refresh_token ?? void 0,
+      tokenType: res.token_type ?? "bearer",
+      userId: res.user_id ?? "",
+      username: res.username ?? ""
+    };
+  }
+  /**
+   * Validate the access token and return the current user + permissions. If the
+   * access token is expired and a refresh token is supplied, the gateway may
+   * return a rotated access token in `newAccessToken`.
+   */
+  async validate(accessToken, refreshToken) {
+    const res = await this.http.post(
+      "/api/auth/validate-token",
+      { token: accessToken, refresh_token: refreshToken },
+      { auth: false }
+    );
+    if (!res.valid) return { user: null, newAccessToken: res.new_access_token ?? void 0 };
+    return {
+      user: {
+        userId: res.user_id ?? "",
+        username: res.username ?? "",
+        isSuperuser: !!res.is_superuser,
+        roles: res.roles ?? [],
+        permissions: res.permissions ?? []
+      },
+      newAccessToken: res.new_access_token ?? void 0
+    };
+  }
+  /** Exchange a refresh token for a fresh access token. */
+  async refresh(refreshToken) {
+    const res = await this.http.post(
+      "/api/auth/refresh",
+      { refresh_token: refreshToken },
+      { auth: false }
+    );
+    return res.success ? res.access_token : null;
+  }
+  async logout(accessToken) {
+    try {
+      await this.http.post("/api/auth/logout", { token: accessToken }, { timeoutMs: 8e3 });
+    } catch {
+    }
+  }
+  /** Server session policy (timeouts) — useful for a refresh scheduler. */
+  async sessionConfig() {
+    return this.http.get("/api/auth/session-config", { timeoutMs: 8e3 });
+  }
+};
+
+// ../../packages/protocol/src/avatars.ts
+var AvatarsApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** Upload one avatar file (model zip or photo) → parsed descriptor. */
+  async uploadAsset(bytes, filename) {
+    const form = new FormData();
+    const buf = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+    form.append("file", new Blob([buf]), filename);
+    const res = await this.http.upload("/api/storage/avatar/upload", form);
+    return res.avatar;
+  }
+  /** Delete an avatar's stored asset tree. */
+  async deleteAsset(avatarId) {
+    await this.http.json("DELETE", `/api/storage/avatar/${avatarId}`);
+  }
+  // ── store ──────────────────────────────────────────────────────
+  async storeList() {
+    const res = await this.http.get("/api/storage/avatar/store/list");
+    return res.items || [];
+  }
+  async storePublish(descriptor, name, description = "") {
+    const res = await this.http.post("/api/storage/avatar/store/publish", {
+      descriptor,
+      name,
+      description
+    });
+    return res.item;
+  }
+  /** Add a store avatar to my assets → descriptor with a fresh local id. */
+  async storeDownload(storeId) {
+    const res = await this.http.post(`/api/storage/avatar/store/${storeId}/download`, {});
+    return res.avatar;
+  }
+  async storeRate(storeId, stars) {
+    const res = await this.http.post(`/api/storage/avatar/store/${storeId}/rate`, { stars });
+    return res.item;
+  }
+  async storeUnpublish(storeId) {
+    await this.http.json("DELETE", `/api/storage/avatar/store/${storeId}`);
+  }
+};
+
+// ../../packages/protocol/src/sse.ts
+var SseParser = class {
+  buffer = "";
+  /** Feed a raw chunk; returns any complete frames it produced. */
+  push(chunk) {
+    this.buffer += chunk;
+    const frames = [];
+    let sep2;
+    while ((sep2 = this.nextSeparator()) !== -1) {
+      const rawFrame = this.buffer.slice(0, sep2.valueOf());
+      this.buffer = this.buffer.slice(this.advanceAfterSeparator(sep2));
+      const frame = this.parseFrame(rawFrame);
+      if (frame) frames.push(frame);
+    }
+    return frames;
+  }
+  /** Flush any trailing frame not terminated by a blank line (stream end). */
+  flush() {
+    const rest = this.buffer.trim();
+    this.buffer = "";
+    if (!rest) return [];
+    const frame = this.parseFrame(rest);
+    return frame ? [frame] : [];
+  }
+  nextSeparator() {
+    const a = this.buffer.indexOf("\n\n");
+    const b = this.buffer.indexOf("\r\n\r\n");
+    if (a === -1) return b;
+    if (b === -1) return a;
+    return Math.min(a, b);
+  }
+  advanceAfterSeparator(sep2) {
+    return this.buffer.startsWith("\r\n\r\n", sep2) ? sep2 + 4 : sep2 + 2;
+  }
+  parseFrame(raw) {
+    let event;
+    const dataLines = [];
+    for (const line of raw.split(/\r?\n/)) {
+      if (!line || line.startsWith(":")) continue;
+      if (line.startsWith("event:")) {
+        event = line.slice(6).trim();
+      } else if (line.startsWith("data:")) {
+        dataLines.push(line.slice(5).replace(/^ /, ""));
+      }
+    }
+    if (dataLines.length === 0 && event === void 0) return null;
+    return { event, data: dataLines.join("\n") };
+  }
+};
+
+// ../../packages/protocol/src/chat.ts
+function toRequestBody(req) {
+  return {
+    workflow_name: req.workflowName,
+    workflow_id: req.workflowId,
+    input_data: req.input,
+    interaction_id: req.interactionId,
+    selected_collections: req.selectedCollections ?? [],
+    selected_files: req.selectedFiles ?? [],
+    include_logs: req.includeLogs ?? true,
+    include_node_status: req.includeNodeStatus ?? true,
+    include_tool_events: req.includeToolEvents ?? true,
+    response_format: "stream",
+    // 대화 출처 — 이 턴이 데스크톱 커넥터에서 왔음을 서버에 알린다. 서버는 이
+    // 값이 "connector" 인 실행에만 커넥터 호스팅 로컬 도구(이 PC 의 파일/셸/
+    // 브라우저/오피스 조작)를 에이전트에 노출·실행한다. 웹 채팅은 이 필드를
+    // 보내지 않으므로, 같은 사용자가 커넥터를 켜 둔 상태로 웹에서 대화해도
+    // 로컬 도구는 절대 작동하지 않는다.
+    client_surface: "connector",
+    // 실행 환경 지시 — 로컬 실행 v2 폴백 턴은 'sandbox'(서버 sandbox 강제; 커넥터
+    // 로컬 워크스페이스를 원격 조작하는 중간 형태를 쓰지 않는다). 없으면 생략(auto).
+    ...req.executionTarget ? { execution_target: req.executionTarget } : {}
+  };
+}
+function mapToolEvent(d) {
+  return {
+    eventType: String(d.event_type ?? d.type ?? "tool"),
+    toolName: d.tool_name,
+    toolInput: d.tool_input,
+    result: d.result,
+    resultLength: d.result_length,
+    error: d.error,
+    citations: d.citations,
+    runId: d.run_id,
+    indicator: d.indicator,
+    durationMs: d.duration_ms,
+    timestamp: d.timestamp
+  };
+}
+function parseData(raw) {
+  try {
+    const v = JSON.parse(raw);
+    return v && typeof v === "object" ? v : null;
+  } catch {
+    return null;
+  }
+}
+function frameToChatEvent(frameEvent, rawData) {
+  const d = parseData(rawData);
+  switch (frameEvent) {
+    case "tool":
+      return d ? { kind: "tool", event: mapToolEvent(d) } : null;
+    case "node_status":
+      return d ? {
+        kind: "node_status",
+        event: { nodeId: String(d.node_id ?? ""), status: String(d.status ?? ""), ...d }
+      } : null;
+    case "log":
+      return { kind: "log", data: d ?? rawData };
+    case "execution_io":
+      return d ? { kind: "execution_io", executionIoId: Number(d.execution_io_id ?? 0) } : null;
+    case "download_artifact":
+      return d ? { kind: "download", data: d } : null;
+    case "a2ui_command":
+      return d ? { kind: "ui_command", surface: "a2ui", command: d } : null;
+    case "floui_command":
+      return d ? { kind: "ui_command", surface: "floui", command: d } : null;
+    case "quota_warning":
+      return d ? { kind: "quota", level: "warning", data: d } : null;
+    case "quota_exceeded":
+      return d ? { kind: "quota", level: "exceeded", data: d } : null;
+    case "execution_suspended":
+      return { kind: "error", detail: "\uC6CC\uD06C\uD50C\uB85C\uC6B0\uAC00 \uAD00\uB9AC\uC790\uC5D0 \uC758\uD574 \uC77C\uC2DC \uC911\uC9C0\uB418\uC5C8\uC2B5\uB2C8\uB2E4." };
+    case void 0:
+    case "":
+    case "message":
+      break;
+    // default frame — dispatch on the JSON `type` below
+    default:
+      return null;
+  }
+  if (!d) return null;
+  switch (d.type) {
+    case "data":
+      return { kind: "text", content: String(d.content ?? "") };
+    case "summary": {
+      const data = d.data ?? {};
+      const outputs = data.outputs ?? [];
+      return { kind: "summary", text: outputs.map(String).join(""), data };
+    }
+    case "end":
+      return { kind: "end" };
+    case "error":
+      return { kind: "error", detail: String(d.detail ?? d.error ?? "unknown error") };
+    // Some tool/agent frames arrive as bare `data:` JSON (no event: line).
+    case "tool_call":
+    case "tool_start":
+    case "tool_result":
+    case "tool_error":
+      return { kind: "tool", event: mapToolEvent(d) };
+    default:
+      return null;
+  }
+}
+var ChatApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Stream a chat turn. Yields normalized ChatEvents until the terminal `end`
+   * (or the stream closes). Pass an AbortSignal to cancel mid-stream.
+   */
+  async *stream(req, signal) {
+    const res = await this.http.stream(
+      "/api/agentflow/execute/based-id/stream",
+      toRequestBody(req),
+      signal
+    );
+    const body = res.body;
+    if (!body) throw new Error("\uC2A4\uD2B8\uB9BC \uC751\uB2F5 \uBCF8\uBB38\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.");
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    const parser = new SseParser();
+    try {
+      for (; ; ) {
+        const { value, done } = await reader.read();
+        if (done) break;
+        const frames = parser.push(decoder.decode(value, { stream: true }));
+        for (const f of frames) {
+          const ev = frameToChatEvent(f.event, f.data);
+          if (ev) {
+            yield ev;
+            if (ev.kind === "end") return;
+          }
+        }
+      }
+      for (const f of parser.flush()) {
+        const ev = frameToChatEvent(f.event, f.data);
+        if (ev) yield ev;
+      }
+    } finally {
+      try {
+        reader.releaseLock();
+      } catch {
+      }
+    }
+  }
+  /**
+   * Convenience: run a turn to completion and return the accumulated assistant
+   * text plus collected tool events. Ignores intermediate UI/log frames.
+   */
+  async complete(req, onEvent, signal) {
+    let text = "";
+    let summary = "";
+    const tools = [];
+    let error;
+    let executionIoId;
+    for await (const e of this.stream(req, signal)) {
+      onEvent?.(e);
+      if (e.kind === "text") text += e.content;
+      else if (e.kind === "summary") summary = e.text;
+      else if (e.kind === "tool") tools.push(e.event);
+      else if (e.kind === "execution_io") executionIoId = e.executionIoId;
+      else if (e.kind === "error") error = e.detail;
+    }
+    return { text: text || summary, tools, error, executionIoId };
+  }
+};
+
+// ../../packages/protocol/src/browser.ts
+var BROWSER_CONTEXT_START = "<xgen_browser_context>";
+var BROWSER_CONTEXT_END = "</xgen_browser_context>";
+function stripBrowserContext(text) {
+  if (typeof text !== "string" || !text.startsWith(BROWSER_CONTEXT_START)) return text;
+  const end = text.indexOf(BROWSER_CONTEXT_END);
+  if (end < 0) return text;
+  return text.slice(end + BROWSER_CONTEXT_END.length).replace(/^\r?\n/, "");
+}
+
+// ../../packages/protocol/src/history.ts
+function toHistoryAttachments(value) {
+  if (!Array.isArray(value)) return [];
+  const result = [];
+  for (const item of value) {
+    if (!item || typeof item !== "object") continue;
+    const raw = item;
+    const path = String(raw.minioPath ?? raw.filePath ?? raw.object_name ?? raw.path ?? "").trim();
+    if (!path) continue;
+    const name = String(raw.name ?? raw.original_name ?? path.split("/").pop() ?? "attachment");
+    const contentType = String(raw.contentType ?? raw.content_type ?? "application/octet-stream").split(";", 1)[0].trim().toLowerCase();
+    const type = raw.type === "picture" || contentType.startsWith("image/") ? "picture" : "file";
+    const numericSize = Number(raw.size ?? raw.file_size ?? 0);
+    result.push({
+      id: typeof raw.id === "string" || typeof raw.id === "number" ? raw.id : void 0,
+      name,
+      size: Number.isFinite(numericSize) && numericSize > 0 ? numericSize : 0,
+      contentType,
+      type,
+      path,
+      bucket: String(raw.bucket ?? "")
+    });
+  }
+  return result;
+}
+function toDisplayText(v) {
+  if (v == null) return "";
+  if (typeof v === "string") return stripBrowserContext(v);
+  if (typeof v === "number" || typeof v === "boolean") return String(v);
+  if (Array.isArray(v)) {
+    const parts = v.map((b) => {
+      if (b == null) return "";
+      if (typeof b === "string") return b;
+      if (typeof b === "object") {
+        const o = b;
+        if (typeof o.text === "string") return o.text;
+        const t = typeof o.type === "string" ? o.type : "";
+        if (t.includes("image")) return "[\uC774\uBBF8\uC9C0]";
+        try {
+          return JSON.stringify(b);
+        } catch {
+          return String(b);
+        }
+      }
+      return String(b);
+    });
+    return stripBrowserContext(parts.filter(Boolean).join("\n"));
+  }
+  try {
+    return JSON.stringify(v, null, 2);
+  } catch {
+    return String(v);
+  }
+}
+var HistoryApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** Ordered turns of one conversation. */
+  async turns(workflowId, interactionId, workflowName) {
+    const params = new URLSearchParams({ workflow_id: workflowId, interaction_id: interactionId });
+    if (workflowName) params.set("workflow_name", workflowName);
+    const res = await this.http.get(`/api/chat/io-logs?${params}`);
+    return (res.in_out_logs ?? []).map((r) => ({
+      logId: r.log_id,
+      ioId: r.io_id,
+      interactionId: r.interaction_id,
+      workflowId: r.workflow_id,
+      workflowName: r.workflow_name,
+      input: toDisplayText(r.input_data),
+      output: toDisplayText(r.output_data),
+      attachments: toHistoryAttachments(r.attachments),
+      updatedAt: r.updated_at
+    }));
+  }
+  /** Past conversations (interactions) for the sidebar. */
+  async conversations() {
+    const res = await this.http.get("/api/interaction/list");
+    return (res.execution_meta_list ?? []).map((r) => ({
+      id: r.id,
+      interactionId: r.interaction_id,
+      workflowId: r.workflow_id,
+      workflowName: r.workflow_name,
+      interactionCount: r.interaction_count ?? 0,
+      metadata: r.metadata ?? {},
+      createdAt: r.created_at ?? "",
+      updatedAt: r.updated_at ?? ""
+    }));
+  }
+};
+
+// ../../packages/protocol/src/preferences.ts
+var PreferencesApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** GET /api/admin/user → preferences.avatar.
+   *
+   *  THROWS on failure (network / 401 / not-yet-authenticated) rather than
+   *  returning an empty config: at startup the overlay's fetch can beat the
+   *  main window's session restore, and masking that as `{enabled:false}` made
+   *  the avatar look permanently absent. Propagating lets the caller retry until
+   *  the client is authed. A genuinely empty config (feature off) still returns
+   *  normally. */
+  async getAvatarConfig() {
+    const res = await this.http.get("/api/admin/user");
+    if (!res || !res.user) {
+      throw new Error("avatar config: no authenticated profile");
+    }
+    let prefs = res.user.preferences ?? {};
+    if (typeof prefs === "string") {
+      try {
+        prefs = JSON.parse(prefs);
+      } catch {
+        prefs = {};
+      }
+    }
+    const raw = prefs?.avatar ?? {};
+    return {
+      enabled: !!raw.enabled,
+      defaultAvatarId: typeof raw.defaultAvatarId === "string" ? raw.defaultAvatarId : null,
+      avatars: Array.isArray(raw.avatars) ? raw.avatars : []
+    };
+  }
+  /** Persist the whole avatar config (PUT shallow-merges preferences top-level,
+   *  so sending {avatar} replaces just that key). Used when the overlay adjusts
+   *  the avatar's scale/position in-place. */
+  async saveAvatarConfig(config) {
+    await this.http.put("/api/admin/user", { preferences: { avatar: config } });
+  }
+  /** Read-modify-write: 서버의 CURRENT config 를 읽어 최소 패치만 적용한다.
+   *  화면에 캐시된 스냅샷 전체를 저장하면 그 사이의 변경(선택 등)을 조용히
+   *  되돌린다 — 모든 부분 수정은 반드시 이 경로를 쓴다. */
+  async mutateAvatarConfig(mutate) {
+    const cfg = await this.getAvatarConfig();
+    const next = mutate(cfg);
+    await this.saveAvatarConfig(next);
+    return next;
+  }
+  /** Persist ONE avatar's scale/position (read-modify-write). */
+  async saveAvatarTransform(avatarId, tf) {
+    await this.mutateAvatarConfig((cfg) => ({
+      ...cfg,
+      avatars: cfg.avatars.map(
+        (a) => a.id === avatarId ? { ...a, scale: tf.scale, position: tf.position } : a
+      )
+    }));
+  }
+  setAvatarEnabled(enabled) {
+    return this.mutateAvatarConfig((c) => ({ ...c, enabled }));
+  }
+  selectAvatar(id) {
+    return this.mutateAvatarConfig((c) => ({ ...c, defaultAvatarId: id }));
+  }
+  renameAvatar(id, name) {
+    return this.mutateAvatarConfig((c) => ({
+      ...c,
+      avatars: c.avatars.map((a) => a.id === id ? { ...a, name } : a)
+    }));
+  }
+  /** Add an uploaded/downloaded descriptor (optionally renamed); first avatar
+   *  becomes the selection. */
+  addAvatar(descriptor, name) {
+    return this.mutateAvatarConfig((c) => ({
+      ...c,
+      avatars: [...c.avatars, { ...descriptor, name: (name ?? descriptor.name) || descriptor.name }],
+      defaultAvatarId: c.defaultAvatarId ?? descriptor.id
+    }));
+  }
+  removeAvatar(id) {
+    return this.mutateAvatarConfig((c) => {
+      const remaining = c.avatars.filter((a) => a.id !== id);
+      return {
+        ...c,
+        avatars: remaining,
+        defaultAvatarId: c.defaultAvatarId === id ? remaining[0]?.id ?? null : c.defaultAvatarId
+      };
+    });
+  }
+};
+
+// ../../packages/protocol/src/ssh.ts
+var BASE = "/api/agentflow/user-ssh";
+var SshApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  getConfig() {
+    return this.http.get(`${BASE}/config`);
+  }
+  /** Master switch only — the server list survives being turned off. */
+  setEnabled(enabled) {
+    return this.http.put(`${BASE}/config`, { enabled });
+  }
+  createServer(input) {
+    return this.http.post(`${BASE}/servers`, input);
+  }
+  /** Partial update. Renaming also rewrites this server out of others' jump paths. */
+  updateServer(name, input) {
+    return this.http.put(`${BASE}/servers/${encodeURIComponent(name)}`, input);
+  }
+  /** Refused (400) while another server still lists it as a jump host. */
+  deleteServer(name) {
+    return this.http.del(`${BASE}/servers/${encodeURIComponent(name)}`);
+  }
+  /**
+   * Dial it for real, through the jump path.
+   *
+   * Works regardless of the master switch — you must be able to check a server
+   * *before* turning the feature on, otherwise the only order available is
+   * "switch it on and hope".
+   *
+   * The connection is opened by the XGEN server, not this machine: the agent
+   * runs there, so that is the only reachability that matters.
+   */
+  testServer(name) {
+    return this.http.post(
+      `${BASE}/servers/${encodeURIComponent(name)}/test`,
+      {},
+      // A three-hop chain can legitimately take a while; the default JSON
+      // timeout would report a failure the server never saw.
+      { timeoutMs: 7e4 }
+    );
+  }
+};
+
+// ../../packages/protocol/src/teams.ts
+var str = (v, fallback = "") => typeof v === "string" ? v : v === null || v === void 0 ? fallback : String(v);
+var num = (v, fallback = 0) => {
+  const n = Number(v);
+  return Number.isFinite(n) ? n : fallback;
+};
+function normalizeRouterMode(v) {
+  const raw = str(v, "hybrid");
+  if (raw === "chat" || raw === "manual" || raw === "hybrid" || raw === "auto") return raw;
+  return "hybrid";
+}
+function normalizeSenderType(v) {
+  const raw = str(v, "user");
+  if (raw === "agent" || raw === "router" || raw === "system") return raw;
+  return "user";
+}
+function mapRoom(raw) {
+  const r = raw ?? {};
+  return {
+    id: str(r.id),
+    name: str(r.name, "\uC774\uB984 \uC5C6\uB294 \uB300\uD654"),
+    description: str(r.description) || void 0,
+    routerMode: normalizeRouterMode(r.router_mode),
+    isDirect: Boolean(r.is_direct),
+    createdAt: str(r.created_at),
+    createdBy: num(r.created_by),
+    lastMessageAt: str(r.last_message_at) || void 0
+  };
+}
+function mapMember(raw) {
+  const m = raw ?? {};
+  const role = str(m.role, "member");
+  return {
+    userId: num(m.user_id),
+    username: str(m.username) || `User-${num(m.user_id)}`,
+    fullName: str(m.full_name) || str(m.name) || void 0,
+    role: role === "owner" || role === "admin" ? role : "member",
+    isOnline: Boolean(m.is_online),
+    joinedAt: str(m.joined_at)
+  };
+}
+function directRoomNameForViewer(room, members, viewerUserId) {
+  if (!room.isDirect || !viewerUserId) return room.name;
+  const other = members.find((member) => String(member.userId) !== viewerUserId);
+  return other ? other.fullName || other.username || room.name : room.name;
+}
+function mapReactions(raw) {
+  if (!Array.isArray(raw) || raw.length === 0) return void 0;
+  return raw.map((item) => {
+    const r = item ?? {};
+    return {
+      emoji: str(r.emoji),
+      count: num(r.count),
+      userIds: Array.isArray(r.user_ids) ? r.user_ids.map((x) => num(x)) : []
+    };
+  });
+}
+function mapAttachment(raw) {
+  const a = raw ?? {};
+  const extracted = str(a.extracted_text) || str(a.extractedText);
+  return {
+    id: str(a.id),
+    filename: str(a.original_filename) || str(a.display_name) || str(a.name) || str(a.filename, "file"),
+    mime: str(a.mime, "application/octet-stream"),
+    size: num(a.size),
+    storageKey: str(a.storage_key) || str(a.storageKey),
+    extractedText: extracted || void 0,
+    truncated: Boolean(a.truncated) || void 0
+  };
+}
+function mapAttachments(raw) {
+  let arr = [];
+  if (Array.isArray(raw)) arr = raw;
+  else if (typeof raw === "string" && raw.trim().startsWith("[")) {
+    try {
+      const parsed = JSON.parse(raw);
+      if (Array.isArray(parsed)) arr = parsed;
+    } catch {
+      arr = [];
+    }
+  }
+  if (arr.length === 0) return void 0;
+  return arr.map((item) => {
+    const { extractedText: _drop, ...meta } = mapAttachment(item);
+    return meta;
+  });
+}
+function senderName(raw, type, senderId) {
+  const name = str(raw).trim();
+  if (name) return name;
+  if (type === "system") return "\uC2DC\uC2A4\uD15C";
+  if (type === "agent") return "Agent";
+  return senderId ? `User-${senderId}` : "\uC54C \uC218 \uC5C6\uC74C";
+}
+function mapMessage(raw) {
+  const m = raw ?? {};
+  const type = normalizeSenderType(m.sender_type);
+  const senderId = str(m.sender_id);
+  return {
+    id: str(m.id),
+    roomId: str(m.room_id),
+    senderType: type,
+    senderId,
+    senderName: senderName(m.sender_name, type, senderId),
+    content: str(m.content),
+    createdAt: str(m.created_at),
+    reactions: mapReactions(m.reactions),
+    attachments: mapAttachments(m.attachments),
+    replyToId: str(m.reply_to_id) || void 0,
+    replyToSenderName: str(m.reply_to_sender_name) || void 0,
+    replyToContent: str(m.reply_to_content) || void 0,
+    isEdited: Boolean(m.is_edited),
+    editedAt: str(m.edited_at) || void 0
+  };
+}
+function safeMapMessage(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  try {
+    const mapped = mapMessage(raw);
+    return mapped.id ? mapped : null;
+  } catch {
+    return null;
+  }
+}
+var TEAMS_ATTACHMENT_MAX_BYTES = 50 * 1024 * 1024;
+var TeamsApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  // ── 방 ───────────────────────────────────────────────────
+  /** 내가 속한 방 전체. 최근 메시지 순 정렬은 호출자(렌더러 store)가 한다. */
+  async listRooms(viewerUserId) {
+    const res = await this.http.get("/api/teams/rooms/list");
+    const rooms = (res.data ?? []).map(mapRoom);
+    if (!viewerUserId) return rooms;
+    return Promise.all(
+      rooms.map(async (room) => {
+        if (!room.isDirect) return room;
+        try {
+          const members = await this.listMembers(room.id);
+          return { ...room, name: directRoomNameForViewer(room, members, viewerUserId) };
+        } catch {
+          return room;
+        }
+      })
+    );
+  }
+  async getRoom(roomId) {
+    const res = await this.http.get(
+      `/api/teams/rooms/${encodeURIComponent(roomId)}`
+    );
+    return res.data ? mapRoom(res.data) : null;
+  }
+  async createRoom(opts) {
+    const res = await this.http.post("/api/teams/rooms/create", {
+      name: opts.name,
+      description: opts.description ?? null,
+      router_mode: opts.routerMode ?? "chat"
+    });
+    return mapRoom(res.data);
+  }
+  /**
+   * 1:1 대화 — 이미 있으면 그 방을, 없으면 새로 만들어 돌려준다.
+   * 서버가 `dm:u{min}:u{max}` 키로 중복을 막으므로 클라이언트가 찾을 필요가 없다.
+   */
+  async openDirectMessage(userId, username) {
+    const res = await this.http.post(
+      "/api/teams/rooms/dm/lookup-or-create",
+      {
+        target_type: "user",
+        target_id: String(userId),
+        target_name: username ?? null,
+        target_description: null,
+        target_color: null
+      }
+    );
+    return mapRoom(res.data?.room);
+  }
+  /**
+   * 방 정보 수정 (이름·설명). 서버는 **멤버 전원**에게 허용한다(방장 전용이 아니다).
+   *
+   * ⚠ 서버가 이 변경을 broadcast 하지 않는다 — 다른 클라이언트는 새로고침 전까지
+   * 옛 이름을 본다. 우리 화면만 즉시 갱신할 수 있다.
+   */
+  async updateRoom(roomId, patch) {
+    const res = await this.http.put(
+      `/api/teams/rooms/${encodeURIComponent(roomId)}`,
+      {
+        // 서버는 null 을 "변경 없음" 으로 읽는다. 보내지 않을 값은 넣지 않는다.
+        ...patch.name !== void 0 ? { name: patch.name } : {},
+        ...patch.description !== void 0 ? { description: patch.description } : {}
+      }
+    );
+    return res.data ? mapRoom(res.data) : null;
+  }
+  /** 마지막 멤버의 나가기를 빈 방 정리로 바꿀 때만 쓰는 내부 경로. */
+  async deleteRoom(roomId) {
+    await this.http.del(`/api/teams/rooms/${encodeURIComponent(roomId)}`);
+  }
+  /**
+   * 사용자가 보는 방 종료 동작은 항상 "나가기" 하나다. 마지막 멤버라면 빈 방을
+   * 남기지 않도록 내부적으로 방을 정리한다. 멤버 조회나 정리 권한이 없는 구버전
+   * 서버에서는 기존 leave API 로 폴백해 사용자가 방에 갇히지 않게 한다.
+   */
+  async leaveRoom(roomId) {
+    let lastMember = false;
+    try {
+      lastMember = (await this.listMembers(roomId)).length <= 1;
+    } catch {
+    }
+    if (lastMember) {
+      try {
+        await this.deleteRoom(roomId);
+        return;
+      } catch {
+      }
+    }
+    await this.http.post(`/api/teams/rooms/${encodeURIComponent(roomId)}/leave`);
+  }
+  // ── 멤버 ─────────────────────────────────────────────────
+  async listMembers(roomId) {
+    const res = await this.http.get(
+      `/api/teams/rooms/${encodeURIComponent(roomId)}/members`
+    );
+    return (res.data ?? []).map(mapMember);
+  }
+  async addMember(roomId, userId) {
+    await this.http.post(`/api/teams/rooms/${encodeURIComponent(roomId)}/members`, {
+      user_id: userId,
+      role: "member",
+      force_override: false
+    });
+  }
+  /** 초대 대상 검색. 빈 질의는 서버를 부르지 않는다. */
+  async searchUsers(query, limit = 20) {
+    const q = query.trim();
+    if (!q) return [];
+    const params = new URLSearchParams({ q, limit: String(limit) });
+    const res = await this.http.get(`/api/teams/users/search?${params}`);
+    return (res.data ?? []).map((item) => {
+      const u = item ?? {};
+      const id = num(u.id);
+      return {
+        id,
+        username: str(u.username) || str(u.user_name) || `user_${id}`,
+        fullName: str(u.full_name) || str(u.name) || void 0,
+        email: str(u.email) || void 0
+      };
+    });
+  }
+  // ── 메시지 ───────────────────────────────────────────────
+  /**
+   * 메시지 조회 (커서 페이지네이션). `before` 는 더 과거를 부르는 커서이고,
+   * 서버는 **최신순**으로 돌려주므로 시간 오름차순 정렬은 호출자가 한다
+   * (렌더러 store 의 mergeMessages 가 담당).
+   */
+  async listMessages(roomId, opts) {
+    const params = new URLSearchParams({ limit: String(opts?.limit ?? 50) });
+    if (opts?.before) params.set("before", opts.before);
+    const res = await this.http.get(
+      `/api/teams/rooms/${encodeURIComponent(roomId)}/messages?${params}`
+    );
+    return (res.data ?? []).flatMap((raw) => {
+      const mapped = safeMapMessage(raw);
+      return mapped ? [mapped] : [];
+    });
+  }
+  /**
+   * 메시지 전송. 응답의 `data.message` 가 서버가 확정한 메시지다 —
+   * 낙관적으로 그려 둔 임시 메시지를 이것으로 교체한다.
+   *
+   * 라우팅 결과(`data.routing`)는 에이전트 실행용이라 1차 범위에서는 버린다.
+   * router_mode='chat' 방에서는 서버가 애초에 에이전트를 부르지 않는다.
+   */
+  async sendMessage(roomId, content, opts) {
+    const res = await this.http.post(
+      `/api/teams/rooms/${encodeURIComponent(roomId)}/messages`,
+      {
+        content,
+        mentioned_agent_ids: null,
+        attachments: opts?.attachments?.length ? opts.attachments.map((a) => ({
+          id: a.id,
+          filename: a.filename,
+          mime: a.mime,
+          size: a.size,
+          storage_key: a.storageKey,
+          // 업로드 응답을 그대로 되돌려준다 — null 로 덮으면 첨부 내용이 사라진다.
+          extracted_text: a.extractedText ?? null,
+          truncated: a.truncated ?? false
+        })) : null,
+        discussion_max_rounds: null,
+        reply_to_id: opts?.replyToId ?? null
+      }
+    );
+    const mapped = safeMapMessage(res.data?.message);
+    if (!mapped) throw new Error("\uBA54\uC2DC\uC9C0\uB97C \uBCF4\uB0C8\uC9C0\uB9CC \uC11C\uBC84 \uC751\uB2F5\uC744 \uD574\uC11D\uD558\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4.");
+    return mapped;
+  }
+  /** 본인 메시지 편집. 서버가 `message_updated` 를 broadcast 한다. */
+  async editMessage(roomId, messageId, content) {
+    const res = await this.http.patch(
+      `/api/teams/rooms/${encodeURIComponent(roomId)}/messages/${encodeURIComponent(messageId)}`,
+      { content }
+    );
+    return safeMapMessage(res.data);
+  }
+  // ── 첨부 ─────────────────────────────────────────────────
+  /**
+   * 첨부 업로드 → 메타. 이 메타를 `sendMessage` 의 `attachments` 로 넘겨야
+   * 실제로 메시지에 붙는다 (업로드만으로는 방에 나타나지 않는다).
+   *
+   * 서버가 같은 요청 안에서 문서 본문까지 추출해 `extracted_text` 로 돌려주므로
+   * 응답을 통째로 들고 다닌다 — 그래야 나중에 에이전트가 그 파일의 내용을 본다.
+   * 상한은 서버 기준 50MB, 허용 확장자는 `attachment_controller.ALLOWED_EXTENSIONS`.
+   */
+  async uploadAttachment(roomId, bytes, filename, mime) {
+    const form = new FormData();
+    const buf = bytes.buffer.slice(
+      bytes.byteOffset,
+      bytes.byteOffset + bytes.byteLength
+    );
+    form.append("file", new Blob([buf], mime ? { type: mime } : void 0), filename);
+    const res = await this.http.upload(
+      `/api/teams/rooms/${encodeURIComponent(roomId)}/attachments/upload`,
+      form,
+      // 50MB 까지 받는 엔드포인트라 기본 타임아웃으로는 큰 파일이 끊긴다.
+      { timeoutMs: 3e5 }
+    );
+    const mapped = mapAttachment(res.data);
+    if (!mapped.storageKey) throw new Error("\uCCA8\uBD80\uB97C \uC62C\uB838\uC9C0\uB9CC \uC11C\uBC84 \uC751\uB2F5\uC744 \uD574\uC11D\uD558\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4.");
+    return { ...mapped, filename: mapped.filename || filename };
+  }
+  /**
+   * 첨부 원본 바이트. 다운로드 주소에 `filename` 을 함께 넘겨야 서버가
+   * Content-Disposition 에 실제 이름을 실어 준다 (안 넘기면 `att-xxx.docx` 로 떨어진다).
+   */
+  async downloadAttachment(roomId, attachment) {
+    const params = attachment.filename ? `?filename=${encodeURIComponent(attachment.filename)}` : "";
+    const { bytes } = await this.http.getBinary(
+      `/api/teams/rooms/${encodeURIComponent(roomId)}/attachments/${encodeURIComponent(
+        attachment.storageKey
+      )}${params}`
+    );
+    return bytes;
+  }
+  /**
+   * 이모지 리액션 토글. 서버가 집계 전체를 돌려주고 동시에 `reaction_update` 를
+   * broadcast 하므로, 반환값은 즉시 반영용 보조다.
+   */
+  async toggleReaction(roomId, messageId, emoji) {
+    const res = await this.http.post(
+      `/api/teams/rooms/${encodeURIComponent(roomId)}/messages/${encodeURIComponent(messageId)}/reactions`,
+      { emoji }
+    );
+    return mapReactions(res.data?.reactions) ?? [];
+  }
+};
+
+// ../../packages/protocol/src/voice.ts
+function filenameFor(mime) {
+  const m = (mime || "").toLowerCase();
+  if (m.includes("webm")) return "audio.webm";
+  if (m.includes("ogg")) return "audio.ogg";
+  if (m.includes("wav")) return "audio.wav";
+  if (m.includes("mp4") || m.includes("m4a") || m.includes("aac")) return "audio.m4a";
+  if (m.includes("mpeg") || m.includes("mp3")) return "audio.mp3";
+  return "audio.webm";
+}
+var VoiceApi = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** GET /api/admin/user → { stt: preferences.stt|null, tts: preferences.tts|null }.
+   *  UI hints only — no secrets. THROWS when not yet authenticated (mirrors
+   *  PreferencesApi.getAvatarConfig) so callers can retry rather than latch a
+   *  false "voice off". */
+  async getVoiceConfig() {
+    const res = await this.http.get("/api/admin/user");
+    if (!res || !res.user) {
+      throw new Error("voice config: no authenticated profile");
+    }
+    let prefs = res.user.preferences ?? {};
+    if (typeof prefs === "string") {
+      try {
+        prefs = JSON.parse(prefs);
+      } catch {
+        prefs = {};
+      }
+    }
+    const p = prefs ?? {};
+    const stt = p.stt && typeof p.stt === "object" ? p.stt : null;
+    const tts = p.tts && typeof p.tts === "object" ? p.tts : null;
+    return { stt, tts };
+  }
+  /** POST an audio clip → transcript text. Uses the caller's saved STT
+   *  preference server-side unless `language` overrides it. */
+  async transcribe(blob, language) {
+    const form = new FormData();
+    form.append("file", blob, filenameFor(blob.type));
+    if (language) form.append("language", language);
+    const res = await this.http.upload("/api/audio/stt/transcribe", form);
+    return res?.text ?? "";
+  }
+  /** POST text → synthesized audio Blob. Uses the caller's active TTS profile
+   *  server-side unless `opts` overrides it. */
+  async speak(text, opts) {
+    const { bytes, contentType } = await this.http.postBinary(
+      "/api/audio/tts/speak",
+      { text, ...opts ?? {} },
+      // Synthesis can take a few seconds for longer replies.
+      { timeoutMs: 6e4 }
+    );
+    const buf = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+    return new Blob([buf], { type: contentType || "audio/wav" });
+  }
+};
+
+// ../../packages/protocol/src/index.ts
+var XgenClient = class {
+  http;
+  auth;
+  agents;
+  chat;
+  history;
+  preferences;
+  ssh;
+  teams;
+  avatars;
+  voice;
+  agentData;
+  refreshToken;
+  onTokensRotated;
+  /** ensureFreshAuth 의 single-flight 가드 — 동시 401 들이 refresh 를 한 번만 태운다. */
+  refreshing = null;
+  user = null;
+  constructor(opts) {
+    this.http = new HttpClient({
+      baseUrl: opts.baseUrl,
+      fetch: opts.fetch,
+      onAuthFailure: opts.onAuthFailure
+    });
+    if (opts.accessToken) this.http.setToken(opts.accessToken);
+    this.refreshToken = opts.refreshToken;
+    this.onTokensRotated = opts.onTokensRotated;
+    this.auth = new AuthApi(this.http);
+    this.agents = new AgentsApi(this.http);
+    this.chat = new ChatApi(this.http);
+    this.history = new HistoryApi(this.http);
+    this.preferences = new PreferencesApi(this.http);
+    this.ssh = new SshApi(this.http);
+    this.teams = new TeamsApi(this.http);
+    this.avatars = new AvatarsApi(this.http);
+    this.voice = new VoiceApi(this.http);
+    this.agentData = new AgentDataApi(this.http);
+  }
+  setBaseUrl(baseUrl) {
+    this.http.setBaseUrl(baseUrl);
+  }
+  setTokens(accessToken, refreshToken) {
+    this.http.setToken(accessToken);
+    if (refreshToken !== void 0) this.refreshToken = refreshToken;
+  }
+  /** Log in and adopt the returned tokens. */
+  async login(email, password) {
+    return this.adoptLogin(await this.auth.login(email, password));
+  }
+  /** Adopt tokens returned by an external SSO bridge and resolve full identity. */
+  async adoptLogin(res) {
+    this.http.setToken(res.accessToken);
+    this.refreshToken = res.refreshToken;
+    this.onTokensRotated?.(res.accessToken, res.refreshToken);
+    this.user = {
+      userId: res.userId,
+      username: res.username,
+      isSuperuser: false,
+      roles: [],
+      permissions: []
+    };
+    try {
+      const { user } = await this.auth.validate(res.accessToken, res.refreshToken);
+      if (user) this.user = user;
+    } catch {
+    }
+    return res;
+  }
+  /**
+   * Validate the current session, rotating the access token if the gateway
+   * returned a fresh one. Returns true if still/again authenticated.
+   */
+  async restore(accessToken, refreshToken) {
+    return await this.restoreDetailed(accessToken, refreshToken) === "valid";
+  }
+  /**
+   * restore() 의 판정 세분화 — 호출자가 토큰 폐기 여부를 올바르게 정할 수
+   * 있게 한다 (geny-connector validateAndRefreshAuth 강건성 이식):
+   *   'valid'   — 인증 성공 (토큰 회전 반영됨)
+   *   'invalid' — 서버가 **응답으로** 거부 (토큰 폐기가 맞다)
+   *   'network' — 서버 미응답/네트워크 오류 (토큰을 지우면 안 된다 — 일시
+   *               장애 후 재시작에서 재로그인을 강요하게 된다)
+   */
+  async restoreDetailed(accessToken, refreshToken) {
+    this.http.setToken(accessToken);
+    this.refreshToken = refreshToken;
+    let sawNetworkError = false;
+    try {
+      const { user, newAccessToken } = await this.auth.validate(accessToken, refreshToken);
+      if (newAccessToken) {
+        this.http.setToken(newAccessToken);
+        this.onTokensRotated?.(newAccessToken, refreshToken);
+      }
+      if (user) {
+        this.user = user;
+        return "valid";
+      }
+    } catch {
+      sawNetworkError = true;
+    }
+    if (refreshToken) {
+      try {
+        const fresh = await this.auth.refresh(refreshToken);
+        if (fresh) {
+          this.http.setToken(fresh);
+          this.onTokensRotated?.(fresh, refreshToken);
+          const { user } = await this.auth.validate(fresh, refreshToken);
+          if (user) {
+            this.user = user;
+            return "valid";
+          }
+        }
+        sawNetworkError = false;
+      } catch {
+        sawNetworkError = true;
+      }
+    }
+    return sawNetworkError ? "network" : "invalid";
+  }
+  getAccessTokenAfterRotation() {
+    return this.http.accessToken ?? "";
+  }
+  /**
+   * 인증 실패(401/403)를 맞은 소비자가 부르는 **자가치유** 경로: refresh 토큰으로
+   * 액세스 토큰을 회전시키고 새 토큰을 돌려준다. 실패(refresh 토큰 없음/거부)면
+   * null — 그때는 진짜 재로그인 대상이다.
+   *
+   * single-flight: WS 브릿지·워크스페이스 동기화·HTTP 가 동시에 401 을 맞아도
+   * refresh 는 한 번만 나간다 (게이트웨이는 refresh 마다 이전 세션을 지우므로,
+   * 동시 refresh 는 서로의 새 토큰을 폐기하는 경쟁이 된다).
+   *
+   * ``fallbackRefreshToken`` — 인메모리에 refresh 토큰이 없을 때(재시작 직후 등)
+   * 호스트가 keychain 값을 넘겨줄 수 있다.
+   */
+  async ensureFreshAuth(fallbackRefreshToken) {
+    if (this.refreshing) return this.refreshing;
+    const rt = this.refreshToken ?? fallbackRefreshToken;
+    if (!rt) return null;
+    this.refreshing = (async () => {
+      try {
+        const fresh = await this.auth.refresh(rt);
+        if (!fresh) return null;
+        this.http.setToken(fresh);
+        this.refreshToken = rt;
+        this.onTokensRotated?.(fresh, rt);
+        return fresh;
+      } catch {
+        return null;
+      } finally {
+        this.refreshing = null;
+      }
+    })();
+    return this.refreshing;
+  }
+  /** The current refresh token, so the host can persist it (e.g. keychain). */
+  getRefreshToken() {
+    return this.refreshToken;
+  }
+  async logout() {
+    const token = this.getAccessTokenAfterRotation();
+    if (token) await this.auth.logout(token);
+    this.http.setToken(null);
+    this.refreshToken = void 0;
+    this.user = null;
+  }
+};
+
+// ../../packages/engine/src/mcp-bridge.ts
+import WebSocket from "ws";
+
+// ../../packages/engine/src/secret-stores.ts
+var MCP_SECRET_PREFIX = "xgen_mcp_secret_";
+var MCP_OAUTH_PREFIX = "xgen_mcp_oauth_";
+function nonEmpty(o) {
+  return !!o && Object.values(o).some((v) => typeof v === "string" && v.length > 0);
+}
+function parseObject(raw, fallback) {
+  if (!raw) return fallback;
+  try {
+    const p = JSON.parse(raw);
+    return p && typeof p === "object" ? p : fallback;
+  } catch {
+    return fallback;
+  }
+}
+function createMcpSecretStore(secrets) {
+  return {
+    /** 비어 있으면 저장이 아니라 **삭제**다 — 빈 객체를 남기면 다음 로드가
+     *  "설정됨"으로 읽고 사용자는 왜 인증이 안 되는지 알 수 없다. */
+    async save(server, value) {
+      if (!nonEmpty(value.env) && !nonEmpty(value.headers)) {
+        await secrets.set(MCP_SECRET_PREFIX + server, null);
+        return true;
+      }
+      return secrets.set(MCP_SECRET_PREFIX + server, JSON.stringify(value));
+    },
+    async get(server) {
+      return parseObject(
+        await secrets.get(MCP_SECRET_PREFIX + server),
+        null
+      );
+    },
+    async clear(server) {
+      await secrets.set(MCP_SECRET_PREFIX + server, null);
+    }
+  };
+}
+function createMcpOAuthStore(secrets) {
+  const writeChain = /* @__PURE__ */ new Map();
+  const store = {
+    async load(server) {
+      return parseObject(await secrets.get(MCP_OAUTH_PREFIX + server), {});
+    },
+    async save(server, state) {
+      return secrets.set(MCP_OAUTH_PREFIX + server, JSON.stringify(state));
+    },
+    async patch(server, patch) {
+      const prev = writeChain.get(server) ?? Promise.resolve();
+      const next = prev.then(async () => {
+        const cur = await store.load(server);
+        return store.save(server, { ...cur, ...patch });
+      });
+      writeChain.set(
+        server,
+        next.catch(() => void 0)
+      );
+      return next;
+    },
+    async clear(server) {
+      await secrets.set(MCP_OAUTH_PREFIX + server, null);
+      writeChain.delete(server);
+    }
+  };
+  return store;
+}
+
+// ../../packages/engine/src/host.ts
+var bound = null;
+function bindHost(ports) {
+  bound = {
+    ports,
+    mcpSecrets: createMcpSecretStore(ports.secrets),
+    mcpOAuth: createMcpOAuthStore(ports.secrets)
+  };
+}
+function isHostBound() {
+  return bound !== null;
+}
+function need() {
+  if (!bound) {
+    throw new Error(
+      "@dex/engine: \uD638\uC2A4\uD2B8\uAC00 \uBD99\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4. \uC571 \uC2DC\uC791 \uC2DC bindHost({ secrets, config, paths }) \uB97C \uD55C \uBC88 \uD638\uCD9C\uD558\uC138\uC694."
+    );
+  }
+  return bound;
+}
+function hostPorts() {
+  return need().ports;
+}
+function interaction() {
+  return need().ports.interaction ?? {};
+}
+var mcpSecretStore = {
+  save: (s, v) => need().mcpSecrets.save(s, v),
+  get: (s) => need().mcpSecrets.get(s),
+  clear: (s) => need().mcpSecrets.clear(s)
+};
+var mcpOAuthStore = {
+  load: (s) => need().mcpOAuth.load(s),
+  save: (s, v) => need().mcpOAuth.save(s, v),
+  patch: (s, p) => need().mcpOAuth.patch(s, p),
+  clear: (s) => need().mcpOAuth.clear(s)
+};
+
+// ../../packages/engine/src/mcp-secrets.ts
+function resolveSecretKv(configVals, secretVals) {
+  const keys = /* @__PURE__ */ new Set([...Object.keys(configVals || {}), ...Object.keys(secretVals || {})]);
+  if (!keys.size) return void 0;
+  const out = {};
+  for (const k of keys) {
+    const cfg = configVals?.[k];
+    const v = cfg && cfg.length ? cfg : secretVals?.[k] || "";
+    if (v) out[k] = v;
+  }
+  return Object.keys(out).length ? out : void 0;
+}
+function withResolvedSecrets(cfg, secrets) {
+  const env = resolveSecretKv(cfg.env, secrets?.env ?? void 0);
+  const headers = resolveSecretKv(cfg.headers, secrets?.headers ?? void 0);
+  const out = { ...cfg };
+  if (env) out.env = env;
+  else delete out.env;
+  if (headers) out.headers = headers;
+  else delete out.headers;
+  return out;
+}
+
+// ../../packages/engine/src/mcp-oauth.ts
+var CLIENT_NAME = "XGen Dex";
+var AUTH_TIMEOUT_MS = 5 * 6e4;
+var ConnectorOAuthProvider = class {
+  constructor(server, port, interactive, onRedirect, stateValue) {
+    this.server = server;
+    this.port = port;
+    this.interactive = interactive;
+    this.onRedirect = onRedirect;
+    this.stateValue = stateValue;
+  }
+  get redirectUrl() {
+    return `http://127.0.0.1:${this.port}/callback`;
+  }
+  /** OAuth2 state (CSRF) — only the interactive flow sets one; verified at the
+   *  loopback callback before the code is accepted. */
+  state() {
+    return this.stateValue;
+  }
+  get clientMetadata() {
+    return {
+      client_name: CLIENT_NAME,
+      redirect_uris: [this.redirectUrl],
+      grant_types: ["authorization_code", "refresh_token"],
+      response_types: ["code"],
+      token_endpoint_auth_method: "none"
+    };
+  }
+  async clientInformation() {
+    return (await mcpOAuthStore.load(this.server)).clientInformation;
+  }
+  async saveClientInformation(info) {
+    await mcpOAuthStore.patch(this.server, { clientInformation: info });
+  }
+  async tokens() {
+    return (await mcpOAuthStore.load(this.server)).tokens;
+  }
+  async saveTokens(tokens) {
+    await mcpOAuthStore.patch(this.server, { tokens });
+  }
+  async saveCodeVerifier(v) {
+    await mcpOAuthStore.patch(this.server, { codeVerifier: v });
+  }
+  async codeVerifier() {
+    const s = await mcpOAuthStore.load(this.server);
+    if (!s.codeVerifier) throw new Error("PKCE code_verifier \uAC00 \uC5C6\uC2B5\uB2C8\uB2E4 (\uC7AC\uC778\uC99D\uC774 \uD544\uC694\uD569\uB2C8\uB2E4).");
+    return s.codeVerifier;
+  }
+  async redirectToAuthorization(url) {
+    if (!this.interactive) return;
+    if (this.onRedirect) await this.onRedirect(url);
+  }
+  /** SDK self-heal: on InvalidGrant/registration errors the SDK asks us to drop
+   *  the stale credential so the next attempt re-registers / re-authorizes. */
+  async invalidateCredentials(scope) {
+    if (scope === "all") {
+      await mcpOAuthStore.clear(this.server);
+      return;
+    }
+    await mcpOAuthStore.patch(this.server, {
+      ...scope === "client" ? { clientInformation: void 0 } : {},
+      ...scope === "tokens" ? { tokens: void 0 } : {},
+      ...scope === "verifier" ? { codeVerifier: void 0 } : {}
+    });
+  }
+};
+function makeSilentOAuthProvider(server) {
+  return new ConnectorOAuthProvider(server, 0, false);
+}
+function oauthTransportOptions(cfg, base) {
+  if (cfg.auth !== "oauth") return base;
+  return { ...base, authProvider: makeSilentOAuthProvider(cfg.name) };
+}
+
+// ../../packages/engine/src/mcp-manager.ts
+import { homedir as homedir3 } from "os";
+
+// ../../packages/engine/src/exec-resolve.ts
+import { execFile } from "child_process";
+import { accessSync, constants, statSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { basename, delimiter, isAbsolute, join as join2, sep } from "path";
+var IS_WIN = process.platform === "win32";
+var IS_MAC = process.platform === "darwin";
+var RUNTIMES = [
+  {
+    label: "uv",
+    commands: ["uvx", "uv"],
+    what: "Python MCP \uC11C\uBC84\uB97C \uC2E4\uD589\uD558\uB294 uv \uD328\uD0A4\uC9C0 \uB9E4\uB2C8\uC800\uC758 \uC2E4\uD589\uAE30\uC785\uB2C8\uB2E4.",
+    url: "https://docs.astral.sh/uv/getting-started/installation/",
+    install: () => IS_WIN ? ['powershell -c "irm https://astral.sh/uv/install.ps1 | iex"', "winget install astral-sh.uv"] : IS_MAC ? ["curl -LsSf https://astral.sh/uv/install.sh | sh", "brew install uv"] : ["curl -LsSf https://astral.sh/uv/install.sh | sh"]
+  },
+  {
+    label: "Node.js",
+    commands: ["npx", "npm", "node"],
+    what: "JavaScript MCP \uC11C\uBC84\uB97C \uC2E4\uD589\uD558\uB294 Node.js \uB7F0\uD0C0\uC784\uC785\uB2C8\uB2E4.",
+    url: "https://nodejs.org/",
+    install: () => IS_WIN ? ["winget install OpenJS.NodeJS.LTS", "https://nodejs.org \uC5D0\uC11C LTS \uC124\uCE58 \uD504\uB85C\uADF8\uB7A8 \uB0B4\uB824\uBC1B\uAE30"] : IS_MAC ? ["brew install node", "https://nodejs.org \uC5D0\uC11C LTS \uC124\uCE58 \uD504\uB85C\uADF8\uB7A8 \uB0B4\uB824\uBC1B\uAE30"] : ["sudo apt install nodejs npm  (Debian/Ubuntu)", "https://nodejs.org \uC5D0\uC11C LTS \uB0B4\uB824\uBC1B\uAE30"]
+  },
+  {
+    label: "Python",
+    commands: ["python3", "python", "pip", "pip3", "pipx"],
+    what: "Python \uB7F0\uD0C0\uC784/\uD328\uD0A4\uC9C0 \uB3C4\uAD6C\uC785\uB2C8\uB2E4.",
+    url: "https://www.python.org/downloads/",
+    install: () => IS_WIN ? ["winget install Python.Python.3.12"] : IS_MAC ? ["brew install python"] : ["sudo apt install python3 python3-pip  (Debian/Ubuntu)"]
+  },
+  {
+    label: "Docker",
+    commands: ["docker"],
+    what: "\uCEE8\uD14C\uC774\uB108\uB85C \uBC30\uD3EC\uB41C MCP \uC11C\uBC84\uB97C \uC2E4\uD589\uD569\uB2C8\uB2E4.",
+    url: "https://docs.docker.com/get-started/get-docker/",
+    install: () => ["https://docs.docker.com/get-started/get-docker/ \uC5D0\uC11C Docker Desktop \uC124\uCE58"]
+  },
+  {
+    label: "Bun",
+    commands: ["bun", "bunx"],
+    what: "Bun \uB7F0\uD0C0\uC784\uC785\uB2C8\uB2E4.",
+    url: "https://bun.sh/",
+    install: () => IS_WIN ? ['powershell -c "irm bun.sh/install.ps1 | iex"'] : ["curl -fsSL https://bun.sh/install | bash"]
+  },
+  {
+    label: "Deno",
+    commands: ["deno"],
+    what: "Deno \uB7F0\uD0C0\uC784\uC785\uB2C8\uB2E4.",
+    url: "https://deno.land/",
+    install: () => IS_WIN ? ["irm https://deno.land/install.ps1 | iex"] : ["curl -fsSL https://deno.land/install.sh | sh"]
+  }
+];
+function runtimeFor(command) {
+  const base = basename(command.trim()).toLowerCase().replace(/\.(exe|cmd|bat|com)$/i, "");
+  return RUNTIMES.find((r) => r.commands.includes(base)) ?? null;
+}
+function commonBinDirs(home = homedir2()) {
+  if (IS_WIN) {
+    const appData = process.env.APPDATA || join2(home, "AppData", "Roaming");
+    const localAppData = process.env.LOCALAPPDATA || join2(home, "AppData", "Local");
+    return [
+      join2(localAppData, "Microsoft", "WindowsApps"),
+      join2(appData, "npm"),
+      join2(localAppData, "Programs", "nodejs"),
+      join2(home, ".local", "bin"),
+      join2(home, ".cargo", "bin"),
+      join2(home, ".bun", "bin"),
+      join2(localAppData, "Programs", "Python", "Scripts"),
+      "C:\\Program Files\\nodejs"
+    ];
+  }
+  return [
+    "/opt/homebrew/bin",
+    // Apple Silicon homebrew
+    "/usr/local/bin",
+    "/opt/local/bin",
+    // MacPorts
+    join2(home, ".local", "bin"),
+    // uv / pipx
+    join2(home, ".cargo", "bin"),
+    join2(home, ".bun", "bin"),
+    join2(home, ".deno", "bin"),
+    join2(home, "bin"),
+    "/usr/bin",
+    "/bin",
+    "/snap/bin"
+  ];
+}
+var loginPathCache = null;
+var PATH_CACHE_TTL_MS = 2e4;
+function resetPathCache() {
+  loginPathCache = null;
+}
+function parseEnvPath(stdout) {
+  let found = null;
+  for (const line of stdout.split(/\r?\n/)) {
+    const m = /^PATH=(.*)$/.exec(line);
+    if (m) found = m[1];
+  }
+  if (!found) return null;
+  const value = found.trim();
+  if (!value) return null;
+  const usable = value.split(delimiter).some((d) => {
+    if (!d) return false;
+    try {
+      return statSync(d).isDirectory();
+    } catch {
+      return false;
+    }
+  });
+  return usable ? value : null;
+}
+async function loginShellPath() {
+  if (IS_WIN) return null;
+  if (loginPathCache && Date.now() - loginPathCache.at < PATH_CACHE_TTL_MS) {
+    return loginPathCache.value;
+  }
+  const shell = process.env.SHELL || "/bin/bash";
+  const value = await new Promise((resolve) => {
+    execFile(shell, ["-ilc", "env"], { timeout: 4e3, windowsHide: true, maxBuffer: 1 << 20 }, (_err, stdout) => {
+      resolve(stdout ? parseEnvPath(stdout) : null);
+    });
+  });
+  loginPathCache = { value, at: Date.now() };
+  return value;
+}
+function mergePaths(...sources) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const src of sources) {
+    if (!src) continue;
+    for (const p of src.split(delimiter)) {
+      const dir = p.trim().replace(new RegExp(`${sep === "\\" ? "\\\\" : sep}+$`), "");
+      if (!dir || seen.has(dir)) continue;
+      seen.add(dir);
+      out.push(dir);
+    }
+  }
+  return out.join(delimiter);
+}
+async function augmentedPath() {
+  const login = await loginShellPath();
+  return mergePaths(login, process.env.PATH, commonBinDirs().join(delimiter));
+}
+function buildChildEnv(pathStr, cfgEnv, base = process.env) {
+  const isPathKey = (k) => k.toLowerCase() === "path";
+  const out = {};
+  for (const [k, v] of Object.entries(base)) {
+    if (v === void 0) continue;
+    if (IS_WIN && isPathKey(k)) continue;
+    out[k] = v;
+  }
+  const userPathKey = Object.keys(cfgEnv || {}).find(isPathKey);
+  const effectivePath = userPathKey ? cfgEnv[userPathKey] : pathStr;
+  for (const [k, v] of Object.entries(cfgEnv || {})) {
+    if (isPathKey(k)) continue;
+    out[k] = v;
+  }
+  if (IS_WIN) {
+    out.Path = effectivePath;
+  } else {
+    out.PATH = effectivePath;
+  }
+  return out;
+}
+function isExecutableFile(p) {
+  try {
+    if (!statSync(p).isFile()) return false;
+    if (IS_WIN) return true;
+    accessSync(p, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function winExtensions() {
+  const raw = process.env.PATHEXT || ".COM;.EXE;.BAT;.CMD";
+  return raw.split(";").map((e) => e.trim().toLowerCase()).filter(Boolean);
+}
+function resolveExecutable(command, pathStr) {
+  const cmd = command.trim();
+  if (!cmd) return null;
+  const hasSep = cmd.includes("/") || IS_WIN && cmd.includes("\\");
+  const candidates = (base) => IS_WIN ? [base, ...winExtensions().map((e) => base + e)] : [base];
+  if (hasSep || isAbsolute(cmd)) {
+    for (const c of candidates(cmd)) if (isExecutableFile(c)) return c;
+    return null;
+  }
+  for (const dir of pathStr.split(delimiter)) {
+    if (!dir) continue;
+    for (const c of candidates(join2(dir, cmd))) {
+      if (isExecutableFile(c)) return c;
+    }
+  }
+  return null;
+}
+function diagnoseMissing(command, pathStr) {
+  const rt = runtimeFor(command);
+  const hints = [];
+  const dirCount = pathStr.split(delimiter).filter(Boolean).length;
+  const base = basename(command);
+  if (rt) {
+    const sibling = rt.commands.find((c) => c !== base && resolveExecutable(c, pathStr));
+    if (sibling) {
+      hints.push(
+        `\uCC38\uACE0: \uAC19\uC740 \uB7F0\uD0C0\uC784\uC758 "${sibling}" \uB294 \uCC3E\uC558\uC2B5\uB2C8\uB2E4 \u2014 ${rt.label} \uBC84\uC804\uC774 \uB0AE\uC744 \uC218 \uC788\uC2B5\uB2C8\uB2E4. \uCD5C\uC2E0\uC73C\uB85C \uC62C\uB9AC\uBA74 "${base}" \uB3C4 \uD568\uAED8 \uC124\uCE58\uB429\uB2C8\uB2E4.`
+      );
+    }
+    hints.push(...rt.install().map((cmd) => `\uC124\uCE58: ${cmd}`));
+    hints.push(`\uC548\uB0B4: ${rt.url}`);
+  }
+  const example = IS_WIN ? join2(homedir2(), ".local", "bin", `${base}.exe`) : join2(homedir2(), ".local", "bin", base);
+  hints.push(
+    IS_WIN ? `\uB610\uB294 \uC2E4\uD589 \uBA85\uB839\uC5D0 \uC808\uB300 \uACBD\uB85C\uB97C \uC801\uC73C\uC138\uC694 (\uC608: ${example}). PowerShell \uC5D0\uC11C \`Get-Command ${base}\` \uB85C \uD655\uC778\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4.` : `\uB610\uB294 \uC2E4\uD589 \uBA85\uB839\uC5D0 \uC808\uB300 \uACBD\uB85C\uB97C \uC801\uC73C\uC138\uC694 (\uC608: ${example}). \uD130\uBBF8\uB110\uC5D0\uC11C \`which ${base}\` \uB85C \uD655\uC778\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4.`
+  );
+  hints.push("\uC124\uCE58\uD55C \uB4A4 [\uD14C\uC2A4\uD2B8]\uB97C \uB2E4\uC2DC \uB204\uB974\uBA74 \uC7AC\uAC80\uC0C9\uD569\uB2C8\uB2E4 (\uC571 \uC7AC\uC2DC\uC791 \uBD88\uD544\uC694).");
+  const summary = rt ? `"${command}" \u2014 \uC2E4\uD589 \uD30C\uC77C\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. ${rt.label} \uC124\uCE58\uAC00 \uD544\uC694\uD569\uB2C8\uB2E4. ${rt.what}` : `"${command}" \u2014 \uC2E4\uD589 \uD30C\uC77C\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4 (PATH ${dirCount}\uAC1C \uACBD\uB85C \uAC80\uC0C9).`;
+  return { command, summary, hints };
+}
+var ExecNotFoundError = class extends Error {
+  hints;
+  command;
+  constructor(d) {
+    super(d.summary);
+    this.name = "ExecNotFoundError";
+    this.command = d.command;
+    this.hints = d.hints;
+  }
+};
+
+// ../../packages/engine/src/mcp-manager.ts
+function tokenize(cmd) {
+  const m = cmd.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) || [];
+  return m.map((t) => t.replace(/^["']|["']$/g, ""));
+}
+function tailLines(text, maxLines = 12, maxChars = 200) {
+  return text.split(/\r?\n/).map((l) => l.replace(/\s+$/, "")).filter(Boolean).slice(-maxLines).map((l) => l.length > maxChars ? `${l.slice(0, maxChars)}\u2026` : l);
+}
+var McpStartError = class extends Error {
+  hints;
+  constructor(message, hints) {
+    super(message);
+    this.name = "McpStartError";
+    this.hints = hints;
+  }
+};
+function collectStderr(transport, onData, cap = 64 * 1024) {
+  let buf = "";
+  let last = Date.now();
+  const stream = transport.stderr;
+  stream?.on?.("data", (chunk) => {
+    buf += String(chunk);
+    if (buf.length > cap) buf = buf.slice(-cap);
+    last = Date.now();
+    onData?.(tailLines(buf));
+  });
+  return { text: () => buf, lastAt: () => last };
+}
+function throttle(fn, everyMs) {
+  let at = 0;
+  let pending = null;
+  let latest;
+  return (v) => {
+    latest = v;
+    const now = Date.now();
+    if (now - at >= everyMs) {
+      at = now;
+      fn(latest);
+      return;
+    }
+    if (pending) return;
+    pending = setTimeout(() => {
+      pending = null;
+      at = Date.now();
+      fn(latest);
+    }, everyMs - (now - at));
+  };
+}
+var _sdk = null;
+async function loadSdk() {
+  if (_sdk) return _sdk;
+  const [{ Client }, { StdioClientTransport }, { StreamableHTTPClientTransport }, sse, types] = await Promise.all([
+    import("@modelcontextprotocol/sdk/client/index.js"),
+    import("@modelcontextprotocol/sdk/client/stdio.js"),
+    import("@modelcontextprotocol/sdk/client/streamableHttp.js"),
+    // 레거시 HTTP+SSE 전송 — 없는 빌드일 수 있어 안전하게 감싼다.
+    import("@modelcontextprotocol/sdk/client/sse.js").catch(() => null),
+    // tools/list_changed 알림 스키마 — 구버전 SDK 에 없을 수 있어 안전하게 감싼다.
+    import("@modelcontextprotocol/sdk/types.js").catch(() => null)
+  ]);
+  _sdk = {
+    Client,
+    StdioClientTransport,
+    StreamableHTTPClientTransport,
+    SSEClientTransport: sse?.SSEClientTransport ?? null,
+    ToolListChangedNotificationSchema: types?.ToolListChangedNotificationSchema ?? null
+  };
+  return _sdk;
+}
+async function withTimeout(p, ms, label) {
+  let t;
+  const timeout = new Promise((_, rej) => {
+    t = setTimeout(() => rej(new Error(`${label} timed out after ${ms}ms`)), ms);
+  });
+  try {
+    return await Promise.race([p, timeout]);
+  } finally {
+    clearTimeout(t);
+  }
+}
+var IDLE_TIMEOUT_MS = 9e4;
+var MAX_START_MS = 15 * 6e4;
+async function waitWhileProgressing(p, lastAt, label, idleMs = IDLE_TIMEOUT_MS, maxMs = MAX_START_MS) {
+  const started = Date.now();
+  let timer;
+  const guard = new Promise((_, rej) => {
+    const tick = () => {
+      const idle = Date.now() - lastAt();
+      const total = Date.now() - started;
+      if (total >= maxMs) {
+        return rej(new Error(`${label}: ${Math.round(maxMs / 6e4)}\uBD84\uC744 \uB118\uACA8 \uC911\uB2E8\uD588\uC2B5\uB2C8\uB2E4`));
+      }
+      if (idle >= idleMs) {
+        return rej(
+          new Error(`${label}: ${Math.round(idleMs / 1e3)}\uCD08 \uB3D9\uC548 \uC544\uBB34 \uC751\uB2F5\uC774 \uC5C6\uC5B4 \uC911\uB2E8\uD588\uC2B5\uB2C8\uB2E4`)
+        );
+      }
+      timer = setTimeout(tick, Math.max(250, Math.min(idleMs - idle, maxMs - total)));
+    };
+    timer = setTimeout(tick, Math.min(idleMs, maxMs));
+  });
+  try {
+    return await Promise.race([p, guard]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+var MCPManager = class {
+  states = /* @__PURE__ */ new Map();
+  httpFetch;
+  allowPrivateCertificate = false;
+  /** 서버가 도구 목록을 바꾸거나(list_changed) 죽었을 때(onclose) 카탈로그를 다시
+   *  광고하도록 호출된다 (index 가 bridge.refreshCatalog 로 배선). */
+  onCatalogChange;
+  /** 카탈로그 변경(도구 추가/제거/서버 종료) 시 재광고할 리스너를 등록한다. */
+  setCatalogChangeListener(fn) {
+    this.onCatalogChange = fn;
+  }
+  /** Reconcile the configured server list into live state (drops removed,
+   *  reconnects changed configs lazily). Does NOT connect yet. */
+  configure(servers, options = {}) {
+    const certificatePolicyChanged = this.allowPrivateCertificate !== (options.allowPrivateCertificate === true);
+    this.httpFetch = options.httpFetch;
+    this.allowPrivateCertificate = options.allowPrivateCertificate === true;
+    const next = /* @__PURE__ */ new Map();
+    for (const s of servers || []) if (s && s.name) next.set(s.name, s);
+    for (const [name, st] of [...this.states]) {
+      const cfg = next.get(name);
+      if (!cfg || JSON.stringify(cfg) !== JSON.stringify(st.config) || certificatePolicyChanged && (st.config.transport === "http" || st.config.transport === "sse")) {
+        void this.disconnect(name);
+        this.states.delete(name);
+      }
+    }
+    for (const [name, cfg] of next) {
+      if (!this.states.has(name)) this.states.set(name, { config: cfg, client: null, tools: [] });
+    }
+  }
+  async connect(name) {
+    const st = this.states.get(name);
+    if (!st) throw new Error(`unknown MCP server: ${name}`);
+    if (st.client) return;
+    const label = name.replace(/^__test__/, "");
+    if (st.connecting) return st.connecting;
+    st.connecting = (async () => {
+      const {
+        Client,
+        StdioClientTransport,
+        StreamableHTTPClientTransport,
+        SSEClientTransport,
+        ToolListChangedNotificationSchema
+      } = await loadSdk();
+      const secrets = await mcpSecretStore.get(name).catch(() => null);
+      const cfg = withResolvedSecrets(st.config, secrets);
+      let transport;
+      let tap = null;
+      if (cfg.transport === "stdio") {
+        if (!cfg.command) throw new Error("stdio server has no command");
+        const [command, ...args] = cfg.args?.length ? [cfg.command.trim(), ...cfg.args] : tokenize(cfg.command);
+        if (!command) throw new Error("empty command");
+        let pathStr = await augmentedPath();
+        let resolved = resolveExecutable(command, pathStr);
+        if (!resolved) {
+          resetPathCache();
+          pathStr = await augmentedPath();
+          resolved = resolveExecutable(command, pathStr);
+        }
+        if (!resolved) throw new ExecNotFoundError(diagnoseMissing(command, pathStr));
+        transport = new StdioClientTransport({
+          command: resolved,
+          args,
+          env: buildChildEnv(pathStr, cfg.env),
+          // 작업 디렉터리를 홈으로 고정한다. 안 정하면 앱을 어떻게 띄웠는지에
+          // 따라(터미널 vs Finder/시작 메뉴) `/` 나 `C:\Windows\System32` 가
+          // 되어 상대 경로 인자와 캐시 위치가 플랫폼마다 달라진다.
+          cwd: homedir3(),
+          // 기동 실패 원인을 읽으려면 파이프여야 한다 (기본 'inherit' 는
+          // Electron 콘솔로 흘려보내 사용자에게 안 보인다).
+          stderr: "pipe"
+        });
+        const notify = st.onProgress ? throttle(st.onProgress, 300) : void 0;
+        tap = collectStderr(transport, notify);
+      } else if (cfg.transport === "sse") {
+        if (!cfg.url) throw new Error("sse server has no url");
+        if (!SSEClientTransport) throw new Error("\uC774 \uBE4C\uB4DC\uC5D0\uC11C SSE \uC804\uC1A1\uC744 \uC0AC\uC6A9\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.");
+        transport = new SSEClientTransport(
+          new URL(cfg.url),
+          oauthTransportOptions(cfg, {
+            requestInit: cfg.headers ? { headers: cfg.headers } : void 0,
+            fetch: this.httpFetch
+          })
+        );
+      } else {
+        if (!cfg.url) throw new Error("http server has no url");
+        transport = new StreamableHTTPClientTransport(
+          new URL(cfg.url),
+          oauthTransportOptions(cfg, {
+            requestInit: cfg.headers ? { headers: cfg.headers } : void 0,
+            fetch: this.httpFetch
+          })
+        );
+      }
+      const client = new Client({ name: "xgen-dex", version: "1.0.0" }, { capabilities: {} });
+      let listed;
+      try {
+        if (tap) {
+          await waitWhileProgressing(client.connect(transport), tap.lastAt, `${label} \uC5F0\uACB0`);
+        } else {
+          await withTimeout(client.connect(transport), 2e4, `${label} \uC5F0\uACB0`);
+        }
+        listed = await withTimeout(client.listTools(), 3e4, `${label} \uB3C4\uAD6C \uBAA9\uB85D`);
+      } catch (e) {
+        const tail = tap ? tailLines(tap.text()) : [];
+        if (tail.length) {
+          throw new McpStartError(
+            `${e.message} \u2014 \uC11C\uBC84\uAC00 \uAE30\uB3D9\uD558\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4. \uC544\uB798 \uCD9C\uB825\uC744 \uD655\uC778\uD558\uC138\uC694.`,
+            tail
+          );
+        }
+        throw e;
+      }
+      st.client = client;
+      st.tools = (listed?.tools || []).map((t) => ({
+        name: t.name,
+        description: t.description,
+        inputSchema: t.inputSchema
+      }));
+      st.error = void 0;
+      if (ToolListChangedNotificationSchema) {
+        try {
+          client.setNotificationHandler(
+            ToolListChangedNotificationSchema,
+            async () => {
+              try {
+                const relisted = await withTimeout(client.listTools(), 3e4, `${label} \uB3C4\uAD6C \uC7AC\uC870\uD68C`);
+                if (st.client !== client) return;
+                st.tools = (relisted?.tools || []).map((t) => ({
+                  name: t.name,
+                  description: t.description,
+                  inputSchema: t.inputSchema
+                }));
+                this.onCatalogChange?.();
+              } catch {
+              }
+            }
+          );
+        } catch {
+        }
+      }
+      client.onclose = () => {
+        if (st.client !== client) return;
+        st.client = null;
+        st.tools = [];
+        this.onCatalogChange?.();
+      };
+    })();
+    try {
+      await st.connecting;
+    } catch (e) {
+      st.error = String(e.message);
+      st.client = null;
+      throw e;
+    } finally {
+      st.connecting = void 0;
+    }
+  }
+  async disconnect(name) {
+    const st = this.states.get(name);
+    if (!st) return;
+    const c = st.client;
+    st.client = null;
+    st.tools = [];
+    try {
+      await c?.close?.();
+    } catch {
+    }
+  }
+  /**
+   * Connect every enabled server + return their tool catalogs.
+   *
+   * **병렬로** 붙는다. 순차로 붙이면 첫 실행이라 의존성을 내려받는 서버 하나가
+   * 나머지 전부를 막는다 (기동 대기가 진행 상황 기반이라 몇 분까지 갈 수 있다).
+   * 결과 순서는 설정 순서를 유지한다.
+   */
+  async advertise() {
+    const targets = [...this.states].filter(([, st]) => st.config.enabled !== false);
+    return Promise.all(
+      targets.map(async ([name, st]) => {
+        try {
+          await this.connect(name);
+          return { name, connected: true, tools: st.tools };
+        } catch (e) {
+          return { name, connected: false, error: String(e.message), tools: [] };
+        }
+      })
+    );
+  }
+  /** Flat catalog for the bridge `hello` frame (only connected servers' tools). */
+  async advertisedTools() {
+    const adverts = await this.advertise();
+    const flat = [];
+    for (const a of adverts) {
+      if (!a.connected) continue;
+      for (const t of a.tools) {
+        flat.push({ server: a.name, name: t.name, description: t.description, inputSchema: t.inputSchema });
+      }
+    }
+    return flat;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async callTool(name, tool, args) {
+    if (!this.states.has(name)) {
+      throw new Error(
+        `\uB85C\uCEEC MCP \uC11C\uBC84 '${name}' \uAC00 \uC9C0\uAE08\uC740 \uCEE4\uB125\uD130\uC5D0 \uC5C6\uC2B5\uB2C8\uB2E4 (\uC124\uC815\uC5D0\uC11C \uC81C\uAC70\uB410\uAC70\uB098 \uB85C\uCEEC MCP \uC2A4\uC704\uCE58\uAC00 \uAEBC\uC84C\uC2B5\uB2C8\uB2E4). \uB3C4\uAD6C \uC774\uB984 \uBB38\uC81C\uAC00 \uC544\uB2C8\uBBC0\uB85C \uC7AC\uC2DC\uB3C4\uD574\uB3C4 \uAC19\uC2B5\uB2C8\uB2E4 \u2014 \uC774 \uC11C\uBC84 \uC5C6\uC774 \uC9C4\uD589\uD558\uAC70\uB098 \uC0AC\uC6A9\uC790\uC5D0\uAC8C \uD655\uC778\uD558\uC138\uC694.`
+      );
+    }
+    await this.connect(name);
+    const st = this.states.get(name);
+    if (!st?.client) throw new Error(`MCP server ${name} not connected`);
+    try {
+      return await withTimeout(
+        st.client.callTool({ name: tool, arguments: args || {} }),
+        12e4,
+        `callTool ${name}.${tool}`
+      );
+    } catch (e) {
+      await this.disconnect(name);
+      throw e;
+    }
+  }
+  /** One-shot connect → list → disconnect, for the settings "테스트" button. */
+  async test(config, onProgress) {
+    const tmp = `__test__${config.name || "srv"}`;
+    this.states.set(tmp, { config: { ...config, name: tmp }, client: null, tools: [], onProgress });
+    try {
+      await this.connect(tmp);
+      const tools = this.states.get(tmp)?.tools || [];
+      return { ok: true, tools };
+    } catch (e) {
+      const err = e;
+      const hints = Array.isArray(err.hints) && err.hints.length ? err.hints : void 0;
+      return { ok: false, error: String(err.message), hints };
+    } finally {
+      await this.disconnect(tmp);
+      this.states.delete(tmp);
+    }
+  }
+  listServers() {
+    return [...this.states.values()].map((s) => s.config);
+  }
+  async closeAll() {
+    for (const name of [...this.states.keys()]) await this.disconnect(name);
+  }
+};
+var _manager = null;
+function getMcpManager() {
+  if (!_manager) _manager = new MCPManager();
+  return _manager;
+}
+
+// ../../packages/engine/src/local-tools.ts
+import { spawn } from "node:child_process";
+import { homedir as homedir4, platform as platform2 } from "node:os";
+import {
+  readFile as fsReadFile,
+  writeFile as fsWriteFile,
+  appendFile as fsAppendFile,
+  readdir,
+  stat,
+  mkdir as mkdir2
+} from "node:fs/promises";
+import {
+  resolve as pathResolve,
+  relative as pathRelative,
+  isAbsolute as isAbsolute2,
+  join as pathJoin,
+  dirname as dirname2,
+  extname
+} from "node:path";
+var LOCAL_SERVER = "local";
+var SHELL_TOOL = "Shell";
+var OPEN_TOOL = "Open";
+var READ_FILE_TOOL = "ReadFile";
+var WRITE_FILE_TOOL = "WriteFile";
+var LIST_DIR_TOOL = "ListDir";
+var SEARCH_TOOL = "Search";
+var CLIPBOARD_TOOL = "Clipboard";
+var NOTIFY_TOOL = "Notify";
+var SHELL_JOB_TOOL = "ShellJob";
+function localToolCallContext(raw) {
+  const value = raw && typeof raw === "object" ? raw : {};
+  const text = (input) => {
+    const normalized = String(input ?? "").trim();
+    return normalized || void 0;
+  };
+  return {
+    workflowId: text(value.workflow_id ?? value.workflowId),
+    workflowName: text(value.workflow_name ?? value.workflowName),
+    interactionId: text(value.interaction_id ?? value.interactionId)
+  };
+}
+var DEFAULT_TIMEOUT_MS = 6e5;
+var MIN_TIMEOUT_MS = 1e3;
+var MAX_TIMEOUT_MS = 60 * 6e4;
+var OUTPUT_CAP = 2e5;
+var BG_SETTLE_MS = 350;
+var JOB_STREAM_CAP = 262144;
+var MAX_JOBS = 50;
+var MAX_RUNNING_JOBS = 25;
+var IS_WIN2 = platform2() === "win32";
+var IS_MAC2 = platform2() === "darwin";
+function shellConfig(cfg) {
+  const c = cfg || {};
+  const t = typeof c.timeoutMs === "number" && c.timeoutMs > 0 ? c.timeoutMs : DEFAULT_TIMEOUT_MS;
+  const cwd = (c.cwd || "").trim();
+  const listed = Array.isArray(c.allowedRoots) ? c.allowedRoots.map((r) => String(r).trim()).filter(Boolean) : [];
+  const allowedRoots = cwd ? [...listed.length ? listed : ["~"], cwd] : listed;
+  return {
+    enabled: c.enabled === true,
+    // opt-in (default OFF) — 로컬 셸은 명시적으로 켜야 한다
+    cwd,
+    timeoutMs: Math.max(MIN_TIMEOUT_MS, Math.min(MAX_TIMEOUT_MS, Math.round(t))),
+    blocked: Array.isArray(c.blocked) ? c.blocked.map((b) => String(b).trim()).filter(Boolean) : [],
+    allowedRoots
+  };
+}
+function nativeShellLabel() {
+  if (IS_WIN2) return "PowerShell";
+  if (IS_MAC2) return "zsh/bash";
+  return "bash/sh";
+}
+function shellInvocation(command, userShellBin, explicitShell) {
+  const want = (explicitShell || "default").toLowerCase();
+  if (want === "powershell" || want === "default" && IS_WIN2) {
+    return {
+      file: "powershell.exe",
+      args: ["-NoProfile", "-NonInteractive", "-Command", command]
+    };
+  }
+  if (want === "cmd") {
+    return { file: "cmd.exe", args: ["/d", "/s", "/c", command] };
+  }
+  if (want === "bash") return { file: "bash", args: ["-lc", command] };
+  if (want === "sh") return { file: "sh", args: ["-lc", command] };
+  const bin = (userShellBin || "").trim();
+  const file = bin.startsWith("/") ? bin : "bash";
+  return { file, args: ["-lc", command] };
+}
+function openerInvocation(target) {
+  const t = String(target || "").trim();
+  if (IS_WIN2) return { file: "cmd.exe", args: ["/d", "/s", "/c", "start", "", t] };
+  if (IS_MAC2) return { file: "open", args: [t] };
+  return { file: "xdg-open", args: [t] };
+}
+function firstToken(command) {
+  const m = String(command || "").trim().match(/^(?:"([^"]+)"|'([^']+)'|(\S+))/);
+  const raw = m && (m[1] || m[2] || m[3]) || "";
+  const base = raw.split(/[\\/]/).pop() || raw;
+  return base.replace(/\.(exe|cmd|bat|com|ps1)$/i, "").toLowerCase();
+}
+function isBlocked(command, blocked) {
+  if (!blocked.length) return false;
+  const tok = firstToken(command);
+  return blocked.some((b) => firstToken(b) === tok || b.trim().toLowerCase() === tok);
+}
+var DANGEROUS_PATTERNS = [
+  /\brm\s+-[a-z]*[rf]/i,
+  // rm -rf / -r / -f
+  /(^|[;&|`(])\s*rm\s+\//i,
+  // rm on an absolute path
+  /\bRemove-Item\b[^\n]*-Recurse/i,
+  /\brmdir\s+\/s/i,
+  /\bdel\s+\/[a-z]*[sf]/i,
+  /\b(mkfs|fdisk|format)\b/i,
+  /\bdd\b[^\n]*\b(of|if)=/i,
+  /\b(shutdown|reboot|halt|poweroff)\b/i,
+  /\bchmod\s+-R\b/i,
+  /\bchown\s+-R\b/i,
+  />\s*\/dev\/(sd|nvme|disk|hd)/i,
+  /:\s*\(\s*\)\s*\{\s*:\s*\|\s*:/,
+  // fork bomb
+  /\bgit\s+push\b[^\n]*--force/i,
+  /\b(curl|wget)\b[^\n]*\|\s*(sudo\s+)?(sh|bash|zsh)\b/i,
+  // curl … | sh
+  /\bsudo\s+rm\b/i
+];
+function isDangerousShellCommand(command) {
+  const c = String(command || "");
+  return DANGEROUS_PATTERNS.some((re) => re.test(c));
+}
+var sessionApprovedDangerous = false;
+async function ensureDangerousApproval(command) {
+  if (!isDangerousShellCommand(command)) return true;
+  if (sessionApprovedDangerous) return true;
+  const ask = interaction().confirmDangerous;
+  if (!ask) return false;
+  try {
+    const answer = await ask(command);
+    if (answer === "session") {
+      sessionApprovedDangerous = true;
+      return true;
+    }
+    return answer === "once";
+  } catch {
+    return false;
+  }
+}
+var DANGEROUS_COMMAND_PROMPT = {
+  title: "\uC704\uD5D8\uD560 \uC218 \uC788\uB294 \uBA85\uB839 \uC2E4\uD589 \uD655\uC778",
+  message: "XGEN \uC5D0\uC774\uC804\uD2B8\uAC00 \uC774 PC \uC5D0\uC11C \uB418\uB3CC\uB9AC\uAE30 \uC5B4\uB824\uC6B4 \uBA85\uB839\uC744 \uC2E4\uD589\uD558\uB824 \uD569\uB2C8\uB2E4.",
+  detail: (command) => command
+};
+function shapeResult(stdout, stderr, code, signal) {
+  const parts = [];
+  const out = stdout.length > OUTPUT_CAP ? stdout.slice(0, OUTPUT_CAP) + "\n\u2026(truncated)" : stdout;
+  const err = stderr.length > OUTPUT_CAP ? stderr.slice(0, OUTPUT_CAP) + "\n\u2026(truncated)" : stderr;
+  if (out.trim()) parts.push(out.replace(/\s+$/, ""));
+  if (err.trim()) parts.push(`STDERR:
+${err.replace(/\s+$/, "")}`);
+  const failed = signal != null || code != null && code !== 0;
+  if (signal) parts.push(`(terminated by signal ${signal})`);
+  else if (code != null && code !== 0) parts.push(`(exit code ${code})`);
+  return {
+    content: [{ type: "text", text: parts.join("\n\n") || "(no output)" }],
+    isError: failed
+  };
+}
+var SYNCED_WORKSPACE_NOTE = `
+AGENT WORKSPACE ON THIS COMPUTER: when connected through this desktop connector, your own agent workspace is synced to a LOCAL folder \u2014 under the configured default working folder, one subfolder per connected agent (named after the agent). PREFER working there with these local tools; every change syncs back to your server workspace automatically, so web sessions and the sandbox see the same files.`;
+function shellToolSchema() {
+  return {
+    name: SHELL_TOOL,
+    description: `Run ONE command on the USER'S OWN COMPUTER (the local desktop where this connector runs), through its native shell (${nativeShellLabel()}), as the logged-in user. This is the physical machine \u2014 NOT the cloud workspace/sandbox. Use it to operate that computer: run scripts, read/write local files, inspect the system, launch apps.` + SYNCED_WORKSPACE_NOTE + `
+IMPORTANT for reliability:
+\u2022 Non-interactive only \u2014 stdin is closed, so REPLs/prompts (bash, python with no args, \`read\`, pagers) return immediately instead of hanging. Pass the full command each call.
+\u2022 To launch a GUI app or a long-running/never-exiting process (editors like notepad/gedit, servers, watchers) \u2014 or ANY job that may run longer than a couple of minutes \u2014 set background:true. It starts detached, returns a job_id at once, and is NOT killed at the timeout; its output is captured. Poll it later with the ShellJob tool (action:'poll', job_id).
+\u2022 To just open a file/URL/folder with its default app, prefer the Open tool.
+Returns combined stdout/stderr and the exit code (foreground); a job_id (background). For huge output, pass head/tail (lines) or max_bytes to page it.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        command: { type: "string", description: "The shell command line to execute." },
+        background: {
+          type: "boolean",
+          description: "Launch detached and return a job_id immediately (output captured, pollable via ShellJob). Use for GUI apps and long-running jobs so they keep running and are not killed at the timeout."
+        },
+        cwd: {
+          type: "string",
+          description: "Working directory (absolute). Defaults to the configured directory or home."
+        },
+        shell: {
+          type: "string",
+          enum: ["default", "powershell", "cmd", "bash", "sh"],
+          description: "Shell to use. 'default' picks the OS native shell."
+        },
+        timeout_ms: {
+          type: "integer",
+          description: "Optional per-command timeout override (ms). Ignored when background=true."
+        },
+        tail: {
+          type: "integer",
+          description: "Return only the last N lines of output (for chatty commands)."
+        },
+        head: { type: "integer", description: "Return only the first N lines of output." },
+        max_bytes: {
+          type: "integer",
+          description: `Cap returned output bytes (default/cap ${OUTPUT_CAP}).`
+        }
+      },
+      required: ["command"]
+    }
+  };
+}
+function shellJobToolSchema() {
+  return {
+    name: SHELL_JOB_TOOL,
+    description: `Manage long-running background jobs started with Shell(background:true) on the USER'S OWN COMPUTER. This is how you run work that outlives a single tool call: start it in the background, then poll it here until it finishes.
+\u2022 action:'list' \u2014 show all recent/running jobs (id, status, pid, duration, command).
+\u2022 action:'poll' (job_id) \u2014 status + captured stdout/stderr (paginated: tail default, or head/max_bytes).
+\u2022 action:'kill' (job_id) \u2014 terminate a running job (whole process tree).`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: { type: "string", enum: ["list", "poll", "kill"], description: "Default 'list'." },
+        job_id: {
+          type: "string",
+          description: "The job id returned by Shell(background:true). Required for poll/kill."
+        },
+        tail: { type: "integer", description: "poll: last N lines (default 200)." },
+        head: { type: "integer", description: "poll: first N lines." },
+        max_bytes: { type: "integer", description: "poll: cap returned output bytes." }
+      }
+    }
+  };
+}
+function openToolSchema() {
+  return {
+    name: OPEN_TOOL,
+    description: `Open a file, folder, or URL on the USER'S OWN COMPUTER with its default application. Non-blocking \u2014 the app launches and this returns immediately. Use this for "open <file>", "show me <folder>", "open <url>". Safe by construction: only http/https/mailto/tel/ftp URLs and filesystem paths within the allowed folders are opened (javascript:/data: and unknown schemes are refused). To launch an app by name or run a command, use Shell(background:true).`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        target: {
+          type: "string",
+          description: "A file/folder path (within allowed folders) or an http/https/mailto/tel/ftp URL."
+        }
+      },
+      required: ["target"]
+    }
+  };
+}
+function coerceShellArgs(args) {
+  const a = args && typeof args === "object" ? args : {};
+  const command = typeof a.command === "string" ? a.command : String(a.command ?? "");
+  const cwd = typeof a.cwd === "string" && a.cwd.trim() ? a.cwd.trim() : void 0;
+  const shell = typeof a.shell === "string" ? a.shell : void 0;
+  const t = a.timeout_ms ?? a.timeoutMs;
+  const timeoutMs = typeof t === "number" && t > 0 ? t : void 0;
+  const bg = a.background ?? a.detach ?? a.detached;
+  const background = bg === true || bg === "true" || bg === 1;
+  return { command, cwd, shell, timeoutMs, background };
+}
+function coerceOpenArgs(args) {
+  const a = args && typeof args === "object" ? args : {};
+  const raw = a.target ?? a.path ?? a.url ?? a.file;
+  return { target: typeof raw === "string" ? raw : String(raw ?? "") };
+}
+function killTree(child, detachedGroup) {
+  try {
+    if (IS_WIN2) {
+      if (child.pid)
+        spawn("taskkill", ["/pid", String(child.pid), "/t", "/f"], { windowsHide: true });
+      else child.kill("SIGKILL");
+    } else if (detachedGroup && child.pid) {
+      process.kill(-child.pid, "SIGKILL");
+    } else {
+      child.kill("SIGKILL");
+    }
+  } catch {
+    try {
+      child.kill("SIGKILL");
+    } catch {
+    }
+  }
+}
+var bgJobs = /* @__PURE__ */ new Map();
+var bgJobSeq = 0;
+function newJobId() {
+  bgJobSeq += 1;
+  return `job-${Date.now().toString(36)}-${bgJobSeq}`;
+}
+function evictFinishedJobs() {
+  if (bgJobs.size <= MAX_JOBS) return;
+  const finished = [...bgJobs.values()].filter((j) => j.status !== "running").sort((a, b) => (a.endedAt ?? a.startedAt) - (b.endedAt ?? b.startedAt));
+  for (const j of finished) {
+    if (bgJobs.size <= MAX_JOBS) break;
+    bgJobs.delete(j.id);
+  }
+}
+function appendCapped(prev, chunk) {
+  const next = prev + chunk;
+  return next.length > JOB_STREAM_CAP ? next.slice(-JOB_STREAM_CAP) : next;
+}
+function paginate(text, opts) {
+  const totalBytes = Buffer.byteLength(text);
+  let out = text;
+  let truncated = false;
+  const head = Number(opts.head) > 0 ? Math.floor(Number(opts.head)) : 0;
+  const tail = Number(opts.tail) > 0 ? Math.floor(Number(opts.tail)) : 0;
+  if (head || tail) {
+    const lines = text.split("\n");
+    if (head) out = lines.slice(0, head).join("\n");
+    else out = lines.slice(-tail).join("\n");
+    if (out.length < text.length) truncated = true;
+  }
+  const cap = Math.max(
+    1,
+    Math.min(
+      OUTPUT_CAP,
+      Number(opts.maxBytes) > 0 ? Math.floor(Number(opts.maxBytes)) : OUTPUT_CAP
+    )
+  );
+  if (Buffer.byteLength(out) > cap) {
+    const buf = Buffer.from(out, "utf8");
+    if (head) {
+      let end = cap;
+      while (end > 0 && (buf[end] & 192) === 128) end--;
+      out = buf.subarray(0, end).toString("utf8");
+    } else {
+      let start = buf.length - cap;
+      while (start < buf.length && (buf[start] & 192) === 128) start++;
+      out = buf.subarray(start).toString("utf8");
+    }
+    truncated = true;
+  }
+  return { text: out, truncated, totalBytes };
+}
+var SAFE_OPEN_SCHEMES = /* @__PURE__ */ new Set(["http", "https", "mailto", "tel", "ftp", "ftps"]);
+function classifyOpenTarget(target) {
+  const t = String(target || "").trim();
+  if (!t) return { kind: "blocked", reason: "target \uC774 \uBE44\uC5B4 \uC788\uC2B5\uB2C8\uB2E4." };
+  const m = t.match(/^([a-zA-Z][a-zA-Z0-9+.-]*):/);
+  if (m) {
+    const scheme = m[1].toLowerCase();
+    if (scheme === "file")
+      return { kind: "path", value: t.replace(/^file:\/\//i, "").replace(/^file:/i, "") };
+    if (SAFE_OPEN_SCHEMES.has(scheme)) return { kind: "url", value: t };
+    if (IS_WIN2 && /^[a-zA-Z]:[\\/]/.test(t)) return { kind: "path", value: t };
+    return {
+      kind: "blocked",
+      reason: `\uD5C8\uC6A9\uB418\uC9C0 \uC54A\uC740 \uC2A4\uD0B4 '${scheme}:' (javascript/data \uB4F1\uC740 \uCC28\uB2E8).`
+    };
+  }
+  return { kind: "path", value: t };
+}
+var BINARY_EXT = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".ico",
+  ".bmp",
+  ".pdf",
+  ".zip",
+  ".gz",
+  ".tar",
+  ".7z",
+  ".rar",
+  ".mp3",
+  ".mp4",
+  ".mov",
+  ".avi",
+  ".wav",
+  ".ogg",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".eot",
+  ".so",
+  ".dll",
+  ".dylib",
+  ".exe",
+  ".bin",
+  ".class",
+  ".o"
+]);
+function resolveOne(p, base) {
+  const home = homedir4();
+  const expanded = p.startsWith("~") ? home + p.slice(1) : p;
+  return isAbsolute2(expanded) ? pathResolve(expanded) : pathResolve(base, expanded);
+}
+function resolveWithinRoots(input, roots) {
+  const home = homedir4();
+  const effective = (roots && roots.length ? roots : [home]).map((r) => resolveOne(r, home));
+  const abs = resolveOne(String(input || ""), home);
+  for (const root of effective) {
+    const rel = pathRelative(root, abs);
+    if (rel === "" || !rel.startsWith("..") && !isAbsolute2(rel)) return abs;
+  }
+  return null;
+}
+function readFileToolSchema() {
+  return {
+    name: READ_FILE_TOOL,
+    description: "Read a text file on the USER'S OWN COMPUTER (the local desktop), within the allowed folders. Prefer this over `Shell cat` \u2014 it distinguishes \u201Cnot found\u201D from \u201Cno permission\u201D cleanly. Returns UTF-8 text (truncated at maxBytes)." + SYNCED_WORKSPACE_NOTE,
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "File path. Absolute, ~ for home, or relative to home."
+        },
+        maxBytes: {
+          type: "number",
+          description: `Max bytes to return (default/cap ${OUTPUT_CAP}).`
+        }
+      },
+      required: ["path"]
+    }
+  };
+}
+function writeFileToolSchema() {
+  return {
+    name: WRITE_FILE_TOOL,
+    description: "Write (or append to) a text file on the USER'S OWN COMPUTER, within the allowed folders. Creates parent directories as needed. Prefer this over shell redirection." + SYNCED_WORKSPACE_NOTE,
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "File path. Absolute, ~ for home, or relative to home."
+        },
+        content: { type: "string", description: "Text to write." },
+        mode: { type: "string", enum: ["overwrite", "append"], description: "Default overwrite." }
+      },
+      required: ["path", "content"]
+    }
+  };
+}
+function listDirToolSchema() {
+  return {
+    name: LIST_DIR_TOOL,
+    description: "List a directory on the USER'S OWN COMPUTER (within allowed folders). Shows type/size/name." + SYNCED_WORKSPACE_NOTE,
+    inputSchema: {
+      type: "object",
+      properties: { path: { type: "string", description: "Directory path (default: home)." } }
+    }
+  };
+}
+function searchToolSchema() {
+  return {
+    name: SEARCH_TOOL,
+    description: "Recursively search text files under a folder on the USER'S OWN COMPUTER (within allowed folders) for a literal substring. Skips node_modules/.git/binaries. Returns path:line: match.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Literal substring to find." },
+        path: { type: "string", description: "Root folder to search (default: home)." },
+        maxResults: { type: "number", description: "Max matches (default 100, cap 500)." }
+      },
+      required: ["query"]
+    }
+  };
+}
+function clipboardToolSchema() {
+  return {
+    name: CLIPBOARD_TOOL,
+    description: "Read or write the USER'S system clipboard (plain text).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          enum: ["read", "write"],
+          description: "read (default) or write."
+        },
+        text: { type: "string", description: "Text to put on the clipboard when action=write." }
+      }
+    }
+  };
+}
+function notifyToolSchema() {
+  return {
+    name: NOTIFY_TOOL,
+    description: "Show a desktop notification on the USER'S OWN COMPUTER.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        title: { type: "string", description: "Notification title." },
+        body: { type: "string", description: "Notification body." }
+      },
+      required: ["title"]
+    }
+  };
+}
+var LocalToolProvider = class {
+  cfg = shellConfig(void 0);
+  delegate = null;
+  /** 서버 런타임이 이 PC 를 실행 환경으로 쓰는 내부 브리지 (workspace-bridge-tools). */
+  workspaceBridge = null;
+  /** main 의 공통 NotificationCenter. 주입해 Node 단위 테스트는 Electron 을 요구하지 않는다. */
+  notificationHandler = null;
+  /** 로컬 MCP 자기관리(McpAddServer/McpRemoveServer/McpListServers). 로컬 MCP 가 켜져
+   *  있을 때만 도구를 광고한다 — 이 delegate 자신이 게이트를 판단한다. */
+  mcpAdmin = null;
+  configure(cfg, delegate) {
+    this.cfg = shellConfig(cfg);
+    this.delegate = delegate ?? null;
+  }
+  /** 워크스페이스 브리지 배선 — 로컬 동기화 매니저가 준비된 뒤 한 번 건다. */
+  configureWorkspaceBridge(bridge) {
+    this.workspaceBridge = bridge;
+  }
+  configureNotificationHandler(handler) {
+    this.notificationHandler = handler;
+  }
+  /** 로컬 MCP 자기관리 delegate 배선(syncMcp 에서). null 이면 미노출. */
+  configureMcpAdmin(admin) {
+    this.mcpAdmin = admin;
+  }
+  /** True iff this call frame belongs to a built-in tool (server === LOCAL_SERVER). */
+  owns(server) {
+    return server === LOCAL_SERVER;
+  }
+  /** Tools advertised into the catalog. Empty when the capability is off. */
+  /**
+   * 셸/파일 도구의 **전체 카탈로그** — 켜져 있는지와 무관하게.
+   *
+   * `advertise()` 는 "지금 에이전트에게 노출되는 것"이라 꺼져 있으면 빈 목록이다.
+   * 그건 서버에 광고할 때는 맞지만, 사용자가 "이 도구로 뭘 할 수 있지"를 물을 때는
+   * 아무 답이 안 된다. 두 질문은 다르므로 답도 둘이다.
+   */
+  catalog() {
+    return [
+      shellToolSchema(),
+      shellJobToolSchema(),
+      openToolSchema(),
+      readFileToolSchema(),
+      writeFileToolSchema(),
+      listDirToolSchema(),
+      searchToolSchema(),
+      clipboardToolSchema(),
+      notifyToolSchema()
+    ];
+  }
+  advertise() {
+    const shell = this.cfg.enabled ? [
+      shellToolSchema(),
+      shellJobToolSchema(),
+      openToolSchema(),
+      readFileToolSchema(),
+      writeFileToolSchema(),
+      listDirToolSchema(),
+      searchToolSchema(),
+      clipboardToolSchema(),
+      notifyToolSchema()
+    ] : [];
+    const bridge = this.cfg.enabled ? this.workspaceBridge?.advertise() ?? [] : [];
+    const mcpAdmin = this.mcpAdmin?.advertise() ?? [];
+    return [...shell, ...bridge, ...mcpAdmin, ...this.delegate?.advertise() ?? []];
+  }
+  async callTool(tool, args, context) {
+    if (this.delegate?.owns(tool)) return this.delegate.callTool(tool, args, context);
+    if (this.mcpAdmin?.owns(tool)) return this.mcpAdmin.callTool(tool, args);
+    if (!this.cfg.enabled) throw new Error("\uB85C\uCEEC \uB3C4\uAD6C \uC811\uADFC\uC774 \uAEBC\uC838 \uC788\uC2B5\uB2C8\uB2E4 (\uC124\uC815 > \uB85C\uCEEC \uB3C4\uAD6C).");
+    if (this.workspaceBridge?.owns(tool)) return this.workspaceBridge.callTool(tool, args);
+    if (tool === SHELL_TOOL) return this.shell(args);
+    if (tool === SHELL_JOB_TOOL) return this.shellJob(args);
+    if (tool === OPEN_TOOL) return this.open(args);
+    if (tool === READ_FILE_TOOL) return this.readFile(args);
+    if (tool === WRITE_FILE_TOOL) return this.writeFile(args);
+    if (tool === LIST_DIR_TOOL) return this.listDir(args);
+    if (tool === SEARCH_TOOL) return this.search(args);
+    if (tool === CLIPBOARD_TOOL) return this.clipboard(args);
+    if (tool === NOTIFY_TOOL) return this.notify(args, context);
+    throw new Error(`unknown local tool: ${tool}`);
+  }
+  /** Resolve + scope-check a file path against allowedRoots (throws if outside). */
+  guardPath(p) {
+    const abs = resolveWithinRoots(String(p ?? ""), this.cfg.allowedRoots);
+    if (!abs) {
+      throw new Error(
+        `\uACBD\uB85C\uAC00 \uD5C8\uC6A9\uB41C \uBC94\uC704 \uBC16\uC785\uB2C8\uB2E4: ${String(p ?? "")} (\uC124\uC815 > \uB85C\uCEEC \uB3C4\uAD6C > \uD5C8\uC6A9 \uD3F4\uB354\uC5D0\uC11C \uBC94\uC704\uB97C \uB113\uD790 \uC218 \uC788\uC2B5\uB2C8\uB2E4).`
+      );
+    }
+    return abs;
+  }
+  async readFile(args) {
+    const a = args && typeof args === "object" ? args : {};
+    const abs = this.guardPath(a.path);
+    const maxBytes = Math.max(1, Math.min(OUTPUT_CAP, Number(a.maxBytes) || OUTPUT_CAP));
+    try {
+      const buf = await fsReadFile(abs);
+      const text = buf.subarray(0, maxBytes).toString("utf8");
+      const suffix = buf.byteLength > maxBytes ? `
+\u2026(truncated, ${buf.byteLength} bytes total)` : "";
+      return { content: [{ type: "text", text: (text || "(empty file)") + suffix }] };
+    } catch (e) {
+      return {
+        content: [{ type: "text", text: `\uC77D\uAE30 \uC2E4\uD328: ${e.message}` }],
+        isError: true
+      };
+    }
+  }
+  async writeFile(args) {
+    const a = args && typeof args === "object" ? args : {};
+    const abs = this.guardPath(a.path);
+    const content = typeof a.content === "string" ? a.content : String(a.content ?? "");
+    const append = a.mode === "append" || a.append === true;
+    try {
+      await mkdir2(dirname2(abs), { recursive: true });
+      if (append) await fsAppendFile(abs, content, "utf8");
+      else await fsWriteFile(abs, content, "utf8");
+      return {
+        content: [
+          {
+            type: "text",
+            text: `${append ? "\uC774\uC5B4\uC37C\uC2B5\uB2C8\uB2E4" : "\uC800\uC7A5\uD588\uC2B5\uB2C8\uB2E4"}: ${abs} (${Buffer.byteLength(content)} bytes)`
+          }
+        ]
+      };
+    } catch (e) {
+      return {
+        content: [{ type: "text", text: `\uC4F0\uAE30 \uC2E4\uD328: ${e.message}` }],
+        isError: true
+      };
+    }
+  }
+  async listDir(args) {
+    const a = args && typeof args === "object" ? args : {};
+    const abs = this.guardPath(a.path ?? "~");
+    try {
+      const names = await readdir(abs);
+      const rows = [];
+      for (const name of names.slice(0, 1e3)) {
+        try {
+          const s = await stat(pathJoin(abs, name));
+          rows.push(`${s.isDirectory() ? "d" : "-"} ${String(s.size).padStart(10)}  ${name}`);
+        } catch {
+          rows.push(`?          ?  ${name}`);
+        }
+      }
+      const more = names.length > 1e3 ? `
+\u2026(${names.length} entries, first 1000 shown)` : "";
+      return { content: [{ type: "text", text: rows.join("\n") + more || "(empty directory)" }] };
+    } catch (e) {
+      return {
+        content: [{ type: "text", text: `\uBAA9\uB85D \uC2E4\uD328: ${e.message}` }],
+        isError: true
+      };
+    }
+  }
+  async search(args) {
+    const a = args && typeof args === "object" ? args : {};
+    const query = String(a.query ?? "");
+    if (!query) throw new Error("query must not be empty");
+    const abs = this.guardPath(a.path ?? "~");
+    const maxResults = Math.max(1, Math.min(500, Number(a.maxResults) || 100));
+    const hits = [];
+    const skipDirs = /* @__PURE__ */ new Set([
+      "node_modules",
+      ".git",
+      ".venv",
+      "dist",
+      "out",
+      ".next",
+      "__pycache__"
+    ]);
+    const walk = async (dir, depth) => {
+      if (hits.length >= maxResults || depth > 8) return;
+      let entries2;
+      try {
+        entries2 = await readdir(dir);
+      } catch {
+        return;
+      }
+      for (const name of entries2) {
+        if (hits.length >= maxResults) return;
+        const full = pathJoin(dir, name);
+        let s;
+        try {
+          s = await stat(full);
+        } catch {
+          continue;
+        }
+        if (s.isDirectory()) {
+          if (!skipDirs.has(name) && !name.startsWith(".")) await walk(full, depth + 1);
+        } else if (s.size <= 2e6 && !BINARY_EXT.has(extname(name).toLowerCase())) {
+          try {
+            const text = await fsReadFile(full, "utf8");
+            const lines = text.split(/\r?\n/);
+            for (let i = 0; i < lines.length; i++) {
+              if (lines[i].includes(query)) {
+                hits.push(`${full}:${i + 1}: ${lines[i].trim().slice(0, 200)}`);
+                if (hits.length >= maxResults) return;
+              }
+            }
+          } catch {
+          }
+        }
+      }
+    };
+    await walk(abs, 0);
+    return {
+      content: [
+        {
+          type: "text",
+          text: hits.length ? hits.join("\n") : `'${query}' \uB97C \uCC3E\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4 (${abs}).`
+        }
+      ]
+    };
+  }
+  async clipboard(args) {
+    const a = args && typeof args === "object" ? args : {};
+    const action = String(a.action ?? "read");
+    const clip = interaction().clipboard;
+    if (!clip) {
+      return {
+        content: [{ type: "text", text: "\uC774 \uD638\uC2A4\uD2B8\uC5D0\uC11C\uB294 \uD074\uB9BD\uBCF4\uB4DC\uB97C \uC4F8 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4." }],
+        isError: true
+      };
+    }
+    try {
+      if (action === "write") {
+        await clip.write(String(a.text ?? ""));
+        return { content: [{ type: "text", text: "\uD074\uB9BD\uBCF4\uB4DC\uC5D0 \uBCF5\uC0AC\uD588\uC2B5\uB2C8\uB2E4." }] };
+      }
+      const text = await clip.read();
+      return { content: [{ type: "text", text: text || "(\uD074\uB9BD\uBCF4\uB4DC\uAC00 \uBE44\uC5B4 \uC788\uC2B5\uB2C8\uB2E4)" }] };
+    } catch (e) {
+      return {
+        content: [{ type: "text", text: `\uD074\uB9BD\uBCF4\uB4DC \uC811\uADFC \uC2E4\uD328: ${e.message}` }],
+        isError: true
+      };
+    }
+  }
+  async notify(args, context) {
+    const a = args && typeof args === "object" ? args : {};
+    const title = String(a.title ?? "XGEN");
+    const body = String(a.body ?? "");
+    try {
+      if (this.notificationHandler) {
+        const shown2 = await this.notificationHandler(title, body, context);
+        return {
+          content: [
+            {
+              type: "text",
+              text: shown2 ? "\uC54C\uB9BC\uC744 \uD45C\uC2DC\uD588\uC2B5\uB2C8\uB2E4." : "\uC0AC\uC6A9\uC790\uC758 \uC54C\uB9BC \uC124\uC815\uC5D0 \uB530\uB77C \uD45C\uC2DC\uD558\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4."
+            }
+          ]
+        };
+      }
+      const notify = interaction().notify;
+      if (!notify) {
+        return {
+          content: [{ type: "text", text: "\uC774 \uD638\uC2A4\uD2B8\uC5D0\uC11C\uB294 \uC54C\uB9BC\uC744 \uD45C\uC2DC\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4." }],
+          isError: true
+        };
+      }
+      const shown = await notify(title, body);
+      return {
+        content: [
+          { type: "text", text: shown ? "\uC54C\uB9BC\uC744 \uD45C\uC2DC\uD588\uC2B5\uB2C8\uB2E4." : "\uC54C\uB9BC\uC774 \uD45C\uC2DC\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4." }
+        ]
+      };
+    } catch (e) {
+      return {
+        content: [{ type: "text", text: `\uC54C\uB9BC \uC2E4\uD328: ${e.message}` }],
+        isError: true
+      };
+    }
+  }
+  async shell(args) {
+    const { command, cwd, shell, timeoutMs, background } = coerceShellArgs(args);
+    if (!command.trim()) throw new Error("command must not be empty");
+    if (isBlocked(command, this.cfg.blocked)) {
+      throw new Error(`\uBA85\uB839 '${firstToken(command)}' \uC740(\uB294) \uCC28\uB2E8 \uBAA9\uB85D\uC5D0 \uC788\uC5B4 \uC2E4\uD589\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.`);
+    }
+    if (!await ensureDangerousApproval(command)) {
+      return {
+        content: [
+          { type: "text", text: "\uC0AC\uC6A9\uC790\uAC00 \uC774 \uBA85\uB839\uC758 \uC2E4\uD589\uC744 \uAC70\uBD80\uD588\uC2B5\uB2C8\uB2E4 (\uC704\uD5D8\uD560 \uC218 \uC788\uB294 \uBA85\uB839)." }
+        ],
+        isError: true
+      };
+    }
+    const pathStr = await augmentedPath();
+    const userShellBin = IS_WIN2 ? null : process.env.SHELL || null;
+    const { file, args: argv } = shellInvocation(command, userShellBin, shell);
+    const env = buildChildEnv(pathStr);
+    const runCwd = cwd || this.cfg.cwd || homedir4();
+    if (background) return this.spawnBackground(command, file, argv, env, runCwd);
+    const timeout = Math.max(
+      MIN_TIMEOUT_MS,
+      Math.min(MAX_TIMEOUT_MS, Math.round(timeoutMs || this.cfg.timeoutMs))
+    );
+    const r = await this.spawnCapture(file, argv, env, runCwd, timeout);
+    if (r.error)
+      return {
+        content: [{ type: "text", text: `\uC178 \uC2E4\uD589 \uC2E4\uD328: ${r.error.message}` }],
+        isError: true
+      };
+    if (r.timedOut) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `\uBA85\uB839\uC774 ${Math.round(timeout / 1e3)}\uCD08 \uC548\uC5D0 \uB05D\uB098\uC9C0 \uC54A\uC544 \uC911\uB2E8\uD588\uC2B5\uB2C8\uB2E4. \uB300\uD654\uD615 \uBA85\uB839\uC774\uAC70\uB098 \uC885\uB8CC\uB418\uC9C0 \uC54A\uB294 \uD504\uB85C\uADF8\uB7A8(\uC5D0\uB514\uD130\xB7\uC11C\uBC84 \uB4F1)\uC774\uBA74 background:true \uB85C \uC2E4\uD589\uD558\uC138\uC694.` + (r.stdout || r.stderr ? `
+
+--- \uC911\uB2E8 \uC804 \uCD9C\uB825 ---
+${(r.stdout + "\n" + r.stderr).trim().slice(-2e3)}` : "")
+          }
+        ],
+        isError: true
+      };
+    }
+    const a = args && typeof args === "object" ? args : {};
+    const head = Number(a.head) || 0;
+    const tail = Number(a.tail) || 0;
+    const maxBytes = Number(a.max_bytes ?? a.maxBytes) || 0;
+    if (head || tail || maxBytes) {
+      const outP = paginate(r.stdout, { head, tail, maxBytes });
+      const errP = paginate(r.stderr, { head, tail, maxBytes });
+      return shapeResult(outP.text, errP.text, r.code, r.signal);
+    }
+    return shapeResult(r.stdout, r.stderr, r.code, r.signal);
+  }
+  async open(args) {
+    const { target } = coerceOpenArgs(args);
+    if (!target.trim()) throw new Error("target must not be empty");
+    const cls = classifyOpenTarget(target);
+    if (cls.kind === "blocked") {
+      return { content: [{ type: "text", text: `\uC5F4 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${cls.reason}` }], isError: true };
+    }
+    const host = interaction();
+    if (!host.openExternal && !host.openPath) {
+      return {
+        content: [{ type: "text", text: "\uC774 \uD638\uC2A4\uD2B8\uC5D0\uC11C\uB294 \uC678\uBD80 \uC5F4\uAE30\uB97C \uC9C0\uC6D0\uD558\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4." }],
+        isError: true
+      };
+    }
+    try {
+      if (cls.kind === "url") {
+        if (!host.openExternal) {
+          return {
+            content: [{ type: "text", text: "\uC774 \uD638\uC2A4\uD2B8\uC5D0\uC11C\uB294 \uB9C1\uD06C\uB97C \uC5F4 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4." }],
+            isError: true
+          };
+        }
+        await host.openExternal(cls.value);
+        return { content: [{ type: "text", text: `\uC5F4\uC5C8\uC2B5\uB2C8\uB2E4: ${cls.value}` }] };
+      }
+      const abs = this.guardPath(cls.value);
+      if (!host.openPath) {
+        return {
+          content: [{ type: "text", text: "\uC774 \uD638\uC2A4\uD2B8\uC5D0\uC11C\uB294 \uD30C\uC77C\uC744 \uC5F4 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4." }],
+          isError: true
+        };
+      }
+      const err = await host.openPath(abs);
+      if (err) return { content: [{ type: "text", text: `\uC5F4\uAE30 \uC2E4\uD328: ${err}` }], isError: true };
+      return { content: [{ type: "text", text: `\uC5F4\uC5C8\uC2B5\uB2C8\uB2E4: ${abs}` }] };
+    } catch (e) {
+      return {
+        content: [{ type: "text", text: `\uC5F4\uAE30 \uC2E4\uD328: ${e.message}` }],
+        isError: true
+      };
+    }
+  }
+  /** Foreground: capture output, close stdin (no interactive hang), tree-kill on timeout. */
+  spawnCapture(file, argv, env, cwd, timeoutMs) {
+    const detachedGroup = !IS_WIN2;
+    return new Promise((resolve) => {
+      let child;
+      try {
+        child = spawn(file, argv, {
+          cwd: cwd || homedir4(),
+          env,
+          windowsHide: true,
+          detached: detachedGroup,
+          // stdin IGNORED → interactive programs get EOF immediately instead of
+          // blocking to the timeout (the "대화형 쉘 타임아웃" report).
+          stdio: ["ignore", "pipe", "pipe"]
+        });
+      } catch (e) {
+        resolve({ code: null, signal: null, stdout: "", stderr: "", error: e });
+        return;
+      }
+      let out = "";
+      let err = "";
+      let done = false;
+      const finish = (r) => {
+        if (done) return;
+        done = true;
+        clearTimeout(timer);
+        resolve(r);
+      };
+      const timer = setTimeout(() => {
+        killTree(child, detachedGroup);
+        finish({ code: null, signal: "SIGKILL", stdout: out, stderr: err, timedOut: true });
+      }, timeoutMs);
+      child.stdout?.on("data", (d) => {
+        out += String(d);
+        if (out.length > OUTPUT_CAP * 2) out = out.slice(-OUTPUT_CAP * 2);
+      });
+      child.stderr?.on("data", (d) => {
+        err += String(d);
+        if (err.length > OUTPUT_CAP * 2) err = err.slice(-OUTPUT_CAP * 2);
+      });
+      child.on(
+        "error",
+        (e) => finish({ code: null, signal: null, stdout: out, stderr: err, error: e })
+      );
+      child.on("close", (code, signal) => finish({ code, signal, stdout: out, stderr: err }));
+    });
+  }
+  /** Background: detached, output captured into the job registry, returns a
+   *  job_id at once. The process keeps running past any tool-call timeout; poll
+   *  or kill it later with the ShellJob tool. */
+  spawnBackground(command, file, argv, env, cwd) {
+    const detachedGroup = !IS_WIN2;
+    return new Promise((resolve) => {
+      const running = [...bgJobs.values()].filter((j) => j.status === "running").length;
+      if (running >= MAX_RUNNING_JOBS) {
+        resolve({
+          content: [
+            {
+              type: "text",
+              text: `\uC2E4\uD589 \uC911\uC778 \uBC31\uADF8\uB77C\uC6B4\uB4DC \uC791\uC5C5\uC774 \uB108\uBB34 \uB9CE\uC2B5\uB2C8\uB2E4 (${running}/${MAX_RUNNING_JOBS}). ShellJob(action:'list')\uB85C \uD655\uC778\uD558\uACE0 kill \uB85C \uC815\uB9AC\uD55C \uB4A4 \uB2E4\uC2DC \uC2DC\uB3C4\uD558\uC138\uC694.`
+            }
+          ],
+          isError: true
+        });
+        return;
+      }
+      let child;
+      try {
+        child = spawn(file, argv, {
+          cwd: cwd || homedir4(),
+          env,
+          windowsHide: true,
+          detached: detachedGroup,
+          // Capture output (so it can be polled) but close stdin so REPLs don't hang.
+          stdio: ["ignore", "pipe", "pipe"]
+        });
+      } catch (e) {
+        resolve({
+          content: [
+            {
+              type: "text",
+              text: `\uBC31\uADF8\uB77C\uC6B4\uB4DC \uC2E4\uD589 \uC2E4\uD328: ${e instanceof Error ? e.message : String(e)}`
+            }
+          ],
+          isError: true
+        });
+        return;
+      }
+      const job = {
+        id: newJobId(),
+        command,
+        pid: child.pid,
+        child,
+        detachedGroup,
+        status: "running",
+        code: null,
+        signal: null,
+        startedAt: Date.now(),
+        stdout: "",
+        stderr: ""
+      };
+      bgJobs.set(job.id, job);
+      evictFinishedJobs();
+      child.stdout?.on("data", (d) => {
+        job.stdout = appendCapped(job.stdout, String(d));
+      });
+      child.stderr?.on("data", (d) => {
+        job.stderr = appendCapped(job.stderr, String(d));
+      });
+      let settled = false;
+      const done = (r) => {
+        if (settled) return;
+        settled = true;
+        resolve(r);
+      };
+      child.on("error", (e) => {
+        if (job.status === "running") {
+          job.status = "error";
+          job.errorMsg = e.message;
+          job.endedAt = Date.now();
+        }
+        done({
+          content: [{ type: "text", text: `\uBC31\uADF8\uB77C\uC6B4\uB4DC \uC2E4\uD589 \uC2E4\uD328: ${e.message}` }],
+          isError: true
+        });
+      });
+      child.on("close", (code, signal) => {
+        job.code = code;
+        job.signal = signal;
+        if (job.status === "running") {
+          job.status = signal ? "killed" : "exited";
+          job.endedAt = Date.now();
+        } else if (!job.endedAt) {
+          job.endedAt = Date.now();
+        }
+      });
+      child.unref();
+      child.stdout?.unref?.();
+      child.stderr?.unref?.();
+      setTimeout(
+        () => done({
+          content: [
+            {
+              type: "text",
+              text: `\uBC31\uADF8\uB77C\uC6B4\uB4DC \uC791\uC5C5\uC744 \uC2DC\uC791\uD588\uC2B5\uB2C8\uB2E4.
+job_id: ${job.id}  (pid ${job.pid ?? "?"})
+\uACC4\uC18D \uC2E4\uD589\uB418\uBA70 \uCD9C\uB825\uC774 \uCEA1\uCC98\uB429\uB2C8\uB2E4. \uC0C1\uD0DC\xB7\uCD9C\uB825\uC740 ShellJob(action:'poll', job_id) \uB85C, \uC885\uB8CC\uB294 ShellJob(action:'kill', job_id) \uB85C \uD655\uC778/\uC81C\uC5B4\uD558\uC138\uC694.`
+            }
+          ]
+        }),
+        BG_SETTLE_MS
+      );
+    });
+  }
+  /** ShellJob: manage background jobs — list / poll (status+output) / kill. */
+  async shellJob(args) {
+    const a = args && typeof args === "object" ? args : {};
+    const action = String(a.action ?? "list").toLowerCase();
+    const jobId = String(a.job_id ?? a.jobId ?? "").trim();
+    if (action === "list") {
+      if (!bgJobs.size)
+        return {
+          content: [
+            { type: "text", text: "\uC2E4\uD589 \uC911\uC774\uAC70\uB098 \uCD5C\uADFC \uC885\uB8CC\uB41C \uBC31\uADF8\uB77C\uC6B4\uB4DC \uC791\uC5C5\uC774 \uC5C6\uC2B5\uB2C8\uB2E4." }
+          ]
+        };
+      const rows = [...bgJobs.values()].sort((x, y) => y.startedAt - x.startedAt).map((j) => {
+        const dur = Math.round(((j.endedAt ?? Date.now()) - j.startedAt) / 1e3);
+        const exit = j.status === "running" ? "" : ` exit=${j.signal ? j.signal : j.code}`;
+        return `${j.id}  [${j.status}${exit}]  pid=${j.pid ?? "?"}  ${dur}s  ${j.command.slice(0, 80)}`;
+      });
+      return { content: [{ type: "text", text: rows.join("\n") }] };
+    }
+    const job = jobId ? bgJobs.get(jobId) : void 0;
+    if (!job) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `job_id '${jobId}' \uB97C \uCC3E\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4. ShellJob(action:'list') \uB85C \uD655\uC778\uD558\uC138\uC694.`
+          }
+        ],
+        isError: true
+      };
+    }
+    if (action === "kill") {
+      if (job.status === "running") {
+        killTree(job.child, job.detachedGroup);
+        job.status = "killed";
+        job.endedAt = Date.now();
+      }
+      return {
+        content: [
+          { type: "text", text: `\uC791\uC5C5 ${job.id} \uC744(\uB97C) \uC885\uB8CC\uD588\uC2B5\uB2C8\uB2E4 (\uC0C1\uD0DC: ${job.status}).` }
+        ]
+      };
+    }
+    if (action === "poll" || action === "logs") {
+      const head = Number(a.head) || 0;
+      const tail = Number(a.tail) || (head ? 0 : 200);
+      const maxBytes = Number(a.max_bytes ?? a.maxBytes) || 0;
+      const outP = paginate(job.stdout, { head, tail, maxBytes });
+      const errP = paginate(job.stderr, { head, tail, maxBytes });
+      const dur = Math.round(((job.endedAt ?? Date.now()) - job.startedAt) / 1e3);
+      const header = `job ${job.id} \u2014 ${job.status}` + (job.status !== "running" ? ` (exit ${job.signal ? job.signal : job.code})` : "") + `  pid=${job.pid ?? "?"}  ${dur}s`;
+      const parts = [header];
+      if (job.errorMsg) parts.push(`ERROR: ${job.errorMsg}`);
+      parts.push(
+        `--- stdout${outP.truncated ? ` (last, ${outP.totalBytes}B total)` : ""} ---
+${outP.text || "(none)"}`
+      );
+      if (errP.text.trim() || errP.totalBytes) {
+        parts.push(
+          `--- stderr${errP.truncated ? ` (last, ${errP.totalBytes}B total)` : ""} ---
+${errP.text || "(none)"}`
+        );
+      }
+      return {
+        content: [{ type: "text", text: parts.join("\n\n") }],
+        isError: job.status === "error"
+      };
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: `\uC54C \uC218 \uC5C6\uB294 action '${action}'. list | poll | kill \uC911 \uD558\uB098\uB97C \uC4F0\uC138\uC694.`
+        }
+      ],
+      isError: true
+    };
+  }
+};
+var _provider = null;
+function getLocalToolProvider() {
+  if (!_provider) _provider = new LocalToolProvider();
+  return _provider;
+}
+
+// ../../packages/engine/src/mcp-runtime-log.ts
+var MAX_ENTRIES = 200;
+var entries = [];
+var listeners = /* @__PURE__ */ new Set();
+var sequence = 0;
+function appendMcpRuntimeLog(entry) {
+  const next = {
+    ...entry,
+    id: ++sequence,
+    timestamp: Date.now()
+  };
+  entries.push(next);
+  if (entries.length > MAX_ENTRIES) entries.splice(0, entries.length - MAX_ENTRIES);
+  for (const listener of listeners) {
+    try {
+      listener(next);
+    } catch {
+    }
+  }
+  return next;
+}
+
+// ../../packages/engine/src/connection-security.ts
+function xgenWebSocketTlsOptions(enabled) {
+  return { rejectUnauthorized: !enabled };
+}
+
+// ../../packages/engine/src/mcp-bridge.ts
+var HEARTBEAT_MS = 2e4;
+var RECONNECT_MIN_MS = 5e3;
+var RECONNECT_MAX_MS = 6e4;
+var SETTLE_MS = 1200;
+var GRACE_MS = 4e3;
+var McpBridge = class {
+  ws = null;
+  hb = null;
+  retry = null;
+  settle = null;
+  grace = null;
+  backoff = RECONNECT_MIN_MS;
+  stopped = true;
+  /** Debounced UI state — NOT the raw socket state, to avoid flicker. */
+  uiConnected = false;
+  catalogSynced = false;
+  serverToolCount = 0;
+  catalogSeq = 0;
+  pendingCatalogId = "";
+  serverUrl = "";
+  userId = "";
+  allowPrivateCertificate = false;
+  getToken = async () => null;
+  refreshAuth = async () => null;
+  lastServers = [];
+  lastError;
+  lastEmit = "";
+  onStatus = () => {
+  };
+  setStatusListener(cb) {
+    this.onStatus = cb;
+  }
+  status() {
+    const localTools = getLocalToolProvider().advertise();
+    const localServer = localTools.length ? [{ name: LOCAL_SERVER, connected: true, tools: localTools }] : [];
+    return {
+      enabled: !this.stopped,
+      connected: this.uiConnected,
+      catalogSynced: this.catalogSynced,
+      serverToolCount: this.serverToolCount,
+      error: this.lastError,
+      servers: [...localServer, ...this.lastServers]
+    };
+  }
+  /** Emit only when the status actually changed (dedupe). */
+  emit() {
+    const s = this.status();
+    const key = JSON.stringify({
+      e: s.enabled,
+      c: s.connected,
+      sync: s.catalogSynced,
+      tools: s.serverToolCount,
+      err: s.error,
+      n: s.servers.map((x) => [x.name, x.connected, x.tools.length])
+    });
+    if (key === this.lastEmit) return;
+    this.lastEmit = key;
+    this.onStatus(s);
+  }
+  start(opts) {
+    const sameTarget = this.serverUrl === opts.serverUrl && this.userId === opts.userId && this.allowPrivateCertificate === opts.allowPrivateCertificate;
+    this.serverUrl = opts.serverUrl;
+    this.userId = opts.userId;
+    this.allowPrivateCertificate = opts.allowPrivateCertificate;
+    this.getToken = opts.getToken;
+    if (opts.refreshAuth) this.refreshAuth = opts.refreshAuth;
+    if (!this.stopped && sameTarget && (this.ws || this.retry)) {
+      void this.refreshCatalog();
+      return;
+    }
+    this.stopped = false;
+    this.backoff = RECONNECT_MIN_MS;
+    this.reconnect(true);
+  }
+  stop() {
+    this.stopped = true;
+    this.clearTimers();
+    try {
+      const ws = this.ws;
+      if (ws) {
+        ws.removeAllListeners();
+        ws.on("error", () => void 0);
+        ws.close();
+      }
+    } catch {
+    }
+    this.ws = null;
+    this.uiConnected = false;
+    this.catalogSynced = false;
+    this.serverToolCount = 0;
+    this.pendingCatalogId = "";
+    this.lastError = void 0;
+    this.emit();
+  }
+  clearTimers() {
+    for (const t of [this.retry, this.hb, this.settle, this.grace]) if (t) clearTimeout(t);
+    this.retry = this.hb = this.settle = this.grace = null;
+  }
+  /**
+   * 서버들에 다시 붙어 카탈로그·상태를 갱신한다.
+   *
+   * 소켓이 열려 있지 않아도 재광고한다 — 한 번 실패한 서버의 오류 문구가
+   * 소켓 이벤트가 있을 때까지 화면에 그대로 남아 있던 문제(사용자가 uv 를
+   * 나중에 설치한 경우)를 여기서 끊는다. sendHello() 는 열려 있을 때만
+   * 실제로 전송하고, 상태는 항상 emit 한다.
+   */
+  /**
+   * 카탈로그가 서버에 반영될 때까지 기다린다 (헤드리스 실행용).
+   *
+   * CLI 는 한 번 물어보고 끝나는 명령이 많다 — 브릿지가 붙기 전에 채팅을 시작하면
+   * 에이전트에게 로컬 도구가 없는 채로 첫 턴이 돈다. 데스크톱은 창이 떠 있으니
+   * 상태 표시로 충분하지만 CLI 에는 기다릴 자리가 필요하다.
+   *
+   * 타임아웃은 실패가 아니다 — 현재 상태를 그대로 돌려주고, 부를 쪽이 판단한다.
+   */
+  async waitUntilReady(timeoutMs = 3e3) {
+    if (this.status().catalogSynced) return this.status();
+    return new Promise((resolve) => {
+      const previous = this.onStatus;
+      let done = false;
+      const finish = (s) => {
+        if (done) return;
+        done = true;
+        this.setStatusListener(previous);
+        resolve(s);
+      };
+      const timer = setTimeout(() => finish(this.status()), Math.max(0, timeoutMs));
+      this.setStatusListener((s) => {
+        previous(s);
+        if (!s.catalogSynced) return;
+        clearTimeout(timer);
+        finish(s);
+      });
+    });
+  }
+  async refreshCatalog() {
+    await this.sendHello();
+  }
+  wsUrl() {
+    const base = this.serverUrl.replace(/\/+$/, "").replace(/^http/, "ws");
+    return `${base}/api/tools/ws/connector-mcp/${encodeURIComponent(this.userId)}`;
+  }
+  scheduleRetry() {
+    if (this.stopped || this.retry) return;
+    const delay = this.backoff;
+    this.backoff = Math.min(RECONNECT_MAX_MS, Math.round(this.backoff * 1.8));
+    this.retry = setTimeout(() => {
+      this.retry = null;
+      void this.reconnect(false);
+    }, delay);
+  }
+  async reconnect(immediate) {
+    if (this.stopped) return;
+    if (immediate && this.retry) {
+      clearTimeout(this.retry);
+      this.retry = null;
+    }
+    if (!immediate && this.retry) return;
+    if (this.settle) {
+      clearTimeout(this.settle);
+      this.settle = null;
+    }
+    if (this.hb) {
+      clearInterval(this.hb);
+      this.hb = null;
+    }
+    try {
+      const ws2 = this.ws;
+      if (ws2) {
+        ws2.removeAllListeners();
+        ws2.on("error", () => void 0);
+        ws2.close();
+      }
+    } catch {
+    }
+    this.ws = null;
+    const token = await this.getToken();
+    if (this.stopped || !this.serverUrl || !this.userId) {
+      if (!this.stopped) this.scheduleRetry();
+      return;
+    }
+    let ws;
+    try {
+      ws = new WebSocket(this.wsUrl(), {
+        headers: token ? { Authorization: `Bearer ${token}` } : void 0,
+        ...xgenWebSocketTlsOptions(this.allowPrivateCertificate)
+      });
+    } catch (e) {
+      this.lastError = e instanceof Error ? e.message : String(e);
+      this.emit();
+      this.scheduleRetry();
+      return;
+    }
+    this.ws = ws;
+    ws.on("unexpected-response", (_req, res) => {
+      const sc = res?.statusCode ?? 0;
+      try {
+        res?.resume?.();
+      } catch {
+      }
+      this.lastError = `handshake HTTP ${sc}`;
+      const heal = sc === 401 || sc === 403 ? Promise.resolve(this.refreshAuth()).catch(() => null) : Promise.resolve(null);
+      void heal.then((fresh) => {
+        if (this.ws === ws) this.ws = null;
+        try {
+          ws.removeAllListeners();
+          ws.close();
+        } catch {
+        }
+        if (fresh) this.backoff = RECONNECT_MIN_MS;
+        this.emit();
+        this.scheduleRetry();
+      });
+    });
+    ws.on("open", () => {
+      if (this.grace) {
+        clearTimeout(this.grace);
+        this.grace = null;
+      }
+      this.lastError = void 0;
+      void this.sendHello();
+      if (this.hb) clearInterval(this.hb);
+      this.hb = setInterval(() => {
+        try {
+          if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify({ type: "ping" }));
+        } catch {
+        }
+      }, HEARTBEAT_MS);
+      if (this.settle) clearTimeout(this.settle);
+      this.settle = setTimeout(() => {
+        this.settle = null;
+        if (this.ws === ws && ws.readyState === WebSocket.OPEN) {
+          this.uiConnected = true;
+          this.backoff = RECONNECT_MIN_MS;
+          this.emit();
+        }
+      }, SETTLE_MS);
+    });
+    ws.on("message", (raw) => void this.onMessage(String(raw)));
+    ws.on("close", () => {
+      if (this.settle) {
+        clearTimeout(this.settle);
+        this.settle = null;
+      }
+      if (this.hb) {
+        clearInterval(this.hb);
+        this.hb = null;
+      }
+      if (this.stopped) return;
+      this.catalogSynced = false;
+      this.serverToolCount = 0;
+      this.pendingCatalogId = "";
+      if (this.uiConnected && !this.grace) {
+        this.grace = setTimeout(() => {
+          this.grace = null;
+          this.uiConnected = false;
+          this.emit();
+        }, GRACE_MS);
+      }
+      this.scheduleRetry();
+    });
+    ws.on("error", (e) => {
+      this.lastError = e?.message;
+      try {
+        ws.close();
+      } catch {
+      }
+    });
+  }
+  async sendHello() {
+    try {
+      const adverts = await getMcpManager().advertise();
+      this.lastServers = adverts;
+      const tools = adverts.filter((a) => a.connected).flatMap(
+        (a) => a.tools.map((t) => ({
+          server: a.name,
+          name: t.name,
+          description: t.description,
+          inputSchema: t.inputSchema
+        }))
+      );
+      const builtins = getLocalToolProvider().advertise().map((t) => ({
+        server: LOCAL_SERVER,
+        name: t.name,
+        description: t.description,
+        inputSchema: t.inputSchema
+      }));
+      tools.unshift(...builtins);
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        const catalogId = `${Date.now()}-${++this.catalogSeq}`;
+        this.pendingCatalogId = catalogId;
+        this.catalogSynced = false;
+        this.serverToolCount = 0;
+        this.ws.send(JSON.stringify({ type: "hello", catalog_id: catalogId, tools }));
+        appendMcpRuntimeLog({
+          kind: "catalog",
+          message: `\uB3C4\uAD6C \uCE74\uD0C8\uB85C\uADF8 ${tools.length}\uAC1C \uC7AC\uCD08\uAE30\uD654 \uC694\uCCAD`,
+          requestId: catalogId
+        });
+      }
+      this.emit();
+    } catch (e) {
+      this.lastError = e instanceof Error ? e.message : String(e);
+      this.emit();
+    }
+  }
+  async onMessage(text) {
+    let msg;
+    try {
+      msg = JSON.parse(text);
+    } catch {
+      return;
+    }
+    if (msg.type === "ready") {
+      if (msg.catalog_id !== this.pendingCatalogId) return;
+      this.catalogSynced = true;
+      this.serverToolCount = Number.isFinite(msg.tool_count) ? Math.max(0, Math.trunc(msg.tool_count)) : 0;
+      appendMcpRuntimeLog({
+        kind: "catalog",
+        message: `workflow \uB3C4\uAD6C ${this.serverToolCount}\uAC1C \uC801\uC6A9 \uC644\uB8CC`,
+        requestId: msg.catalog_id,
+        ok: true
+      });
+      this.emit();
+      return;
+    }
+    if (msg.type === "mcp_call") {
+      const { request_id, server, tool, args } = msg;
+      const context = localToolCallContext(msg.context);
+      const startedAt = Date.now();
+      appendMcpRuntimeLog({
+        kind: "call",
+        message: "\uB85C\uCEEC MCP \uB3C4\uAD6C \uD638\uCD9C \uC218\uC2E0",
+        requestId: request_id,
+        server: String(server),
+        tool: String(tool)
+      });
+      let payload;
+      try {
+        const local = getLocalToolProvider();
+        const result = local.owns(String(server)) ? await local.callTool(String(tool), args ?? {}, context) : await getMcpManager().callTool(String(server), String(tool), args ?? {});
+        payload = { request_id, ok: true, result };
+      } catch (e) {
+        payload = { request_id, ok: false, error: e instanceof Error ? e.message : String(e) };
+      }
+      appendMcpRuntimeLog({
+        kind: "result",
+        message: payload.ok ? "\uB85C\uCEEC MCP \uB3C4\uAD6C \uC2E4\uD589 \uC131\uACF5" : String(payload.error || "\uB85C\uCEEC MCP \uB3C4\uAD6C \uC2E4\uD589 \uC2E4\uD328"),
+        requestId: request_id,
+        server: String(server),
+        tool: String(tool),
+        ok: payload.ok === true,
+        durationMs: Date.now() - startedAt
+      });
+      try {
+        this.ws?.send(JSON.stringify({ type: "mcp_result", ...payload }));
+      } catch {
+      }
+    }
+  }
+};
+var _bridge = null;
+function getMcpBridge() {
+  if (!_bridge) _bridge = new McpBridge();
+  return _bridge;
+}
+
+// ../../packages/engine/src/dex-engine.ts
+var DexEngine = class {
+  constructor(configs, credentials, options = {}) {
+    this.configs = configs;
+    this.credentials = credentials;
+    this.localTools = options.localToolProvider ?? getLocalToolProvider();
+    this.localToolBridge = options.localToolBridge ?? getMcpBridge();
+  }
+  clients = /* @__PURE__ */ new Map();
+  localTools;
+  localToolBridge;
+  async listProfiles() {
+    const config = await this.configs.read();
+    return Object.entries(config.profiles).map(([name, profile]) => ({ name, ...profile, current: name === config.currentProfile })).sort((a, b) => a.name.localeCompare(b.name));
+  }
+  onLocalToolsStatus(listener) {
+    this.localToolBridge.setStatusListener(listener);
+    return () => this.localToolBridge.setStatusListener(() => void 0);
+  }
+  /**
+   * 설정을 도구 제공자에 반영한다.
+   *
+   * `allowDangerous` 는 여기서 승인 포트로 바뀐다 — 물을 사람이 없는 실행에서
+   * "설정으로 미리 승인했다"를 표현하는 유일한 자리다. 이미 호스트가 붙어 있으면
+   * 그 포트를 유지한 채 승인 답만 덮는다(데스크톱에서 물을 수 있는 능력을
+   * 설정 하나로 잃지 않게).
+   */
+  applyToolConfig(config) {
+    this.localTools.configure(toShellConfig(config));
+    const preApproved = dangerousApprovalFromConfig(config);
+    if (!preApproved) return;
+    const current = isHostBound() ? hostPorts() : null;
+    if (!current) return;
+    bindHost({
+      ...current,
+      interaction: { ...current.interaction ?? {}, confirmDangerous: preApproved }
+    });
+  }
+  async localToolsStatus() {
+    const config = normalizeLocalToolsConfig((await this.configs.read()).localTools);
+    this.applyToolConfig(config);
+    const tools = this.localTools.advertise();
+    const bridge = this.localToolBridge.status();
+    return { config, tools, catalog: this.localTools.catalog(), bridge };
+  }
+  async configureLocalTools(patch) {
+    const config = await this.configs.read();
+    const current = normalizeLocalToolsConfig(config.localTools);
+    config.localTools = normalizeLocalToolsConfig({
+      ...current,
+      ...patch,
+      allowedRoots: patch.allowedRoots ?? current.allowedRoots,
+      blockedCommands: patch.blockedCommands ?? current.blockedCommands
+    });
+    await this.configs.write(config);
+    this.applyToolConfig(config.localTools);
+    if (!config.localTools.enabled) this.localToolBridge.stop();
+    else this.localToolBridge.refreshCatalog();
+    return this.localToolsStatus();
+  }
+  async runLocalTool(tool, args) {
+    const config = normalizeLocalToolsConfig((await this.configs.read()).localTools);
+    this.applyToolConfig(config);
+    return this.localTools.callTool(tool, args);
+  }
+  async startLocalTools(requestedProfile, waitMs = 0) {
+    const config = normalizeLocalToolsConfig((await this.configs.read()).localTools);
+    this.applyToolConfig(config);
+    if (!config.enabled) {
+      this.localToolBridge.stop();
+      return this.localToolsStatus();
+    }
+    const record = await this.authenticatedRecord(requestedProfile);
+    const userId = record.client.user?.userId?.trim();
+    if (!userId) throw new DexError("auth_invalid", "\uB85C\uCEEC \uB3C4\uAD6C \uC5F0\uACB0\uC5D0 \uD544\uC694\uD55C \uC0AC\uC6A9\uC790 ID\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.");
+    this.localToolBridge.start({
+      serverUrl: record.serverUrl,
+      userId,
+      // CLI 는 사내 인증서를 아직 설정으로 받지 않는다 — 기본은 검증이다.
+      allowPrivateCertificate: false,
+      getToken: async () => {
+        await this.flush(record);
+        return record.client.getAccessTokenAfterRotation() || (await this.credentials.get(record.profile))?.accessToken || null;
+      },
+      refreshAuth: async () => {
+        const session = await this.credentials.get(record.profile);
+        const token = await record.client.ensureFreshAuth(session?.refreshToken);
+        await this.flush(record);
+        return token;
+      }
+    });
+    if (waitMs > 0) await this.localToolBridge.waitUntilReady(waitMs);
+    return this.localToolsStatus();
+  }
+  stopLocalTools() {
+    this.localToolBridge.stop();
+  }
+  // ── SSH ───────────────────────────────────────────────────────────
+  //
+  // 개인 SSH 서버 목록은 XGEN 계정에 있고 접속은 서버가 연다 — 이 기기에서
+  // 닿는지는 에이전트에게 아무 의미가 없다. 그래서 여기는 얇은 통과 계층이고,
+  // 검증(이름 규칙 · 점프 그래프 · 자격증명 유무)은 전부 서버가 한다.
+  //
+  // 비밀번호와 개인키는 응답에 실리지 않는다. 쓰기는 부분 수정이라 보내지 않은
+  // 자격증명은 유지되고 빈 문자열로만 지워진다 — 설명만 고치려던 저장이 접속을
+  // 끊으면 안 된다.
+  async sshConfig(profile) {
+    const record = await this.authenticatedRecord(profile);
+    return record.client.ssh.getConfig();
+  }
+  async setSshEnabled(enabled, profile) {
+    const record = await this.authenticatedRecord(profile);
+    return record.client.ssh.setEnabled(enabled);
+  }
+  async createSshServer(input, profile) {
+    const record = await this.authenticatedRecord(profile);
+    return record.client.ssh.createServer(input);
+  }
+  async updateSshServer(name, input, profile) {
+    const record = await this.authenticatedRecord(profile);
+    return record.client.ssh.updateServer(name, input);
+  }
+  async deleteSshServer(name, profile) {
+    const record = await this.authenticatedRecord(profile);
+    return record.client.ssh.deleteServer(name);
+  }
+  /** 서버가 점프 경로를 그대로 타고 실제로 접속해 본다. 마스터 스위치와 무관하다 —
+   *  켜기 전에 맞는지 확인할 수 있어야 한다. */
+  async testSshServer(name, profile) {
+    const record = await this.authenticatedRecord(profile);
+    return record.client.ssh.testServer(name);
+  }
+  async setProfile(nameInput, serverUrlInput) {
+    const name = validateProfileName(nameInput);
+    const serverUrl = validateServerUrl(serverUrlInput);
+    const config = await this.configs.read();
+    const previous = config.profiles[name];
+    config.profiles[name] = { serverUrl };
+    if (!config.profiles[config.currentProfile]) config.currentProfile = name;
+    await this.configs.write(config);
+    this.clients.delete(name);
+    if (name === config.currentProfile && previous?.serverUrl !== serverUrl) this.localToolBridge.stop();
+    if (previous && previous.serverUrl !== serverUrl) await this.credentials.delete(name);
+    return { name, serverUrl, current: name === config.currentProfile };
+  }
+  async useProfile(nameInput) {
+    const name = validateProfileName(nameInput);
+    const config = await this.configs.read();
+    const profile = config.profiles[name];
+    if (!profile) throw new DexError("not_found", `\uD504\uB85C\uD544\uC744 \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${name}`);
+    config.currentProfile = name;
+    await this.configs.write(config);
+    this.localToolBridge.stop();
+    return { name, ...profile, current: true };
+  }
+  async login(email, password, requestedProfile) {
+    if (!email.trim() || !password) throw new DexError("usage_error", "\uC774\uBA54\uC77C\uACFC \uBE44\uBC00\uBC88\uD638\uAC00 \uD544\uC694\uD569\uB2C8\uB2E4.");
+    const { name, profile } = await this.resolveProfile(requestedProfile);
+    this.clients.delete(name);
+    const record = this.createClient(name, profile.serverUrl);
+    const result = await record.client.login(email.trim(), password);
+    const session = {
+      serverUrl: profile.serverUrl,
+      accessToken: result.accessToken,
+      refreshToken: result.refreshToken
+    };
+    await this.credentials.set(name, session);
+    await this.flush(record);
+    record.authenticated = true;
+    return {
+      profile: name,
+      serverUrl: profile.serverUrl,
+      authenticated: true,
+      user: record.client.user ?? void 0
+    };
+  }
+  async authStatus(requestedProfile) {
+    const { name, profile } = await this.resolveProfile(requestedProfile);
+    const session = await this.credentials.get(name);
+    if (!session || session.serverUrl !== profile.serverUrl) {
+      return {
+        profile: name,
+        serverUrl: profile.serverUrl,
+        authenticated: false,
+        reason: "missing_session"
+      };
+    }
+    try {
+      const record = await this.ensureAuthenticated(name, profile.serverUrl, session);
+      return {
+        profile: name,
+        serverUrl: profile.serverUrl,
+        authenticated: true,
+        user: record.client.user ?? void 0
+      };
+    } catch (error) {
+      if (error instanceof DexError && error.code === "network_error") {
+        return {
+          profile: name,
+          serverUrl: profile.serverUrl,
+          authenticated: false,
+          reason: "network"
+        };
+      }
+      if (error instanceof DexError && (error.code === "auth_required" || error.code === "auth_invalid")) {
+        return {
+          profile: name,
+          serverUrl: profile.serverUrl,
+          authenticated: false,
+          reason: "invalid_session"
+        };
+      }
+      throw error;
+    }
+  }
+  async logout(requestedProfile) {
+    const { name, profile } = await this.resolveProfile(requestedProfile);
+    const session = await this.credentials.get(name);
+    if (session?.serverUrl === profile.serverUrl) {
+      const record = this.createClient(name, profile.serverUrl);
+      record.client.setTokens(session.accessToken, session.refreshToken);
+      await record.client.logout().catch(() => {
+      });
+    }
+    await this.credentials.delete(name);
+    this.clients.delete(name);
+    this.localToolBridge.stop();
+  }
+  async listAgents(query = {}, requestedProfile) {
+    return this.withAuthRetry(requestedProfile, (client) => client.agents.list(query));
+  }
+  async listConversations(requestedProfile) {
+    return this.withAuthRetry(requestedProfile, (client) => client.history.conversations());
+  }
+  async historyTurns(workflowId, interactionId, workflowName, requestedProfile) {
+    if (!workflowId || !interactionId) {
+      throw new DexError("usage_error", "workflowId\uC640 interactionId\uAC00 \uD544\uC694\uD569\uB2C8\uB2E4.");
+    }
+    return this.withAuthRetry(
+      requestedProfile,
+      (client) => client.history.turns(workflowId, interactionId, workflowName)
+    );
+  }
+  async resolveChatInput(input) {
+    const workflowId = input.workflowId.trim();
+    if (!workflowId) throw new DexError("usage_error", "Agent workflow ID\uAC00 \uD544\uC694\uD569\uB2C8\uB2E4.");
+    const { name } = await this.resolveProfile(input.profile);
+    const workflowName = input.workflowName?.trim() || (await this.findAgent(workflowId, name)).workflowName;
+    return {
+      profile: name,
+      workflowId,
+      workflowName,
+      input: input.input,
+      interactionId: input.interactionId?.trim() || randomUUID()
+    };
+  }
+  async *chat(input, signal) {
+    const resolved = await this.resolveChatInput(input);
+    let record = await this.authenticatedRecord(resolved.profile);
+    let emitted = false;
+    try {
+      const local = await this.startLocalTools(resolved.profile, 3e3);
+      if (local.config.enabled) {
+        yield local.bridge.catalogSynced ? {
+          kind: "status",
+          surface: "connector_local",
+          detail: `\uB85C\uCEEC \uB3C4\uAD6C ${local.bridge.serverToolCount || local.tools.length}\uAC1C \uC5F0\uACB0\uB428`
+        } : {
+          kind: "status",
+          surface: "connector_local",
+          detail: local.bridge.error || "\uB85C\uCEEC \uB3C4\uAD6C \uCE74\uD0C8\uB85C\uADF8 \uC5F0\uACB0 \uB300\uAE30 \uC911",
+          reason: "bridge_not_ready"
+        };
+      }
+    } catch (error) {
+      yield {
+        kind: "status",
+        surface: "connector_local",
+        detail: `\uB85C\uCEEC \uB3C4\uAD6C \uC5F0\uACB0 \uC2E4\uD328: ${error instanceof Error ? error.message : String(error)}`,
+        reason: "bridge_error"
+      };
+    }
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      try {
+        for await (const event of record.client.chat.stream(
+          {
+            workflowId: resolved.workflowId,
+            workflowName: resolved.workflowName,
+            input: resolved.input,
+            interactionId: resolved.interactionId
+          },
+          signal
+        )) {
+          emitted = true;
+          yield event;
+        }
+        return resolved;
+      } catch (error) {
+        if (attempt === 0 && !emitted && isUnauthorized(error)) {
+          await this.refresh(record);
+          record = await this.authenticatedRecord(resolved.profile);
+          continue;
+        }
+        throw error;
+      }
+    }
+    return resolved;
+  }
+  async findAgent(selector, profile) {
+    const agents = await this.withAuthRetry(profile, (client) => client.agents.listAll({}, 100));
+    const normalized = selector.trim().toLocaleLowerCase();
+    const found = agents.find((agent) => agent.workflowId === selector.trim()) ?? agents.find((agent) => agent.workflowName.toLocaleLowerCase() === normalized);
+    if (!found) throw new DexError("not_found", `Agent\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${selector}`);
+    return found;
+  }
+  async withAuthRetry(requestedProfile, operation) {
+    const record = await this.authenticatedRecord(requestedProfile);
+    try {
+      return await operation(record.client);
+    } catch (error) {
+      if (!isUnauthorized(error)) throw error;
+      await this.refresh(record);
+      return operation(record.client);
+    }
+  }
+  async authenticatedRecord(requestedProfile) {
+    const { name, profile } = await this.resolveProfile(requestedProfile);
+    const session = await this.credentials.get(name);
+    if (!session || session.serverUrl !== profile.serverUrl) {
+      throw new DexError("auth_required", `\uB85C\uADF8\uC778\uC774 \uD544\uC694\uD569\uB2C8\uB2E4: dex login --profile ${name}`);
+    }
+    return this.ensureAuthenticated(name, profile.serverUrl, session);
+  }
+  async ensureAuthenticated(name, serverUrl, session) {
+    const cached = this.clients.get(name);
+    if (cached?.authenticated && cached.serverUrl === serverUrl) return cached;
+    const record = cached?.serverUrl === serverUrl ? cached : this.createClient(name, serverUrl);
+    const state = await record.client.restoreDetailed(session.accessToken, session.refreshToken);
+    await this.flush(record);
+    if (state === "valid") {
+      record.authenticated = true;
+      return record;
+    }
+    if (state === "invalid") {
+      await this.credentials.delete(name);
+      this.clients.delete(name);
+      throw new DexError("auth_invalid", `\uC138\uC158\uC774 \uB9CC\uB8CC\uB418\uC5C8\uC2B5\uB2C8\uB2E4: dex login --profile ${name}`);
+    }
+    throw new DexError("network_error", `XGEN \uC11C\uBC84\uC5D0 \uC5F0\uACB0\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4: ${serverUrl}`);
+  }
+  createClient(profile, serverUrl) {
+    const existing = this.clients.get(profile);
+    if (existing?.serverUrl === serverUrl) return existing;
+    const record = {
+      profile,
+      serverUrl,
+      authenticated: false,
+      persisting: Promise.resolve()
+    };
+    record.client = new XgenClient({
+      baseUrl: serverUrl,
+      onTokensRotated: (accessToken, refreshToken) => {
+        record.persisting = record.persisting.then(
+          () => this.credentials.set(profile, { serverUrl, accessToken, refreshToken })
+        );
+      }
+    });
+    this.clients.set(profile, record);
+    return record;
+  }
+  async refresh(record) {
+    const session = await this.credentials.get(record.profile);
+    const accessToken = await record.client.ensureFreshAuth(session?.refreshToken);
+    await this.flush(record);
+    if (!accessToken) {
+      await this.credentials.delete(record.profile);
+      record.authenticated = false;
+      throw new DexError("auth_invalid", `\uC138\uC158\uC774 \uB9CC\uB8CC\uB418\uC5C8\uC2B5\uB2C8\uB2E4: dex login --profile ${record.profile}`);
+    }
+    record.authenticated = true;
+  }
+  async flush(record) {
+    await record.persisting;
+  }
+  async resolveProfile(requested) {
+    const config = await this.configs.read();
+    const name = requested ? validateProfileName(requested) : config.currentProfile;
+    const profile = config.profiles[name];
+    if (!profile) {
+      throw new DexError(
+        "config_invalid",
+        `XGEN \uC11C\uBC84 \uD504\uB85C\uD544\uC774 \uC5C6\uC2B5\uB2C8\uB2E4. \uBA3C\uC800 \uC2E4\uD589\uD558\uC138\uC694: dex profile set ${name} --server <URL>`
+      );
+    }
+    return { name, profile };
+  }
+};
+
+// ../../packages/engine/src/credential-store.ts
+var SERVICE = "xgen-dex-cli";
+var ACCOUNT_PREFIX = "profile:";
+async function loadKeytar() {
+  try {
+    const loaded = await import("keytar");
+    const keytar = loaded.default ?? loaded;
+    if (!keytar.getPassword || !keytar.setPassword || !keytar.deletePassword) throw new Error("invalid keytar module");
+    return keytar;
+  } catch (error) {
+    throw new DexError(
+      "credential_store_unavailable",
+      "OS \uD0A4\uCCB4\uC778\uC744 \uC0AC\uC6A9\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. keytar \uC124\uCE58\uC640 OS \uD0A4\uB9C1 \uC0C1\uD0DC\uB97C \uD655\uC778\uD558\uC138\uC694.",
+      error
+    );
+  }
+}
+function parseSession(raw) {
+  if (!raw) return null;
+  try {
+    const value = JSON.parse(raw);
+    if (!value.serverUrl || !value.accessToken) return null;
+    return value;
+  } catch {
+    return null;
+  }
+}
+var KeytarCredentialStore = class {
+  /**
+   * 엔진의 `SecretPort` 로 내보내는 두 함수 — 프로파일 세션 말고 **임의의 비밀**
+   * (MCP 서버 시크릿 · OAuth 상태)을 같은 백엔드에 둔다.
+   *
+   * 저장소를 나누지 않는 이유: 사용자에게는 "이 앱이 내 키체인에 무엇을 넣었나"가
+   * 하나의 질문이고, 두 곳에 나뉘면 로그아웃할 때 한쪽이 남는다.
+   */
+  async getRaw(name) {
+    const keytar = await loadKeytar();
+    return keytar.getPassword(SERVICE, name);
+  }
+  async setRaw(name, value) {
+    const keytar = await loadKeytar();
+    if (value === null) {
+      await keytar.deletePassword(SERVICE, name);
+      return true;
+    }
+    await keytar.setPassword(SERVICE, name, value);
+    return true;
+  }
+  async get(profile) {
+    const keytar = await loadKeytar();
+    return parseSession(await keytar.getPassword(SERVICE, ACCOUNT_PREFIX + profile));
+  }
+  async set(profile, session) {
+    const keytar = await loadKeytar();
+    await keytar.setPassword(SERVICE, ACCOUNT_PREFIX + profile, JSON.stringify(session));
+  }
+  async delete(profile) {
+    const keytar = await loadKeytar();
+    await keytar.deletePassword(SERVICE, ACCOUNT_PREFIX + profile);
+  }
+};
+
+// ../../packages/engine/src/deployment-defaults.ts
+function optionalBoolean(value, name) {
+  if (value === void 0 || value === "") return void 0;
+  if (value === "true" || value === "1") return true;
+  if (value === "false" || value === "0") return false;
+  throw new Error(`${name}\uC740 true, false, 1, 0 \uC911 \uD558\uB098\uC5EC\uC57C \uD569\uB2C8\uB2E4.`);
+}
+function resolveDeploymentDefaults(input) {
+  const defaults = {};
+  if (input.serverUrl) {
+    const serverUrl = input.serverUrl.trim().replace(/\/+$/, "");
+    const parsed = new URL(serverUrl);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      throw new Error("\uAE30\uBCF8 \uC11C\uBC84 URL\uC740 http \uB610\uB294 https URL\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4.");
+    }
+    defaults.serverUrl = serverUrl;
+  }
+  const allowPrivateCertificate = optionalBoolean(
+    input.allowPrivateCertificate,
+    "XGEN_DEFAULT_ALLOW_PRIVATE_CERTIFICATE"
+  );
+  if (allowPrivateCertificate !== void 0)
+    defaults.allowPrivateCertificate = allowPrivateCertificate;
+  const ssoEnabled = optionalBoolean(input.ssoEnabled, "XGEN_DEFAULT_SSO_ENABLED");
+  if (ssoEnabled !== void 0) defaults.ssoEnabled = ssoEnabled;
+  if (input.ssoPath) {
+    const ssoPath = input.ssoPath.trim();
+    if (!ssoPath.startsWith("/") || ssoPath.startsWith("//")) {
+      throw new Error("\uAE30\uBCF8 SSO PATH\uB294 /\uB85C \uC2DC\uC791\uD558\uB294 \uC0C1\uB300 \uACBD\uB85C\uC5EC\uC57C \uD569\uB2C8\uB2E4.");
+    }
+    defaults.ssoPath = ssoPath;
+  }
+  if (input.updateServer) {
+    if (input.updateServer !== "github" && input.updateServer !== "xgen") {
+      throw new Error("\uAE30\uBCF8 \uC5C5\uB370\uC774\uD2B8 \uC11C\uBC84\uB294 github \uB610\uB294 xgen\uC774\uC5B4\uC57C \uD569\uB2C8\uB2E4.");
+    }
+    defaults.updateServer = input.updateServer;
+  }
+  return defaults;
+}
+var DEPLOYMENT_DEFAULTS = resolveDeploymentDefaults({
+  serverUrl: process.env.XGEN_DEFAULT_SERVER_URL,
+  allowPrivateCertificate: process.env.XGEN_DEFAULT_ALLOW_PRIVATE_CERTIFICATE,
+  ssoEnabled: process.env.XGEN_DEFAULT_SSO_ENABLED,
+  ssoPath: process.env.XGEN_DEFAULT_SSO_PATH,
+  updateServer: process.env.XGEN_DEFAULT_UPDATE_SERVER
+});
+
+export {
+  bindHost,
+  openerInvocation,
+  DANGEROUS_COMMAND_PROMPT,
+  DexError,
+  publicError,
+  dataDirectory,
+  FileConfigStore,
+  DexEngine,
+  KeytarCredentialStore
+};
+//# sourceMappingURL=chunk-QXSCKZEG.js.map