@event4u/agent-config 9.9.0 → 9.11.0

package/dist/cli-delegate/cmd_uninstall.js

@@ -0,0 +1,656 @@
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  PROJECT_BRIDGE_MARKERS,
+  USER_SCOPE_PATHS,
+  subtract_pointers
+} from "./chunk-YMFO6FDN.js";
+import "./chunk-XX6TOPD7.js";
+import {
+  manifest_path,
+  read_manifest,
+  write_atomic,
+  write_manifest
+} from "./chunk-IR7P7JWA.js";
+import {
+  lockfile_path,
+  lockfile_write_path,
+  read_lockfile,
+  write_lockfile
+} from "./chunk-GRRPEPRN.js";
+import {
+  remove_managed_hooks
+} from "./chunk-7DSAMZFU.js";
+import {
+  resolve_project_root
+} from "./chunk-HJ6DAJHR.js";
+import "./chunk-NDJLNC6Q.js";
+import "./chunk-MCJYCQPF.js";
+import "./chunk-OY53J6II.js";
+import "./chunk-J55WI3RR.js";
+
+// src/scripts/_cli/cmd_uninstall.ts
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import process from "node:process";
+import { fileURLToPath, pathToFileURL } from "node:url";
+var ArgparseExit = class extends Error {
+  code;
+  constructor(code) {
+    super(`ArgparseExit(${code})`);
+    this.name = "ArgparseExit";
+    this.code = code;
+  }
+};
+var _stdout = { write: (t) => process.stdout.write(t) };
+var _stderr = { write: (t) => process.stderr.write(t) };
+function _print(out, line = "") {
+  out.write(line + "\n");
+}
+function expanduser(p) {
+  if (p === "~" || p.startsWith("~/")) {
+    const home = process.env["HOME"] ?? process.env["USERPROFILE"] ?? "";
+    return home + p.slice(1);
+  }
+  return p;
+}
+function _isDir(p) {
+  try {
+    return fs.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function _exists(p) {
+  try {
+    fs.lstatSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function _isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function _jsonStrAscii(s) {
+  let out = '"';
+  for (let i = 0; i < s.length; i++) {
+    const code = s.charCodeAt(i);
+    const ch = s[i];
+    switch (ch) {
+      case '"':
+        out += '\\"';
+        break;
+      case "\\":
+        out += "\\\\";
+        break;
+      case "\n":
+        out += "\\n";
+        break;
+      case "\r":
+        out += "\\r";
+        break;
+      case "	":
+        out += "\\t";
+        break;
+      case "\b":
+        out += "\\b";
+        break;
+      case "\f":
+        out += "\\f";
+        break;
+      default:
+        if (code < 32 || code > 126) {
+          out += "\\u" + code.toString(16).padStart(4, "0");
+        } else {
+          out += ch;
+        }
+    }
+  }
+  return out + '"';
+}
+function _jsonScalarAscii(value) {
+  if (value === null || value === void 0) return "null";
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      if (Number.isNaN(value)) return "NaN";
+      return value > 0 ? "Infinity" : "-Infinity";
+    }
+    return String(value);
+  }
+  if (typeof value === "string") return _jsonStrAscii(value);
+  return null;
+}
+function _dumpIndentAscii(value, indent, depth) {
+  const scalar = _jsonScalarAscii(value);
+  if (scalar !== null) return scalar;
+  const pad = " ".repeat(indent * (depth + 1));
+  const closePad = " ".repeat(indent * depth);
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "[]";
+    const items = value.map((v) => pad + _dumpIndentAscii(v, indent, depth + 1));
+    return `[
+${items.join(",\n")}
+${closePad}]`;
+  }
+  if (typeof value === "object" && value !== null) {
+    const obj = value;
+    const keys = Object.keys(obj);
+    if (keys.length === 0) return "{}";
+    const items = keys.map(
+      (k) => `${pad}${_jsonStrAscii(k)}: ${_dumpIndentAscii(obj[k], indent, depth + 1)}`
+    );
+    return `{
+${items.join(",\n")}
+${closePad}}`;
+  }
+  return _jsonStrAscii(String(value));
+}
+function _jsonDumpsIndentAscii(value, indent) {
+  return _dumpIndentAscii(value, indent, 0);
+}
+function _resolve_project_root(arg) {
+  const [root] = resolve_project_root(arg);
+  return root;
+}
+function _filter_tools(all_tools, requested) {
+  const pool = [...all_tools];
+  if (!requested || requested.trim() === "all") {
+    return pool;
+  }
+  const wanted = new Set(
+    requested.split(",").map((t) => t.trim()).filter((t) => t)
+  );
+  return pool.filter((t) => wanted.has(t));
+}
+function _remove_project_marker(project_root, tool, opts) {
+  const rel = PROJECT_BRIDGE_MARKERS[tool];
+  if (!rel) {
+    return [`${tool}: no project marker registered (skipped)`, false];
+  }
+  const target = path.join(project_root, rel);
+  if (!_exists(target)) {
+    return [`${tool}: ${rel} already absent`, false];
+  }
+  if (opts.dry_run) {
+    return [`${tool}: would remove ${rel}`, true];
+  }
+  try {
+    fs.unlinkSync(target);
+    return [`${tool}: removed ${rel}`, true];
+  } catch (exc) {
+    return [`${tool}: \u274C failed to remove ${rel} (${_osErr(exc)})`, false];
+  }
+}
+function _remove_global_content(tool, opts) {
+  const anchor = USER_SCOPE_PATHS[tool];
+  if (!anchor) {
+    return [`${tool}: no global anchor registered (skipped)`, false];
+  }
+  const target = expanduser(anchor);
+  if (!_exists(target)) {
+    return [`${tool}: ${anchor} already absent`, false];
+  }
+  if (!opts.purge) {
+    return [`${tool}: ${anchor} preserved (pass --purge to delete)`, false];
+  }
+  if (opts.dry_run) {
+    return [`${tool}: would purge ${anchor}`, true];
+  }
+  try {
+    if (_isDir(target)) {
+      fs.rmSync(target, { recursive: true, force: false });
+    } else {
+      fs.unlinkSync(target);
+    }
+    return [`${tool}: purged ${anchor}`, true];
+  } catch (exc) {
+    return [`${tool}: \u274C failed to purge ${anchor} (${_osErr(exc)})`, false];
+  }
+}
+function _osErr(exc) {
+  const e = exc;
+  return e && e.message ? e.message : String(exc);
+}
+function _is_v2_entry(entry) {
+  return Boolean(_listOf(entry["files"]).length) || Boolean(_listOf(entry["merged_keys"]).length);
+}
+function _listOf(value) {
+  return Array.isArray(value) ? value : [];
+}
+function _resolve_recorded_path(project_root, recorded) {
+  if (path.isAbsolute(recorded)) {
+    return recorded;
+  }
+  return path.resolve(project_root, recorded);
+}
+function _set_tool_status(manifest_path2, version, tools, name, status, opts) {
+  const new_tools = [];
+  for (let entry of tools) {
+    if (entry["name"] === name) {
+      entry = { ...entry, status };
+    }
+    new_tools.push(entry);
+  }
+  write_manifest(manifest_path2, version, new_tools, {
+    deploy_roots: opts.deploy_roots
+  });
+  return new_tools;
+}
+function _subtract_merged_keys(entry, project_root, opts) {
+  const warnings = [];
+  const emptied = /* @__PURE__ */ new Set();
+  const touched = /* @__PURE__ */ new Set();
+  const merged_keys = _listOf(entry["merged_keys"]);
+  if (!merged_keys.length) {
+    return [warnings, emptied, touched];
+  }
+  const by_file = /* @__PURE__ */ new Map();
+  for (const record of merged_keys) {
+    const file = String(record["file"]);
+    if (!by_file.has(file)) {
+      by_file.set(file, []);
+    }
+    by_file.get(file).push(record);
+  }
+  for (const [file_label, records] of by_file) {
+    const target = _resolve_recorded_path(project_root, file_label);
+    touched.add(target);
+    if (!_exists(target)) {
+      warnings.push(`${file_label}: absent \u2014 skipping ${records.length} pointer(s)`);
+      continue;
+    }
+    let doc;
+    try {
+      doc = JSON.parse(fs.readFileSync(target, { encoding: "utf-8" }));
+    } catch (exc) {
+      warnings.push(`${file_label}: unparseable JSON (${_jsonExc(exc, target)}); skipped`);
+      continue;
+    }
+    if (!_isPlainObject(doc)) {
+      warnings.push(`${file_label}: not a JSON object; skipped`);
+      continue;
+    }
+    const [new_doc, sub_warnings] = subtract_pointers(
+      doc,
+      records.map((r) => ({
+        json_pointer: String(r["json_pointer"]),
+        value_hash: r["value_hash"] ?? null
+      }))
+    );
+    for (const w of sub_warnings) {
+      warnings.push(`${file_label}${w.pointer}: ${w.reason}`);
+    }
+    if (opts.dry_run) {
+      if (Object.keys(new_doc).length === 0) {
+        emptied.add(target);
+      }
+      continue;
+    }
+    if (Object.keys(new_doc).length > 0) {
+      write_atomic(target, _jsonDumpsIndentAscii(new_doc, 2) + "\n");
+    } else {
+      emptied.add(target);
+    }
+  }
+  return [warnings, emptied, touched];
+}
+function _jsonExc(exc, _target) {
+  return _osErr(exc);
+}
+function _delete_tool_files(entry, project_root, opts) {
+  const deleted = [];
+  const skipped = [];
+  for (const record of _listOf(entry["files"])) {
+    const target = _resolve_recorded_path(project_root, String(record["path"]));
+    const kind = record["kind"];
+    const label = target;
+    if (kind === "bridge") {
+      const is_shared_json = _exists(label) && path.extname(label) === ".json" && opts.touched_files.has(label) && !opts.emptied_files.has(label);
+      if (is_shared_json) {
+        skipped.push(`bridge ${label}: foreign keys preserved`);
+        continue;
+      }
+      if (!_exists(label)) {
+        skipped.push(`bridge ${label}: already absent`);
+        continue;
+      }
+      if (opts.dry_run) {
+        deleted.push(`would remove bridge ${label}`);
+        continue;
+      }
+      try {
+        fs.unlinkSync(label);
+        deleted.push(`removed bridge ${label}`);
+      } catch (exc) {
+        skipped.push(`bridge ${label}: \u274C ${_osErr(exc)}`);
+      }
+    } else if (kind === "marker") {
+      if (!_exists(label)) {
+        skipped.push(`marker ${label}: already absent`);
+        continue;
+      }
+      if (opts.dry_run) {
+        deleted.push(`would remove marker ${label}`);
+        continue;
+      }
+      try {
+        fs.unlinkSync(label);
+        deleted.push(`removed marker ${label}`);
+      } catch (exc) {
+        skipped.push(`marker ${label}: \u274C ${_osErr(exc)}`);
+      }
+    } else if (kind === "deployed") {
+      if (!opts.purge) {
+        skipped.push(`deployed ${label}: preserved (pass --purge)`);
+        continue;
+      }
+      if (!_exists(label)) {
+        skipped.push(`deployed ${label}: already absent`);
+        continue;
+      }
+      if (opts.dry_run) {
+        deleted.push(`would purge deployed ${label}`);
+        continue;
+      }
+      try {
+        if (_isDir(label)) {
+          fs.rmSync(label, { recursive: true, force: false });
+        } else {
+          fs.unlinkSync(label);
+        }
+        deleted.push(`purged deployed ${label}`);
+      } catch (exc) {
+        skipped.push(`deployed ${label}: \u274C ${_osErr(exc)}`);
+      }
+    } else {
+      skipped.push(`${label}: unknown kind=${_pyRepr(kind)}`);
+    }
+  }
+  return [deleted, skipped];
+}
+function _pyRepr(value) {
+  if (value === null || value === void 0) return "None";
+  if (typeof value === "string") return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+  if (typeof value === "boolean") return value ? "True" : "False";
+  return String(value);
+}
+function _parse(argv) {
+  const prog = "agent-config uninstall";
+  const usage = "usage: agent-config uninstall [-h] [--global] [--tools TOOLS]\n                              [--project PROJECT] [--dry-run] [--purge]\n                              [--force]\n";
+  const emitError = (msg) => {
+    _stderr.write(usage);
+    _stderr.write(`${prog}: error: ${msg}
+`);
+    throw new ArgparseExit(2);
+  };
+  const opts = {
+    global_mode: false,
+    tools: null,
+    project: null,
+    dry_run: false,
+    purge: false,
+    force: false
+  };
+  const takeValue = (tok, i2) => {
+    const eq = tok.indexOf("=");
+    if (eq >= 0) {
+      return [tok.slice(eq + 1), i2 + 1];
+    }
+    const val = argv[i2 + 1];
+    if (val === void 0) {
+      emitError(`argument ${tok}: expected one argument`);
+    }
+    return [val, i2 + 2];
+  };
+  let i = 0;
+  while (i < argv.length) {
+    const tok = argv[i];
+    const flag = tok.includes("=") ? tok.slice(0, tok.indexOf("=")) : tok;
+    if (flag === "-h" || flag === "--help") {
+      _stdout.write(usage);
+      throw new ArgparseExit(0);
+    } else if (flag === "--global") {
+      opts.global_mode = true;
+      i += 1;
+    } else if (flag === "--tools") {
+      const [v, ni] = takeValue(tok, i);
+      opts.tools = v;
+      i = ni;
+    } else if (flag === "--project") {
+      const [v, ni] = takeValue(tok, i);
+      opts.project = v;
+      i = ni;
+    } else if (flag === "--dry-run") {
+      opts.dry_run = true;
+      i += 1;
+    } else if (flag === "--purge") {
+      opts.purge = true;
+      i += 1;
+    } else if (flag === "--force") {
+      opts.force = true;
+      i += 1;
+    } else {
+      emitError(`unrecognized arguments: ${tok}`);
+    }
+  }
+  return opts;
+}
+function _uninstall_project(opts) {
+  const project_root = _resolve_project_root(opts.project);
+  const manifest_path2 = manifest_path(project_root);
+  const manifest = read_manifest(manifest_path2);
+  if (manifest === null && !opts.force) {
+    _print(_stderr, `\u274C  no project lockfile at ${manifest_path2}`);
+    _print(_stderr, "    pass --force to uninstall by --tools=<list> without manifest");
+    return 1;
+  }
+  let pool = (manifest ? _listOf(manifest["tools"]) : []).map((e) => String(e["name"] ?? ""));
+  if (!pool.length && opts.tools) {
+    pool = opts.tools.split(",").map((t) => t.trim()).filter((t) => t);
+  }
+  const tools = _filter_tools(pool, opts.tools);
+  if (!tools.length) {
+    _print(_stdout, "\u2139\uFE0F   no tools to uninstall");
+    return 0;
+  }
+  _print(
+    _stdout,
+    `${opts.dry_run ? "[dry-run] " : ""}uninstalling ${tools.length} tool(s) from ${project_root}:`
+  );
+  if (manifest === null) {
+    for (const tool of tools) {
+      const [line] = _remove_project_marker(project_root, tool, { dry_run: opts.dry_run });
+      _print(_stdout, `  \xB7 ${line}`);
+    }
+    return 0;
+  }
+  const version = String(manifest["agent_config_version"] ?? "");
+  const deploy_roots = manifest["deploy_roots"] || null;
+  let tool_entries = [..._listOf(manifest["tools"])];
+  const removed_names = [];
+  for (const tool of tools) {
+    let entry = tool_entries.find((e) => e["name"] === tool) ?? null;
+    if (entry === null) {
+      const [line, removed] = _remove_project_marker(project_root, tool, {
+        dry_run: opts.dry_run
+      });
+      _print(_stdout, `  \xB7 ${line}`);
+      if (removed && !opts.dry_run) {
+        removed_names.push(tool);
+      }
+      continue;
+    }
+    if (!_is_v2_entry(entry)) {
+      const [line, removed] = _remove_project_marker(project_root, tool, {
+        dry_run: opts.dry_run
+      });
+      _print(_stdout, `  \xB7 ${line}`);
+      if (removed && !opts.dry_run) {
+        removed_names.push(tool);
+      }
+      continue;
+    }
+    const files_n = _listOf(entry["files"]).length;
+    const merges_n = _listOf(entry["merged_keys"]).length;
+    _print(
+      _stdout,
+      `  \xB7 ${tool}: v2 uninstall (${files_n} file(s), ${merges_n} merge pointer(s))`
+    );
+    if (!opts.dry_run) {
+      tool_entries = _set_tool_status(
+        manifest_path2,
+        version,
+        tool_entries,
+        tool,
+        "uninstalling",
+        { deploy_roots }
+      );
+      entry = tool_entries.find((e) => e["name"] === tool) ?? entry;
+    }
+    const [warnings, emptied, touched] = _subtract_merged_keys(entry, project_root, {
+      dry_run: opts.dry_run
+    });
+    for (const w of warnings) {
+      _print(_stdout, `      \u26A0\uFE0F  ${w}`);
+    }
+    const [deleted, skipped] = _delete_tool_files(entry, project_root, {
+      dry_run: opts.dry_run,
+      purge: opts.purge,
+      emptied_files: emptied,
+      touched_files: touched
+    });
+    for (const d of deleted) {
+      _print(_stdout, `      \u2713  ${d}`);
+    }
+    for (const s of skipped) {
+      _print(_stdout, `      \u21B7  ${s}`);
+    }
+    if (!opts.dry_run) {
+      removed_names.push(tool);
+    }
+  }
+  if (removed_names.length && !opts.dry_run) {
+    const remaining = tool_entries.filter((e) => !removed_names.includes(String(e["name"])));
+    write_manifest(manifest_path2, version, remaining, { deploy_roots });
+    _print(_stdout, `\u2705  manifest updated (${removed_names.length} entries removed)`);
+  }
+  return 0;
+}
+function _uninstall_global(opts) {
+  const lock_path = lockfile_path();
+  const write_path = lockfile_write_path();
+  const lock = read_lockfile(lock_path);
+  if (lock === null && !opts.force) {
+    _print(_stderr, `\u274C  no global lockfile at ${lock_path}`);
+    return 1;
+  }
+  let pool = lock ? [...lock.tools ?? []] : [];
+  if (!pool.length && opts.tools) {
+    pool = opts.tools.split(",").map((t) => t.trim()).filter((t) => t);
+  }
+  const tools = _filter_tools(pool, opts.tools);
+  if (!tools.length) {
+    _print(_stdout, "\u2139\uFE0F   no tools to uninstall");
+    return 0;
+  }
+  _print(
+    _stdout,
+    `${opts.dry_run ? "[dry-run] " : ""}uninstalling ${tools.length} tool(s) from global scope:`
+  );
+  const removed_names = [];
+  for (const tool of tools) {
+    const [line, removed] = _remove_global_content(tool, {
+      dry_run: opts.dry_run,
+      purge: opts.purge
+    });
+    _print(_stdout, `  \xB7 ${line}`);
+    if (removed && !opts.dry_run) {
+      removed_names.push(tool);
+    }
+  }
+  if (tools.includes("claude-code")) {
+    const settings_path = path.join(os.homedir(), ".claude", "settings.json");
+    if (opts.dry_run) {
+      _print(_stdout, `  \xB7 claude-code: would remove managed hooks from ${settings_path}`);
+    } else {
+      try {
+        const res = remove_managed_hooks(settings_path);
+        if (res.changed) {
+          _print(
+            _stdout,
+            `  \xB7 claude-code: removed managed hooks (${res.events.join(", ")})`
+          );
+        }
+      } catch (e) {
+        _print(_stderr, `\u26A0\uFE0F  claude-code: managed-hook removal skipped \u2014 ${String(e)}`);
+      }
+    }
+  }
+  if (lock !== null && !opts.dry_run) {
+    const remaining = (lock.tools ?? []).filter((t) => !tools.includes(t));
+    const version = String(lock["agent_config_version"] ?? "");
+    if (remaining.length) {
+      write_lockfile(version, remaining, { path: write_path });
+      if (lock_path !== write_path) {
+        try {
+          fs.unlinkSync(lock_path);
+        } catch {
+        }
+      }
+      _print(
+        _stdout,
+        `\u2705  lockfile updated (${tools.length} entries removed, ${remaining.length} kept)`
+      );
+    } else {
+      const targets = lock_path === write_path ? [write_path] : [lock_path, write_path];
+      for (const target of targets) {
+        try {
+          fs.unlinkSync(target);
+        } catch {
+        }
+      }
+      _print(_stdout, `\u2705  lockfile deleted (${write_path})`);
+    }
+  }
+  return 0;
+}
+function main(argv = null) {
+  const opts = _parse(argv !== null ? [...argv] : process.argv.slice(2));
+  if (opts.global_mode) {
+    return _uninstall_global(opts);
+  }
+  return _uninstall_project(opts);
+}
+var _HERE = fileURLToPath(import.meta.url);
+function _isCliEntry() {
+  if (process.argv[1] === void 0) {
+    return false;
+  }
+  const argvUrl = pathToFileURL(path.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) {
+    return true;
+  }
+  try {
+    const here = fs.realpathSync(fileURLToPath(import.meta.url));
+    const argv = fs.realpathSync(path.resolve(process.argv[1]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry() || process.argv[1] === _HERE) {
+  try {
+    process.exitCode = main(process.argv.slice(2));
+  } catch (exc) {
+    if (exc instanceof ArgparseExit) {
+      process.exitCode = exc.code;
+    } else {
+      throw exc;
+    }
+  }
+}
+export {
+  main
+};