aimakeall-mcp 0.9.0 → 0.10.0

package/lib/companion-client.test.mjs

@@ -0,0 +1,71 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+import { downloadRenderOutput } from "./companion-client.mjs";
+
+function fixture(t) {
+  const dir = mkdtempSync(path.join(tmpdir(), "aio-download-test-"));
+  const originalFetch = globalThis.fetch;
+  t.after(() => {
+    globalThis.fetch = originalFetch;
+    rmSync(dir, { recursive: true, force: true });
+  });
+  return dir;
+}
+
+test("동시 같은 이름 다운로드는 독립 파일로 저장하고 기존 출력도 보존", async (t) => {
+  const dir = fixture(t);
+  writeFileSync(path.join(dir, "same.mp4"), "EXISTING");
+  globalThis.fetch = async (url) => {
+    const text = String(url).includes("job-a/") ? "AAAACCCC" : "BBBBDDDD";
+    return new Response(new ReadableStream({
+      start(controller) {
+        controller.enqueue(Buffer.from(text.slice(0, 4)));
+        setTimeout(() => {
+          controller.enqueue(Buffer.from(text.slice(4)));
+          controller.close();
+        }, 20);
+      },
+    }), { headers: { "content-disposition": 'attachment; filename="same.mp4"' } });
+  };
+  const results = await Promise.all([
+    downloadRenderOutput("http://mock.invalid", "job-a", dir),
+    downloadRenderOutput("http://mock.invalid", "job-b", dir),
+  ]);
+  assert.ok(results.every((result) => !result.error), JSON.stringify(results));
+  assert.equal(new Set(results.map((result) => result.filePath)).size, 2);
+  assert.deepEqual(results.map((result) => readFileSync(result.filePath, "utf8")), ["AAAACCCC", "BBBBDDDD"]);
+  assert.deepEqual(results.map((result) => result.bytes), [8, 8]);
+  assert.equal(readFileSync(path.join(dir, "same.mp4"), "utf8"), "EXISTING");
+  assert.deepEqual(readdirSync(dir).sort(), ["same-2.mp4", "same-3.mp4", "same.mp4"]);
+});
+
+test("중단된 다운로드는 자기 임시 파일·예약만 정리한다", async (t) => {
+  const dir = fixture(t);
+  writeFileSync(path.join(dir, "same.mp4"), "EXISTING");
+  globalThis.fetch = async () => new Response(new ReadableStream({
+    start(controller) {
+      controller.enqueue(Buffer.from("partial"));
+      setTimeout(() => controller.error(new Error("fixture connection lost")), 10);
+    },
+  }));
+  const result = await downloadRenderOutput("http://mock.invalid", "job", dir, { suggestedName: "same.mp4" });
+  assert.match(result.error, /fixture connection lost/u);
+  assert.deepEqual(readdirSync(dir), ["same.mp4"]);
+  assert.equal(readFileSync(path.join(dir, "same.mp4"), "utf8"), "EXISTING");
+});
+
+test("출력 폴더 오류는 일회성 다운로드 요청 전에 반환", async (t) => {
+  const dir = fixture(t);
+  const notDirectory = path.join(dir, "file");
+  writeFileSync(notDirectory, "keep");
+  let called = false;
+  globalThis.fetch = async () => { called = true; throw new Error("must not fetch"); };
+  const result = await downloadRenderOutput("http://mock.invalid", "job", notDirectory);
+  assert.ok(result.error);
+  assert.equal(called, false);
+  assert.equal(readFileSync(notDirectory, "utf8"), "keep");
+});

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.9.0";
+export const MCP_PROXY_VERSION = "0.10.0";
 
 export const DEFAULT_API_BASE = "https://aimakeall.com";
 export const DEFAULT_COMPANION_URL = "http://127.0.0.1:9876";

package/lib/generation-jobs.mjs

@@ -0,0 +1,39 @@
+import { randomUUID } from "node:crypto";
+
+export const GENERATION_JOB_PATH = "/api/tracker/mcp/generation-jobs";
+const JOB_ID = /^[a-zA-Z0-9_-]{16,80}$/;
+
+export function assertGenerationJobId(id) {
+  if (!JOB_ID.test(String(id || ""))) throw new Error("유효한 generationJobId가 필요합니다.");
+  return id;
+}
+
+// Submission never waits for a provider. The server owns the long-running work;
+// both its result and accepted task IDs remain queryable after MCP restarts.
+export async function submitGenerationJob(api, { kind, input, requestId = randomUUID(), includePreview = true }) {
+  assertGenerationJobId(requestId);
+  try {
+    const response = await api.request(GENERATION_JOB_PATH, {
+      method: "POST", body: { id: requestId, kind, input, includePreview }, timeoutMs: 30_000,
+    });
+    if (response?.job?.id !== requestId) throw new Error("생성 작업 접수 응답을 확인할 수 없습니다.");
+    return { generationJobId: requestId, status: response.job.status, kind, includePreview,
+      existing: response.existing === true, nextTool: "get_generation_job",
+      guidance: "생성 작업을 접수했습니다. get_generation_job으로 조회해 completed 결과를 확인한 뒤 다음 단계로 진행하세요. 같은 장면을 다시 생성하지 마세요." };
+  } catch (error) {
+    if (Number(error?.status) >= 400 && Number(error?.status) < 500) throw error;
+    // A lost acceptance response does not establish failure: don't submit a new
+    // paid job. The caller retains the ID, and list_generation_jobs also recovers it.
+    return { generationJobId: requestId, status: "unknown", kind, includePreview,
+      nextTool: "get_generation_job",
+      guidance: "접수 응답이 끊겼습니다. 이 작업 ID 또는 list_generation_jobs로 먼저 확인하세요. 새 작업을 재생성하지 마세요.",
+      error: String(error?.message || error) };
+  }
+}
+
+export async function fetchGenerationJob(api, generationJobId) {
+  const id = assertGenerationJobId(generationJobId);
+  const response = await api.request(`${GENERATION_JOB_PATH}/${encodeURIComponent(id)}`, { timeoutMs: 30_000 });
+  if (!response?.job || response.job.id !== id) throw new Error("생성 작업 상태 응답이 올바르지 않습니다.");
+  return response.job;
+}

package/lib/generation-jobs.test.mjs

@@ -0,0 +1,34 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { fetchGenerationJob, submitGenerationJob } from "./generation-jobs.mjs";
+
+const id = "generation-client-test-0001";
+test("submission returns a recoverable handle without waiting for a completed image or video", async () => {
+  const calls = [];
+  const api = { async request(route, options) { calls.push({ route, options }); return { job: { id, status: "running" } }; } };
+  const result = await submitGenerationJob(api, { requestId: id, kind: "image", input: { prompt: "rain" } });
+  assert.equal(result.generationJobId, id);
+  assert.equal(result.nextTool, "get_generation_job");
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].options.body.id, id);
+  assert.equal(calls[0].route, "/api/tracker/mcp/generation-jobs");
+});
+test("a lost acceptance response preserves the ID and never resubmits paid work automatically", async () => {
+  let attempts = 0;
+  const api = { async request() { attempts++; throw new TypeError("fetch failed"); } };
+  const result = await submitGenerationJob(api, { requestId: id, kind: "video", input: {} });
+  assert.equal(result.status, "unknown");
+  assert.equal(result.generationJobId, id);
+  assert.equal(attempts, 1);
+});
+test("authorization and capacity rejections remain actionable errors", async () => {
+  for (const status of [401, 403, 409, 429]) {
+    const error = Object.assign(new Error("rejected"), { status });
+    await assert.rejects(submitGenerationJob({ request: async () => { throw error; } }, { requestId: id, kind: "image", input: {} }), error);
+  }
+});
+test("polls retrieve completed results, check response identity and reject path injection", async () => {
+  assert.equal((await fetchGenerationJob({ request: async () => ({ job: { id, status: "completed", result: { videoUrl: "test" } } }) }, id)).result.videoUrl, "test");
+  await assert.rejects(fetchGenerationJob({ request: async () => ({ job: { id: "another" } }) }, id));
+  await assert.rejects(fetchGenerationJob({ request: async () => { throw new Error("must not call"); } }, "../background-jobs"), /generationJobId/);
+});

package/lib/media-store.mjs

@@ -42,7 +42,7 @@ export function encodedDataUrlBytes(sourceBytes, mimeType = "application/octet-s
 }
 
 // 입력 경로 검증 — 확장자 화이트리스트 + 존재 + 상한. 위반 시 한국어 예외.
-export function assertAllowedInputFile(filePath, allowedExts, { kind = "파일" } = {}) {
+export function assertAllowedInputFile(filePath, allowedExts, { kind = "파일", maxBytes = MAX_DATA_URL_SOURCE_BYTES } = {}) {
   const resolved = String(filePath || "").trim();
   if (!resolved) throw new Error(`${kind} 경로가 비어 있습니다.`);
   const ext = path.extname(resolved).toLowerCase();
@@ -52,14 +52,19 @@ export function assertAllowedInputFile(filePath, allowedExts, { kind = "파일"
   if (!existsSync(resolved)) throw new Error(`${kind}을(를) 찾을 수 없습니다: ${resolved}`);
   const stats = statSync(resolved);
   if (!stats.isFile()) throw new Error(`${kind}이(가) 일반 파일이 아닙니다: ${resolved}`);
-  if (stats.size > MAX_DATA_URL_SOURCE_BYTES) {
+  if (stats.size > maxBytes) {
     throw new Error(
-      `${kind}이(가) 너무 큽니다 (${Math.round(stats.size / 1024 / 1024)}MB > ${Math.round(MAX_DATA_URL_SOURCE_BYTES / 1024 / 1024)}MB): ${resolved}`,
+      `${kind}이(가) 너무 큽니다 (${Math.round(stats.size / 1024 / 1024)}MB > ${Math.round(maxBytes / 1024 / 1024)}MB): ${resolved}`,
     );
   }
   return { ext, size: stats.size };
 }
 
+// raw body 업로드는 base64/JSON 상한과 무관하다. 확장자·일반 파일 검증은 유지한다.
+export function assertAllowedVideoUpload(filePath) {
+  return assertAllowedInputFile(filePath, ALLOWED_VIDEO_EXTS, { kind: "영상 파일", maxBytes: Infinity });
+}
+
 export function saveMediaBuffer(stateDir, name, buffer, { contentType = "" } = {}) {
   const dir = mediaDir(stateDir);
   mkdirSync(dir, { recursive: true });

package/lib/media-store.test.mjs

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, writeFileSync, utimesSync } from "node:fs";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync, utimesSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import test, { after } from "node:test";
@@ -7,6 +7,7 @@ import test, { after } from "node:test";
 import {
   ALLOWED_IMAGE_EXTS,
   assertAllowedInputFile,
+  assertAllowedVideoUpload,
   encodedDataUrlBytes,
   fileToDataUrl,
   fileToImagePayload,
@@ -55,6 +56,25 @@ test("크기 상한 초과 파일은 거부", () => {
   assert.throws(() => fileToDataUrl(big), /너무 큽니다/u);
 });
 
+test("스트리밍 MP4는 17MiB를 넘어도 허용하되 파일 종류 검증은 유지", () => {
+  const big = saveMediaBuffer(scratch, "large.mp4", Buffer.alloc(MAX_DATA_URL_SOURCE_BYTES + 1)).filePath;
+  assert.equal(assertAllowedVideoUpload(big).size, MAX_DATA_URL_SOURCE_BYTES + 1);
+  assert.throws(() => assertAllowedVideoUpload(join(scratch, "id_rsa")), /허용되지 않은/u);
+  assert.throws(() => assertAllowedVideoUpload(join(scratch, "missing.mp4")), /찾을 수 없습니다/u);
+  assert.throws(() => fileToDataUrl(big), /허용되지 않은/u);
+  // The binary upload exception must never lift the data-URL audio/image limit.
+  const audio = saveMediaBuffer(scratch, "large.wav", Buffer.alloc(MAX_DATA_URL_SOURCE_BYTES + 1)).filePath;
+  assert.throws(() => fileToDataUrl(audio), /너무 큽니다/u);
+});
+
+test("publish_youtube는 스트리밍 전용 검사기를 사용한다", () => {
+  const source = readFileSync(new URL("./cloud-tools.mjs", import.meta.url), "utf8");
+  const publish = source.slice(source.indexOf('"publish_youtube"'), source.indexOf('"write_script"'));
+  assert.match(publish, /const stats = assertAllowedVideoUpload\(videoPath\)/u);
+  assert.doesNotMatch(publish, /assertAllowedInputFile\(/u);
+  assert.match(publish, /requestStreamUpload\(/u);
+});
+
 test("이미지 페이로드 변환 — {name, mimeType, base64}", () => {
   const imgPath = join(scratch, "product.png");
   writeFileSync(imgPath, Buffer.from([0x89, 0x50, 0x4e, 0x47]));

package/lib/render-job-store.mjs

@@ -1,10 +1,11 @@
-import { randomUUID } from "node:crypto";
-import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { createHash, randomUUID } from "node:crypto";
+import { mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import path from "node:path";
 
 // 렌더 잡 영속화 — npx 프록시가 재시작돼도 jobId 를 잃지 않도록
-// ~/.aimakeall/render-jobs.json 에 기록한다. 컴패니언 잡 TTL(만료) 은 서버가 판정하므로
-// 여기서는 오래된 항목만 정리한다.
+// 잡별 디렉터리로 분리해 여러 프록시가 공유 배열을 read-modify-write 하며
+// 다른 잡을 잃어버리지 않게 한다. 구버전 render-jobs.json 은 계속 읽되 덮어쓰지 않는다.
+// 같은 잡의 서로 다른 필드도 별도 원자 파일로 저장해 동시 패치를 보존한다.
 
 const MAX_ENTRIES = 50;
 const ENTRY_TTL_MS = 24 * 60 * 60 * 1000;
@@ -13,55 +14,130 @@ export function renderJobStorePath(stateDir) {
   return path.join(stateDir, "render-jobs.json");
 }
 
-function readEntries(filePath) {
+export function renderJobRecordsDir(stateDir) {
+  return path.join(stateDir, "render-jobs");
+}
+
+function digest(value) {
+  return createHash("sha256").update(String(value)).digest("hex");
+}
+
+function jobDirectory(stateDir, jobId) {
+  return path.join(renderJobRecordsDir(stateDir), digest(jobId));
+}
+
+function readJson(filePath) {
   try {
-    const parsed = JSON.parse(readFileSync(filePath, "utf8"));
-    return Array.isArray(parsed?.jobs) ? parsed.jobs : [];
+    return JSON.parse(readFileSync(filePath, "utf8"));
   } catch {
-    return [];
+    return null;
   }
 }
 
-function writeEntries(filePath, jobs) {
+function readDirectory(dir) {
+  try { return readdirSync(dir); } catch { return []; }
+}
+
+function writeJsonAtomic(filePath, value) {
   mkdirSync(path.dirname(filePath), { recursive: true });
-  // 여러 프록시 프로세스(세션마다 별도)가 같은 파일을 쓰므로 tmp 경로를 프로세스·uuid 로
-  // 유일하게 만들어 rename 레이스(ENOENT)를 막는다.
-  const tmpPath = `${filePath}.${process.pid}.${randomUUID().slice(0, 8)}.tmp`;
-  writeFileSync(tmpPath, `${JSON.stringify({ jobs }, null, 2)}\n`, { mode: 0o600 });
-  renameSync(tmpPath, filePath);
+  const tmpPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    writeFileSync(tmpPath, `${JSON.stringify(value)}\n`, { flag: "wx", mode: 0o600 });
+    renameSync(tmpPath, filePath);
+  } finally {
+    rmSync(tmpPath, { force: true });
+  }
 }
 
-function pruneEntries(jobs, now) {
-  return jobs
-    .filter((job) => job && job.jobId && now - (Number(job.createdAtMs) || 0) < ENTRY_TTL_MS)
-    .slice(-MAX_ENTRIES);
+const IDENTITY_FIELDS = new Set(["jobId", "createdAt", "createdAtMs"]);
+
+function readStoredJob(dir, fallback = null) {
+  const record = readJson(path.join(dir, "record.json"));
+  let job = record?.job?.jobId ? record.job : fallback;
+  if (!job?.jobId) return null;
+  for (const name of readDirectory(dir)) {
+    if (!/^[a-f0-9]{64}\.field\.json$/u.test(name)) continue;
+    const patch = readJson(path.join(dir, name));
+    if (typeof patch?.field !== "string" || IDENTITY_FIELDS.has(patch.field)) continue;
+    job = { ...job, [patch.field]: patch.value };
+  }
+  return { job, order: String(record?.order || "") };
+}
+
+function readAllJobs(stateDir) {
+  const legacy = readJson(renderJobStorePath(stateDir));
+  const entries = new Map();
+  for (const job of Array.isArray(legacy?.jobs) ? legacy.jobs : []) {
+    if (job?.jobId) entries.set(String(job.jobId), { job, order: "" });
+  }
+  for (const name of readDirectory(renderJobRecordsDir(stateDir))) {
+    if (!/^[a-f0-9]{64}$/u.test(name)) continue;
+    const dir = path.join(renderJobRecordsDir(stateDir), name);
+    const record = readJson(path.join(dir, "record.json"));
+    if (!record?.job?.jobId || digest(record.job.jobId) !== name) continue;
+    const entry = readStoredJob(dir);
+    if (entry) entries.set(String(entry.job.jobId), entry);
+  }
+  return [...entries.values()];
+}
+
+function isRecent(job, now) {
+  return Boolean(job?.jobId) && now - (Number(job.createdAtMs) || 0) < ENTRY_TTL_MS;
+}
+
+function pruneExpiredRecords(stateDir, now) {
+  for (const name of readDirectory(renderJobRecordsDir(stateDir))) {
+    if (!/^[a-f0-9]{64}$/u.test(name)) continue;
+    const dir = path.join(renderJobRecordsDir(stateDir), name);
+    const record = readJson(path.join(dir, "record.json"));
+    if (record?.job?.jobId && !isRecent(record.job, now)) {
+      rmSync(dir, { force: true, recursive: true });
+    }
+  }
 }
 
 export function recordRenderJob(stateDir, { jobId, projectTitle = "", statusUrl = "", outputUrl = "" }, now = Date.now()) {
-  const filePath = renderJobStorePath(stateDir);
-  const jobs = pruneEntries(readEntries(filePath), now);
-  jobs.push({
+  const job = {
     createdAt: new Date(now).toISOString(),
     createdAtMs: now,
     jobId: String(jobId || ""),
     outputUrl: String(outputUrl || ""),
     projectTitle: String(projectTitle || ""),
     statusUrl: String(statusUrl || ""),
+  };
+  if (!job.jobId) throw new Error("jobId가 필요합니다.");
+  pruneExpiredRecords(stateDir, now);
+  writeJsonAtomic(path.join(jobDirectory(stateDir, job.jobId), "record.json"), {
+    job,
+    order: process.hrtime.bigint().toString().padStart(24, "0"),
   });
-  writeEntries(filePath, jobs);
-  return jobs[jobs.length - 1];
+  return job;
 }
 
 export function listRenderJobs(stateDir, now = Date.now()) {
-  return pruneEntries(readEntries(renderJobStorePath(stateDir)), now).reverse();
+  return readAllJobs(stateDir)
+    .filter(({ job }) => isRecent(job, now))
+    .sort((left, right) => Number(left.job.createdAtMs) - Number(right.job.createdAtMs)
+      || left.order.localeCompare(right.order))
+    .slice(-MAX_ENTRIES)
+    .reverse()
+    .map(({ job }) => job);
 }
 
 export function updateRenderJob(stateDir, jobId, patch = {}, now = Date.now()) {
-  const filePath = renderJobStorePath(stateDir);
-  const jobs = pruneEntries(readEntries(filePath), now);
-  const index = jobs.findIndex((job) => job.jobId === String(jobId || ""));
-  if (index < 0) return null;
-  jobs[index] = { ...jobs[index], ...patch };
-  writeEntries(filePath, jobs);
-  return jobs[index];
+  const id = String(jobId || "");
+  const legacy = readJson(renderJobStorePath(stateDir));
+  const fallback = (Array.isArray(legacy?.jobs) ? legacy.jobs : []).find((job) => job?.jobId === id);
+  const dir = jobDirectory(stateDir, id);
+  const entry = readStoredJob(dir, fallback);
+  if (!entry || !isRecent(entry.job, now)) return null;
+  // Migrate only this legacy job; leave the original shared file untouched.
+  if (!readJson(path.join(dir, "record.json"))?.job?.jobId) {
+    writeJsonAtomic(path.join(dir, "record.json"), { job: entry.job, order: entry.order });
+  }
+  for (const [field, value] of Object.entries(patch)) {
+    if (IDENTITY_FIELDS.has(field)) continue;
+    writeJsonAtomic(path.join(dir, `${digest(field)}.field.json`), { field, value });
+  }
+  return readStoredJob(dir)?.job || null;
 }

package/lib/render-job-store.test.mjs

@@ -1,20 +1,26 @@
 import assert from "node:assert/strict";
-import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { spawn } from "node:child_process";
+import { mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import test, { after } from "node:test";
+import test from "node:test";
 
 import {
   listRenderJobs,
   recordRenderJob,
+  renderJobRecordsDir,
   renderJobStorePath,
   updateRenderJob,
 } from "./render-job-store.mjs";
 
-const stateDir = mkdtempSync(join(tmpdir(), "aio-mcp-jobstore-"));
-after(() => rmSync(stateDir, { force: true, recursive: true }));
+function fixture(t) {
+  const stateDir = mkdtempSync(join(tmpdir(), "aio-mcp-jobstore-"));
+  t.after(() => rmSync(stateDir, { force: true, recursive: true }));
+  return stateDir;
+}
 
-test("기록 → 목록(최신순) → 갱신 roundtrip", () => {
+test("기록 → 목록(최신순) → 갱신 roundtrip", (t) => {
+  const stateDir = fixture(t);
   recordRenderJob(stateDir, { jobId: "job-1", projectTitle: "첫번째" });
   recordRenderJob(stateDir, { jobId: "job-2", projectTitle: "두번째", statusUrl: "/api/moviepy/render-jobs/job-2" });
 
@@ -29,18 +35,115 @@ test("기록 → 목록(최신순) → 갱신 roundtrip", () => {
   assert.equal(updateRenderJob(stateDir, "missing", { status: "x" }), null);
 });
 
-test("24시간 지난 항목은 정리된다", () => {
+test("24시간 지난 항목은 정리된다", (t) => {
+  const stateDir = fixture(t);
   const now = Date.now();
   recordRenderJob(stateDir, { jobId: "old-job" }, now - 25 * 60 * 60 * 1000);
   const jobs = listRenderJobs(stateDir, now);
   assert.equal(jobs.some((job) => job.jobId === "old-job"), false);
+  recordRenderJob(stateDir, { jobId: "new-job" }, now);
+  assert.equal(readdirSync(renderJobRecordsDir(stateDir)).length, 1);
 });
 
-test("손상된 저장 파일은 빈 목록으로 복구된다", () => {
-  const filePath = renderJobStorePath(stateDir);
-  assert.ok(readFileSync(filePath, "utf8").includes("job-2"));
-  rmSync(filePath);
+test("손상된 legacy 파일이나 잡 레코드는 다른 잡을 지우지 않는다", (t) => {
+  const stateDir = fixture(t);
+  writeFileSync(renderJobStorePath(stateDir), "invalid json");
   assert.deepEqual(listRenderJobs(stateDir), []);
-  recordRenderJob(stateDir, { jobId: "after-reset" });
-  assert.equal(listRenderJobs(stateDir)[0].jobId, "after-reset");
+  recordRenderJob(stateDir, { jobId: "broken" });
+  const firstDir = readdirSync(renderJobRecordsDir(stateDir))[0];
+  writeFileSync(join(renderJobRecordsDir(stateDir), firstDir, "record.json"), "invalid json");
+  recordRenderJob(stateDir, { jobId: "healthy" });
+  assert.deepEqual(listRenderJobs(stateDir).map((job) => job.jobId), ["healthy"]);
+});
+
+test("legacy 목록을 보존하면서 새 저장소에 갱신하고 중복 없이 병합", (t) => {
+  const stateDir = fixture(t);
+  const now = Date.now();
+  const legacy = JSON.stringify({ jobs: [
+    { jobId: "legacy-1", createdAtMs: now - 2, projectTitle: "old title" },
+    { jobId: "legacy-2", createdAtMs: now - 1 },
+  ] });
+  writeFileSync(renderJobStorePath(stateDir), legacy);
+  recordRenderJob(stateDir, { jobId: "new" }, now);
+  updateRenderJob(stateDir, "legacy-1", { status: "downloaded", filePath: "/tmp/kept.mp4" }, now);
+  const jobs = listRenderJobs(stateDir, now);
+  assert.equal(jobs.length, 3);
+  assert.equal(jobs.find((job) => job.jobId === "legacy-1").filePath, "/tmp/kept.mp4");
+  assert.equal(jobs.find((job) => job.jobId === "legacy-1").projectTitle, "old title");
+  assert.equal(readFileSync(renderJobStorePath(stateDir), "utf8"), legacy);
+  rmSync(renderJobStorePath(stateDir));
+  assert.equal(listRenderJobs(stateDir, now).find((job) => job.jobId === "legacy-1").status, "downloaded");
+});
+
+test("최신 50개 상한과 jobId 경로 격리를 유지", (t) => {
+  const stateDir = fixture(t);
+  const now = Date.now();
+  for (let i = 0; i < 55; i++) recordRenderJob(stateDir, { jobId: `../job-${i}` }, now + i);
+  const jobs = listRenderJobs(stateDir, now + 55);
+  assert.equal(jobs.length, 50);
+  assert.equal(jobs[0].jobId, "../job-54");
+  assert.equal(jobs.at(-1).jobId, "../job-5");
+  assert.ok(readdirSync(renderJobRecordsDir(stateDir)).every((name) => /^[a-f0-9]{64}$/u.test(name)));
+});
+
+// Start independent Node processes at the same barrier, not sequential promises
+// in one event loop (the old synchronous read-modify-write passed those tests).
+async function concurrentWorkers(t, stateDir, operation, count = 8) {
+  const moduleUrl = new URL("./render-job-store.mjs", import.meta.url).href;
+  const workers = Array.from({ length: count }, (_, index) => {
+    const source = `
+      import { recordRenderJob, updateRenderJob } from ${JSON.stringify(moduleUrl)};
+      const stateDir = ${JSON.stringify(stateDir)};
+      const worker = ${index};
+      process.stdin.once('data', () => {
+        ${operation}
+        process.stdin.destroy();
+      });
+      process.stdout.write('ready');
+    `;
+    const child = spawn(process.execPath, ["--input-type=module", "--eval", source], { stdio: ["pipe", "pipe", "pipe"] });
+    t.after(() => { if (child.exitCode === null) child.kill(); });
+    let stderr = "";
+    child.stderr.on("data", (chunk) => { stderr += chunk; });
+    const ready = new Promise((resolve, reject) => {
+      child.stdout.once("data", resolve);
+      child.once("error", reject);
+      child.once("exit", (code) => { if (code !== 0) reject(new Error(stderr || `worker exit ${code}`)); });
+    });
+    const done = new Promise((resolve, reject) => {
+      child.once("error", reject);
+      child.once("exit", (code) => code === 0 ? resolve() : reject(new Error(stderr || `worker exit ${code}`)));
+    });
+    return { child, ready, done };
+  });
+  await Promise.all(workers.map(({ ready }) => ready));
+  for (const { child } of workers) child.stdin.end("go");
+  await Promise.all(workers.map(({ done }) => done));
+}
+
+test("8개 프로세스가 동시에 기록·갱신해도 모든 잡이 보존된다", async (t) => {
+  const stateDir = fixture(t);
+  await concurrentWorkers(t, stateDir, `
+    for (let i = 0; i < 4; i++) {
+      const jobId = 'worker-' + worker + '-job-' + i;
+      recordRenderJob(stateDir, { jobId });
+      updateRenderJob(stateDir, jobId, { status: 'succeeded' });
+    }
+  `);
+  const jobs = listRenderJobs(stateDir);
+  assert.equal(jobs.length, 32);
+  assert.equal(new Set(jobs.map((job) => job.jobId)).size, 32);
+  assert.ok(jobs.every((job) => job.status === "succeeded"));
+});
+
+test("같은 잡의 서로 다른 필드에 대한 프로세스 동시 패치를 보존", async (t) => {
+  const stateDir = fixture(t);
+  recordRenderJob(stateDir, { jobId: "shared" });
+  await concurrentWorkers(t, stateDir, `
+    updateRenderJob(stateDir, 'shared', { ['field-' + worker]: 'value-' + worker });
+  `);
+  const [job] = listRenderJobs(stateDir);
+  for (let i = 0; i < 8; i++) assert.equal(job[`field-${i}`], `value-${i}`);
+  updateRenderJob(stateDir, "shared", { status: "downloaded", filePath: "/tmp/shared.mp4", jobId: "other" });
+  assert.equal(listRenderJobs(stateDir)[0].jobId, "shared");
 });

package/lib/tool-contract.test.mjs

@@ -0,0 +1,80 @@
+// MCP 도구 ↔ 서버 계약 회귀.
+// 감사에서 확인된 실제 결함들을 고정한다 — 전부 "테스트는 통과하는데 사용자에겐 깨져 보이던" 종류다.
+//
+// 이 파일은 zod·cloud-tools 를 import 하지 않는다. mcp/ 는 별도 npm 패키지라 그 의존성이
+// 저장소 루트의 npm ci 에는 없고, 배포 게이트(prep.sh)는 루트에서 npm test 를 돌린다.
+// 다른 mcp 테스트들도 같은 이유로 의존성 없이 작성돼 있다.
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import test from "node:test";
+
+const SOURCE = readFileSync(new URL("./cloud-tools.mjs", import.meta.url), "utf8");
+
+/** 특정 api.request 호출 뒤에 붙은 timeoutMs 값을 읽는다. */
+function clientBudgetFor(routePath) {
+  const at = SOURCE.indexOf(`"${routePath}"`);
+  assert.ok(at > 0, `${routePath} 호출을 찾지 못했다`);
+  const found = SOURCE.slice(at, at + 2600).match(/timeoutMs:\s*([0-9_]+)/);
+  assert.ok(found, `${routePath}: timeoutMs 를 찾지 못했다`);
+  return Number(found[1].replace(/_/g, ""));
+}
+
+test("stitch_timeline 전환 기본값은 none — fade 는 맞대기 배치에서 컷마다 검은 딥을 만든다", () => {
+  // 0.8.0 이 서버·웹 기본값만 none 으로 바꾸고 MCP 를 놓쳐 MCP 렌더에만 딥이 남아 있었다.
+  // MCP 는 transitionMode 를 항상 명시 전송하므로 서버 기본값이 적용되지 않는다.
+  assert.match(SOURCE, /transitionMode = "none"/, "MCP 핸들러 기본값이 none 이 아니다");
+  assert.doesNotMatch(SOURCE, /transitionMode = "fade"/, "fade 기본값이 남아 있다");
+});
+
+test("대본 도구의 targetLength 상한이 서버 출력 상한 안에 있다", () => {
+  // 서버는 max_tokens 8192 고정이라 한국어 약 12,300자가 한계다. 20000 을 광고하면
+  // 프롬프트에 도달 불가한 목표가 나가고, 잘림 감지가 없어 끊긴 대본이 정상 반환된다.
+  assert.doesNotMatch(SOURCE, /targetLength: z\.number\(\)\.int\(\)\.min\(500\)\.max\(20000\)/,
+    "도달 불가한 20000 상한이 남아 있다");
+  const caps = [...SOURCE.matchAll(/targetLength: z\.number\(\)\.int\(\)\.min\(500\)\.max\((\d+)\)/g)]
+    .map((m) => Number(m[1]));
+  assert.equal(caps.length, 3, `대본 도구 3종을 찾지 못했다 (${caps.length}개)`);
+  for (const cap of caps) assert.ok(cap <= 12000, `상한 ${cap} 이 서버 한계를 넘는다`);
+});
+
+test("지문 파라미터는 sampleSize 를 요구한다 — 없으면 서버가 조용히 무시한다", () => {
+  // 서버 buildFingerprintDirectives 는 sampleSize > 0 이 아니면 빈 배열을 반환한다.
+  // 선택 필드로 두면 부분 지문이 통과해 아무 일도 안 일어나는데 성공처럼 보인다.
+  assert.doesNotMatch(SOURCE, /sampleSize: z\.number\(\)\.optional\(\)/,
+    "sampleSize 가 아직 선택 필드다");
+  const required = [...SOURCE.matchAll(/sampleSize: z\.number\(\)\.describe\(/g)].length;
+  assert.ok(required >= 2, `sampleSize 필수 선언이 부족하다 (${required}곳)`);
+});
+
+test("measure_channel_spec 은 재지 않는 축(말속도)을 약속하지 않는다", () => {
+  // cpsTarget 은 타임코드 전사가 있어야 산출되는데 이 도구는 전사를 하지 않는다.
+  const at = SOURCE.indexOf('"measure_channel_spec"');
+  assert.ok(at > 0);
+  const block = SOURCE.slice(at, at + 1200);
+  assert.match(block, /말속도는 측정하지 않습니다/, "재지 않는 축을 약속하고 있다");
+});
+
+test("대본 도구의 클라이언트 예산이 서버 최악 예산보다 크다", () => {
+  // 역전되면 클라는 실패로 끝나는데 서버는 계속 돌며 과금한다 — 회수 불가능한 지출.
+  // 서버 최악: 리서치 8초 + 생성 150초 × 2회 ≈ 310초.
+  for (const route of [
+    "/api/tracker/ai/script",
+    "/api/tracker/ai/real-estate-report",
+    "/api/tracker/ai/market-analysis",
+  ]) {
+    const budget = clientBudgetFor(route);
+    assert.ok(budget >= 400_000, `${route}: 클라이언트 예산 ${budget}ms 가 서버 최악보다 작다`);
+  }
+});
+
+test("이 테스트 파일은 mcp 전용 의존성을 import 하지 않는다", () => {
+  // 배포 게이트는 저장소 루트에서 npm test 를 돌리는데 zod 는 mcp/ 에만 있다.
+  // (실제로 이 규칙을 어겨 배포가 한 번 막혔다.)
+  const self = readFileSync(new URL("./tool-contract.test.mjs", import.meta.url), "utf8");
+  const importLines = self.split("\n").filter((line) => /^\s*import\s/.test(line));
+  for (const line of importLines) {
+    assert.doesNotMatch(line, /["']zod["']/, `zod 를 import 하면 루트 npm test 에서 깨진다: ${line.trim()}`);
+    assert.doesNotMatch(line, /cloud-tools\.mjs/, `cloud-tools 는 zod 를 import 하므로 같이 깨진다: ${line.trim()}`);
+  }
+  assert.ok(importLines.length >= 3, "import 문을 찾지 못했다 — 검사가 무력화됐다");
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aimakeall-mcp",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "AImakeAll MCP 서버 — Claude Code/Codex에서 자연어로 영상 기획·생성·렌더·퍼블리시 (렌더는 로컬 컴패니언)",
   "type": "module",
   "bin": {