@fenglimg/fabric-cli 2.0.0-rc.13 → 2.0.0-rc.15

package/dist/{chunk-OHWQNSLH.js → chunk-SKSYUHKK.js}

@@ -1,31 +1,257 @@
 #!/usr/bin/env node
-import {
-  ClaudeCodeCLIWriter,
-  CursorWriter,
-  createServerEntry,
-  normalizeConfigPath,
-  removeJsonClientConfigEntry,
-  writeJsonClientConfig
-} from "./chunk-X7QPY5KH.js";
 
 // src/config/resolver.ts
-import { existsSync as existsSync3 } from "fs";
-import { join as join3 } from "path";
-import { homedir as homedir3 } from "os";
+import { existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir4 } from "os";
 
 // src/config/claude-code.ts
+import { existsSync as existsSync2 } from "fs";
+import { join as join2, resolve as resolve2 } from "path";
+import { homedir as homedir2, platform } from "os";
+
+// src/config/json.ts
 import { existsSync } from "fs";
-import { join, resolve } from "path";
-import { homedir, platform } from "os";
+import { mkdir, readFile } from "fs/promises";
+import { dirname, join, resolve } from "path";
+import { homedir } from "os";
+import { atomicWriteJson } from "@fenglimg/fabric-shared/node/atomic-write";
+
+// src/config/writer.ts
+function createServerEntry(serverPath) {
+  return {
+    command: process.execPath,
+    args: [serverPath]
+  };
+}
+
+// src/config/json.ts
+function deepMerge(target, source, options = {}) {
+  return deepMergeAtPath(target, source, "", options);
+}
+function deepMergeAtPath(target, source, path, options) {
+  if (options.arrayAppendPaths && options.arrayAppendPaths.includes(path) && Array.isArray(target) && Array.isArray(source)) {
+    return appendArrayWithDedupe(target, source);
+  }
+  if (target === null || typeof target !== "object" || Array.isArray(target) || source === null || typeof source !== "object" || Array.isArray(source)) {
+    return source;
+  }
+  const out = { ...target };
+  for (const key of Object.keys(source)) {
+    const childPath = path === "" ? key : `${path}.${key}`;
+    out[key] = deepMergeAtPath(
+      target[key],
+      source[key],
+      childPath,
+      options
+    );
+  }
+  return out;
+}
+function appendArrayWithDedupe(target, source) {
+  const out = [...target];
+  for (const candidate of source) {
+    if (out.some((existing) => isSameHookEntry(existing, candidate))) {
+      continue;
+    }
+    out.push(candidate);
+  }
+  return out;
+}
+function isSameHookEntry(a, b) {
+  const cmdA = extractHookCommand(a);
+  const cmdB = extractHookCommand(b);
+  if (cmdA !== null && cmdB !== null) {
+    return cmdA === cmdB;
+  }
+  return deepEqual(a, b);
+}
+function extractHookCommand(item) {
+  if (item === null || typeof item !== "object") {
+    return null;
+  }
+  const obj = item;
+  if (typeof obj.command === "string") {
+    return obj.command;
+  }
+  if (Array.isArray(obj.hooks)) {
+    for (const inner of obj.hooks) {
+      if (inner !== null && typeof inner === "object") {
+        const innerObj = inner;
+        if (typeof innerObj.command === "string") {
+          return innerObj.command;
+        }
+      }
+    }
+  }
+  return null;
+}
+function deepEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (a === null || b === null || typeof a !== "object" || typeof b !== "object") {
+    return false;
+  }
+  if (Array.isArray(a) !== Array.isArray(b)) {
+    return false;
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) {
+      return false;
+    }
+    return a.every((value, index) => deepEqual(value, b[index]));
+  }
+  const aObj = a;
+  const bObj = b;
+  const aKeys = Object.keys(aObj);
+  const bKeys = Object.keys(bObj);
+  if (aKeys.length !== bKeys.length) {
+    return false;
+  }
+  return aKeys.every((key) => deepEqual(aObj[key], bObj[key]));
+}
+function expandHome(filePath) {
+  if (filePath === "~") {
+    return homedir();
+  }
+  if (filePath.startsWith("~/")) {
+    return join(homedir(), filePath.slice(2));
+  }
+  return filePath;
+}
+function normalizeConfigPath(filePath) {
+  return resolve(expandHome(filePath));
+}
+async function readJsonConfig(configPath) {
+  try {
+    const raw = await readFile(configPath, "utf8");
+    if (raw.trim().length === 0) {
+      return {};
+    }
+    const parsed = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error(`Expected JSON object in ${configPath}`);
+    }
+    return parsed;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return {};
+    }
+    throw error;
+  }
+}
+async function writeJsonClientConfig(configPath, serverEntry) {
+  const existing = await readJsonConfig(configPath);
+  const merged = deepMerge(existing, { mcpServers: { fabric: serverEntry } });
+  await mkdir(dirname(configPath), { recursive: true });
+  await atomicWriteJson(configPath, merged, { indent: 2 });
+}
+async function removeJsonClientConfigEntry(configPath, serverName) {
+  if (!existsSync(configPath)) {
+    return { status: "skipped", path: configPath, message: "no-config-file" };
+  }
+  let existing;
+  try {
+    existing = await readJsonConfig(configPath);
+  } catch (error) {
+    return {
+      status: "error",
+      path: configPath,
+      message: error instanceof Error ? error.message : String(error)
+    };
+  }
+  const mcpServers = existing.mcpServers;
+  if (mcpServers === void 0 || mcpServers === null || typeof mcpServers !== "object" || Array.isArray(mcpServers)) {
+    return { status: "skipped", path: configPath, message: "no-mcp-servers-object" };
+  }
+  const servers = mcpServers;
+  if (!Object.prototype.hasOwnProperty.call(servers, serverName)) {
+    return { status: "skipped", path: configPath, message: "not-present" };
+  }
+  const nextServers = { ...servers };
+  delete nextServers[serverName];
+  const next = { ...existing, mcpServers: nextServers };
+  try {
+    await mkdir(dirname(configPath), { recursive: true });
+    await atomicWriteJson(configPath, next, { indent: 2 });
+    return { status: "removed", path: configPath };
+  } catch (error) {
+    return {
+      status: "error",
+      path: configPath,
+      message: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+var JsonClientConfigWriter = class {
+  configuredPath;
+  constructor(configuredPath) {
+    this.configuredPath = configuredPath;
+  }
+  async detect(workspaceRoot, overridePath) {
+    const explicitPath = overridePath ?? this.configuredPath;
+    if (explicitPath !== void 0) {
+      return normalizeConfigPath(explicitPath);
+    }
+    const configPath = this.defaultPath(workspaceRoot);
+    return configPath === null ? null : normalizeConfigPath(configPath);
+  }
+  async write(serverPath, workspaceRoot, overridePath) {
+    const configPath = await this.detect(workspaceRoot, overridePath);
+    if (configPath === null) {
+      return;
+    }
+    await writeJsonClientConfig(configPath, createServerEntry(serverPath));
+  }
+  async remove(serverName, workspaceRoot, overridePath) {
+    const configPath = await this.detect(workspaceRoot, overridePath);
+    if (configPath === null) {
+      return { status: "skipped", message: "no-config-path" };
+    }
+    return removeJsonClientConfigEntry(configPath, serverName);
+  }
+};
+var ClaudeCodeCLIWriter = class extends JsonClientConfigWriter {
+  clientKind = "ClaudeCodeCLI";
+  scope;
+  constructor(configuredPath, scope = "project") {
+    super(configuredPath);
+    this.scope = scope;
+  }
+  // Writes to project-level .mcp.json (per Claude Code MCP spec) by default,
+  // or ~/.claude.json for user scope.
+  // Detection still checks ~/.claude to confirm Claude Code is installed.
+  defaultPath(workspaceRoot) {
+    const globalClaudeDir = join(homedir(), ".claude");
+    const projectClaudeDir = join(workspaceRoot, ".claude");
+    if (!existsSync(globalClaudeDir) && !existsSync(projectClaudeDir)) {
+      return null;
+    }
+    return this.scope === "user" ? join(homedir(), ".claude.json") : join(workspaceRoot, ".mcp.json");
+  }
+};
+var CursorWriter = class extends JsonClientConfigWriter {
+  clientKind = "Cursor";
+  constructor(configuredPath) {
+    super(configuredPath);
+  }
+  defaultPath(workspaceRoot) {
+    const cursorDir = join(workspaceRoot, ".cursor");
+    return existsSync(cursorDir) ? join(cursorDir, "mcp.json") : null;
+  }
+};
+
+// src/config/claude-code.ts
 function getClaudeDesktopConfigPath() {
   const os = platform();
   if (os === "darwin") {
-    return join(homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    return join2(homedir2(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
   }
   if (os === "win32") {
-    return join(process.env.APPDATA ?? join(homedir(), "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
+    return join2(process.env.APPDATA ?? join2(homedir2(), "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
   }
-  return join(homedir(), ".config", "Claude", "claude_desktop_config.json");
+  return join2(homedir2(), ".config", "Claude", "claude_desktop_config.json");
 }
 var ClaudeCodeDesktopWriter = class {
   clientKind = "ClaudeCodeDesktop";
@@ -35,7 +261,7 @@ var ClaudeCodeDesktopWriter = class {
   }
   async detect(_workspaceRoot, overridePath) {
     const configPath = normalizeConfigPath(overridePath ?? this.configuredPath ?? getClaudeDesktopConfigPath());
-    return existsSync(configPath) || overridePath !== void 0 || this.configuredPath !== void 0 ? configPath : null;
+    return existsSync2(configPath) || overridePath !== void 0 || this.configuredPath !== void 0 ? configPath : null;
   }
   async write(serverPath, workspaceRoot, overridePath) {
     const configPath = await this.detect(workspaceRoot, overridePath);
@@ -57,17 +283,17 @@ var ClaudeCodeDesktopWriter = class {
 };
 
 // src/config/toml.ts
-import { existsSync as existsSync2 } from "fs";
-import { mkdir, readFile } from "fs/promises";
-import { dirname, join as join2, resolve as resolve2 } from "path";
-import { homedir as homedir2 } from "os";
+import { existsSync as existsSync3 } from "fs";
+import { mkdir as mkdir2, readFile as readFile2 } from "fs/promises";
+import { dirname as dirname2, join as join3, resolve as resolve3 } from "path";
+import { homedir as homedir3 } from "os";
 import { atomicWriteText } from "@fenglimg/fabric-shared/node/atomic-write";
-function expandHome(filePath) {
+function expandHome2(filePath) {
   if (filePath === "~") {
-    return homedir2();
+    return homedir3();
   }
   if (filePath.startsWith("~/")) {
-    return join2(homedir2(), filePath.slice(2));
+    return join3(homedir3(), filePath.slice(2));
   }
   return filePath;
 }
@@ -134,7 +360,7 @@ ${block}`;
 }
 async function readTomlConfigText(configPath) {
   try {
-    return await readFile(configPath, "utf8");
+    return await readFile2(configPath, "utf8");
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
       return "";
@@ -151,10 +377,10 @@ var CodexTOMLConfigWriter = class {
   async detect(_workspaceRoot, overridePath) {
     const explicitPath = overridePath ?? this.configuredPath;
     if (explicitPath !== void 0) {
-      return resolve2(expandHome(explicitPath));
+      return resolve3(expandHome2(explicitPath));
     }
-    const codexDir = join2(homedir2(), ".codex");
-    return existsSync2(codexDir) ? resolve2(join2(codexDir, "config.toml")) : null;
+    const codexDir = join3(homedir3(), ".codex");
+    return existsSync3(codexDir) ? resolve3(join3(codexDir, "config.toml")) : null;
   }
   async write(serverPath, workspaceRoot, overridePath) {
     const configPath = await this.detect(workspaceRoot, overridePath);
@@ -163,7 +389,7 @@ var CodexTOMLConfigWriter = class {
     }
     const rawConfig = await readTomlConfigText(configPath);
     const nextConfig = upsertCodexServerBlock(rawConfig, "fabric", createServerEntry(serverPath));
-    await mkdir(dirname(configPath), { recursive: true });
+    await mkdir2(dirname2(configPath), { recursive: true });
     await atomicWriteText(configPath, nextConfig);
   }
   async remove(serverName, workspaceRoot, overridePath) {
@@ -171,7 +397,7 @@ var CodexTOMLConfigWriter = class {
     if (configPath === null) {
       return { status: "skipped", message: "no-config-path" };
     }
-    if (!existsSync2(configPath)) {
+    if (!existsSync3(configPath)) {
       return { status: "skipped", path: configPath, message: "no-config-file" };
     }
     let rawConfig;
@@ -189,7 +415,7 @@ var CodexTOMLConfigWriter = class {
       return { status: "skipped", path: configPath, message: "not-present" };
     }
     try {
-      await mkdir(dirname(configPath), { recursive: true });
+      await mkdir2(dirname2(configPath), { recursive: true });
       await atomicWriteText(configPath, text);
       return { status: "removed", path: configPath };
     } catch (error) {
@@ -218,25 +444,25 @@ function resolveClients(workspaceRoot, fabricConfig = {}, opts = {}) {
   const claudeMcpScope = opts.claudeMcpScope ?? "project";
   addIfDetected(
     writers,
-    existsSync3(join3(homedir3(), ".claude")) || existsSync3(join3(workspaceRoot, ".claude")),
+    existsSync4(join4(homedir4(), ".claude")) || existsSync4(join4(workspaceRoot, ".claude")),
     (configuredPath) => new ClaudeCodeCLIWriter(configuredPath, claudeMcpScope),
     hasExplicitPath(clientPaths, "claudeCodeCLI") ? clientPaths.claudeCodeCLI : void 0
   );
   addIfDetected(
     writers,
-    existsSync3(getClaudeDesktopConfigPath()),
+    existsSync4(getClaudeDesktopConfigPath()),
     (configuredPath) => new ClaudeCodeDesktopWriter(configuredPath),
     hasExplicitPath(clientPaths, "claudeCodeDesktop") ? clientPaths.claudeCodeDesktop : void 0
   );
   addIfDetected(
     writers,
-    existsSync3(join3(workspaceRoot, ".cursor")),
+    existsSync4(join4(workspaceRoot, ".cursor")),
     (configuredPath) => new CursorWriter(configuredPath),
     hasExplicitPath(clientPaths, "cursor") ? clientPaths.cursor : void 0
   );
   addIfDetected(
     writers,
-    existsSync3(join3(homedir3(), ".codex")),
+    existsSync4(join4(homedir4(), ".codex")),
     (configuredPath) => new CodexTOMLConfigWriter(configuredPath),
     hasExplicitPath(clientPaths, "codexCLI") ? clientPaths.codexCLI : void 0
   );
@@ -244,10 +470,10 @@ function resolveClients(workspaceRoot, fabricConfig = {}, opts = {}) {
 }
 function detectClientSupports(workspaceRoot, fabricConfig = {}) {
   const clientPaths = fabricConfig.clientPaths;
-  const claudeDetected = existsSync3(join3(homedir3(), ".claude")) || existsSync3(join3(workspaceRoot, ".claude"));
-  const claudeDesktopDetected = existsSync3(getClaudeDesktopConfigPath());
-  const cursorDetected = existsSync3(join3(workspaceRoot, ".cursor"));
-  const codexDetected = existsSync3(join3(homedir3(), ".codex"));
+  const claudeDetected = existsSync4(join4(homedir4(), ".claude")) || existsSync4(join4(workspaceRoot, ".claude"));
+  const claudeDesktopDetected = existsSync4(getClaudeDesktopConfigPath());
+  const cursorDetected = existsSync4(join4(workspaceRoot, ".cursor"));
+  const codexDetected = existsSync4(join4(homedir4(), ".codex"));
   return [
     {
       clientKind: "ClaudeCodeCLI",
@@ -305,7 +531,7 @@ function detectClientSupports(workspaceRoot, fabricConfig = {}) {
         skill: true
       },
       installedCapabilities: {
-        hook: existsSync3(join3(workspaceRoot, ".codex", "hooks.json")),
+        hook: existsSync4(join4(workspaceRoot, ".codex", "hooks.json")),
         // v2/rc.2: v1 client-side init skill removed; skill-installation probes
         // will return once rc.2/3/4 introduce the v2 skills (fabric-archive,
         // fabric-review, fabric-import). Until then there is nothing to probe.
@@ -316,6 +542,7 @@ function detectClientSupports(workspaceRoot, fabricConfig = {}) {
 }
 
 export {
+  deepMerge,
   resolveClients,
   detectClientSupports
 };