@seojin08/skill-finder 0.0.0-stage → 0.3.3

package/server/src/install/installed.js

@@ -0,0 +1,206 @@
+// What is installed on this PC and how it matches the index (UI debate stage 3: shown only, nothing is run).
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { readdir, readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join, posix } from 'node:path';
+import { extractSkillMeta } from "../analyze/frontmatter.js";
+import { riskLevel, skillRiskFlags } from "../analyze/risk.js";
+import { runClaude } from "../claude/cli.js";
+import { SKILLS_CLI_VERSION } from "../config.js";
+import { truncate } from "../util/sanitize.js";
+import { skillTokens } from "../util/tokens.js";
+import { parseJsonArray } from "./run.js";
+const sha256 = (s) => createHash('sha256').update(s).digest('hex');
+/** As the indexer hashes SKILL.md (indexer.ts buildSkillRow): line endings would otherwise make every copy differ. */
+const mdHash = (raw) => sha256(raw.replace(/\r\n/g, '\n'));
+/** Paths relative to the skill folder, for the "scripts" signal; at most 500, no dependency folders. */
+async function listFiles(dir, prefix = '', out = []) {
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const e of entries) {
+        if (out.length >= 500)
+            break;
+        if (e.name === 'node_modules' || e.name === '.git')
+            continue;
+        const rel = prefix ? `${prefix}/${e.name}` : e.name;
+        if (e.isDirectory())
+            await listFiles(join(dir, e.name), rel, out);
+        else
+            out.push(rel);
+    }
+    return out;
+}
+/** skills CLI lock files: `skills-lock.json` in a project, `~/.agents/.skill-lock.json` for the user. */
+function readLock(file) {
+    const byFolder = new Map();
+    try {
+        const skills = JSON.parse(readFileSync(file, 'utf8')).skills ?? {};
+        for (const [folder, e] of Object.entries(skills)) {
+            if (typeof e.source !== 'string' || typeof e.skillPath !== 'string' || !/^[^/\s]+\/[^/\s]+$/.test(e.source))
+                continue;
+            if (e.sourceType !== undefined && e.sourceType !== 'github')
+                continue; // gitlab etc. are not gh: rows
+            const dir = posix.dirname(e.skillPath.replace(/\\/g, '/'));
+            // index ids keep the repo part in lower case (indexer.ts), so an exact lookup finds "ECC" as "ecc"
+            byFolder.set(folder.toLowerCase(), `gh:${e.source.toLowerCase()}:${dir === '.' ? '' : dir}`);
+        }
+    }
+    catch {
+        // no lock file, or not one we can read
+    }
+    return byFolder;
+}
+/** The folder the skills CLI installs a skill into (its `sanitizeName`, the same in skills@1.7.4 and 1.7.6). */
+export function skillFolderName(name) {
+    return name.toLowerCase().replace(/[^a-z0-9._]+/g, '-').replace(/^[.\-]+|[.\-]+$/g, '').slice(0, 255) || 'unnamed-skill';
+}
+/**
+ * Installed skill folders of one scope, each matched to the index by, in order: the skills CLI lock file
+ * (source + path), the app's own install log (same name), or an identical SKILL.md (hash). `onlyFolder` limits
+ * the scan to that folder.
+ */
+export async function scanInstalledSkills(store, scope, projectPath, onlyFolder) {
+    const root = scope === 'user' ? homedir() : projectPath;
+    const dir = join(root, '.claude', 'skills');
+    const lock = readLock(scope === 'user' ? join(homedir(), '.agents', '.skill-lock.json') : join(root, 'skills-lock.json'));
+    const logged = new Map();
+    for (const l of store.listInstalledSkillLog()) {
+        if (l.scope !== scope || (scope === 'project' && l.project_path?.toLowerCase() !== root.toLowerCase()))
+            continue;
+        const name = store.getSkill(l.skill_id)?.name.toLowerCase();
+        if (name && !logged.has(name))
+            logged.set(name, { id: l.skill_id, risk: l.risk_level });
+    }
+    let entries = [];
+    try {
+        entries = (await readdir(dir, { withFileTypes: true })).filter((e) => e.isDirectory() || e.isSymbolicLink()).map((e) => e.name);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const folder of entries.sort()) {
+        if (onlyFolder && folder.toLowerCase() !== onlyFolder.toLowerCase())
+            continue;
+        const path = join(dir, folder);
+        let raw;
+        try {
+            raw = await readFile(join(path, 'SKILL.md'), 'utf8');
+        }
+        catch {
+            continue; // not a skill folder
+        }
+        const meta = extractSkillMeta(raw, folder);
+        const hash = mdHash(raw);
+        const log = logged.get(meta.name.toLowerCase()) ?? logged.get(folder.toLowerCase());
+        const fromLock = lock.get(folder.toLowerCase());
+        const skillId = (fromLock && store.getSkill(fromLock)?.id) || (log && store.getSkill(log.id) ? log.id : null) || store.findSkillIdByMdSha(hash);
+        const indexed = skillId ? store.getSkill(skillId) : undefined;
+        const flags = skillRiskFlags({ files: await listFiles(path), allowedTools: meta.allowedTools, body: meta.body, hasHooks: meta.hasHooks, raw });
+        out.push({
+            scope,
+            path,
+            folder,
+            name: meta.name,
+            description: truncate(meta.description, 200),
+            removeCommand: `npx skills@${SKILLS_CLI_VERSION} remove ${/\s/.test(folder) ? `"${folder}"` : folder} -a claude-code -y${scope === 'user' ? ' -g' : ''}`,
+            skillId,
+            risk: { level: riskLevel(flags), flags },
+            installedRisk: (log?.id === skillId ? log?.risk : null) ?? null,
+            change: !indexed?.skill_md_sha256 ? 'unknown' : indexed.skill_md_sha256 === hash ? 'same' : 'changed',
+            tokens: skillTokens(meta.name, meta.description, raw),
+        });
+    }
+    return out;
+}
+export async function existingSkillFolder(store, skillId, skillName, scope, projectPath) {
+    const folder = skillFolderName(skillName);
+    const path = join(scope === 'user' ? homedir() : projectPath, '.claude', 'skills', folder);
+    if (!existsSync(path))
+        return null;
+    const [hit] = await scanInstalledSkills(store, scope, projectPath, folder);
+    if (!hit)
+        return { path, name: folder, same: null, change: 'unknown' };
+    const same = hit.skillId == null ? null : hit.skillId === skillId;
+    return { path: hit.path, name: hit.name, same, change: same ? hit.change : 'unknown' };
+}
+/** `claude plugin list --json`, kept for a minute per folder; installs and uninstalls drop it (forgetPlugins). */
+const pluginCache = new Map();
+const PLUGIN_CACHE_MS = 60_000;
+export function forgetPlugins() {
+    pluginCache.clear();
+}
+/** `fresh`: ask Claude Code now (the installed page, where a change made in a terminal must show at once). */
+export function listInstalledPlugins(cwd = homedir(), fresh = false) {
+    const hit = pluginCache.get(cwd);
+    if (!fresh && hit && Date.now() - hit.at < PLUGIN_CACHE_MS)
+        return hit.value;
+    const value = runClaude(['plugin', 'list', '--json'], { cwd, timeoutMs: 60_000 })
+        .then((list) => ({
+        plugins: (parseJsonArray(list.stdout) ?? []).map((p) => {
+            const o = p;
+            return {
+                id: String(o.id ?? ''),
+                version: o.version ?? null,
+                scope: typeof o.scope === 'string' ? o.scope : 'user',
+                projectPath: typeof o.projectPath === 'string' ? o.projectPath : null,
+                installPath: o.installPath ?? null,
+                enabled: o.enabled ?? null,
+            };
+        }),
+        error: list.exitCode !== 0 ? 'claude plugin list 실패' : null,
+    }))
+        .catch((err) => ({ plugins: [], error: String(err.message ?? err) }));
+    pluginCache.set(cwd, { at: Date.now(), value });
+    // a failure is not kept: the next call asks again
+    void value.then((v) => v.error && pluginCache.delete(cwd));
+    return value;
+}
+/** The commit Claude Code installed each plugin from (`~/.claude/plugins/installed_plugins.json`), by id and scope. */
+export function installedPluginCommits() {
+    const out = new Map();
+    try {
+        const file = join(homedir(), '.claude', 'plugins', 'installed_plugins.json');
+        const plugins = JSON.parse(readFileSync(file, 'utf8')).plugins ?? {};
+        for (const [id, installs] of Object.entries(plugins)) {
+            for (const i of Array.isArray(installs) ? installs : []) {
+                if (typeof i.gitCommitSha === 'string')
+                    out.set(pluginCommitKey(id, String(i.scope), typeof i.projectPath === 'string' ? i.projectPath : null), i.gitCommitSha);
+            }
+        }
+    }
+    catch {
+        // Claude Code keeps this file; without it the commit is unknown
+    }
+    return out;
+}
+/** Windows paths compared as Claude Code writes them: backslashes, no trailing one, any case. */
+const pathKey = (p) => p.replace(/\//g, '\\').replace(/\\+$/, '').toLowerCase();
+export const pluginCommitKey = (id, scope, projectPath) => `${id}|${scope}|${scope === 'user' ? '' : pathKey(projectPath ?? '')}`;
+/** How a plugin install compares with the index: its skills' top risk and whether it came from the indexed commit. */
+/** The indexed skills a plugin install brought in (its own, or those whose install plan names it), for the 설치됨 screen. */
+export function pluginSkills(store, id) {
+    const at = id.lastIndexOf('@');
+    const rows = store.getPlugin(id) ? store.listSkillsByPlugin(id) : at > 0 ? store.listSkillsByInstallPlugin(id.slice(at + 1), id.slice(0, at)) : [];
+    return rows.map((s) => ({ id: s.id, name: s.name, riskLevel: (s.risk_level ?? 'low') }));
+}
+export function pluginIndexInfo(store, id, commit) {
+    const rank = { low: 0, medium: 1, high: 2 };
+    const top = (skills) => skills.reduce((t, s) => (rank[s.risk_level] > rank[t] ? s.risk_level : t), 'low');
+    const plugin = store.getPlugin(id);
+    if (!plugin) {
+        // installed from a repo's own marketplace: known through the skills whose install plan points at it
+        const at = id.lastIndexOf('@');
+        const skills = at > 0 ? store.listSkillsByInstallPlugin(id.slice(at + 1), id.slice(0, at)) : [];
+        return skills.length ? { indexed: true, topRisk: top(skills), change: 'unknown' } : { indexed: false, topRisk: null, change: 'unknown' };
+    }
+    const topRisk = top(store.listSkillsByPlugin(id));
+    const indexedAt = plugin.skills_indexed_sha;
+    return { indexed: true, topRisk, change: !commit || !indexedAt ? 'unknown' : commit === indexedAt ? 'same' : 'changed' };
+}

package/server/src/install/plan.js

@@ -0,0 +1,118 @@
+import { homedir } from 'node:os';
+import { join, sep } from 'node:path';
+import { SKILLS_CLI_PATH, SKILLS_CLI_VERSION } from "../config.js";
+import { formatCommand } from "../claude/cli.js";
+import { skillFolderName } from "./installed.js";
+import { isCommitSha, isPluginName, isRepo, isRepoDir, isSkillName } from "./validate.js";
+const NPX_SKILLS = `npx skills@${SKILLS_CLI_VERSION}`;
+/**
+ * `-y` only for the app's own run, after its confirm dialog (D-5). The command shown for running by hand (copied,
+ * shared, exported) leaves it out, so the CLI asks there as it normally would (review 2026-11-02).
+ */
+function skillsCliArgs(source, name, scope, yes = true) {
+    return ['add', source, '--skill', name, '-a', 'claude-code', '--copy', ...(yes ? ['-y'] : []), ...(scope === 'user' ? ['-g'] : [])];
+}
+/**
+ * The skills CLI takes `…/tree/<sha>/<folder>` and clones exactly that commit, so the files installed are the ones
+ * the risk check read (UI debate 1-3). The plain repo (its latest commit) when the stored commit or folder fails
+ * the checks.
+ */
+function skillsSource(repo, ref, dir) {
+    if (!isCommitSha(ref) || dir == null || (dir !== '' && !isRepoDir(dir)))
+        return { source: repo };
+    return { source: `https://github.com/${repo}/tree/${ref}${dir ? `/${dir}` : ''}`, pinnedRef: ref };
+}
+function pluginPlan(pluginName, mp, pluginId) {
+    return {
+        method: 'plugin',
+        scopes: ['user', 'project', 'local'],
+        command: formatCommand('claude', ['plugin', 'install', `${pluginName}@${mp.name}`, '--scope', 'user']),
+        pluginId: pluginId ?? `${pluginName}@${mp.name}`,
+        pluginName,
+        marketplace: mp,
+    };
+}
+const manual = (command, reason, disabled = false) => ({
+    method: 'manual-only',
+    scopes: [],
+    command,
+    reason,
+    disabled,
+});
+export function planInstall(skill, plugin, marketplace) {
+    const flags = skill.risk_json ? JSON.parse(skill.risk_json) : [];
+    if (skill.origin === 'wellknown') {
+        const domain = JSON.parse(skill.install_json ?? '{}').domain ?? '';
+        return manual(formatCommand('npx', [`skills@${SKILLS_CLI_VERSION}`, 'add', `https://${domain}`, '--skill', skill.name]), 'well-known 출처는 미리보기 없이 설치 명령만 제공합니다');
+    }
+    if (skill.origin === 'plugin' && plugin) {
+        const cmd = formatCommand('claude', ['plugin', 'install', `${plugin.name}@${plugin.marketplace}`]);
+        if (plugin.source_kind === 'command')
+            return manual(cmd, '설치할 때 마켓플레이스가 지정한 명령을 실행하는 command 출처라 앱에서 설치하지 않습니다. 터미널에서 직접 확인 후 설치하세요.', true);
+        if (['npm', 'archive', 'unknown'].includes(plugin.source_kind) || !plugin.repo)
+            return manual(cmd, `${plugin.source_kind} 출처 또는 GitHub 외 호스트라 앱에서 설치하지 않습니다`);
+        if (!marketplace || !isPluginName(plugin.name) || !isPluginName(marketplace.name) || !isRepo(marketplace.repo)) {
+            return manual(cmd, '이름 형식이 검증 규칙에 맞지 않아 앱에서 설치하지 않습니다');
+        }
+        return pluginPlan(plugin.name, { name: marketplace.name, repo: marketplace.repo }, plugin.id);
+    }
+    const info = (skill.install_json ? JSON.parse(skill.install_json) : null);
+    const repo = skill.repo ?? '';
+    if (flags.includes('pluginRootDependency')) {
+        if (info?.marketplaceName && info.pluginName && isPluginName(info.pluginName) && isPluginName(info.marketplaceName) && isRepo(repo)) {
+            return pluginPlan(info.pluginName, { name: info.marketplaceName, repo });
+        }
+        return manual(formatCommand('claude', ['plugin', 'marketplace', 'add', repo]), '${CLAUDE_PLUGIN_ROOT}에 의존해 플러그인으로만 동작하지만, 이 저장소에 설치할 마켓플레이스가 없습니다');
+    }
+    if (!isRepo(repo) || !isSkillName(skill.name)) {
+        return manual(formatCommand('npx', [`skills@${SKILLS_CLI_VERSION}`, 'add', repo]), '저장소나 스킬 이름이 검증 규칙에 맞지 않아 앱에서 설치하지 않습니다');
+    }
+    const { source, pinnedRef } = skillsSource(repo, skill.ref, skill.dir_path);
+    return {
+        method: 'skills-cli',
+        scopes: ['user', 'project'],
+        command: formatCommand('npx', [`skills@${SKILLS_CLI_VERSION}`, ...skillsCliArgs(source, skill.name, 'user', false)]),
+        repo,
+        source,
+        ...(pinnedRef ? { pinnedRef } : {}),
+        skillName: skill.name,
+    };
+}
+export function buildSteps(plan, scope, projectPath) {
+    const cwd = scope === 'user' ? homedir() : projectPath;
+    if (plan.method === 'plugin') {
+        const mp = plan.marketplace;
+        const installArgs = ['plugin', 'install', `${plan.pluginName}@${mp.name}`, '--scope', scope, '--json'];
+        const addArgs = ['plugin', 'marketplace', 'add', mp.repo, '--json'];
+        return [
+            { kind: 'ensure-marketplace', file: 'claude', args: addArgs, cwd: homedir(), display: formatCommand('claude', addArgs), note: '마켓플레이스 미등록 시에만' },
+            { kind: 'plugin-install', file: 'claude', args: installArgs, cwd, display: formatCommand('claude', installArgs) },
+        ];
+    }
+    if (plan.method === 'skills-cli') {
+        const source = plan.source ?? plan.repo;
+        const args = [SKILLS_CLI_PATH, ...skillsCliArgs(source, plan.skillName, scope)];
+        // The app runs its own copy of the CLI, whose path depends on how the app was installed (under npx it was
+        // "../skills/bin/cli.mjs"). Shown as the same version through npx and without -y, since it can be copied into
+        // any terminal and there the CLI should ask before replacing a folder (D#410d); the note says what the app adds.
+        const shown = [`skills@${SKILLS_CLI_VERSION}`, ...skillsCliArgs(source, plan.skillName, scope, false)];
+        return [{ kind: 'skills-add', file: 'node', args, cwd, display: formatCommand('npx', shown), note: '앱은 내장된 같은 버전에 -y를 붙여 실행' }];
+    }
+    return [];
+}
+export function installLocation(plan, scope, projectPath) {
+    if (plan.method === 'skills-cli') {
+        // the folder the CLI writes (its own name rule), in the system's path style (review 2026-11-02: "\" and "/" mixed)
+        const folder = skillFolderName(plan.skillName);
+        return scope === 'user' ? `~/.claude/skills/${folder}/` : `${join(projectPath, '.claude', 'skills', folder)}${sep} (+ skills-lock.json)`;
+    }
+    if (plan.method === 'plugin') {
+        if (scope === 'user')
+            return '~/.claude/settings.json (enabledPlugins), 플러그인 캐시';
+        if (scope === 'project')
+            return `${join(projectPath, '.claude', 'settings.json')} (enabledPlugins)`;
+        return `${join(projectPath, '.claude', 'settings.local.json')} (enabledPlugins)`;
+    }
+    return '';
+}
+export { NPX_SKILLS };

package/server/src/install/run.js

@@ -0,0 +1,97 @@
+import { runClaude } from "../claude/cli.js";
+import { run } from "../util/proc.js";
+/** Last stdout line that parses as a JSON object (`claude ... --json` prints its result there). */
+export function lastJsonLine(stdout) {
+    const lines = stdout.trim().split('\n').reverse();
+    for (const line of lines) {
+        const t = line.trim();
+        if (!t.startsWith('{'))
+            continue;
+        try {
+            const v = JSON.parse(t);
+            if (v && typeof v === 'object' && !Array.isArray(v))
+                return v;
+        }
+        catch {
+            // keep looking
+        }
+    }
+    return null;
+}
+export function parseJsonArray(stdout) {
+    const start = stdout.indexOf('[');
+    if (start < 0)
+        return null;
+    try {
+        const v = JSON.parse(stdout.slice(start));
+        return Array.isArray(v) ? v : null;
+    }
+    catch {
+        return null;
+    }
+}
+const FAILURE_OUTCOMES = /fail|error|refus|denied|reject|not.?found|cancel/i;
+export async function executeInstall(plan, steps, log, env) {
+    const argv = [];
+    let output = '';
+    const onLine = (line, stream) => {
+        output += line + '\n';
+        log(line, stream);
+    };
+    const exec = async (step) => {
+        argv.push([step.file, ...step.args]);
+        log(`$ ${step.display}`, 'info');
+        if (step.file === 'claude')
+            return runClaude(step.args, { cwd: step.cwd, env, timeoutMs: 5 * 60_000, onLine });
+        return run(process.execPath, step.args, { cwd: step.cwd, env, timeoutMs: 5 * 60_000, onLine });
+    };
+    for (const step of steps) {
+        if (step.kind === 'ensure-marketplace') {
+            const list = await runClaude(['plugin', 'marketplace', 'list', '--json'], { env, timeoutMs: 60_000 });
+            const entries = (parseJsonArray(list.stdout) ?? []);
+            const { name, repo } = plan.marketplace;
+            const same = entries.find((e) => e.name === name);
+            if (same) {
+                // The name alone is not enough: another repo registered under it would serve "plugin@name" from a source
+                // this app never checked (project review 2026-11-02). Stop instead of installing from it.
+                if (typeof same.repo !== 'string' || same.repo.toLowerCase() !== repo.toLowerCase()) {
+                    const message = `마켓플레이스 이름 ${name}이(가) 이미 다른 저장소(${same.repo ?? '알 수 없음'})로 등록되어 있어 설치하지 않았습니다. 검사한 저장소는 ${repo}입니다. Claude Code에서 그 마켓플레이스를 확인하세요.`;
+                    log(message, 'stderr');
+                    return { ok: false, exitCode: -1, message, argv, output };
+                }
+                log(`마켓플레이스 ${name}은(는) 이미 등록되어 있습니다`, 'info');
+                continue;
+            }
+            const r = await exec(step);
+            const res = lastJsonLine(r.stdout);
+            if (r.exitCode !== 0) {
+                return { ok: false, exitCode: r.exitCode, message: String(res?.message ?? '마켓플레이스 등록에 실패했습니다'), argv, output };
+            }
+            continue;
+        }
+        const r = await exec(step);
+        if (r.timedOut)
+            return { ok: false, exitCode: r.exitCode, message: '시간 초과로 중단했습니다', argv, output };
+        if (step.kind === 'plugin-install') {
+            const res = lastJsonLine(r.stdout);
+            const outcome = String(res?.outcome ?? '');
+            const message = String(res?.message ?? (r.exitCode === 0 ? '설치했습니다' : '설치에 실패했습니다'));
+            const ok = r.exitCode === 0 && !FAILURE_OUTCOMES.test(outcome);
+            return {
+                ok,
+                exitCode: r.exitCode,
+                message: ok ? `${message} — 다음 세션부터 또는 /reload-plugins 실행 후 반영됩니다` : message,
+                argv,
+                output,
+            };
+        }
+        return {
+            ok: r.exitCode === 0,
+            exitCode: r.exitCode,
+            message: r.exitCode === 0 ? '설치했습니다 — 새 Claude Code 세션에서 사용할 수 있습니다' : 'skills CLI가 오류로 끝났습니다',
+            argv,
+            output,
+        };
+    }
+    return { ok: false, exitCode: -1, message: '실행할 단계가 없습니다', argv, output };
+}

package/server/src/install/scan.js

@@ -0,0 +1,70 @@
+// What an install brings besides SKILL.md (project review 2026-11-02 F1). The risk rules run on SKILL.md when a
+// skill is indexed; the other text files of the folder (scripts, references) are installed unchecked. Before an
+// install the app reads them at the pinned commit and runs the same text rules on each. Remote files are only read.
+import { hasCurlPipeShell, hasRmRf } from "../analyze/risk.js";
+import { looksBinary } from "../util/http.js";
+import { pool } from "../util/limiter.js";
+import { SizedCache } from "../util/sizedCache.js";
+import { isTextPath, MAX_FILE_BYTES } from "../util/textFiles.js";
+/** Text files read per skill: scripts first, then the rest in path order. */
+export const SCAN_MAX_FILES = 50;
+const SCRIPT_EXT = /\.(sh|bash|zsh|fish|py|js|mjs|cjs|ts|rb|pl|ps1|psm1|bat|cmd)$/i;
+/** The text rules that apply outside SKILL.md: download-and-run and rm -rf (the rest read frontmatter). */
+export function textFileFlags(text) {
+    const flags = [];
+    if (hasCurlPipeShell(text))
+        flags.push('curlPipeShell');
+    if (hasRmRf(text))
+        flags.push('rmRf');
+    return flags;
+}
+const cache = new SizedCache({ maxSize: 500, ttlMs: 30 * 60 * 1000, sizeOf: () => 1 });
+/** One skill folder at its indexed commit; kept 30 minutes unless a file could not be downloaded. */
+export async function scanSkillFiles(github, skill) {
+    const key = `${skill.repo}@${skill.ref}:${skill.dir_path}`;
+    const hit = cache.get(key);
+    if (hit)
+        return hit;
+    const scan = await runScan(github, skill);
+    if (!scan.skipped.some((s) => s.reason === 'failed'))
+        cache.set(key, Promise.resolve(scan));
+    return scan;
+}
+async function runScan(github, skill) {
+    const repo = skill.repo;
+    const ref = skill.ref;
+    const stored = (skill.files_json ? JSON.parse(skill.files_json) : { files: [], total: 0 });
+    const files = stored.files.filter((f) => f.path !== 'SKILL.md');
+    const skipped = [];
+    const text = [];
+    for (const f of files) {
+        if (!isTextPath(f.path))
+            skipped.push({ path: f.path, reason: 'binary' });
+        else if (f.size != null && f.size > MAX_FILE_BYTES)
+            skipped.push({ path: f.path, reason: 'large' });
+        else
+            text.push(f);
+    }
+    text.sort((a, b) => Number(SCRIPT_EXT.test(b.path)) - Number(SCRIPT_EXT.test(a.path)) || a.path.localeCompare(b.path));
+    for (const f of text.slice(SCAN_MAX_FILES))
+        skipped.push({ path: f.path, reason: 'limit' });
+    const findings = [];
+    let checked = 0;
+    await pool(text.slice(0, SCAN_MAX_FILES), 6, async (f) => {
+        const full = skill.dir_path ? `${skill.dir_path}/${f.path}` : f.path;
+        const out = await github.getRawText(repo, ref, full, MAX_FILE_BYTES).catch(() => null);
+        if (!out || out.text == null)
+            return skipped.push({ path: f.path, reason: 'failed' });
+        if (out.truncated)
+            return skipped.push({ path: f.path, reason: 'large' });
+        if (looksBinary(out.text))
+            return skipped.push({ path: f.path, reason: 'binary' });
+        checked++;
+        const flags = textFileFlags(out.text);
+        if (flags.length)
+            findings.push({ path: f.path, flags });
+    });
+    findings.sort((a, b) => a.path.localeCompare(b.path));
+    skipped.sort((a, b) => a.path.localeCompare(b.path));
+    return { commit: ref, checked, findings, skipped, unlisted: Math.max(0, stored.total - stored.files.length) };
+}

package/server/src/install/summary.js

@@ -0,0 +1,14 @@
+import { planInstall } from "./plan.js";
+export function installSummary(s, lookup, name = s.name) {
+    const plugin = lookup.plugin(s.plugin_id);
+    const plan = planInstall(s, plugin, lookup.marketplace(plugin?.marketplace));
+    return {
+        id: s.id,
+        name,
+        riskLevel: s.risk_level ?? 'low',
+        riskFlags: s.risk_json ? JSON.parse(s.risk_json) : [],
+        method: plan.method,
+        installable: plan.method !== 'manual-only' && !plan.disabled,
+        scopes: plan.scopes,
+    };
+}

package/server/src/install/uninstall.js

@@ -0,0 +1,59 @@
+import { existsSync, lstatSync } from 'node:fs';
+import { rm } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { runClaude } from "../claude/cli.js";
+import { SKILLS_CLI_PATH } from "../config.js";
+import { run } from "../util/proc.js";
+import { lastJsonLine } from "./run.js";
+export const PLUGIN_ID_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}@[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+export const SKILL_FOLDER_RE = /^[A-Za-z0-9][A-Za-z0-9 ._-]{0,127}$/;
+export function skillsRoot(scope, projectPath) {
+    return scope === 'user' ? join(homedir(), '.claude', 'skills') : join(projectPath, '.claude', 'skills');
+}
+/** `claude plugin uninstall <id> --scope <scope>`; project/local scopes run in the project folder. */
+export async function uninstallPlugin(id, scope, projectPath) {
+    if (!PLUGIN_ID_RE.test(id))
+        return { ok: false, message: '플러그인 ID 형식이 올바르지 않습니다', output: '' };
+    const r = await runClaude(['plugin', 'uninstall', id, '--scope', scope, '--json'], {
+        cwd: scope === 'user' ? homedir() : projectPath,
+        timeoutMs: 2 * 60_000,
+    });
+    const res = lastJsonLine(r.stdout);
+    const ok = r.exitCode === 0;
+    const message = String(res?.message ?? (ok ? '플러그인을 제거했습니다' : '플러그인 제거에 실패했습니다'));
+    return { ok, message, output: (r.stdout + r.stderr).slice(-4000) };
+}
+/**
+ * Removes one skill folder directly under ~/.claude/skills or <project>/.claude/skills.
+ * The skills CLI goes first (it also updates skills-lock.json); if the folder is still there
+ * (e.g. it was copied in by hand) it is deleted after checking it is exactly one level below the skills root.
+ */
+export async function uninstallSkill(folder, scope, projectPath, env) {
+    if (!SKILL_FOLDER_RE.test(folder) || folder.includes('..'))
+        return { ok: false, message: '스킬 폴더 이름이 올바르지 않습니다', output: '' };
+    const root = resolve(skillsRoot(scope, projectPath));
+    const target = resolve(root, folder);
+    if (dirname(target) !== root)
+        return { ok: false, message: '스킬 폴더 위치가 올바르지 않습니다', output: '' };
+    if (!existsSync(target))
+        return { ok: false, message: '이미 없는 스킬입니다', output: '' };
+    if (!existsSync(join(target, 'SKILL.md')))
+        return { ok: false, message: 'SKILL.md가 없는 폴더라 지우지 않았습니다', output: '' };
+    const cli = await run(process.execPath, [SKILLS_CLI_PATH, 'remove', folder, '-a', 'claude-code', '-y', ...(scope === 'user' ? ['-g'] : [])], {
+        cwd: scope === 'user' ? homedir() : projectPath,
+        env,
+        timeoutMs: 2 * 60_000,
+    }).catch((err) => ({ exitCode: -1, stdout: '', stderr: String(err), timedOut: false }));
+    let output = (cli.stdout + cli.stderr).slice(-4000);
+    if (existsSync(target)) {
+        // A symlinked skill: remove the link, never what it points to.
+        if (lstatSync(target).isSymbolicLink())
+            await rm(target, { force: true });
+        else
+            await rm(target, { recursive: true, force: true });
+        output += '\n(skills CLI가 지우지 않은 폴더를 직접 삭제했습니다)';
+    }
+    const gone = !existsSync(target);
+    return { ok: gone, message: gone ? '스킬을 삭제했습니다' : '스킬 폴더를 지우지 못했습니다', output };
+}

package/server/src/install/validate.js

@@ -0,0 +1,24 @@
+import { statSync } from 'node:fs';
+import { isAbsolute } from 'node:path';
+export const OWNER_REPO_RE = /^[A-Za-z0-9-]{1,39}\/[A-Za-z0-9._-]{1,100}$/;
+export const PLUGIN_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+export const SKILL_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9 ._-]{0,63}$/;
+export const COMMIT_SHA_RE = /^[0-9a-f]{40}$/;
+/** A folder inside a repo: plain name segments, never `.` or `..`, no leading or trailing slash. */
+export const REPO_DIR_RE = /^[A-Za-z0-9._-]+(?:\/[A-Za-z0-9._-]+)*$/;
+export const isRepo = (s) => typeof s === 'string' && OWNER_REPO_RE.test(s) && !s.includes('..');
+export const isPluginName = (s) => typeof s === 'string' && PLUGIN_NAME_RE.test(s);
+export const isSkillName = (s) => typeof s === 'string' && SKILL_NAME_RE.test(s) && !/\s$/.test(s);
+export const isCommitSha = (s) => typeof s === 'string' && COMMIT_SHA_RE.test(s);
+export const isRepoDir = (s) => typeof s === 'string' && REPO_DIR_RE.test(s) && !s.split('/').some((seg) => seg === '.' || seg === '..');
+/** Absolute path to an existing directory. */
+export function isProjectDir(p) {
+    if (typeof p !== 'string' || !p || !isAbsolute(p) || /[\0\r\n]/.test(p))
+        return false;
+    try {
+        return statSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}