canary-test-cli 6.8.0 → 7.0.0

package/dist/uninstall.js

@@ -0,0 +1,174 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.render = exports.enumerate = void 0;
+exports.removeAll = removeAll;
+exports.run = run;
+/**
+ * `canary uninstall` — remove what the CLI can safely remove, and print
+ * instructions for what it structurally cannot.
+ *
+ * The command deliberately refuses to claim more than it did. A full install
+ * scatters artifacts across seven locations (#523) and two of them belong to
+ * other owners: the CLI binary (the running process, removed by whichever
+ * package manager installed it) and the Claude Code plugin registration
+ * (`installed_plugins.json`, mutated only by `/plugin uninstall`). Reporting
+ * those as done would be the same false-green shape the guardian exists to
+ * catch, so they render as `manual` and are never passed to the removal path.
+ */
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const registry = __importStar(require("./overlays-registry.js"));
+const uninstall_scan_js_1 = require("./uninstall-scan.js");
+const uninstall_render_js_1 = require("./uninstall-render.js");
+const uninstall_types_js_1 = require("./uninstall-types.js");
+var uninstall_scan_js_2 = require("./uninstall-scan.js");
+Object.defineProperty(exports, "enumerate", { enumerable: true, get: function () { return uninstall_scan_js_2.enumerate; } });
+var uninstall_render_js_2 = require("./uninstall-render.js");
+Object.defineProperty(exports, "render", { enumerable: true, get: function () { return uninstall_render_js_2.render; } });
+function removeCanaryDir(dir, keepQuarantine) {
+    if (!keepQuarantine) {
+        fs.rmSync(dir, { recursive: true, force: true });
+        return;
+    }
+    for (const child of fs.readdirSync(dir)) {
+        if (child === 'quarantine.json')
+            continue;
+        fs.rmSync(path.join(dir, child), { recursive: true, force: true });
+    }
+}
+function removeMcpEntry(file) {
+    const raw = fs.readFileSync(file, 'utf8');
+    const doc = JSON.parse(raw);
+    if (doc.mcpServers)
+        delete doc.mcpServers[uninstall_types_js_1.MCP_KEY];
+    // Two-space JSON matches what the ecosystem writes; the file is left in
+    // place even when `mcpServers` is now empty — deciding an empty config
+    // should not exist is the user's call.
+    fs.writeFileSync(file, `${JSON.stringify(doc, null, 2)}\n`);
+}
+/** Delete one artifact. Assumes the caller already checked `removable`. */
+function removeOne(artifact, home, keepQuarantine) {
+    const target = artifact.path;
+    if (!target)
+        return;
+    if (artifact.kind === 'mcp-entry') {
+        removeMcpEntry(target);
+        return;
+    }
+    if (artifact.kind === 'project-config') {
+        removeCanaryDir(target, keepQuarantine);
+        return;
+    }
+    fs.rmSync(target, { recursive: true, force: true });
+    if (artifact.kind === 'overlay') {
+        // The clone is gone; drop its registry row too, or `overlay list` keeps
+        // advertising a path that no longer exists.
+        const name = artifact.label.replace(/^overlay /, '');
+        registry.write(registry.remove(registry.read(home), name).registry, home);
+    }
+}
+function removeAll(artifacts, deps = {}) {
+    const home = deps.homeDir ?? os.homedir();
+    const outcome = { removed: [], failed: [] };
+    // When the ledger was withheld, `.canary/` must be emptied around it rather
+    // than deleted wholesale — otherwise the removal silently undoes the
+    // protection the `blocked` disposition just promised.
+    const keepQuarantine = artifacts.some((a) => a.kind === 'quarantine-ledger' && a.disposition === 'blocked');
+    for (const a of artifacts) {
+        if (a.disposition !== 'removable')
+            continue;
+        try {
+            removeOne(a, home, keepQuarantine);
+            outcome.removed.push(a);
+        }
+        catch (e) {
+            outcome.failed.push({ artifact: a, error: e.message });
+        }
+    }
+    return outcome;
+}
+const KNOWN_FLAGS = new Set([
+    '--global',
+    '--project',
+    '--all',
+    '--apply',
+    '--include-generated',
+]);
+function run(argv, deps = {}) {
+    const out = deps.out ?? process.stdout;
+    const err = deps.err ?? process.stderr;
+    for (const a of argv) {
+        if (!KNOWN_FLAGS.has(a)) {
+            err.write(`canary uninstall: unknown option "${a}".\n`);
+            return 1;
+        }
+    }
+    const scopes = [];
+    if (argv.includes('--global'))
+        scopes.push('global');
+    if (argv.includes('--project'))
+        scopes.push('project');
+    if (argv.includes('--all'))
+        scopes.push('all');
+    if (scopes.length === 0) {
+        err.write('canary uninstall: choose a scope.\n' +
+            '  --global   overlays and orphaned Claude Code plugin caches\n' +
+            '  --project  .canary/, generated reports, and the .mcp.json entry\n' +
+            '  --all      both\n' +
+            'Nothing is removed without --apply.\n');
+        return 1;
+    }
+    if (scopes.length > 1) {
+        err.write('canary uninstall: pass exactly one of --global/--project/--all.\n');
+        return 1;
+    }
+    const scope = scopes[0];
+    const apply = argv.includes('--apply');
+    const includeGenerated = argv.includes('--include-generated');
+    const artifacts = (0, uninstall_scan_js_1.enumerate)({ scope, includeGenerated }, deps);
+    let failed = [];
+    if (apply) {
+        failed = removeAll(artifacts, deps).failed;
+    }
+    // Hand the failures to the renderer so a removal that threw is never counted
+    // as removed — the report must not be cleaner than the outcome.
+    out.write(`${(0, uninstall_render_js_1.render)(artifacts, { scope, apply, failed: failed.map((f) => f.artifact) })}\n`);
+    for (const f of failed) {
+        err.write(`canary uninstall: failed to remove ${f.artifact.path}: ${f.error}\n`);
+    }
+    return failed.length > 0 ? 1 : 0;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "canary-test-cli",
-  "version": "6.8.0",
+  "version": "7.0.0",
   "description": "Canary — AI-powered test automation agent",
   "license": "MIT",
   "repository": {