gitmaps 1.0.0 → 1.1.1

package/app/api/repo/pdf-thumb/route.ts

@@ -0,0 +1,127 @@
+import path from 'path';
+import { existsSync } from 'fs';
+import { validateRepoPath } from '../validate-path';
+
+/**
+ * GET /api/repo/pdf-thumb?path=REPO&file=FILE&page=0&width=600
+ *
+ * Converts a PDF page to a PNG thumbnail using Bun's native sharp or
+ * falls back to pdftoppm (poppler-utils) if available.
+ * Returns the image directly as image/png.
+ */
+export async function GET(req: Request) {
+    const url = new URL(req.url);
+    const repoPath = url.searchParams.get('path') || '';
+    const filePath = url.searchParams.get('file') || '';
+    const page = parseInt(url.searchParams.get('page') || '0', 10);
+    const width = parseInt(url.searchParams.get('width') || '800', 10);
+
+    if (!repoPath || !filePath) {
+        return new Response('path and file params required', { status: 400 });
+    }
+
+    const blocked = validateRepoPath(repoPath);
+    if (blocked) return blocked;
+
+    // Prevent path traversal
+    if (filePath.includes('..') || filePath.startsWith('/')) {
+        return new Response('Invalid file path', { status: 400 });
+    }
+
+    const fullPath = path.join(repoPath, filePath);
+    if (!existsSync(fullPath)) {
+        return new Response('File not found', { status: 404 });
+    }
+
+    // Cache key based on file path + modification time
+    const file = Bun.file(fullPath);
+    const cacheKey = `pdf-thumb:${fullPath}:${file.size}:p${page}:w${width}`;
+
+    // Try pdftoppm (poppler-utils) — most reliable cross-platform PDF renderer
+    try {
+        const proc = Bun.spawnSync([
+            'pdftoppm',
+            '-png',
+            '-f', String(page + 1),
+            '-l', String(page + 1),
+            '-scale-to-x', String(width),
+            '-scale-to-y', '-1',
+            '-singlefile',
+            fullPath,
+            '-',
+        ], {
+            stdout: 'pipe',
+            stderr: 'pipe',
+            timeout: 15000,
+        });
+
+        if (proc.exitCode === 0 && proc.stdout.length > 0) {
+            return new Response(proc.stdout, {
+                headers: {
+                    'Content-Type': 'image/png',
+                    'Cache-Control': 'public, max-age=86400',
+                },
+            });
+        }
+
+        // pdftoppm outputs to stdout with `-` but some versions need a prefix
+        // Try alternative invocation
+        const proc2 = Bun.spawnSync([
+            'pdftoppm',
+            '-png',
+            '-f', String(page + 1),
+            '-l', String(page + 1),
+            '-scale-to-x', String(width),
+            '-scale-to-y', '-1',
+            '-singlefile',
+            fullPath,
+        ], {
+            stdout: 'pipe',
+            stderr: 'pipe',
+            timeout: 15000,
+        });
+
+        if (proc2.exitCode === 0 && proc2.stdout.length > 0) {
+            return new Response(proc2.stdout, {
+                headers: {
+                    'Content-Type': 'image/png',
+                    'Cache-Control': 'public, max-age=86400',
+                },
+            });
+        }
+    } catch (_) {
+        // pdftoppm not available
+    }
+
+    // Fallback: try magick (ImageMagick)
+    try {
+        const proc = Bun.spawnSync([
+            'magick',
+            '-density', '150',
+            `${fullPath}[${page}]`,
+            '-resize', `${width}x`,
+            'png:-',
+        ], {
+            stdout: 'pipe',
+            stderr: 'pipe',
+            timeout: 30000,
+        });
+
+        if (proc.exitCode === 0 && proc.stdout.length > 0) {
+            return new Response(proc.stdout, {
+                headers: {
+                    'Content-Type': 'image/png',
+                    'Cache-Control': 'public, max-age=86400',
+                },
+            });
+        }
+    } catch (_) {
+        // magick not available
+    }
+
+    // No PDF renderer available — return a helpful placeholder
+    return new Response('PDF preview requires poppler-utils (pdftoppm) or ImageMagick (magick). Install one to enable PDF thumbnails.', {
+        status: 501,
+        headers: { 'Content-Type': 'text/plain' },
+    });
+}

package/app/api/repo/resolve-slug/route.ts

@@ -0,0 +1,51 @@
+import { existsSync, readdirSync, statSync } from 'fs';
+import path from 'path';
+import simpleGit from 'simple-git';
+import { extractCanonicalForgeSlugInfo } from '../load/route';
+
+const CLONES_DIR = path.join(process.cwd(), 'git-canvas', 'repos');
+
+async function findRepoByCanonicalSlug(slug: string): Promise<string | null> {
+  if (!slug || !existsSync(CLONES_DIR)) return null;
+
+  const entries = readdirSync(CLONES_DIR);
+  for (const entry of entries) {
+    const fullPath = path.join(CLONES_DIR, entry);
+    try {
+      const stat = statSync(fullPath);
+      if (!stat.isDirectory()) continue;
+      if (!existsSync(path.join(fullPath, '.git'))) continue;
+
+      try {
+        const git = simpleGit(fullPath);
+        const remotes = await git.getRemotes(true);
+        const origin = remotes.find((r) => r.name === 'origin') || remotes[0];
+        const info = extractCanonicalForgeSlugInfo(origin?.refs?.fetch || origin?.refs?.push || null);
+        if (info.slug === slug) {
+          return fullPath.replace(/\\/g, '/');
+        }
+      } catch {
+        // ignore invalid repos
+      }
+    } catch {
+      // ignore bad entries
+    }
+  }
+
+  return null;
+}
+
+export async function POST(req: Request) {
+  try {
+    const { slug } = await req.json() as { slug?: string };
+    const normalizedSlug = (slug || '').trim().replace(/^\/+|\/+$/g, '');
+    if (!normalizedSlug) {
+      return Response.json({ error: 'slug is required' }, { status: 400 });
+    }
+
+    const resolvedPath = await findRepoByCanonicalSlug(normalizedSlug);
+    return Response.json({ path: resolvedPath });
+  } catch (error: any) {
+    return Response.json({ error: error?.message || 'Failed to resolve slug' }, { status: 500 });
+  }
+}

package/app/api/repo/tree/route.ts

@@ -1,104 +1,188 @@
-import { measure } from 'measure-fn';
-import simpleGit from 'simple-git';
-import { readFileSync, existsSync } from 'fs';
-import path from 'path';
-import { validateRepoPath } from '../validate-path';
-
-const BINARY_EXTS = new Set(['png', 'jpg', 'jpeg', 'gif', 'bmp', 'ico', 'svg', 'webp', 'mp3', 'mp4', 'wav', 'ogg', 'avi', 'mov', 'zip', 'tar', 'gz', 'rar', '7z', 'pdf', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'exe', 'dll', 'so', 'dylib', 'woff', 'woff2', 'ttf', 'eot', 'otf', 'lock']);
-
-export async function POST(req: Request) {
-    return measure('api:repo:tree', async () => {
-        try {
-            const { path: repoPath } = await req.json();
-
-            if (!repoPath) {
-                return new Response('Repository path is required', { status: 400 });
-            }
-
-            const blocked = validateRepoPath(repoPath);
-            if (blocked) return blocked;
-
-            const git = simpleGit(repoPath);
-
-            // Get tracked files only (respects .gitignore by definition)
-            const result = await git.raw(['ls-files']);
-            const ignoreDirs = ['node_modules', '.git', 'dist', 'build', '.next', '.cache', 'coverage', '.turbo', '__pycache__', '.tsbuildinfo'];
-
-            // Also parse .gitignore for extra patterns
-            const gitignorePatterns: string[] = [];
-            const gitignorePath = path.join(repoPath, '.gitignore');
-            if (existsSync(gitignorePath)) {
-                try {
-                    const content = readFileSync(gitignorePath, 'utf-8');
-                    content.split('\n').forEach(line => {
-                        line = line.trim();
-                        if (line && !line.startsWith('#')) {
-                            // Normalize: remove trailing slashes for dir matching
-                            const clean = line.replace(/\/+$/, '');
-                            if (clean) gitignorePatterns.push(clean);
-                        }
-                    });
-                } catch (e) { /* ignore */ }
-            }
-
-            const filePaths = result.trim().split('\n').filter(fp => {
-                if (!fp) return false;
-                // Filter out known heavy directories
-                if (ignoreDirs.some(d => fp.startsWith(d + '/') || fp.startsWith(d + '\\'))) return false;
-                // Filter out files matching gitignore patterns (extra safety)
-                for (const pattern of gitignorePatterns) {
-                    if (fp.startsWith(pattern + '/') || fp.startsWith(pattern + '\\')) return false;
-                    if (fp === pattern) return false;
-                    // Simple glob: *.ext
-                    if (pattern.startsWith('*.')) {
-                        const ext = pattern.substring(1); // .ext
-                        if (fp.endsWith(ext)) return false;
-                    }
-                }
-                return true;
-            });
-
-            const files = filePaths.map(filePath => {
-                const parts = filePath.split('/');
-                const name = parts[parts.length - 1];
-                const ext = name.includes('.') ? name.split('.').pop()!.toLowerCase() : '';
-
-                let content = null;
-                let lines = 0;
-                let isBinary = BINARY_EXTS.has(ext);
-
-                if (!isBinary) {
-                    try {
-                        const fullPath = path.join(repoPath, filePath);
-                        const raw = readFileSync(fullPath, 'utf-8');
-                        const allLines = raw.split('\n');
-                        lines = allLines.length;
-                        // Send full content for small/medium files, truncate very large ones
-                        if (allLines.length > 10000) {
-                            content = allLines.slice(0, 10000).join('\n');
-                        } else {
-                            content = raw;
-                        }
-                    } catch (e) {
-                        content = null;
-                    }
-                }
-
-                return {
-                    path: filePath,
-                    name,
-                    ext,
-                    type: 'file',
-                    content,
-                    lines,
-                    isBinary
-                };
-            });
-
-            return Response.json({ files, total: files.length });
-        } catch (error: any) {
-            console.error('api:repo:tree:error', error);
-            return new Response(`Error: ${error.message}`, { status: 500 });
-        }
-    });
-}
+import { measure } from 'measure-fn';
+import simpleGit from 'simple-git';
+import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
+import path from 'path';
+import { validateRepoPath } from '../validate-path';
+
+const BINARY_EXTS = new Set(['png', 'jpg', 'jpeg', 'gif', 'bmp', 'ico', 'svg', 'webp', 'mp3', 'mp4', 'wav', 'ogg', 'avi', 'mov', 'zip', 'tar', 'gz', 'rar', '7z', 'pdf', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'exe', 'dll', 'so', 'dylib', 'woff', 'woff2', 'ttf', 'eot', 'otf', 'lock']);
+const IMAGE_EXTS = new Set(['png', 'jpg', 'jpeg', 'gif', 'bmp', 'ico', 'svg', 'webp']);
+const PDF_EXTS = new Set(['pdf']);
+const MAX_READ_SIZE = 2 * 1024 * 1024;
+
+export async function POST(req: Request) {
+    return measure('api:repo:tree', async () => {
+        try {
+            const body = await req.json();
+            const repoPath = body.path;
+            const stream = body.stream === true;
+            const includeAll = body.includeAll === true;
+
+            if (!repoPath) {
+                return new Response('Repository path is required', { status: 400 });
+            }
+
+            const blocked = validateRepoPath(repoPath);
+            if (blocked) return blocked;
+
+            const ignoreDirs = new Set(['node_modules', '.git', 'dist', 'build', '.next', '.cache', 'coverage', '.turbo', '__pycache__', '.tsbuildinfo']);
+
+            // Recursively scan filesystem for all files (ignoring standard dirs)
+            function scanDir(dir: string, prefix: string): string[] {
+                const results: string[] = [];
+                try {
+                    const entries = readdirSync(dir);
+                    for (const entry of entries) {
+                        if (ignoreDirs.has(entry)) continue;
+                        const fullPath = path.join(dir, entry);
+                        const relativePath = prefix ? `${prefix}/${entry}` : entry;
+                        try {
+                            const stats = statSync(fullPath);
+                            if (stats.isDirectory()) {
+                                results.push(...scanDir(fullPath, relativePath));
+                            } else if (stats.isFile()) {
+                                results.push(relativePath);
+                            }
+                        } catch (e: any) {
+                            console.warn(`[tree:scanDir] stat error: ${fullPath}: ${e.message}`);
+                        }
+                    }
+                } catch (e: any) {
+                    console.warn(`[tree:scanDir] readdir error: ${dir}: ${e.message}`);
+                }
+                return results;
+            }
+
+            let filePaths: string[];
+
+            const git = simpleGit(repoPath);
+            const isRepo = await git.checkIsRepo().catch(() => false);
+
+            if (!isRepo || includeAll) {
+                // Not a git repo or explicit all-files mode: scan filesystem
+                filePaths = scanDir(repoPath, '');
+            } else {
+                // Get tracked files
+                const result = await git.raw(['ls-files']);
+                const trackedPaths = result.trim().split('\n').filter(fp => {
+                    if (!fp) return false;
+                    if (Array.from(ignoreDirs).some(d => fp.startsWith(d + '/') || fp.startsWith(d + '\\'))) return false;
+                    return true;
+                });
+
+                // If very few tracked files, also scan filesystem for untracked content
+                // This catches repos where most content (PDFs, images) is gitignored
+                if (trackedPaths.length < 50) {
+                    const allPaths = scanDir(repoPath, '');
+                    console.log(`[tree] ${trackedPaths.length} tracked, ${allPaths.length} on disk`);
+                    if (allPaths.length > trackedPaths.length * 5) {
+                        // Lots of untracked content — include everything
+                        const trackedSet = new Set(trackedPaths);
+                        filePaths = allPaths;
+                        // But still filter out obvious junk from non-tracked scan
+                        filePaths = filePaths.filter(fp => {
+                            if (Array.from(ignoreDirs).some(d => fp.startsWith(d + '/') || fp.startsWith(d + '\\'))) return false;
+                            return true;
+                        });
+                        console.log(`[tree] ${trackedPaths.length} tracked, ${allPaths.length} on disk → including all ${filePaths.length} files`);
+                    } else {
+                        filePaths = trackedPaths;
+                    }
+                } else {
+                    filePaths = trackedPaths;
+                }
+            }
+
+            function readFile(filePath: string) {
+                const parts = filePath.split('/');
+                const name = parts[parts.length - 1];
+                const ext = name.includes('.') ? name.split('.').pop()!.toLowerCase() : '';
+
+                let content = null;
+                let lines = 0;
+                let size = 0;
+                let isBinary = BINARY_EXTS.has(ext);
+                const isImage = IMAGE_EXTS.has(ext);
+                const isPdf = PDF_EXTS.has(ext);
+
+                if (!isBinary) {
+                    try {
+                        const fullPath = path.join(repoPath, filePath);
+                        const file = Bun.file(fullPath);
+                        size = file.size;
+
+                        // Skip reading content for very large files
+                        if (size > MAX_READ_SIZE) {
+                            isBinary = true;
+                        } else {
+                            const raw = readFileSync(fullPath, 'utf-8');
+                            size = raw.length;
+                            const allLines = raw.split('\n');
+                            lines = allLines.length;
+                            if (allLines.length > 10000) {
+                                content = allLines.slice(0, 10000).join('\n');
+                            } else {
+                                content = raw;
+                            }
+                        }
+                    } catch (e) {
+                        content = null;
+                    }
+                } else {
+                    // For binary files, at least get the file size
+                    try {
+                        const fullPath = path.join(repoPath, filePath);
+                        size = Bun.file(fullPath).size;
+                    } catch (_) {}
+                }
+
+                return { path: filePath, name, ext, type: 'file', content, lines, size, isBinary, isImage, isPdf };
+            }
+
+            // ── Streaming mode: NDJSON with total header ──
+            if (stream) {
+                const total = filePaths.length;
+                const BATCH_SIZE = 20;
+                const encoder = new TextEncoder();
+
+                const readable = new ReadableStream({
+                    start(controller) {
+                        // First line: total count
+                        controller.enqueue(encoder.encode(JSON.stringify({ total }) + '\n'));
+
+                        let i = 0;
+                        function nextBatch() {
+                            const end = Math.min(i + BATCH_SIZE, total);
+                            const batch: any[] = [];
+                            for (; i < end; i++) {
+                                batch.push(readFile(filePaths[i]));
+                            }
+                            controller.enqueue(encoder.encode(JSON.stringify({ files: batch, loaded: i }) + '\n'));
+
+                            if (i < total) {
+                                // Yield to event loop between batches
+                                setTimeout(nextBatch, 0);
+                            } else {
+                                controller.close();
+                            }
+                        }
+                        nextBatch();
+                    }
+                });
+
+                return new Response(readable, {
+                    headers: {
+                        'Content-Type': 'application/x-ndjson',
+                        'Cache-Control': 'no-cache',
+                    }
+                });
+            }
+
+            // ── Legacy non-streaming mode ──
+            const files = filePaths.map(readFile);
+            return Response.json({ files, total: files.length });
+        } catch (error: any) {
+            console.error('api:repo:tree:error', error);
+            return new Response(`Error: ${error.message}`, { status: 500 });
+        }
+    });
+}

package/app/api/repo/upload/route.ts

@@ -1,9 +1,6 @@
 import { mkdir, writeFile } from "fs/promises";
 import * as path from "path";
-import { exec } from "child_process";
-import { promisify } from "util";
-
-const execAsync = promisify(exec);
+import { $ } from "bun";
 
 export async function POST(req: Request) {
     try {
@@ -35,15 +32,15 @@ export async function POST(req: Request) {
         }
 
         // Initialize a Git repository so galaxy-canvas can read it
-        await execAsync(`git init`, { cwd: repoPath });
+        await $`git init`.cwd(repoPath);
 
         // Setup dummy user info, otherwise git commits will fail if not globally set
-        await execAsync(`git config user.name "Galaxy Canvas"`, { cwd: repoPath });
-        await execAsync(`git config user.email "bot@galaxycanvas.local"`, { cwd: repoPath });
+        await $`git config user.name "Galaxy Canvas"`.cwd(repoPath);
+        await $`git config user.email "bot@galaxycanvas.local"`.cwd(repoPath);
 
         // Add all files and commit
-        await execAsync(`git add .`, { cwd: repoPath });
-        await execAsync(`git commit -m "Initial drop imported by drag-and-drop"`, { cwd: repoPath });
+        await $`git add .`.cwd(repoPath);
+        await $`git commit -m "Initial drop imported by drag-and-drop"`.cwd(repoPath);
 
         return Response.json({ path: repoPath, success: true });
     } catch (e: any) {

package/app/api/sw.js/route.ts

@@ -0,0 +1,70 @@
+// GET /api/sw.js — Service Worker for offline caching
+export function GET() {
+    const sw = `
+const CACHE_NAME = 'gitmaps-v1';
+const PRECACHE = [
+    '/',
+];
+
+self.addEventListener('install', (e) => {
+    e.waitUntil(
+        caches.open(CACHE_NAME).then(cache => cache.addAll(PRECACHE))
+    );
+    self.skipWaiting();
+});
+
+self.addEventListener('activate', (e) => {
+    e.waitUntil(
+        caches.keys().then(keys =>
+            Promise.all(keys.filter(k => k !== CACHE_NAME).map(k => caches.delete(k)))
+        )
+    );
+    self.clients.claim();
+});
+
+self.addEventListener('fetch', (e) => {
+    const url = new URL(e.request.url);
+
+    // Skip non-GET, WebSocket, and API requests (except manifest)
+    if (e.request.method !== 'GET') return;
+    if (url.protocol === 'ws:' || url.protocol === 'wss:') return;
+    if (url.pathname.startsWith('/api/') && !url.pathname.includes('manifest')) return;
+
+    // Network-first for HTML pages (always get fresh content)
+    if (e.request.headers.get('accept')?.includes('text/html')) {
+        e.respondWith(
+            fetch(e.request)
+                .then(res => {
+                    const clone = res.clone();
+                    caches.open(CACHE_NAME).then(c => c.put(e.request, clone));
+                    return res;
+                })
+                .catch(() => caches.match(e.request))
+        );
+        return;
+    }
+
+    // Cache-first for static assets (CSS, JS, fonts, images)
+    e.respondWith(
+        caches.match(e.request).then(cached => {
+            if (cached) return cached;
+            return fetch(e.request).then(res => {
+                if (res.ok && res.status === 200) {
+                    const clone = res.clone();
+                    caches.open(CACHE_NAME).then(c => c.put(e.request, clone));
+                }
+                return res;
+            });
+        })
+    );
+});
+`;
+
+    return new Response(sw, {
+        headers: {
+            'Content-Type': 'application/javascript',
+            'Service-Worker-Allowed': '/',
+            'Cache-Control': 'no-cache',
+        },
+    });
+}

package/app/api/version/route.ts

@@ -0,0 +1,26 @@
+import path from 'path';
+
+function runGit(args: string[]): string {
+    const repoRoot = path.resolve(import.meta.dir, '../../..');
+    const proc = Bun.spawnSync(['git', ...args], {
+        cwd: repoRoot,
+        stdout: 'pipe',
+        stderr: 'pipe',
+    });
+
+    if (proc.exitCode !== 0) {
+        return '';
+    }
+
+    return proc.stdout.toString().trim();
+}
+
+export async function GET() {
+    const commit = process.env.GIT_COMMIT_HASH || runGit(['rev-parse', '--short', 'HEAD']) || 'unknown';
+    const commitDate = process.env.GIT_COMMIT_DATE || runGit(['log', '-1', '--format=%cs']) || '';
+
+    return Response.json({
+        commit,
+        commitDate,
+    });
+}

package/app/galaxy-canvas/page.client.tsx

@@ -0,0 +1,2 @@
+// Re-export root page client for /galaxy-canvas route
+export { default } from '../page.client';

package/app/galaxy-canvas/page.tsx

@@ -0,0 +1,5 @@
+/**
+ * galaxy-canvas route — Aliases root page for /galaxy-canvas path
+ */
+import Page from '../page';
+export default Page;