aimakeall-mcp 0.1.0

package/lib/media-store.test.mjs

@@ -0,0 +1,99 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, writeFileSync, utimesSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test, { after } from "node:test";
+
+import {
+  ALLOWED_IMAGE_EXTS,
+  assertAllowedInputFile,
+  encodedDataUrlBytes,
+  fileToDataUrl,
+  fileToImagePayload,
+  guessMimeType,
+  MAX_DATA_URL_SOURCE_BYTES,
+  mediaDir,
+  pruneOldMedia,
+  readPayloadHandle,
+  saveMediaBuffer,
+  savePayloadHandle,
+} from "./media-store.mjs";
+import { createUsageEventId } from "./usage-event.mjs";
+
+const stateDir = mkdtempSync(join(tmpdir(), "aio-mcp-media-"));
+const scratch = mkdtempSync(join(tmpdir(), "aio-mcp-scratch-"));
+after(() => {
+  rmSync(stateDir, { force: true, recursive: true });
+  rmSync(scratch, { force: true, recursive: true });
+});
+
+test("버퍼 저장 → data URL 변환 roundtrip (유일 파일명)", () => {
+  const audioPath = join(scratch, "clip.mp3");
+  writeFileSync(audioPath, Buffer.from("hello-audio"));
+  const dataUrl = fileToDataUrl(audioPath);
+  assert.ok(dataUrl.startsWith("data:audio/mpeg;base64,"));
+  assert.equal(Buffer.from(dataUrl.split(",")[1], "base64").toString(), "hello-audio");
+});
+
+test("saveMediaBuffer 는 동일 이름 병렬 저장에도 경로가 겹치지 않는다", () => {
+  const a = saveMediaBuffer(stateDir, "narration.mp3", Buffer.from("A"));
+  const b = saveMediaBuffer(stateDir, "narration.mp3", Buffer.from("B"));
+  assert.notEqual(a.filePath, b.filePath);
+});
+
+test("확장자 화이트리스트 — 허용 외 확장자·존재하지 않는 파일 거부", () => {
+  const secret = join(scratch, "id_rsa");
+  writeFileSync(secret, "PRIVATE KEY");
+  assert.throws(() => assertAllowedInputFile(secret, ALLOWED_IMAGE_EXTS, { kind: "이미지" }), /허용되지 않은/u);
+  assert.throws(() => fileToImagePayload(secret), /허용되지 않은/u);
+  assert.throws(() => assertAllowedInputFile(join(scratch, "nope.png"), ALLOWED_IMAGE_EXTS), /찾을 수 없습니다/u);
+});
+
+test("크기 상한 초과 파일은 거부", () => {
+  const big = join(scratch, "big.mp3");
+  writeFileSync(big, Buffer.alloc(MAX_DATA_URL_SOURCE_BYTES + 1));
+  assert.throws(() => fileToDataUrl(big), /너무 큽니다/u);
+});
+
+test("이미지 페이로드 변환 — {name, mimeType, base64}", () => {
+  const imgPath = join(scratch, "product.png");
+  writeFileSync(imgPath, Buffer.from([0x89, 0x50, 0x4e, 0x47]));
+  const payload = fileToImagePayload(imgPath);
+  assert.equal(payload.name, "product.png");
+  assert.equal(payload.mimeType, "image/png");
+  assert.equal(Buffer.from(payload.base64, "base64").length, 4);
+});
+
+test("encodedDataUrlBytes — base64 4/3 팽창 반영", () => {
+  assert.ok(encodedDataUrlBytes(3_000_000) > 4_000_000);
+  assert.ok(encodedDataUrlBytes(0) > 0); // 헤더만
+});
+
+test("payload 핸들 저장·복원 + stateDir 밖 경로 거부", () => {
+  const manifest = { assets: [{ id: "a" }], projectTitle: "테스트" };
+  const handle = savePayloadHandle(stateDir, manifest, "stitch");
+  assert.deepEqual(readPayloadHandle(handle.filePath, { stateDir }), manifest);
+  // stateDir/media 밖 경로는 거부
+  const outside = join(scratch, "evil.json");
+  writeFileSync(outside, JSON.stringify({ x: 1 }));
+  assert.throws(() => readPayloadHandle(outside, { stateDir }), /stitch_timeline이 반환한 경로/u);
+});
+
+test("MIME 추정 — 확장자 기반, 미지정 폴백", () => {
+  assert.equal(guessMimeType("/x/a.MP4"), "video/mp4");
+  assert.equal(guessMimeType("/x/a.unknown"), "application/octet-stream");
+});
+
+test("pruneOldMedia — TTL 지난 파일만 삭제", () => {
+  const fresh = saveMediaBuffer(stateDir, "fresh.mp3", Buffer.from("f"));
+  const stale = saveMediaBuffer(stateDir, "stale.mp3", Buffer.from("s"));
+  const old = (Date.now() - 3 * 24 * 60 * 60 * 1000) / 1000;
+  utimesSync(stale.filePath, old, old);
+  const removed = pruneOldMedia(stateDir);
+  assert.ok(removed >= 1);
+  assert.ok(mediaDir(stateDir).endsWith("media"));
+});
+
+test("usage event id — 서버 규칙 준수", () => {
+  assert.match(createUsageEventId("shorts-plan"), /^[a-z0-9._:-]{1,120}$/iu);
+});

package/lib/mp3-duration.mjs

@@ -0,0 +1,96 @@
+// MPEG 오디오(mp3) 실측 길이 계산 — 프레임을 순회해 CBR·VBR 모두 정확히 처리한다.
+// 스티치 타임라인의 audioDurationSec 에 쓰이며, 여기가 틀리면 마지막 클립이
+// 늘어나거나(정지 화면) 오디오가 잘린다. CBR 비트레이트 추정 대신 프레임 합산을 쓴다.
+
+// [MPEG version index][layer index] → samples/frame
+const SAMPLES_PER_FRAME = {
+  // MPEG1
+  3: { 3: 384, 2: 1152, 1: 1152 }, // layer I, II, III
+  // MPEG2
+  2: { 3: 384, 2: 1152, 1: 576 },
+  // MPEG2.5
+  0: { 3: 384, 2: 1152, 1: 576 },
+};
+
+const SAMPLE_RATES = {
+  3: [44100, 48000, 32000], // MPEG1
+  2: [22050, 24000, 16000], // MPEG2
+  0: [11025, 12000, 8000], // MPEG2.5
+};
+
+// [versionBit][layer] → bitrate table (kbps), index by 4-bit bitrate field.
+const BITRATES = {
+  // MPEG1
+  "3-3": [0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448], // layer I
+  "3-2": [0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384], // layer II
+  "3-1": [0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320], // layer III
+  // MPEG2 / 2.5
+  "2-3": [0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256],
+  "2-2": [0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160],
+  "2-1": [0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160],
+};
+
+function skipId3v2(buffer) {
+  if (buffer.length >= 10 && buffer[0] === 0x49 && buffer[1] === 0x44 && buffer[2] === 0x33) {
+    // syncsafe 28-bit size
+    const size = (buffer[6] << 21) | (buffer[7] << 14) | (buffer[8] << 7) | buffer[9];
+    return 10 + size;
+  }
+  return 0;
+}
+
+// mp3 버퍼의 총 재생 길이(초). 파싱 실패 시 0 (호출자가 폴백 판단).
+export function mp3DurationSec(buffer) {
+  if (!Buffer.isBuffer(buffer) || buffer.length < 4) return 0;
+  let offset = skipId3v2(buffer);
+  let totalSamples = 0;
+  let sampleRate = 0;
+  let frames = 0;
+  const limit = buffer.length - 4;
+
+  while (offset <= limit) {
+    // 프레임 싱크: 11비트 1
+    if (buffer[offset] !== 0xff || (buffer[offset + 1] & 0xe0) !== 0xe0) {
+      offset += 1;
+      continue;
+    }
+    const b1 = buffer[offset + 1];
+    const b2 = buffer[offset + 2];
+    const versionBits = (b1 >> 3) & 0x03; // 3=MPEG1, 2=MPEG2, 0=MPEG2.5, 1=reserved
+    const layerBits = (b1 >> 1) & 0x03; // 3=I, 2=II, 1=III, 0=reserved
+    const bitrateIdx = (b2 >> 4) & 0x0f;
+    const sampleRateIdx = (b2 >> 2) & 0x03;
+    const padding = (b2 >> 1) & 0x01;
+
+    if (versionBits === 1 || layerBits === 0 || bitrateIdx === 0 || bitrateIdx === 15 || sampleRateIdx === 3) {
+      offset += 1;
+      continue;
+    }
+
+    const bitrateTable = BITRATES[`${versionBits === 3 ? 3 : 2}-${layerBits}`];
+    const bitrate = (bitrateTable ? bitrateTable[bitrateIdx] : 0) * 1000;
+    const rate = SAMPLE_RATES[versionBits]?.[sampleRateIdx] || 0;
+    const spf = SAMPLES_PER_FRAME[versionBits]?.[layerBits] || 0;
+    if (!bitrate || !rate || !spf) {
+      offset += 1;
+      continue;
+    }
+
+    // 프레임 바이트 길이
+    const frameLen = layerBits === 3
+      ? Math.floor((12 * bitrate) / rate + padding) * 4 // layer I
+      : Math.floor((spf / 8 * bitrate) / rate) + padding;
+    if (frameLen < 4) {
+      offset += 1;
+      continue;
+    }
+
+    totalSamples += spf;
+    sampleRate = rate;
+    frames += 1;
+    offset += frameLen;
+  }
+
+  if (!frames || !sampleRate) return 0;
+  return Math.round((totalSamples / sampleRate) * 100) / 100;
+}

package/lib/mp3-duration.test.mjs

@@ -0,0 +1,50 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test, { after } from "node:test";
+
+import { mp3DurationSec } from "./mp3-duration.mjs";
+
+const dir = mkdtempSync(join(tmpdir(), "aio-mp3-test-"));
+after(() => rmSync(dir, { force: true, recursive: true }));
+
+function hasFfmpeg() {
+  try {
+    execFileSync("ffmpeg", ["-version"], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+test("빈/짧은 버퍼는 0", () => {
+  assert.equal(mp3DurationSec(Buffer.alloc(0)), 0);
+  assert.equal(mp3DurationSec(Buffer.from([0xff])), 0);
+  assert.equal(mp3DurationSec("not a buffer"), 0);
+});
+
+test("mp3 프레임이 없으면 0 (오디오 아님)", () => {
+  assert.equal(mp3DurationSec(Buffer.alloc(4096, 0x11)), 0);
+});
+
+test("실측 CBR/VBR 길이 (ffmpeg 있을 때만)", { skip: !hasFfmpeg() && "ffmpeg 미설치" }, () => {
+  const cbr = join(dir, "cbr.mp3");
+  execFileSync("ffmpeg", ["-y", "-f", "lavfi", "-i", "sine=frequency=440:duration=3", "-c:a", "libmp3lame", "-b:a", "128k", cbr], { stdio: "ignore" });
+  assert.ok(existsSync(cbr));
+  const cbrDur = mp3DurationSec(readFileSync(cbr));
+  assert.ok(cbrDur >= 2.8 && cbrDur <= 3.3, `CBR 길이 ${cbrDur} 가 3초 근처가 아님`);
+
+  const vbr = join(dir, "vbr.mp3");
+  execFileSync("ffmpeg", ["-y", "-f", "lavfi", "-i", "sine=frequency=440:duration=5", "-c:a", "libmp3lame", "-q:a", "4", vbr], { stdio: "ignore" });
+  const vbrDur = mp3DurationSec(readFileSync(vbr));
+  assert.ok(vbrDur >= 4.7 && vbrDur <= 5.3, `VBR 길이 ${vbrDur} 가 5초 근처가 아님`);
+});
+
+test("ID3v2 태그가 앞에 있어도 파싱 (ffmpeg 있을 때만)", { skip: !hasFfmpeg() && "ffmpeg 미설치" }, () => {
+  const tagged = join(dir, "tagged.mp3");
+  execFileSync("ffmpeg", ["-y", "-f", "lavfi", "-i", "sine=frequency=440:duration=2", "-c:a", "libmp3lame", "-b:a", "192k", "-metadata", "title=테스트", tagged], { stdio: "ignore" });
+  const dur = mp3DurationSec(readFileSync(tagged));
+  assert.ok(dur >= 1.8 && dur <= 2.3, `태그 mp3 길이 ${dur} 가 2초 근처가 아님`);
+});

package/lib/payload-guard.mjs

@@ -0,0 +1,103 @@
+// 서버가 준비한 렌더 페이로드를 로컬 컴패니언에 전달하기 전 정화한다.
+// 분리 배포 토폴로지에서 클라우드 응답은 로컬 파일 경로를 정당하게 쓸 일이 없으므로,
+// path/companionFileUrl 자산은 제거하고 원격 URL 은 허용 호스트만 통과시킨다.
+
+// 컴패니언의 렌더 바디 상한(MAX_MOVIEPY_RENDER_BODY_BYTES)과 동일하게 유지.
+export const COMPANION_RENDER_BODY_LIMIT_BYTES = 32 * 1024 * 1024;
+
+const ALLOWED_YOUTUBE_HOSTS = new Set([
+  "youtube.com",
+  "www.youtube.com",
+  "m.youtube.com",
+  "music.youtube.com",
+  "youtu.be",
+]);
+
+export function isAllowedYoutubeUrl(value) {
+  try {
+    const url = new URL(String(value || ""));
+    return (url.protocol === "https:" || url.protocol === "http:")
+      && ALLOWED_YOUTUBE_HOSTS.has(url.hostname.toLowerCase());
+  } catch {
+    return false;
+  }
+}
+
+function isHttpsUrl(value) {
+  try {
+    return new URL(String(value || "")).protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * 렌더 페이로드 정화 — 반환: { payload, warnings }.
+ * - asset.path / asset.companionFileUrl 제거 (로컬 파일 탈취 경로 차단)
+ * - youtubeUrl 은 유튜브 호스트만, sourceUrl 은 https 만 허용 (SSRF-류 차단)
+ * - dataUrl 은 data: 스킴만
+ */
+export function sanitizeRenderPayload(input) {
+  const warnings = [];
+  const payload = structuredClone(input || {});
+  const assets = Array.isArray(payload.assets) ? payload.assets : [];
+
+  payload.assets = assets.map((asset, index) => {
+    if (!asset || typeof asset !== "object") return asset;
+    const cleaned = { ...asset };
+    const label = cleaned.id || `#${index}`;
+
+    if ("path" in cleaned) {
+      delete cleaned.path;
+      warnings.push(`자산 ${label}: 로컬 path 제거됨 (분리 배포에서 서버는 로컬 경로를 보낼 수 없습니다)`);
+    }
+    if ("companionFileUrl" in cleaned) {
+      delete cleaned.companionFileUrl;
+      warnings.push(`자산 ${label}: companionFileUrl 제거됨`);
+    }
+    if (cleaned.youtubeUrl && !isAllowedYoutubeUrl(cleaned.youtubeUrl)) {
+      delete cleaned.youtubeUrl;
+      warnings.push(`자산 ${label}: 허용되지 않은 youtubeUrl 제거됨`);
+    }
+    if (cleaned.sourceUrl && !isHttpsUrl(cleaned.sourceUrl)) {
+      delete cleaned.sourceUrl;
+      warnings.push(`자산 ${label}: https 가 아닌 sourceUrl 제거됨`);
+    }
+    // 컴패니언은 sourceUrl 부재 시 asset.url 로 폴백하므로(moviepy_bridge) url 도 동일 규칙 적용.
+    if (cleaned.url && !isHttpsUrl(cleaned.url)) {
+      delete cleaned.url;
+      warnings.push(`자산 ${label}: https 가 아닌 url 제거됨`);
+    }
+    if (cleaned.dataUrl && !String(cleaned.dataUrl).startsWith("data:")) {
+      delete cleaned.dataUrl;
+      warnings.push(`자산 ${label}: data: 스킴이 아닌 dataUrl 제거됨`);
+    }
+    return cleaned;
+  });
+
+  return { payload, warnings };
+}
+
+// 컴패니언 제출 전 크기 검사 — 초과 시 사용자에게 행동 가능한 안내를 준다.
+export function checkRenderPayloadSize(payload) {
+  const bytes = Buffer.byteLength(JSON.stringify(payload || {}), "utf8");
+  return {
+    bytes,
+    ok: bytes <= COMPANION_RENDER_BODY_LIMIT_BYTES,
+    limitBytes: COMPANION_RENDER_BODY_LIMIT_BYTES,
+  };
+}
+
+// Windows 금지 문자·길이까지 안전한 출력 파일명.
+export function sanitizeOutputFilename(name, fallback = "render.mp4") {
+  let base = String(name || "").trim();
+  if (!base) return fallback;
+  base = base.replace(/[<>:"/\\|?*\u0000-\u001f]/gu, "_").replace(/[. ]+$/u, "");
+  if (!base) return fallback;
+  if (base.length > 120) {
+    const extMatch = base.match(/\.[A-Za-z0-9]{1,5}$/u);
+    const ext = extMatch ? extMatch[0] : "";
+    base = base.slice(0, 120 - ext.length) + ext;
+  }
+  return base;
+}

package/lib/payload-guard.test.mjs

@@ -0,0 +1,76 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  checkRenderPayloadSize,
+  COMPANION_RENDER_BODY_LIMIT_BYTES,
+  isAllowedYoutubeUrl,
+  sanitizeOutputFilename,
+  sanitizeRenderPayload,
+} from "./payload-guard.mjs";
+
+test("path·companionFileUrl 자산은 제거되고 경고가 남는다", () => {
+  const { payload, warnings } = sanitizeRenderPayload({
+    assets: [
+      { id: "a", kind: "video", path: "/Users/x/private.mov", youtubeUrl: "https://www.youtube.com/watch?v=abc" },
+      { id: "b", kind: "audio", companionFileUrl: "http://127.0.0.1:9876/api/files/p/f.mp3", dataUrl: "data:audio/mp3;base64,AAA" },
+    ],
+  });
+  assert.equal(payload.assets[0].path, undefined);
+  assert.equal(payload.assets[0].youtubeUrl, "https://www.youtube.com/watch?v=abc");
+  assert.equal(payload.assets[1].companionFileUrl, undefined);
+  assert.equal(payload.assets[1].dataUrl, "data:audio/mp3;base64,AAA");
+  assert.equal(warnings.length, 2);
+});
+
+test("유튜브 외 호스트 youtubeUrl·비 https sourceUrl/url·비 data dataUrl 은 제거", () => {
+  const { payload, warnings } = sanitizeRenderPayload({
+    assets: [
+      { id: "a", youtubeUrl: "https://evil.example.com/watch?v=abc" },
+      { id: "b", sourceUrl: "http://internal.host/file.mp4" },
+      { id: "c", dataUrl: "https://not-data.example.com/x" },
+      { id: "d", sourceUrl: "https://cdn.example.com/ok.mp4" },
+      { id: "e", url: "http://169.254.169.254/latest/meta-data" },
+      { id: "f", url: "https://cdn.example.com/ok.mp4" },
+    ],
+  });
+  assert.equal(payload.assets[0].youtubeUrl, undefined);
+  assert.equal(payload.assets[1].sourceUrl, undefined);
+  assert.equal(payload.assets[2].dataUrl, undefined);
+  assert.equal(payload.assets[3].sourceUrl, "https://cdn.example.com/ok.mp4");
+  assert.equal(payload.assets[4].url, undefined); // 컴패니언이 sourceUrl 부재 시 url 로 폴백하므로 검증
+  assert.equal(payload.assets[5].url, "https://cdn.example.com/ok.mp4");
+  assert.equal(warnings.length, 4);
+});
+
+test("입력 페이로드는 변형되지 않는다 (deep clone)", () => {
+  const input = { assets: [{ id: "a", path: "/tmp/x" }] };
+  sanitizeRenderPayload(input);
+  assert.equal(input.assets[0].path, "/tmp/x");
+});
+
+test("isAllowedYoutubeUrl — 표준 호스트만", () => {
+  assert.equal(isAllowedYoutubeUrl("https://youtu.be/abc"), true);
+  assert.equal(isAllowedYoutubeUrl("https://m.youtube.com/watch?v=a"), true);
+  assert.equal(isAllowedYoutubeUrl("https://youtube.com.evil.com/watch"), false);
+  assert.equal(isAllowedYoutubeUrl("ftp://youtube.com/x"), false);
+  assert.equal(isAllowedYoutubeUrl("not-a-url"), false);
+});
+
+test("페이로드 크기 검사 — 32MB 상한", () => {
+  const small = checkRenderPayloadSize({ a: 1 });
+  assert.equal(small.ok, true);
+  assert.equal(small.limitBytes, COMPANION_RENDER_BODY_LIMIT_BYTES);
+  const big = checkRenderPayloadSize({ blob: "x".repeat(COMPANION_RENDER_BODY_LIMIT_BYTES) });
+  assert.equal(big.ok, false);
+});
+
+test("출력 파일명 정화 — 금지문자 치환·길이 상한·확장자 보존·폴백", () => {
+  assert.equal(sanitizeOutputFilename('내 영상: "최종"?.mp4'), "내 영상_ _최종__.mp4");
+  assert.equal(sanitizeOutputFilename("a-b c.mp4"), "a-b c.mp4");
+  assert.equal(sanitizeOutputFilename("", "fallback.mp4"), "fallback.mp4");
+  assert.equal(sanitizeOutputFilename("..."), "render.mp4");
+  const long = sanitizeOutputFilename(`${"가".repeat(200)}.mp4`);
+  assert.ok(long.length <= 120);
+  assert.ok(long.endsWith(".mp4"));
+});

package/lib/render-job-store.mjs

@@ -0,0 +1,67 @@
+import { randomUUID } from "node:crypto";
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import path from "node:path";
+
+// 렌더 잡 영속화 — npx 프록시가 재시작돼도 jobId 를 잃지 않도록
+// ~/.aimakeall/render-jobs.json 에 기록한다. 컴패니언 잡 TTL(만료) 은 서버가 판정하므로
+// 여기서는 오래된 항목만 정리한다.
+
+const MAX_ENTRIES = 50;
+const ENTRY_TTL_MS = 24 * 60 * 60 * 1000;
+
+export function renderJobStorePath(stateDir) {
+  return path.join(stateDir, "render-jobs.json");
+}
+
+function readEntries(filePath) {
+  try {
+    const parsed = JSON.parse(readFileSync(filePath, "utf8"));
+    return Array.isArray(parsed?.jobs) ? parsed.jobs : [];
+  } catch {
+    return [];
+  }
+}
+
+function writeEntries(filePath, jobs) {
+  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);
+}
+
+function pruneEntries(jobs, now) {
+  return jobs
+    .filter((job) => job && job.jobId && now - (Number(job.createdAtMs) || 0) < ENTRY_TTL_MS)
+    .slice(-MAX_ENTRIES);
+}
+
+export function recordRenderJob(stateDir, { jobId, projectTitle = "", statusUrl = "", outputUrl = "" }, now = Date.now()) {
+  const filePath = renderJobStorePath(stateDir);
+  const jobs = pruneEntries(readEntries(filePath), now);
+  jobs.push({
+    createdAt: new Date(now).toISOString(),
+    createdAtMs: now,
+    jobId: String(jobId || ""),
+    outputUrl: String(outputUrl || ""),
+    projectTitle: String(projectTitle || ""),
+    statusUrl: String(statusUrl || ""),
+  });
+  writeEntries(filePath, jobs);
+  return jobs[jobs.length - 1];
+}
+
+export function listRenderJobs(stateDir, now = Date.now()) {
+  return pruneEntries(readEntries(renderJobStorePath(stateDir)), now).reverse();
+}
+
+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];
+}

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

@@ -0,0 +1,46 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test, { after } from "node:test";
+
+import {
+  listRenderJobs,
+  recordRenderJob,
+  renderJobStorePath,
+  updateRenderJob,
+} from "./render-job-store.mjs";
+
+const stateDir = mkdtempSync(join(tmpdir(), "aio-mcp-jobstore-"));
+after(() => rmSync(stateDir, { force: true, recursive: true }));
+
+test("기록 → 목록(최신순) → 갱신 roundtrip", () => {
+  recordRenderJob(stateDir, { jobId: "job-1", projectTitle: "첫번째" });
+  recordRenderJob(stateDir, { jobId: "job-2", projectTitle: "두번째", statusUrl: "/api/moviepy/render-jobs/job-2" });
+
+  const jobs = listRenderJobs(stateDir);
+  assert.equal(jobs.length, 2);
+  assert.equal(jobs[0].jobId, "job-2");
+  assert.equal(jobs[1].projectTitle, "첫번째");
+
+  const updated = updateRenderJob(stateDir, "job-1", { status: "succeeded", filePath: "/tmp/a.mp4" });
+  assert.equal(updated.status, "succeeded");
+  assert.equal(listRenderJobs(stateDir).find((job) => job.jobId === "job-1").filePath, "/tmp/a.mp4");
+  assert.equal(updateRenderJob(stateDir, "missing", { status: "x" }), null);
+});
+
+test("24시간 지난 항목은 정리된다", () => {
+  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);
+});
+
+test("손상된 저장 파일은 빈 목록으로 복구된다", () => {
+  const filePath = renderJobStorePath(stateDir);
+  assert.ok(readFileSync(filePath, "utf8").includes("job-2"));
+  rmSync(filePath);
+  assert.deepEqual(listRenderJobs(stateDir), []);
+  recordRenderJob(stateDir, { jobId: "after-reset" });
+  assert.equal(listRenderJobs(stateDir)[0].jobId, "after-reset");
+});

package/lib/usage-event.mjs

@@ -0,0 +1,7 @@
+import { randomUUID } from "node:crypto";
+
+// 서버 usage-event id 규칙(/^[a-z0-9._:-]{1,120}$/i)에 맞는 클라이언트 이벤트 id.
+// 비용 원장(user_cost_ledger)의 멱등 키로 쓰인다 — 재시도 시 중복 과금 방지.
+export function createUsageEventId(prefix) {
+  return `${prefix}:started-${Date.now()}:${randomUUID()}`;
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "aimakeall-mcp",
+  "version": "0.1.0",
+  "description": "AImakeAll MCP 서버 — Claude Code/Codex에서 자연어로 영상 기획·생성·렌더·퍼블리시 (렌더는 로컬 컴패니언)",
+  "type": "module",
+  "bin": {
+    "aimakeall-mcp": "index.mjs"
+  },
+  "files": [
+    "index.mjs",
+    "lib/",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18.17"
+  },
+  "scripts": {
+    "test": "node --test lib/*.test.mjs"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "zod": "^3.25.1"
+  },
+  "license": "UNLICENSED"
+}