opencode-image-compressor 0.1.0

package/README.md

@@ -0,0 +1,72 @@
+# Opencode Image Compressor plugin
+
+`opencode-image-compressor` shrinks large image attachments into smaller JPEG payloads before they are passed into the model.
+
+## What it does
+
+- checks supported images larger than `200 KB`
+- rewrites successful outputs as `image/jpeg`
+- aims for roughly `50 KB`
+- accepts results up to `200 KB`
+- supports `image/jpeg`, `image/jpg`, `image/pjpeg`, `image/png`, and `image/webp`
+- does not process GIF input
+- keeps the original file when recompression fails or would not reduce size
+
+## Installation
+
+Requirements:
+
+- OpenCode plugin support with `@opencode-ai/plugin >= 1.2.27`
+- a working `sharp` install in the runtime environment
+
+This plugin is intended to work on macOS, Linux and Windows as long as `sharp` installs and loads correctly on that machine.
+
+```bash
+bun add opencode-image-compressor
+```
+
+Then add it to `opencode.json`:
+
+```json
+{
+  "plugin": ["opencode-image-compressor"]
+}
+```
+
+If installing from source:
+
+```bash
+bun install
+bun run build
+```
+
+## Development
+
+```bash
+bun install
+bun run typecheck
+bun run build
+```
+
+## Debug logging
+
+Enable verbose logging:
+
+```bash
+OPENCODE_IMAGE_COMPRESSOR_DEBUG=true
+```
+
+Optional custom log file path:
+
+```bash
+OPENCODE_IMAGE_COMPRESSOR_DEBUG_LOG_PATH=/tmp/opencode-image-compressor.log
+```
+
+When enabled, the plugin:
+
+- appends trace lines to the log file for each inspected attachment
+- emits runtime status lines to stderr
+
+When debug is disabled, routine status messages stay silent and only actual errors are written to stderr.
+
+On macOS, `/tmp` maps to `/private/tmp`, so check both locations if needed.

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import { Plugin } from '@opencode-ai/plugin';
+
+declare const imageCompressor: Plugin;
+
+export { imageCompressor as default };

package/dist/index.js

@@ -0,0 +1,327 @@
+// src/config.ts
+function envBool(name, fallback) {
+  const value = process.env[name]?.trim().toLowerCase();
+  if (!value) return fallback;
+  return value === "1" || value === "true" || value === "yes" || value === "on";
+}
+var DEFAULT_CONFIG = {
+  minBytesForCompression: 200 * 1024,
+  targetBytes: 50 * 1024,
+  maxOutputBytes: 200 * 1024,
+  debug: envBool("OPENCODE_IMAGE_COMPRESSOR_DEBUG", false),
+  debugLogPath: process.env.OPENCODE_IMAGE_COMPRESSOR_DEBUG_LOG_PATH || "/tmp/opencode-image-compressor.log",
+  background: { r: 255, g: 255, b: 255 },
+  supportedMimes: ["image/jpeg", "image/jpg", "image/pjpeg", "image/png", "image/webp"],
+  compressionPasses: [
+    { maxEdge: null, quality: 55 },
+    { maxEdge: null, quality: 45 },
+    { maxEdge: 1600, quality: 40 },
+    { maxEdge: 1280, quality: 35 },
+    { maxEdge: 1024, quality: 32 },
+    { maxEdge: 768, quality: 30 },
+    { maxEdge: 640, quality: 28 }
+  ],
+  cacheEntries: 128
+};
+function createConfig(overrides) {
+  return {
+    ...DEFAULT_CONFIG,
+    ...overrides,
+    debug: overrides?.debug ?? DEFAULT_CONFIG.debug,
+    debugLogPath: overrides?.debugLogPath ?? DEFAULT_CONFIG.debugLogPath,
+    background: overrides?.background ?? DEFAULT_CONFIG.background,
+    supportedMimes: overrides?.supportedMimes ?? DEFAULT_CONFIG.supportedMimes,
+    compressionPasses: overrides?.compressionPasses ?? DEFAULT_CONFIG.compressionPasses
+  };
+}
+
+// src/compression/cache.ts
+import { createHash } from "crypto";
+var AttachmentCache = class {
+  constructor(maxEntries) {
+    this.maxEntries = maxEntries;
+  }
+  maxEntries;
+  entries = /* @__PURE__ */ new Map();
+  keyFor(buffer) {
+    return createHash("sha1").update(buffer).digest("hex");
+  }
+  get(key) {
+    const value = this.entries.get(key);
+    if (!value) return void 0;
+    this.entries.delete(key);
+    this.entries.set(key, value);
+    return value;
+  }
+  set(key, value) {
+    if (this.entries.has(key)) {
+      this.entries.delete(key);
+    }
+    this.entries.set(key, value);
+    if (this.entries.size > this.maxEntries) {
+      const oldest = this.entries.keys().next().value;
+      if (oldest) this.entries.delete(oldest);
+    }
+  }
+};
+
+// src/compression/compress.ts
+import sharp from "sharp";
+var LIMIT_INPUT_PIXELS = 16383 * 16383;
+async function readMeta(buffer) {
+  const meta = await sharp(buffer, { limitInputPixels: LIMIT_INPUT_PIXELS }).metadata();
+  return {
+    width: meta.width ?? 0,
+    height: meta.height ?? 0
+  };
+}
+function unchanged(buffer, reason, meta) {
+  return {
+    changed: false,
+    buffer,
+    originalBytes: buffer.length,
+    outputBytes: buffer.length,
+    width: meta?.width ?? 0,
+    height: meta?.height ?? 0,
+    quality: null,
+    maxEdge: null,
+    reason
+  };
+}
+async function encodeCandidate(input, step, background) {
+  let pipeline = sharp(input, { limitInputPixels: LIMIT_INPUT_PIXELS }).rotate();
+  if (step.maxEdge) {
+    pipeline = pipeline.resize({
+      width: step.maxEdge,
+      height: step.maxEdge,
+      fit: "inside",
+      withoutEnlargement: true
+    });
+  }
+  pipeline = pipeline.flatten({ background }).jpeg({
+    quality: step.quality,
+    mozjpeg: true,
+    progressive: true
+  });
+  const { data, info } = await pipeline.toBuffer({ resolveWithObject: true });
+  return { buffer: data, width: info.width, height: info.height };
+}
+async function compressAggressively(buffer, config = DEFAULT_CONFIG) {
+  if (buffer.length <= config.minBytesForCompression) {
+    return unchanged(buffer, "under threshold");
+  }
+  try {
+    const meta = await readMeta(buffer);
+    let best = null;
+    for (const step of config.compressionPasses) {
+      const candidate = await encodeCandidate(buffer, step, config.background);
+      const result = {
+        changed: true,
+        buffer: candidate.buffer,
+        originalBytes: buffer.length,
+        outputBytes: candidate.buffer.length,
+        width: candidate.width,
+        height: candidate.height,
+        quality: step.quality,
+        maxEdge: step.maxEdge,
+        reason: "optimized"
+      };
+      if (result.outputBytes >= result.originalBytes) {
+        continue;
+      }
+      if (result.outputBytes <= config.targetBytes) {
+        return result;
+      }
+      if (result.outputBytes <= config.maxOutputBytes) {
+        if (!best || result.outputBytes < best.outputBytes) {
+          best = result;
+        }
+      }
+    }
+    return best ?? unchanged(buffer, "could not reach output policy", meta);
+  } catch {
+    return unchanged(buffer, "compression failed");
+  }
+}
+
+// src/logger.ts
+import fs from "fs/promises";
+var PREFIX = "[image-compressor]";
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function logConsole(config, message) {
+  if (!config.debug) return;
+  console.error(`${PREFIX} ${message}`);
+}
+function logReady(config) {
+  logConsole(config, "Ready to recompress large image attachments");
+}
+function logCompressed(config, result) {
+  logConsole(
+    config,
+    `Compressed ${formatBytes(result.originalBytes)} \u2192 ${formatBytes(result.outputBytes)} (jpeg, ${result.width}x${result.height}, q=${result.quality ?? "-"}, edge=${result.maxEdge ?? "orig"})`
+  );
+}
+function logBypassed(config, reason) {
+  logConsole(config, `Bypassed attachment: ${reason}`);
+}
+function logError(error) {
+  console.error(`${PREFIX} Error: ${error.message}`);
+}
+async function logDebug(config, message) {
+  if (!config.debug) return;
+  const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${message}
+`;
+  try {
+    await fs.appendFile(config.debugLogPath, line, "utf8");
+  } catch {
+    console.error(`${PREFIX} Failed writing debug log: ${config.debugLogPath}`);
+  }
+}
+
+// src/attachments/resolve.ts
+import fs2 from "fs/promises";
+import { fileURLToPath } from "url";
+var DATA_URI_PREFIX = "data:";
+var BASE64_MARKER = ";base64,";
+function isSupportedMime(mime, config) {
+  return config.supportedMimes.includes(mime);
+}
+function parseDataUri(url, config) {
+  if (!url.startsWith(DATA_URI_PREFIX)) return null;
+  const markerIndex = url.indexOf(BASE64_MARKER);
+  if (markerIndex === -1) return null;
+  const mime = url.slice(DATA_URI_PREFIX.length, markerIndex);
+  if (!isSupportedMime(mime, config)) return null;
+  const base64 = url.slice(markerIndex + BASE64_MARKER.length);
+  if (!base64) return null;
+  return Buffer.from(base64, "base64");
+}
+async function resolveImageBuffer(url, mime, config) {
+  if (!isSupportedMime(mime, config)) return null;
+  const parsed = parseDataUri(url, config);
+  if (parsed) return parsed;
+  try {
+    if (url.startsWith("file://")) {
+      return await fs2.readFile(fileURLToPath(url));
+    }
+    if (url.startsWith("/")) {
+      return await fs2.readFile(url);
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function toJpegDataUri(buffer) {
+  return `data:image/jpeg;base64,${buffer.toString("base64")}`;
+}
+
+// src/attachments/rewriter.ts
+function createAttachmentRewriter(config) {
+  const cache = new AttachmentCache(config.cacheEntries);
+  return async function rewriteAttachment(attachment) {
+    await logDebug(config, `inspect attachment mime=${attachment.mime} urlPrefix=${attachment.url.slice(0, 48)}`);
+    const sourceBuffer = await resolveImageBuffer(attachment.url, attachment.mime, config);
+    if (!sourceBuffer) {
+      await logDebug(config, `ignore attachment reason=unresolved-or-unsupported mime=${attachment.mime}`);
+      logBypassed(config, "unsupported or unreadable image payload");
+      return;
+    }
+    const key = cache.keyFor(sourceBuffer);
+    const cached = cache.get(key);
+    await logDebug(
+      config,
+      `resolved bytes=${sourceBuffer.length} cache=${cached ? "hit" : "miss"} mime=${attachment.mime}`
+    );
+    const result = cached ?? await compressAggressively(sourceBuffer, config);
+    if (!cached) cache.set(key, result);
+    if (!result.changed) {
+      await logDebug(config, `leave-original reason=${result.reason} bytes=${result.outputBytes}`);
+      logBypassed(config, result.reason);
+      return;
+    }
+    try {
+      attachment.url = toJpegDataUri(result.buffer);
+      attachment.mime = "image/jpeg";
+      await logDebug(
+        config,
+        `rewrite attachment original=${result.originalBytes} output=${result.outputBytes} q=${result.quality ?? "-"} edge=${result.maxEdge ?? "orig"}`
+      );
+      logCompressed(config, result);
+    } catch (error) {
+      await logDebug(config, `error applying optimized payload: ${String(error)}`);
+      logError(error instanceof Error ? error : new Error(String(error)));
+    }
+  };
+}
+
+// src/hooks/run-hook-safely.ts
+async function runHookSafely(task) {
+  try {
+    await task();
+  } catch (error) {
+    logError(error instanceof Error ? error : new Error(String(error)));
+  }
+}
+
+// src/hooks/tool-hook.ts
+function createToolHook(config) {
+  const rewriteAttachment = createAttachmentRewriter(config);
+  return async (input, output) => {
+    await runHookSafely(async () => {
+      if (input.tool !== "read") return;
+      const attachments = output.attachments;
+      if (!attachments?.length) return;
+      for (const attachment of attachments) {
+        if (attachment.type !== "file") continue;
+        await rewriteAttachment(attachment);
+      }
+    });
+  };
+}
+
+// src/hooks/message-hook.ts
+function isDirectAttachment(part) {
+  return typeof part.mime === "string" && typeof part.url === "string";
+}
+function createMessageHook(config) {
+  const rewriteAttachment = createAttachmentRewriter(config);
+  return async (_input, output) => {
+    await runHookSafely(async () => {
+      for (const message of output.messages) {
+        for (const part of message.parts) {
+          if (part.type === "tool") {
+            if (part.state?.status !== "completed" || !part.state.attachments?.length) {
+              continue;
+            }
+            for (const attachment of part.state.attachments) {
+              await rewriteAttachment(attachment);
+            }
+            continue;
+          }
+          if (isDirectAttachment(part)) {
+            await rewriteAttachment(part);
+          }
+        }
+      }
+    });
+  };
+}
+
+// src/index.ts
+var imageCompressor = async () => {
+  const config = createConfig();
+  logReady(config);
+  return {
+    "tool.execute.after": createToolHook(config),
+    "experimental.chat.messages.transform": createMessageHook(config)
+  };
+};
+var index_default = imageCompressor;
+export {
+  index_default as default
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "opencode-image-compressor",
+  "version": "0.1.0",
+  "description": "OpenCode plugin that recompresses large image attachments into model-friendly JPEG payloads",
+  "type": "module",
+  "main": "dist/index.js",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "opencode",
+    "plugin",
+    "image",
+    "jpeg",
+    "compression",
+    "attachments",
+    "images"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "sharp": "^0.33.0"
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": ">=1.2.27"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "^1.2.27",
+    "@types/bun": "latest",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "bun run typecheck && bun run build"
+  }
+}