Save images locally and provide path info in messages (#14)

# Image Local Path Feature

This PR implements the feature requested in issue #12 to allow agents
programmatic access to images by:

1. Saving incoming images to the local filesystem at
`~/.remote_swe_workspace/images/image[seqNo].[extension]`
2. Appending a text block after each image block with path information
3. Maintaining a sequence counter that increments for each image and
resets when the process is killed

## Implementation Details:
- Added utility functions to save images locally
- Modified `postProcessMessageContent` to append text blocks with path
info
- Images are saved as webp format (matching the existing conversion)

Fixes #12

---------

Co-authored-by: remote-swe-app[bot] <123456+remote-swe-app[bot]@users.noreply.github.com>
Co-authored-by: Masashi Tomooka <[email protected]>

Author: 3 people

AmazonQ.md

@@ -24,6 +24,7 @@ This project consists of the following main components:
 - Use Promise-based patterns for asynchronous operations
 - Use Prettier for code formatting
 - Prefer function-based implementations over classes
+- DO NOT write code comment unless the implementation is so complicated or difficult to understand without comments.
 
 ## Commonly Used Commands
 

slack-bolt-app/src/app.ts

@@ -10,6 +10,7 @@ import * as os from 'os';
 import { Message } from '@aws-sdk/client-bedrock-runtime';
 import { s3, BucketName } from './common/s3';
 import { PutObjectCommand } from '@aws-sdk/client-s3';
+import { IdempotencyAlreadyInProgressError } from '@aws-lambda-powertools/idempotency';
 
 const SigningSecret = process.env.SIGNING_SECRET!;
 const BotToken = process.env.BOT_TOKEN!;
@@ -291,6 +292,7 @@ app.event('app_mention', async ({ event, client, logger }) => {
   } catch (e: any) {
     console.log(e);
     if (e.message.includes('already_reacted')) return;
+    if (e instanceof IdempotencyAlreadyInProgressError) return;
 
     await client.chat.postMessage({
       channel,

worker/src/agent/common/messages.ts

@@ -3,6 +3,9 @@ import { PutCommand, UpdateCommand, paginateQuery, TransactWriteCommand } from '
 import { getBytesFromKey } from './s3';
 import sharp from 'sharp';
 import { ddb, TableName } from './ddb';
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import path from 'path';
+import { tmpdir } from 'os';
 
 // Maximum input token count before applying middle-out strategy
 export const MAX_INPUT_TOKEN = 80_000;
@@ -198,30 +201,73 @@ const preProcessMessageContent = async (content: Message['content']) => {
   return JSON.stringify(content);
 };
 
-const imageCache: Record<string, Buffer> = {};
+const imageCache: Record<string, { data: Buffer; localPath: string }> = {};
+let imageSeqNo = 0;
+
+const ensureImagesDirectory = () => {
+  const imagesDir = path.join(tmpdir(), `.remote-swe-images`);
+  if (!existsSync(imagesDir)) {
+    mkdirSync(imagesDir, { recursive: true });
+  }
+  return imagesDir;
+};
+
+const saveImageToLocalFs = async (imageBuffer: Buffer): Promise<string> => {
+  const imagesDir = ensureImagesDirectory();
+
+  // Since we're converting to webp above, we know the extension
+  const extension = 'webp';
+
+  // Create path with sequence number
+  const fileName = `image${imageSeqNo}.${extension}`;
+  const filePath = path.join(imagesDir, fileName);
+
+  // Write image to file
+  writeFileSync(filePath, imageBuffer);
+
+  // Increment sequence number for next image
+  imageSeqNo++;
+
+  // Return the path in the format specified in the issue
+  return filePath;
+};
+
 const postProcessMessageContent = async (content: string) => {
-  return await Promise.all(
-    JSON.parse(content).map(async (c: any) => {
-      if (!('image' in c)) return c;
-      // embed images
-      const s3Key = c.image.source.s3Key;
-      let webp: Buffer;
-      if (s3Key in imageCache) {
-        webp = imageCache[s3Key];
-      } else {
-        const file = await getBytesFromKey(s3Key);
-        // using sharp, convert file to webp
-        webp = await sharp(file).webp({ lossless: false, quality: 80 }).toBuffer();
-        imageCache[s3Key] = webp;
-      }
-      return {
-        image: {
-          format: 'webp',
-          source: {
-            bytes: webp,
-          },
+  const contentArray = JSON.parse(content);
+  const flattenedArray = [];
+
+  for (const c of contentArray) {
+    if (!('image' in c)) {
+      flattenedArray.push(c);
+      continue;
+    }
+
+    const s3Key = c.image.source.s3Key;
+    let imageBuffer: Buffer;
+    let localPath: string;
+
+    if (s3Key in imageCache) {
+      imageBuffer = imageCache[s3Key].data;
+      localPath = imageCache[s3Key].localPath;
+    } else {
+      const file = await getBytesFromKey(s3Key);
+      imageBuffer = await sharp(file).webp({ lossless: false, quality: 80 }).toBuffer();
+      localPath = await saveImageToLocalFs(imageBuffer);
+      imageCache[s3Key] = { data: imageBuffer, localPath };
+    }
+
+    flattenedArray.push({
+      image: {
+        format: 'webp',
+        source: {
+          bytes: imageBuffer,
         },
-      };
-    })
-  );
+      },
+    });
+    flattenedArray.push({
+      text: `the image is stored locally on ${localPath}`,
+    });
+  }
+
+  return flattenedArray;
 };