imagemcp-cli 1.0.0

package/README.md

@@ -0,0 +1,32 @@
+# ImageMCP CLI & Auth SDK (`imagemcp`)
+
+The official CLI and authentication SDK for [ImageMCP Server](https://api.imagemcpserver.com).
+
+## Quick Start
+
+### 1. Browser-based Authentication
+```bash
+npx imagemcp login
+```
+Opens your browser, lets you select or generate an API token, and securely stores an encrypted access token in `~/.imagemcp/config.json`.
+
+### 2. Check Auth Status
+```bash
+npx imagemcp status
+```
+
+### 3. Log Out
+```bash
+npx imagemcp logout
+```
+
+## Agent Skill Usage
+When installed via skills CLI:
+```bash
+npx skills add web5lab/imagemcpserver
+```
+If not logged in, any invocation prompts:
+```
+ImageMCPServer isn't connected yet. Run npx imagemcp login to connect your account.
+```
+Once `npx imagemcp login` is completed, skills automatically resolve and use the saved token.

package/bin/imagemcp.js

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+
+/**
+ * ImageMCP CLI - Browser-based authentication & token manager
+ */
+
+const { loginFlow, verifyToken } = require('../src/auth');
+const { loadConfig, clearConfig, GLOBAL_CONFIG_FILE } = require('../src/config');
+
+const isTTY = Boolean(process.stderr.isTTY);
+const c = {
+  reset: isTTY ? '\x1b[0m' : '',
+  bold: isTTY ? '\x1b[1m' : '',
+  green: isTTY ? '\x1b[32m' : '',
+  yellow: isTTY ? '\x1b[33m' : '',
+  cyan: isTTY ? '\x1b[36m' : '',
+  red: isTTY ? '\x1b[31m' : '',
+  dim: isTTY ? '\x1b[2m' : ''
+};
+
+async function handleLogin() {
+  const cfg = loadConfig();
+  if (cfg.apiKey) {
+    try {
+      const user = await verifyToken(cfg.apiKey, cfg.apiUrl);
+      console.log(`${c.bold}${c.green}✓ Already logged in as ${user.name} (${user.email})${c.reset}`);
+      console.log(`Stored token in ${cfg.savedTo || GLOBAL_CONFIG_FILE}\n`);
+      console.log(`Re-authenticating...`);
+    } catch (_) {
+      // Stored token invalid/expired, proceed to login
+    }
+  }
+
+  try {
+    const result = await loginFlow();
+    console.log(`${c.bold}${c.green}✓ Successfully authenticated as ${result.user.name} (${result.user.email})!${c.reset}`);
+    console.log(`${c.dim}Encrypted access token stored in ${result.savedTo}${c.reset}`);
+  } catch (err) {
+    console.error(`${c.bold}${c.red}✗ Login failed: ${err.message}${c.reset}`);
+    process.exit(1);
+  }
+}
+
+function handleLogout() {
+  const cleared = clearConfig();
+  if (cleared) {
+    console.log(`${c.bold}${c.green}✓ Successfully logged out from ImageMCP Server.${c.reset}`);
+    console.log(`Cleared config at ${GLOBAL_CONFIG_FILE}`);
+  } else {
+    console.log(`${c.yellow}No active login session found.${c.reset}`);
+  }
+}
+
+async function handleStatus() {
+  const cfg = loadConfig();
+  if (!cfg.apiKey) {
+    console.log(`${c.bold}${c.yellow}ImageMCPServer isn't connected yet. Run npx imagemcp login to connect your account.${c.reset}`);
+    process.exit(1);
+  }
+
+  try {
+    const user = await verifyToken(cfg.apiKey, cfg.apiUrl);
+    console.log(`${c.bold}${c.cyan}ImageMCP CLI Status:${c.reset}`);
+    console.log(`  User:     ${c.bold}${user.name}${c.reset} (${user.email})`);
+    console.log(`  Plan:     ${user.plan || 'free'}`);
+    console.log(`  Credits:  ${user.credits ?? 0}`);
+    console.log(`  API URL:  ${cfg.apiUrl}`);
+    console.log(`  Saved To: ${cfg.savedTo || GLOBAL_CONFIG_FILE}`);
+  } catch (err) {
+    console.error(`${c.bold}${c.red}Invalid or expired session. Run npx imagemcp login to re-authenticate.${c.reset}`);
+    process.exit(1);
+  }
+}
+
+function printHelp() {
+  console.log(`
+${c.bold}${c.cyan}ImageMCP CLI${c.reset} - Authentication & Token Management
+
+${c.bold}USAGE:${c.reset}
+  npx imagemcp <command>
+
+${c.bold}COMMANDS:${c.reset}
+  ${c.green}login${c.reset}          Log into ImageMCPServer via browser & save encrypted token
+  ${c.green}status${c.reset} (whoami)  Check current authentication status and user credits
+  ${c.green}logout${c.reset}         Remove stored authentication credentials from this machine
+  ${c.green}help${c.reset}           Display help details
+`);
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+
+  switch (command) {
+    case 'login':
+      await handleLogin();
+      break;
+    case 'logout':
+      handleLogout();
+      break;
+    case 'status':
+    case 'whoami':
+      await handleStatus();
+      break;
+    case 'help':
+    case '--help':
+    case '-h':
+      printHelp();
+      break;
+    default:
+      if (!command) {
+        printHelp();
+      } else {
+        console.error(`${c.red}Unknown command: ${command}${c.reset}`);
+        printHelp();
+        process.exit(1);
+      }
+  }
+}
+
+main();

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "imagemcp-cli",
+  "version": "1.0.0",
+  "description": "ImageMCP CLI & Authentication SDK — Seamless browser login, token encryption, and multi-model AI image generation.",
+  "main": "src/index.js",
+  "bin": {
+    "imagemcp": "bin/imagemcp.js"
+  },
+  "scripts": {
+    "login": "node bin/imagemcp.js login",
+    "status": "node bin/imagemcp.js status",
+    "logout": "node bin/imagemcp.js logout"
+  },
+  "keywords": [
+    "imagemcp",
+    "mcp",
+    "auth",
+    "cli",
+    "ai",
+    "image-generation",
+    "skills"
+  ],
+  "author": "web5lab",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/auth.js

@@ -0,0 +1,250 @@
+const http = require('http');
+const url = require('url');
+const { exec } = require('child_process');
+const { saveConfig, loadConfig } = require('./config');
+
+/**
+ * Open URL in default system web browser across OS platforms
+ */
+function openBrowser(targetUrl) {
+  const platform = process.platform;
+  let command = '';
+
+  if (platform === 'darwin') {
+    command = `open "${targetUrl}"`;
+  } else if (platform === 'win32') {
+    command = `start "" "${targetUrl}"`;
+  } else {
+    command = `xdg-open "${targetUrl}"`;
+  }
+
+  exec(command, (err) => {
+    if (err) {
+      console.error(`\x1b[33mNote: Could not open browser automatically. Please open this link manually:\x1b[0m`);
+      console.error(`  \x1b[36m${targetUrl}\x1b[0m\n`);
+    }
+  });
+}
+
+/**
+ * Verify token with ImageMCP Server backend
+ */
+async function verifyToken(token, apiUrl = 'https://api.imagemcpserver.com') {
+  const backendUrl = apiUrl.replace(/\/+$/, '');
+  const res = await fetch(`${backendUrl}/auth/user-data`, {
+    headers: {
+      'Authorization': `Bearer ${token}`,
+      'Content-Type': 'application/json'
+    }
+  });
+
+  if (!res.ok) {
+    const errorData = await res.json().catch(() => ({}));
+    throw new Error(errorData.message || `Authentication failed with status ${res.status}`);
+  }
+
+  const data = await res.json();
+  if (!data.user) {
+    throw new Error('User profile data not returned by backend');
+  }
+
+  return data.user;
+}
+
+/**
+ * HTML Response template shown in browser after login callback
+ */
+function getSuccessHtml(userName, userEmail) {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>ImageMCP CLI Authentication Successful</title>
+  <style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+      background-color: #0f172a;
+      color: #f8fafc;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      height: 100vh;
+      margin: 0;
+    }
+    .card {
+      background: #1e293b;
+      border: 1px solid #334155;
+      border-radius: 16px;
+      padding: 40px;
+      text-align: center;
+      max-width: 440px;
+      box-shadow: 0 20px 25px -5px rgba(0, 0, 0, 0.5);
+    }
+    .icon {
+      width: 64px;
+      height: 64px;
+      background: #10b981;
+      color: #ffffff;
+      border-radius: 50%;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      font-size: 32px;
+      margin: 0 auto 24px;
+    }
+    h1 { font-size: 24px; margin: 0 0 12px; font-weight: 700; color: #ffffff; }
+    p { color: #94a3b8; font-size: 15px; margin: 0 0 24px; line-height: 1.5; }
+    .user-badge {
+      background: #334155;
+      border-radius: 8px;
+      padding: 12px 16px;
+      font-size: 14px;
+      color: #38bdf8;
+      font-weight: 600;
+      margin-bottom: 24px;
+      word-break: break-all;
+    }
+    .footer { font-size: 13px; color: #64748b; }
+  </style>
+</head>
+<body>
+  <div class="card">
+    <div class="icon">✓</div>
+    <h1>CLI Connected!</h1>
+    <p>ImageMCP Server CLI has been successfully authenticated on this machine.</p>
+    <div class="user-badge">${userName || 'Authenticated User'} (${userEmail || 'ImageMCP Account'})</div>
+    <div class="footer">You can safely close this browser window and return to your terminal.</div>
+  </div>
+</body>
+</html>`;
+}
+
+function getErrorHtml(errorMessage) {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>Authentication Failed - ImageMCP</title>
+  <style>
+    body { font-family: sans-serif; background: #0f172a; color: #f8fafc; display: flex; align-items: center; justify-content: center; height: 100vh; margin: 0; }
+    .card { background: #1e293b; border: 1px solid #ef4444; border-radius: 16px; padding: 40px; text-align: center; max-width: 440px; }
+    .icon { font-size: 36px; margin-bottom: 16px; color: #ef4444; }
+    h1 { margin: 0 0 12px; color: #f87171; }
+    p { color: #cbd5e1; }
+  </style>
+</head>
+<body>
+  <div class="card">
+    <div class="icon">✕</div>
+    <h1>Authentication Failed</h1>
+    <p>${errorMessage || 'An error occurred during authentication.'}</p>
+  </div>
+</body>
+</html>`;
+}
+
+/**
+ * Execute interactive browser login flow
+ */
+function loginFlow(options = {}) {
+  const currentConfig = loadConfig();
+  const apiUrl = options.apiUrl || currentConfig.apiUrl || 'https://api.imagemcpserver.com';
+  const webUrl = options.webUrl || process.env.IMAGEMCP_WEB_URL || 'http://localhost:5173';
+
+  return new Promise((resolve, reject) => {
+    const server = http.createServer(async (req, res) => {
+      const parsedUrl = url.parse(req.url, true);
+
+      // Handle CORS for options request
+      if (req.method === 'OPTIONS') {
+        res.writeHead(204, {
+          'Access-Control-Allow-Origin': '*',
+          'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+          'Access-Control-Allow-Headers': 'Content-Type, Authorization'
+        });
+        return res.end();
+      }
+
+      if (parsedUrl.pathname === '/callback') {
+        const token = parsedUrl.query.token;
+
+        if (!token) {
+          res.writeHead(400, { 'Content-Type': 'text/html' });
+          res.end(getErrorHtml('No authentication token received in callback.'));
+          server.close();
+          return reject(new Error('No authentication token received'));
+        }
+
+        try {
+          // Verify token against ImageMCP backend
+          const user = await verifyToken(token, apiUrl);
+
+          // Save encrypted token & user data to ~/.imagemcp/config.json
+          const savedFile = saveConfig({
+            apiKey: token,
+            apiUrl,
+            user: {
+              id: user._id,
+              name: user.name,
+              email: user.email,
+              plan: user.plan || 'free',
+              credits: user.credits ?? 0
+            }
+          });
+
+          res.writeHead(200, {
+            'Content-Type': 'text/html',
+            'Access-Control-Allow-Origin': '*'
+          });
+          res.end(getSuccessHtml(user.name, user.email));
+
+          // Close server and resolve CLI login process
+          setTimeout(() => {
+            server.close();
+            resolve({
+              success: true,
+              token,
+              user,
+              savedTo: savedFile
+            });
+          }, 500);
+
+        } catch (err) {
+          res.writeHead(401, { 'Content-Type': 'text/html' });
+          res.end(getErrorHtml(`Failed to verify token: ${err.message}`));
+          server.close();
+          reject(err);
+        }
+      } else {
+        res.writeHead(404, { 'Content-Type': 'text/plain' });
+        res.end('Not found');
+      }
+    });
+
+    // Listen on random available port or fallback port
+    server.listen(0, '127.0.0.1', () => {
+      const address = server.address();
+      const port = address.port;
+
+      const authUrl = `${webUrl.replace(/\/+$/, '')}/cli-login?port=${port}&apiUrl=${encodeURIComponent(apiUrl)}`;
+
+      console.log(`\n\x1b[1m\x1b[36m--- ImageMCP CLI Authentication ---\x1b[0m\n`);
+      console.log(`Opening browser to authenticate with ImageMCPServer...`);
+      console.log(`If browser does not open automatically, visit:\n  \x1b[34m${authUrl}\x1b[0m\n`);
+      console.log(`Waiting for authentication...\n`);
+
+      openBrowser(authUrl);
+    });
+
+    server.on('error', (err) => {
+      reject(new Error(`Local authentication server failed: ${err.message}`));
+    });
+  });
+}
+
+module.exports = {
+  openBrowser,
+  verifyToken,
+  loginFlow
+};

package/src/config.js

@@ -0,0 +1,169 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+
+// Configuration directory & file paths
+const GLOBAL_CONFIG_DIR = path.join(os.homedir(), '.imagemcp');
+const GLOBAL_CONFIG_FILE = path.join(GLOBAL_CONFIG_DIR, 'config.json');
+const LOCAL_CONFIG_DIR = path.join(process.cwd(), '.imagemcp');
+const LOCAL_CONFIG_FILE = path.join(LOCAL_CONFIG_DIR, 'config.json');
+
+const DEFAULT_API_URL = process.env.IMAGEMCP_API_URL || 'https://api.imagemcpserver.com';
+
+// Derive machine-specific key for AES-256-GCM encryption
+function getMasterKey() {
+  const secretInfo = `${os.hostname()}-${os.userInfo().username}-imagemcp-secure-salt-v1`;
+  return crypto.createHash('sha256').update(secretInfo).digest();
+}
+
+/**
+ * Encrypt string data using AES-256-GCM
+ */
+function encrypt(text) {
+  if (!text) return null;
+  try {
+    const iv = crypto.randomBytes(12);
+    const key = getMasterKey();
+    const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
+    
+    let encrypted = cipher.update(text, 'utf8', 'hex');
+    encrypted += cipher.final('hex');
+    const authTag = cipher.getAuthTag().toString('hex');
+    
+    return {
+      encrypted,
+      iv: iv.toString('hex'),
+      authTag
+    };
+  } catch (err) {
+    // Fallback to unencrypted in case of crypto error
+    return { raw: text };
+  }
+}
+
+/**
+ * Decrypt data structure produced by encrypt()
+ */
+function decrypt(payload) {
+  if (!payload) return '';
+  if (typeof payload === 'string') return payload; // Legacy / plain text support
+  if (payload.raw) return payload.raw;
+
+  try {
+    const key = getMasterKey();
+    const iv = Buffer.from(payload.iv, 'hex');
+    const authTag = Buffer.from(payload.authTag, 'hex');
+    const decipher = crypto.createDecipheriv('aes-256-gcm', key, iv);
+    decipher.setAuthTag(authTag);
+
+    let decrypted = decipher.update(payload.encrypted, 'hex', 'utf8');
+    decrypted += decipher.final('utf8');
+    return decrypted;
+  } catch (err) {
+    // If decryption fails, check if plain text token exists
+    return payload.encrypted || '';
+  }
+}
+
+/**
+ * Load active config from env, local file, or global ~/.imagemcp/config.json
+ */
+function loadConfig() {
+  let config = {
+    apiKey: '',
+    apiUrl: DEFAULT_API_URL,
+    user: null,
+    savedTo: null
+  };
+
+  // 1. Environment variable override
+  if (process.env.IMAGEMCP_API_KEY || process.env.IMAGEMCP_KEY || process.env.IMAGEMCP_TOKEN) {
+    config.apiKey = process.env.IMAGEMCP_API_KEY || process.env.IMAGEMCP_KEY || process.env.IMAGEMCP_TOKEN;
+  }
+  if (process.env.IMAGEMCP_API_URL) {
+    config.apiUrl = process.env.IMAGEMCP_API_URL;
+  }
+
+  // 2. Local config file (.imagemcp/config.json)
+  if (!config.apiKey && fs.existsSync(LOCAL_CONFIG_FILE)) {
+    try {
+      const data = JSON.parse(fs.readFileSync(LOCAL_CONFIG_FILE, 'utf8'));
+      if (data.token) config.apiKey = decrypt(data.token);
+      if (data.apiUrl) config.apiUrl = data.apiUrl;
+      if (data.user) config.user = data.user;
+      config.savedTo = LOCAL_CONFIG_FILE;
+    } catch (_) {}
+  }
+
+  // 3. Global config file (~/.imagemcp/config.json)
+  if (!config.apiKey && fs.existsSync(GLOBAL_CONFIG_FILE)) {
+    try {
+      const data = JSON.parse(fs.readFileSync(GLOBAL_CONFIG_FILE, 'utf8'));
+      if (data.token) config.apiKey = decrypt(data.token);
+      if (data.apiUrl) config.apiUrl = data.apiUrl;
+      if (data.user) config.user = data.user;
+      config.savedTo = GLOBAL_CONFIG_FILE;
+    } catch (_) {}
+  }
+
+  config.apiUrl = (config.apiUrl || DEFAULT_API_URL).replace(/\/+$/, '');
+  return config;
+}
+
+/**
+ * Save configuration to global ~/.imagemcp/config.json or local .imagemcp/config.json
+ */
+function saveConfig({ apiKey, apiUrl, user }, isLocal = false) {
+  const configFile = isLocal ? LOCAL_CONFIG_FILE : GLOBAL_CONFIG_FILE;
+  const configDir = isLocal ? LOCAL_CONFIG_DIR : GLOBAL_CONFIG_DIR;
+
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true, mode: 0o700 });
+  }
+
+  let existing = {};
+  if (fs.existsSync(configFile)) {
+    try {
+      existing = JSON.parse(fs.readFileSync(configFile, 'utf8'));
+    } catch (_) {}
+  }
+
+  const encryptedToken = encrypt(apiKey);
+
+  const updated = {
+    ...existing,
+    token: encryptedToken,
+    apiUrl: apiUrl || existing.apiUrl || DEFAULT_API_URL,
+    user: user || existing.user || null,
+    updatedAt: new Date().toISOString()
+  };
+
+  fs.writeFileSync(configFile, JSON.stringify(updated, null, 2), { encoding: 'utf8', mode: 0o600 });
+  return configFile;
+}
+
+/**
+ * Clear configuration / token
+ */
+function clearConfig(isLocal = false) {
+  const configFile = isLocal ? LOCAL_CONFIG_FILE : GLOBAL_CONFIG_FILE;
+  if (fs.existsSync(configFile)) {
+    fs.unlinkSync(configFile);
+    return true;
+  }
+  return false;
+}
+
+module.exports = {
+  GLOBAL_CONFIG_DIR,
+  GLOBAL_CONFIG_FILE,
+  LOCAL_CONFIG_DIR,
+  LOCAL_CONFIG_FILE,
+  DEFAULT_API_URL,
+  loadConfig,
+  saveConfig,
+  clearConfig,
+  encrypt,
+  decrypt
+};

package/src/index.js

@@ -0,0 +1,32 @@
+const config = require('./config');
+const auth = require('./auth');
+
+/**
+ * Get active API token or null if unauthenticated
+ */
+function getToken() {
+  const cfg = config.loadConfig();
+  return cfg.apiKey || null;
+}
+
+/**
+ * Check authentication or throw helpful error message
+ */
+function requireAuth(options = {}) {
+  const cfg = config.loadConfig();
+  if (!cfg.apiKey) {
+    const message = options.customMessage || "ImageMCPServer isn't connected yet. Run npx imagemcp login to connect your account.";
+    const err = new Error(message);
+    err.code = 'UNAUTHENTICATED';
+    err.hint = "Run 'npx imagemcp login' in your terminal to log in via browser.";
+    throw err;
+  }
+  return cfg;
+}
+
+module.exports = {
+  ...config,
+  ...auth,
+  getToken,
+  requireAuth
+};