@quantiya/codevibe-antigravity-plugin 1.0.0 → 1.0.2

package/dist/server.js

@@ -1457,6 +1457,7 @@ function parseApprovalUISnapshot(stripped, originalSnapshot) {
   if (options.length < 2) return null;
   const submitMap = buildApprovalSubmitMap(options);
   const { command, filePath } = extractIdentity(headerText);
+  const body = extractBodyBetweenHeaderAndFirstOption(belowHeader);
   return {
     kind: "approval",
     headerText,
@@ -1465,6 +1466,7 @@ function parseApprovalUISnapshot(stripped, originalSnapshot) {
     filePath,
     options,
     submitMap,
+    body,
     paneHash: hashPromptSnapshot(originalSnapshot)
   };
 }
@@ -1481,6 +1483,7 @@ function parseQuestionSnapshot(stripped, originalSnapshot, header) {
   const options = parseOptions(belowHeader);
   if (options.length < 2) return null;
   const submitMap = buildQuestionSubmitMap(options);
+  const body = extractBodyBetweenHeaderAndFirstOption(belowHeader);
   return {
     kind: "question",
     headerText: header.body,
@@ -1489,9 +1492,30 @@ function parseQuestionSnapshot(stripped, originalSnapshot, header) {
     filePath: void 0,
     options,
     submitMap,
+    body,
     paneHash: hashPromptSnapshot(originalSnapshot)
   };
 }
+function extractBodyBetweenHeaderAndFirstOption(belowHeader) {
+  const lines = belowHeader.split("\n");
+  const optionRegex = /^[>\s]*([1-9])\. (.+?)\s*$/;
+  const fenceRegex = /^```/;
+  let firstOptionIdx = -1;
+  let inFence = false;
+  for (let i = 0; i < lines.length; i++) {
+    if (fenceRegex.test(lines[i])) {
+      inFence = !inFence;
+      continue;
+    }
+    if (inFence) continue;
+    if (optionRegex.test(lines[i])) {
+      firstOptionIdx = i;
+      break;
+    }
+  }
+  if (firstOptionIdx <= 0) return "";
+  return lines.slice(0, firstOptionIdx).join("\n").trim();
+}
 function parseOptions(snapshot) {
   const recent = snapshot.split("\n").slice(-30);
   const optionRegex = /^[>\s]*([1-9])\. (.+?)\s*$/;
@@ -1720,6 +1744,7 @@ var ApprovalDetector = class extends import_events3.EventEmitter {
       submitMap: candidate.submitMap,
       matchedPaneHeader: candidate.headerText,
       paneDisplayHeader: candidate.fullHeaderLine,
+      body: candidate.body,
       emittedAt: Date.now(),
       ttlMs: this.promptTtlMs,
       paneOptions: candidate.options
@@ -1904,6 +1929,7 @@ var ApprovalDetector = class extends import_events3.EventEmitter {
       submitMap: candidate.submitMap,
       matchedPaneHeader: candidate.headerText,
       paneDisplayHeader: candidate.fullHeaderLine,
+      body: candidate.body,
       emittedAt: Date.now(),
       ttlMs: this.promptTtlMs
     };
@@ -2826,6 +2852,7 @@ var McpServer = class {
     this.wrapperPid = options.wrapperPid ?? null;
     this.cliLogPath = options.cliLogPath ?? null;
     this.appSyncClient = options.appSyncClient ?? new import_codevibe_core4.AppSyncClient();
+    this.workingDirectory = process.cwd();
     this.approvalDetector = options.approvalDetector ?? new ApprovalDetector(options.detectorOptions);
     this.paneObserver = options.paneObserver ?? new TmuxPaneObserver();
     this.transcriptTailer = options.transcriptTailer ?? new TranscriptTailer();
@@ -3269,12 +3296,36 @@ var McpServer = class {
       return;
     }
     const optionsArr = state.paneOptions ? state.paneOptions.map((o) => ({ number: o.number, text: o.text })) : Object.keys(state.submitMap).map((n) => ({ number: n }));
+    const diffParsed = parseFencedDiffFromBody(
+      state.body,
+      state.paneDisplayHeader
+    );
+    if (diffParsed) {
+      logger.info("Parsed fenced diff for INTERACTIVE_PROMPT", {
+        promptId: state.promptId,
+        filePath: diffParsed.filePath,
+        oldLines: diffParsed.oldString.split("\n").length,
+        newLines: diffParsed.newString.split("\n").length,
+        rawDiffLength: diffParsed.rawDiff.length
+      });
+    }
+    const toolName = diffParsed ? "Edit" : state.pendingCall?.toolType;
+    const filePath = diffParsed?.filePath ?? state.pendingCall?.filePath;
+    const toolInput = diffParsed ? {
+      file_path: diffParsed.filePath,
+      old_string: diffParsed.oldString,
+      new_string: diffParsed.newString,
+      old_start_line: diffParsed.oldStartLine,
+      new_start_line: diffParsed.newStartLine,
+      diff: diffParsed.rawDiff
+    } : void 0;
     const optionsForMobile = state.pendingCall ? {
       promptId: state.promptId,
-      tool_name: state.pendingCall.toolType,
+      tool_name: toolName,
       command: state.pendingCall.command,
-      file_path: state.pendingCall.filePath,
-      options: optionsArr
+      file_path: filePath,
+      options: optionsArr,
+      ...toolInput ? { tool_input: toolInput } : {}
     } : { promptId: state.promptId };
     const content = state.paneDisplayHeader || state.matchedPaneHeader || state.pendingCall?.command || state.pendingCall?.filePath || "approval requested";
     const input = {
@@ -3296,6 +3347,89 @@ var McpServer = class {
     }
   }
   // ─── Mobile → desktop flow ──────────────────────────────────────────────
+  /**
+   * Download an attachment from S3 to the working directory and return a
+   * relative path suitable for agy's `@./path` syntax (inherited from
+   * gemini-cli — Antigravity CLI is downstream of Gemini CLI).
+   *
+   * Mirrors codevibe-gemini-plugin's downloadAttachment() including the
+   * AppSync nested-isEncrypted fallback (subscriptions return null on
+   * nested object fields even when DynamoDB has the value).
+   *
+   * Returns the relative path (e.g. `./.codevibe-attachments/attachment-xxx.png`)
+   * on success, or null on failure (logged + swallowed — one bad attachment
+   * shouldn't block the whole prompt).
+   */
+  async downloadAttachment(attachment, sessionId, sessionKey, eventIsEncrypted) {
+    try {
+      const shouldDecrypt = attachment.isEncrypted ?? eventIsEncrypted ?? false;
+      logger.info("Downloading attachment", {
+        id: attachment.id,
+        type: attachment.type,
+        filename: attachment.filename,
+        s3Key: attachment.s3Key,
+        attachmentIsEncrypted: attachment.isEncrypted,
+        eventIsEncrypted,
+        shouldDecrypt
+      });
+      const { downloadUrl } = await this.appSyncClient.getAttachmentDownloadUrl(attachment.s3Key);
+      const response = await fetch(downloadUrl);
+      if (!response.ok) {
+        throw new Error(`Failed to download attachment: ${response.status} ${response.statusText}`);
+      }
+      let buffer = Buffer.from(await response.arrayBuffer());
+      if (shouldDecrypt && sessionKey) {
+        try {
+          logger.info("Decrypting attachment", { id: attachment.id });
+          buffer = import_codevibe_core4.cryptoService.decryptData(buffer, sessionKey);
+          logger.info("Attachment decrypted successfully", {
+            id: attachment.id,
+            decryptedSize: buffer.length
+          });
+        } catch (decryptError) {
+          logger.error("Failed to decrypt attachment:", { id: attachment.id, error: String(decryptError) });
+          throw new Error("Failed to decrypt attachment");
+        }
+      } else if (shouldDecrypt && !sessionKey) {
+        logger.warn("Cannot decrypt attachment - no session key available", { id: attachment.id });
+      }
+      const attachmentsDir = path5.join(this.workingDirectory, ".codevibe-attachments");
+      if (!fs5.existsSync(attachmentsDir)) {
+        fs5.mkdirSync(attachmentsDir, { recursive: true });
+      }
+      let extension = "";
+      if (attachment.filename) {
+        const ext = path5.extname(attachment.filename);
+        if (ext) extension = ext;
+      }
+      if (!extension) {
+        const mimeToExt = {
+          "image/jpeg": ".jpg",
+          "image/png": ".png",
+          "image/gif": ".gif",
+          "image/webp": ".webp",
+          "image/heic": ".heic",
+          "application/pdf": ".pdf"
+        };
+        extension = mimeToExt[attachment.type] || ".bin";
+      }
+      const filename = `attachment-${attachment.id}${extension}`;
+      const absolutePath = path5.join(attachmentsDir, filename);
+      fs5.writeFileSync(absolutePath, buffer);
+      const relativePath = `./.codevibe-attachments/${filename}`;
+      logger.info("Attachment saved to working directory", {
+        id: attachment.id,
+        sessionId,
+        absolutePath,
+        relativePath,
+        size: buffer.length
+      });
+      return relativePath;
+    } catch (error) {
+      logger.error("Failed to download attachment:", { id: attachment.id, error: String(error) });
+      return null;
+    }
+  }
   async handleMobileEvent(evt) {
     if (!this.started) return;
     if (this.sessionDisabled) return;
@@ -3318,10 +3452,42 @@ var McpServer = class {
     evt = decrypted;
     await this.markDelivered(evt);
     if (evt.type === import_codevibe_core4.EventType.USER_PROMPT) {
-      this.mobileDeduper.track(session.sessionId, evt.content);
-      const result = await this.promptResponder.sendFreeForm(evt.content);
+      let promptContent = evt.content;
+      const attachments = evt.attachments ?? [];
+      if (attachments.length > 0) {
+        logger.info("Downloading attachments for USER_PROMPT", {
+          sessionId: session.sessionId,
+          eventId: evt.eventId,
+          count: attachments.length
+        });
+        const attachmentPaths = [];
+        for (const attachment of attachments) {
+          const relPath = await this.downloadAttachment(
+            attachment,
+            session.sessionId,
+            session.sessionKey ?? null,
+            evt.isEncrypted
+          );
+          if (relPath) attachmentPaths.push(relPath);
+        }
+        if (attachmentPaths.length > 0) {
+          const fileReferences = attachmentPaths.map((p) => `@${p}`).join(" ");
+          if (promptContent) {
+            promptContent = `${fileReferences} ${promptContent}`;
+          } else {
+            promptContent = `${fileReferences} Please analyze the attached file(s).`;
+          }
+          logger.info("Prompt augmented with attachment paths", {
+            sessionId: session.sessionId,
+            eventId: evt.eventId,
+            attachmentCount: attachmentPaths.length
+          });
+        }
+      }
+      this.mobileDeduper.track(session.sessionId, promptContent);
+      const result = await this.promptResponder.sendFreeForm(promptContent);
       if (!result.ok) {
-        this.mobileDeduper.forget(session.sessionId, evt.content);
+        this.mobileDeduper.forget(session.sessionId, promptContent);
         logger.warn("sendFreeForm failed", { reason: result.reason, details: result.details });
         return;
       }
@@ -3541,11 +3707,96 @@ function parseArgs(argv) {
 if (require.main === module) {
   void main();
 }
+function parseFencedDiffFromBody(body, header) {
+  if (!body) return null;
+  const fenceMatch = body.match(/```[^\n]*\n([\s\S]*?)\n```/i);
+  if (!fenceMatch) return null;
+  const rawDiff = fenceMatch[1];
+  const oldLines = [];
+  const newLines = [];
+  const hunkHeaderPattern = /^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/;
+  let currentOldLine = 0;
+  let currentNewLine = 0;
+  let oldStartLine;
+  let newStartLine;
+  let hunkCount = 0;
+  let filePath;
+  const stripPrefix = (raw) => {
+    let p = raw.trim();
+    if (p.startsWith("a/") || p.startsWith("b/")) p = p.slice(2);
+    if (p === "/dev/null") return "";
+    return p;
+  };
+  for (const line of rawDiff.split("\n")) {
+    const hunkMatch = line.match(hunkHeaderPattern);
+    if (hunkMatch) {
+      hunkCount += 1;
+      currentOldLine = Number.parseInt(hunkMatch[1], 10);
+      currentNewLine = Number.parseInt(hunkMatch[2], 10);
+      continue;
+    }
+    if (line.startsWith("+++ ")) {
+      const pathVal = stripPrefix(line.slice(4));
+      if (pathVal) filePath = pathVal;
+      continue;
+    }
+    if (line.startsWith("--- ")) {
+      if (!filePath) {
+        const pathVal = stripPrefix(line.slice(4));
+        if (pathVal) filePath = pathVal;
+      }
+      continue;
+    }
+    if (line.startsWith("+")) {
+      if (newStartLine === void 0) newStartLine = currentNewLine;
+      newLines.push(line.slice(1));
+      currentNewLine += 1;
+    } else if (line.startsWith("-")) {
+      if (oldStartLine === void 0) oldStartLine = currentOldLine;
+      oldLines.push(line.slice(1));
+      currentOldLine += 1;
+    } else if (line.startsWith(" ")) {
+      const ctx = line.slice(1);
+      oldLines.push(ctx);
+      newLines.push(ctx);
+      currentOldLine += 1;
+      currentNewLine += 1;
+    }
+  }
+  if (hunkCount > 1) {
+    oldStartLine = void 0;
+    newStartLine = void 0;
+  }
+  if (!filePath) {
+    const searchTargets = [body, header ?? ""];
+    for (const target of searchTargets) {
+      if (!target) continue;
+      const m = target.match(/\[.*?\]\(file:\/\/([^\s\)]+)\)/) || target.match(/file:\/\/([^\s\)]+)/);
+      if (m) {
+        try {
+          filePath = decodeURIComponent(m[1]);
+        } catch {
+          filePath = m[1];
+        }
+        break;
+      }
+    }
+  }
+  return {
+    filePath,
+    oldString: oldLines.join("\n"),
+    newString: newLines.join("\n"),
+    oldStartLine,
+    newStartLine,
+    rawDiff
+  };
+}
 var __testing = {
   generateLaunchSessionId,
   parseArgs,
   parseMaybeJson,
-  getActiveConversationFromCliLog
+  getActiveConversationFromCliLog,
+  parseFencedDiffFromBody
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quantiya/codevibe-antigravity-plugin",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Control Antigravity CLI from your iPhone and Android — real-time sync, approve file edits, send prompts by voice. Part of CodeVibe.",
   "main": "dist/server.js",
   "bin": {