repoimage 0.2.0

package/server/src/scan.ts

@@ -0,0 +1,203 @@
+import fs from 'fs';
+import path from 'path';
+import sizeOf from 'image-size';
+import {
+  IMAGE_EXTENSIONS,
+  COMMON_EXCLUDE_PATHS,
+  guessRole,
+  type ImageRow,
+  type RawImageEntry,
+  type ScanIssue
+} from '@repoimage/shared';
+
+export { IMAGE_EXTENSIONS };
+
+export function computeCompressionFields(
+  ext: string,
+  fileSize: number,
+  width: number | null | undefined,
+  height: number | null | undefined
+): { uncompressedSize: number | null; compressionRatio: string | null } {
+  let uncompressedSize: number | null = null;
+  let compressionRatio: string | null = null;
+
+  if (width && height && !['.svg'].includes(ext)) {
+    const bytesPerPixel = ['.png', '.gif'].includes(ext) ? 4 : 3;
+    uncompressedSize = width * height * bytesPerPixel;
+    const linearRatio = fileSize / uncompressedSize;
+    const logScore = Math.max(0, Math.min(10, -Math.log2(linearRatio)));
+    compressionRatio = logScore.toFixed(1);
+  }
+
+  return { uncompressedSize, compressionRatio };
+}
+
+export function enrichImageEntry(entry: RawImageEntry): ImageRow | null {
+  const relativePath = String(entry.path || '').replace(/\\/g, '/').trim();
+  if (!relativePath || relativePath.split('/').includes('..')) {
+    return null;
+  }
+
+  const size = Number(entry.size);
+  if (!Number.isFinite(size) || size < 0) {
+    return null;
+  }
+
+  let width: number | null = entry.width != null ? Number(entry.width) : null;
+  let height: number | null = entry.height != null ? Number(entry.height) : null;
+  if (!Number.isFinite(width)) width = null;
+  if (!Number.isFinite(height)) height = null;
+
+  const ext = path.extname(relativePath).toLowerCase();
+  const { uncompressedSize, compressionRatio } = computeCompressionFields(
+    ext,
+    size,
+    width,
+    height
+  );
+  const { roleGuess, roleGuessReason } = guessRole({
+    path: relativePath,
+    size,
+    width,
+    height
+  });
+
+  const row: ImageRow = {
+    path: relativePath,
+    size: Math.round(size),
+    width,
+    height,
+    uncompressedSize,
+    compressionRatio,
+    role: null,
+    roleGuess
+  };
+
+  if (roleGuessReason) {
+    row.roleGuessReason = roleGuessReason;
+  }
+
+  return row;
+}
+
+function isImageFile(filename: string): boolean {
+  const ext = path.extname(filename).toLowerCase();
+  return (IMAGE_EXTENSIONS as readonly string[]).includes(ext);
+}
+
+function shouldExcludePath(dirName: string, excludeCommon: boolean): boolean {
+  if (!excludeCommon) {
+    return false;
+  }
+  return (COMMON_EXCLUDE_PATHS as readonly string[]).includes(dirName);
+}
+
+interface WalkRow {
+  path: string;
+  size: number;
+  width: number | null;
+  height: number | null;
+}
+
+interface WalkContext {
+  issues: ScanIssue[];
+  verbose: boolean;
+  excludeCommon: boolean;
+}
+
+function walkDirectory(
+  dirPath: string,
+  imageFiles: WalkRow[],
+  ctx: WalkContext
+): WalkRow[] {
+  try {
+    const items = fs.readdirSync(dirPath);
+
+    for (const item of items) {
+      const fullPath = path.join(dirPath, item);
+      const stat = fs.statSync(fullPath);
+
+      if (stat.isDirectory()) {
+        if (!shouldExcludePath(item, ctx.excludeCommon)) {
+          walkDirectory(fullPath, imageFiles, ctx);
+        }
+      } else if (stat.isFile() && isImageFile(item)) {
+        try {
+          const dimensions = sizeOf(fullPath);
+          imageFiles.push({
+            path: fullPath,
+            size: stat.size,
+            width: dimensions.width ?? null,
+            height: dimensions.height ?? null
+          });
+        } catch {
+          imageFiles.push({
+            path: fullPath,
+            size: stat.size,
+            width: null,
+            height: null
+          });
+        }
+      }
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    ctx.issues.push({ code: 'DIR_READ_ERROR', path: dirPath, message });
+    if (ctx.verbose) {
+      console.error(`Error reading directory ${dirPath}:`, message);
+    }
+  }
+
+  return imageFiles;
+}
+
+export function findImagesInFolders(
+  folders: string[],
+  options: { verbose?: boolean; excludeCommon?: boolean } = {}
+): { images: ImageRow[]; issues: ScanIssue[] } {
+  const verbose = Boolean(options.verbose);
+  const excludeCommon = Boolean(options.excludeCommon);
+  const issues: ScanIssue[] = [];
+  const ctx = { issues, verbose, excludeCommon };
+  const allImages: ImageRow[] = [];
+
+  for (const folder of folders) {
+    if (!fs.existsSync(folder)) {
+      const message = `Folder does not exist: ${folder}`;
+      issues.push({ code: 'MISSING_FOLDER', path: folder, message });
+      if (verbose) {
+        console.error(message);
+      }
+      continue;
+    }
+
+    if (verbose) {
+      console.log(`Scanning folder: ${folder}`);
+    }
+
+    const images = walkDirectory(folder, [], ctx);
+    const relativeImages = images
+      .map(image => {
+        const relativePath = path.relative(folder, image.path).split(path.sep).join('/');
+        return enrichImageEntry({
+          path: relativePath,
+          size: image.size,
+          width: image.width,
+          height: image.height
+        });
+      })
+      .filter((row): row is ImageRow => row != null);
+
+    allImages.push(...relativeImages);
+  }
+
+  return { images: allImages, issues };
+}
+
+export function sortByCompressionScore(images: ImageRow[]): ImageRow[] {
+  return [...images].sort((a, b) => {
+    const scoreA = parseFloat(a.compressionRatio ?? '') || 0;
+    const scoreB = parseFloat(b.compressionRatio ?? '') || 0;
+    return scoreB - scoreA;
+  });
+}

package/server/src/server.ts

@@ -0,0 +1,356 @@
+import http from 'http';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { IMAGE_EXTENSIONS } from '@repoimage/shared';
+import { listDirectory } from './fs-list';
+import {
+  enrichImageEntry,
+  findImagesInFolders,
+  sortByCompressionScore
+} from './scan';
+import { defaultClientRoot } from './paths';
+
+const MAX_SCAN_ENTRIES = 100_000;
+
+function isLoopbackAddress(addr: string | undefined): boolean {
+  if (addr == null) return true;
+  const a = String(addr);
+  return a === '127.0.0.1' || a === '::1' || a === '::ffff:127.0.0.1';
+}
+
+function assertLoopbackForFsApi(
+  req: http.IncomingMessage,
+  res: http.ServerResponse
+): boolean {
+  if (process.env.REPOIMAGE_FS_TRUST_REMOTE === '1') {
+    return true;
+  }
+  const addr = req.socket.remoteAddress;
+  if (!isLoopbackAddress(addr)) {
+    sendJson(res, 403, {
+      error:
+        'Filesystem API is only available to loopback clients. Set REPOIMAGE_FS_TRUST_REMOTE=1 to disable this check (not recommended).'
+    });
+    return false;
+  }
+  return true;
+}
+
+function resolveScanFolders(body: Record<string, unknown>): string[] {
+  if (typeof body.folder === 'string' && body.folder.trim()) {
+    return [body.folder.trim()];
+  }
+  if (Array.isArray(body.folders)) {
+    return body.folders
+      .map(f => (typeof f === 'string' ? f.trim() : ''))
+      .filter(Boolean);
+  }
+  return [];
+}
+
+const IMAGE_FILE_EXTS = new Set<string>(IMAGE_EXTENSIONS);
+
+const MIME: Record<string, string> = {
+  '.html': 'text/html; charset=utf-8',
+  '.css': 'text/css; charset=utf-8',
+  '.js': 'application/javascript; charset=utf-8',
+  '.json': 'application/json; charset=utf-8',
+  '.ico': 'image/x-icon',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.bmp': 'image/bmp',
+  '.tif': 'image/tiff',
+  '.tiff': 'image/tiff',
+  '.webp': 'image/webp',
+  '.svg': 'image/svg+xml',
+  '.avif': 'image/avif',
+  '.heic': 'image/heic',
+  '.heif': 'image/heif'
+};
+
+function readJsonBody(req: http.IncomingMessage): Promise<Record<string, unknown>> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = [];
+    req.on('data', chunk => chunks.push(chunk));
+    req.on('end', () => {
+      const raw = Buffer.concat(chunks).toString('utf8');
+      if (!raw.trim()) {
+        resolve({});
+        return;
+      }
+      try {
+        resolve(JSON.parse(raw) as Record<string, unknown>);
+      } catch (e) {
+        reject(e);
+      }
+    });
+    req.on('error', reject);
+  });
+}
+
+function send(
+  res: http.ServerResponse,
+  status: number,
+  body: string | Buffer,
+  headers: Record<string, string> = {}
+): void {
+  const buf = Buffer.isBuffer(body) ? body : Buffer.from(body, 'utf8');
+  res.writeHead(status, {
+    'Content-Length': buf.length,
+    ...headers
+  });
+  res.end(buf);
+}
+
+function sendJson(res: http.ServerResponse, status: number, obj: unknown): void {
+  send(res, status, JSON.stringify(obj), {
+    'Content-Type': 'application/json; charset=utf-8'
+  });
+}
+
+export interface RepoimageServerOptions {
+  clientRoot?: string;
+}
+
+export function createRepoimageServer(options: RepoimageServerOptions = {}): http.Server {
+  const clientRoot = path.resolve(options.clientRoot ?? defaultClientRoot());
+
+  function safeStaticFile(urlPath: string): string | null {
+    const decoded = decodeURIComponent((urlPath || '').split('?')[0]);
+    if (decoded.includes('..')) {
+      return null;
+    }
+    const rel = decoded === '/' || decoded === '' ? 'index.html' : decoded.replace(/^\/+/, '');
+    const full = path.resolve(path.join(clientRoot, rel));
+    const root = path.resolve(clientRoot);
+    if (full !== root && !full.startsWith(root + path.sep)) {
+      return null;
+    }
+    return full;
+  }
+
+  function serveSpaIndex(res: http.ServerResponse): void {
+    const indexPath = path.join(clientRoot, 'index.html');
+    if (!fs.existsSync(indexPath)) {
+      send(
+        res,
+        503,
+        'Client not built. Run npm run build from the repo root.',
+        { 'Content-Type': 'text/plain; charset=utf-8' }
+      );
+      return;
+    }
+    send(res, 200, fs.readFileSync(indexPath), {
+      'Content-Type': 'text/html; charset=utf-8'
+    });
+  }
+
+  return http.createServer(async (req, res) => {
+    const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
+
+    if (req.method === 'POST' && url.pathname === '/api/scan') {
+      try {
+        const body = await readJsonBody(req);
+        const rawFolders = resolveScanFolders(body);
+        const normalized = rawFolders.map(f => path.resolve(f)).filter(Boolean);
+
+        if (normalized.length === 0) {
+          sendJson(res, 400, {
+            error: 'Provide a project root: non-empty string "folder" or "folders" array.'
+          });
+          return;
+        }
+
+        const sortByScore = Boolean(body.sortByScore);
+        const excludeCommon = Boolean(body.excludeCommonFolders);
+        const { images, issues } = findImagesInFolders(normalized, {
+          verbose: false,
+          excludeCommon
+        });
+        const imagesOut = sortByScore ? sortByCompressionScore(images) : images;
+
+        sendJson(res, 200, { images: imagesOut, issues });
+      } catch (e) {
+        sendJson(res, 400, {
+          error: 'Invalid JSON body',
+          detail: String(e instanceof Error ? e.message : e)
+        });
+      }
+      return;
+    }
+
+    if (req.method === 'POST' && url.pathname === '/api/scan-entries') {
+      try {
+        const body = await readJsonBody(req);
+        const entries = Array.isArray(body.entries) ? body.entries : [];
+
+        if (entries.length === 0) {
+          sendJson(res, 400, { error: 'Provide a non-empty "entries" array.' });
+          return;
+        }
+
+        if (entries.length > MAX_SCAN_ENTRIES) {
+          sendJson(res, 400, {
+            error: `Too many entries (max ${MAX_SCAN_ENTRIES}).`
+          });
+          return;
+        }
+
+        const images = [];
+        for (const raw of entries) {
+          const row = enrichImageEntry(raw as Parameters<typeof enrichImageEntry>[0]);
+          if (row) {
+            images.push(row);
+          }
+        }
+
+        const sortByScore = Boolean(body.sortByScore);
+        const imagesOut = sortByScore ? sortByCompressionScore(images) : images;
+
+        sendJson(res, 200, { images: imagesOut, issues: [] });
+      } catch (e) {
+        sendJson(res, 400, {
+          error: 'Invalid JSON body',
+          detail: String(e instanceof Error ? e.message : e)
+        });
+      }
+      return;
+    }
+
+    if (url.pathname === '/api/fs/list') {
+      if (!assertLoopbackForFsApi(req, res)) {
+        return;
+      }
+
+      let rawPath = '';
+      if (req.method === 'GET') {
+        rawPath = url.searchParams.get('path') ?? '';
+      } else if (req.method === 'POST') {
+        try {
+          const body = await readJsonBody(req);
+          rawPath = typeof body.path === 'string' ? body.path : '';
+        } catch {
+          sendJson(res, 400, { error: 'Invalid JSON body' });
+          return;
+        }
+      } else {
+        send(res, 405, 'Method not allowed', { 'Content-Type': 'text/plain; charset=utf-8' });
+        return;
+      }
+
+      const trimmed = rawPath.trim();
+      if (!trimmed) {
+        sendJson(res, 400, {
+          error:
+            'Missing path. Use GET ?path=/absolute/path or POST JSON { "path": "/absolute/path" }.'
+        });
+        return;
+      }
+
+      const result = listDirectory(trimmed);
+      if ('error' in result) {
+        let code = 400;
+        if (result.error === 'ENOENT') code = 404;
+        else if (result.error === 'ENOTDIR') code = 400;
+        else if (result.error === 'EACCES' || result.error === 'ESTAT') code = 403;
+        sendJson(res, code, result);
+        return;
+      }
+
+      sendJson(res, 200, result);
+      return;
+    }
+
+    if (req.method === 'GET' && url.pathname === '/api/fs/home') {
+      if (!assertLoopbackForFsApi(req, res)) {
+        return;
+      }
+      const home = os.homedir();
+      sendJson(res, 200, { path: home.split(path.sep).join('/') });
+      return;
+    }
+
+    if (req.method === 'GET' && url.pathname === '/api/file') {
+      if (!assertLoopbackForFsApi(req, res)) {
+        return;
+      }
+
+      const raw = url.searchParams.get('path') ?? '';
+      const trimmed = raw.trim();
+      if (!trimmed) {
+        sendJson(res, 400, { error: 'Missing path. Use ?path=/absolute/path/to/image.png' });
+        return;
+      }
+
+      const resolved = path.resolve(trimmed);
+      const ext = path.extname(resolved).toLowerCase();
+      if (!IMAGE_FILE_EXTS.has(ext)) {
+        sendJson(res, 403, { error: 'Not an allowed image type.' });
+        return;
+      }
+
+      let st: fs.Stats;
+      try {
+        st = fs.statSync(resolved);
+      } catch (e) {
+        const err = e as NodeJS.ErrnoException;
+        const code = err.code === 'ENOENT' ? 404 : 403;
+        sendJson(res, code, {
+          error: err.code ?? 'ESTAT',
+          message: String(err.message || e)
+        });
+        return;
+      }
+
+      if (!st.isFile()) {
+        sendJson(res, 400, { error: 'ENOTFILE', message: 'Path is not a file.' });
+        return;
+      }
+
+      const type = MIME[ext] || 'application/octet-stream';
+      send(res, 200, fs.readFileSync(resolved), { 'Content-Type': type });
+      return;
+    }
+
+    if (req.method === 'GET') {
+      let filePath = safeStaticFile(url.pathname);
+      if (!filePath) {
+        send(res, 403, 'Forbidden', { 'Content-Type': 'text/plain; charset=utf-8' });
+        return;
+      }
+      if (fs.existsSync(filePath) && fs.statSync(filePath).isDirectory()) {
+        filePath = path.join(filePath, 'index.html');
+      }
+      if (!fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) {
+        if (!url.pathname.startsWith('/api')) {
+          serveSpaIndex(res);
+          return;
+        }
+        send(res, 404, 'Not found', { 'Content-Type': 'text/plain; charset=utf-8' });
+        return;
+      }
+      const ext = path.extname(filePath).toLowerCase();
+      const type = MIME[ext] || 'application/octet-stream';
+      send(res, 200, fs.readFileSync(filePath), { 'Content-Type': type });
+      return;
+    }
+
+    send(res, 405, 'Method not allowed', { 'Content-Type': 'text/plain; charset=utf-8' });
+  });
+}
+
+if (require.main === module) {
+  const requested = process.env.PORT;
+  const port = requested !== undefined && requested !== '' ? Number(requested) : 3847;
+  const host = process.env.REPOIMAGE_BIND || '127.0.0.1';
+  const server = createRepoimageServer();
+  server.listen(port, host, () => {
+    const addr = server.address();
+    const p = typeof addr === 'object' && addr ? addr.port : port;
+    const h = typeof addr === 'object' && addr ? addr.address : host;
+    process.stderr.write(`RepoImage GUI: http://${h}:${p}/\n`);
+  });
+}

package/server/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src/**/*.ts"],
+  "references": [{ "path": "../shared" }]
+}

package/shared/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@repoimage/shared",
+  "version": "1.0.0",
+  "private": true,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  }
+}

package/shared/src/constants.ts

@@ -0,0 +1,37 @@
+export const IMAGE_EXTENSIONS = [
+  '.jpg',
+  '.jpeg',
+  '.png',
+  '.gif',
+  '.bmp',
+  '.tiff',
+  '.tif',
+  '.webp',
+  '.svg',
+  '.ico',
+  '.raw',
+  '.heic',
+  '.heif',
+  '.avif'
+] as const;
+
+export const COMMON_EXCLUDE_PATHS = [
+  'node_modules',
+  '.next',
+  'dist',
+  '.git',
+  'build',
+  '.bundle',
+  '.cache',
+  'target',
+  'vendor',
+  '.idea',
+  '.vscode',
+  '__pycache__',
+  '.pytest_cache',
+  '.tox',
+  'venv',
+  '.venv',
+  'env',
+  '.env'
+] as const;

package/shared/src/index.ts

@@ -0,0 +1,4 @@
+export * from './constants';
+export * from './schema';
+export * from './role-guess';
+export * from './types';