claudeup 4.33.0 → 4.34.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudeup",
-  "version": "4.33.0",
+  "version": "4.34.0",
   "description": "TUI tool for managing Claude Code plugins, MCPs, and configuration",
   "type": "module",
   "main": "src/main.tsx",
@@ -64,8 +64,8 @@
     "typescript": "^5.6.3"
   },
   "optionalDependencies": {
-    "claudeup-darwin-arm64": "4.33.0",
-    "claudeup-darwin-x64": "4.33.0",
-    "claudeup-linux-x64": "4.33.0"
+    "claudeup-darwin-arm64": "4.34.0",
+    "claudeup-darwin-x64": "4.34.0",
+    "claudeup-linux-x64": "4.34.0"
   }
 }

package/src/__tests__/content-drift.test.ts

@@ -20,8 +20,17 @@ let configDir: string;
 let prevConfigDir: string | undefined;
 let repo: string;
 
+// commit.gpgsign=false isolates the developer's git config. With signing on
+// (1Password's SSH signer, for instance) every commit here calls that signer,
+// and because this helper ignores the exit status a failure is silent: no
+// commit is created, so drift is never detected and the assertions fail with a
+// bare `false` that points nowhere near the real cause. CI has no signing
+// config, so this only ever broke locally.
 const git = (args: string[]) =>
-	spawnSync("git", args, { cwd: repo, encoding: "utf-8" });
+	spawnSync("git", ["-c", "commit.gpgsign=false", ...args], {
+		cwd: repo,
+		encoding: "utf-8",
+	});
 
 const head = () => git(["rev-parse", "HEAD"]).stdout.trim();
 

package/src/__tests__/gitignore-detector.test.ts

@@ -9,7 +9,19 @@ import type { ResolvedManifest } from "../types/gitignore";
 function git(cwd: string, ...args: string[]): string {
   // core.excludesFile=/dev/null bypasses the developer's global gitignore
   // so the test environment doesn't leak into the result.
-  const r = spawnSync("git", ["-c", "core.excludesFile=/dev/null", ...args], {
+  //
+  // commit.gpgsign=false is the same isolation, one step further: a developer
+  // with signed commits makes every `git commit` here call their signer. With
+  // 1Password's SSH agent that means a prompt or an agent error, so these tests
+  // failed or timed out locally for reasons that have nothing to do with the
+  // code under test. CI has no signing config, so it only ever broke locally.
+  const r = spawnSync("git", [
+    "-c",
+    "core.excludesFile=/dev/null",
+    "-c",
+    "commit.gpgsign=false",
+    ...args,
+  ], {
     cwd,
     encoding: "utf8",
   });

package/src/__tests__/skill-install-files.test.ts

@@ -0,0 +1,128 @@
+import { describe, expect, test } from "bun:test";
+import path from "node:path";
+import {
+  resolveSkillFilePath,
+  selectSkillFiles,
+} from "../services/skills-manager.js";
+
+/**
+ * Installing a skill used to write exactly one file, SKILL.md, and drop
+ * everything beside it. Measured against the real repos: audit-website lost
+ * `references/OUTPUT-FORMAT.md` while its SKILL.md still linked to it,
+ * systematic-debugging lost `find-polluter.sh` and 9 more, and
+ * remotion-best-practices lost 136 files. The installed skill looked fine and
+ * had dangling links.
+ *
+ * These cover the two pieces of that fix that are pure: choosing which files
+ * belong to a skill, and refusing to write outside its directory.
+ */
+
+const blob = (p: string) => ({ path: p, type: "blob" });
+const tree = (p: string) => ({ path: p, type: "tree" });
+
+describe("selectSkillFiles", () => {
+  test("returns paths relative to the skill directory", () => {
+    expect(
+      selectSkillFiles(
+        [
+          blob("skills/audit-website/SKILL.md"),
+          blob("skills/audit-website/references/OUTPUT-FORMAT.md"),
+          blob("skills/audit-website/assets/icon-small.svg"),
+        ],
+        "skills/audit-website",
+      ),
+    ).toEqual(["SKILL.md", "references/OUTPUT-FORMAT.md", "assets/icon-small.svg"]);
+  });
+
+  test("REGRESSION: a sibling with a shared name prefix is excluded", () => {
+    // Without the trailing slash on the prefix, "skills/audit" also matches
+    // "skills/audit-website/..." and dumps a second skill's files into the
+    // first one's directory.
+    expect(
+      selectSkillFiles(
+        [
+          blob("skills/audit/SKILL.md"),
+          blob("skills/audit-website/SKILL.md"),
+          blob("skills/audit-website/references/OUTPUT-FORMAT.md"),
+        ],
+        "skills/audit",
+      ),
+    ).toEqual(["SKILL.md"]);
+  });
+
+  test("tree entries are skipped — only blobs are downloadable", () => {
+    expect(
+      selectSkillFiles(
+        [
+          tree("skills/x/references"),
+          blob("skills/x/SKILL.md"),
+          blob("skills/x/references/a.md"),
+        ],
+        "skills/x",
+      ),
+    ).toEqual(["SKILL.md", "references/a.md"]);
+  });
+
+  test("files outside the skill directory are excluded", () => {
+    expect(
+      selectSkillFiles(
+        [blob("README.md"), blob("other/SKILL.md"), blob("skills/x/SKILL.md")],
+        "skills/x",
+      ),
+    ).toEqual(["SKILL.md"]);
+  });
+
+  test("a trailing slash on the skill path does not break matching", () => {
+    expect(
+      selectSkillFiles([blob("skills/x/SKILL.md")], "skills/x/"),
+    ).toEqual(["SKILL.md"]);
+  });
+
+  test("a skill directory with no files yields nothing", () => {
+    expect(selectSkillFiles([blob("skills/other/SKILL.md")], "skills/x")).toEqual([]);
+  });
+});
+
+describe("resolveSkillFilePath", () => {
+  const dir = path.join(path.sep, "tmp", "skills", "demo");
+
+  test("resolves a plain relative path inside the install directory", () => {
+    expect(resolveSkillFilePath(dir, "SKILL.md")).toBe(
+      path.join(dir, "SKILL.md"),
+    );
+  });
+
+  test("resolves a nested path", () => {
+    expect(resolveSkillFilePath(dir, "references/OUTPUT-FORMAT.md")).toBe(
+      path.join(dir, "references", "OUTPUT-FORMAT.md"),
+    );
+  });
+
+  test("SECURITY: rejects paths escaping via ..", () => {
+    // These paths come from a remote repository and are untrusted input to a
+    // filesystem write.
+    expect(resolveSkillFilePath(dir, "../evil.md")).toBeNull();
+    expect(resolveSkillFilePath(dir, "../../.bashrc")).toBeNull();
+    expect(resolveSkillFilePath(dir, "refs/../../../evil.md")).toBeNull();
+  });
+
+  test("SECURITY: rejects absolute paths", () => {
+    expect(resolveSkillFilePath(dir, path.join(path.sep, "etc", "passwd"))).toBeNull();
+  });
+
+  test("rejects an empty path", () => {
+    expect(resolveSkillFilePath(dir, "")).toBeNull();
+  });
+
+  test("a .. that stays inside the directory is allowed", () => {
+    expect(resolveSkillFilePath(dir, "refs/../SKILL.md")).toBe(
+      path.join(dir, "SKILL.md"),
+    );
+  });
+
+  test("REGRESSION: a sibling directory sharing the name prefix is rejected", () => {
+    // path.startsWith without a separator would accept /tmp/skills/demo-evil
+    // as being inside /tmp/skills/demo.
+    expect(resolveSkillFilePath(dir, "../demo-evil/x.md")).toBeNull();
+  });
+});

package/src/data/skill-repos.ts

@@ -32,11 +32,17 @@ const MEGA_REPOS = new Set([
 ]);
 
 /** Skill-dump repos: large collections where stars reflect quantity, not quality. */
+// Renamed repos are listed under BOTH names on purpose. The curated catalog
+// serves the current name while older cached copies and this file's fallback
+// list still carry the old one; dropping either silently reclassifies the repo
+// as "dedicated" and its stars start reading as a quality signal again.
 const SKILL_DUMP_REPOS = new Set([
   "affaan-m/everything-claude-code",
   "openclaw/openclaw",
   "jh941213/my-claude-code-asset",
+  "jh941213/my-cc-harness", // renamed from my-claude-code-asset
   "inferen-sh/skills",
+  "inference-sh/skills", // renamed from inferen-sh
 ]);
 
 /**

package/src/services/skills-manager.ts

@@ -344,11 +344,69 @@ export async function fetchAvailableSkills(
 
 // ─── Install / Uninstall ──────────────────────────────────────────────────────
 
+/** Hard ceilings so one pathological repo cannot fill a user's disk. */
+const MAX_SKILL_FILES = 200;
+const MAX_SKILL_BYTES = 20 * 1024 * 1024;
+
+/**
+ * Pick the files that belong to one skill out of a whole-repo tree listing.
+ *
+ * Returns paths relative to the skill directory, so `skills/x/refs/a.md`
+ * under `skills/x` becomes `refs/a.md`.
+ *
+ * The trailing slash on the prefix is load-bearing: without it `skills/audit`
+ * also matches `skills/audit-website/...`, and the user gets a second skill's
+ * files dumped into the first one's directory.
+ */
+export function selectSkillFiles(
+	treePaths: { path: string; type: string }[],
+	repoPath: string,
+): string[] {
+	const prefix = `${repoPath.replace(/\/+$/, "")}/`;
+	return treePaths
+		.filter((e) => e.type === "blob" && e.path.startsWith(prefix))
+		.map((e) => e.path.slice(prefix.length))
+		.filter((rel) => rel.length > 0);
+}
+
+/**
+ * Resolve one relative path inside the install directory, or return null.
+ *
+ * These paths come from a remote repository, so they are untrusted input to a
+ * filesystem write. Anything that escapes the install directory — `..`
+ * segments, an absolute path — is dropped rather than written outside the
+ * skill folder.
+ */
+export function resolveSkillFilePath(
+	installDir: string,
+	relativePath: string,
+): string | null {
+	if (!relativePath || path.isAbsolute(relativePath)) return null;
+	const resolvedDir = path.resolve(installDir);
+	const target = path.resolve(resolvedDir, relativePath);
+	if (target !== resolvedDir && !target.startsWith(resolvedDir + path.sep)) {
+		return null;
+	}
+	return target;
+}
+
+/** What an install actually delivered — surfaced so the UI can be honest. */
+export interface InstallResult {
+	/** Number of files written, always ≥ 1 (SKILL.md). */
+	fileCount: number;
+	/**
+	 * Set when only SKILL.md could be written for a skill that has more files,
+	 * e.g. the GitHub tree call was rate-limited. The skill is installed but
+	 * incomplete, and the caller should say so.
+	 */
+	degraded?: string;
+}
+
 export async function installSkill(
 	skill: SkillInfo,
 	scope: "user" | "project",
 	projectPath?: string,
-): Promise<void> {
+): Promise<InstallResult> {
 	// Try multiple URL patterns — repos structure SKILL.md differently
 	const repo = skill.source.repo;
 	const repoPath = skill.repoPath.replace(/\/SKILL\.md$/, "");
@@ -392,6 +450,74 @@ export async function installSkill(
 
 	await fs.ensureDir(installDir);
 	await fs.writeFile(path.join(installDir, "SKILL.md"), content, "utf8");
+
+	// SKILL.md alone is usually not a working skill. Skills ship scripts,
+	// references and assets beside it and link to them by relative path, so
+	// writing only SKILL.md leaves dangling links — measured: audit-website
+	// references `references/OUTPUT-FORMAT.md`, systematic-debugging ships
+	// `find-polluter.sh` and 9 more. Fetch the rest of the directory.
+	let extras: string[] = [];
+	try {
+		const tree = await fetchGitTree(repo);
+		extras = selectSkillFiles(tree.tree, repoPath).filter(
+			(rel) => rel !== "SKILL.md",
+		);
+	} catch (error) {
+		// The tree call is the rate-limited one. A skill with only SKILL.md is
+		// still correct, so report the shortfall instead of failing the install.
+		return {
+			fileCount: 1,
+			degraded:
+				error instanceof Error && /rate limit/i.test(error.message)
+					? "GitHub rate limit — supporting files not fetched. Set GITHUB_TOKEN and reinstall."
+					: "supporting files could not be listed; SKILL.md only",
+		};
+	}
+
+	if (extras.length === 0) return { fileCount: 1 };
+
+	const truncated = extras.length > MAX_SKILL_FILES;
+	const selected = truncated ? extras.slice(0, MAX_SKILL_FILES) : extras;
+
+	let written = 1;
+	let bytes = content.length;
+	let budgetHit = false;
+
+	for (const rel of selected) {
+		if (bytes >= MAX_SKILL_BYTES) {
+			budgetHit = true;
+			break;
+		}
+		const target = resolveSkillFilePath(installDir, rel);
+		if (!target) continue; // escapes the install dir — never write it
+		try {
+			const res = await fetch(
+				`https://raw.githubusercontent.com/${repo}/HEAD/${repoPath}/${rel}`,
+				{ signal: AbortSignal.timeout(15000) },
+			);
+			if (!res.ok) continue;
+			// Buffer, not text: skills ship binary assets (.png, .svg) and
+			// decoding those as UTF-8 corrupts them.
+			const buf = Buffer.from(await res.arrayBuffer());
+			await fs.ensureDir(path.dirname(target));
+			await fs.writeFile(target, buf);
+			written++;
+			bytes += buf.length;
+		} catch {
+			// One unreachable asset should not abandon a half-written skill.
+		}
+	}
+
+	let degraded: string | undefined;
+	if (budgetHit) {
+		degraded = `stopped at ${MAX_SKILL_BYTES / 1024 / 1024}MB — skill is larger than the install budget`;
+	} else if (truncated) {
+		degraded = `only the first ${MAX_SKILL_FILES} of ${extras.length + 1} files were installed`;
+	} else if (written < selected.length + 1) {
+		degraded = `${selected.length + 1 - written} of ${selected.length + 1} files could not be fetched`;
+	}
+
+	return { fileCount: written, degraded };
 }
 
 export async function uninstallSkill(
@@ -411,11 +537,20 @@ export async function uninstallSkill(
 
 	const skillMdPath = path.join(installDir, "SKILL.md");
 
+	// Remove the whole skill directory, not just SKILL.md. Installs now write
+	// supporting files (scripts, references, assets); deleting SKILL.md alone
+	// left those orphaned, and the follow-up `rmdir` then failed silently on the
+	// non-empty directory — so the skill vanished from the UI while its files
+	// stayed on disk forever.
+	//
+	// Gated on SKILL.md existing so this only ever deletes a directory that is
+	// actually an installed skill.
 	if (await fs.pathExists(skillMdPath)) {
-		await fs.remove(skillMdPath);
+		await fs.remove(installDir);
+		return;
 	}
 
-	// Try to remove directory if empty
+	// No SKILL.md: at most an empty leftover directory. Remove it only if empty.
 	try {
 		await fs.rmdir(installDir);
 	} catch {

package/src/ui/screens/SkillsScreen.tsx

@@ -271,10 +271,12 @@ export function SkillsScreen() {
       showStatus(`Installing ${toInstall.length} skills from ${set.name}...`);
       let installed = 0;
       let failed = 0;
+      let degraded = 0;
       for (const skill of toInstall) {
         try {
-          await installSkill(skill, scope, state.projectPath);
+          const result = await installSkill(skill, scope, state.projectPath);
           installed++;
+          if (result.degraded) degraded++;
         } catch {
           failed++;
         }
@@ -282,6 +284,13 @@ export function SkillsScreen() {
       await scanDisk();
       if (failed > 0) {
         showStatus(`Installed ${installed}/${toInstall.length} (${failed} failed)`, "error");
+      } else if (degraded > 0) {
+        // Incomplete is not the same as installed. Say so rather than let a
+        // batch of half-written skills report a clean success.
+        showStatus(
+          `Installed ${installed} skills from ${set.name} to ${scope} — ${degraded} incomplete (missing supporting files)`,
+          "error",
+        );
       } else {
         showStatus(`Installed ${installed} skills from ${set.name} to ${scope}`);
       }
@@ -443,9 +452,20 @@ export function SkillsScreen() {
   const handleInstall = useCallback(async (scope: "user" | "project") => {
     if (!selectedSkill) return;
     try {
-      await installSkill(selectedSkill, scope, state.projectPath);
+      const result = await installSkill(selectedSkill, scope, state.projectPath);
       await scanDisk(); // Re-scan disk only — no network re-fetch needed
-      showStatus(`Installed ${selectedSkill.name} to ${scope}`);
+      const files =
+        result.fileCount === 1 ? "1 file" : `${result.fileCount} files`;
+      // An install that silently dropped supporting files used to report plain
+      // success, so a half-installed skill looked identical to a good one.
+      if (result.degraded) {
+        showStatus(
+          `Installed ${selectedSkill.name} to ${scope} (${files}) — ${result.degraded}`,
+          "error",
+        );
+      } else {
+        showStatus(`Installed ${selectedSkill.name} to ${scope} (${files})`);
+      }
     } catch (error) {
       showStatus(`Failed: ${error}`, "error");
     }