creator-editing-studio 1.4.0 → 1.4.2

package/template/preview/server.mjs

@@ -21,7 +21,7 @@ import {McpServer} from '@modelcontextprotocol/sdk/server/mcp.js';
 import {StdioServerTransport} from '@modelcontextprotocol/sdk/server/stdio.js';
 import {registerAppResource, registerAppTool, RESOURCE_MIME_TYPE} from '@modelcontextprotocol/ext-apps/server';
 import {z} from 'zod';
-import {buildManifest, checkPage, compileEdit, configFor, HERE, PAGE_LIMIT, PUBLIC, playerHtml, PROXY_TIERS, SRC, STUDIO} from './lib.mjs';
+import {buildManifest, checkPage, compileEdit, configFor, HERE, PAGE_LIMIT, PUBLIC, playerHtml, playerJs, PROXY_TIERS, shellHtml, SRC, STUDIO} from './lib.mjs';
 
 const CONFIG = join(HERE, 'current.json');
 const cfg = () => JSON.parse(readFileSync(CONFIG, 'utf8'));
@@ -86,6 +86,9 @@ let lastBuilt = null;
 let readyBuilt = null;
 let pageHashes = {};
 const deltaFor = (b) => b && {...b.data, files: Object.fromEntries(Object.entries(b.data.files).filter(([k]) => pageHashes[k] !== b.hashes[k]))};
+/** What every result carries since the shell (lib.mjs shellHtml): the edit, all its files, and the player itself. */
+let shell = '';
+const lpFor = (b) => b && {...deltaFor(b), ui: playerJs(uiHtml)};
 /** The newest preview_edit call. Each page carries the open that made it, so old players can see they are old. */
 let opens = 0;
 let latest = null;
@@ -124,9 +127,7 @@ function checkNote(report) {
 
 /** The page the app loads at startup, before any open: no video, only a line saying the preview opens below. */
 async function startupPage() {
-  if (!uiHtml) [uiHtml, uiSig] = [await playerHtml(), 'built'];
-  const data = {open: null, version: 0, canUndo: false, project: '', edit: '', composition: '', error: 'Opening the preview… it appears in the next card below.', code: null, files: {}};
-  return uiHtml.replace('<head>', `<head><script>window.__LP_DATA=${JSON.stringify(data)}</script>`);
+  return (shell ||= await shellHtml());
 }
 
 /** The player page with the current edit and its footage inside it. `extra`: more files under assets/ to pack. */
@@ -168,6 +169,7 @@ async function page(extra = []) {
     const mb = (html.length / 1e6).toFixed(1);
     error = `This edit's preview is ${mb} MB even with small copies — the chat can only take ${PAGE_LIMIT / 1e6} MB. Use fewer cutout frames or shorter clips in the edit, then open the preview again.`;
     code = null;
+    lastBuilt = {data: {open: latest, version, canUndo: false, project: c.project, edit: c.edit, composition: c.composition, error, code, files: {}}, hashes: {}};
     html = uiHtml.replace('<head>', `<head><script>window.__LP_DATA=${JSON.stringify({open: latest, version, canUndo: false, project: c.project, edit: c.edit, composition: c.composition, error, code, files: {}}).replace(/</g, '\\u003c')}</script>`);
   }
   const mb = (html.length / 1e6).toFixed(1);
@@ -202,8 +204,9 @@ const addPage = (n) =>
         text: await (async () => {
           // Before any open, the only fetch is the app's own at startup, and it keeps that copy for the first open of
           // the chat — so it must never be a video (2026-11-05: a different video showed twice for the edit asked for).
-          const html = !opens ? await startupPage() : (ready ?? (await page()));
-          pageHashes = !opens ? {} : ((ready ? readyBuilt : lastBuilt)?.hashes ?? {});
+          // Always the shell: the player and the edit come inside each preview_edit result (lib.mjs shellHtml).
+          const html = await startupPage();
+          pageHashes = {};
           fetched.add(n);
           appendFileSync(join(HERE, '.reads.log'), `${new Date().toISOString()} FETCHED by the chat: slot ${n}, ${(html.length / 1e6).toFixed(1)}MB\n`);
           return html;
@@ -260,7 +263,55 @@ const previewTool = registerAppTool(
       addPage(slot);
       previewTool.update({_meta: uiMeta(slot)});
     }, 50);
-    return {content: [{type: 'text', text: `Live preview of ${c.project} (version ${v}) sent to the chat, with this version's edit inside the result.${checkNote(report)} Before telling the person it's ready, check read_widget_context says "${c.project} v${v}".`}], structuredContent: {project: c.project, version: v, check: report, open: latest}, _meta: {lp: deltaFor(readyBuilt)}};
+    return {content: [{type: 'text', text: `Live preview of ${c.project} (version ${v}) sent to the chat, with this version's edit inside the result.${checkNote(report)} Before telling the person it's ready, check read_widget_context says "${c.project} v${v}".`}], structuredContent: {project: c.project, version: v, check: report, open: latest}, _meta: {lp: lpFor(readyBuilt)}};
+  },
+);
+
+/*
+ * SAVING IS A TOOL, NOT A NOTE (2026-11-06). The person's on-video changes (fonts, colours, icons, moves) used to
+ * reach the edit only if Claude copied a JSON out of a hidden note into tweaks.json — nothing checked it. Now the
+ * player calls this itself when the chat lets it (an app call), and otherwise asks Claude to call it with the JSON;
+ * either way it answers a fingerprint the player (and Claude) compare with what was sent, and the next card shows
+ * "your changes are kept" or "didn't save" (ui/app.tsx). Same fingerprint both sides: fnv() over the JSON text.
+ */
+const fnv = (t) => {
+  let h = 0x811c9dc5;
+  for (let i = 0; i < t.length; i++) h = Math.imul(h ^ t.charCodeAt(i), 0x01000193) >>> 0;
+  return h.toString(36);
+};
+registerAppTool(
+  server,
+  'preview_save',
+  {
+    title: 'Save the preview adjustments',
+    description:
+      "Write the person's live-preview adjustments (fonts, colours, icons, moves, replaced files) into the video's tweaks.json — the render reads the same file. " +
+      'Call it when a message from the live preview asks you to, passing the JSON exactly as given. It answers a fingerprint: it must equal the one the message names; if not, call it again with the exact JSON.',
+    inputSchema: {
+      tweaks: z.string().describe('The adjustments JSON, exactly as the live preview gave it.'),
+      video: z.string().optional().describe('The video folder name; defaults to the one the preview last showed.'),
+    },
+    _meta: {ui: {resourceUri: uriFor(0), visibility: ['model', 'app']}},
+  },
+  async ({tweaks, video}) => {
+    const project = video ?? cfg().project;
+    if (!/^[a-z0-9][a-z0-9-]*$/.test(project ?? '')) return {content: [{type: 'text', text: `"${project}" is not a video name.`}], isError: true};
+    let parsed;
+    try {
+      parsed = JSON.parse(tweaks);
+    } catch (e) {
+      return {content: [{type: 'text', text: `Not saved: that is not valid JSON (${e.message}). Pass the adjustments exactly as the preview gave them.`}], isError: true};
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return {content: [{type: 'text', text: 'Not saved: the adjustments must be a JSON object.'}], isError: true};
+    const dir = videoDir(project);
+    if (!existsSync(dir)) return {content: [{type: 'text', text: `Not saved: there is no src/videos/${project}.`}], isError: true};
+    const text = JSON.stringify(parsed);
+    writeFileSync(join(dir, 'tweaks.json'), JSON.stringify(parsed, null, 2) + '\n');
+    const hash = fnv(text);
+    const count = Object.keys(parsed).length;
+    log(`saved ${count} adjusted piece(s) for ${project}: #${hash}`);
+    appendFileSync(join(HERE, '.reads.log'), `${new Date().toISOString()} SAVED ${project} #${hash} (${count})\n`);
+    return {content: [{type: 'text', text: `Saved ${count} adjusted piece(s) to src/videos/${project}/tweaks.json — fingerprint #${hash}.`}], structuredContent: {project, hash, count}};
   },
 );