claude-slim 2.2.1 → 2.2.3

package/dist/cleaner.js

@@ -1,7 +1,7 @@
 import { rename, readdir, rmdir, rm, unlink, lstat, mkdir } from 'node:fs/promises';
 import { join, dirname } from 'node:path';
 import { appendManifest, ensureDisabledDir, getDisabledDir, removeEntry } from './manifest.js';
-import { getSkillsDir } from './paths.js';
+import { assertInsideClaudeDir, getSkillsDir } from './paths.js';
 async function pathExists(p) {
     try {
         await lstat(p);
@@ -33,6 +33,7 @@ export async function cleanIssues(issues) {
     const errors = [];
     for (const issue of issues) {
         try {
+            assertInsideClaudeDir(issue.path);
             if (issue.type === 'broken_symlink') {
                 await unlink(issue.path);
                 const entry = {
@@ -67,8 +68,17 @@ export async function cleanIssues(issues) {
                 moved.push(entry);
             }
             else if (issue.type === 'temp_cache') {
-                // Delete temp directories (failed plugin installs, not restorable)
-                await rm(issue.path, { recursive: true, force: true });
+                // Delete temp directories (failed plugin installs, not restorable).
+                // If the path is itself a symlink, only remove the link — never
+                // follow it into whatever it points at. fs.rm on Node >=18 already
+                // behaves this way, but we encode the invariant explicitly.
+                const st = await lstat(issue.path);
+                if (st.isSymbolicLink()) {
+                    await unlink(issue.path);
+                }
+                else {
+                    await rm(issue.path, { recursive: true, force: true });
+                }
                 const entry = {
                     date: new Date().toISOString(),
                     name: issue.name,
@@ -138,6 +148,7 @@ async function cleanEmptyDirs(dir) {
     catch { /* skip */ }
 }
 export async function restoreItem(entry) {
+    assertInsideClaudeDir(entry.from);
     if (entry.type === 'broken_symlink') {
         throw new Error(`Broken symlinks cannot be restored (${entry.name})`);
     }
@@ -163,6 +174,14 @@ export async function restoreItem(entry) {
         // Restore skill directory using the same naming as cleanIssues
         const safeName = entry.name.replace(/\//g, '--');
         const src = join(disabledDir, safeName);
+        if (!(await pathExists(src))) {
+            throw new Error(`Backup not found for "${entry.name}" at ${src}. ` +
+                `It may have been manually removed.`);
+        }
+        if (await pathExists(entry.from)) {
+            throw new Error(`Cannot restore: ${entry.from} already exists. ` +
+                `Remove or rename it first.`);
+        }
         await mkdir(dirname(entry.from), { recursive: true });
         await rename(src, entry.from);
     }

package/dist/paths.d.ts

@@ -5,3 +5,4 @@ export declare function getProjectsDir(): string;
 export declare function getDisabledDir(): string;
 export declare function getManifestPath(): string;
 export declare function getLegacyManifestPath(): string;
+export declare function assertInsideClaudeDir(p: string): void;

package/dist/paths.js

@@ -1,5 +1,5 @@
 import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { join, resolve, sep } from 'node:path';
 export function getClaudeDir() {
     return join(homedir(), '.claude');
 }
@@ -21,3 +21,12 @@ export function getManifestPath() {
 export function getLegacyManifestPath() {
     return join(getDisabledDir(), '.claude-slim-manifest.jsonl');
 }
+// Refuse to operate on a path outside ~/.claude/. Guards destructive operations
+// (rename/rm/unlink) from acting on attacker-tampered manifests or scanner bugs.
+export function assertInsideClaudeDir(p) {
+    const resolved = resolve(p);
+    const root = resolve(getClaudeDir());
+    if (resolved !== root && !resolved.startsWith(root + sep)) {
+        throw new Error(`Refusing to operate on path outside ~/.claude/: ${p}`);
+    }
+}

package/dist/report.js

@@ -28,25 +28,25 @@ export function calculateReport(scanBefore, scanAfter, movedEntries, sessionsPer
             label: 'Local skills',
             before: String(localBefore),
             after: String(localAfter),
-            saved: `${localAfter - localBefore}`,
+            saved: `${localBefore - localAfter}`,
         },
         {
             label: 'System prompt',
             before: `~${promptBefore}`,
             after: `~${promptAfter}`,
-            saved: `${promptAfter - promptBefore}`,
+            saved: `${promptBefore - promptAfter}`,
         },
         {
             label: 'Memory files',
             before: `${(memBefore / 1024).toFixed(1)}KB`,
             after: `${(memAfter / 1024).toFixed(1)}KB`,
-            saved: `${((memAfter - memBefore) / 1024).toFixed(1)}KB`,
+            saved: `${((memBefore - memAfter) / 1024).toFixed(1)}KB`,
         },
         {
             label: 'Est. tokens',
             before: `~${before.toLocaleString()}`,
             after: `~${after.toLocaleString()}`,
-            saved: `~${(after - before).toLocaleString()}`,
+            saved: `~${(before - after).toLocaleString()}`,
         },
     ];
     return {

package/dist/scanner.js

@@ -47,11 +47,13 @@ async function isBrokenSymlink(p) {
         }
     }
 }
-async function runCommand(cmd) {
+// execFile (not exec) — never routes through a shell, so command arguments
+// cannot be interpreted as shell metacharacters regardless of caller inputs.
+async function runCommand(file, args) {
     try {
-        const { exec } = await import('node:child_process');
+        const { execFile } = await import('node:child_process');
         return new Promise((resolve) => {
-            exec(cmd, { timeout: 10000 }, (_err, stdout) => {
+            execFile(file, args, { timeout: 10000 }, (_err, stdout) => {
                 resolve(stdout || '');
             });
         });
@@ -307,7 +309,7 @@ export function parseDisabledPlugins(output) {
     return disabled;
 }
 async function getDisabledPlugins() {
-    return parseDisabledPlugins(await runCommand('claude plugin list'));
+    return parseDisabledPlugins(await runCommand('claude', ['plugin', 'list']));
 }
 export function parseClaudeMdSections(content) {
     const sections = [];

package/dist/selection.js

@@ -28,9 +28,11 @@ export function resolveRestoreSelection(input, count) {
         return Array.from({ length: count }, (_, i) => i);
     }
     const indices = [];
+    const seen = new Set();
     for (const part of trimmed.split(',')) {
         const num = parseInt(part.trim(), 10);
-        if (!isNaN(num) && num >= 1 && num <= count) {
+        if (!isNaN(num) && num >= 1 && num <= count && !seen.has(num)) {
+            seen.add(num);
             indices.push(num - 1);
         }
     }

package/dist/tokenizer.js

@@ -1,10 +1,13 @@
 import { createHash } from 'node:crypto';
-import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { readFile, writeFile, mkdir, rename } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
-import { homedir } from 'node:os';
+import { getClaudeDir } from './paths.js';
 let encoder = null;
 let useFallback = false;
-const CACHE_PATH = join(homedir(), '.claude', '.token-cache.json');
+// Resolved lazily so the HOME env stub used in tests is honored.
+function getCachePath() {
+    return join(getClaudeDir(), '.token-cache.json');
+}
 let cache = { version: 1, entries: {} };
 let cacheDirty = false;
 export async function initTokenizer() {
@@ -16,8 +19,12 @@ export async function initTokenizer() {
     catch {
         useFallback = true;
     }
+    // Reset in-memory state so repeated initTokenizer() calls (e.g. across
+    // test cases) don't bleed cache entries from a prior invocation.
+    cache = { version: 1, entries: {} };
+    cacheDirty = false;
     try {
-        const raw = await readFile(CACHE_PATH, 'utf-8');
+        const raw = await readFile(getCachePath(), 'utf-8');
         cache = JSON.parse(raw);
     }
     catch {
@@ -47,9 +54,15 @@ export function countTokensCached(text, filePath) {
 export async function flushCache() {
     if (!cacheDirty)
         return;
+    const target = getCachePath();
+    const tmp = target + '.tmp';
     try {
-        await mkdir(dirname(CACHE_PATH), { recursive: true });
-        await writeFile(CACHE_PATH, JSON.stringify(cache, null, 2));
+        await mkdir(dirname(target), { recursive: true });
+        // Atomic: write to a sibling tmp file first, then rename. A crash mid-write
+        // leaves the prior cache (or nothing) — never a torn JSON file.
+        await writeFile(tmp, JSON.stringify(cache, null, 2));
+        await rename(tmp, target);
+        cacheDirty = false;
     }
     catch {
         // Non-critical

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-slim",
-  "version": "2.2.1",
+  "version": "2.2.3",
   "description": "Analyze and reduce Claude Code token overhead",
   "type": "module",
   "bin": {

package/skills/claude-slim/SKILL.md

@@ -41,26 +41,28 @@ bash "${CLAUDE_PLUGIN_ROOT}/skills/claude-slim/scripts/scan.sh"
 
 After getting the scan JSON, YOU must interpret and present results to the user. Do NOT just dump raw CLI output. Present a full diagnostic report in the user's language.
 
+> **Templates below are shown in English for readability. Always translate headers, labels, and prompts into the user's detected language when rendering.**
+
 ### 2-1. Environment Snapshot Table
 
 Show a summary table:
 
-| 항목 | 수치 | 토큰 |
-|------|------|------|
-| 로컬 스킬 | N개 (XKB) | X tok |
-| 플러그인 | N개 (M 스킬) | ~X tok |
+| Item | Count | Tokens |
+|------|-------|--------|
+| Local skills | N (XKB) | X tok |
+| Plugins | N (M skills) | ~X tok |
 | CLAUDE.md | XKB | X tok |
-| 메모리 파일 | N개 (XKB) | ~X tok |
-| **세션 시작 오버헤드** | | **~X tok** |
+| Memory files | N (XKB) | ~X tok |
+| **Session startup overhead** | | **~X tok** |
 
 ### 2-2. Plugin Detail Table
 
 List each plugin with skill count and a judgment:
 
-| 플러그인 | 스킬 수 | 비고 |
-|----------|:-------:|------|
-| omc | 36 | 코어 플러그인. 유지 |
-| temp_local_... | 1 | **실패한 설치 잔여물. 삭제 대상** |
+| Plugin | Skills | Notes |
+|--------|:------:|-------|
+| omc | 36 | Core plugin. Keep. |
+| temp_local_... | 1 | **Failed install remnant. Cleanup target.** |
 
 Annotate each with status: actively used, possibly unused, or cleanup target. Flag `temp_local_*` entries as failed install remnants.
 
@@ -68,18 +70,18 @@ Annotate each with status: actively used, possibly unused, or cleanup target. Fl
 
 Group issues by tier and explain EACH one with context and recommendation:
 
-**Tier 1 — 즉시 정리 (위험 없음):**
+**Tier 1 — Immediate cleanup (zero risk):**
 These are safe to remove with zero risk: broken symlinks, empty templates, .skill/ duplicates, temp_local_* cache. Pre-selected. Explain why each is safe.
 
-**Tier 2 — 정리 추천:**
+**Tier 2 — Recommended cleanup:**
 These are recommended but need user judgment. For each issue, explain:
 - What is it and why it's flagged
 - What happens if you remove it (safe? any side effects?)
 - How many tokens it saves
 
-Example: "frontend-design이 로컬과 플러그인에 둘 다 있습니다. 로컬 제거해도 플러그인 버전이 남으니 안전하게 제거 가능. ~823 tok 절감."
+Example: "frontend-design exists both locally and in a plugin. Removing the local copy is safe because the plugin version remains. Saves ~823 tok."
 
-**Tier 3 — 선택 사항 (사용자 판단):**
+**Tier 3 — Optional (user judgment):**
 These are large skills that cost tokens but might be in active use. For each:
 - Show size and token cost
 - Judge whether the user likely uses it (based on what it does)
@@ -94,7 +96,7 @@ End with a numbered action list, ordered by impact:
 
 Show estimated total token savings if all recommended actions are taken.
 
-If subcommand is `scan`, stop here. Ask "정리할까요?" only for the full pipeline.
+If subcommand is `scan`, stop here. Ask a localized equivalent of "Proceed with cleanup?" only for the full pipeline.
 
 ---
 
@@ -133,7 +135,7 @@ cd "${CLAUDE_PLUGIN_ROOT}" && node dist/cli.js restore
 
 ## Language
 
-Detect the user's language from their most recent message. Present all reports, analysis, and explanations in that language. The CLI output is machine-readable — translate only the user-facing interpretation.
+Detect the user's language from their most recent message. Present all reports, analysis, and explanations in that language — including table headers, tier labels, prompts, and every user-facing string. The CLI output is machine-readable (always English) and must not be echoed verbatim; translate its content into the user's language when you interpret it. The example tables above are written in English only for authoring clarity — do not treat them as a required output format.
 
 ## Rules