@datarails-ai/dr-cli 0.0.1-locked → 1.6.70

package/dist/skills/validate-workato-migration/scripts/compare_files.py

@@ -0,0 +1,255 @@
+"""Byte-compare Workato filebox versions against DRIP (dr-connectors) staging versions.
+
+Usage:
+    python compare_files.py <manifest.json> [--report report.md]
+    python compare_files.py --pair <workato.csv> <staging.csv>
+
+manifest.json is a list of pairs. Relative paths resolve against the manifest's own folder:
+    [{"name": "Shifts / Jarana Aventura / 2026-09-16",
+      "workato": "wk/617001_39532879.csv", "workato_version": 39532879,
+      "staging": "st/700001_39800001.csv", "staging_version": 39800001}, ...]
+
+The pass rule is BYTE-IDENTICAL (sha256 equal). On any mismatch the script explains
+WHY the bytes differ (encoding/BOM, line endings, trailing newline, header, rows,
+cells, quoting-only), so the operator can decide what to change in the connector.
+It never modifies anything. Exit code 0 = every pair identical, 1 = any mismatch/missing or no pairs.
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import hashlib
+import io
+import json
+import sys
+from collections import Counter
+from pathlib import Path
+
+MAX_EXAMPLES = 10
+MAX_VALUE_CHARS = 80
+# Workato/connector CSVs can carry large cells (embedded JSON); the default 128 KiB limit raises
+# csv.Error. 2**27 stays inside a 32-bit C long, so it is safe on Windows too.
+csv.field_size_limit(2**27)
+
+
+def sha256(data: bytes) -> str:
+    return hashlib.sha256(data).hexdigest()
+
+
+def line_ending(data: bytes) -> str:
+    crlf = data.count(b"\r\n")
+    lf = data.count(b"\n") - crlf
+    if crlf and lf:
+        return f"mixed (CRLF={crlf}, LF={lf})"
+    return "CRLF" if crlf else ("LF" if lf else "none")
+
+
+def decode(data: bytes) -> tuple[str, str]:
+    if data.startswith(b"\xef\xbb\xbf"):
+        return data[3:].decode("utf-8", errors="replace"), "utf-8-sig (BOM)"
+    try:
+        return data.decode("utf-8"), "utf-8"
+    except UnicodeDecodeError:
+        return data.decode("latin-1"), "NOT utf-8 (decoded as latin-1)"
+
+
+def parse(text: str) -> tuple[list[list[str]] | None, str | None]:
+    """Parsed rows, or (None, reason) when the text isn't parseable CSV."""
+    try:
+        return list(csv.reader(io.StringIO(text, newline=""), strict=True)), None
+    except csv.Error as exc:
+        return None, str(exc)
+
+
+def short(value: object) -> str:
+    """repr() of an example value, truncated so one huge cell can't flood the report."""
+    text = repr(value)
+    if len(text) <= MAX_VALUE_CHARS:
+        return text
+    return f"{text[:MAX_VALUE_CHARS]}... ({len(str(value))} chars)"
+
+
+def multiset_diff(a: list, b: list) -> tuple[list, list]:
+    """Items only in a / only in b, respecting multiplicity."""
+    ca, cb = Counter(a), Counter(b)
+    return list((ca - cb).elements()), list((cb - ca).elements())
+
+
+def diagnose(wk: bytes, st: bytes) -> list[str]:
+    notes: list[str] = []
+    wk_text, wk_enc = decode(wk)
+    st_text, st_enc = decode(st)
+    if wk_enc != st_enc:
+        notes.append(f"encoding: workato={wk_enc}, staging={st_enc}")
+    if line_ending(wk) != line_ending(st):
+        notes.append(
+            f"line endings: workato={line_ending(wk)}, staging={line_ending(st)}"
+        )
+    wk_nl, st_nl = wk.endswith(b"\n"), st.endswith(b"\n")
+    if wk_nl != st_nl:
+        notes.append(f"trailing newline: workato={wk_nl}, staging={st_nl}")
+
+    wk_rows, wk_err = parse(wk_text)
+    st_rows, st_err = parse(st_text)
+    for side, err in (("workato", wk_err), ("staging", st_err)):
+        if err:
+            notes.append(
+                f"CSV unparseable ({side}): {err}; no header/row/cell diagnosis"
+            )
+    if wk_rows is None or st_rows is None:
+        return notes
+
+    wk_head, st_head = (wk_rows[0] if wk_rows else []), (st_rows[0] if st_rows else [])
+    if wk_head != st_head:
+        missing, extra = multiset_diff(wk_head, st_head)
+        if missing or extra:
+            notes.append(
+                f"header differs: missing in staging={missing}, extra in staging={extra}"
+            )
+        else:
+            notes.append(
+                f"header column ORDER differs: workato={wk_head} staging={st_head}"
+            )
+
+    wk_body, st_body = wk_rows[1:], st_rows[1:]
+    if len(wk_body) != len(st_body):
+        # A positional diff would cascade after the first inserted/deleted row, so report the
+        # multiset difference instead.
+        notes.append(f"row count: workato={len(wk_body)}, staging={len(st_body)}")
+        only_wk, only_st = multiset_diff(
+            list(map(tuple, wk_body)), list(map(tuple, st_body))
+        )
+        notes.append(
+            f"rows only in workato: {len(only_wk)}, rows only in staging: {len(only_st)}"
+        )
+        for label, rows in (("only in workato", only_wk), ("only in staging", only_st)):
+            for row in rows[:MAX_EXAMPLES]:
+                notes.append(f"  {label}: {short(list(row))}")
+    elif wk_body != st_body and Counter(map(tuple, wk_body)) == Counter(
+        map(tuple, st_body)
+    ):
+        notes.append("same rows, different ORDER")
+    else:
+        cell_diffs = []
+        for i, (a, b) in enumerate(zip(wk_body, st_body), start=2):
+            for j in range(max(len(a), len(b))):
+                va = a[j] if j < len(a) else "<missing>"
+                vb = b[j] if j < len(b) else "<missing>"
+                if va != vb:
+                    col = wk_head[j] if j < len(wk_head) else f"#{j}"
+                    cell_diffs.append((i, col, va, vb))
+        if cell_diffs:
+            by_col = Counter(col for _, col, _, _ in cell_diffs)
+            notes.append(
+                f"cell diffs: {len(cell_diffs)} total, by column {dict(by_col)}"
+            )
+            for i, col, va, vb in cell_diffs[:MAX_EXAMPLES]:
+                notes.append(
+                    f"  row {i} [{col}]: workato={short(va)} staging={short(vb)}"
+                )
+
+    if wk_rows == st_rows and not notes:
+        notes.append(
+            "parsed CSV values are IDENTICAL - difference is quoting/escaping only "
+            '(e.g. Workato writes empty cells as ""). Match Workato\'s quoting in the connector.'
+        )
+    elif wk_rows == st_rows:
+        notes.append(
+            "parsed CSV values are identical apart from the byte-level notes above"
+        )
+    if not notes:
+        notes.append(
+            "bytes differ but no specific cause found - inspect with a hex diff"
+        )
+    return notes
+
+
+def compare(entry: dict, wk_path: Path, st_path: Path) -> dict:
+    res = {
+        "name": entry.get("name", wk_path.name),
+        "workato": str(wk_path),
+        "staging": str(st_path),
+        "workato_version": entry.get("workato_version", "-"),
+        "staging_version": entry.get("staging_version", "-"),
+    }
+    for side, p in (("workato", wk_path), ("staging", st_path)):
+        if not p.is_file():
+            res.update(status="MISSING", notes=[f"{side} file not found: {p}"])
+            return res
+    wk, st = wk_path.read_bytes(), st_path.read_bytes()
+    res.update(
+        workato_sha256=sha256(wk),
+        staging_sha256=sha256(st),
+        workato_bytes=len(wk),
+        staging_bytes=len(st),
+    )
+    if wk == st:
+        res.update(status="IDENTICAL", notes=[])
+    else:
+        res.update(status="DIFFERENT", notes=diagnose(wk, st))
+    return res
+
+
+def cell(value: object) -> str:
+    return str(value).replace("|", r"\|")
+
+
+def render_report(results: list[dict]) -> str:
+    ok = sum(r["status"] == "IDENTICAL" for r in results)
+    out = [f"# Workato vs DRIP comparison: {ok}/{len(results)} identical", ""]
+    out.append(
+        "| Pair | Status | Workato version | Staging version | Workato bytes | Staging bytes "
+        "| sha256 (workato / staging) |"
+    )
+    out.append("|---|---|---|---|---|---|---|")
+    for r in results:
+        out.append(
+            f"| {cell(r['name'])} | {r['status']} | {r['workato_version']} | {r['staging_version']} "
+            f"| {r.get('workato_bytes', '-')} | {r.get('staging_bytes', '-')} "
+            f"| {r.get('workato_sha256', '-')[:12]} / {r.get('staging_sha256', '-')[:12]} |"
+        )
+    for r in results:
+        if r["notes"]:
+            out += ["", f"## {r['name']} - {r['status']}", ""]
+            out += [
+                f"- {n}" if not n.startswith("  ") else f"  - {n.strip()}"
+                for n in r["notes"]
+            ]
+    return "\n".join(out) + "\n"
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("manifest", nargs="?")
+    ap.add_argument("--pair", nargs=2, metavar=("WORKATO", "STAGING"))
+    ap.add_argument("--report")
+    args = ap.parse_args()
+    if args.pair:
+        base = Path.cwd()
+        pairs = [
+            {
+                "name": Path(args.pair[0]).name,
+                "workato": args.pair[0],
+                "staging": args.pair[1],
+            }
+        ]
+    elif args.manifest:
+        base = Path(args.manifest).resolve().parent
+        pairs = json.loads(Path(args.manifest).read_text(encoding="utf-8"))
+    else:
+        ap.error("pass a manifest or --pair")
+
+    def resolve(p: str) -> Path:
+        return Path(p) if Path(p).is_absolute() else base / p
+
+    results = [compare(p, resolve(p["workato"]), resolve(p["staging"])) for p in pairs]
+    report = render_report(results)
+    if args.report:
+        Path(args.report).write_text(report, encoding="utf-8")
+    sys.stdout.write(report)
+    return 0 if results and all(r["status"] == "IDENTICAL" for r in results) else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/dist/zendeskKb-JPSHVOPH.js

@@ -0,0 +1,243 @@
+#!/usr/bin/env node
+import {
+  extractImageUrls,
+  getArticle,
+  getArticleAttachments,
+  listArticlesInSection,
+  listCategories,
+  listRecentArticles,
+  listSections,
+  search
+} from "./chunk-DWMCBGQH.js";
+
+// src/mcp/servers/zendeskKb.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+// src/mcp/servers/zendeskKbDescriptions.ts
+var SEARCH_KB = `Search the Datarails customer-facing Help Center. Call this BEFORE running \`dr\` commands when the user's request uses product vocabulary the dr-cli surface doesn't mirror directly \u2014 e.g. "why isn't reconciliation pairing", "how does FX translation work in MEC", "what does a 'calc model self-loop' mean". Use the returned article as ground truth, then map to dr verbs. Trigger phrases (non-exhaustive): "why isn't X working", "how does X work in Datarails", "what does X mean", "the customer is asking", "explain X to me". Don't call when: the request is already in dr-cli verbs ("list dashboards in org X"), or you've already searched this turn.`;
+var GET_ARTICLE = 'Fetch one Help Center article by ID. Call when you already have an article ID from a URL the user pasted ("https://support.datarails.com/hc/en-us/articles/12345"), from a prior search_kb call, or from a different tool that referenced an article. Faster than re-searching when you know the ID. Returns the same shape as search_kb items.';
+var FETCH_ARTICLE_MEDIA = "Fetch inline images from an article and return them as image content blocks so you can SEE the screenshots. Call after search_kb / get_article when the article's visual content matters \u2014 comparing what the user describes against what the product UI actually looks like, reading text inside screenshots, identifying which screen the customer is on. Don't call routinely \u2014 most KB questions are answerable from the markdown body alone.";
+var LIST_CATEGORIES = "List the top-level Help Center categories. Useful when the user's question is broad and you want to identify which area of the product the answer lives in before drilling down via list_sections / list_articles_in_section.";
+var LIST_SECTIONS = "List sections within a category (or all sections). Use after list_categories to drill down, or directly when you already know the category_id from a prior call.";
+var LIST_ARTICLES_IN_SECTION = "Enumerate articles in a specific section. Returns metadata only by default \u2014 pass include_bodies=true if you need full markdown content (more tokens). Use when you want to skim everything in one functional area of the product.";
+var LIST_RECENT_ARTICLES = 'Articles updated within the last N days. Call when troubleshooting a feature the customer says is "new" or "just changed" \u2014 the recent updates list often shows the article documenting the change. Metadata only; follow up with get_article for content.';
+var GET_ARTICLE_ATTACHMENTS = 'List ALL attachments on an article (both inline images and non-inline files like PDFs and ZIPs). Use when the user mentions a downloadable artifact ("the template they reference", "the example file"), or when the article body mentions an attachment without inlining it. Returns metadata + URLs only; does not download non-image binaries.';
+
+// src/mcp/servers/zendeskKb.ts
+function jsonText(value) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(value, null, 2) }]
+  };
+}
+function plainText(text) {
+  return { content: [{ type: "text", text }] };
+}
+async function searchKbTool(args) {
+  return jsonText(await search(args));
+}
+async function getArticleTool(args) {
+  const article = await getArticle(args);
+  if (article === null) {
+    return plainText(`Article ${args.article_id} not found in locale '${args.locale ?? "en-us"}'.`);
+  }
+  return jsonText(article);
+}
+var MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+var CONTENT_TYPE_TO_MIME = {
+  "image/png": "image/png",
+  "image/jpeg": "image/jpeg",
+  "image/jpg": "image/jpeg",
+  "image/gif": "image/gif",
+  "image/webp": "image/webp"
+};
+var SUBDOMAIN = process.env.ZENDESK_SUBDOMAIN ?? "datarails";
+var KB_BASE_URL = `https://${SUBDOMAIN}.zendesk.com/api/v2/help_center`;
+function clamp(n, lo, hi) {
+  return Math.max(lo, Math.min(n, hi));
+}
+async function fetchArticleMediaTool(args) {
+  const locale = args.locale ?? "en-us";
+  const limit = clamp(args.limit ?? 5, 1, 10);
+  const r = await fetch(`${KB_BASE_URL}/${locale}/articles/${args.article_id}.json`);
+  if (r.status === 404) {
+    return plainText(`Article ${args.article_id} not found in locale '${locale}'.`);
+  }
+  if (!r.ok) {
+    throw new Error(`HTTP ${r.status} fetching article ${args.article_id}`);
+  }
+  const data = await r.json();
+  const raw = data.article;
+  if (raw === void 0) {
+    return plainText(`Article ${args.article_id} not found.`);
+  }
+  const urls = extractImageUrls(raw.body).slice(0, limit);
+  if (urls.length === 0) {
+    return plainText(`Article ${args.article_id} ('${raw.title ?? ""}') has no inline images.`);
+  }
+  const content = [
+    {
+      type: "text",
+      text: `Article ${args.article_id}: '${raw.title ?? ""}'
+Images (${urls.length}):`
+    }
+  ];
+  for (const url of urls) {
+    try {
+      const ir = await fetch(url, { redirect: "follow" });
+      if (!ir.ok) {
+        content.push({ type: "text", text: `- ${url} (skipped: HTTP ${ir.status})` });
+        continue;
+      }
+      const ct = (ir.headers.get("content-type") ?? "").split(";")[0]?.trim().toLowerCase() ?? "";
+      const mime = CONTENT_TYPE_TO_MIME[ct];
+      if (mime === void 0) {
+        content.push({
+          type: "text",
+          text: `- ${url} (skipped: unsupported type '${ct}')`
+        });
+        continue;
+      }
+      const buf = Buffer.from(await ir.arrayBuffer());
+      if (buf.length > MAX_IMAGE_BYTES) {
+        content.push({
+          type: "text",
+          text: `- ${url} (skipped: ${buf.length} bytes > 5 MB cap)`
+        });
+        continue;
+      }
+      content.push({ type: "text", text: `- ${url}` });
+      content.push({ type: "image", data: buf.toString("base64"), mimeType: mime });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      content.push({ type: "text", text: `- ${url} (skipped: ${msg})` });
+    }
+  }
+  return { content };
+}
+async function listCategoriesTool(args) {
+  return jsonText(await listCategories(args));
+}
+async function listSectionsTool(args) {
+  return jsonText(await listSections(args));
+}
+async function listArticlesInSectionTool(args) {
+  return jsonText(await listArticlesInSection(args));
+}
+async function listRecentArticlesTool(args) {
+  return jsonText(await listRecentArticles(args));
+}
+async function getArticleAttachmentsTool(args) {
+  return jsonText(await getArticleAttachments(args));
+}
+function createServer() {
+  const server = new McpServer({ name: "dr-zendesk-kb", version: "0.1.0" });
+  server.registerTool(
+    "search_kb",
+    {
+      description: SEARCH_KB,
+      inputSchema: {
+        query: z.string(),
+        locale: z.string().default("en-us"),
+        limit: z.number().int().default(5)
+      }
+    },
+    async (args) => searchKbTool(args)
+  );
+  server.registerTool(
+    "get_article",
+    {
+      description: GET_ARTICLE,
+      inputSchema: {
+        article_id: z.number().int(),
+        locale: z.string().default("en-us")
+      }
+    },
+    async (args) => getArticleTool(args)
+  );
+  server.registerTool(
+    "fetch_article_media",
+    {
+      description: FETCH_ARTICLE_MEDIA,
+      inputSchema: {
+        article_id: z.number().int(),
+        locale: z.string().default("en-us"),
+        limit: z.number().int().default(5)
+      }
+    },
+    async (args) => fetchArticleMediaTool(args)
+  );
+  server.registerTool(
+    "list_categories",
+    {
+      description: LIST_CATEGORIES,
+      inputSchema: { locale: z.string().default("en-us") }
+    },
+    async (args) => listCategoriesTool(args)
+  );
+  server.registerTool(
+    "list_sections",
+    {
+      description: LIST_SECTIONS,
+      inputSchema: {
+        category_id: z.number().int().optional(),
+        locale: z.string().default("en-us"),
+        limit: z.number().int().default(50)
+      }
+    },
+    async (args) => listSectionsTool(args)
+  );
+  server.registerTool(
+    "list_articles_in_section",
+    {
+      description: LIST_ARTICLES_IN_SECTION,
+      inputSchema: {
+        section_id: z.number().int(),
+        locale: z.string().default("en-us"),
+        limit: z.number().int().default(25),
+        include_bodies: z.boolean().default(false)
+      }
+    },
+    async (args) => listArticlesInSectionTool(args)
+  );
+  server.registerTool(
+    "list_recent_articles",
+    {
+      description: LIST_RECENT_ARTICLES,
+      inputSchema: {
+        days: z.number().int().default(30),
+        locale: z.string().default("en-us"),
+        limit: z.number().int().default(25)
+      }
+    },
+    async (args) => listRecentArticlesTool(args)
+  );
+  server.registerTool(
+    "get_article_attachments",
+    {
+      description: GET_ARTICLE_ATTACHMENTS,
+      inputSchema: {
+        article_id: z.number().int(),
+        locale: z.string().default("en-us")
+      }
+    },
+    async (args) => getArticleAttachmentsTool(args)
+  );
+  return server;
+}
+async function run() {
+  await createServer().connect(new StdioServerTransport());
+}
+export {
+  createServer,
+  fetchArticleMediaTool,
+  getArticleAttachmentsTool,
+  getArticleTool,
+  listArticlesInSectionTool,
+  listCategoriesTool,
+  listRecentArticlesTool,
+  listSectionsTool,
+  run,
+  searchKbTool
+};

package/package.json

@@ -1,11 +1,58 @@
 {
   "name": "@datarails-ai/dr-cli",
-  "version": "0.0.1-locked",
-  "description": "Reserved namespace. Install from the Datarails JFrog registry, not from npmjs.org.",
-  "private": false,
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/Datarails/dr-cli"
-  },
-  "license": "UNLICENSED"
-}
+  "version": "1.6.70",
+  "description": "Datarails CLI",
+  "type": "module",
+  "engines": {
+    "node": ">=18"
+  },
+  "bin": {
+    "dr": "./dist/cli.js"
+  },
+  "files": [
+    "dist/",
+    "scripts/postinstall.mjs"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@datarails-ai/dr-appspace-cli": "0.9.2",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@napi-rs/keyring": "^1.3.0",
+    "commander": "^12.1.0",
+    "jszip": "^3.10.1",
+    "node-html-parser": "^6.1.13",
+    "open": "^10.1.0",
+    "turndown": "^7.2.4",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "@types/turndown": "^5.0.6",
+    "@typescript-eslint/eslint-plugin": "^8.0.0",
+    "@typescript-eslint/parser": "^8.0.0",
+    "@vitest/coverage-v8": "^2.1.9",
+    "eslint": "^9.7.0",
+    "jsdom": "^29.1.1",
+    "msw": "^2.3.0",
+    "prettier": "^3.3.0",
+    "tsup": "^8.1.0",
+    "tsx": "^4.16.0",
+    "typescript": "^5.5.0",
+    "vitest": "^2.0.0"
+  },
+  "scripts": {
+    "dev": "tsx src/cli.ts",
+    "build": "tsup",
+    "gen:scopes": "tsx scripts/gen-scopes-map.mts",
+    "check:scopes": "tsx scripts/gen-scopes-map.mts --check",
+    "typecheck": "tsc -p tsconfig.build.json --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "postinstall": "node scripts/postinstall.mjs"
+  }
+}

package/scripts/postinstall.mjs

@@ -0,0 +1,91 @@
+// scripts/postinstall.mjs
+//
+// Runs automatically after `npm install -g @datarails-ai/dr-cli` (or any npm install of
+// this package). Copies every embedded skill into:
+//
+//   ~/.claude/skills/<name>/SKILL.md   (Claude Code path — unless the dr-cli
+//                                        plugin manages this machine, below)
+//   ~/.gemini/skills/<name>/SKILL.md   (only when ~/.gemini/ already
+//                                        exists — Gemini CLI path)
+//
+// plus an idempotent managed block in ~/.gemini/GEMINI.md when the Gemini
+// side ran. So every AI-assistant session on this machine picks up the
+// dr-cli skills without manual setup.
+//
+// On a machine where Claude Code or the Claude desktop app has the dr-cli plugin
+// installed, the CLI skips the
+// `~/.claude/skills/` write, prints a notice, and removes the copies an earlier install
+// wrote for every skill an installed dr-cli plugin now serves — only the files each
+// copy's `.dr-cli-manifest.json` lists (see `pluginManagedProbe` and
+// `removeUserSpaceCopy` in src/commands/skill.ts). Two copies make skill dispatch
+// ambiguous. A satellite's copy stays while that satellite is absent. The Gemini
+// mirror is unaffected. `dr skill install ~ --force` writes them anyway.
+//
+// `dr skill install` always overwrites differing on-disk content silently
+// — a refresh on every package upgrade is the contract. Bytes-equal writes
+// short-circuit as a perf optimisation.
+//
+// Failure modes that are intentionally non-fatal:
+//   - dist/cli.js missing (dev install before `pnpm build`) — skip silently
+//   - skill copy returns non-zero — log a warning and let the install
+//     succeed. The user can rerun `dr skill install ~` later.
+//
+// We intentionally do NOT use `process.exit(non-zero)` from this hook,
+// because npm aborts the entire install on a non-zero postinstall exit.
+// Failing to copy a skill shouldn't break the operator's install.
+//
+// Cleaning up removed skills: when a future release drops a skill that
+// previous releases shipped, add an explicit `rm` call here for the
+// orphaned `<home>/.claude/skills/<name>/` directory, kept for ~1–2
+// release cycles before being pruned. Example pattern:
+//
+//   import { rm } from 'node:fs/promises';
+//   import { join } from 'node:path';
+//   await rm(join(target, '.claude', 'skills', '<old-skill-name>'),
+//            { recursive: true, force: true });
+//
+// Files dropped *within* a surviving skill need no such call: each install records
+// a `.dr-cli-manifest.json` per skill and prunes what the previous one listed.
+
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const cli = resolve(here, '..', 'dist', 'cli.js');
+
+if (!existsSync(cli)) {
+  // Dev install before `pnpm build` — nothing to copy from yet.
+  process.exit(0);
+}
+
+const target = homedir();
+const result = spawnSync('node', [cli, 'skill', 'install', target], { stdio: 'inherit' });
+
+if (result.status !== 0) {
+  process.stderr.write(
+    `(dr-cli postinstall: skill copy returned ${result.status} — run \`dr skill install ~\` to retry)\n`,
+  );
+}
+
+// Auto-register every bundled MCP server with Claude Code. Same
+// non-fatal contract as the skill install above: a non-zero exit just
+// prints a warning and lets npm install succeed. The contract is
+// "always overwrite" — a user who manually unregistered an MCP will
+// see it reappear on the next `npm install -g @datarails-ai/dr-cli`, matching the
+// `dr skill install` policy. If a future release drops an MCP, add an
+// explicit `dr mcp unregister <old-name>` line here, kept for ~1–2
+// release cycles before pruning.
+const mcps = ['dr-zendesk-kb'];
+for (const name of mcps) {
+  const mcpResult = spawnSync('node', [cli, 'mcp', 'register', name], { stdio: 'inherit' });
+  if (mcpResult.status !== 0) {
+    process.stderr.write(
+      `(dr-cli postinstall: MCP register ${name} returned ${mcpResult.status} — run \`dr mcp register ${name}\` to retry)\n`,
+    );
+  }
+}
+
+process.exit(0);