claude-slim 2.11.0 → 2.12.0

package/README.md

@@ -165,6 +165,7 @@ npx claude-slim scan --no-codex          # Skip the ~/.codex scan
 npx claude-slim doctor                   # Diagnose Node/Claude/session-log readiness
 npx claude-slim doctor --offline         # Same, without the version check (no network)
 npx claude-slim check-update             # Report-only version check
+npx claude-slim update                   # Run the upgrade for this install method
 npx claude-slim restore                  # Undo
 npx claude-slim report                   # Show savings from last clean
 ```
@@ -247,16 +248,12 @@ Token counts come from [js-tiktoken](https://github.com/nicolo-ribaudo/js-tiktok
 
 ---
 
-## v2.11.0 — What's new
+## v2.12.0 — What's new
 
-Codex gets the same tiered propose-and-choose cleanup Claude Code has, minus the two categories Codex cannot honestly support.
+- **`claude-slim update`** — runs the upgrade command for however this copy was installed, after showing it and asking. `--dry-run` to preview, `--yes` to skip the prompt. Plugin installs get the marketplace refresh first, then the qualified `claude-slim@claude-slim` id, and are reminded that a restart is needed. npx and source checkouts run nothing and say why — npx already resolves the latest every invocation, and pulling your own repository is not claude-slim's to do.
+- **This corrects v2.9.0's reasoning.** That release stopped at detection, arguing updating belonged to the package manager. Half held: claude-slim must not write into a directory `claude plugin` owns. The other half did not — invoking the package manager is something this tool already does during cleanup (`claude plugin disable`), so refusing to here was inconsistent. It still writes nothing itself.
 
-- **Codex cleanup, tiered.** Five of seven categories carry over because they are filesystem facts, not usage inferences: broken symlinks and unfilled templates (Tier 1), install leftovers in `~/.codex/.tmp` (Tier 1 — 146MB on the dev machine), backup copies and plugin-shadowed duplicates (Tier 2), oversized skills (Tier 3). Codex items join the same numbered list tagged `[codex]`. `--no-codex` opts out.
-- **`~/.codex/skills.disabled/`** — moves are reversible through the same `restore`, and manifest entries record which agent they came from.
-- **The path guard is now per-agent.** Not "inside any known root" — a Codex issue must not resolve into `~/.claude/` and vice versa, so a tampered manifest cannot cross between agents.
-- `unused_skill` and `oversized_memory` remain unavailable for Codex: no invocation record, and no `~/.codex/projects/*/memory/`.
-
-Tests: 347 → 374 (+27), the guard suite being the point — cross-agent isolation both directions, traversal escapes, and a `~/.claude-backup` sibling a naive `startsWith` would have allowed.
+Tests: 374 → 392 (+18), pinning the safety properties — every argv a fixed literal, no shell metacharacters, executable only ever `claude` or `npm`, and a refusal to run unattended with no TTY and no `--yes`.
 
 For older release notes, see [CHANGELOG.md](CHANGELOG.md).
 

package/dist/cli.js

@@ -11,6 +11,7 @@ import { readManifest } from './manifest.js';
 import { formatScanSummary, formatReportBox, calculateReport, } from './report.js';
 import { collectDoctorReport, formatDoctorReport } from './doctor.js';
 import { checkForUpdate, formatUpdateNotice } from './update-check.js';
+import { confirmDecision, planUpdate, renderStep, runUpdate } from './update-run.js';
 import { scanCodex } from './codex/index.js';
 import { formatCodexSummary } from './codex/report.js';
 import { classifyCodexIssues } from './codex/detectors.js';
@@ -101,6 +102,81 @@ program
         console.log(`\n  \x1b[32m✓\x1b[0m claude-slim ${result.installed} is up to date.\n`);
     }
 });
+// --- update ---
+// Detection lives in `check-update`; this runs the command that detection
+// identified. claude-slim still never writes into a package manager's
+// directories itself — it invokes the manager, the same way cleanup already
+// invokes `claude plugin disable`.
+program
+    .command('update')
+    .description('Run the upgrade command for however this copy was installed')
+    .option('--yes', 'Skip the confirmation prompt')
+    .option('--dry-run', 'Show the commands without running them')
+    .action(async (opts) => {
+    const result = await checkForUpdate({ force: true });
+    const plan = planUpdate(result.installMethod);
+    console.log('');
+    console.log(`  Installed: ${result.installed}   Latest: ${result.latest ?? 'unknown'}`);
+    console.log(`  Install method: ${result.installMethod}`);
+    console.log('');
+    if (result.latest === null) {
+        console.log('  Could not reach the npm registry, so there is nothing to compare against.');
+        console.log('');
+        process.exitCode = 1;
+        return;
+    }
+    if (!result.outdated) {
+        console.log('  \x1b[32m✓\x1b[0m Already up to date.\n');
+        return;
+    }
+    if (!plan.runnable) {
+        console.log(`  ${plan.guidance}\n`);
+        return;
+    }
+    console.log('  Will run:');
+    for (const step of plan.steps)
+        console.log(`    ${renderStep(step)}`);
+    console.log('');
+    if (opts.dryRun) {
+        console.log('  \x1b[90mDry run — nothing was executed.\x1b[0m\n');
+        return;
+    }
+    const gate = confirmDecision(opts, Boolean(process.stdin.isTTY));
+    if (gate === 'refuse') {
+        console.error('  Refusing to run unattended. Re-run with --yes to confirm.\n');
+        process.exitCode = 1;
+        return;
+    }
+    if (gate === 'prompt') {
+        const answer = await askUser('  Proceed? [y/N] ');
+        if (!/^y(es)?$/i.test(answer)) {
+            console.log('  Cancelled.\n');
+            return;
+        }
+        console.log('');
+    }
+    const results = await runUpdate(plan);
+    for (const r of results) {
+        const mark = r.ok ? '\x1b[32m✓\x1b[0m' : '\x1b[31m✗\x1b[0m';
+        console.log(`  ${mark} ${renderStep(r.step)}`);
+        if (r.output)
+            console.log(r.output.split('\n').map((l) => `      ${l}`).join('\n'));
+    }
+    const failed = results.find((r) => !r.ok);
+    console.log('');
+    if (failed) {
+        console.log('  Update did not complete. Run the commands above manually to see the full error.\n');
+        process.exitCode = 1;
+    }
+    else if (result.installMethod === 'plugin') {
+        // The new version is on disk but the running session still holds the old
+        // one — without saying so, users update, re-run, and see identical output.
+        console.log('  \x1b[33m!\x1b[0m Restart Claude Code for the update to take effect.\n');
+    }
+    else {
+        console.log('  \x1b[32m✓\x1b[0m Updated.\n');
+    }
+});
 // --- clean ---
 program
     .command('clean')

package/dist/update-run.d.ts

@@ -0,0 +1,40 @@
+import type { InstallMethod } from './update-check.js';
+export interface UpdateStep {
+    file: string;
+    args: string[];
+}
+export interface UpdatePlan {
+    /** false when there is nothing to execute — see `guidance`. */
+    runnable: boolean;
+    steps: UpdateStep[];
+    /** Why nothing runs, for the methods where that is the correct answer. */
+    guidance?: string;
+}
+export declare function planUpdate(method: InstallMethod): UpdatePlan;
+/** Human-readable rendering of a step, matching what the user would type. */
+export declare function renderStep(step: UpdateStep): string;
+export interface StepResult {
+    step: UpdateStep;
+    ok: boolean;
+    output: string;
+}
+/**
+ * Run the plan's steps in order, stopping at the first failure.
+ *
+ * Sequential rather than parallel, and halting on error, because step 2 depends
+ * on step 1 having refreshed the marketplace — running it against a stale
+ * manifest would report success while changing nothing.
+ */
+export declare function runUpdate(plan: UpdatePlan): Promise<StepResult[]>;
+export type ConfirmDecision = 'run' | 'prompt' | 'refuse';
+/**
+ * Decide how to gate an update that will modify the user's install.
+ *
+ * Refusing when there is no TTY is the important case: piped into a script or a
+ * CI job, there is nobody to answer the prompt, and silently proceeding would
+ * mean a tool that changes an installation without anyone agreeing to it.
+ * `--yes` is how you say so deliberately.
+ */
+export declare function confirmDecision(opts: {
+    yes?: boolean;
+}, isTTY: boolean): ConfirmDecision;

package/dist/update-run.js

@@ -0,0 +1,101 @@
+import { execFile } from 'node:child_process';
+// Running the upgrade.
+//
+// v2.9.0 shipped detection only, on the reasoning that updating is the package
+// manager's job. Half of that was right and half was not. Writing into the
+// plugin directory ourselves would indeed corrupt an install — but *invoking*
+// the package manager is something this tool already does elsewhere
+// (`claude plugin disable` during unused-plugin cleanup). Refusing to invoke it
+// here was inconsistent, not principled.
+//
+// So: still never write to those directories directly. Just run the command the
+// user would have typed, after showing it to them.
+//
+// Every argv below is a fixed literal. Nothing from the environment, the
+// manifest, or user input is interpolated, and execFile never routes through a
+// shell — so there is no argument-injection surface to guard.
+const STEP_TIMEOUT_MS = 180_000;
+export function planUpdate(method) {
+    switch (method) {
+        case 'plugin':
+            return {
+                runnable: true,
+                steps: [
+                    // Refresh the marketplace first; otherwise `plugin update` compares
+                    // against a stale manifest and reports "already up to date".
+                    { file: 'claude', args: ['plugin', 'marketplace', 'update', 'claude-slim'] },
+                    // The qualified id is required: the bare name fails with
+                    // `Plugin "claude-slim" not found` when a marketplace shares its name.
+                    { file: 'claude', args: ['plugin', 'update', 'claude-slim@claude-slim'] },
+                ],
+            };
+        case 'global':
+            return {
+                runnable: true,
+                steps: [{ file: 'npm', args: ['install', '-g', 'claude-slim@latest'] }],
+            };
+        case 'npx':
+            return {
+                runnable: false,
+                steps: [],
+                guidance: 'npx resolves the latest version on every invocation, so there is nothing to update. ' +
+                    'If a stale copy is cached, run `npx claude-slim@latest` once to refresh it.',
+            };
+        case 'source':
+            return {
+                runnable: false,
+                steps: [],
+                guidance: 'This is a source checkout. Updating it means pulling your own repository, ' +
+                    'which claude-slim will not do on your behalf — run `git pull && npm install` yourself.',
+            };
+        default:
+            return {
+                runnable: false,
+                steps: [],
+                guidance: 'Could not tell how this copy was installed, so no upgrade command can be chosen safely. ' +
+                    'Update it the same way you installed it.',
+            };
+    }
+}
+/** Human-readable rendering of a step, matching what the user would type. */
+export function renderStep(step) {
+    return [step.file, ...step.args].join(' ');
+}
+function runStep(step) {
+    return new Promise((resolve) => {
+        execFile(step.file, step.args, { timeout: STEP_TIMEOUT_MS }, (err, stdout, stderr) => {
+            const output = [stdout, stderr].map((s) => s?.trim()).filter(Boolean).join('\n');
+            resolve({ step, ok: !err, output: err ? `${err.message}${output ? `\n${output}` : ''}` : output });
+        });
+    });
+}
+/**
+ * Run the plan's steps in order, stopping at the first failure.
+ *
+ * Sequential rather than parallel, and halting on error, because step 2 depends
+ * on step 1 having refreshed the marketplace — running it against a stale
+ * manifest would report success while changing nothing.
+ */
+export async function runUpdate(plan) {
+    const results = [];
+    for (const step of plan.steps) {
+        const result = await runStep(step);
+        results.push(result);
+        if (!result.ok)
+            break;
+    }
+    return results;
+}
+/**
+ * Decide how to gate an update that will modify the user's install.
+ *
+ * Refusing when there is no TTY is the important case: piped into a script or a
+ * CI job, there is nobody to answer the prompt, and silently proceeding would
+ * mean a tool that changes an installation without anyone agreeing to it.
+ * `--yes` is how you say so deliberately.
+ */
+export function confirmDecision(opts, isTTY) {
+    if (opts.yes)
+        return 'run';
+    return isTTY ? 'prompt' : 'refuse';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-slim",
-  "version": "2.11.0",
+  "version": "2.12.0",
   "description": "Audit and shrink your Claude Code startup context. Measures what every skill, plugin, agent, command, and memory file costs in the system prompt, then reversibly disables the dead weight. Non-destructive scan, tiered proposals, one-command restore — no proxy, no compression.",
   "type": "module",
   "bin": {