aimakeall-mcp 0.14.2 → 0.14.4

package/lib/review-full-analysis.mjs

@@ -4,6 +4,10 @@ import path from "node:path";
 import { savePayloadHandle } from "./media-store.mjs";
 import { canonicalYoutubeWatchUrl } from "./payload-guard.mjs";
 import { inspectReviewLocalFile, readReviewHandle, reviewPublicSources, validateReviewSources } from "./review-sources.mjs";
+import { createReviewStoryJobClient, REVIEW_STORY_TRANSPORT } from "./review-story-job-request.mjs";
+import { createReviewNativeJobClient, REVIEW_NATIVE_TRANSPORT, unwrapReviewNativeJobResult } from "./review-native-job-request.mjs";
+import { DEFAULT_API_BASE } from "./config.mjs";
+import { matchesApiClientAuthority } from "./api-client.mjs";
 
 const KIND = "aimakeall-review-full-analysis";
 const MAX_CHUNK_BYTES = 10 * 1024 * 1024;
@@ -68,14 +72,64 @@ function lockAnalysis(config, analysisId) {
 function receipt(value, stage, chunkId = "") {
   return { stage, chunkId, ...Object.fromEntries(RECEIPT_KEYS.filter(key => value?.[key] !== undefined).map(key => [key, value[key]])) };
 }
+function upsertStoryReceipt(state, value, operationId) {
+  upsertStageReceipt(state, value, operationId, "synthesizing");
+}
+function upsertStageReceipt(state, value, operationId, stage, chunkId = "") {
+  const item = { ...receipt(value, stage, chunkId), clientOperationId: operationId };
+  const index = state.receipts.findIndex(row => row.clientOperationId === operationId);
+  if (index < 0) state.receipts.push(item);
+  else {
+    const previous = state.receipts[index];
+    const unique = field => [...new Map([...(previous[field] || []), ...(item[field] || [])]
+      .map(event => [event.accountCostEventId || event.eventId || event.id || JSON.stringify(event), event])).values()];
+    state.receipts[index] = { ...previous, ...item, usage: item.usage || previous.usage,
+      operationId: item.operationId || previous.operationId, costUsd: Math.max(Number(previous.costUsd) || 0, Number(item.costUsd) || 0),
+      accountCostEvents: unique("accountCostEvents"), acceptedTaskCosts: unique("acceptedTaskCosts") };
+  }
+}
+function authorityBinding(config) {
+  const scope = new URL(config.apiBase || DEFAULT_API_BASE).href.replace(/\/$/u, "");
+  return { apiScope: scope, authorityFingerprint: createHash("sha256").update(JSON.stringify([scope, config.pat || ""])).digest("hex") };
+}
+function assertCheckpointAuthority(config, state) {
+  const current = authorityBinding(config);
+  if (!state.authorityBinding && (state.inFlight || state.pendingStageResult || state.receipts?.length || Object.keys(state.analyses || {}).length)) {
+    throw fail("REVIEW_CHECKPOINT_AUTHORITY_MISSING", "이전 분석 기록에 서버·계정 연결 증명이 없습니다. 기존 파일의 로컬 확인만 가능하며 현재 PAT로 결과를 적용하거나 유료 요청을 다시 보내지 않습니다.");
+  }
+  if (state.authorityBinding && (state.authorityBinding.apiScope !== current.apiScope || state.authorityBinding.authorityFingerprint !== current.authorityFingerprint)) {
+    throw fail("REVIEW_CHECKPOINT_AUTHORITY_CHANGED", "분석을 시작한 서버와 PAT로 기존 작업을 확인해 주세요. 계정이 변경된 상태에서는 업로드·유료 요청·결과 조회를 하지 않습니다.");
+  }
+  state.authorityBinding ||= current;
+}
+function storyClient(config, api) {
+  return createReviewStoryJobClient({ apiScope: config.apiBase || DEFAULT_API_BASE,
+    getAuthority: () => transportAuthority(config, api),
+    request: (route, options) => api.request(route, { ...options, ...(options.body === undefined ? {} : { body: JSON.parse(options.body) }) }),
+  });
+}
+function nativeClient(config, api) {
+  return createReviewNativeJobClient({ apiScope: config.apiBase || DEFAULT_API_BASE,
+    getAuthority: () => transportAuthority(config, api),
+    request: (route, options) => api.request(route, { ...options, ...(options.body === undefined ? {} : { body: JSON.parse(options.body) }) }),
+  });
+}
+function transportAuthority(config, api) {
+  if (matchesApiClientAuthority(api, { apiBase: config.apiBase || DEFAULT_API_BASE, pat: config.pat }) === false) return null;
+  return config.pat ? JSON.stringify([config.apiBase || DEFAULT_API_BASE, config.pat]) : api;
+}
+function mediaDescriptor(media) {
+  const { videoBase64, ...chunk } = media.chunk;
+  return { source: media.source, chunk, ...(media.workTitle !== undefined ? { workTitle: media.workTitle } : {}) };
+}
 function safeStageResult(value) {
   if (Array.isArray(value)) return value.map(safeStageResult);
   if (!value || typeof value !== "object") return value;
-  return Object.fromEntries(Object.entries(value).filter(([key]) => !/base64|dataUrl|localPath|sourceHandle|apiKey|token/i.test(key)).map(([key, item]) => [key, safeStageResult(item)]));
+  return Object.fromEntries(Object.entries(value).filter(([key]) => !/base64|dataUrl|localPath|sourceHandle|apiKey|^token$|accessToken|refreshToken|authorization|cookie/i.test(key)).map(([key, item]) => [key, safeStageResult(item)]));
 }
 function billing(state) {
   const costs = state.receipts || [];
-  const unique = (field) => [...new Map(costs.flatMap(item => item[field] || []).map(item => [item.eventId || item.id || JSON.stringify(item), item])).values()];
+  const unique = (field) => [...new Map(costs.flatMap(item => item[field] || []).map(item => [item.accountCostEventId || item.eventId || item.id || JSON.stringify(item), item])).values()];
   return { accountCostEvents: unique("accountCostEvents"), acceptedTaskCosts: unique("acceptedTaskCosts"),
     costUsd: costs.reduce((sum, item) => sum + (Number(item.costUsd) || 0), 0), stageReceipts: costs };
 }
@@ -94,12 +148,58 @@ function summary(state, resumePath) {
       analyzedTimelineSec: analyzedMs / 1000, totalTimelineSec: state.sources.reduce((sum, item) => sum + item.durationSec, 0) },
     sources: reviewPublicSources(state.sources), ...billing(state),
     warnings: state.warnings || [], error: state.error || undefined,
+    ...(state.inFlight?.transport === REVIEW_STORY_TRANSPORT ? { storyJob: { requestId: state.inFlight.operationId,
+      jobId: state.inFlight.jobId || null, apiScope: state.inFlight.apiScope, recovery: "read-only-known-job", paidReplayAllowed: false } } : {}),
+    ...(state.inFlight?.transport === REVIEW_NATIVE_TRANSPORT ? { nativeJob: { stage: state.inFlight.stage,
+      requestId: state.inFlight.operationId, jobId: state.inFlight.jobId || null, status: state.inFlight.jobStatus || "unknown",
+      apiScope: state.inFlight.apiScope, mediaAttemptId: state.inFlight.mediaAttempt?.attemptId || null,
+      fileState: state.inFlight.mediaReference ? "ready" : state.inFlight.mediaAttempt ? "reconciliation-required" : "not-uploaded",
+      recovery: state.inFlight.jobId ? "read-only-known-job" : state.inFlight.submissionAttempted ? "submission-unknown-no-replay" : "reconcile-upload",
+      paidReplayAllowed: false, automaticUploadRetryAllowed: false } } : {}),
+    mediaFiles: { ready: Object.keys(state.mediaReferences || {}).length, retainedForVerification: true },
+    reviewRequired: state.reviewRequired === true,
     failedStageResultPath: state.failedStageResultPath || undefined,
     requiresHumanReview: true, next: state.stage === "complete" ? "plan_review_video({reviewSourcePath,...})" : state.stage === "blocked" ? "실패 원인·이미 접수된 비용을 확인하세요. 자동 재시도하지 않습니다." : "analyze_review_sources({resumePath,allowCloudVideoUpload:true})로 다음 1개 단계를 계속하세요.",
   };
 }
 export function fullReviewStatus(config, resumePath) { const loaded = loadFullReviewAnalysis(config, resumePath); return summary(loaded.state, loaded.resumePath); }
 
+export async function refreshFullReviewStatus(config, api, resumePath) {
+  const loaded = loadFullReviewAnalysis(config, resumePath);
+  const release = lockAnalysis(config, loaded.state.analysisId);
+  try {
+    let { state, resumePath: latestPath } = loadFullReviewAnalysis(config, resumePath);
+    assertCheckpointAuthority(config, state);
+    const operation = state.inFlight;
+    if (![REVIEW_STORY_TRANSPORT, REVIEW_NATIVE_TRANSPORT].includes(operation?.transport)
+        || operation.transport === REVIEW_STORY_TRANSPORT && !operation.jobId) return summary(state, latestPath);
+    try {
+      const job = operation.transport === REVIEW_STORY_TRANSPORT
+        ? await storyClient(config, api).read(operation.jobId, { requestId: operation.operationId, apiScope: operation.apiScope })
+        : await nativeClient(config, api).read(operation.stage, { ...operation, requestId: operation.operationId,
+          onCheckpoint: async metadata => {
+            assertCheckpointAuthority(config, state); Object.assign(operation, metadata);
+            if (operation.mediaReference) (state.mediaReferences ||= {})[operation.chunkId] = operation.mediaReference;
+            latestPath = snapshot(config, state);
+          } });
+      assertCheckpointAuthority(config, state);
+      operation.jobStatus = job.status;
+      if (job.status === "completed") {
+        if (!job.result || typeof job.result !== "object" || Array.isArray(job.result)) throw fail("REVIEW_STORY_RESULT_MISSING", "저장된 줄거리 결과가 없습니다.");
+        const result = operation.transport === REVIEW_STORY_TRANSPORT ? job.result
+          : unwrapReviewNativeJobResult(operation.stage, job.result, operation.mediaReference);
+        upsertStageReceipt(state, result, operation.operationId, operation.stage, operation.chunkId);
+        state.pendingStageResult = safeStageResult(result);
+      }
+      latestPath = snapshot(config, state);
+    } catch (error) {
+      state.error = { code: error.code || error.errorCode || "REVIEW_JOB_READ_FAILED", message: String(error.message || error) };
+      latestPath = snapshot(config, state);
+    }
+    return summary(state, latestPath);
+  } finally { release(); }
+}
+
 // This limits only the editing candidate list, never the full story/transcript
 // evidence. All native analysis remains in the original immutable handle.
 export function selectReviewPlanningCatalog(handle, requestedIds) {
@@ -188,7 +288,8 @@ export async function runFullReviewAnalysis({ config, api, args, companionJson,
     const health = await companionJson(config, "/health", undefined, 15000);
     if (health.capabilities?.reviewSourceAnalysis !== true || health.capabilities?.reviewSourceChunks !== true || health.capabilities.reviewSourceChunkMaxDurationSec < 300 || health.capabilities.reviewSourceChunkMaxBytes < MAX_CHUNK_BYTES) throw fail("COMPANION_UPDATE_REQUIRED", "전체 영상·음성 분석 청크를 지원하는 로컬 처리기로 업데이트하세요. 대표 프레임으로 우회하지 않습니다.");
     const state = { kind: KIND, version: 1, analysisId: randomUUID(), revision: 0, stage: "analyzing", workTitle: args.workTitle || "",
-      sources: [], chunks: [], analyses: {}, verifications: {}, receipts: [], warnings: ["전체 구간을 압축 영상+오디오로 분석하고 서사 주장을 실제 원본 구간으로 재검증합니다. 공개 권리와 최종 해석은 사람이 확인해야 합니다."], uploadConsent: true };
+      sources: [], chunks: [], analyses: {}, verifications: {}, receipts: [], mediaReferences: {}, authorityBinding: authorityBinding(config),
+      warnings: ["전체 구간을 압축 영상+오디오로 분석하고 서사 주장을 실제 원본 구간으로 재검증합니다. 공개 권리와 최종 해석은 사람이 확인해야 합니다."], uploadConsent: true };
     const fingerprints = args.sources.map(source => source.kind === "local" ? inspectReviewLocalFile(source.videoPath) : null);
     for (const [index, input] of args.sources.entries()) {
       const id = `review-${randomUUID().slice(0, 8)}`;
@@ -209,16 +310,27 @@ export async function runFullReviewAnalysis({ config, api, args, companionJson,
   let state, resumePath;
   try {
     ({ state, resumePath } = loadFullReviewAnalysis(config, args.resumePath));
-    validateReviewSources(state.sources);
+    assertCheckpointAuthority(config, state);
     if (state.stage === "complete") return summary(state, resumePath);
+    if (state.reviewRequired) return { ...summary(state, resumePath), requiresExplicitRetryApproval: false };
     if (state.inFlight || state.stage === "blocked") {
+      if ([REVIEW_STORY_TRANSPORT, REVIEW_NATIVE_TRANSPORT].includes(state.inFlight?.transport) || state.pendingStageResult) {
+        if (!state.inFlight || !["analyzing", "synthesizing", "verifying"].includes(state.inFlight.stage)
+            || state.inFlight.transport === REVIEW_STORY_TRANSPORT && state.inFlight.stage !== "synthesizing") throw fail("REVIEW_JOB_STATE_INVALID", "저장된 작업 단계가 다릅니다.");
+        state.stage = state.inFlight.stage;
+        delete state.error;
+      } else {
       if (args.retryFailedStage !== true) return { ...summary(state, resumePath), requiresExplicitRetryApproval: true };
       state.stage = state.failedStage || state.inFlight?.stage || "analyzing";
       delete state.inFlight; delete state.error;
+      }
       resumePath = snapshot(config, state);
     }
     const refreshed = new Set();
     const getMedia = async (chunk, expectedSha256) => {
+      // A known server job / saved result does not need the local source. Only
+      // a genuinely new media transfer or explicit legacy recheck reads it.
+      validateReviewSources(state.sources);
       const index = state.sources.findIndex(source => source.id === chunk.sourceId);
       try { return await videoChunk(config, companionJson, state.sources[index], chunk, expectedSha256); }
       catch (error) {
@@ -232,41 +344,87 @@ export async function runFullReviewAnalysis({ config, api, args, companionJson,
       if (!onProgress) return;
       try { await onProgress(summary(state, resumePath)); } catch { /* Progress delivery cannot replay/abort an accepted paid operation. */ }
     };
-    const charge = async (stage, chunkId, route, body) => {
-      state.inFlight = { stage, chunkId, operationId: randomUUID() }; state.failedStage = stage;
+    const charge = async (stage, chunkId, body, options = {}) => {
+      assertCheckpointAuthority(config, state);
+      const existing = state.inFlight;
+      if (existing && (existing.stage !== stage || existing.chunkId !== chunkId)) throw fail("REVIEW_JOB_STATE_INVALID", "체크포인트의 작업 구간이 다릅니다.");
+      if (state.pendingStageResult) return state.pendingStageResult;
+      state.inFlight = existing || { stage, chunkId, operationId: randomUUID(),
+        ...(stage === "analyzing" ? { mediaDescriptor: mediaDescriptor(body), priorContext: body.priorContext || "" } : {}) }; state.failedStage = stage;
       resumePath = snapshot(config, state);
       await progress();
       let response;
-      try { response = await api.request(route, { method: "POST", body: { ...body, costEventId: state.inFlight.operationId }, timeoutMs: 600000 }); }
-      catch (error) { state.receipts.push(receipt(error, stage, chunkId)); throw error; }
-      state.receipts.push(receipt(response, stage, chunkId));
+      const operationId = state.inFlight.operationId;
+      try {
+        response = stage === "synthesizing"
+          ? await storyClient(config, api).run(body, {
+            requestId: operationId, ...(existing ? { transport: existing.transport, jobId: existing.jobId, apiScope: existing.apiScope } : {}),
+            onSubmissionAttempt: async metadata => { Object.assign(state.inFlight, metadata); resumePath = snapshot(config, state); },
+            onJobAccepted: async metadata => { Object.assign(state.inFlight, metadata); resumePath = snapshot(config, state); },
+          })
+          : await nativeClient(config, api).run(stage, body, { ...state.inFlight, requestId: operationId,
+            // A resumed operation owns its exact reference and origin. Never
+            // repair a damaged/missing binding from the analysis-wide cache.
+            ...(!existing && options.mediaReference ? { mediaReference: options.mediaReference,
+              apiScope: state.authorityBinding.apiScope } : {}),
+            getLegacyMedia: options.getLegacyMedia,
+            onCheckpoint: async metadata => {
+              assertCheckpointAuthority(config, state); Object.assign(state.inFlight, metadata);
+              if (state.inFlight.mediaReference) (state.mediaReferences ||= {})[chunkId] = state.inFlight.mediaReference;
+              resumePath = snapshot(config, state);
+            },
+          });
+      }
+      catch (error) {
+        if (stage === "synthesizing") upsertStoryReceipt(state, error, operationId);
+        else upsertStageReceipt(state, error, operationId, stage, chunkId);
+        throw error;
+      }
+      assertCheckpointAuthority(config, state);
+      if (stage === "synthesizing") upsertStoryReceipt(state, response, operationId);
+      else upsertStageReceipt(state, response, operationId, stage, chunkId);
+      if (state.inFlight.transport) state.inFlight.jobStatus = "completed";
       state.pendingStageResult = safeStageResult(response);
+      // Commit received output before validation/application can fail or MCP exits.
+      resumePath = snapshot(config, state);
       return response;
     };
     for (let step = 0; step < (args.maxSteps ?? 1); step++) {
       if (state.stage === "analyzing") {
         const chunk = state.chunks.find(item => !state.analyses[item.chunkId]);
         if (!chunk) { state.stage = "synthesizing"; resumePath = snapshot(config, state); step--; continue; }
-        const media = await getMedia(chunk);
-        media.workTitle = state.workTitle;
-        const previous = Object.values(state.analyses).filter(item => item.sourceId === chunk.sourceId && item.startMs < chunk.startMs).sort((a, b) => b.startMs - a.startMs)[0];
-        if (previous) media.priorContext = JSON.stringify({ previousSummary: previous.summary, observedCharacters: previous.characters }).slice(0, 12000);
-        const response = await charge("analyzing", chunk.chunkId, "/api/tracker/review/analyze-chunk", media);
+        let media;
+        if (state.inFlight?.transport === REVIEW_NATIVE_TRANSPORT || state.pendingStageResult) {
+          media = state.inFlight.mediaDescriptor;
+          if (!media?.chunk || media.chunk.chunkId !== chunk.chunkId) throw fail("REVIEW_MEDIA_CHECKPOINT_INVALID", "저장된 미디어 구간 정보가 없습니다. 다시 인코딩하거나 업로드하지 않습니다.");
+        } else {
+          media = await getMedia(chunk); media.workTitle = state.workTitle;
+          const previous = Object.values(state.analyses).filter(item => item.sourceId === chunk.sourceId && item.startMs < chunk.startMs).sort((a, b) => b.startMs - a.startMs)[0];
+          if (previous) media.priorContext = JSON.stringify({ previousSummary: previous.summary, observedCharacters: previous.characters }).slice(0, 12000);
+        }
+        const response = await charge("analyzing", chunk.chunkId, state.inFlight?.transport === REVIEW_NATIVE_TRANSPORT
+          ? state.inFlight.jobId ? null : { priorContext: state.inFlight.priorContext || "" } : media);
         state.analyses[chunk.chunkId] = checkedAnalysis(response, chunk, media);
       } else if (state.stage === "synthesizing") {
         const body = { sources: reviewPublicSources(state.sources), chunks: Object.values(state.analyses), workTitle: state.workTitle };
         textBudget(body);
-        state.storyResult = await charge("synthesizing", "", "/api/tracker/review/synthesize-story", body);
+        state.storyResult = await charge("synthesizing", "", body);
         state.verifyChunkIds = verificationGroups(state);
         state.stage = "verifying";
       } else if (state.stage === "verifying") {
         const id = state.verifyChunkIds.find(chunkId => !state.verifications[chunkId]);
         if (!id) { state.stage = "finalizing"; step--; continue; }
         const chunk = state.chunks.find(item => item.chunkId === id), analyzed = state.analyses[id];
-        const media = await getMedia(chunk, analyzed.sha256);
-        const response = await charge("verifying", id, "/api/tracker/review/verify-evidence", { story: state.storyResult.story, chunks: Object.values(state.analyses), chunk: media });
-        if (response.chunkId !== id || !Array.isArray(response.verdicts) || !response.verdicts.length || response.verdicts.some(item => item.status !== "supported")) throw fail("REVIEW_ORIGINAL_VERIFICATION_FAILED", "원본 재검증에서 모순되거나 근거가 부족한 주장이 발견되었습니다. 전체 이해 완료나 자동 기획으로 진행하지 않습니다. 사용자가 줄거리·근거를 검토해야 합니다.");
+        const response = await charge("verifying", id, state.inFlight?.jobId ? null
+          : { story: state.storyResult.story, chunks: Object.values(state.analyses), chunkId: id },
+        { mediaReference: state.mediaReferences?.[id], getLegacyMedia: async () => ({ ...await getMedia(chunk, analyzed.sha256), workTitle: state.workTitle }) });
+        if (response.chunkId !== id || !Array.isArray(response.verdicts) || !response.verdicts.length
+            || response.verdicts.some(item => !["supported", "contradicted", "insufficient"].includes(item.status))) throw fail("REVIEW_ORIGINAL_VERIFICATION_INVALID", "저장된 원본 재검증 결과가 불완전합니다. 다시 과금하지 않습니다.");
         state.verifications[id] = response;
+        if (response.verdicts.some(item => item.status !== "supported")) {
+          state.reviewRequired = true;
+          throw fail("REVIEW_ORIGINAL_VERIFICATION_FAILED", "원본 재검증에서 모순되거나 근거가 부족한 주장이 발견되었습니다. 판정과 비용은 저장했습니다. 자동 재검증·전체 이해 완료·자동 기획으로 진행하지 않으며 사용자의 검토가 필요합니다.");
+        }
       } else if (state.stage === "finalizing") {
         const completed = { kind: "aimakeall-review-sources", version: 1, analysisScope: "full", analysisId: state.analysisId,
           sources: state.sources, sourceCatalog: Object.values(state.analyses).flatMap(chunk => chunk.sceneCatalog), globalStory: state.storyResult.story,
@@ -290,13 +448,18 @@ export async function runFullReviewAnalysis({ config, api, args, companionJson,
     return summary(state, resumePath);
   } catch (error) {
     if (!state) throw error;
+    // Never attach another account's saved costs/results to the caller or write
+    // through its journal after PAT/server changes (including mid-request).
+    assertCheckpointAuthority(config, state);
     state.failedStage ||= state.stage; state.stage = "blocked";
     state.error = { code: error.errorCode || error.code || "REVIEW_FULL_ANALYSIS_FAILED", message: String(error.message || error) };
-    if (state.pendingStageResult) {
+    if (state.pendingStageResult && state.inFlight?.transport !== REVIEW_STORY_TRANSPORT) {
       state.failedStageResultPath = savePayloadHandle(config.stateDir, { kind: "aimakeall-review-failed-stage", version: 1, analysisId: state.analysisId, stage: state.failedStage, result: state.pendingStageResult }, "review-failed-stage").filePath;
-      delete state.pendingStageResult;
+      // Keep the received result in the journal too: a restart must apply it,
+      // never repeat the paid request (including legacy successful responses).
     }
     resumePath = snapshot(config, state);
-    return { ...summary(state, resumePath), requiresExplicitRetryApproval: true };
+    return { ...summary(state, resumePath), requiresExplicitRetryApproval: !state.reviewRequired
+      && ![REVIEW_STORY_TRANSPORT, REVIEW_NATIVE_TRANSPORT].includes(state.inFlight?.transport) };
   } finally { release(); }
 }