goatedit-mcp 1.1.11 → 1.1.13

package/bundle/goatedit-mcp.js

@@ -19841,7 +19841,7 @@ import crypto2 from "crypto";
 import http from "http";
 import fs3 from "fs";
 import path3 from "path";
-import { execFileSync } from "child_process";
+import { execFile, execFileSync } from "child_process";
 import os2 from "os";
 import { fileURLToPath } from "url";
 
@@ -20055,9 +20055,18 @@ var BASE_TOOLS = [
     },
     method: "deleteSequence"
   },
+  {
+    name: "list_projects",
+    description: "The person's saved GoatEdit projects, newest first: id, name, when last changed, and whether a connected tab has it open. Use an id with open_project to work on a project that is not open yet. Read-only.",
+    inputSchema: {
+      type: "object",
+      properties: { limit: { type: "number", description: "How many to list (default 30, at most 100)." } }
+    },
+    method: "listProjects"
+  },
   {
     name: "list_sequences",
-    description: "Every sequence in the project: id, name, whether it is the one open for editing, open in a tab, a nest (made by nest_clips) or top-level, its length, how many clips it holds, and the clips that play it. Every other tool edits the open sequence only \u2014 use this to find the id to pass to open_sequence.",
+    description: "Every sequence in the project: id, name, whether it is the one open for editing, open in a tab, a nest (made by nest_clips) or top-level, its length, how many clips it holds, and the clips that play it. Tools act on the open sequence unless they are given expectedSequenceId \u2014 pass one of these ids to read or edit another sequence without opening it (open_sequence moves the person's view; prefer expectedSequenceId).",
     inputSchema: { type: "object", properties: {} },
     method: "listSequences"
   },
@@ -21059,7 +21068,7 @@ var BASE_TOOLS = [
         clipId: CLIP_ID,
         type: {
           type: "string",
-          description: "Effect type: blur, invert, hue, saturation, brightness, contrast, exposure, grayscale, sepia, gradientMap, vignette, filmGrain, flicker, posterizeTime, lensDistortion, chromaticAberration, lensFlare, liquidGlass, opacityFx, colorCorrection, depthMap, gradientMap, glow, pixelDissolve, motionBlur, dropShadow, reflection, colorama, outline, echo, flutedGlass, lightRays, halftone, datamosh, roughenEdges, filmStock, halation, starGlow, filmDamage, lightLeak, thermal, colorBalance, duotone, levels, monochrome, channelMixer, dither, threshold, lensBlur, directionalBlur, spinBlur, zoomBlur, sharpen, cameraShake, bulge, twirl, ripple, waveWarp, polarCoords, turbulentDisplace, elasticGrid, gridSplit, cubify, glitch, vhs, ntsc, crtScreen, ledScreen, rgbSplit, jpegGlitch, ascii, macpaint, modulation, stripe, risograph, emboss, bevel, inkBleed, paperTexture, paperCutout, crossHatch, scatter, blobTracker, edgeGlow, pageTurn, lightSweep, deepGlow, twister, fill, grid, repeater, plus transform, layer3d, model3d and showcase. Call describe_effect with a type for its parameters, their ranges and what they do before setting anything but the obvious. An unknown name comes back with the full list."
+          description: "Effect type: blur, invert, hue, saturation, brightness, contrast, exposure, grayscale, sepia, gradientMap, vignette, filmGrain, flicker, posterizeTime, lensDistortion, chromaticAberration, lensFlare, liquidGlass, opacityFx, colorCorrection, depthMap, gradientMap, vegas, glow, pixelDissolve, motionBlur, dropShadow, reflection, colorama, outline, echo, flutedGlass, lightRays, halftone, datamosh, roughenEdges, filmStock, halation, starGlow, filmDamage, lightLeak, thermal, colorBalance, duotone, levels, monochrome, channelMixer, dither, threshold, fourColorGradient, lensBlur, boxBlur, directionalBlur, spinBlur, zoomBlur, sharpen, cameraShake, bulge, twirl, ripple, waveWarp, polarCoords, turbulentDisplace, elasticGrid, gridSplit, cubify, glitch, vhs, ntsc, crtScreen, ledScreen, rgbSplit, jpegGlitch, ascii, macpaint, modulation, stripe, risograph, emboss, bevel, inkBleed, paperTexture, paperCutout, crossHatch, scatter, blobTracker, edgeGlow, pageTurn, lightSweep, deepGlow, twister, fill, compositeOriginal, grid, repeater, plus transform, layer3d, model3d and showcase. Call describe_effect with a type for its parameters, their ranges and what they do before setting anything but the obvious. An unknown name comes back with the full list."
         },
         params: {
           type: "object",
@@ -21575,7 +21584,7 @@ var BASE_TOOLS = [
   },
   {
     name: "studio_tasks",
-    description: 'The work GoatEdit Studio has for you in this project. Studio makes a video in stages (brief, research, script, breakdown (the script cut into parts), moodboard, styleGuide (the design language every part follows), storyboard, edit plan, combine (the parts joined into the final edit plan), timeline, mix, QC, export, plus any the user added, whose ids start "x-" and whose document is {"notes": string, "points"?: string[]}); a stage opens once the stages it reads are approved, so several are often open at once. Each task is kind "write" (write that stage\'s JSON document: follow `role` as your system prompt, read `inputs`, follow `lessons` when present (what this user has asked for before), and if `previousDraft` is there, revise it using `note` and `problems`) or kind "run" (ask the tab to do it with studio_run_stage). Open tasks in one run do not depend on each other: hand each to its own subagent and do them side by side. When a task names an `agent`, the user wants that subagent or skill of yours on it: hand the task to the subagent with that name, or use the skill with that name. In a batch of reels each run has `batch` (reel number, name, avatar); stages listed in batch.filled are filled by Studio itself (the locked script, the pilot\'s look), so leave them. For each write task: studio_claim it first (the person sees your agent working on that stage), then studio_submit the document. The reply to a submit names the stages it opened; call studio_tasks again for them. Stages waiting for the person are listed under waitingForPerson \u2014 stop there and tell the user to approve them in the Studio panel.',
+    description: 'The work GoatEdit Studio has for you in this project. Studio makes a video in stages (brief, research, script, breakdown (the script cut into parts), moodboard, styleGuide (the design language every part follows), storyboard, edit plan, combine (the parts joined into the final edit plan), timeline, mix, QC, export, plus any the user added, whose ids start "x-" and whose document is {"notes": string, "points"?: string[]}); a stage opens once the stages it reads are approved, so several are often open at once. Each task is kind "write" (write that stage\'s JSON document: follow `role` as your system prompt, read `inputs`, follow `lessons` when present (what this user has asked for before), and if `previousDraft` is there, revise it using `note` and `problems`) or kind "run" (ask the tab to do it with studio_run_stage). Open tasks in one run do not depend on each other: hand each to its own subagent and do them side by side. When a task names an `agent`, the user wants that subagent or skill of yours on it: hand the task to the subagent with that name, or use the skill with that name. In a batch of reels each run has `batch` (reel number, name, avatar); stages listed in batch.filled are filled by Studio itself (the locked script, the pilot\'s look), so leave them. For each write task: studio_claim it first (the person sees your agent working on that stage), then studio_submit the document. The reply to a submit names the stages it opened; call studio_tasks again for them. Stages waiting for the person are listed under waitingForPerson \u2014 stop there and tell the user to approve them in the Studio panel, unless the user told you to approve them yourself (then studio_approve).',
     inputSchema: {
       type: "object",
       properties: {
@@ -21608,12 +21617,61 @@ var BASE_TOOLS = [
         runId: str("The run, from studio_tasks."),
         stage: str("The stage id."),
         document: { type: "object", description: "The stage's document, in the shape its role card gives." },
-        agent: str("Who wrote it, as in studio_claim.")
+        agent: str("Who wrote it, as in studio_claim."),
+        part: str("For a stage written part by part (the task lists `parts`): the part id. The document then holds only that part's beats (storyboard) or scenes (edit plan), and the part is checked and shown in the Studio gallery on its own.")
       },
       required: ["runId", "stage", "document"]
     },
     method: "studioSubmit"
   },
+  {
+    name: "studio_approve",
+    description: "Approve a Studio stage that is waiting for the person (waitingForPerson in studio_tasks), on their behalf. Only when the user told you to approve it, or to run Studio on their own without stopping: otherwise tell them it is waiting for them in the Studio panel. personSaid keeps what they told you in the run's log, so the panel shows who approved it and why. A stage with rival drafts needs pick; a stage written part by part approves every part waiting. The reply names the stages that opened.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        runId: str("The run, from studio_tasks."),
+        stage: str("The stage id."),
+        agent: str('Who is approving, shown in the log ("Claude Code").'),
+        personSaid: str(`The user's words that let you approve it, e.g. "do everything by yourself".`),
+        pick: num("With rival drafts: which one, 0-based.")
+      },
+      required: ["runId", "stage"]
+    },
+    method: "studioApprove"
+  },
+  {
+    name: "studio_send_back",
+    description: "Send a Studio stage in review back to whoever writes it, with what to change; it opens again with the note. Use it when a draft you are reviewing for the user is not good enough.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        runId: str("The run, from studio_tasks."),
+        stage: str("The stage id."),
+        note: str("What to change.")
+      },
+      required: ["runId", "stage", "note"]
+    },
+    method: "studioSendBack"
+  },
+  {
+    name: "studio_update_run",
+    description: `Change a Studio run under way, for the stages still to come (approved, left-out or running stages keep theirs): who writes each stage and who approves it (the same settings as studio_save_workflow; brief, moodboard, styleGuide and export stay approved by the person), and editSequenceId: a sequence the person already edited, for the timeline and qc stages to restyle in place instead of building a new one. With editSequenceId set, timeline and qc can take writer "outside": you edit that sequence over MCP and studio_submit the stage's document. null for editSequenceId goes back to a new sequence.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        runId: str("The run, from studio_tasks."),
+        stages: {
+          type: "object",
+          description: 'Stage id to { writer?, approver?: "person" | "auto", agent?, instructions?, tier?, review?, enabled? }.',
+          additionalProperties: { type: "object" }
+        },
+        editSequenceId: { type: ["string", "null"], description: "A sequence id from list_sequences, or null." }
+      },
+      required: ["runId"]
+    },
+    method: "studioUpdateRun"
+  },
   {
     name: "studio_run_stage",
     description: `Start a Studio stage the tab does itself: "timeline" (build the edit from the approved plan) or "qc" (check it), or a stage the workflow gives to Studio's agent in the tab. Returns at once; the work goes on in the tab and the panel shows it. Poll studio_tasks to see it finish.`,
@@ -21748,8 +21806,18 @@ var SEQUENCE_EDITS = /* @__PURE__ */ new Set([
   "setAudioMaster",
   "loopClip"
 ]);
+var SEQUENCE_READS = /* @__PURE__ */ new Set([
+  "getTimeline",
+  "getClips",
+  "renderFrame",
+  "lintTimeline",
+  "lintMotion",
+  "describeMotion",
+  "listCuts",
+  "exportRange"
+]);
 var EXPECTED_SEQUENCE = str(
-  "Optional guard: the sequence id this edit is meant for (from list_sequences). If the tab has a different sequence open, the call is refused instead of editing the wrong one."
+  "Optional: the sequence id (from list_sequences) this call reads or edits. It does not need to be open: the edit lands in that sequence and the tab stays on whatever sequence the person is looking at, so several agents can each work on their own sequence at once. Without it, the call acts on the open sequence."
 );
 var PLACING_EDITS = /* @__PURE__ */ new Set([
   "addClip",
@@ -21776,7 +21844,7 @@ var NEW_TRACK_ABOVE = str(
 );
 var NEW_TRACK_BELOW = str('With trackId "__new_track__": put the new track directly below this video track.');
 var TOOLS = BASE_TOOLS.map((tool) => {
-  if (!tool.method || !SEQUENCE_EDITS.has(tool.method)) return tool;
+  if (!tool.method || !(SEQUENCE_EDITS.has(tool.method) || SEQUENCE_READS.has(tool.method))) return tool;
   return {
     ...tool,
     inputSchema: {
@@ -21935,6 +22003,11 @@ function withRunProject(stepArgs, projectId) {
   if (typeof projectId !== "string" || !projectId || typeof stepArgs.projectId === "string") return stepArgs;
   return { ...stepArgs, projectId };
 }
+function withRunSequence(stepArgs, sequenceId, tool) {
+  if (typeof sequenceId !== "string" || !sequenceId || typeof stepArgs.expectedSequenceId === "string") return stepArgs;
+  if (!tool || !("expectedSequenceId" in (tool.inputSchema.properties ?? {}))) return stepArgs;
+  return { ...stepArgs, expectedSequenceId: sequenceId };
+}
 
 // src/tab-registry.ts
 function indexTabs(reports, isOpen) {
@@ -21945,6 +22018,23 @@ function indexTabs(reports, isOpen) {
   return index;
 }
 
+// src/open-project.ts
+var DEFAULT_EDITOR = "https://ai.goatedit.com";
+function editorUrl(origin, projectId) {
+  const url2 = new URL(origin || DEFAULT_EDITOR);
+  url2.pathname = "/";
+  url2.search = "";
+  url2.hash = "";
+  url2.searchParams.set("project", projectId);
+  url2.searchParams.set("via", "agent");
+  return url2.toString();
+}
+function openCommand(platform, url2) {
+  if (platform === "darwin") return ["open", [url2]];
+  if (platform === "win32") return ["cmd", ["/c", "start", "", url2]];
+  return ["xdg-open", [url2]];
+}
+
 // node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/client.js
 var ExperimentalClientTasks = class {
   constructor(_client) {
@@ -24444,7 +24534,7 @@ var VERSION = (() => {
   }
   return "0.0.0";
 })();
-var INSTRUCTIONS = `Edits a GoatEdit video project live in the user's browser tab at ai.goatedit.com. At the start of each new request from the user, call begin_request with the kind of edit, its style words and any reference videos, then get_style_profile for how this user edits; treat that style as defaults, the request wins. Call get_timeline before your first edit \u2014 clip ids change after every split, trim or delete, and a stale id is rejected. Each edit's reply carries timelineChanges (clips added, with their ids and placement; clips changed; ids removed), so take the next ids from there instead of reading the timeline again. get_timeline is lean by default; pass detail: "full" only when you need effect parameters, and trackId or from/to to read part of it. Several edits in a row go faster as one run_tools call. With more than one tab open, call list_connected_projects, then use_project to pick one. To work on several projects at once (one helper agent per video), do not use use_project \u2014 it moves every caller \u2014 but pass projectId on each call, or once on run_tools for all its steps. render_preview_frame and preview_media accept saveToDisk: true, which writes the frame to a file and returns its path instead of the image. If a tool reports the editor is not connected, ask the user to open ai.goatedit.com and switch on Local in the AI status menu.`;
+var INSTRUCTIONS = `Edits a GoatEdit video project live in the user's browser tab at ai.goatedit.com. At the start of each new request from the user, call begin_request with the kind of edit, its style words and any reference videos, then get_style_profile for how this user edits; treat that style as defaults, the request wins. Call get_timeline before your first edit \u2014 clip ids change after every split, trim or delete, and a stale id is rejected. Each edit's reply carries timelineChanges (clips added, with their ids and placement; clips changed; ids removed), so take the next ids from there instead of reading the timeline again. get_timeline is lean by default; pass detail: "full" only when you need effect parameters, and trackId or from/to to read part of it. Several edits in a row go faster as one run_tools call. With more than one tab open, call list_connected_projects, then use_project to pick one. To work on a project that is not open, find it with list_projects and call open_project. To work on several projects at once (one helper agent per video), do not use use_project \u2014 it moves every caller \u2014 but pass projectId on each call, or once on run_tools for all its steps. To read or edit a sequence other than the open one, do not call open_sequence \u2014 it moves the user's view \u2014 but pass expectedSequenceId on each call, or once on run_tools; the edit lands in that sequence while the user keeps working wherever they are. render_preview_frame and preview_media accept saveToDisk: true, which writes the frame to a file and returns its path instead of the image. If a tool reports the editor is not connected, ask the user to open ai.goatedit.com and switch on Local in the AI status menu.`;
 var MEDIA_TYPES = {
   ".mp4": { mime: "video/mp4", kind: "video" },
   ".m4v": { mime: "video/mp4", kind: "video" },
@@ -24701,6 +24791,8 @@ wss.on("error", () => {
 });
 var tabs = /* @__PURE__ */ new Map();
 var tabReports = /* @__PURE__ */ new Map();
+var tabOrigins = /* @__PURE__ */ new WeakMap();
+var lastEditorOrigin = process.env.GOATEDIT_EDITOR_URL || null;
 function reindexTabs() {
   tabs.clear();
   for (const [pid, r] of indexTabs(tabReports.values(), (s) => s.readyState === import_websocket.default.OPEN)) {
@@ -24809,6 +24901,10 @@ wss.on("connection", (ws, req) => {
     return;
   }
   console.error("[GoatEdit MCP] Browser editor connected via WebSocket");
+  if (req.headers.origin) {
+    tabOrigins.set(ws, req.headers.origin);
+    lastEditorOrigin = req.headers.origin;
+  }
   ws.on("message", (data) => {
     let message;
     try {
@@ -24968,8 +25064,31 @@ var LOCAL_HANDLERS = {
   list_connected_projects: async () => connectedProjects(),
   list_local_assets: async (args) => handleListLocalAssets(args),
   generate_voiceover: async (args, projectId) => handleGenerateVoiceover(args.text, projectId),
-  find_local_file: async (args) => handleFindLocalFile(args)
+  find_local_file: async (args) => handleFindLocalFile(args),
+  open_project: async (args) => handleOpenProject(args)
 };
+var OPEN_WAIT_MS = 45e3;
+async function handleOpenProject(args) {
+  const projectId = typeof args?.projectId === "string" ? args.projectId.trim() : "";
+  if (!projectId) throw new Error("Missing required argument: projectId (from list_projects).");
+  const open = tabs.get(projectId);
+  if (open && open.ws.readyState === import_websocket.default.OPEN) return { projectId, name: open.projectName, alreadyOpen: true };
+  const origin = [...tabReports.keys()].map((ws) => tabOrigins.get(ws)).find(Boolean) ?? lastEditorOrigin;
+  const url2 = editorUrl(origin, projectId);
+  const [cmd, cmdArgs] = openCommand(process.platform, url2);
+  await new Promise((resolve, reject) => {
+    execFile(cmd, cmdArgs, (err) => err ? reject(new Error(`Could not open the browser (${cmd}): ${err.message}. Open ${url2} by hand.`)) : resolve());
+  });
+  const deadline = Date.now() + OPEN_WAIT_MS;
+  while (Date.now() < deadline) {
+    const tab = tabs.get(projectId);
+    if (tab && tab.ws.readyState === import_websocket.default.OPEN) return { projectId, name: tab.projectName, opened: url2 };
+    await new Promise((r) => setTimeout(r, 500));
+  }
+  throw new Error(
+    `Opened ${url2}, but no tab reported project ${projectId} within ${OPEN_WAIT_MS / 1e3}s. The person may need to sign in, or switch on Local in the AI status menu of that tab. Check list_connected_projects again in a moment.`
+  );
+}
 async function callLocal(method, args, projectId) {
   await ensureTransport();
   if (ownsPort) return LOCAL_HANDLERS[method](args, projectId ?? void 0);
@@ -24985,6 +25104,15 @@ var LOCAL_TOOLS = [
     description: "List the GoatEdit projects open in connected browser tabs, with which one tools act on by default.",
     inputSchema: { type: "object", properties: {} }
   },
+  {
+    name: "open_project",
+    description: "Open a saved project (id from list_projects) in a new browser tab and wait until it connects, so you can work on it \u2014 several projects at once, one tab each, addressed with projectId. A project already open is left as it is. The tab asks the person to allow its footage folder with a popup: tell them to click Allow.",
+    inputSchema: {
+      type: "object",
+      properties: { projectId: { type: "string", description: "The project to open." } },
+      required: ["projectId"]
+    }
+  },
   {
     name: "use_project",
     description: "Pick which connected project every later tool call acts on, when more than one tab is open. Ids come from list_connected_projects.",
@@ -25032,7 +25160,8 @@ var LOCAL_TOOLS = [
         },
         continueOnError: { type: "boolean", description: "Run the remaining steps after one fails." },
         rollback: { type: "boolean", description: "Take a checkpoint first and restore it if any step fails, so a run either lands whole or not at all. Cannot be combined with continueOnError." },
-        projectId: { type: "string", description: "Run every step on this project (from list_connected_projects). Use it when several agents edit different tabs at once; a step's own projectId wins." }
+        projectId: { type: "string", description: "Run every step on this project (from list_connected_projects). Use it when several agents edit different tabs at once; a step's own projectId wins." },
+        expectedSequenceId: { type: "string", description: "Run every step that takes expectedSequenceId on this sequence (from list_sequences), open or not. Use it when several agents edit different sequences at once; a step's own expectedSequenceId wins." }
       },
       required: ["calls"]
     }
@@ -25060,6 +25189,7 @@ async function callTool(name, args) {
     case "list_connected_projects":
     case "list_local_assets":
     case "generate_voiceover":
+    case "open_project":
       return callLocal(name, forwarded, projectId);
     case "use_project": {
       const wanted = typeof forwarded.projectId === "string" ? forwarded.projectId : projectId;
@@ -25127,7 +25257,7 @@ async function runTools(args) {
     const tool = typeof step?.tool === "string" ? step.tool : "";
     try {
       const stepArgs = resolveRefs(step.args && typeof step.args === "object" ? step.args : {}, refs);
-      const raw = await callTool(tool, withRunProject(stepArgs, args.projectId));
+      const raw = await callTool(tool, withRunSequence(withRunProject(stepArgs, args.projectId), args.expectedSequenceId, BROWSER_TOOLS_BY_NAME.get(tool)));
       if (typeof step.as === "string" && step.as) {
         if (raw && typeof raw === "object" && !Array.isArray(raw)) {
           const { _image, _images, ...kept } = raw;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "goatedit-mcp",
-  "version": "1.1.11",
+  "version": "1.1.13",
   "description": "Local MCP server for the GoatEdit video editor: drive your open editor tab from Claude Code or any MCP client",
   "license": "UNLICENSED",
   "type": "module",