@eyejack-creator/mcp 0.3.0 → 0.4.0

package/dist/index.js

@@ -617,11 +617,10 @@ var SceneApi = class {
 
 // ../creator-api/dist/domains/agent.js
 var CREATE_AGENT_SESSION = `
-  mutation CreateAgentSession($artworkId: ID!) {
-    createAgentSession(artworkId: $artworkId) {
+  mutation CreateAgentSession {
+    createAgentSession {
       sessionId
       token
-      artworkId
       expiresAt
     }
   }
@@ -714,9 +713,34 @@ var ON_AGENT_ACTION_RESULT = `
     }
   }
 `;
+var AGENT_LIST_ARTWORKS = `
+  query AgentListArtworks {
+    agentListArtworks {
+      id
+      userid
+      name
+      description
+      status
+      artworkType
+      sceneRevision
+      modified
+      created
+    }
+  }
+`;
+var AGENT_ENSURE_SCENE_BACKUP = `
+  mutation AgentEnsureSceneBackup($artworkId: ID!) {
+    agentEnsureSceneBackup(artworkId: $artworkId) {
+      artworkId
+      sessionId
+      sceneRevision
+      createdAt
+    }
+  }
+`;
 var AGENT_GET_SCENE = `
-  query AgentGetScene {
-    agentGetScene {
+  query AgentGetScene($artworkId: ID) {
+    agentGetScene(artworkId: $artworkId) {
       artworkId
       name
       status
@@ -740,10 +764,12 @@ var AgentApi = class {
   constructor(client2, realtime) {
     this.client = client2;
     this.realtime = realtime;
+    this.backupEnsured = /* @__PURE__ */ new Set();
   }
   // --- Browser-side (Cognito) session lifecycle ---
-  async createSession(artworkId) {
-    const data = await this.client.execute(CREATE_AGENT_SESSION, { artworkId });
+  /** Mint an ACCOUNT-scoped session (P6a) — authorizes everything the account owns. */
+  async createSession() {
+    const data = await this.client.execute(CREATE_AGENT_SESSION);
     return data.createAgentSession;
   }
   async heartbeat(sessionId) {
@@ -769,10 +795,52 @@ var AgentApi = class {
     const data = await this.client.execute(AGENT_GET_SESSION);
     return data.agentGetSession;
   }
-  async getScene() {
-    const data = await this.client.execute(AGENT_GET_SCENE);
+  /** Read any artwork the session's account owns (ownership checked server-side). */
+  async getScene(artworkId) {
+    const data = await this.client.execute(AGENT_GET_SCENE, {
+      artworkId
+    });
     return data.agentGetScene;
   }
+  /** The account's workspace: every non-deleted artwork it owns. */
+  async listArtworks() {
+    const data = await this.client.execute(AGENT_LIST_ARTWORKS);
+    return data.agentListArtworks ?? [];
+  }
+  /**
+   * Create a new panels (worldTarget) artwork owned by the session's account
+   * (the server forces ownership regardless of input). Mirrors the editor's
+   * new-panels defaults; the artwork starts published like the web flow.
+   */
+  async createArtwork(params) {
+    const id = `Artwork-${globalThis.crypto.randomUUID()}`;
+    const input = {
+      id,
+      files: [],
+      creatorVersion: "agent-mcp",
+      status: "published",
+      artworkType: "worldTarget",
+      name: params?.name ?? "Untitled panels",
+      description: params?.description ?? "",
+      downloadsCount: 0,
+      viewsCount: 0,
+      publishEnabled: true,
+      enabled: true,
+      animationHasAlpha: false,
+      animationVideoOrientation: "horizontal"
+    };
+    const data = await this.client.execute(CREATE_ARTWORK, { input });
+    return data.createArtwork;
+  }
+  /**
+   * Lazy pre-write snapshot (P6a): idempotent per (session, artwork) —
+   * powers the editor's "Revert AI changes". saveScene calls this
+   * automatically before a session's first write to each artwork.
+   */
+  async ensureSceneBackup(artworkId) {
+    const data = await this.client.execute(AGENT_ENSURE_SCENE_BACKUP, { artworkId });
+    return data.agentEnsureSceneBackup;
+  }
   // --- Agent-side (session token) writes (P4) ---
   /**
    * Revision-checked scene write with a session token. Same mutation and
@@ -789,6 +857,13 @@ var AgentApi = class {
         throw new Error(`Refusing to save invalid scene document: ${errors.map((i) => i.message).join("; ")}`);
       }
     }
+    if (!this.backupEnsured.has(params.artworkId)) {
+      try {
+        await this.ensureSceneBackup(params.artworkId);
+        this.backupEnsured.add(params.artworkId);
+      } catch {
+      }
+    }
     try {
       const data = await this.client.execute(UPDATE_ARTWORK_SCENE, {
         input: {
@@ -803,7 +878,7 @@ var AgentApi = class {
       return { conflict: false, revision: payload.sceneRevision, modified: payload.modified ?? null, payload };
     } catch (err) {
       if (err instanceof GraphQLRequestError && err.errorType === "SceneRevisionConflict") {
-        const current = await this.getScene().catch(() => null);
+        const current = await this.getScene(params.artworkId).catch(() => null);
         return { conflict: true, currentRevision: current?.sceneRevision ?? null, current };
       }
       throw err;
@@ -1019,7 +1094,7 @@ function errorText(err) {
     if ((err.errorType || "").includes("Unauthorized")) {
       return REJECTED_HINT;
     }
-    return `EyeJack API error: ${err.errorType || err.message}`;
+    return `EyeJack API error (${err.errorType || "unknown"}): ${err.message}`;
   }
   return `Error: ${err.message}`;
 }
@@ -1031,19 +1106,92 @@ var asError = (err) => ({
   isError: true
 });
 function registerTools(server2, client2, options) {
-  let cachedArtworkId = null;
-  const artworkId = async () => {
-    if (!cachedArtworkId) {
-      cachedArtworkId = (await client2.agent.getSession()).artworkId;
+  let resultSub = null;
+  const pendingResults = /* @__PURE__ */ new Map();
+  const ensureResultListener = async () => {
+    if (resultSub) return;
+    resultSub = client2.agent.watchActionResults(options.sessionId, {
+      next: (result) => {
+        const resolve = pendingResults.get(result.requestId);
+        if (resolve) {
+          pendingResults.delete(result.requestId);
+          resolve(result);
+        }
+      },
+      error: (err) => {
+        console.error("[eyejack-mcp] action result channel error:", err);
+      }
+    });
+    await new Promise((resolve) => setTimeout(resolve, 800));
+  };
+  const requestOnce = async (actionType, payload, timeoutMs) => {
+    const requestId = randomUUID();
+    const waiter = new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        pendingResults.delete(requestId);
+        resolve(null);
+      }, timeoutMs);
+      pendingResults.set(requestId, (result) => {
+        clearTimeout(timer);
+        resolve(result);
+      });
+    });
+    await client2.agent.requestAction({
+      sessionId: options.sessionId,
+      requestId,
+      actionType,
+      payload
+    });
+    return waiter;
+  };
+  const NO_ARTWORK_HINT = "No artworkId given and no artwork is open in the editor tab. Pass artworkId explicitly (see list_artworks) or use open_artwork first.";
+  const resolveArtworkId = async (explicit) => {
+    if (explicit) return explicit;
+    await ensureResultListener();
+    const pong = await requestOnce("PING", null, 6e3);
+    if (pong?.ok && pong.payload) {
+      try {
+        const parsed = JSON.parse(pong.payload);
+        if (parsed.activeArtworkId) return parsed.activeArtworkId;
+      } catch {
+      }
     }
-    return cachedArtworkId;
+    throw new Error(NO_ARTWORK_HINT);
+  };
+  const artworkIdParam = {
+    artworkId: z.string().optional().describe(
+      'Target artwork id ("Artwork-\u2026"), any panels project the account owns. Omit to target the one open in the editor tab.'
+    )
   };
   server2.tool(
-    "get_scene",
-    `Read the full structured snapshot of the connected EyeJack artwork: metadata, the parsed scene document, the current sceneRevision, and the asset files it references. This session's token is scoped to exactly one artwork \u2014 there is nothing to select. ${SCENE_CONTRACT}`,
+    "list_artworks",
+    "List every artwork in the connected EyeJack account \u2014 the whole workspace this session can read and edit. Only worldTarget (panels) artworks are editable through this server; other types are read-only context.",
     async () => {
       try {
-        const record = await client2.agent.getScene();
+        const artworks = await client2.agent.listArtworks();
+        return asText(
+          artworks.map((a) => ({
+            id: a.id,
+            name: a.name,
+            artworkType: a.artworkType,
+            status: a.status,
+            sceneRevision: a.sceneRevision ?? 0,
+            modified: a.modified
+          }))
+        );
+      } catch (err) {
+        return asError(err);
+      }
+    }
+  );
+  server2.tool(
+    "get_scene",
+    `Read the full structured snapshot of an artwork: metadata, the parsed scene document, the current sceneRevision, and the asset files it references. The session covers the whole account (P6a) \u2014 omit artworkId to read whatever is open in the editor tab. ${SCENE_CONTRACT}`,
+    artworkIdParam,
+    async (args) => {
+      try {
+        const id = await resolveArtworkId(args.artworkId);
+        const record = await client2.agent.getScene(id);
         const doc = parseSceneConfig(record.sceneConfig);
         return asText({
           artworkId: record.artworkId,
@@ -1068,10 +1216,12 @@ function registerTools(server2, client2, options) {
   );
   server2.tool(
     "list_assets",
-    "List the asset files (images, videos, 3D models) available on the connected artwork \u2014 the palette the scene's panels can reference via assetID == fileID. Read-only.",
-    async () => {
+    "List the asset files (images, videos, 3D models) available on an artwork \u2014 the palette its panels can reference via assetID == fileID. Omit artworkId to target the open artwork. Read-only.",
+    artworkIdParam,
+    async (args) => {
       try {
-        const record = await client2.agent.getScene();
+        const id = await resolveArtworkId(args.artworkId);
+        const record = await client2.agent.getScene(id);
         const doc = parseSceneConfig(record.sceneConfig);
         const usedIds = new Set((doc?.scenes?.[0]?.children || []).map((c) => c.assetID));
         return asText(
@@ -1089,8 +1239,55 @@ function registerTools(server2, client2, options) {
       }
     }
   );
+  const createArtworkParams = {
+    name: z.string().min(1).max(120).optional().describe('Project name (default "Untitled panels").'),
+    description: z.string().max(2e3).optional().describe("Optional description.")
+  };
+  server2.tool(
+    "create_artwork",
+    "Create a new, empty panels (worldTarget) project in the connected account. It starts with no assets \u2014 the human adds media in the browser; you can arrange the scene once assets exist. Follow up with open_artwork to bring it up in their editor.",
+    createArtworkParams,
+    async (args) => {
+      const { name, description } = args;
+      try {
+        const created = await client2.agent.createArtwork({ name, description });
+        return asText({
+          id: created.id,
+          status: created.status,
+          message: `Created "${name ?? "Untitled panels"}" (${created.id}). Use open_artwork to show it in the user's editor.`
+        });
+      } catch (err) {
+        return asError(err);
+      }
+    }
+  );
+  const openArtworkParams = {
+    artworkId: z.string().describe('The panels artwork to open ("Artwork-\u2026").')
+  };
+  server2.tool(
+    "open_artwork",
+    "Navigate the user's open editor tab to a panels artwork \u2014 steering the viewport. Viewport-bound tools (screenshot) always target whatever is open. Requires the editor tab to be open; the user sees the navigation happen, so tell them why you are switching.",
+    openArtworkParams,
+    async (args) => {
+      const { artworkId } = args;
+      try {
+        await ensureResultListener();
+        const result = await requestOnce("OPEN_ARTWORK", JSON.stringify({ artworkId }), 15e3);
+        if (!result) {
+          return asText("No response from the editor tab \u2014 is it open and visible?");
+        }
+        if (!result.ok) {
+          return asText(`Could not open the artwork: ${result.error || "unknown error"}`);
+        }
+        return asText({ opened: artworkId });
+      } catch (err) {
+        return asError(err);
+      }
+    }
+  );
   const updateSceneParams = {
-    expectedRevision: z.number().int().min(0).describe("The sceneRevision your edit is based on, from your latest read."),
+    artworkId: z.string().optional().describe("Target artwork id. Omit to write the one open in the editor tab."),
+    expectedRevision: z.number().int().min(0).describe("The sceneRevision your edit is based on, from your latest read of THIS artwork."),
     scene: z.record(z.any()).describe(
       "The complete scene document to store: { version, settings?, assets, scenes }. Top-level keys are frozen to these; per-child additive keys are allowed."
     ),
@@ -1100,13 +1297,14 @@ function registerTools(server2, client2, options) {
   };
   server2.tool(
     "update_scene",
-    `Write the connected artwork's scene (whole-document, revision-checked). The user's open editor applies the change LIVE and shows your ops descriptions, so keep ops honest and human-readable. Rules: send the COMPLETE document (this is not a patch \u2014 anything you omit is deleted); preserve any unknown keys you read; base expectedRevision on your latest get_scene (or the revision returned by your last successful update_scene). On a revision conflict nothing is written \u2014 the response includes the current scene so you can rebase and retry. ${SCENE_CONTRACT}`,
+    `Write an artwork's scene (whole-document, revision-checked; account-scoped \u2014 any panels project you own, open in the editor or not). If the artwork is open, the user's editor applies the change LIVE and shows your ops descriptions, so keep ops honest and human-readable. Rules: send the COMPLETE document (this is not a patch \u2014 anything you omit is deleted); preserve any unknown keys you read; base expectedRevision on your latest read of the SAME artwork. On a revision conflict nothing is written \u2014 the response includes the current scene so you can rebase and retry. ${SCENE_CONTRACT}`,
     updateSceneParams,
     async (args) => {
-      const { expectedRevision, scene, ops } = args;
+      const { artworkId, expectedRevision, scene, ops } = args;
       try {
+        const id = await resolveArtworkId(artworkId);
         const result = await client2.agent.saveScene({
-          artworkId: await artworkId(),
+          artworkId: id,
           doc: scene,
           expectedRevision,
           ops,
@@ -1115,6 +1313,7 @@ function registerTools(server2, client2, options) {
         if (result.conflict) {
           return asText({
             conflict: true,
+            artworkId: id,
             message: "Not written: the scene changed since your read (the human may have edited it). Rebase your change onto the current scene below and retry with its revision.",
             currentRevision: result.currentRevision,
             currentScene: result.current ? parseSceneConfig(result.current.sceneConfig) : null
@@ -1122,8 +1321,9 @@ function registerTools(server2, client2, options) {
         }
         return asText({
           conflict: false,
+          artworkId: id,
           revision: result.revision,
-          message: `Saved (revision ${result.revision}). The user's editor has applied your change live.`
+          message: `Saved (revision ${result.revision}).`
         });
       } catch (err) {
         return asError(err);
@@ -1132,10 +1332,11 @@ function registerTools(server2, client2, options) {
   );
   server2.tool(
     "publish_artwork",
-    `Publish the connected artwork so it is publicly viewable at its launch URL (${options.launchBaseUrl}/<artworkId>). Only works when the artwork is in draft or disabled state \u2014 already-published artworks reject (their live page already reflects saved scene changes). Ask the user before publishing unless they already told you to.`,
-    async () => {
+    `Publish an artwork so it is publicly viewable at its launch URL (${options.launchBaseUrl}/<artworkId>). Only works when the artwork is in draft or disabled state \u2014 already-published artworks reject (their live page already reflects saved scene changes). Omit artworkId to target the open artwork. Ask the user before publishing unless they already told you to.`,
+    artworkIdParam,
+    async (args) => {
       try {
-        const id = await artworkId();
+        const id = await resolveArtworkId(args.artworkId);
         const artwork = await client2.agent.publish(id);
         return asText({
           id: artwork.id,
@@ -1145,67 +1346,29 @@ function registerTools(server2, client2, options) {
       } catch (err) {
         if (err instanceof GraphQLRequestError && `${err.errorType} ${err.message}`.includes("ConditionalCheckFailed")) {
           return asText(
-            "Nothing to do: the artwork is already published (publish only transitions draft/disabled \u2192 published). Saved scene changes are already live on its launch URL."
+            "Nothing to do: the artwork is already published (publish only transitions draft/disabled \u2192 published), or the account does not own it. Saved scene changes are already live on its launch URL."
           );
         }
         return asError(err);
       }
     }
   );
-  let resultSub = null;
-  const pendingResults = /* @__PURE__ */ new Map();
-  const ensureResultListener = async () => {
-    if (resultSub) return;
-    resultSub = client2.agent.watchActionResults(options.sessionId, {
-      next: (result) => {
-        const resolve = pendingResults.get(result.requestId);
-        if (resolve) {
-          pendingResults.delete(result.requestId);
-          resolve(result);
-        }
-      },
-      error: (err) => {
-        console.error("[eyejack-mcp] action result channel error:", err);
-      }
-    });
-    await new Promise((resolve) => setTimeout(resolve, 800));
-  };
-  const requestOnce = async (payload, timeoutMs) => {
-    const requestId = randomUUID();
-    const waiter = new Promise((resolve) => {
-      const timer = setTimeout(() => {
-        pendingResults.delete(requestId);
-        resolve(null);
-      }, timeoutMs);
-      pendingResults.set(requestId, (result) => {
-        clearTimeout(timer);
-        resolve(result);
-      });
-    });
-    await client2.agent.requestAction({
-      sessionId: options.sessionId,
-      requestId,
-      actionType: "SCREENSHOT",
-      payload
-    });
-    return waiter;
-  };
   const screenshotParams = {
     width: z.number().int().min(64).max(2048).optional().describe("Image width in px (default 1280; height follows the editor aspect)."),
     quality: z.number().min(0.1).max(1).optional().describe("JPEG quality 0.1\u20131 (default 0.8; auto-degraded if the image exceeds the transport cap).")
   };
   server2.tool(
     "screenshot",
-    "See the scene: capture a rendered JPEG of the connected artwork exactly as the user's open editor shows it. Use it to visually verify your update_scene edits (read \u2192 edit \u2192 screenshot \u2192 correct). Requires the editor tab open in a desktop browser; if nobody answers, the tab is closed, hidden, or on a touch device.",
+    "See the scene: capture a rendered JPEG of whatever artwork the user's editor tab currently shows (use open_artwork to switch it first). Use it to visually verify your update_scene edits (read \u2192 edit \u2192 screenshot \u2192 correct). Requires the editor tab open in a desktop browser; if nobody answers, the tab is closed, hidden, or on a touch device.",
     screenshotParams,
     async (args) => {
       const { width, quality } = args;
       try {
         await ensureResultListener();
         const payload = JSON.stringify({ width: width ?? 1280, quality: quality ?? 0.8 });
-        let result = await requestOnce(payload, 2e4);
+        let result = await requestOnce("SCREENSHOT", payload, 2e4);
         if (!result) {
-          result = await requestOnce(payload, 2e4);
+          result = await requestOnce("SCREENSHOT", payload, 2e4);
         }
         if (!result) {
           return asText(
@@ -1231,14 +1394,23 @@ function registerTools(server2, client2, options) {
   );
   server2.tool(
     "get_session_status",
-    "Inspect the agent session itself: which artwork it is scoped to, whether it is active, and when it expires (the editor tab heartbeats it while open; closing the tab lets it lapse).",
+    "Inspect the agent session: whether it is active, when it expires (the editor tab heartbeats it while open; closing the tab lets it lapse), and which artwork the tab currently shows (activeArtworkId; null when no panels page is open).",
     async () => {
       try {
         const session = await client2.agent.getSession();
         const now = Math.floor(Date.now() / 1e3);
+        let activeArtworkId = null;
+        try {
+          await ensureResultListener();
+          const pong = await requestOnce("PING", null, 5e3);
+          if (pong?.ok && pong.payload) {
+            activeArtworkId = JSON.parse(pong.payload).activeArtworkId ?? null;
+          }
+        } catch {
+        }
         return asText({
-          artworkId: session.artworkId,
           status: session.status,
+          activeArtworkId,
           expiresAt: session.expiresAt,
           expiresInSeconds: session.expiresAt ? session.expiresAt - now : null,
           lastHeartbeat: session.lastHeartbeat
@@ -1261,7 +1433,7 @@ var client = createCreatorClient({
 });
 var server = new McpServer({
   name: "eyejack-creator",
-  version: "0.3.0"
+  version: "0.4.0"
 });
 registerTools(server, client, {
   launchBaseUrl: config.launchBaseUrl,
@@ -1270,4 +1442,4 @@ registerTools(server, client, {
 });
 var transport = new StdioServerTransport();
 await server.connect(transport);
-console.error(`eyejack-mcp connected (stage: ${config.stage}) \u2014 scene read/write + screenshot tools ready.`);
+console.error(`eyejack-mcp connected (stage: ${config.stage}) \u2014 account-scoped workspace tools ready.`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eyejack-creator/mcp",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "EyeJack Creator MCP server — connect Claude Code / Codex / Cursor to a live EyeJack editing session.",
   "license": "UNLICENSED",
   "type": "module",