@fenglimg/fabric-cli 1.8.0-rc.3 → 2.0.0-rc.10

package/dist/chunk-HQLEHH4O.js

@@ -0,0 +1,321 @@
+#!/usr/bin/env node
+import {
+  ClaudeCodeCLIWriter,
+  CursorWriter,
+  createServerEntry,
+  normalizeConfigPath,
+  removeJsonClientConfigEntry,
+  writeJsonClientConfig
+} from "./chunk-AW3G7ZH5.js";
+
+// src/config/resolver.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+
+// src/config/claude-code.ts
+import { existsSync } from "fs";
+import { join, resolve } from "path";
+import { homedir, platform } from "os";
+function getClaudeDesktopConfigPath() {
+  const os = platform();
+  if (os === "darwin") {
+    return join(homedir(), "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 join(homedir(), ".config", "Claude", "claude_desktop_config.json");
+}
+var ClaudeCodeDesktopWriter = class {
+  clientKind = "ClaudeCodeDesktop";
+  configuredPath;
+  constructor(configuredPath) {
+    this.configuredPath = configuredPath;
+  }
+  async detect(_workspaceRoot, overridePath) {
+    const configPath = normalizeConfigPath(overridePath ?? this.configuredPath ?? getClaudeDesktopConfigPath());
+    return existsSync(configPath) || overridePath !== void 0 || this.configuredPath !== void 0 ? configPath : null;
+  }
+  async write(serverPath, workspaceRoot, overridePath) {
+    const configPath = await this.detect(workspaceRoot, overridePath);
+    if (configPath === null) {
+      return;
+    }
+    await writeJsonClientConfig(configPath, {
+      command: process.execPath,
+      args: [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);
+  }
+};
+
+// 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 { atomicWriteText } from "@fenglimg/fabric-shared/node/atomic-write";
+function expandHome(filePath) {
+  if (filePath === "~") {
+    return homedir2();
+  }
+  if (filePath.startsWith("~/")) {
+    return join2(homedir2(), filePath.slice(2));
+  }
+  return filePath;
+}
+function escapeTomlString(value) {
+  return JSON.stringify(value);
+}
+function serializeTomlStringArray(values) {
+  return `[${values.map((value) => escapeTomlString(value)).join(", ")}]`;
+}
+function serializeTomlInlineTable(values) {
+  const entries = Object.entries(values).sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => `${key} = ${escapeTomlString(value)}`);
+  return `{ ${entries.join(", ")} }`;
+}
+function serializeCodexServerBlock(serverName, serverEntry) {
+  const lines = [
+    `[mcp_servers.${serverName}]`,
+    `command = ${escapeTomlString(serverEntry.command)}`,
+    `args = ${serializeTomlStringArray(serverEntry.args)}`
+  ];
+  if (serverEntry.env !== void 0 && Object.keys(serverEntry.env).length > 0) {
+    lines.push(`env = ${serializeTomlInlineTable(serverEntry.env)}`);
+  }
+  return `${lines.join("\n")}
+`;
+}
+function trimTrailingBlankLines(value) {
+  return value.replace(/\s+$/u, "");
+}
+function removeCodexServerBlock(rawConfig, serverName) {
+  const normalized = rawConfig.replace(/\r\n/g, "\n");
+  const escaped = serverName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const legacyPattern = new RegExp(
+    String.raw`\n?\[mcp\.servers\.${escaped}\]\n[\s\S]*?(?=\n\[[^\n]+\]\n|$)`,
+    "g"
+  );
+  const currentPattern = new RegExp(
+    String.raw`\n?\[mcp_servers\.${escaped}\]\n[\s\S]*?(?=\n\[[^\n]+\]\n|$)`,
+    "g"
+  );
+  const withoutLegacy = normalized.replace(legacyPattern, "");
+  const withoutCurrent = withoutLegacy.replace(currentPattern, "");
+  const changed = withoutCurrent !== normalized;
+  const text = changed ? `${trimTrailingBlankLines(withoutCurrent)}
+` : rawConfig;
+  return { text, changed };
+}
+function upsertCodexServerBlock(rawConfig, serverName, serverEntry) {
+  const block = serializeCodexServerBlock(serverName, serverEntry);
+  const normalized = rawConfig.replace(/\r\n/g, "\n");
+  const legacyPattern = new RegExp(String.raw`\n?\[mcp\.servers\.${serverName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\]\n[\s\S]*?(?=\n\[[^\n]+\]\n|$)`, "g");
+  const currentPattern = new RegExp(
+    String.raw`\n?\[mcp_servers\.${serverName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\]\n[\s\S]*?(?=\n\[[^\n]+\]\n|$)`,
+    "g"
+  );
+  const withoutLegacy = normalized.replace(legacyPattern, "");
+  const withoutExisting = withoutLegacy.replace(currentPattern, "");
+  const trimmed = trimTrailingBlankLines(withoutExisting);
+  if (trimmed.length === 0) {
+    return block;
+  }
+  return `${trimmed}
+
+${block}`;
+}
+async function readTomlConfigText(configPath) {
+  try {
+    return await readFile(configPath, "utf8");
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return "";
+    }
+    throw error;
+  }
+}
+var CodexTOMLConfigWriter = class {
+  clientKind = "CodexCLI";
+  configuredPath;
+  constructor(configuredPath) {
+    this.configuredPath = configuredPath;
+  }
+  async detect(_workspaceRoot, overridePath) {
+    const explicitPath = overridePath ?? this.configuredPath;
+    if (explicitPath !== void 0) {
+      return resolve2(expandHome(explicitPath));
+    }
+    const codexDir = join2(homedir2(), ".codex");
+    return existsSync2(codexDir) ? resolve2(join2(codexDir, "config.toml")) : null;
+  }
+  async write(serverPath, workspaceRoot, overridePath) {
+    const configPath = await this.detect(workspaceRoot, overridePath);
+    if (configPath === null) {
+      return;
+    }
+    const rawConfig = await readTomlConfigText(configPath);
+    const nextConfig = upsertCodexServerBlock(rawConfig, "fabric", createServerEntry(serverPath));
+    await mkdir(dirname(configPath), { recursive: true });
+    await atomicWriteText(configPath, nextConfig);
+  }
+  async remove(serverName, workspaceRoot, overridePath) {
+    const configPath = await this.detect(workspaceRoot, overridePath);
+    if (configPath === null) {
+      return { status: "skipped", message: "no-config-path" };
+    }
+    if (!existsSync2(configPath)) {
+      return { status: "skipped", path: configPath, message: "no-config-file" };
+    }
+    let rawConfig;
+    try {
+      rawConfig = await readTomlConfigText(configPath);
+    } catch (error) {
+      return {
+        status: "error",
+        path: configPath,
+        message: error instanceof Error ? error.message : String(error)
+      };
+    }
+    const { text, changed } = removeCodexServerBlock(rawConfig, serverName);
+    if (!changed) {
+      return { status: "skipped", path: configPath, message: "not-present" };
+    }
+    try {
+      await mkdir(dirname(configPath), { recursive: true });
+      await atomicWriteText(configPath, text);
+      return { status: "removed", path: configPath };
+    } catch (error) {
+      return {
+        status: "error",
+        path: configPath,
+        message: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+};
+
+// src/config/resolver.ts
+import { clientPathsSchema, fabricConfigSchema } from "@fenglimg/fabric-shared";
+function hasExplicitPath(clientPaths, key) {
+  return typeof clientPaths?.[key] === "string" && clientPaths[key].trim().length > 0;
+}
+function addIfDetected(writers, detected, createWriter, configuredPath) {
+  if (configuredPath !== void 0 || detected) {
+    writers.push(createWriter(configuredPath));
+  }
+}
+function resolveClients(workspaceRoot, fabricConfig = {}, opts = {}) {
+  const clientPaths = fabricConfig.clientPaths;
+  const writers = [];
+  const claudeMcpScope = opts.claudeMcpScope ?? "project";
+  addIfDetected(
+    writers,
+    existsSync3(join3(homedir3(), ".claude")) || existsSync3(join3(workspaceRoot, ".claude")),
+    (configuredPath) => new ClaudeCodeCLIWriter(configuredPath, claudeMcpScope),
+    hasExplicitPath(clientPaths, "claudeCodeCLI") ? clientPaths.claudeCodeCLI : void 0
+  );
+  addIfDetected(
+    writers,
+    existsSync3(getClaudeDesktopConfigPath()),
+    (configuredPath) => new ClaudeCodeDesktopWriter(configuredPath),
+    hasExplicitPath(clientPaths, "claudeCodeDesktop") ? clientPaths.claudeCodeDesktop : void 0
+  );
+  addIfDetected(
+    writers,
+    existsSync3(join3(workspaceRoot, ".cursor")),
+    (configuredPath) => new CursorWriter(configuredPath),
+    hasExplicitPath(clientPaths, "cursor") ? clientPaths.cursor : void 0
+  );
+  addIfDetected(
+    writers,
+    existsSync3(join3(homedir3(), ".codex")),
+    (configuredPath) => new CodexTOMLConfigWriter(configuredPath),
+    hasExplicitPath(clientPaths, "codexCLI") ? clientPaths.codexCLI : void 0
+  );
+  return writers;
+}
+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"));
+  return [
+    {
+      clientKind: "ClaudeCodeCLI",
+      label: "Claude Code CLI",
+      detected: claudeDetected || hasExplicitPath(clientPaths, "claudeCodeCLI"),
+      bootstrapTargetPath: ".fabric/bootstrap/README.md",
+      configPath: "project .claude/settings.json",
+      capabilities: {
+        bootstrap: true,
+        mcp: true,
+        hook: true,
+        skill: true
+      },
+      installedCapabilities: {
+        hook: true,
+        skill: true
+      }
+    },
+    {
+      clientKind: "ClaudeCodeDesktop",
+      label: "Claude Code Desktop",
+      detected: claudeDesktopDetected || hasExplicitPath(clientPaths, "claudeCodeDesktop"),
+      bootstrapTargetPath: ".fabric/bootstrap/README.md",
+      configPath: "desktop Claude config",
+      capabilities: {
+        bootstrap: true,
+        mcp: true,
+        hook: false,
+        skill: false
+      }
+    },
+    {
+      clientKind: "Cursor",
+      label: "Cursor",
+      detected: cursorDetected || hasExplicitPath(clientPaths, "cursor"),
+      bootstrapTargetPath: ".fabric/bootstrap/README.md",
+      configPath: ".cursor/mcp.json",
+      capabilities: {
+        bootstrap: true,
+        mcp: true,
+        hook: false,
+        skill: false
+      }
+    },
+    {
+      clientKind: "CodexCLI",
+      label: "Codex CLI",
+      detected: codexDetected || hasExplicitPath(clientPaths, "codexCLI"),
+      bootstrapTargetPath: ".fabric/bootstrap/README.md",
+      configPath: "~/.codex/config.toml",
+      capabilities: {
+        bootstrap: true,
+        mcp: true,
+        hook: true,
+        skill: true
+      },
+      installedCapabilities: {
+        hook: existsSync3(join3(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.
+        skill: false
+      }
+    }
+  ];
+}
+
+export {
+  resolveClients,
+  detectClientSupports
+};