claude-slim 2.2.2 → 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.2",
+  "version": "2.2.3",
   "description": "Analyze and reduce Claude Code token overhead",
   "type": "module",
   "bin": {