@remix-run/cli 0.0.0 → 0.1.0

package/dist/lib/skills-cache.js

@@ -0,0 +1,89 @@
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import * as process from 'node:process';
+const REMIX_SKILLS_CACHE_VERSION = 1;
+const REMIX_SKILLS_CACHE_REPO = 'remix-run/remix';
+const REMIX_SKILLS_CACHE_REF = 'main';
+export function createSkillsCacheManifest(skillsDir, skills) {
+    return {
+        ref: REMIX_SKILLS_CACHE_REF,
+        repo: REMIX_SKILLS_CACHE_REPO,
+        skills,
+        skillsDir: path.resolve(skillsDir),
+        version: REMIX_SKILLS_CACHE_VERSION,
+    };
+}
+export function getSkillsCacheFilePath(skillsDir) {
+    let cacheKey = crypto.createHash('sha256').update(path.resolve(skillsDir)).digest('hex');
+    return path.join(getSkillsCacheDir(), `${cacheKey}.json`);
+}
+export async function readSkillsCache(skillsDir) {
+    try {
+        let filePath = getSkillsCacheFilePath(skillsDir);
+        let raw = JSON.parse(await fs.readFile(filePath, 'utf8'));
+        return isSkillsCacheManifest(raw, skillsDir) ? raw : null;
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            return null;
+        }
+        let nodeError = error;
+        if (nodeError.code === 'ENOENT') {
+            return null;
+        }
+        throw error;
+    }
+}
+export async function writeSkillsCache(skillsDir, manifest) {
+    let filePath = getSkillsCacheFilePath(skillsDir);
+    let tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(tempPath, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+    await fs.rename(tempPath, filePath);
+}
+function getSkillsCacheDir() {
+    if (process.platform === 'win32') {
+        let localAppData = process.env.LOCALAPPDATA ?? path.join(os.homedir(), 'AppData', 'Local');
+        return path.join(localAppData, 'remix', 'Cache', 'skills');
+    }
+    if (process.platform === 'darwin') {
+        return path.join(process.env.HOME ?? os.homedir(), 'Library', 'Caches', 'remix', 'cli', 'skills');
+    }
+    let xdgCacheHome = process.env.XDG_CACHE_HOME ?? path.join(os.homedir(), '.cache');
+    return path.join(xdgCacheHome, 'remix', 'cli', 'skills');
+}
+function isSkillsCacheManifest(value, skillsDir) {
+    if (typeof value !== 'object' || value == null) {
+        return false;
+    }
+    if (Reflect.get(value, 'version') !== REMIX_SKILLS_CACHE_VERSION ||
+        Reflect.get(value, 'repo') !== REMIX_SKILLS_CACHE_REPO ||
+        Reflect.get(value, 'ref') !== REMIX_SKILLS_CACHE_REF ||
+        Reflect.get(value, 'skillsDir') !== path.resolve(skillsDir)) {
+        return false;
+    }
+    let skills = Reflect.get(value, 'skills');
+    if (typeof skills !== 'object' || skills == null) {
+        return false;
+    }
+    for (let skillEntry of Object.values(skills)) {
+        if (typeof skillEntry !== 'object' || skillEntry == null) {
+            return false;
+        }
+        let files = Reflect.get(skillEntry, 'files');
+        if (typeof files !== 'object' || files == null) {
+            return false;
+        }
+        for (let fileEntry of Object.values(files)) {
+            if (typeof fileEntry !== 'object' ||
+                fileEntry == null ||
+                typeof Reflect.get(fileEntry, 'localHash') !== 'string' ||
+                typeof Reflect.get(fileEntry, 'remoteSha') !== 'string') {
+                return false;
+            }
+        }
+    }
+    return true;
+}

package/dist/lib/skills.d.ts

@@ -0,0 +1,30 @@
+import { type StepProgressReporter } from './reporter.ts';
+export interface SkillChange {
+    action: 'add' | 'replace';
+    name: string;
+}
+export interface SkillStatusEntry {
+    name: string;
+    state: 'installed' | 'missing' | 'outdated';
+}
+interface SkillsResult {
+    entries: SkillStatusEntry[];
+    projectRoot: string;
+    skillsDir: string;
+}
+export interface SkillsOverview extends SkillsResult {
+}
+export interface SkillsInstallResult extends SkillsResult {
+    appliedChanges: SkillChange[];
+}
+export interface SkillsOptions {
+    progress?: SkillsProgressReporter;
+    skillsDir?: string;
+}
+export type SkillsInstallPhase = 'resolve-project-root' | 'fetch-remix-skills-metadata' | 'read-local-skills-cache' | 'compare-local-skills' | 'download-remix-skills-archive' | 'write-updated-skills';
+export type SkillsProgressReporter = StepProgressReporter<SkillsInstallPhase>;
+type FetchImpl = typeof fetch;
+export declare function getSkillsOverview(cwd?: string, fetchImpl?: FetchImpl, options?: SkillsOptions): Promise<SkillsOverview>;
+export declare function installRemixSkills(cwd?: string, fetchImpl?: FetchImpl, options?: SkillsOptions): Promise<SkillsInstallResult>;
+export {};
+//# sourceMappingURL=skills.d.ts.map

package/dist/lib/skills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skills.d.ts","sourceRoot":"","sources":["../../src/lib/skills.ts"],"names":[],"mappings":"AASA,OAAO,EAAmB,KAAK,oBAAoB,EAAE,MAAM,eAAe,CAAA;AAe1E,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,KAAK,GAAG,SAAS,CAAA;IACzB,IAAI,EAAE,MAAM,CAAA;CACb;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,WAAW,GAAG,SAAS,GAAG,UAAU,CAAA;CAC5C;AAED,UAAU,YAAY;IACpB,OAAO,EAAE,gBAAgB,EAAE,CAAA;IAC3B,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,cAAe,SAAQ,YAAY;CAAG;AAEvD,MAAM,WAAW,mBAAoB,SAAQ,YAAY;IACvD,cAAc,EAAE,WAAW,EAAE,CAAA;CAC9B;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,EAAE,sBAAsB,CAAA;IACjC,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,MAAM,kBAAkB,GAC1B,sBAAsB,GACtB,6BAA6B,GAC7B,yBAAyB,GACzB,sBAAsB,GACtB,+BAA+B,GAC/B,sBAAsB,CAAA;AAE1B,MAAM,MAAM,sBAAsB,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,CAAA;AA4C7E,KAAK,SAAS,GAAG,OAAO,KAAK,CAAA;AAE7B,wBAAsB,iBAAiB,CACrC,GAAG,GAAE,MAAsB,EAC3B,SAAS,GAAE,SAA4B,EACvC,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,cAAc,CAAC,CAOzB;AAED,wBAAsB,kBAAkB,CACtC,GAAG,GAAE,MAAsB,EAC3B,SAAS,GAAE,SAA4B,EACvC,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,mBAAmB,CAAC,CA4C9B"}

package/dist/lib/skills.js

@@ -0,0 +1,441 @@
+import { parseTar } from '@remix-run/tar-parser';
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as process from 'node:process';
+import { gunzipSync } from 'node:zlib';
+import { resolveContainedPath } from "./contained-path.js";
+import { fetchUnavailable, projectRootNotFound, remoteSkillDataMissing } from "./errors.js";
+import { runProgressStep } from "./reporter.js";
+import { createSkillsCacheManifest, readSkillsCache, writeSkillsCache, } from "./skills-cache.js";
+const REMIX_GITHUB_TREE_URL = 'https://api.github.com/repos/remix-run/remix/git/trees/main?recursive=1';
+const REMIX_GITHUB_ARCHIVE_URL = 'https://codeload.github.com/remix-run/remix/tar.gz/refs/heads/main';
+const REMIX_SKILLS_PATH = 'skills/';
+export async function getSkillsOverview(cwd = process.cwd(), fetchImpl = globalThis.fetch, options = {}) {
+    let plan = await loadSkillsPlan(cwd, fetchImpl, options);
+    return {
+        entries: plan.entries,
+        projectRoot: plan.projectRoot,
+        skillsDir: plan.skillsDir,
+    };
+}
+export async function installRemixSkills(cwd = process.cwd(), fetchImpl = globalThis.fetch, options = {}) {
+    let plan = await loadSkillsPlan(cwd, fetchImpl, options);
+    if (plan.pendingChanges.length === 0) {
+        options.progress?.skip('write-updated-skills', 'No changes.');
+        return {
+            appliedChanges: [],
+            entries: plan.entries,
+            projectRoot: plan.projectRoot,
+            skillsDir: plan.skillsDir,
+        };
+    }
+    let targetSkillNames = new Set(plan.pendingChanges.map((change) => change.name));
+    let downloadedSkills = await runProgressStep(options.progress, 'download-remix-skills-archive', () => downloadRemoteSkillsArchive(fetchImpl, plan.remoteSkills, targetSkillNames));
+    await runProgressStep(options.progress, 'write-updated-skills', async () => {
+        await fs.mkdir(plan.skillsDir, { recursive: true });
+        for (let change of plan.pendingChanges) {
+            let remoteSkill = downloadedSkills.get(change.name);
+            if (remoteSkill == null) {
+                throw remoteSkillDataMissing(change.name);
+            }
+            let skillDir = resolveRemoteSkillDir(plan.skillsDir, remoteSkill.name);
+            await fs.rm(skillDir, { recursive: true, force: true });
+            await writeRemoteSkill(skillDir, remoteSkill);
+        }
+        let manifest = await buildSkillsCacheManifest(plan.skillsDir, plan.remoteSkills);
+        await writeSkillsCache(plan.skillsDir, manifest);
+    });
+    return {
+        appliedChanges: plan.pendingChanges,
+        entries: plan.entries,
+        projectRoot: plan.projectRoot,
+        skillsDir: plan.skillsDir,
+    };
+}
+async function loadSkillsPlan(cwd, fetchImpl, options = {}) {
+    if (typeof fetchImpl !== 'function') {
+        throw fetchUnavailable();
+    }
+    let projectRoot = await runProgressStep(options.progress, 'resolve-project-root', () => findProjectRoot(cwd));
+    let skillsDir = resolveSkillsDir(projectRoot, options.skillsDir);
+    let remoteSkills = await runProgressStep(options.progress, 'fetch-remix-skills-metadata', () => fetchRemoteSkills(fetchImpl));
+    let cacheManifest = await runProgressStep(options.progress, 'read-local-skills-cache', () => readSkillsCache(skillsDir));
+    let entries = await runProgressStep(options.progress, 'compare-local-skills', async () => Promise.all(remoteSkills.map(async (remoteSkill) => {
+        let localSkill = await readLocalSkill(resolveRemoteSkillDir(skillsDir, remoteSkill.name));
+        return {
+            name: remoteSkill.name,
+            state: getSkillState(remoteSkill, localSkill, cacheManifest),
+        };
+    })));
+    entries.sort((left, right) => left.name.localeCompare(right.name));
+    return {
+        entries,
+        pendingChanges: entries
+            .filter((entry) => entry.state !== 'installed')
+            .map((entry) => ({
+            action: entry.state === 'missing' ? 'add' : 'replace',
+            name: entry.name,
+        })),
+        projectRoot,
+        remoteSkills,
+        skillsDir,
+    };
+}
+async function fetchRemoteSkills(fetchImpl) {
+    let treeResponse = await fetchGitHubJson(fetchImpl, REMIX_GITHUB_TREE_URL, 'Could not fetch Remix skills metadata from GitHub.');
+    if (treeResponse.truncated === true) {
+        throw new Error('GitHub returned a truncated Remix skills listing.');
+    }
+    if (!Array.isArray(treeResponse.tree)) {
+        throw new Error('Received an invalid Remix skills listing from GitHub.');
+    }
+    let groupedFiles = new Map();
+    for (let entry of treeResponse.tree) {
+        if (!isGitHubTreeEntry(entry)) {
+            continue;
+        }
+        if (entry.type !== 'blob' || !entry.path.startsWith(REMIX_SKILLS_PATH)) {
+            continue;
+        }
+        let pathParts = entry.path.split('/');
+        if (pathParts.length < 3) {
+            continue;
+        }
+        let skillName = pathParts[1];
+        let filePath = pathParts.slice(2).join('/');
+        if (skillName.length === 0) {
+            continue;
+        }
+        validateRemoteSkillPath(skillName, filePath, entry.path);
+        let existing = groupedFiles.get(skillName) ?? [];
+        existing.push({
+            path: filePath,
+            sha: entry.sha,
+        });
+        groupedFiles.set(skillName, existing);
+    }
+    let remoteSkills = [...groupedFiles.entries()]
+        .filter(([, files]) => files.some((file) => file.path === 'SKILL.md'))
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([skillName, files]) => ({
+        files: files.slice().sort((left, right) => left.path.localeCompare(right.path)),
+        name: skillName,
+    }));
+    if (remoteSkills.length === 0) {
+        throw new Error('Could not find any Remix skills on GitHub.');
+    }
+    return remoteSkills;
+}
+async function downloadRemoteSkillsArchive(fetchImpl, remoteSkills, targetSkillNames) {
+    let compressedArchive = await fetchGitHubBytes(fetchImpl, REMIX_GITHUB_ARCHIVE_URL, 'Could not download the Remix skills archive from GitHub.');
+    let archive = gunzipSync(compressedArchive);
+    let downloadedFiles = new Map();
+    await parseTar(archive, async (entry) => {
+        if (entry.header.type !== 'file') {
+            return;
+        }
+        let archivePath = getArchiveSkillPath(entry.name);
+        if (archivePath == null) {
+            return;
+        }
+        let [skillName, ...fileParts] = archivePath.split('/');
+        if (skillName == null || skillName.length === 0 || fileParts.length === 0) {
+            return;
+        }
+        if (!targetSkillNames.has(skillName)) {
+            return;
+        }
+        let filePath = fileParts.join('/');
+        validateRemoteSkillPath(skillName, filePath, archivePath);
+        let files = downloadedFiles.get(skillName);
+        if (files == null) {
+            files = new Map();
+            downloadedFiles.set(skillName, files);
+        }
+        files.set(filePath, new TextDecoder().decode(await entry.bytes()));
+    });
+    let downloadedSkills = new Map();
+    for (let remoteSkill of remoteSkills) {
+        if (!targetSkillNames.has(remoteSkill.name)) {
+            continue;
+        }
+        let files = downloadedFiles.get(remoteSkill.name);
+        if (files == null || files.size !== remoteSkill.files.length) {
+            throw new Error(`GitHub returned incomplete archive data for Remix skill: ${remoteSkill.name}.`);
+        }
+        let validatedFiles = remoteSkill.files.map((file) => {
+            let content = files.get(file.path);
+            if (content == null) {
+                throw new Error(`GitHub returned incomplete archive data for Remix skill file: ${remoteSkill.name}/${file.path}.`);
+            }
+            let bytes = Buffer.from(content, 'utf8');
+            if (computeGitBlobSha(bytes) !== file.sha) {
+                throw new Error(`GitHub returned Remix skill content that did not match the metadata listing for ${remoteSkill.name}/${file.path}. Please try again.`);
+            }
+            return {
+                content,
+                path: file.path,
+            };
+        });
+        downloadedSkills.set(remoteSkill.name, {
+            files: validatedFiles,
+            name: remoteSkill.name,
+        });
+    }
+    return downloadedSkills;
+}
+async function fetchGitHubJson(fetchImpl, url, failureMessage) {
+    let response = await fetchImpl(url, { headers: createGitHubHeaders() });
+    if (!response.ok) {
+        throw createGitHubRequestError(response, failureMessage);
+    }
+    return (await response.json());
+}
+async function fetchGitHubBytes(fetchImpl, url, failureMessage) {
+    let response = await fetchImpl(url, { headers: createGitHubHeaders() });
+    if (!response.ok) {
+        throw createGitHubRequestError(response, failureMessage);
+    }
+    return new Uint8Array(await response.arrayBuffer());
+}
+function createGitHubHeaders() {
+    let token = process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN;
+    return {
+        Accept: 'application/vnd.github+json',
+        ...(token ? { Authorization: `Bearer ${token}` } : {}),
+        'User-Agent': '@remix-run/cli',
+    };
+}
+function createGitHubRequestError(response, failureMessage) {
+    if (response.status === 403 && response.headers.get('x-ratelimit-remaining') === '0') {
+        let resetText = getGitHubRateLimitResetText(response);
+        return new Error(`${failureMessage} GitHub API rate limit exceeded.${resetText} Set GITHUB_TOKEN or GH_TOKEN to use a higher authenticated GitHub rate limit.`);
+    }
+    return new Error(`${failureMessage} ${response.status} ${response.statusText}`.trim());
+}
+function getGitHubRateLimitResetText(response) {
+    let reset = Number(response.headers.get('x-ratelimit-reset'));
+    if (!Number.isFinite(reset)) {
+        return '';
+    }
+    return ` The rate limit resets at ${new Date(reset * 1000).toISOString()}.`;
+}
+function isGitHubTreeEntry(value) {
+    return (typeof value === 'object' &&
+        value != null &&
+        typeof Reflect.get(value, 'path') === 'string' &&
+        typeof Reflect.get(value, 'sha') === 'string' &&
+        (Reflect.get(value, 'type') === 'blob' || Reflect.get(value, 'type') === 'tree'));
+}
+async function findProjectRoot(startDir) {
+    let currentDir = path.resolve(startDir);
+    while (true) {
+        if ((await pathExists(path.join(currentDir, 'package.json'))) ||
+            (await pathExists(path.join(currentDir, '.agents'))) ||
+            (await pathExists(path.join(currentDir, '.git')))) {
+            return currentDir;
+        }
+        let parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            break;
+        }
+        currentDir = parentDir;
+    }
+    throw projectRootNotFound(startDir);
+}
+function resolveSkillsDir(projectRoot, skillsDir) {
+    if (skillsDir == null || skillsDir.length === 0) {
+        return path.join(projectRoot, '.agents', 'skills');
+    }
+    if (path.isAbsolute(skillsDir)) {
+        return skillsDir;
+    }
+    return path.resolve(projectRoot, skillsDir);
+}
+async function pathExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch (error) {
+        let nodeError = error;
+        if (nodeError.code === 'ENOENT') {
+            return false;
+        }
+        throw error;
+    }
+}
+async function readLocalSkill(skillDir) {
+    try {
+        let stats = await fs.stat(skillDir);
+        if (!stats.isDirectory()) {
+            return {
+                exists: true,
+                fileHashes: new Map(),
+                isDirectory: false,
+            };
+        }
+        return {
+            exists: true,
+            fileHashes: await readLocalFiles(skillDir),
+            isDirectory: true,
+        };
+    }
+    catch (error) {
+        let nodeError = error;
+        if (nodeError.code === 'ENOENT') {
+            return {
+                exists: false,
+                fileHashes: new Map(),
+                isDirectory: false,
+            };
+        }
+        throw error;
+    }
+}
+async function readLocalFiles(rootDir, relativeDir = '') {
+    let files = new Map();
+    let dirPath = relativeDir.length === 0 ? rootDir : path.join(rootDir, relativeDir);
+    let entries = await fs.readdir(dirPath, { withFileTypes: true });
+    entries.sort((left, right) => left.name.localeCompare(right.name));
+    for (let entry of entries) {
+        let relativePath = relativeDir.length === 0 ? entry.name : `${relativeDir}/${entry.name}`;
+        let entryPath = path.join(rootDir, relativePath);
+        if (entry.isDirectory()) {
+            let nestedFiles = await readLocalFiles(rootDir, relativePath);
+            for (let [nestedPath, hash] of nestedFiles) {
+                files.set(nestedPath, hash);
+            }
+            continue;
+        }
+        if (entry.isFile()) {
+            files.set(relativePath, computeLocalContentHash(await fs.readFile(entryPath)));
+            continue;
+        }
+        files.set(relativePath, '');
+    }
+    return files;
+}
+function getSkillState(remoteSkill, localSkill, cacheManifest) {
+    if (!localSkill.exists) {
+        return 'missing';
+    }
+    if (!localSkill.isDirectory) {
+        return 'outdated';
+    }
+    let cachedSkill = cacheManifest?.skills[remoteSkill.name];
+    if (cachedSkill == null) {
+        return 'outdated';
+    }
+    let cachedFiles = new Map(Object.entries(cachedSkill.files));
+    if (localSkill.fileHashes.size !== remoteSkill.files.length ||
+        cachedFiles.size !== remoteSkill.files.length) {
+        return 'outdated';
+    }
+    for (let file of remoteSkill.files) {
+        let localHash = localSkill.fileHashes.get(file.path);
+        let cachedFile = cachedFiles.get(file.path);
+        if (localHash == null ||
+            cachedFile == null ||
+            cachedFile.localHash !== localHash ||
+            cachedFile.remoteSha !== file.sha) {
+            return 'outdated';
+        }
+    }
+    return 'installed';
+}
+async function buildSkillsCacheManifest(skillsDir, remoteSkills) {
+    let cachedSkills = {};
+    for (let remoteSkill of remoteSkills) {
+        let localSkill = await readLocalSkill(resolveRemoteSkillDir(skillsDir, remoteSkill.name));
+        if (!localSkill.exists || !localSkill.isDirectory) {
+            throw remoteSkillDataMissing(remoteSkill.name);
+        }
+        let cachedFiles = {};
+        for (let file of remoteSkill.files) {
+            let localHash = localSkill.fileHashes.get(file.path);
+            if (localHash == null) {
+                throw new Error(`Installed Remix skill is missing file data for ${remoteSkill.name}/${file.path}.`);
+            }
+            cachedFiles[file.path] = {
+                localHash,
+                remoteSha: file.sha,
+            };
+        }
+        cachedSkills[remoteSkill.name] = {
+            files: cachedFiles,
+        };
+    }
+    return createSkillsCacheManifest(skillsDir, cachedSkills);
+}
+async function writeRemoteSkill(skillDir, remoteSkill) {
+    await fs.mkdir(skillDir, { recursive: true });
+    for (let file of remoteSkill.files) {
+        let filePath = resolveRemoteSkillFilePath(skillDir, file.path);
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+        await fs.writeFile(filePath, file.content, 'utf8');
+    }
+}
+function resolveRemoteSkillDir(skillsDir, skillName) {
+    validateRemoteSkillName(skillName, skillName);
+    return resolveRemoteSkillPath(skillsDir, skillName);
+}
+function resolveRemoteSkillFilePath(skillDir, filePath) {
+    validateRemoteSkillFilePath(filePath, filePath);
+    return resolveRemoteSkillPath(skillDir, filePath);
+}
+function resolveRemoteSkillPath(rootDir, relativePath) {
+    try {
+        return resolveContainedPath(rootDir, relativePath);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes('escapes the allowed root')) {
+            throw new Error(`GitHub returned an invalid Remix skill path: ${relativePath}`);
+        }
+        throw error;
+    }
+}
+function validateRemoteSkillPath(skillName, filePath, remotePath) {
+    validateRemoteSkillName(skillName, remotePath);
+    validateRemoteSkillFilePath(filePath, remotePath);
+}
+function validateRemoteSkillName(skillName, remotePath) {
+    if (isSafeRemoteSkillPath(skillName, { allowNested: false })) {
+        return;
+    }
+    throw new Error(`GitHub returned an invalid Remix skill path: ${remotePath}`);
+}
+function validateRemoteSkillFilePath(filePath, remotePath) {
+    if (isSafeRemoteSkillPath(filePath, { allowNested: true })) {
+        return;
+    }
+    throw new Error(`GitHub returned an invalid Remix skill path: ${remotePath}`);
+}
+function isSafeRemoteSkillPath(remotePath, options) {
+    if (remotePath.length === 0 ||
+        remotePath.includes('\\') ||
+        path.posix.isAbsolute(remotePath) ||
+        path.win32.isAbsolute(remotePath)) {
+        return false;
+    }
+    let pathParts = remotePath.split('/');
+    if (!options.allowNested && pathParts.length !== 1) {
+        return false;
+    }
+    return pathParts.every((pathPart) => pathPart.length > 0 && pathPart !== '.' && pathPart !== '..');
+}
+function getArchiveSkillPath(entryName) {
+    let marker = `/${REMIX_SKILLS_PATH}`;
+    let markerIndex = entryName.indexOf(marker);
+    if (markerIndex === -1) {
+        return null;
+    }
+    return entryName.slice(markerIndex + marker.length);
+}
+function computeLocalContentHash(bytes) {
+    return crypto.createHash('sha256').update(bytes).digest('hex');
+}
+function computeGitBlobSha(bytes) {
+    return crypto.createHash('sha1').update(`blob ${bytes.length}\0`).update(bytes).digest('hex');
+}

package/dist/lib/terminal.d.ts

@@ -0,0 +1,17 @@
+export declare function configureColors(options: {
+    disabled: boolean;
+}): void;
+export declare function bold(text: string, target?: NodeJS.WriteStream): string;
+export declare function lightGreen(text: string, target?: NodeJS.WriteStream): string;
+export declare function lightBlue(text: string, target?: NodeJS.WriteStream): string;
+export declare function boldLightBlue(text: string, target?: NodeJS.WriteStream): string;
+export declare function lightGray(text: string, target?: NodeJS.WriteStream): string;
+export declare function lightMagenta(text: string, target?: NodeJS.WriteStream): string;
+export declare function lightRed(text: string, target?: NodeJS.WriteStream): string;
+export declare function lightYellow(text: string, target?: NodeJS.WriteStream): string;
+export declare function reset(target: NodeJS.WriteStream): string;
+export declare function remixWordmark(target?: NodeJS.WriteStream): string;
+export declare function clearCurrentLine(): string;
+export declare function restoreTerminalFormatting(): void;
+export declare function canUseAnsi(target: NodeJS.WriteStream): boolean;
+//# sourceMappingURL=terminal.d.ts.map

package/dist/lib/terminal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terminal.d.ts","sourceRoot":"","sources":["../../src/lib/terminal.ts"],"names":[],"mappings":"AAMA,wBAAgB,eAAe,CAAC,OAAO,EAAE;IAAE,QAAQ,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CAEpE;AAED,wBAAgB,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,MAAM,CAAC,WAA4B,GAAG,MAAM,CAEtF;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,MAAM,CAAC,WAA4B,GAAG,MAAM,CAE5F;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,MAAM,CAAC,WAA4B,GAAG,MAAM,CAE3F;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,MAAM,CAAC,WAA4B,GAAG,MAAM,CAE/F;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,MAAM,CAAC,WAA4B,GAAG,MAAM,CAE3F;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,MAAM,CAAC,WAA4B,GAAG,MAAM,CAE9F;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,MAAM,CAAC,WAA4B,GAAG,MAAM,CAE1F;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,MAAM,CAAC,WAA4B,GAAG,MAAM,CAE7F;AAED,wBAAgB,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,WAAW,GAAG,MAAM,CAExD;AAED,wBAAgB,aAAa,CAAC,MAAM,GAAE,MAAM,CAAC,WAA4B,GAAG,MAAM,CAYjF;AAED,wBAAgB,gBAAgB,IAAI,MAAM,CAEzC;AAED,wBAAgB,yBAAyB,IAAI,IAAI,CAShD;AAUD,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,WAAW,GAAG,OAAO,CAE9D"}

package/dist/lib/terminal.js

@@ -0,0 +1,66 @@
+import * as process from 'node:process';
+import { ansi, createTerminal, shouldUseColors } from '@remix-run/terminal';
+let colorDisabledByFlag = false;
+export function configureColors(options) {
+    colorDisabledByFlag = options.disabled;
+}
+export function bold(text, target = process.stdout) {
+    return paint(text, ansi.bold, target);
+}
+export function lightGreen(text, target = process.stdout) {
+    return paint(text, ansi.greenBright, target);
+}
+export function lightBlue(text, target = process.stdout) {
+    return paint(text, ansi.blueBright, target);
+}
+export function boldLightBlue(text, target = process.stdout) {
+    return isColorDisabled(target) ? text : `${ansi.bold}${ansi.blueBright}${text}${ansi.reset}`;
+}
+export function lightGray(text, target = process.stdout) {
+    return paint(text, ansi.gray, target);
+}
+export function lightMagenta(text, target = process.stdout) {
+    return paint(text, ansi.magentaBright, target);
+}
+export function lightRed(text, target = process.stdout) {
+    return paint(text, ansi.redBright, target);
+}
+export function lightYellow(text, target = process.stdout) {
+    return paint(text, ansi.yellowBright, target);
+}
+export function reset(target) {
+    return isColorDisabled(target) ? '' : ansi.reset;
+}
+export function remixWordmark(target = process.stdout) {
+    if (isColorDisabled(target)) {
+        return 'REMIX';
+    }
+    return [
+        paint('R', ansi.blueBright, target),
+        paint('E', ansi.greenBright, target),
+        paint('M', ansi.yellowBright, target),
+        paint('I', ansi.magentaBright, target),
+        paint('X', ansi.redBright, target),
+    ].join('');
+}
+export function clearCurrentLine() {
+    return `\r${ansi.clearLine}`;
+}
+export function restoreTerminalFormatting() {
+    if (canUseAnsi(process.stdout)) {
+        createTerminal({ stdout: process.stdout }).write(ansi.reset);
+        return;
+    }
+    if (canUseAnsi(process.stderr)) {
+        createTerminal({ stderr: process.stderr }).error(ansi.reset);
+    }
+}
+function paint(text, colorCode, target) {
+    return isColorDisabled(target) ? text : `${colorCode}${text}${ansi.reset}`;
+}
+function isColorDisabled(target) {
+    return colorDisabledByFlag || !shouldUseColors({ stream: target });
+}
+export function canUseAnsi(target) {
+    return process.env.TERM !== 'dumb' && target.isTTY === true;
+}