@eyejack-creator/mcp 0.3.0 → 0.5.0

package/README.md

@@ -29,6 +29,7 @@ The token lives as long as your editor tab (the tab heartbeats it; closing the t
 |---|---|
 | `get_scene` | Full structured snapshot: metadata, parsed scene document (unity-space, degrees), `sceneRevision`, referenced files |
 | `list_assets` | The artwork's asset files with `usedInScene` resolution |
+| `import_asset` | Upload a local media file (image/video/GLB) — the open editor ingests it through its normal transcode/upload pipeline and auto-places it in the scene |
 | `update_scene` | Whole-document, revision-checked scene write — applied **live** in the open editor with your `ops` action log; conflicts return the current scene to rebase on |
 | `publish_artwork` | Publish the artwork to its public launch URL (draft/disabled → published) |
 | `screenshot` | JPEG of the editor's current view, rendered by the open tab and relayed over AppSync (auto-degraded under the transport cap) — the agent's eyes |

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,44 @@ var ON_AGENT_ACTION_RESULT = `
     }
   }
 `;
+var AGENT_LIST_ARTWORKS = `
+  query AgentListArtworks {
+    agentListArtworks {
+      id
+      userid
+      name
+      description
+      status
+      artworkType
+      sceneRevision
+      modified
+      created
+    }
+  }
+`;
+var AGENT_CREATE_UPLOAD_URL = `
+  mutation AgentCreateUploadUrl($filename: String!, $contentType: String) {
+    agentCreateUploadUrl(filename: $filename, contentType: $contentType) {
+      uploadUrl
+      downloadUrl
+      key
+      expiresAt
+    }
+  }
+`;
+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 +774,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 +805,61 @@ 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;
+  }
+  /**
+   * Presigned S3 staging pair for asset imports (P6): the agent PUTs local
+   * file bytes to uploadUrl, then hands downloadUrl to the browser (via the
+   * IMPORT_ASSET action) to pull into the normal asset pipeline.
+   */
+  async createUploadUrl(filename, contentType) {
+    const data = await this.client.execute(AGENT_CREATE_UPLOAD_URL, { filename, contentType: contentType ?? null });
+    return data.agentCreateUploadUrl;
+  }
+  /**
+   * 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 +876,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 +897,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;
@@ -1001,6 +1095,8 @@ function loadConfig() {
 
 // src/tools.ts
 import { randomUUID } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { basename, extname } from "node:path";
 import { z } from "zod";
 var SCENE_CONTRACT = `Scene document conventions (the stored EyeJack format):
 - Coordinate space is unity-style left-handed; rotations are in DEGREES.
@@ -1019,7 +1115,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 +1127,97 @@ 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 queryActiveArtwork = async () => {
+    await ensureResultListener();
+    const pong = await requestOnce("PING", null, 6e3);
+    if (pong?.ok && pong.payload) {
+      try {
+        return JSON.parse(pong.payload).activeArtworkId ?? null;
+      } catch {
+        return null;
+      }
     }
-    return cachedArtworkId;
+    return null;
+  };
+  const resolveArtworkId = async (explicit) => {
+    if (explicit) return explicit;
+    const active = await queryActiveArtwork();
+    if (active) return active;
+    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 +1242,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 +1265,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 +1323,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 +1339,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 +1347,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 +1358,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 +1372,106 @@ 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 IMPORT_MIME = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".webp": "image/webp",
+    ".gif": "image/gif",
+    ".mp4": "video/mp4",
+    ".mov": "video/quicktime",
+    ".glb": "model/gltf-binary"
   };
-  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 importAssetParams = {
+    filePath: z.string().describe("Absolute path to a local media file: .png/.jpg/.jpeg/.webp image, .gif/.mp4/.mov video, or .glb model."),
+    artworkId: z.string().optional().describe("Target artwork. Omit for the one open in the editor tab; if another id is given, the tab is steered there first (imports run in the open editor).")
   };
+  server2.tool(
+    "import_asset",
+    "Bring NEW media into a project: upload a local file, which the user's open editor ingests through its normal asset pipeline (transcode, size limits, thumbnails) and auto-places in the scene. Returns the new asset's fileID \u2014 follow up with get_scene/update_scene to position it, and screenshot to verify. Requires the editor tab open; videos can take a minute or two to transcode. Per-project asset budget is ~3MB total, so prefer small optimized files.",
+    importAssetParams,
+    async (args) => {
+      const { filePath, artworkId } = args;
+      try {
+        const ext = extname(filePath).toLowerCase();
+        const contentType = IMPORT_MIME[ext];
+        if (!contentType) {
+          return asText(`Unsupported file type "${ext}". Supported: ${Object.keys(IMPORT_MIME).join(", ")}`);
+        }
+        const bytes = await readFile(filePath);
+        if (bytes.length > 100 * 1024 * 1024) {
+          return asText("File is larger than 100MB \u2014 far beyond the panels asset budget. Pick a smaller file.");
+        }
+        const filename = basename(filePath);
+        const active = await queryActiveArtwork();
+        let target = artworkId ?? active;
+        if (!target) return asText(NO_ARTWORK_HINT);
+        if (target !== active) {
+          const opened = await requestOnce("OPEN_ARTWORK", JSON.stringify({ artworkId: target }), 15e3);
+          if (!opened?.ok) {
+            return asText(`Could not open ${target} in the editor first: ${opened?.error || "no response from the tab"}`);
+          }
+          await new Promise((resolve) => setTimeout(resolve, 4e3));
+        }
+        const staging = await client2.agent.createUploadUrl(filename, contentType);
+        const put = await fetch(staging.uploadUrl, {
+          method: "PUT",
+          headers: { "content-type": contentType },
+          body: new Uint8Array(bytes)
+        });
+        if (!put.ok) {
+          return asText(`Staging upload failed (HTTP ${put.status}).`);
+        }
+        const result = await requestOnce(
+          "IMPORT_ASSET",
+          JSON.stringify({ artworkId: target, downloadUrl: staging.downloadUrl, filename, contentType }),
+          24e4
+        );
+        if (!result) {
+          return asText("No response from the editor tab \u2014 is it open and visible? (Large videos can also exceed the wait; check the editor and re-read the scene.)");
+        }
+        if (!result.ok) {
+          return asText(`Import failed: ${result.error || "unknown error"}`);
+        }
+        let fileID = null;
+        try {
+          fileID = result.payload ? JSON.parse(result.payload).fileID ?? null : null;
+        } catch {
+        }
+        return asText({
+          ok: true,
+          artworkId: target,
+          fileID,
+          message: "Imported through the editor pipeline and auto-placed in the scene. Use get_scene to see it (assetID == fileID) and update_scene to reposition; screenshot to verify visually."
+        });
+      } catch (err) {
+        return asError(err);
+      }
+    }
+  );
   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 +1497,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 +1536,7 @@ var client = createCreatorClient({
 });
 var server = new McpServer({
   name: "eyejack-creator",
-  version: "0.3.0"
+  version: "0.5.0"
 });
 registerTools(server, client, {
   launchBaseUrl: config.launchBaseUrl,
@@ -1270,4 +1545,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 workspace + asset-import tools ready.`);

package/package.json

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