@stage-labs/metro 0.1.0-beta.30 → 0.1.0-beta.301

package/runtime/node_modules/@metro-labs/daemon/src/claude/files.ts

@@ -0,0 +1,359 @@
+import { createReadStream, existsSync, readdirEntries, readdirNames, readRange, statSync } from '../agent-user/agent-fs.js';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { createInterface } from 'node:readline';
+import { ApiError } from '@metro-labs/http/api-error';
+import { isRecord } from '@metro-labs/core/is-record';
+import { removeHome, writeHomeText } from '../agent-user/home-fs.js';
+import { agentUser } from '../agent-user/user.js';
+
+export const PROJECT_RE = /^[A-Za-z0-9._-]{1,200}$/;
+export const SESSION_RE = /^[A-Za-z0-9][A-Za-z0-9-]{7,63}$/;
+const MEMORY_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,119}\.md$/;
+const FOLDER_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,119}$/;
+const MEMORY_DEPTH = 6;
+const MEMORY_FILES_MAX = 5000;
+const EDGE_BYTES = 64 * 1024;
+const TEXT_CAP = 20_000;
+const RESULT_CAP = 8_000;
+const INPUT_CAP = 4_000;
+const FILE_CAP = 1_000_000;
+const MEMORY_MAX = 256 * 1024;
+const MEMORY_MODE = 0o644;
+const NOISE = ['<task-notification>', '<system-reminder>', '<local-command', '<command-name>'];
+
+export function claudeDir(): string {
+  const explicit = process.env.METRO_CLAUDE_DIR?.trim();
+  if (explicit !== undefined && explicit !== '') return explicit;
+  const cfg = process.env.CLAUDE_CONFIG_DIR?.trim();
+  if (cfg !== undefined && cfg !== '') return cfg;
+  const user = agentUser();
+  return join(user === null ? homedir() : user.home, '.claude');
+}
+
+const str = (v: unknown): string | null => (typeof v === 'string' && v !== '' ? v : null);
+
+export function safeName(value: string, re: RegExp, what: string): string {
+  if (!re.test(value) || value === '.' || value === '..')
+    throw new ApiError(`that is not a ${what}`, 400);
+  return value;
+}
+
+function projectDir(project: string, dir: string): string {
+  const path = join(dir, 'projects', safeName(project, PROJECT_RE, 'Claude project id'));
+  if (!existsSync(path)) throw new ApiError('no such Claude project', 404);
+  return path;
+}
+
+function parseLines(text: string): Record<string, unknown>[] {
+  const out: Record<string, unknown>[] = [];
+  for (const line of text.split('\n')) {
+    if (line.trim() === '') continue;
+    try {
+      const parsed: unknown = JSON.parse(line);
+      if (isRecord(parsed)) out.push(parsed);
+    } catch {
+      continue;
+    }
+  }
+  return out;
+}
+
+function readEdge(path: string, fromEnd: boolean): Record<string, unknown>[] {
+  const size = statSync(path).size;
+  const length = Math.min(EDGE_BYTES, size);
+  const text = readRange(path, fromEnd ? size - length : 0, length).toString('utf8');
+  const cut = fromEnd && length < size ? text.indexOf('\n') + 1 : 0;
+  return parseLines(text.slice(cut));
+}
+
+export interface ClaudeProject {
+  id: string;
+  cwd: string | null;
+  sessions: number;
+  lastActiveAt: string | null;
+  hasMemory: boolean;
+}
+
+function sessionFiles(path: string): { name: string; mtime: number; size: number }[] {
+  return readdirNames(path)
+    .filter((name) => name.endsWith('.jsonl'))
+    .map((name) => {
+      const s = statSync(join(path, name));
+      return { name, mtime: s.mtimeMs, size: s.size };
+    })
+    .sort((a, b) => b.mtime - a.mtime);
+}
+
+function cwdOf(path: string): string | null {
+  for (const line of readEdge(path, false)) {
+    const cwd = str(line.cwd);
+    if (cwd !== null) return cwd;
+  }
+  return null;
+}
+
+export function listClaudeProjects(dir = claudeDir()): ClaudeProject[] {
+  const root = join(dir, 'projects');
+  if (!existsSync(root)) return [];
+  return readdirEntries(root)
+    .filter((entry) => entry.isDirectory() && PROJECT_RE.test(entry.name))
+    .map((entry) => {
+      const path = join(root, entry.name);
+      const files = sessionFiles(path);
+      const newest = files[0];
+      return {
+        id: entry.name,
+        cwd: newest === undefined ? null : cwdOf(join(path, newest.name)),
+        sessions: files.length,
+        lastActiveAt: newest === undefined ? null : new Date(newest.mtime).toISOString(),
+        hasMemory: existsSync(join(path, 'memory')),
+      };
+    })
+    .sort((a, b) => (b.lastActiveAt ?? '').localeCompare(a.lastActiveAt ?? ''));
+}
+
+export interface ClaudeSession {
+  id: string;
+  title: string;
+  startedAt: string | null;
+  lastAt: string;
+  bytes: number;
+  gitBranch: string | null;
+  version: string | null;
+}
+
+function firstPrompt(lines: Record<string, unknown>[]): string | null {
+  for (const line of lines) {
+    if (line.type !== 'user' || line.isSidechain === true) continue;
+    const message = isRecord(line.message) ? line.message : {};
+    const text = promptText(message.content);
+    if (text !== null && !NOISE.some((n) => text.startsWith(n))) return text.slice(0, 120);
+  }
+  return null;
+}
+
+function promptText(content: unknown): string | null {
+  if (typeof content === 'string') return content.trim() === '' ? null : content.trim();
+  if (!Array.isArray(content)) return null;
+  for (const block of content)
+    if (isRecord(block) && block.type === 'text') {
+      const text = str(block.text);
+      if (text !== null) return text.trim();
+    }
+  return null;
+}
+
+function sessionOf(path: string, id: string, mtime: number, size: number): ClaudeSession {
+  const head = readEdge(path, false);
+  const tail = readEdge(path, true);
+  const titled = [...tail].reverse().find((l) => l.type === 'ai-title' && str(l.aiTitle) !== null);
+  const meta = head.find((l) => l.type === 'user' || l.type === 'assistant') ?? {};
+  return {
+    id,
+    title: (titled === undefined ? null : str(titled.aiTitle)) ?? firstPrompt(head) ?? 'Untitled session',
+    startedAt: str(head.find((l) => str(l.timestamp) !== null)?.timestamp) ?? null,
+    lastAt: new Date(mtime).toISOString(),
+    bytes: size,
+    gitBranch: str(meta.gitBranch),
+    version: str(meta.version),
+  };
+}
+
+export function listClaudeSessions(project: string, dir = claudeDir()): ClaudeSession[] {
+  const path = projectDir(project, dir);
+  return sessionFiles(path).map((f) =>
+    sessionOf(join(path, f.name), f.name.slice(0, -'.jsonl'.length), f.mtime, f.size),
+  );
+}
+
+type Block =
+  | { kind: 'text'; text: string }
+  | { kind: 'tool_use'; name: string; input: string }
+  | { kind: 'tool_result'; text: string; isError: boolean }
+  | { kind: 'thinking' }
+  | { kind: 'image' };
+
+interface TranscriptEntry {
+  uuid: string;
+  at: string | null;
+  role: 'user' | 'assistant';
+  blocks: Block[];
+}
+
+export interface TranscriptPage {
+  entries: TranscriptEntry[];
+  total: number;
+  next: number | null;
+}
+
+const cap = (text: string, max: number): string =>
+  text.length > max ? `${text.slice(0, max)}\n… (${String(text.length - max)} more characters)` : text;
+
+function resultText(content: unknown): string {
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+  return content
+    .map((b) => (isRecord(b) && b.type === 'text' ? (str(b.text) ?? '') : ''))
+    .filter((t) => t !== '')
+    .join('\n');
+}
+
+function textBlock(raw: Record<string, unknown>): Block | null {
+  const text = str(raw.text);
+  if (text === null || NOISE.some((n) => text.startsWith(n))) return null;
+  return { kind: 'text', text: cap(text, TEXT_CAP) };
+}
+
+const BLOCKS: Record<string, (raw: Record<string, unknown>) => Block | null> = {
+  text: textBlock,
+  tool_use: (raw) => ({
+    kind: 'tool_use',
+    name: str(raw.name) ?? 'tool',
+    input: cap(JSON.stringify(raw.input ?? {}, null, 1), INPUT_CAP),
+  }),
+  tool_result: (raw) => ({
+    kind: 'tool_result',
+    text: cap(resultText(raw.content), RESULT_CAP),
+    isError: raw.is_error === true,
+  }),
+  thinking: () => ({ kind: 'thinking' }),
+  image: () => ({ kind: 'image' }),
+};
+
+function blockOf(raw: unknown): Block | null {
+  if (!isRecord(raw) || typeof raw.type !== 'string') return null;
+  const make = BLOCKS[raw.type];
+  return make === undefined ? null : make(raw);
+}
+
+function entryOf(line: Record<string, unknown>): TranscriptEntry | null {
+  if ((line.type !== 'user' && line.type !== 'assistant') || line.isSidechain === true) return null;
+  const message = isRecord(line.message) ? line.message : {};
+  const content = message.content;
+  const blocks =
+    typeof content === 'string'
+      ? [blockOf({ type: 'text', text: content })]
+      : Array.isArray(content)
+        ? content.map(blockOf)
+        : [];
+  const kept = blocks.filter((b): b is Block => b !== null);
+  if (kept.length === 0) return null;
+  return { uuid: str(line.uuid) ?? '', at: str(line.timestamp), role: line.type, blocks: kept };
+}
+
+export async function readTranscript(
+  project: string,
+  session: string,
+  offset: number,
+  limit: number,
+  dir = claudeDir(),
+): Promise<TranscriptPage> {
+  const path = join(projectDir(project, dir), `${safeName(session, SESSION_RE, 'session id')}.jsonl`);
+  if (!existsSync(path)) throw new ApiError('no such session', 404);
+  const entries: TranscriptEntry[] = [];
+  let total = 0;
+  const lines = createInterface({ input: createReadStream(path), crlfDelay: Infinity });
+  for await (const line of lines) {
+    const parsed = parseLines(line)[0];
+    const entry = parsed === undefined ? null : entryOf(parsed);
+    if (entry === null) continue;
+    if (total >= offset && entries.length < limit) entries.push(entry);
+    total += 1;
+  }
+  return { entries, total, next: offset + limit < total ? offset + limit : null };
+}
+
+export function deleteClaudeSession(project: string, session: string, dir = claudeDir()): void {
+  const root = projectDir(project, dir);
+  const id = safeName(session, SESSION_RE, 'session id');
+  const file = join(root, `${id}.jsonl`);
+  if (!existsSync(file)) throw new ApiError('no such session', 404);
+  removeHome(file);
+  removeHome(join(root, id), true);
+}
+
+export interface MemoryFile {
+  name: string;
+  bytes: number;
+  modifiedAt: string;
+}
+
+export interface MemoryListing {
+  files: MemoryFile[];
+  index: string | null;
+}
+
+function memoryDir(project: string, dir: string): string {
+  return join(projectDir(project, dir), 'memory');
+}
+
+function readCapped(path: string): string {
+  const size = statSync(path).size;
+  const text = readRange(path, 0, Math.min(size, FILE_CAP)).toString('utf8');
+  return size > FILE_CAP ? `${text}\n\n… truncated` : text;
+}
+
+function memoryName(name: string): string[] {
+  const segments = name.split('/');
+  const file = segments.at(-1) ?? '';
+  const folders = segments.slice(0, -1);
+  if (folders.length >= MEMORY_DEPTH || !MEMORY_RE.test(file) || folders.some((f) => !FOLDER_RE.test(f)))
+    throw new ApiError('that is not a memory file name', 400);
+  return segments;
+}
+
+function memoryPath(project: string, name: string, dir: string): string {
+  return join(memoryDir(project, dir), ...memoryName(name));
+}
+
+function walkMemory(root: string, folders: string[], out: MemoryFile[]): void {
+  for (const entry of readdirEntries(join(root, ...folders))) {
+    if (out.length >= MEMORY_FILES_MAX) return;
+    const inner = [...folders, entry.name];
+    if (entry.isDirectory() && FOLDER_RE.test(entry.name) && inner.length < MEMORY_DEPTH) walkMemory(root, inner, out);
+    else if (entry.isFile() && MEMORY_RE.test(entry.name) && !(folders.length === 0 && entry.name === 'MEMORY.md')) {
+      const s = statSync(join(root, ...inner));
+      out.push({ name: inner.join('/'), bytes: s.size, modifiedAt: s.mtime.toISOString() });
+    }
+  }
+}
+
+export function listMemory(project: string, dir = claudeDir()): MemoryListing {
+  const path = memoryDir(project, dir);
+  if (!existsSync(path)) return { files: [], index: null };
+  const files: MemoryFile[] = [];
+  walkMemory(path, [], files);
+  files.sort((a, b) => b.modifiedAt.localeCompare(a.modifiedAt) || a.name.localeCompare(b.name));
+  const index = join(path, 'MEMORY.md');
+  return { files, index: existsSync(index) ? readCapped(index) : null };
+}
+
+const stampOf = (raw: string | undefined): Date | null => {
+  if (raw === undefined) return null;
+  const at = new Date(raw);
+  return Number.isNaN(at.getTime()) ? null : at;
+};
+
+export function writeMemoryFile(project: string, name: string, text: string, dir = claudeDir(), modifiedAt?: string): MemoryFile {
+  if (text.trim() === '') throw new ApiError('a memory file cannot be empty', 400);
+  if (Buffer.byteLength(text, 'utf8') > MEMORY_MAX)
+    throw new ApiError(`a memory file is at most ${String(MEMORY_MAX)} bytes`, 400);
+  const path = memoryPath(project, name, dir);
+  writeHomeText(path, text, MEMORY_MODE, stampOf(modifiedAt) ?? undefined);
+  const stat = statSync(path);
+  return { name, bytes: stat.size, modifiedAt: stat.mtime.toISOString() };
+}
+
+export function deleteMemoryFile(project: string, name: string, dir = claudeDir()): string {
+  const path = memoryPath(project, name, dir);
+  if (!existsSync(path)) throw new ApiError('no such memory file', 404);
+  removeHome(path);
+  return name;
+}
+
+export function readMemoryFile(project: string, name: string, dir = claudeDir()): string {
+  const path = memoryPath(project, name, dir);
+  if (!existsSync(path)) throw new ApiError('no such memory file', 404);
+  return readCapped(path);
+}

package/runtime/node_modules/@metro-labs/daemon/src/claude/github-api.ts

@@ -0,0 +1,12 @@
+import type { IncomingMessage } from 'node:http';
+import { readJsonBody } from '@metro-labs/http/api-http';
+import { ApiError } from '@metro-labs/http/api-error';
+import { githubSkills, type GitHubSkills } from './github-skills.js';
+
+export async function githubSkillsAnswer(req: IncomingMessage, source: GitHubSkills = githubSkills()): Promise<object> {
+  if (req.method === 'GET') return source.view();
+  if (req.method === 'PUT') return source.configure(await readJsonBody(req, 4096));
+  if (req.method === 'DELETE') return source.remove();
+  if (req.method === 'POST') { await source.sync(true); return source.view(); }
+  throw new ApiError('method not allowed', 405);
+}

package/runtime/node_modules/@metro-labs/daemon/src/claude/github-fetch.ts

@@ -0,0 +1,160 @@
+import { createHash } from 'node:crypto';
+import { isRecord } from '@metro-labs/core/is-record';
+import { SKILL_COMMIT, SKILL_FILE_MAX, SKILL_FILES_MAX, SKILL_TOTAL_MAX, skillPath, type SkillSource } from '@metro-labs/core/skill-source';
+
+export class GitHubFailure extends Error {
+  constructor(message: string, readonly retryAt = Date.now() + 60_000, readonly rateLimited = false) { super(message); }
+}
+
+export interface GitHubSnapshot {
+  repositoryId: number;
+  commit: string;
+  etag: string | null;
+  files: Map<string, Buffer>;
+  executables?: string[];
+}
+
+interface Entry { path: string; mode: string; type: string; sha: string; size: number }
+type Request = (url: string, init: RequestInit) => Promise<Response>;
+const API = 'https://api.github.com/repos/';
+const RESPONSE_MAX = 2 * 1024 * 1024;
+
+async function boundedJson(response: Response, text: boolean): Promise<unknown> {
+  if (response.body === null) throw new GitHubFailure('GitHub returned an empty response.');
+  const reader = response.body.getReader();
+  const chunks: Uint8Array[] = [];
+  let bytes = 0;
+  try {
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      bytes += value.byteLength;
+      if (bytes > RESPONSE_MAX) throw new GitHubFailure('GitHub returned too much data. Choose a smaller skills folder.');
+      chunks.push(value);
+    }
+    const body = Buffer.concat(chunks).toString('utf8');
+    return text ? body.trim() : JSON.parse(body) as unknown;
+  } finally { await reader.cancel().catch(() => undefined); }
+}
+
+function refused(response: Response): GitHubFailure {
+  const retry = Number(response.headers.get('retry-after'));
+  const reset = Number(response.headers.get('x-ratelimit-reset')) * 1000;
+  if (response.status === 429 || (response.status === 403 && (response.headers.get('x-ratelimit-remaining') === '0' || retry > 0))) {
+    return new GitHubFailure('GitHub rate limit reached. Sync will retry later.', Math.max(Date.now() + 60_000, Date.now() + (Number.isFinite(retry) ? retry * 1000 : 0), Number.isFinite(reset) ? reset : 0), true);
+  }
+  if ([401, 403, 404].includes(response.status)) return new GitHubFailure('GitHub access was refused. Check the repository, ref, token expiry and organization approval. The loaded skills are kept.', Date.now() + 15 * 60_000);
+  return new GitHubFailure('GitHub could not provide the skills. The loaded skills are kept.');
+}
+
+function headers(token: string, etag: string | null | undefined, shaOnly: boolean): Record<string, string> {
+  return { Authorization: `Bearer ${token}`, Accept: shaOnly ? 'application/vnd.github.sha' : 'application/vnd.github+json', 'X-GitHub-Api-Version': '2022-11-28', ...(etag ? { 'If-None-Match': etag } : {}) };
+}
+
+export class GitHubReader {
+  private readonly base: string;
+  private count = 0;
+  private readonly signal = AbortSignal.timeout(120_000);
+  constructor(private readonly source: SkillSource, private readonly token: string, private readonly request: Request = fetch) {
+    this.base = `${API}${source.repository}`;
+  }
+
+  private async get(path: string, etag?: string | null, shaOnly = false): Promise<{ data: unknown; etag: string | null; unchanged: boolean }> {
+    if (++this.count > SKILL_FILES_MAX + 12) throw new GitHubFailure('The skills folder needs too many GitHub requests.');
+    let response: Response;
+    try {
+      response = await this.request(`${this.base}${path}`, {
+        headers: headers(this.token, etag, shaOnly),
+        redirect: 'manual', signal: AbortSignal.any([this.signal, AbortSignal.timeout(20_000)]),
+      });
+    } catch { throw new GitHubFailure('GitHub is unreachable. The loaded skills are kept.'); }
+    if (response.status === 304) return { data: null, etag: etag ?? null, unchanged: true };
+    if (!response.ok) { await response.body?.cancel(); throw refused(response); }
+    try { return { data: await boundedJson(response, shaOnly), etag: response.headers.get('etag'), unchanged: false }; }
+    catch (err) { if (err instanceof GitHubFailure) throw err; throw new GitHubFailure('GitHub returned invalid skills data.'); }
+  }
+
+  private async tree(sha: string, recursive: boolean): Promise<Entry[]> {
+    const { data } = await this.get(`/git/trees/${sha}${recursive ? '?recursive=1' : ''}`);
+    if (!isRecord(data) || data.truncated !== false || !Array.isArray(data.tree) || data.tree.length > 4096) throw new GitHubFailure('The GitHub tree is incomplete or too large. Choose a smaller skills folder.');
+    return data.tree.map((raw: unknown) => {
+      if (!isRecord(raw) || typeof raw.path !== 'string' || typeof raw.mode !== 'string' || typeof raw.type !== 'string' || typeof raw.sha !== 'string' || !SKILL_COMMIT.test(raw.sha)) throw new GitHubFailure('GitHub returned an invalid tree.');
+      return { path: raw.path, mode: raw.mode, type: raw.type, sha: raw.sha, size: typeof raw.size === 'number' ? raw.size : 0 };
+    });
+  }
+
+  private async folder(tree: string): Promise<string> {
+    let sha = tree;
+    for (const segment of this.source.folder.split('/').filter(Boolean)) {
+      const entry = (await this.tree(sha, false)).find((row) => row.path === segment);
+      if (entry?.mode !== '040000' || entry.type !== 'tree') throw new GitHubFailure('The selected skills folder is missing or is not a regular directory.');
+      sha = entry.sha;
+    }
+    return sha;
+  }
+
+  private async blob(entry: Entry): Promise<Buffer> {
+    const { data } = await this.get(`/git/blobs/${entry.sha}`);
+    if (!isRecord(data) || data.encoding !== 'base64' || typeof data.content !== 'string' || data.size !== entry.size) throw new GitHubFailure('GitHub returned an invalid skill file.');
+    const encoded = data.content.replace(/\n/g, '');
+    if (!/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(encoded)) throw new GitHubFailure('GitHub returned an invalid skill file.');
+    const bytes = Buffer.from(encoded, 'base64');
+    const hash = createHash('sha1').update(`blob ${bytes.byteLength}\0`).update(bytes).digest('hex');
+    if (bytes.byteLength !== entry.size || hash !== entry.sha) throw new GitHubFailure('A skill file has an unexpected size or Git object hash.');
+    return bytes;
+  }
+
+  private async repository(expected: number | null): Promise<number> {
+    const repo = (await this.get('')).data;
+    if (!isRecord(repo) || typeof repo.id !== 'number' || typeof repo.full_name !== 'string' || repo.full_name.toLowerCase() !== this.source.repository.toLowerCase() || (expected !== null && repo.id !== expected)) throw new GitHubFailure('The GitHub repository identity changed. Reconnect it explicitly.');
+    return repo.id;
+  }
+
+  async snapshot(repositoryId: number | null, commit: string | null, etag: string | null): Promise<GitHubSnapshot | null> {
+    const id = await this.repository(repositoryId);
+    const resolved = await this.get(`/commits/${encodeURIComponent(this.source.ref)}`, etag, true);
+    if (resolved.unchanged) return null;
+    if (typeof resolved.data !== 'string' || !SKILL_COMMIT.test(resolved.data)) throw new GitHubFailure('GitHub did not resolve an immutable commit.');
+    if (resolved.data === commit) return null;
+    const data = immutableCommit((await this.get(`/git/commits/${resolved.data}`)).data);
+    if (data.sha !== resolved.data) throw new GitHubFailure('GitHub returned a different commit.');
+    const entries = checkedEntries(await this.tree(await this.folder(data.tree), true));
+    const files = await this.blobs(entries);
+    return { repositoryId: id, commit: data.sha, etag: resolved.etag, files, executables: entries.filter((entry) => entry.mode === '100755').map((entry) => entry.path) };
+  }
+
+  private async blobs(entries: Entry[]): Promise<Map<string, Buffer>> {
+    const queue = [...entries];
+    const files = new Map<string, Buffer>();
+    const worker = async (): Promise<void> => {
+      for (let entry = queue.shift(); entry !== undefined; entry = queue.shift()) files.set(entry.path, await this.blob(entry));
+    };
+    try { await Promise.all(Array.from({ length: Math.min(4, queue.length) }, worker)); }
+    catch (err) { queue.length = 0; throw err; }
+    return files;
+  }
+}
+
+function immutableCommit(data: unknown): { sha: string; tree: string } {
+  if (!isRecord(data) || typeof data.sha !== 'string' || !SKILL_COMMIT.test(data.sha) || !isRecord(data.tree) || typeof data.tree.sha !== 'string' || !SKILL_COMMIT.test(data.tree.sha)) throw new GitHubFailure('GitHub did not resolve an immutable commit.');
+  return { sha: data.sha, tree: data.tree.sha };
+}
+
+function regularFile(entry: Entry): void {
+  if (entry.type !== 'blob' || !['100644', '100755'].includes(entry.mode)) throw new GitHubFailure('Symlinks, submodules and special files are not supported in skills.');
+  if (!skillPath(entry.path) || entry.size < 0 || entry.size > SKILL_FILE_MAX || !Number.isInteger(entry.size)) throw new GitHubFailure('A skills path or file size is not supported. Use skill-name/SKILL.md and regular resources, up to 256 KiB each.');
+}
+
+function checkedEntries(entries: Entry[]): Entry[] {
+  const files: Entry[] = [];
+  let total = 0;
+  for (const entry of entries) {
+    if (entry.mode === '040000' && entry.type === 'tree') continue;
+    regularFile(entry);
+    total += entry.size;
+    files.push(entry);
+  }
+  if (files.length > SKILL_FILES_MAX || total > SKILL_TOTAL_MAX) throw new GitHubFailure('Skills exceed 256 files or 8 MiB.');
+  if (new Set(files.map((entry) => entry.path.toLowerCase())).size !== files.length) throw new GitHubFailure('Skills contain duplicate file paths.');
+  return files;
+}