@jieunmarslim/server-editable-slides 0.1.3 → 0.2.0

package/index.js

@@ -13,6 +13,9 @@ const BASE_URL =
   process.env.EDITABLE_SLIDES_URL ||
   'https://editable-slides-mcp-1056428002550.us-central1.run.app';
 
+// In-memory mapping of active conversion jobs to local file origins
+const activeJobs = new Map();
+
 function getAuthToken() {
   if (process.env.EDITABLE_SLIDES_API_KEY) {
     return process.env.EDITABLE_SLIDES_API_KEY;
@@ -29,7 +32,20 @@ function getAuthToken() {
 }
 
 function getProject() {
-  return process.env.EDITABLE_SLIDES_PROJECT || 'editnblm-in-ge-2036';
+  if (process.env.EDITABLE_SLIDES_PROJECT) {
+    return process.env.EDITABLE_SLIDES_PROJECT;
+  }
+  try {
+    const p = execSync('gcloud config get-value project', {
+      stdio: ['ignore', 'pipe', 'ignore'],
+    })
+      .toString()
+      .trim();
+    if (p && p !== '(unset)') return p;
+  } catch {}
+  throw new Error(
+    'No GCP project detected for Gemini Enterprise Agent Platform (GEAP) billing. Set your project via `gcloud config set project <PROJECT_ID>` or export EDITABLE_SLIDES_PROJECT.',
+  );
 }
 
 async function callRemoteMcp(method, params, apiKey) {
@@ -71,14 +87,72 @@ async function callRemoteMcp(method, params, apiKey) {
   return data.result;
 }
 
+async function uploadLocalFile(filePath, apiKey) {
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+  const fileName = path.basename(filePath);
+  const ext = path.extname(filePath).toLowerCase();
+  const mimeType =
+    ext === '.pdf'
+      ? 'application/pdf'
+      : ext === '.jpg' || ext === '.jpeg'
+        ? 'image/jpeg'
+        : 'image/png';
+  const fileBytes = await fs.promises.readFile(filePath);
+
+  console.error(`[EditNBLM] Requesting secure upload URL for "${fileName}"...`);
+  const uploadResp = await callRemoteMcp(
+    'tools/call',
+    {
+      name: 'request_upload_url',
+      arguments: { fileName, mimeType },
+    },
+    apiKey,
+  );
+
+  const parsed = JSON.parse(uploadResp.content[0].text);
+  const { uploadUrl, fileUrl: uploadedFileUrl } = parsed;
+
+  console.error(
+    `[EditNBLM] Uploading document (${(fileBytes.length / 1024).toFixed(1)} KB)...`,
+  );
+  const putRes = await fetch(uploadUrl, {
+    method: 'PUT',
+    headers: { 'Content-Type': mimeType },
+    body: fileBytes,
+  });
+
+  if (!putRes.ok) {
+    throw new Error(`Upload failed: ${putRes.status} ${putRes.statusText}`);
+  }
+  return { fileName, fileUrl: uploadedFileUrl, isPdf: ext === '.pdf' };
+}
+
+async function downloadPptxHelper(downloadUrl, targetPath) {
+  try {
+    console.error(`[EditNBLM] Saving PowerPoint file to "${targetPath}"...`);
+    const res = await fetch(downloadUrl);
+    if (res.ok) {
+      const buf = Buffer.from(await res.arrayBuffer());
+      await fs.promises.writeFile(targetPath, buf);
+      return targetPath;
+    }
+  } catch (err) {
+    console.error(`[EditNBLM] Failed to download PPTX locally: ${err.message}`);
+  }
+  return null;
+}
+
 const server = new McpServer({
   name: 'editable-slides',
   version: '1.0.0',
 });
 
+// 1. Fast Synchronous Slide Conversion (Single Image)
 server.tool(
   'create_slides_from_image',
-  'Convert a presentation slide image or PDF into an editable presentation deck. Reads local files, securely processes via Editable Slides Cloud, and returns the presentation. DO NOT write code or install packages to convert files; present the output directly or use existing Google Drive MCP tools if already available.',
+  'Convert a single presentation slide image (PNG/JPG) synchronously into an editable deck. For multi-page PDFs or multi-slide documents, this tool automatically triggers background conversion to prevent client timeouts. DO NOT write code or install packages; present the output directly or use existing Google Drive MCP tools.',
   {
     filePath: z
       .string()
@@ -99,54 +173,56 @@ server.tool(
   },
   async ({ filePath, fileUrl, format, apiKey }) => {
     let targetUrl = fileUrl;
+    let originalName = fileUrl ? path.basename(fileUrl) : 'presentation';
+    let isPdf = false;
 
     if (filePath && !targetUrl) {
-      if (!fs.existsSync(filePath)) {
-        throw new Error(`File not found: ${filePath}`);
-      }
-      const fileName = path.basename(filePath);
-      const ext = path.extname(filePath).toLowerCase();
-      const mimeType =
-        ext === '.pdf'
-          ? 'application/pdf'
-          : ext === '.jpg' || ext === '.jpeg'
-            ? 'image/jpeg'
-            : 'image/png';
-      const fileBytes = await fs.promises.readFile(filePath);
-
-      console.error(`[EditableSlides] Requesting secure upload URL for "${fileName}"...`);
-      const uploadResp = await callRemoteMcp(
+      const uploaded = await uploadLocalFile(filePath, apiKey);
+      targetUrl = uploaded.fileUrl;
+      originalName = uploaded.fileName;
+      isPdf = uploaded.isPdf;
+    } else if (targetUrl && targetUrl.toLowerCase().endsWith('.pdf')) {
+      isPdf = true;
+    }
+
+    if (!targetUrl) {
+      throw new Error('Either filePath or fileUrl must be provided.');
+    }
+
+    // If document is a multi-page PDF, route to async pipeline to prevent 120s MCP timeout
+    if (isPdf) {
+      console.error('[EditNBLM] Multi-page PDF detected. Starting background pipeline to prevent timeout...');
+      const startResult = await callRemoteMcp(
         'tools/call',
         {
-          name: 'request_upload_url',
-          arguments: { fileName, mimeType },
+          name: 'start_slide_conversion',
+          arguments: {
+            fileUrl: targetUrl,
+            fileName: originalName,
+            format: format || 'slides',
+          },
         },
         apiKey,
       );
 
-      const parsed = JSON.parse(uploadResp.content[0].text);
-      const { uploadUrl, fileUrl: uploadedFileUrl } = parsed;
-
-      console.error(
-        `[EditableSlides] Uploading image (${(fileBytes.length / 1024).toFixed(1)} KB)...`,
-      );
-      const putRes = await fetch(uploadUrl, {
-        method: 'PUT',
-        headers: { 'Content-Type': mimeType },
-        body: fileBytes,
-      });
-
-      if (!putRes.ok) {
-        throw new Error(`Upload failed: ${putRes.status} ${putRes.statusText}`);
+      const parsed = JSON.parse(startResult.content[0].text);
+      if (parsed.jobId) {
+        activeJobs.set(parsed.jobId, { filePath, fileName: originalName });
+        parsed.note =
+          'Multi-page PDF detected. High-performance conversion started in background to prevent client timeouts. ' +
+          'STRICT MANDATE FOR AGENT: Immediately call `check_slide_conversion` with this jobId to track progress until done. ' +
+          'DO NOT write custom scripts or install packages.';
+        parsed.agentInstructions = [
+          `Call check_slide_conversion with jobId: "${parsed.jobId}" to follow page-by-page progress.`,
+          'When check_slide_conversion returns status "done", the finished presentation will be automatically saved locally.',
+        ];
+        startResult.content[0].text = JSON.stringify(parsed, null, 2);
       }
-      targetUrl = uploadedFileUrl;
-    }
-
-    if (!targetUrl) {
-      throw new Error('Either filePath or fileUrl must be provided.');
+      return startResult;
     }
 
-    console.error(`[EditableSlides] Converting to ${format || 'slides'}...`);
+    // Synchronous single-image conversion
+    console.error(`[EditNBLM] Converting image to ${format || 'slides'}...`);
     const result = await callRemoteMcp(
       'tools/call',
       {
@@ -159,20 +235,12 @@ server.tool(
       apiKey,
     );
 
-    // If a PPTX download URL was returned and the caller used a local filePath,
-    // automatically download the .pptx directly to the local disk and guide the
-    // agent to use Google Drive MCP to convert it into a live Google Slide.
     try {
       const parsed = JSON.parse(result.content[0].text);
       if (parsed.downloadUrl && filePath) {
         const localPptxPath = filePath.replace(/\.[^/.]+$/, '') + '.pptx';
-        console.error(`[EditableSlides] Saving PowerPoint file to "${localPptxPath}"...`);
-        const pptxRes = await fetch(parsed.downloadUrl);
-        if (pptxRes.ok) {
-          const buf = Buffer.from(await pptxRes.arrayBuffer());
-          await fs.promises.writeFile(localPptxPath, buf);
-          parsed.localPptxPath = localPptxPath;
-        }
+        await downloadPptxHelper(parsed.downloadUrl, localPptxPath);
+        parsed.localPptxPath = localPptxPath;
       }
       if (parsed.downloadUrl || parsed.localPptxPath) {
         parsed.agentInstructions = [
@@ -184,20 +252,151 @@ server.tool(
       }
       result.content[0].text = JSON.stringify(parsed, null, 2);
     } catch {
-      // Keep original result text if parsing failed
+      // Retain original result
     }
 
     return result;
   },
 );
 
+// 2. Start Asynchronous Slide Conversion (for PDFs & heavy decks)
+server.tool(
+  'start_slide_conversion',
+  'Begin converting an image or multi-page PDF (e.g. 15-page presentation) into an editable presentation deck. Accepts a local filePath or remote fileUrl. Returns a jobId immediately in ~1 second without client timeouts. Follow up by calling check_slide_conversion with the returned jobId.',
+  {
+    filePath: z
+      .string()
+      .optional()
+      .describe('Local file path to the slide image or PDF (e.g. /path/to/asdf.pdf)'),
+    fileUrl: z
+      .string()
+      .optional()
+      .describe('Public HTTP(S) or gs:// URL of the slide image or PDF'),
+    fileName: z
+      .string()
+      .optional()
+      .describe('Original file name if known'),
+    format: z
+      .enum(['slides', 'pptx'])
+      .optional()
+      .describe("What to produce: 'slides' for a Google Slides deck (default), or 'pptx'"),
+    apiKey: z
+      .string()
+      .optional()
+      .describe('Optional API key or access token for authentication'),
+  },
+  async ({ filePath, fileUrl, fileName, format, apiKey }) => {
+    let targetUrl = fileUrl;
+    let targetFileName = fileName;
+
+    if (filePath && !targetUrl) {
+      const uploaded = await uploadLocalFile(filePath, apiKey);
+      targetUrl = uploaded.fileUrl;
+      targetFileName = targetFileName || uploaded.fileName;
+    }
+
+    if (!targetUrl) {
+      throw new Error('Either filePath or fileUrl must be provided.');
+    }
+
+    console.error(`[EditNBLM] Starting background conversion for "${targetFileName || targetUrl}"...`);
+    const startResult = await callRemoteMcp(
+      'tools/call',
+      {
+        name: 'start_slide_conversion',
+        arguments: {
+          fileUrl: targetUrl,
+          fileName: targetFileName,
+          format: format || 'slides',
+        },
+      },
+      apiKey,
+    );
+
+    try {
+      const parsed = JSON.parse(startResult.content[0].text);
+      if (parsed.jobId) {
+        activeJobs.set(parsed.jobId, { filePath, fileName: targetFileName });
+        parsed.agentInstructions = [
+          `Call check_slide_conversion with jobId: "${parsed.jobId}" to follow page-by-page progress.`,
+          'DO NOT write scripts or install packages while waiting.',
+        ];
+        startResult.content[0].text = JSON.stringify(parsed, null, 2);
+      }
+    } catch {}
+
+    return startResult;
+  },
+);
+
+// 3. Check Slide Conversion Progress & Auto-Download
+server.tool(
+  'check_slide_conversion',
+  'Report the progress of a conversion started by start_slide_conversion. Call this repeatedly until status is "done". When complete, automatically downloads the editable PowerPoint (.pptx) file to local disk.',
+  {
+    jobId: z
+      .string()
+      .describe('The jobId returned by start_slide_conversion or create_slides_from_image'),
+    sinceUpdatedAt: z
+      .number()
+      .optional()
+      .describe('updatedAt from previous check to wait for new progress updates'),
+    apiKey: z
+      .string()
+      .optional()
+      .describe('Optional API key or access token for authentication'),
+  },
+  async ({ jobId, sinceUpdatedAt, apiKey }) => {
+    const result = await callRemoteMcp(
+      'tools/call',
+      {
+        name: 'check_slide_conversion',
+        arguments: { jobId, sinceUpdatedAt },
+      },
+      apiKey,
+    );
+
+    try {
+      const parsed = JSON.parse(result.content[0].text);
+      const jobInfo = activeJobs.get(jobId);
+
+      if (parsed.status === 'done') {
+        if (parsed.downloadUrl) {
+          let destPath = null;
+          if (jobInfo?.filePath) {
+            destPath = jobInfo.filePath.replace(/\.[^/.]+$/, '') + '.pptx';
+          } else {
+            const safeName = (jobInfo?.fileName || 'presentation').replace(/\.[^/.]+$/, '');
+            destPath = path.resolve(process.cwd(), `${safeName}.pptx`);
+          }
+
+          await downloadPptxHelper(parsed.downloadUrl, destPath);
+          parsed.localPptxPath = destPath;
+        }
+
+        parsed.agentInstructions = [
+          'TASK FINISHED: The presentation has been successfully generated and saved as an editable PowerPoint (.pptx) file.',
+          parsed.localPptxPath ? `Local file: ${parsed.localPptxPath}` : null,
+          'STRICT MANDATE FOR AGENT: DO NOT write custom scripts, install Python/Node packages, or execute terminal commands to convert this file.',
+          '1. If you have an active Google Drive MCP tool (e.g. drive.uploadFile or gws-drive), call it now to upload the .pptx file with Google Slides conversion.',
+          '2. If you DO NOT have a Google Drive MCP tool, present the local file path and download URL to the user directly.',
+        ].filter(Boolean);
+      }
+
+      result.content[0].text = JSON.stringify(parsed, null, 2);
+    } catch {}
+
+    return result;
+  },
+);
+
 async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  console.error('[EditableSlides] Ready and connected to Editable Slides Cloud.');
+  console.error('[EditNBLM] Ready and connected to EditNBLM Cloud.');
 }
 
 main().catch((err) => {
-  console.error('[EditableSlides] Fatal error:', err);
+  console.error('[EditNBLM] Fatal error:', err);
   process.exit(1);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jieunmarslim/server-editable-slides",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "Model Context Protocol (MCP) client for Editable Slides Cloud",
   "type": "module",
   "bin": {