@lalalic/markcut 3.2.14 → 3.2.15

package/tests/mcp-preview.test.ts

@@ -1,165 +1,76 @@
-import { describe, expect, it } from "vitest";
-import { mkdtempSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import vm from "node:vm";
-import {
-  buildPreviewHtml,
-  buildPreviewResourceResult,
-  PLAYER_ORIGIN,
-  RESOURCE_MIME_TYPE,
-  RESOURCE_URI,
-  reviewMessage,
-  reviewResult,
-  validateMarkdownPath,
-} from "../src/mcp/preview.mjs";
-import { buildPreviewBridgeScript } from "../src/mcp/bridge.mjs";
-
-describe("MarkCut MCP Markdown preview", () => {
-  it("requires an absolute .md path", () => {
-    expect(() => validateMarkdownPath("notes.md")).toThrow(/absolute/);
-    expect(() => validateMarkdownPath("/tmp/notes.txt")).toThrow(/Markdown/);
-  });
-
-  it("builds a video-player review UI instead of rendering Markdown", () => {
-    const html = buildPreviewHtml();
-    expect(html).toContain('id="video-player"');
-    expect(html).toContain("Review video");
-    expect(html).toContain("Approve");
-    expect(html).toContain("Request changes");
-    expect(html).toContain("ui/notifications/tool-result");
-    expect(html).toContain("previewUrl");
-    expect(html).not.toContain("<article>");
-  });
-
-  it("returns Codex-compatible private no-cache resource metadata", () => {
-    const result = buildPreviewResourceResult();
-    expect(result.ttlMs).toBe(0);
-    expect(result.cacheScope).toBe("private");
-    expect(result.contents).toHaveLength(1);
-    expect(result.contents[0]).toMatchObject({
-      uri: RESOURCE_URI,
-      mimeType: RESOURCE_MIME_TYPE,
-    });
-    expect(result.contents[0].text).toContain("ui/initialize");
-    expect(result.contents[0].text).toContain("ui/notifications/initialized");
-    expect(result.contents[0]._meta.ui.csp.frameDomains).toEqual([PLAYER_ORIGIN]);
-  });
-
-  it("returns approved", () => {
-    expect(reviewResult("approved")).toEqual({ decision: "approved" });
-  });
-
-  it("requires non-empty feedback for requested changes", () => {
-    expect(() => reviewResult("changes_requested", "  ")).toThrow(/feedback is required/);
-    expect(reviewResult("changes_requested", " Fix the title ")).toEqual({
-      decision: "changes_requested", feedback: "Fix the title",
-    });
-  });
-
-  it("formats decisions as an MCP Apps ui/message notification", () => {
-    expect(reviewMessage({ decision: "approved" })).toEqual({
-      jsonrpc: "2.0",
-      method: "ui/message",
-      params: { role: "user", content: [{ type: "text", text: '{"decision":"approved"}' }] },
-    });
-    expect(reviewMessage({ decision: "changes_requested", feedback: "Fix the title" }).params.content[0].text)
-      .toBe('{"decision":"changes_requested","feedback":"Fix the title"}');
-  });
-
-  it("performs the MCP Apps handshake and awaits a successful submit", async () => {
-    const harness = createBridgeHarness();
-    harness.run();
-    expect(harness.messages[0]).toEqual({
-      jsonrpc: "2.0",
-      id: 1,
-      method: "ui/initialize",
-      params: {
-        appInfo: { name: "Markcut Preview", version: "1.1.0" },
-        appCapabilities: {},
-        protocolVersion: "2026-01-26",
-      },
-    });
-    expect(harness.messages.some((message) => message.method === "ui/notifications/initialized")).toBe(false);
-    harness.respond({
-      id: 1,
-      result: {
-        protocolVersion: "2026-01-26",
-        hostInfo: { name: "test-host", version: "1" },
-        hostCapabilities: {},
-        hostContext: {},
-      },
-    });
-    await tick();
-    expect(harness.messages[1]).toMatchObject({ method: "ui/notifications/initialized" });
-
-    harness.toolResult({ path: "/tmp/video.md", previewUrl: PLAYER_ORIGIN + "/" });
-    await tick();
-    expect(harness.elements.player.src).toBe(PLAYER_ORIGIN + "/");
-    expect(harness.elements.pathLabel.textContent).toBe("/tmp/video.md");
-
-    harness.elements.approve.onclick();
-    expect(harness.messages[2]).toMatchObject({ id: 2, method: "tools/call" });
-    expect(harness.messages).not.toContainEqual(expect.objectContaining({ method: "ui/message" }));
-    harness.respond({ id: 2, result: { structuredContent: { decision: "approved" } } });
-    await tick();
-    expect(harness.messages[3]).toMatchObject({ method: "ui/message" });
-    expect(new Set(harness.messages.filter((message) => "id" in message).map((message) => message.id)).size).toBe(3);
-  });
-
-  it("surfaces submit errors without sending a decision message and rejects invalid bridge messages", async () => {
-    const harness = createBridgeHarness();
-    harness.run();
-    harness.dispatch({ source: {}, data: { jsonrpc: "2.0", id: 1, result: {} } });
-    expect(harness.elements.status.textContent).toBe("");
-    harness.respond({ id: 1, result: {} });
-    await tick();
-    harness.elements.changes.onclick();
-    expect(harness.elements.status.textContent).toBe("Feedback is required.");
-    harness.elements.feedback.value = "Fix the title";
-    harness.elements.changes.onclick();
-    harness.respond({ id: 2, error: { message: "submit failed" } });
-    await tick();
-    expect(harness.elements.status.textContent).toBe("submit failed");
-    expect(harness.messages.some((message) => message.method === "ui/message")).toBe(false);
-  });
-});
-
-function tick() {
-  return new Promise((resolve) => setTimeout(resolve, 0));
-}
-
-function createBridgeHarness() {
-  const messages: any[] = [];
-  const listeners: ((event: any) => void)[] = [];
-  const element = (value = "") => ({ value, textContent: "", innerHTML: "", onclick: undefined as (() => void) | undefined, focus() {} });
-  const elements = {
-    feedback: element(),
-    status: element(),
-    player: element(),
-    pathLabel: element(),
-    approve: element(),
-    changes: element(),
-  };
-  const parent = { postMessage(message: any) { messages.push(message); } };
-  const document = {
-    getElementById(id: string) {
-      if (id === "feedback") return elements.feedback;
-      if (id === "status") return elements.status;
-      if (id === "video-player") return elements.player;
-      if (id === "path-label") return elements.pathLabel;
-      if (id === "approve") return elements.approve;
-      return elements.changes;
-    },
-  };
-  const window = { parent, addEventListener(_type: string, listener: (event: any) => void) { listeners.push(listener); } };
-  const context = vm.createContext({ window, document, setTimeout, fetch: async () => ({ ok: true, json: async () => ({ ready: true }) }) });
-  return {
-    messages,
-    elements,
-    run() { vm.runInContext(buildPreviewBridgeScript("markcut.preview.submit"), context); },
-    dispatch(event: any) { listeners.forEach((listener) => listener(event)); },
-    respond(message: any) { this.dispatch({ source: parent, data: { jsonrpc: "2.0", ...message } }); },
-    toolResult(structuredContent: any) { this.dispatch({ source: parent, data: { jsonrpc: "2.0", method: "ui/notifications/tool-result", params: { result: { structuredContent } } } }); },
-  };
-}
+import {describe,it,expect} from 'vitest';
+process.env.NEOY_PUBLIC_ORIGIN = 'https://neoy.example.test';
+import {buildPreviewHtml,buildPreviewResourceResult,RESOURCE_URI,LEGACY_RESOURCE_URIS,validateMarkdownPath,reviewResult,getPreviewMedia,readPreviewAudio,withPreviewAudio} from '../src/mcp/preview.mjs';
+import {buildPreviewBridgeScript} from '../src/mcp/bridge.mjs';
+import {mkdtemp,writeFile,rm} from 'node:fs/promises';
+import {tmpdir} from 'node:os';
+import {join} from 'node:path';
+describe('Markcut Remotion MCP App',()=>{
+ it('requires absolute Markdown path',()=>{expect(()=>validateMarkdownPath('a.md')).toThrow(/absolute/);expect(()=>validateMarkdownPath('/tmp/a.txt')).toThrow(/Markdown/);});
+ it('loads the React Remotion bundle from remote HTTPS',()=>{
+  const html=buildPreviewHtml();
+  expect(html).toContain('id="remotion-root"');
+  expect(html).toContain('id="player-version"');
+  expect(html).toContain('>v24</span>');
+  expect(html).toContain('id="video-md-version"');
+  expect(html).toContain('https://neoy.example.test/files/_neoy/markcut/player/');
+  expect(html).not.toContain('id="remotion-bundle"');
+  expect(html.length).toBeLessThan(20000);
+  expect(html).not.toContain('<video id="video-player"');
+  expect(html).not.toContain('data:video/mp4');
+  expect(html).not.toContain('127.0.0.1');
+  expect(html).not.toContain('src="/player.js"');
+ });
+ it('registers latest resource at startup and aliases previous URIs',()=>{
+  for(const uri of [RESOURCE_URI,...LEGACY_RESOURCE_URIS]){
+   const result=buildPreviewResourceResult(uri);
+   expect(result.contents[0].uri).toBe(uri);
+   expect(result.contents[0].text).toContain('remotion-canvas');
+   expect(result.contents[0]._meta.ui.csp.connectDomains).toEqual([
+    'https://neoy.example.test',
+    'https://maps.googleapis.com', 'https://maps.gstatic.com',
+    'https://maps-api-v3.googleapis.com', 'https://routes.googleapis.com',
+   ]);
+   expect(result.contents[0]._meta.ui.csp.resourceDomains).toContain('https://maps.googleapis.com');
+  }
+ });
+ it('does not perform secondary tool calls for compiled scenes',()=>{
+  const script=buildPreviewBridgeScript();
+  expect(script).toContain('ui/notifications/tool-result');
+  expect(script).toContain("CustomEvent('markcut:revision'");
+  expect(script).toContain('data.compiled');
+  expect(script).not.toContain("'tools/call'");
+  expect(script).not.toContain('videoBase64');
+  expect(script).toContain('fetch(');
+  expect(script).toContain('/files/_neoy/markcut/revisions/');
+ });
+ it('prevents reading unregistered compiled scenes',()=>{
+  expect(()=>getPreviewMedia('a'.repeat(64))).toThrow(/Unknown or expired/);
+ });
+ it('includes a local audio track for Remotion playback',async()=>{
+  const dir=await mkdtemp(join(tmpdir(),'markcut-audio-'));
+  try {
+   await writeFile(join(dir,'clip.md'),'# video\naudio: sample.wav\n');
+   await writeFile(join(dir,'sample.wav'),Buffer.from([82,73,70,70]));
+   const media=await readPreviewAudio(join(dir,'clip.md'));
+   expect(media.audioSrc).toMatch(/^data:audio\/wav;base64,/);
+   expect(media.audioSrc).toContain('UklGRg==');
+   await writeFile(join(dir,'clip.md'),'# video\naudio: ../secret.wav\n');
+   await expect(readPreviewAudio(join(dir,'clip.md'))).rejects.toThrow(/audio must/);
+   await writeFile(join(dir,'clip.md'),'# video\n');
+   await writeFile(join(dir,'clip.wav'),Buffer.from([82,73,70,70]));
+   expect((await readPreviewAudio(join(dir,'clip.md'))).audioSrc).toContain('UklGRg==');
+  } finally {await rm(dir,{recursive:true,force:true});}
+ });
+ it('uses native MarkCut AudioLeaf as a background track without changing original duration',()=>{
+  const compiled={root:{id:'root',type:'root',isSeries:true,durationInSeconds:6,children:[{id:'scene',type:'component',durationInSeconds:6}]}};
+  const mixed=withPreviewAudio(compiled,'data:audio/wav;base64,QQ==');
+  expect(mixed.root.children[1]).toMatchObject({type:'audio',isBackground:true,start:0,end:6,volume:1});
+  expect(compiled.root.children).toHaveLength(1);
+  expect(mixed.root.durationInSeconds).toBe(6);
+ });
+ it('requires review feedback',()=>{
+  expect(reviewResult('approved')).toEqual({decision:'approved'});
+  expect(()=>reviewResult('changes_requested','')).toThrow(/feedback/);
+ });
+});

package/tests/mcp-remote-assets.test.ts

@@ -0,0 +1,59 @@
+import {describe,it,expect} from "vitest";
+import {externalizePreviewMedia,resolveMountedFile,resolvePreviewSource,resolvePreviewPath,publishPlayerBundle,publicOrigin,EXPORT_ROOT} from "../src/mcp/remote-assets.mjs";
+import {readFileSync,rmSync,writeFileSync,mkdirSync,mkdtempSync,symlinkSync,realpathSync} from "node:fs";
+import {join} from "node:path";
+import {tmpdir} from "node:os";
+const id="11111111-2222-4333-8444-555555555555";
+describe("NeoY backed preview files",()=>{
+  it("publishes generated media as persistent files under NeoY export root",()=>{
+    const input={root:{children:[
+      {type:"audio",src:"data:audio/wav;base64,UklGRg=="},
+      {type:"scene",children:[{type:"component",jsx:"<img src='data:image/svg+xml,%3Csvg%3E%3C%2Fsvg%3E' />"}]}
+    ]}};
+    try{
+      const {compiled,assets}=externalizePreviewMedia(input,id,"https://example.org");
+      expect(assets).toEqual(["0.wav","1.svg"]);
+      expect(compiled.root.children[0].src).toBe("https://example.org/files/_neoy/markcut/generated/"+id+"/0.wav");
+      expect(compiled.root.children[1].children[0].jsx).toContain("https://example.org/files/_neoy/markcut/generated/"+id+"/1.svg");
+      expect(readFileSync(join(EXPORT_ROOT,"generated",id,"0.wav")).toString("hex")).toBe("52494646");
+      expect(JSON.stringify(compiled)).not.toContain("data:");
+      expect(input.root.children[0].src).toContain("data:audio/");
+    }finally{rmSync(join(EXPORT_ROOT,"generated",id),{recursive:true,force:true});}
+  });
+  it("rejects a local HTTP media reference",()=>{
+    expect(()=>externalizePreviewMedia({src:"http://127.0.0.1:4571/asset"},id,"https://example.org")).toThrow(/HTTPS|local media URL/);
+  });
+  it("resolves files below NeoY mounts",()=>{
+    expect(resolveMountedFile("/tmp/vlog/README.md","https://example.org",{vlog:"/tmp/vlog"})).toBe("https://example.org/files/vlog/README.md");
+  });
+  it("maps video and image references relative to mounted markdown",()=>{
+    const url=resolvePreviewSource("./assets/shot.mp4","/tmp/vlog/runs/20260909","https://example.org",{vlog:"/tmp/vlog"});
+    expect(url).toBe("https://example.org/files/vlog/runs/20260909/assets/shot.mp4");
+    expect(()=>resolvePreviewSource("../secret.mp4","/tmp/vlog","https://example.org",{vlog:"/tmp/vlog"})).toThrow(/mounted root/);
+  });
+  it("resolves only allowlisted NeoY Markdown URLs to absolute files",()=>{
+    const base=mkdtempSync(join(tmpdir(),"markcut-mount-"));
+    const file=join(base,"video.md");
+    const outside=join(base,"..","secret.md");
+    writeFileSync(file,"# video");
+    symlinkSync("/etc/hosts",join(base,"escape.md"));
+    try{
+      const roots={vlog:base};
+      expect(resolvePreviewPath("https://example.org/files/vlog/video.md","https://example.org",roots)).toBe(realpathSync(file));
+      expect(resolvePreviewPath("/files/vlog/video.md","https://example.org",roots)).toBe(realpathSync(file));
+      expect(()=>resolvePreviewPath("https://other.org/files/vlog/video.md","https://example.org",roots)).toThrow(/Only NeoY/);
+      expect(()=>resolvePreviewPath("/files/vlog/escape.md","https://example.org",roots)).toThrow(/escapes/);
+      expect(()=>resolvePreviewPath("/files/_neoy/markcut/generated/a.md","https://example.org",roots)).toThrow(/Invalid/);
+    }finally{rmSync(base,{recursive:true,force:true});}
+  });
+  it("publishes hashed player script under NeoY exports",()=>{
+    const script=join(EXPORT_ROOT,"test-fixture.js");
+    mkdirSync(EXPORT_ROOT,{recursive:true});
+    writeFileSync(script,"console.log('test')");
+    try{
+      const url=publishPlayerBundle(script,"https://example.org");
+      expect(url).toMatch(/^https:\/\/example.org\/files\/_neoy\/markcut\/player\/[a-f0-9]{20}\.js$/);
+      expect(readFileSync(join(EXPORT_ROOT,"player",url.split("/").pop()!)).toString()).toBe("console.log('test')");
+    }finally{rmSync(script,{force:true});}
+  });
+});

package/tests/mcp-static-preview.test.ts

@@ -0,0 +1,69 @@
+import {describe,it,expect} from 'vitest';
+import {mkdtemp,writeFile,readFile,readdir,rm} from 'node:fs/promises';
+import {tmpdir} from 'node:os';
+import {join} from 'node:path';
+
+describe('stateless Markcut MCP cache',()=>{
+ it('reuses identical sources, preserves latest and retains ten previews without player processes',async()=>{
+  const run=await mkdtemp(join(tmpdir(),'markcut-static-'));
+  const prior=process.env.MARKCUT_EXPORT_ROOT;
+  const priorOrigin=process.env.NEOY_PUBLIC_ORIGIN;
+  process.env.NEOY_PUBLIC_ORIGIN='https://neoy.example.test';
+  process.env.MARKCUT_EXPORT_ROOT=join(run,'exports');
+  try{
+   const {ensureVideoPreview}=await import('../src/mcp/preview.mjs');
+   const input=join(run,'video.md');
+   await writeFile(join(run,'photo.png'),Buffer.from('initial-media-bytes'));
+   const versions=[];
+   for(let i=0;i<11;i++){
+    await writeFile(input,'# video\\nwidth:640 height:480 fps:30 layout:series\\n## Intro\\n- image src:photo.png duration:1 name:"Version '+i+'"\\n');
+    const stages:string[]=[];
+    const result=await ensureVideoPreview(input,{onProgress:(stage:string)=>stages.push(stage)});
+    if(i===0)expect(stages).toEqual([
+     'checking-cache','parsing-markdown','resolving-assets-and-generating-media',
+     'compiling-scenes','freezing-preview-assets','publishing-static-preview'
+    ]);
+    versions.push(result);
+    expect(result.compiledUrl).toContain('/files/_neoy/markcut/cache/'+result.contentHash+'.json');
+    expect(JSON.parse(await readFile(join(run,'.markcut/video/default/compiled.json'),'utf8'))).toBeTruthy();
+   }
+   expect((await readFile(input,'utf8'))).not.toContain('seed:');
+   const again=await ensureVideoPreview(input);
+   expect(again.contentHash).toBe(versions[10].contentHash);
+   const cache=await readdir(join(run,'.markcut/cache'));
+   expect(cache.filter(x=>x.endsWith('.json'))).toHaveLength(10);
+   expect(cache).not.toContain(versions[0].contentHash+'.json');
+   expect(cache).toContain(versions[1].contentHash+'.json');
+   const published=await readdir(join(run,'exports','cache'));
+   expect(published).toHaveLength(10);
+   expect(JSON.parse(await readFile(join(run,'.markcut/video/default/cache-index.json'),'utf8')).latest).toBe(versions[10].contentHash);
+   expect(JSON.parse(await readFile(join(run,'exports','cache',versions[1].contentHash+'.json'),'utf8'))).toBeTruthy();
+   const other=join(run,'other.md');
+   await writeFile(other,'# video\nwidth:640 height:480 fps:30 layout:series\n## Other\n- image src:photo.png duration:1\n');
+   const second=await ensureVideoPreview(other);
+   expect(second.contentHash).not.toBe(again.contentHash);
+   expect(await readdir(join(run,'.markcut/cache'))).toHaveLength(11);
+   expect(JSON.parse(await readFile(join(run,'.markcut/other/default/cache-index.json'),'utf8')).latest).toBe(second.contentHash);
+   const previousLatest=await readFile(join(run,'.markcut/video/default/compiled.json'),'utf8');
+   await writeFile(input,'# video\naudio: ../outside.wav\n');
+   await expect(ensureVideoPreview(input)).rejects.toThrow(/audio must/);
+   expect(await readFile(join(run,'.markcut/video/default/compiled.json'),'utf8')).toBe(previousLatest);
+   // Local source assets are published as immutable files, not live paths.
+   const media=join(run,'media.md'), photo=join(run,'photo2.png');
+   await writeFile(photo,Buffer.from('small-image-payload'));
+   await writeFile(media,'# video\nwidth:640 height:480 fps:30 layout:series\n## Photo\n- image src:photo2.png duration:1\n');
+   const mediaPreview=await ensureVideoPreview(media);
+   const mediaJson=await readFile(join(run,'exports','cache',mediaPreview.contentHash+'.json'),'utf8');
+   expect(mediaJson).toContain('/files/_neoy/markcut/generated/'+mediaPreview.contentHash+'/file-0.png');
+   expect(await readFile(join(run,'exports','generated',mediaPreview.contentHash,'file-0.png'))).toEqual(await readFile(photo));
+   await writeFile(photo,Buffer.from('different-image-payload'));
+   const modified=await ensureVideoPreview(media);
+   expect(modified.contentHash).not.toBe(mediaPreview.contentHash);
+   expect(await readFile(join(run,'exports','generated',mediaPreview.contentHash,'file-0.png'))).toEqual(Buffer.from('small-image-payload'));
+  }finally{
+   if(prior===undefined)delete process.env.MARKCUT_EXPORT_ROOT;else process.env.MARKCUT_EXPORT_ROOT=prior;
+   if(priorOrigin===undefined)delete process.env.NEOY_PUBLIC_ORIGIN;else process.env.NEOY_PUBLIC_ORIGIN=priorOrigin;
+   await rm(run,{recursive:true,force:true});
+  }
+ },20000);
+});