@apresai/gimage-mcp 1.2.133 → 1.2.137

package/README.md

@@ -0,0 +1,56 @@
+# @apresai/gimage-mcp
+
+MCP (Model Context Protocol) server for AI-powered image generation and processing,
+backed by the [`gimage`](https://github.com/apresai/gimage) CLI. Exposes image
+generation (Gemini, Vertex AI, AWS Bedrock, xAI Grok) plus resize/scale/crop/compress/
+convert and batch operations as MCP tools for Claude Desktop and other MCP clients.
+
+## Install
+
+```bash
+npm install -g @apresai/gimage-mcp
+```
+
+This package is a thin Node wrapper. On install it downloads the platform-native
+`gimage` binary from the matching GitHub release into the package. If your package
+manager blocks postinstall scripts, the binary is fetched automatically on first run,
+or it falls back to a `gimage` already on your `PATH` (e.g. installed via Homebrew:
+`brew install apresai/tap/gimage`).
+
+## Use with Claude Desktop
+
+Add to your MCP configuration
+(`~/Library/Application Support/Claude/claude_desktop_config.json` on macOS):
+
+```json
+{
+  "mcpServers": {
+    "gimage": {
+      "command": "npx",
+      "args": ["-y", "@apresai/gimage-mcp"]
+    }
+  }
+}
+```
+
+Running `gimage-mcp` with no arguments starts the MCP server over stdio. Any arguments
+are forwarded to the underlying `gimage` CLI, so `gimage-mcp --version` prints the
+version and `gimage-mcp serve` is equivalent to the default.
+
+## Tools
+
+`generate_image`, `resize_image`, `scale_image`, `crop_image`, `compress_image`,
+`convert_image`, `batch_resize`, `batch_compress`, `batch_convert`, `list_models`.
+
+## Configure API keys
+
+```bash
+gimage auth setup gemini
+```
+
+See the [main project README](https://github.com/apresai/gimage#readme) for full
+documentation, supported models, and pricing.
+
+## License
+
+MIT

package/gimage-mcp.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+
+const { spawn, spawnSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+// The platform gimage binary lives beside this wrapper at <package>/bin/gimage.
+function packageBinaryPath() {
+  const ext = process.platform === 'win32' ? '.exe' : '';
+  return path.join(__dirname, 'bin', `gimage${ext}`);
+}
+
+// Resolve a system-installed gimage (e.g. via Homebrew) on PATH to its full
+// path, or null if absent. Returning the resolved path (rather than the bare
+// name) lets spawn launch it directly — important on Windows, where
+// spawn('gimage') without a shell does not append .exe / search PATHEXT.
+function systemGimagePath() {
+  const probe = process.platform === 'win32' ? 'where' : 'which';
+  const result = spawnSync(probe, ['gimage'], { encoding: 'utf8' });
+  if (result.status !== 0 || !result.stdout) {
+    return null;
+  }
+  // `where` may list several matches; take the first line.
+  const first = result.stdout.split(/\r?\n/)[0].trim();
+  return first || null;
+}
+
+// Resolve the gimage binary, in order of preference:
+//   1. the version-pinned binary bundled into this package (downloaded by the
+//      postinstall hook),
+//   2. a system gimage on PATH (Homebrew, manual install),
+//   3. a lazy download into the package bin/ — this covers the case where npm's
+//      allow-scripts gate blocked postinstall so the binary was never fetched.
+async function resolveBinary() {
+  const pkgBinary = packageBinaryPath();
+  if (fs.existsSync(pkgBinary)) {
+    return pkgBinary;
+  }
+  const systemBinary = systemGimagePath();
+  if (systemBinary) {
+    return systemBinary;
+  }
+  // install.js logs progress to stderr, so this is safe to run right before
+  // launching the MCP server (whose stdout is the JSON-RPC channel).
+  const { ensureBinary } = require('./scripts/install.js');
+  return ensureBinary();
+}
+
+async function main() {
+  let binaryPath;
+  try {
+    binaryPath = await resolveBinary();
+  } catch (error) {
+    console.error('Failed to locate or download the gimage binary:', error.message);
+    console.error('\nInstall gimage manually:');
+    console.error('  npm install -g @apresai/gimage-mcp');
+    console.error('  or');
+    console.error('  brew install apresai/tap/gimage');
+    console.error('\nSee: https://github.com/apresai/gimage');
+    process.exit(1);
+  }
+
+  // Forward any args straight through to gimage. With no args, default to the MCP
+  // server so `npx -y @apresai/gimage-mcp` launches it for Claude Desktop, while
+  // `gimage-mcp --version`, `gimage-mcp serve`, etc. pass through unchanged.
+  const forwarded = process.argv.slice(2);
+  const args = forwarded.length > 0 ? forwarded : ['serve'];
+
+  const child = spawn(binaryPath, args, {
+    stdio: 'inherit',
+    env: process.env
+  });
+
+  child.on('error', (error) => {
+    console.error('Failed to start gimage:', error.message);
+    console.error('\nPlease ensure gimage is installed:');
+    console.error('  npm install -g @apresai/gimage-mcp');
+    console.error('  or');
+    console.error('  brew install apresai/tap/gimage');
+    process.exit(1);
+  });
+
+  child.on('exit', (code) => {
+    process.exit(code || 0);
+  });
+
+  // Forward termination signals for graceful shutdown.
+  process.on('SIGINT', () => child.kill('SIGINT'));
+  process.on('SIGTERM', () => child.kill('SIGTERM'));
+}
+
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apresai/gimage-mcp",
-  "version": "1.2.133",
+  "version": "1.2.137",
   "description": "MCP server for AI-powered image generation and processing with gimage",
   "keywords": [
     "mcp",
@@ -26,13 +26,14 @@
     "url": "https://github.com/apresai/gimage/issues"
   },
   "bin": {
-    "gimage-mcp": "./bin/gimage-mcp.js"
+    "gimage-mcp": "./gimage-mcp.js"
   },
   "scripts": {
-    "postinstall": "node scripts/install.js"
+    "postinstall": "node scripts/install.js",
+    "test": "node --test"
   },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=22.0.0"
   },
   "os": [
     "darwin",
@@ -44,7 +45,7 @@
     "arm64"
   ],
   "files": [
-    "bin/",
+    "gimage-mcp.js",
     "scripts/",
     "README.md"
   ],

package/scripts/install.js

@@ -6,7 +6,10 @@ const path = require('path');
 const tar = require('tar');
 
 const GITHUB_REPO = 'apresai/gimage';
-const VERSION = process.env.npm_package_version || '0.1.0';
+// npm sets npm_package_version during the install lifecycle (postinstall). When
+// this module is require()'d at runtime by the bin wrapper that env var is unset,
+// so fall back to the package's own version.
+const VERSION = process.env.npm_package_version || require('../package.json').version;
 
 function getPlatformInfo() {
   const platform = process.platform;
@@ -27,7 +30,11 @@ function getPlatformInfo() {
   const mappedArch = archMap[arch];
 
   if (!mappedPlatform || !mappedArch) {
-    throw new Error(`Unsupported platform: ${platform}-${arch}`);
+    throw new Error(
+      `Unsupported platform: ${platform}-${arch}. ` +
+      `Install gimage manually from https://github.com/${GITHUB_REPO}/releases ` +
+      `or via Homebrew: brew install apresai/tap/gimage`
+    );
   }
 
   return {
@@ -37,6 +44,13 @@ function getPlatformInfo() {
   };
 }
 
+// binaryPath returns where the platform gimage binary lives (or will live) inside
+// the package: <package>/bin/gimage[.exe].
+function binaryPath() {
+  const { ext } = getPlatformInfo();
+  return path.join(__dirname, '..', 'bin', `gimage${ext}`);
+}
+
 async function downloadBinary() {
   const { platform, arch, ext } = getPlatformInfo();
   const binaryName = `gimage${ext}`;
@@ -51,100 +65,74 @@ async function downloadBinary() {
   const url = `https://github.com/${GITHUB_REPO}/releases/download/v${VERSION}/${tarballName}`;
 
   const binDir = path.join(__dirname, '..', 'bin');
-  const binaryPath = path.join(binDir, binaryName);
+  const binaryDest = path.join(binDir, binaryName);
 
   // Create bin directory if it doesn't exist
   if (!fs.existsSync(binDir)) {
     fs.mkdirSync(binDir, { recursive: true });
   }
 
-  console.log(`Downloading gimage binary for ${platform}-${arch}...`);
-  console.log(`URL: ${url}`);
+  // Progress goes to stderr so it never corrupts the MCP server's stdout
+  // JSON-RPC stream when this runs as a lazy download just before `gimage serve`.
+  console.error(`Downloading gimage binary for ${platform}-${arch}...`);
+  console.error(`URL: ${url}`);
+
+  function extractFrom(response, resolve, reject) {
+    const tarPath = path.join(binDir, tarballName);
+    const file = fs.createWriteStream(tarPath);
+    response.pipe(file);
+    file.on('finish', async () => {
+      file.close();
+      try {
+        await tar.x({ file: tarPath, cwd: binDir });
+        fs.unlinkSync(tarPath);
+        if (platform !== 'windows') {
+          fs.chmodSync(binaryDest, 0o755);
+        }
+        console.error('✓ gimage binary installed successfully');
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+    file.on('error', reject);
+  }
 
   return new Promise((resolve, reject) => {
     https.get(url, (response) => {
       if (response.statusCode === 302 || response.statusCode === 301) {
-        // Follow redirect
+        // Follow redirect (GitHub release assets redirect to a CDN)
         https.get(response.headers.location, (redirectResponse) => {
           if (redirectResponse.statusCode !== 200) {
-            reject(new Error(`Download failed with status ${redirectResponse.statusCode}`));
+            reject(new Error(`Download failed with status ${redirectResponse.statusCode} for ${url}`));
             return;
           }
-
-          const tarPath = path.join(binDir, tarballName);
-          const file = fs.createWriteStream(tarPath);
-
-          redirectResponse.pipe(file);
-
-          file.on('finish', async () => {
-            file.close();
-
-            try {
-              // Extract tarball
-              await tar.x({
-                file: tarPath,
-                cwd: binDir
-              });
-
-              // Remove tarball
-              fs.unlinkSync(tarPath);
-
-              // Make binary executable (Unix-like systems)
-              if (platform !== 'windows') {
-                fs.chmodSync(binaryPath, 0o755);
-              }
-
-              console.log('✓ gimage binary installed successfully');
-              resolve();
-            } catch (err) {
-              reject(err);
-            }
-          });
-
-          file.on('error', reject);
+          extractFrom(redirectResponse, resolve, reject);
         }).on('error', reject);
       } else if (response.statusCode === 200) {
-        const tarPath = path.join(binDir, tarballName);
-        const file = fs.createWriteStream(tarPath);
-
-        response.pipe(file);
-
-        file.on('finish', async () => {
-          file.close();
-
-          try {
-            // Extract tarball
-            await tar.x({
-              file: tarPath,
-              cwd: binDir
-            });
-
-            // Remove tarball
-            fs.unlinkSync(tarPath);
-
-            // Make binary executable (Unix-like systems)
-            if (platform !== 'windows') {
-              fs.chmodSync(binaryPath, 0o755);
-            }
-
-            console.log('✓ gimage binary installed successfully');
-            resolve();
-          } catch (err) {
-            reject(err);
-          }
-        });
-
-        file.on('error', reject);
+        extractFrom(response, resolve, reject);
       } else {
-        reject(new Error(`Download failed with status ${response.statusCode}`));
+        reject(new Error(`Download failed with status ${response.statusCode} for ${url}`));
       }
     }).on('error', reject);
   });
 }
 
+// ensureBinary is idempotent: it returns the path to the platform binary,
+// downloading it only if it is not already present. Safe to call from both the
+// postinstall hook and the runtime bin wrapper.
+async function ensureBinary() {
+  const target = binaryPath();
+  if (fs.existsSync(target)) {
+    return target;
+  }
+  await downloadBinary();
+  return target;
+}
+
 async function main() {
   try {
-    await downloadBinary();
+    await ensureBinary();
     console.log('\n✓ Installation complete!');
     console.log('\nTo use with Claude Desktop, add this to your MCP configuration:');
     console.log('\nmacOS: ~/Library/Application Support/Claude/claude_desktop_config.json');
@@ -159,16 +147,20 @@ async function main() {
     console.log('  }');
     console.log('}');
     console.log('\nBefore using, configure your API keys:');
-    console.log('  gimage auth gemini');
+    console.log('  gimage auth setup gemini');
     console.log('\nFor more information: https://github.com/apresai/gimage');
   } catch (error) {
-    console.error('Installation failed:', error.message);
-    console.error('\nFallback options:');
-    console.error('1. Install gimage manually from: https://github.com/' + GITHUB_REPO + '/releases');
-    console.error('2. Install via Homebrew: brew install gimage');
-    console.error('3. Build from source: https://github.com/' + GITHUB_REPO + '#building-from-source');
-    process.exit(1);
+    // Non-fatal: the bin wrapper will lazily retry the download (or fall back to
+    // a system gimage on PATH) on first run, so don't fail the whole install.
+    console.error('Postinstall could not download the gimage binary:', error.message);
+    console.error('It will be fetched automatically on first run, or install manually:');
+    console.error('1. From releases: https://github.com/' + GITHUB_REPO + '/releases');
+    console.error('2. Via Homebrew:  brew install apresai/tap/gimage');
   }
 }
 
-main();
+module.exports = { ensureBinary, downloadBinary, binaryPath, getPlatformInfo };
+
+if (require.main === module) {
+  main();
+}