@youtyan/code-viewer 0.1.0 → 0.1.1

package/web-src/server/dev.ts

@@ -0,0 +1,95 @@
+#!/usr/bin/env bun
+
+import { readdirSync, statSync } from 'node:fs';
+import { join, normalize } from 'node:path';
+
+const ROOT = normalize(join(import.meta.dir, '..', '..'));
+const SERVER_ROOT = join(ROOT, 'web-src', 'server');
+const DEFAULT_DEV_PORT = 64160;
+
+type ChildProcess = {
+  kill(signal?: string): void;
+  exited: Promise<number>;
+};
+
+let server: ChildProcess | null = null;
+let build: ChildProcess | null = null;
+let restarting = false;
+let firstStart = true;
+
+function withDefaultPort(args: string[]) {
+  if (args.includes('--port')) return args;
+  return ['--port', String(DEFAULT_DEV_PORT), ...args];
+}
+
+function withoutOpen(args: string[]) {
+  return args.filter((arg) => arg !== '--open');
+}
+
+function serverArgs() {
+  const args = withDefaultPort(process.argv.slice(2));
+  return firstStart ? args : withoutOpen(args);
+}
+
+function watchedFiles() {
+  return readdirSync(SERVER_ROOT)
+    .filter((name) => name.endsWith('.ts') && name !== 'runtime.d.ts')
+    .map((name) => join(SERVER_ROOT, name))
+    .concat(join(ROOT, 'web-src', 'types.ts'));
+}
+
+function watchSignature() {
+  return watchedFiles()
+    .map((file) => `${file}:${statSync(file).mtimeMs}`)
+    .join('|');
+}
+
+function startBuild() {
+  build = Bun.spawn([
+    'bun', 'build', '--watch', '--target=browser', '--format=iife',
+    '--outfile=web/app.js', 'web-src/app.ts',
+  ], { cwd: ROOT, stdout: 'inherit', stderr: 'inherit' }) as ChildProcess;
+}
+
+function startServer() {
+  const args = serverArgs();
+  firstStart = false;
+  server = Bun.spawn([
+    'bun', 'run', 'web-src/server/preview.ts', ...args,
+  ], { cwd: ROOT, stdout: 'inherit', stderr: 'inherit' }) as ChildProcess;
+}
+
+async function restartServer() {
+  if (restarting) return;
+  restarting = true;
+  const old = server;
+  server = null;
+  if (old) {
+    old.kill();
+    await old.exited.catch(() => 1);
+  }
+  startServer();
+  restarting = false;
+}
+
+function shutdown() {
+  if (server) server.kill();
+  if (build) build.kill();
+  process.exit(0);
+}
+
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);
+
+console.log(`code-viewer dev server watching ${SERVER_ROOT}`);
+startBuild();
+startServer();
+
+let sig = watchSignature();
+setInterval(() => {
+  const next = watchSignature();
+  if (next === sig) return;
+  sig = next;
+  console.log('server source changed; restarting preview server');
+  restartServer();
+}, 500);

package/web-src/server/git.ts

@@ -13,6 +13,12 @@ export type GitFileMeta = {
   untracked?: boolean;
 };
 
+export type GitTreeEntry = {
+  name: string;
+  path: string;
+  type: 'tree' | 'blob' | 'commit';
+};
+
 function run(args: string[], cwd: string): { code: number; stdout: string; stderr: string } {
   const proc = Bun.spawnSync(args, { cwd, stdout: 'pipe', stderr: 'pipe' });
   return {
@@ -36,6 +42,13 @@ export function show(ref: string, path: string, cwd: string): { code: number; st
   return run(['git', 'show', `${ref}:${path}`], cwd);
 }
 
+export function verifyTreeRef(ref: string, cwd: string): boolean {
+  if (!ref || ref === 'worktree') return false;
+  if (ref.startsWith('-')) return false;
+  const res = run(['git', 'rev-parse', '--verify', `${ref}^{tree}`], cwd);
+  return res.code === 0;
+}
+
 export function refs(cwd: string): { branches: string[]; tags: string[]; commits: string[]; current: string } {
   const out = { branches: [] as string[], tags: [] as string[], commits: [] as string[], current: '' };
   const branches = run([
@@ -106,11 +119,99 @@ export function numstatZ(args: string[], cwd: string): GitFileMeta[] {
   return files;
 }
 
-export function untracked(cwd: string): string[] {
-  const res = run(['git', 'ls-files', '--others', '--exclude-standard'], cwd);
+export function untracked(cwd: string, path = ''): string[] {
+  const args = ['git', 'ls-files', '--others', '--exclude-standard'];
+  if (path) args.push('--', `${path}/`);
+  const res = run(args, cwd);
   return res.code === 0 ? res.stdout.split('\n').filter(Boolean) : [];
 }
 
+function normalizeTreePath(path: string): string {
+  return path.replace(/^\/+|\/+$/g, '');
+}
+
+function directChildren(paths: string[], basePath: string): GitTreeEntry[] {
+  const base = normalizeTreePath(basePath);
+  const prefix = base ? `${base}/` : '';
+  const entries = new Map<string, GitTreeEntry>();
+  for (const rawPath of paths) {
+    if (!rawPath || (prefix && !rawPath.startsWith(prefix))) continue;
+    const rest = prefix ? rawPath.slice(prefix.length) : rawPath;
+    if (!rest) continue;
+    const slash = rest.indexOf('/');
+    const name = slash >= 0 ? rest.slice(0, slash) : rest;
+    const childPath = prefix + name;
+    const type = slash >= 0 ? 'tree' : 'blob';
+    const existing = entries.get(childPath);
+    if (!existing || existing.type !== 'tree') entries.set(childPath, { name, path: childPath, type });
+  }
+  return [...entries.values()].sort((a, b) => {
+    if (a.type !== b.type) return a.type === 'tree' ? -1 : 1;
+    return a.name.localeCompare(b.name);
+  });
+}
+
+export function worktreeEntries(cwd: string, path: string): GitTreeEntry[] {
+  return listTree('worktree', path, cwd).entries;
+}
+
+export function worktreeFiles(cwd: string): GitTreeEntry[] {
+  return listTree('worktree', '', cwd, { recursive: true }).entries;
+}
+
+export function treeEntries(ref: string, path: string, cwd: string): { code: number; entries: GitTreeEntry[]; stderr: string } {
+  return listTree(ref, path, cwd);
+}
+
+export function treeFiles(ref: string, cwd: string): { code: number; entries: GitTreeEntry[]; stderr: string } {
+  return listTree(ref, '', cwd, { recursive: true });
+}
+
+export function listTree(
+  ref: string,
+  path: string,
+  cwd: string,
+  options: { recursive?: boolean } = {},
+): { code: number; entries: GitTreeEntry[]; stderr: string } {
+  const base = normalizeTreePath(path);
+  if (ref === 'worktree') {
+    const trackedArgs = ['git', '-c', 'core.quotepath=false', 'ls-files', '-z'];
+    if (!options.recursive) trackedArgs.push('--', base ? `${base}/` : '.');
+    const tracked = run(trackedArgs, cwd);
+    const paths = tracked.code === 0 ? tracked.stdout.split('\0').filter(Boolean) : [];
+    paths.push(...untracked(cwd, options.recursive ? '' : base));
+    const uniquePaths = [...new Set(paths)].filter(Boolean);
+    const entries = options.recursive
+      ? uniquePaths.sort().map((entryPath) => ({
+        name: entryPath.split('/').pop() || entryPath,
+        path: entryPath,
+        type: 'blob' as const,
+      }))
+      : directChildren(uniquePaths, base);
+    return { code: 0, entries, stderr: '' };
+  }
+
+  const args = ['git', '-c', 'core.quotepath=false', 'ls-tree'];
+  if (options.recursive) args.push('-r');
+  args.push('-z', '--full-tree', ref, '--');
+  if (!options.recursive && base) args.push(`${base}/`);
+  const res = run(args, cwd);
+  if (res.code !== 0) return { code: res.code, entries: [], stderr: res.stderr };
+  const allowedTypes = options.recursive ? 'blob|commit' : 'tree|blob|commit';
+  const entries = res.stdout.split('\0').filter(Boolean).map((rec) => {
+    const match = rec.match(new RegExp(`^\\d+\\s+(${allowedTypes})\\s+[0-9a-fA-F]+\\t(.+)$`));
+    if (!match) return null;
+    const entryPath = match[2];
+    return { name: entryPath.split('/').pop() || entryPath, path: entryPath, type: match[1] as GitTreeEntry['type'] };
+  }).filter((entry): entry is GitTreeEntry => !!entry);
+  entries.sort((a, b) => {
+    if (options.recursive) return a.path.localeCompare(b.path);
+    if (a.type !== b.type) return a.type === 'tree' ? -1 : 1;
+    return a.name.localeCompare(b.name);
+  });
+  return { code: 0, entries, stderr: '' };
+}
+
 export function untrackedMeta(cwd: string): GitFileMeta[] {
   return untracked(cwd).map((path) => {
     const full = join(cwd, path);
@@ -187,7 +288,7 @@ export function truncateToNHunks(diffText: string, n: number): {
     return { text: diffText, totalHunks: 0, renderedHunks: 0, lineCount: (diffText.match(/\n/g) || []).length };
   }
   const renderedHunks = Math.min(n, hunks.length);
-  const text = header + hunks.slice(0, renderedHunks).join('');
+  const text = header + hunks.slice(0, renderedHunks).join('\n');
   return {
     text,
     totalHunks: hunks.length,

package/web-src/server/preview.ts

@@ -2,8 +2,10 @@
 
 import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs';
 import { basename, extname, join, normalize, relative } from 'node:path';
-import type { DiffMeta, FileDiffResponse, FileMeta, FileRangeResponse } from '../types';
+import { APP_ENTRY_PATHS, SPA_PATHS } from '../routes';
+import type { DiffMeta, FileDiffResponse, FileMeta, FileRangeResponse, RepoTreeResponse } from '../types';
 import * as git from './git';
+import { isSameWorktreeRange } from './range';
 
 const ROOT = normalize(join(import.meta.dir, '..', '..'));
 const WEB_ROOT = join(ROOT, 'web');
@@ -18,6 +20,7 @@ const SIZE_LARGE = 20000;
 let generation = 1;
 let cwd = git.repoRoot(process.cwd()) || process.cwd();
 let cliArgs = DEFAULT_ARGS;
+let listenPort = 0;
 
 const enc = new TextEncoder();
 const sseClients = new Set<ReadableStreamDefaultController<Uint8Array>>();
@@ -32,7 +35,7 @@ function parseCli() {
       console.log(`code-viewer ${VERSION}
 
 Usage:
-  code-viewer [--cwd <repo>] [--open] [git-diff-args...]
+  code-viewer [--cwd <repo>] [--port <port>] [--open] [git-diff-args...]
 
 Examples:
   code-viewer --open
@@ -51,6 +54,14 @@ Examples:
         process.exit(1);
       }
       cwd = git.repoRoot(next) || cwd;
+    } else if (arg === '--port') {
+      const next = process.argv[++i];
+      const parsed = Number(next);
+      if (!Number.isInteger(parsed) || parsed < 0 || parsed > 65535) {
+        console.error('--port requires a TCP port number');
+        process.exit(1);
+      }
+      listenPort = parsed;
     } else if (arg === '--open') {
       setTimeout(() => openBrowser(`http://127.0.0.1:${server.port}/`), 0);
     } else {
@@ -88,8 +99,7 @@ function requestAllowed(req: Request) {
 
 function staticFile(pathname: string): Response | null {
   const map: Record<string, [string, string]> = {
-    '/': ['index.html', 'text/html; charset=utf-8'],
-    '/index.html': ['index.html', 'text/html; charset=utf-8'],
+    '/favicon.png': ['favicon.png', 'image/png'],
     '/style.css': ['style.css', 'text/css; charset=utf-8'],
     '/app.js': ['app.js', 'application/javascript; charset=utf-8'],
     '/vendor/diff2html/diff2html.min.css': ['vendor/diff2html/diff2html.min.css', 'text/css; charset=utf-8'],
@@ -98,6 +108,9 @@ function staticFile(pathname: string): Response | null {
     '/vendor/highlight.js/styles/github.min.css': ['vendor/highlight.js/styles/github.min.css', 'text/css; charset=utf-8'],
     '/vendor/highlight.js/styles/github-dark.min.css': ['vendor/highlight.js/styles/github-dark.min.css', 'text/css; charset=utf-8'],
   };
+  for (const spaPath of [...APP_ENTRY_PATHS, ...SPA_PATHS]) {
+    map[spaPath] = ['index.html', 'text/html; charset=utf-8'];
+  }
   const spec = map[pathname];
   if (!spec) return null;
   const full = join(WEB_ROOT, spec[0]);
@@ -180,6 +193,16 @@ function fileToMeta(file: git.GitFileMeta, range: { from?: string; to?: string }
 }
 
 function computePayload(extras: string[], range: { from?: string; to?: string }): DiffMeta {
+  if (isSameWorktreeRange(range)) {
+    return {
+      files: [],
+      totals: { files: 0, additions: 0, deletions: 0 },
+      range: 'worktree .. worktree',
+      project: basename(cwd),
+      branch: git.currentBranch(cwd) || undefined,
+      generation,
+    };
+  }
   const { args, refs } = buildRangeArgs(range);
   const fullArgs = [...extras, ...args];
   const files = git.fileMeta(fullArgs, cwd, false);
@@ -231,7 +254,12 @@ function handleDiffJson(url: URL) {
 }
 
 function safePath(path: string) {
-  return path && !path.includes('../') && !path.includes('..\\') && !path.startsWith('/') && !path.startsWith('\\');
+  if (!path || path.startsWith('/') || path.startsWith('\\') || path.includes('\0')) return false;
+  return !path.split(/[\\/]+/).includes('..');
+}
+
+function safeRepoPath(path: string) {
+  return path === '' || safePath(path);
 }
 
 function safeWorktreePath(path: string): string | null {
@@ -245,6 +273,42 @@ function safeWorktreePath(path: string): string | null {
   return realFull;
 }
 
+function readReadme(target: string, dirPath: string): RepoTreeResponse['readme'] {
+  const candidates = ['README.md', 'readme.md', 'README.markdown', 'README'];
+  for (const name of candidates) {
+    const path = dirPath ? `${dirPath}/${name}` : name;
+    if (target === 'worktree' || target === '') {
+      const full = safeWorktreePath(path);
+      if (!full) continue;
+      try {
+        return { path, text: readFileSync(full, 'utf8') };
+      } catch {
+        continue;
+      }
+    }
+    const res = git.show(target, path, cwd);
+    if (res.code === 0) return { path, text: res.stdout };
+  }
+  return null;
+}
+
+function handleTree(url: URL) {
+  const target = url.searchParams.get('ref') || url.searchParams.get('target') || 'worktree';
+  const path = (url.searchParams.get('path') || '').replace(/^\/+|\/+$/g, '');
+  if (!safeRepoPath(path)) return text('invalid path', 400);
+  if (target !== 'worktree' && !git.verifyTreeRef(target, cwd)) return text('invalid target', 400);
+  const recursive = url.searchParams.get('recursive') === '1';
+  const entries = git.listTree(target, path, cwd, { recursive }).entries;
+  return json({
+    ref: target,
+    path,
+    project: basename(cwd),
+    branch: git.currentBranch(cwd) || undefined,
+    entries,
+    readme: readReadme(target, path),
+  } satisfies RepoTreeResponse);
+}
+
 function handleFileDiff(url: URL) {
   const path = url.searchParams.get('path') || '';
   if (!safePath(path)) return text('invalid path', 400);
@@ -253,6 +317,21 @@ function handleFileDiff(url: URL) {
   if (url.searchParams.get('ignore_blank') === '1') extras.push('--ignore-blank-lines');
   const isUntracked = url.searchParams.get('untracked') === '1';
   const range = { from: url.searchParams.get('from') || '', to: url.searchParams.get('to') || '' };
+  if (isSameWorktreeRange(range)) {
+    return json({
+      path,
+      old_path: url.searchParams.get('old_path') || '',
+      status: url.searchParams.get('status') || '',
+      mode: url.searchParams.get('mode') || 'full',
+      diff: '',
+      hunk_count: 0,
+      rendered_hunk_count: 0,
+      line_count: 0,
+      truncated: false,
+      binary: false,
+      generation,
+    });
+  }
   const { args } = buildRangeArgs(range);
   const oldPath = url.searchParams.get('old_path');
   const cacheKey = isUntracked
@@ -305,6 +384,7 @@ function handleFileRange(url: URL) {
     if (!full) return text('no file', 404);
     content = readFileSync(full, 'utf8');
   } else {
+    if (!git.verifyTreeRef(ref, cwd)) return text('invalid ref', 400);
     const res = git.show(ref, path, cwd);
     if (res.code !== 0) return text('not in ref', 404);
     content = res.stdout;
@@ -322,6 +402,7 @@ function handleRawFile(url: URL) {
   const ref = url.searchParams.get('ref') || 'worktree';
   let body: BodyInit;
   if (ref !== 'worktree' && ref !== '') {
+    if (!git.verifyTreeRef(ref, cwd)) return text('invalid ref', 400);
     const res = git.show(ref, path, cwd);
     if (res.code !== 0) return text('not in ref', 404);
     body = res.stdout;
@@ -355,13 +436,14 @@ parseCli();
 
 const server = Bun.serve({
   hostname: '127.0.0.1',
-  port: 0,
+  port: listenPort,
   fetch(req) {
     if (!requestAllowed(req)) return text('forbidden', 403);
     const url = new URL(req.url);
     const staticResponse = staticFile(url.pathname);
     if (staticResponse) return staticResponse;
     if (url.pathname === '/diff.json') return handleDiffJson(url);
+    if (url.pathname === '/_tree') return handleTree(url);
     if (url.pathname === '/file_diff') return handleFileDiff(url);
     if (url.pathname === '/file_range') return handleFileRange(url);
     if (url.pathname === '/_file') return handleRawFile(url);

package/web-src/server/range.ts

@@ -0,0 +1,8 @@
+export type DiffRange = {
+  from?: string;
+  to?: string;
+};
+
+export function isSameWorktreeRange(range: DiffRange): boolean {
+  return range.from === 'worktree' && range.to === 'worktree';
+}

package/web-src/server/runtime.d.ts

@@ -1,5 +1,8 @@
 declare const Bun: {
-  spawn(args: string[], opts?: Record<string, unknown>): unknown;
+  spawn(args: string[], opts?: Record<string, unknown>): {
+    kill(signal?: string): void;
+    exited: Promise<number>;
+  };
   spawnSync(args: string[], opts?: Record<string, unknown>): {
     exitCode: number;
     stdout: Uint8Array;
@@ -16,6 +19,7 @@ declare const process: {
   argv: string[];
   cwd(): string;
   platform: 'darwin' | 'win32' | string;
+  on(event: 'SIGINT' | 'SIGTERM', listener: () => void): void;
   exit(code?: number): never;
 };
 
@@ -25,6 +29,7 @@ interface ImportMeta {
 
 declare module 'node:fs' {
   export function existsSync(path: string): boolean;
+  export function readdirSync(path: string): string[];
   export function readFileSync(path: string): Buffer;
   export function readFileSync(path: string, encoding: BufferEncoding): string;
   export function realpathSync(path: string): string;

package/web-src/types.ts

@@ -33,6 +33,24 @@ export type DiffMeta = {
   generation?: number;
 };
 
+export type RepoTreeEntry = {
+  name: string;
+  path: string;
+  type: 'tree' | 'blob' | 'commit';
+};
+
+export type RepoTreeResponse = {
+  ref: string;
+  path: string;
+  project: string;
+  branch?: string;
+  entries: RepoTreeEntry[];
+  readme?: {
+    path: string;
+    text: string;
+  } | null;
+};
+
 export type FileDiffResponse = {
   path: string;
   old_path?: string;