aimakeall-mcp 0.13.0 → 0.14.0

package/README.md

@@ -7,22 +7,41 @@ Claude Code·Codex 같은 MCP 클라이언트에서 자연어로 AImakeAll 영
 
 ## 설정
 
+macOS·Windows에서 **Node.js 20 이상**이 필요합니다.
+
 1. [aimakeall.com](https://aimakeall.com) 로그인 → **API 키 설정 → MCP 토큰**에서 토큰 발급 (발급 직후 1회만 표시)
 2. AImakeAll 컴패니언 앱 설치·실행 (렌더용)
-3. MCP 클라이언트 설정 — 버전을 고정해 주세요:
+3. MCP 클라이언트 설정 — **부트스트랩은 `aimakeall-mcp@0.14.0`에 고정**해 주세요. 이후 실제 런타임 버전이 올라가도 이 설치 인자는 그대로 유지합니다:
 
 ```json
 {
   "mcpServers": {
     "aimakeall": {
       "command": "npx",
-      "args": ["-y", "aimakeall-mcp@0.13.0"],
+      "args": ["-y", "aimakeall-mcp@0.14.0"],
       "env": { "AIMAKEALL_PAT": "aio_pat_..." }
     }
   }
 }
 ```
 
+Windows에서 MCP 클라이언트가 `npx`를 직접 실행하지 못한다면 해당 클라이언트의 `cmd /c npx` 실행 래퍼를 사용하세요. 기존 Windows 설정에 래퍼가 있으면 패키지 인자만 바꾸고 래퍼는 유지합니다.
+
+## 시작 시 안전한 자동 업데이트 (0.14.0)
+
+- 부트스트랩은 **MCP 프로세스를 시작할 때** 공식 `https://aimakeall.com/api/mcp/release`에서 승인 릴리스를 확인하고, 배포 파일의 해시를 검증한 뒤 해당 런타임을 사용합니다. npm의 최신 태그를 무조건 실행하는 방식이 아니므로 설치 명령을 `@latest`로 바꾸지 마세요.
+- 업데이트 확인·다운로드·검증에 실패하면 마지막 정상 런타임 또는 동봉 런타임으로 시작합니다. 실행 중인 MCP·제작·렌더 프로세스를 교체하거나 종료하지 않습니다. 새 런타임은 다음 MCP 시작/재연결에 적용됩니다.
+- 자동 업데이트는 기본으로 켜져 있습니다. MCP 설정의 기존 `env`에 `"AIMAKEALL_MCP_AUTO_UPDATE": "0"`을 추가하면 끌 수 있습니다. 나머지 환경변수와 PAT는 유지하세요.
+- **이미 연결한 사용자**는 API 키 설정 → MCP 토큰의 **자동 업데이트 전환 안내**를 복사해 AI에게 전달하세요. 최초 1회 기존 `aimakeall` 실행 항목만 위 부트스트랩으로 바꿉니다. 기존 PAT·다른 MCP·관련 없는 파일은 보존하며 **토큰 재발급은 필요 없습니다.** 설정 백업은 로컬에 보관하고 토큰을 로그나 대화에 출력하지 마세요.
+- 진행 중인 작업이 끝난 뒤 유휴 상태에서만 `aimakeall`을 다시 연결하세요. 이후 런타임 업데이트마다 설정 파일의 버전을 바꿀 필요는 없습니다. 이 업데이트는 MCP용이며 **로컬 렌더용 컴패니언 설치·업데이트는 별도**입니다.
+
+버전과 업데이트 상태를 확인하는 명령(기존 MCP 연결을 종료하지 않음):
+
+```sh
+npx -y aimakeall-mcp@0.14.0 --version
+npx -y aimakeall-mcp@0.14.0 --update-status
+```
+
 ## 환경변수
 
 | 변수 | 기본값 | 설명 |
@@ -31,6 +50,7 @@ Claude Code·Codex 같은 MCP 클라이언트에서 자연어로 AImakeAll 영
 | `AIMAKEALL_API_BASE` | `https://aimakeall.com` | API 서버 |
 | `AIMAKEALL_COMPANION_URL` | `http://127.0.0.1:9876` | 로컬 컴패니언 (SSH 터널 시 변경) |
 | `AIMAKEALL_OUTPUT_DIR` | `~/Downloads/AImakeAll` | 렌더 결과 mp4 저장 위치 |
+| `AIMAKEALL_MCP_AUTO_UPDATE` | 사용 | `0`이면 시작 시 자동 업데이트를 끔 |
 
 ## 기본 플로우 (쇼츠)
 
@@ -55,7 +75,7 @@ plan_shorts_video → (씬마다) generate_scene_image → get_generation_job(co
 
 ## 제작 스타일 유지와 컷컴포저 편집 (0.12.0)
 
-아래의 이미지 소스·영상 표현 선택과 TTS 자동 우선순위는 MCP 0.12.0부터 지원합니다. 현재 설정은 `aimakeall-mcp@0.13.0`으로 바꾸고 클라이언트를 다시 연결하세요. 토큰은 그대로 사용할 수 있습니다. 대응 서버와 컴패니언 런타임도 필요하며, 컴패니언에서 렌더 기능 업데이트를 요청하면 최신 설치 프로그램으로 업데이트하세요.
+아래의 이미지 소스·영상 표현 선택과 TTS 자동 우선순위는 MCP 0.12.0부터 지원합니다. 기존 설치는 위의 `aimakeall-mcp@0.14.0` 부트스트랩으로 한 번 전환하고 유휴 상태에서 다시 연결하세요. 토큰은 그대로 사용할 수 있습니다. 대응 서버와 컴패니언 런타임도 필요하며, 컴패니언에서 렌더 기능 업데이트를 요청하면 최신 설치 프로그램으로 업데이트하세요.
 
 - `plan_shorts_video({categoryId:"viral-shorts",durationTargetSec:40,...})`는 `productionProfile`과 `productionPath`를 반환합니다. 이후 추천·TTS·스티치에 **가장 최근 반환된 `productionPath`**를 전달하세요. 제작별 불변 파일이라 동시에 만든 다른 영상의 스타일과 섞이지 않습니다.
 - 바이럴·커뮤니티 프로필은 `casual-social`을 사용합니다. 사건 소재라도 뉴스 브리핑형으로 자동 변경하지 않습니다. TTS의 `text`를 생략하면 저장된 기획 대본을 사용하며, 분명한 뉴스체 회귀는 과금 전 `422 NARRATION_STYLE_DRIFT`로 중단합니다. 자막은 실제 발화와 일치시켜야 하며 자극성을 위해 사실·인용·피해 내용을 꾸미면 안 됩니다.
@@ -77,7 +97,7 @@ plan_shorts_video → (씬마다) generate_scene_image → get_generation_job(co
 
 ## 장면 이미지 준비와 영상 표현 선택
 
-다음 설정은 0.12.0부터 지원합니다. 기존 0.11.0 클라이언트는 위의 버전 고정 설정을 바꾸고 다시 연결해야 새 입력과 도구 안내를 사용할 수 있습니다. 이미지 모션 렌더에는 해당 기능을 지원하는 최신 컴패니언 런타임도 필요합니다.
+다음 설정은 0.12.0부터 지원합니다. 구형 클라이언트는 위의 자동 업데이트 전환 안내에 따라 한 번 전환하고 유휴 상태에서 다시 연결해야 새 입력과 도구 안내를 사용할 수 있습니다. 이미지 모션 렌더에는 해당 기능을 지원하는 최신 컴패니언 런타임도 필요합니다.
 
 - `plan_shorts_video`, `plan_commerce_video`, `plan_music_video`에서 `imageSourceMode: "web" | "ai" | "mixed"`와 `visualMotionMode: "image-motion" | "i2v"`를 독립적으로 선택합니다. 생략 시 기존 `ai + i2v`입니다. 반환된 `productionPath`를 이미지·영상·TTS·스티치에 계속 전달하면 다른 작업과 선택이 섞이지 않습니다.
 - 웹은 사용자 계정의 Pexels/Pixabay 키로 장면별 `webSearchQuery`를 검색합니다. `web`은 결과가 없으면 중단하고, `mixed`만 결과가 없을 때 AI로 이어집니다. 검색 요청 자체가 실패하면 먼저 오류를 확인합니다. `ai`는 웹 검색을 실행하지 않습니다. 여기서 ‘AI만’은 주 장면 이미지 기준이며 편집용 아이콘·이모지 등은 별도입니다.
@@ -107,7 +127,7 @@ detect_shots(원본별, 컴패니언) → analyze_edit_points(videos + shotsFile
 
 ## 영화·드라마 리뷰 제작 (0.13.0)
 
-이 절은 0.13.0과 대응 서버·컴패니언 런타임에서 사용하는 경로입니다. 기존 설치된 0.12.0에 포함된 기능이 아니므로 위 설정의 버전을 바꾸고 클라이언트를 다시 연결하세요.
+이 절은 런타임 0.13.0부터 대응 서버·컴패니언과 함께 사용하는 경로입니다. 기존 설치된 0.12.0에는 포함되지 않으므로 위의 자동 업데이트 전환 안내를 적용하고 유휴 상태에서 다시 연결하세요.
 
 ```
 analyze_review_sources → resumePath → analyze_review_sources(resumePath) 반복

package/index.mjs

@@ -1,38 +1,25 @@
 #!/usr/bin/env node
-// AImakeAll MCP 서버 (stdio) — Claude Code/Codex에서 자연어로 영상 제작.
-// 클라우드 툴은 PAT(AIMAKEALL_PAT)로 aimakeall.com API를, 렌더 툴은 이 PC의
-// 컴패니언(127.0.0.1:9876)을 호출한다. 렌더는 절대 서버에서 수행되지 않는다.
+// Stable launcher: all tool/config imports live in runtime.mjs.
+import { promises as fs } from "node:fs";
+import { selectRuntime, MIN_NODE_MAJOR } from "./lib/auto-update.mjs";
+import { launchRuntime } from "./lib/runtime-launch.mjs";
 
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-
-import { createApiClient } from "./lib/api-client.mjs";
-import { registerCloudTools } from "./lib/cloud-tools.mjs";
-import { registerCompanionTools } from "./lib/companion-tools.mjs";
-import { MCP_PROXY_VERSION, resolveConfig } from "./lib/config.mjs";
-import { pruneOldMedia } from "./lib/media-store.mjs";
-
-const config = resolveConfig();
-
-// 오래된 스테이징 미디어 정리 (48h TTL) — 숨김 디렉터리가 무한정 커지는 것 방지.
 try {
-  pruneOldMedia(config.stateDir);
+  const metadata = JSON.parse(await fs.readFile(new URL("./package.json", import.meta.url), "utf8"));
+  if (process.argv.includes("--version")) {
+    console.log(`aimakeall-mcp launcher ${metadata.version}`);
+  } else if (Number(process.versions.node.split(".")[0]) < MIN_NODE_MAJOR) {
+    console.error(`[aimakeall-mcp] Node.js ${MIN_NODE_MAJOR} or newer is required; current ${process.versions.node}.`);
+    process.exitCode = 1;
+  } else if (process.argv.includes("--update-status")) {
+    const result = await selectRuntime({ checkOnly: true });
+    console.log(JSON.stringify({ launcherVersion: metadata.version, runtimeVersion: result.version, source: result.source, status: result.status, ...(result.availableVersion ? { availableVersion: result.availableVersion } : {}) }));
+  } else {
+    const selected = await selectRuntime();
+    console.error(`[aimakeall-mcp] launcher ${metadata.version}; runtime ${selected.version} (${selected.source}); ${selected.status}`);
+    process.exitCode = await launchRuntime(selected.runtime, { args: process.argv.slice(2) });
+  }
 } catch {
-  // 정리 실패는 무시
-}
-
-if (!config.pat) {
-  console.error("[aimakeall-mcp] AIMAKEALL_PAT 미설정 — 클라우드 툴은 안내만 반환합니다. aimakeall.com → API 키 설정에서 MCP 토큰을 발급해 환경변수로 넣어주세요.");
-} else if (!config.patLooksValid) {
-  console.error("[aimakeall-mcp] AIMAKEALL_PAT 형식이 올바르지 않습니다 (aio_pat_... 이어야 함).");
+  console.error("[aimakeall-mcp] launcher failed before runtime startup");
+  process.exitCode = 1;
 }
-
-const server = new McpServer({ name: "aimakeall", version: MCP_PROXY_VERSION });
-
-const api = createApiClient({ apiBase: config.apiBase, pat: config.pat });
-registerCloudTools(server, config, api);
-registerCompanionTools(server, config);
-
-const transport = new StdioServerTransport();
-await server.connect(transport);
-console.error(`[aimakeall-mcp] v${MCP_PROXY_VERSION} 시작 — API ${config.apiBase}, 컴패니언 ${config.companionUrl}`);

package/lib/api-client.mjs

@@ -36,7 +36,7 @@ function describeApiFailure(status, payload) {
   if (code === "PLAN_UPGRADE_REQUIRED") return String(payload?.message || "플랜 업그레이드가 필요한 기능입니다.");
   if (status === 413) return "요청 크기가 서버 상한을 초과했습니다. 오디오는 더 짧게/낮은 비트레이트로, 이미지는 더 작게 줄여 다시 시도하세요.";
   if (status === 431) return "요청 헤더가 너무 큽니다. 설명(description)이나 제목을 줄여 다시 시도하세요.";
-  if (status === 426) return "MCP 설정(mcpServers.args)의 aimakeall-mcp 버전을 최신으로 올린 뒤 클라이언트를 재시작하세요.";
+  if (status === 426) return "진행 중인 작업을 마친 뒤 MCP를 다시 연결해 승인된 버전을 자동 적용하세요. 구형 설치본은 AImakeAll MCP 설정의 ‘자동 업데이트 전환 안내’를 한 번 적용해야 합니다. 이 요청을 자동으로 재실행하지 마세요.";
   const message = String(payload?.message || payload?.error || "");
   return message || `AImakeAll API 요청 실패 (HTTP ${status})`;
 }

package/lib/auto-update.mjs

@@ -0,0 +1,407 @@
+// Startup only: no credentials, remote code URLs, or API overrides are accepted.
+import https from "node:https";
+import path from "node:path";
+import os from "node:os";
+import { fileURLToPath } from "node:url";
+import { createHash, randomUUID, timingSafeEqual } from "node:crypto";
+import { promises as fs, constants } from "node:fs";
+import { gunzipSync } from "node:zlib";
+import { spawn } from "node:child_process";
+
+export const RELEASE_URL = "https://aimakeall.com/api/mcp/release";
+export const LAUNCHER_PROTOCOL = 1;
+export const MIN_NODE_MAJOR = 20;
+export const STARTUP_BUDGET_MS = 25_000;
+export const MAX_ARCHIVE_BYTES = 50 * 1024 * 1024;
+const MAX_EXPANDED_BYTES = 256 * 1024 * 1024;
+const MAX_METADATA_BYTES = 16 * 1024;
+const PACKAGE_NAME = "aimakeall-mcp";
+const packageRoot = fileURLToPath(new URL("../", import.meta.url));
+const VERSION_PATTERN = /^(0|[1-9]\d{0,8})\.(0|[1-9]\d{0,8})\.(0|[1-9]\d{0,8})$/;
+const CACHE_NAME_PATTERN = /^v((?:0|[1-9]\d{0,8})\.(?:0|[1-9]\d{0,8})\.(?:0|[1-9]\d{0,8}))-([a-f0-9]{32})$/;
+
+function fail(code) { const error = new Error(code); error.code = code; throw error; }
+function remaining(deadline, cap = STARTUP_BUDGET_MS) {
+  const left = deadline - Date.now();
+  if (left <= 0) fail("startup-timeout");
+  return Math.max(1, Math.min(left, cap));
+}
+function exactKeys(value, keys) {
+  if (!value || typeof value !== "object" || Array.isArray(value)
+    || Object.keys(value).sort().join(",") !== [...keys].sort().join(",")) fail("invalid-metadata");
+}
+export function compareVersions(left, right) {
+  if (!VERSION_PATTERN.test(left) || !VERSION_PATTERN.test(right)) fail("invalid-version");
+  const a = left.split(".").map(Number), b = right.split(".").map(Number);
+  for (let index = 0; index < 3; index++) if (a[index] !== b[index]) return Math.sign(a[index] - b[index]);
+  return 0;
+}
+export function validateManifest(value, nodeMajor = Number(process.versions.node.split(".")[0])) {
+  exactKeys(value, ["schemaVersion", "channel", "packageName", "version", "launcherProtocol", "minNodeMajor", "tarballUrl", "integrity", "sizeBytes"]);
+  if (value.schemaVersion !== 1 || value.channel !== "stable" || value.packageName !== PACKAGE_NAME
+    || typeof value.version !== "string" || !VERSION_PATTERN.test(value.version)
+    || value.launcherProtocol !== LAUNCHER_PROTOCOL
+    || !Number.isInteger(value.minNodeMajor) || value.minNodeMajor < MIN_NODE_MAJOR || value.minNodeMajor > 100 || value.minNodeMajor > nodeMajor
+    || !Number.isInteger(value.sizeBytes) || value.sizeBytes < 1 || value.sizeBytes > MAX_ARCHIVE_BYTES
+    || value.tarballUrl !== `https://registry.npmjs.org/aimakeall-mcp/-/aimakeall-mcp-${value.version}.tgz`
+    || typeof value.integrity !== "string" || !/^sha512-[A-Za-z0-9+/]{86}==$/.test(value.integrity)) fail("invalid-manifest");
+  const digest = Buffer.from(value.integrity.slice(7), "base64");
+  if (digest.length !== 64 || digest.toString("base64") !== value.integrity.slice(7)) fail("invalid-integrity");
+  return Object.freeze({ ...value });
+}
+
+// Direct HTTPS: no Authorization, cookies, proxy/API overrides, redirects,
+// or ambient NODE_TLS_REJECT_UNAUTHORIZED trust.
+export function requestBytes(url, { maxBytes, timeoutMs, request = https.get } = {}) {
+  if (url !== RELEASE_URL && !/^https:\/\/registry\.npmjs\.org\/aimakeall-mcp\/-\/aimakeall-mcp-(?:0|[1-9]\d{0,8})\.(?:0|[1-9]\d{0,8})\.(?:0|[1-9]\d{0,8})\.tgz$/.test(url)) fail("untrusted-url");
+  return new Promise((resolve, reject) => {
+    let settled = false, req, response;
+    const finish = (error, data) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (error) { response?.destroy(); req?.destroy(); reject(error); }
+      else resolve(data);
+    };
+    const timer = setTimeout(() => finish(new Error("network-timeout")), timeoutMs);
+    try {
+      req = request(url, { rejectUnauthorized: true, headers: { Accept: url === RELEASE_URL ? "application/json" : "application/octet-stream" }, agent: false }, (res) => {
+        response = res;
+        if (res.statusCode !== 200) return finish(new Error(res.statusCode === 503 ? "no-approved-release" : "http-status"));
+        if (res.headers["content-encoding"] && res.headers["content-encoding"] !== "identity") return finish(new Error("unexpected-encoding"));
+        const length = res.headers["content-length"];
+        if (length !== undefined && (!/^\d+$/.test(String(length)) || Number(length) > maxBytes)) return finish(new Error("response-too-large"));
+        let size = 0;
+        const chunks = [];
+        res.on("data", (chunk) => {
+          size += chunk.length;
+          if (size > maxBytes) return finish(new Error("response-too-large"));
+          chunks.push(chunk);
+        });
+        res.on("error", (error) => finish(error));
+        res.on("aborted", () => finish(new Error("response-aborted")));
+        res.on("end", () => finish(null, Buffer.concat(chunks)));
+      });
+      req.on("error", (error) => finish(error));
+    } catch (error) { finish(error); }
+  });
+}
+export function verifyArchive(bytes, manifest) {
+  if (bytes.length !== manifest.sizeBytes) fail("size-mismatch");
+  const actual = createHash("sha512").update(bytes).digest();
+  const expected = Buffer.from(manifest.integrity.slice(7), "base64");
+  if (expected.length !== actual.length || !timingSafeEqual(actual, expected)) fail("integrity-mismatch");
+}
+function safeArchivePath(name) {
+  const parts = name.replace(/\/$/, "").split("/");
+  if (!name.startsWith("package/") || /[\\\x00-\x1f\x7f<>:"|?*]/.test(name)
+    || parts.some((part) => !part || part === ".." || part === "." || /[.\s]$/.test(part)
+      || /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(part))) fail("unsafe-archive-path");
+}
+function parsePax(bytes) {
+  let cursor = 0;
+  const fields = Object.create(null);
+  while (cursor < bytes.length) {
+    const space = bytes.indexOf(32, cursor);
+    if (space < 0) fail("invalid-tar");
+    const lengthText = bytes.subarray(cursor, space).toString();
+    if (!/^[1-9]\d*$/.test(lengthText)) fail("invalid-tar");
+    const length = Number(lengthText);
+    if (!Number.isSafeInteger(length) || length <= space - cursor + 1 || cursor + length > bytes.length) fail("invalid-tar");
+    const record = bytes.subarray(space + 1, cursor + length).toString("utf8");
+    const equals = record.indexOf("=");
+    if (equals < 1 || !record.endsWith("\n")) fail("invalid-tar");
+    const key = record.slice(0, equals);
+    if (!["path", "mtime", "atime", "ctime", "uid", "gid", "uname", "gname"].includes(key) || key in fields) fail("unsafe-archive-entry");
+    fields[key] = record.slice(equals + 1, -1);
+    cursor += length;
+  }
+  return fields;
+}
+// Reject traversal and all link entries before an approved archive is installed.
+export function validateTarball(bytes) {
+  const tar = gunzipSync(bytes, { maxOutputLength: MAX_EXPANDED_BYTES });
+  let offset = 0, count = 0, pending = {};
+  const paths = new Map();
+  function claimPath(name, directory) {
+    safeArchivePath(name);
+    if (name.endsWith("/") && !directory) fail("unsafe-archive-path");
+    const parts = name.replace(/\/$/, "").split("/");
+    for (let index = 0; index < parts.length; index++) {
+      const actual = parts.slice(0, index + 1).join("/");
+      const key = actual.normalize("NFC").toLowerCase();
+      const isDirectory = index < parts.length - 1 || directory;
+      const previous = paths.get(key);
+      if (previous && (previous.actual !== actual || !previous.directory || !isDirectory)) fail("duplicate-archive-path");
+      paths.set(key, { actual, directory: isDirectory });
+    }
+  }
+  while (offset + 512 <= tar.length) {
+    const header = tar.subarray(offset, offset + 512);
+    if (header.every((byte) => byte === 0)) {
+      if (!tar.subarray(offset).every((byte) => byte === 0) || count === 0) fail("invalid-tar");
+      return;
+    }
+    const field = (start, length) => header.subarray(start, start + length).toString("utf8").split("\0")[0];
+    const sizeText = field(124, 12).trim(), checksumText = field(148, 8).trim();
+    if (!/^[0-7]+$/.test(sizeText) || !/^[0-7]+$/.test(checksumText)) fail("invalid-tar");
+    const size = parseInt(sizeText, 8);
+    const checksum = header.reduce((sum, byte, index) => sum + (index >= 148 && index < 156 ? 32 : byte), 0);
+    if (parseInt(checksumText, 8) !== checksum || size > MAX_EXPANDED_BYTES || offset + 512 + size > tar.length) fail("invalid-tar");
+    const type = field(156, 1), prefix = field(345, 155);
+    const name = prefix ? `${prefix}/${field(0, 100)}` : field(0, 100);
+    if (type === "x") {
+      pending = parsePax(tar.subarray(offset + 512, offset + 512 + size));
+      if ("linkpath" in pending || "size" in pending) fail("unsafe-archive-entry");
+      if (pending.path) safeArchivePath(pending.path);
+    } else {
+      if (!["", "0", "5"].includes(type) || field(157, 100)) fail("unsafe-archive-entry");
+      claimPath(pending.path || name, type === "5");
+      if (type === "5" && size !== 0) fail("invalid-tar");
+      pending = {};
+      if (++count > 50_000) fail("archive-too-many-files");
+    }
+    offset += 512 + Math.ceil(size / 512) * 512;
+  }
+  fail("invalid-tar");
+}
+
+async function safeDirectory(directory, { create = false, privateDirectory = false } = {}) {
+  const absolute = path.resolve(directory);
+  const parts = absolute.slice(path.parse(absolute).root.length).split(path.sep).filter(Boolean);
+  let cursor = path.parse(absolute).root;
+  let protectedByPrivateAncestor = false;
+  for (const part of parts) {
+    cursor = path.join(cursor, part);
+    if (create) {
+      try { await fs.mkdir(cursor, { mode: 0o700 }); } catch (error) { if (error.code !== "EEXIST") throw error; }
+    }
+    const stat = await fs.lstat(cursor);
+    if (!stat.isDirectory() || stat.isSymbolicLink()) fail("unsafe-cache-directory");
+    // Another account must not be able to replace the private boundary. Once
+    // beneath a current-user-only directory, npm's ordinary 0775 directories
+    // (Linux umask 0002) are inaccessible to that account and safe. Continue
+    // rejecting symlinks at every level, regardless of the boundary.
+    if (process.platform !== "win32") {
+      if (!protectedByPrivateAncestor && (stat.mode & 0o022) !== 0
+        && !((stat.mode & 0o1000) !== 0 && stat.uid === 0)) fail("unsafe-cache-parent");
+      if (typeof process.getuid === "function" && stat.uid === process.getuid() && (stat.mode & 0o077) === 0)
+        protectedByPrivateAncestor = true;
+    }
+  }
+  const stat = await fs.lstat(absolute);
+  if (privateDirectory && process.platform !== "win32"
+    && ((stat.mode & 0o077) !== 0 || (typeof process.getuid === "function" && stat.uid !== process.getuid()))) fail("unsafe-cache-permissions");
+  return absolute;
+}
+async function readRegular(filename, limit) {
+  const stat = await fs.lstat(filename);
+  if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1 || stat.size > limit) fail("unsafe-cache-file");
+  const handle = await fs.open(filename, constants.O_RDONLY | (constants.O_NOFOLLOW || 0));
+  try {
+    const actual = await handle.stat();
+    if (!actual.isFile() || actual.nlink !== 1 || actual.size > limit) fail("unsafe-cache-file");
+    const bytes = await handle.readFile();
+    if (bytes.length > limit) fail("unsafe-cache-file");
+    return bytes;
+  } finally { await handle.close(); }
+}
+async function readJson(filename) { return JSON.parse((await readRegular(filename, MAX_METADATA_BYTES)).toString("utf8")); }
+export async function hashTree(directory, deadline = Infinity) {
+  const hash = createHash("sha512");
+  let total = 0, count = 0;
+  async function walk(current, relative) {
+    remaining(deadline);
+    const stat = await fs.lstat(current);
+    if (stat.isSymbolicLink()) fail("unsafe-cache-symlink");
+    if (stat.isDirectory()) {
+      hash.update(`d:${relative}\0`);
+      for (const name of (await fs.readdir(current)).sort()) await walk(path.join(current, name), relative ? `${relative}/${name}` : name);
+    } else if (stat.isFile() && stat.nlink === 1) {
+      total += stat.size;
+      if (++count > 50_000 || total > MAX_EXPANDED_BYTES) fail("cache-too-large");
+      hash.update(`f:${relative}:${stat.size}\0`);
+      hash.update(await readRegular(current, MAX_EXPANDED_BYTES));
+    } else fail("unsafe-cache-file");
+  }
+  await walk(directory, "");
+  return hash.digest("hex");
+}
+export function cacheName(manifest) {
+  return `v${manifest.version}-${Buffer.from(manifest.integrity.slice(7), "base64").toString("hex").slice(0, 32)}`;
+}
+function runtimeAt(directory) { return path.join(directory, "install", "node_modules", PACKAGE_NAME, "runtime.mjs"); }
+async function verifyCached(root, name, deadline = Infinity) {
+  remaining(deadline);
+  if (!CACHE_NAME_PATTERN.test(name)) fail("invalid-cache-name");
+  const directory = await safeDirectory(path.join(root, name), { privateDirectory: true });
+  const receipt = await readJson(path.join(directory, "receipt.json"));
+  exactKeys(receipt, ["schemaVersion", "manifest", "treeHash"]);
+  const manifest = validateManifest(receipt.manifest);
+  if (receipt.schemaVersion !== 1 || cacheName(manifest) !== name || !/^[a-f0-9]{128}$/.test(receipt.treeHash)) fail("invalid-cache-receipt");
+  verifyArchive(await readRegular(path.join(directory, "release.tgz"), MAX_ARCHIVE_BYTES), manifest);
+  const install = await safeDirectory(path.join(directory, "install"));
+  if (await hashTree(install, deadline) !== receipt.treeHash) fail("cache-tree-mismatch");
+  const runtime = runtimeAt(directory);
+  const metadata = await readJson(path.join(path.dirname(runtime), "package.json"));
+  if (metadata.name !== PACKAGE_NAME || metadata.version !== manifest.version) fail("cache-package-mismatch");
+  await readRegular(runtime, MAX_METADATA_BYTES * 16);
+  return { runtime, version: manifest.version, source: "cache", name };
+}
+
+// Never pass PATs, provider keys, npm tokens/config, NODE_OPTIONS, or the user's
+// output/state configuration to install/check processes.
+export function subprocessEnv(env = process.env) {
+  const clean = {};
+  for (const name of ["PATH", "Path", "SystemRoot", "SYSTEMROOT", "WINDIR", "TEMP", "TMP", "TMPDIR", "LANG", "LC_ALL"])
+    if (typeof env[name] === "string") clean[name] = env[name];
+  clean.AIMAKEALL_MCP_AUTO_UPDATE = "0";
+  return clean;
+}
+export async function findNpmCli(nodeExecutable = process.execPath) {
+  const parent = path.dirname(nodeExecutable);
+  const candidates = [path.join(parent, "node_modules/npm/bin/npm-cli.js"), path.resolve(parent, "../lib/node_modules/npm/bin/npm-cli.js")];
+  for (const candidate of candidates) {
+    try { if ((await fs.stat(candidate)).isFile()) return await fs.realpath(candidate); } catch { /* next layout */ }
+  }
+  fail("npm-cli-unavailable");
+}
+export function npmInstallArgs(npmCli, archive, install, work) {
+  return [npmCli, "install", "--prefix", install, "--offline", "--ignore-scripts", "--no-audit", "--no-fund", "--no-package-lock", "--no-bin-links", "--omit=dev", "--workspaces=false", "--update-notifier=false", "--cache", path.join(work, "npm-cache"), "--userconfig", path.join(work, "empty-npmrc"), "--globalconfig", path.join(work, "empty-global-npmrc"), archive];
+}
+export function runSubprocess(executable, args, { cwd, env, timeoutMs, capture = false, spawnImpl = spawn }) {
+  return new Promise((resolve, reject) => {
+    let child, done = false, output = "";
+    const finish = (error) => { if (done) return; done = true; clearTimeout(timer); error ? reject(error) : resolve(output); };
+    const timer = setTimeout(() => { child?.kill("SIGKILL"); finish(new Error("subprocess-timeout")); }, timeoutMs);
+    try {
+      child = spawnImpl(executable, args, { cwd, env, shell: false, stdio: ["ignore", capture ? "pipe" : "ignore", "ignore"], windowsHide: true });
+      if (capture) child.stdout.on("data", (chunk) => {
+        output += chunk.toString("utf8");
+        if (Buffer.byteLength(output) > 4096) { child.kill("SIGKILL"); finish(new Error("self-check-output-limit")); }
+      });
+      child.once("error", () => finish(new Error("subprocess-error")));
+      child.once("close", (code, signal) => finish(code === 0 && !signal ? null : new Error("subprocess-failed")));
+    } catch { finish(new Error("subprocess-error")); }
+  });
+}
+async function installArchive(stage, manifest, { env, npmCli, run = runSubprocess, deadline = Infinity } = {}) {
+  remaining(deadline);
+  const install = path.join(stage, "install"), work = path.join(stage, "work");
+  await fs.mkdir(install, { mode: 0o700 });
+  await fs.mkdir(work, { mode: 0o700 });
+  await fs.writeFile(path.join(install, "package.json"), JSON.stringify({ private: true, name: "aimakeall-runtime-install", version: "1.0.0" }), { mode: 0o600, flag: "wx" });
+  await fs.writeFile(path.join(work, "empty-npmrc"), "", { mode: 0o600, flag: "wx" });
+  await fs.writeFile(path.join(work, "empty-global-npmrc"), "", { mode: 0o600, flag: "wx" });
+  const clean = subprocessEnv(env);
+  // Explicit empty npm config files and a private cache isolate npm without
+  // changing HOME/USERPROFILE or consulting any user npm configuration.
+  await run(process.execPath, npmInstallArgs(npmCli || await findNpmCli(), path.join(stage, "release.tgz"), install, work), { cwd: work, env: clean, timeoutMs: remaining(deadline, 12_000) });
+  const runtime = runtimeAt(stage);
+  await safeDirectory(path.dirname(runtime));
+  const metadata = await readJson(path.join(path.dirname(runtime), "package.json"));
+  if (metadata.name !== PACKAGE_NAME || metadata.version !== manifest.version) fail("installed-package-mismatch");
+  const treeHash = await hashTree(install, deadline); // Reject links before execution.
+  const check = JSON.parse(await run(process.execPath, [runtime, "--self-check"], { cwd: work, env: clean, timeoutMs: remaining(deadline, 5000), capture: true }));
+  exactKeys(check, ["ok", "version"]);
+  if (check.ok !== true || check.version !== manifest.version) fail("self-check-failed");
+  if (await hashTree(install, deadline) !== treeHash) fail("self-check-modified-runtime");
+  return treeHash;
+}
+async function promote(root, manifest, bytes, previous, options) {
+  remaining(options.deadline);
+  const stage = await fs.mkdtemp(path.join(root, ".staging-"));
+  const name = cacheName(manifest), target = path.join(root, name);
+  try {
+    await fs.writeFile(path.join(stage, "release.tgz"), bytes, { mode: 0o600, flag: "wx" });
+    const treeHash = await installArchive(stage, manifest, options);
+    remaining(options.deadline);
+    await fs.writeFile(path.join(stage, "receipt.json"), JSON.stringify({ schemaVersion: 1, manifest, treeHash }), { mode: 0o600, flag: "wx" });
+    try { await fs.rename(stage, target); }
+    catch (error) {
+      // Concurrent installs never overwrite immutable versions.
+      if (!["EEXIST", "ENOTEMPTY", "EPERM"].includes(error.code)) throw error;
+      await verifyCached(root, name, options.deadline);
+    }
+    const selected = await verifyCached(root, name, options.deadline);
+    remaining(options.deadline);
+    await writePointer(root, name, previous?.name || null);
+    return selected;
+  } finally {
+    // Only our unpublished staging path; never a cached/running version.
+    // Antivirus/file locks may delay deletion on Windows. Cleanup is best
+    // effort and cannot postpone the already-decided runtime handoff.
+    void Promise.resolve().then(() => options.cleanupStaging
+      ? options.cleanupStaging(stage)
+      : fs.rm(stage, { recursive: true, force: true })).catch(() => {});
+  }
+}
+async function writePointer(root, current, previous) {
+  const pointerTemp = path.join(root, `.pointer-${randomUUID()}.json`);
+  await fs.writeFile(pointerTemp, JSON.stringify({ schemaVersion: 1, current, previous }), { mode: 0o600, flag: "wx" });
+  try { await fs.rename(pointerTemp, path.join(root, "current.json")); }
+  finally { void fs.rm(pointerTemp, { force: true }).catch(() => {}); }
+}
+async function cachedRuntimes(root, bundledVersion, deadline) {
+  try {
+    await safeDirectory(root, { privateDirectory: true });
+    try {
+      const pointer = await readJson(path.join(root, "current.json"));
+      exactKeys(pointer, ["schemaVersion", "current", "previous"]);
+      if (pointer.schemaVersion !== 1 || [pointer.current, pointer.previous].some((name) => name !== null && (typeof name !== "string" || !CACHE_NAME_PATTERN.test(name)))) fail("invalid-cache-pointer");
+      // A null current records an explicit official rollback to the bundle.
+      if (pointer.current === null) return null;
+      for (const name of [pointer.current, pointer.previous].filter(Boolean)) {
+        if (compareVersions(CACHE_NAME_PATTERN.exec(name)[1], bundledVersion) < 0) continue;
+        try { return await verifyCached(root, name, deadline); } catch { /* previous */ }
+      }
+    } catch { /* Reject invalid paths/metadata; discover verified versions. */ }
+    const names = (await fs.readdir(root)).filter((name) => CACHE_NAME_PATTERN.test(name));
+    // Recover a checked immutable version after a crashed pointer write.
+    names.sort((a, b) => compareVersions(CACHE_NAME_PATTERN.exec(b)[1], CACHE_NAME_PATTERN.exec(a)[1]));
+    for (const name of names.slice(0, 50)) {
+      remaining(deadline);
+      if (compareVersions(CACHE_NAME_PATTERN.exec(name)[1], bundledVersion) < 0) continue;
+      try { return await verifyCached(root, name, deadline); } catch { /* skip corrupt version */ }
+    }
+  } catch { /* Missing/unsafe cache: bundled fallback. */ }
+  return null;
+}
+
+export async function selectRuntime({ root = path.join(os.homedir(), ".aimakeall", "mcp-runtime"), bundledRoot = packageRoot, env = process.env, download = requestBytes, installOptions = {}, checkOnly = false, startupTimeoutMs = STARTUP_BUDGET_MS } = {}) {
+  const deadline = Date.now() + Math.min(STARTUP_BUDGET_MS, Math.max(1, startupTimeoutMs));
+  const metadata = await readJson(path.join(bundledRoot, "package.json"));
+  if (metadata.name !== PACKAGE_NAME || !VERSION_PATTERN.test(metadata.version)) fail("invalid-bundled-package");
+  const bundled = { runtime: path.join(bundledRoot, "runtime.mjs"), version: metadata.version, source: "bundled", name: null };
+  const cached = await cachedRuntimes(root, metadata.version, deadline);
+  const fallback = cached || bundled;
+  if (env.AIMAKEALL_MCP_AUTO_UPDATE === "0") return { ...fallback, status: "disabled" };
+  try {
+    const manifest = validateManifest(JSON.parse((await download(RELEASE_URL, { maxBytes: MAX_METADATA_BYTES, timeoutMs: remaining(deadline, 2500) })).toString("utf8")));
+    remaining(deadline);
+    if (manifest.version === fallback.version && (fallback.source === "bundled" || fallback.name === cacheName(manifest))) return { ...fallback, status: "up-to-date", availableVersion: manifest.version };
+    if (compareVersions(manifest.version, bundled.version) < 0) return { ...fallback, status: "unsupported-release", availableVersion: manifest.version };
+    if (checkOnly) return { ...fallback, status: "update-available", availableVersion: manifest.version };
+    await safeDirectory(root, { create: true, privateDirectory: true });
+    if (manifest.version === bundled.version) {
+      await writePointer(root, null, cached?.name || null);
+      return { ...bundled, status: "rolled-back", availableVersion: manifest.version };
+    }
+    try {
+      const existing = await verifyCached(root, cacheName(manifest), deadline);
+      remaining(deadline);
+      await writePointer(root, existing.name, cached?.name || null);
+      return { ...existing, status: "updated", availableVersion: manifest.version };
+    } catch { /* Approved release is not yet installed/valid. */ }
+    const bytes = await download(manifest.tarballUrl, { maxBytes: manifest.sizeBytes, timeoutMs: remaining(deadline, 8000) });
+    remaining(deadline);
+    verifyArchive(bytes, manifest);
+    validateTarball(bytes);
+    remaining(deadline);
+    const selected = await promote(root, manifest, bytes, cached, { env, ...installOptions, deadline });
+    return { ...selected, status: "updated", availableVersion: manifest.version };
+  } catch (error) {
+    // Never print raw exception bodies, paths, request URLs, or environment.
+    return { ...fallback, status: error.message === "no-approved-release" ? "no-approved-release" : "update-unavailable" };
+  }
+}

package/lib/config.mjs

@@ -2,7 +2,7 @@ import { homedir } from "node:os";
 import path from "node:path";
 
 // 프록시 버전 — 서버가 X-AImakeAll-MCP-Version 으로 하한을 강제(426)할 수 있다.
-export const MCP_PROXY_VERSION = "0.13.0";
+export const MCP_PROXY_VERSION = "0.14.0";
 
 export const DEFAULT_API_BASE = "https://aimakeall.com";
 export const DEFAULT_COMPANION_URL = "http://127.0.0.1:9876";

package/lib/runtime-launch.mjs

@@ -0,0 +1,26 @@
+import { spawn } from "node:child_process";
+import os from "node:os";
+
+// There is no update, retry, restart, or request replay path after handoff.
+export function launchRuntime(runtime, { args = [], env = process.env, spawnImpl = spawn, signalSource = process } = {}) {
+  return new Promise((resolve) => {
+    let child, settled = false;
+    const handlers = new Map();
+    const finish = (code) => {
+      if (settled) return;
+      settled = true;
+      for (const [signal, handler] of handlers) signalSource.removeListener(signal, handler);
+      resolve(code);
+    };
+    try {
+      child = spawnImpl(process.execPath, [runtime, ...args], { env, shell: false, stdio: "inherit", windowsHide: true });
+      child.once("error", () => finish(1));
+      child.once("exit", (code, signal) => finish(code ?? (128 + (os.constants.signals[signal] || 1))));
+      for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+        const handler = () => { if (!settled) child.kill(signal); };
+        handlers.set(signal, handler);
+        signalSource.on(signal, handler);
+      }
+    } catch { finish(1); }
+  });
+}

package/node_modules/@hono/node-server/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 - present, Yusuke Wada and Hono contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.