@stevenzxs/ccharness 1.0.0

package/dist/chunk-91ttqm6v.js

@@ -0,0 +1,213 @@
+// @bun
+import {
+  init_sessionStoragePortable
+} from "./chunk-8rxpkg7r.js";
+import {
+  getPlatform,
+  init_platform
+} from "./chunk-rey3eqc4.js";
+import {
+  init_memoize as init_memoize2,
+  memoizeWithLRU
+} from "./chunk-rv6qkhq1.js";
+import {
+  execSync_DEPRECATED,
+  init_execSyncWrapper
+} from "./chunk-rgp8gbze.js";
+import {
+  getCwd,
+  init_cwd
+} from "./chunk-03eejbgx.js";
+import {
+  getFsImplementation,
+  init_debug,
+  init_fsOperations,
+  logForDebugging
+} from "./chunk-7fxg2tat.js";
+import {
+  init_memoize,
+  memoize_default
+} from "./chunk-aheacmqy.js";
+import {
+  __esm
+} from "./chunk-hhsxm2yr.js";
+
+// src/utils/windowsPaths.ts
+import * as path from "path";
+import * as pathWin32 from "path/win32";
+function checkPathExists(path2) {
+  try {
+    execSync_DEPRECATED(`dir "${path2}"`, { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function findExecutable(executable) {
+  if (executable === "git") {
+    const defaultLocations = [
+      "C:\\Program Files\\Git\\cmd\\git.exe",
+      "C:\\Program Files (x86)\\Git\\cmd\\git.exe"
+    ];
+    for (const location of defaultLocations) {
+      if (checkPathExists(location)) {
+        return location;
+      }
+    }
+  }
+  try {
+    const result = execSync_DEPRECATED(`where.exe ${executable}`, {
+      stdio: "pipe",
+      encoding: "utf8"
+    }).trim();
+    const paths = result.split(`\r
+`).filter(Boolean);
+    const cwd = getCwd().toLowerCase();
+    for (const candidatePath of paths) {
+      const normalizedPath = path.resolve(candidatePath).toLowerCase();
+      const pathDir = path.dirname(normalizedPath).toLowerCase();
+      if (pathDir === cwd || normalizedPath.startsWith(cwd + path.sep)) {
+        logForDebugging(`Skipping potentially malicious executable in current directory: ${candidatePath}`);
+        continue;
+      }
+      return candidatePath;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function setShellIfWindows() {
+  if (getPlatform() === "windows") {
+    const gitBashPath = findGitBashPath();
+    process.env.SHELL = gitBashPath;
+    logForDebugging(`Using bash path: "${gitBashPath}"`);
+  }
+}
+var findGitBashPath, windowsPathToPosixPath, posixPathToWindowsPath;
+var init_windowsPaths = __esm(() => {
+  init_memoize();
+  init_cwd();
+  init_debug();
+  init_execSyncWrapper();
+  init_memoize2();
+  init_platform();
+  findGitBashPath = memoize_default(() => {
+    if (process.env.CLAUDE_CODE_GIT_BASH_PATH) {
+      if (checkPathExists(process.env.CLAUDE_CODE_GIT_BASH_PATH)) {
+        return process.env.CLAUDE_CODE_GIT_BASH_PATH;
+      }
+      console.error(`Claude Code was unable to find CLAUDE_CODE_GIT_BASH_PATH path "${process.env.CLAUDE_CODE_GIT_BASH_PATH}"`);
+      process.exit(1);
+    }
+    const gitPath = findExecutable("git");
+    if (gitPath) {
+      const bashPath = pathWin32.join(gitPath, "..", "..", "bin", "bash.exe");
+      if (checkPathExists(bashPath)) {
+        return bashPath;
+      }
+    }
+    console.error("Claude Code on Windows requires git-bash (https://git-scm.com/downloads/win). If installed but not in PATH, set environment variable pointing to your bash.exe, similar to: CLAUDE_CODE_GIT_BASH_PATH=C:\\Program Files\\Git\\bin\\bash.exe");
+    process.exit(1);
+  });
+  windowsPathToPosixPath = memoizeWithLRU((windowsPath) => {
+    if (windowsPath.startsWith("\\\\")) {
+      return windowsPath.replace(/\\/g, "/");
+    }
+    const match = windowsPath.match(/^([A-Za-z]):[/\\]/);
+    if (match) {
+      const driveLetter = match[1].toLowerCase();
+      return "/" + driveLetter + windowsPath.slice(2).replace(/\\/g, "/");
+    }
+    return windowsPath.replace(/\\/g, "/");
+  }, (p) => p, 500);
+  posixPathToWindowsPath = memoizeWithLRU((posixPath) => {
+    if (posixPath.startsWith("//")) {
+      return posixPath.replace(/\//g, "\\");
+    }
+    const cygdriveMatch = posixPath.match(/^\/cygdrive\/([A-Za-z])(\/|$)/);
+    if (cygdriveMatch) {
+      const driveLetter = cygdriveMatch[1].toUpperCase();
+      const rest = posixPath.slice(("/cygdrive/" + cygdriveMatch[1]).length);
+      return driveLetter + ":" + (rest || "\\").replace(/\//g, "\\");
+    }
+    const driveMatch = posixPath.match(/^\/([A-Za-z])(\/|$)/);
+    if (driveMatch) {
+      const driveLetter = driveMatch[1].toUpperCase();
+      const rest = posixPath.slice(2);
+      return driveLetter + ":" + (rest || "\\").replace(/\//g, "\\");
+    }
+    return posixPath.replace(/\//g, "\\");
+  }, (p) => p, 500);
+});
+
+// src/utils/path.ts
+import { homedir } from "os";
+import { dirname as dirname2, isAbsolute, join as join2, normalize, relative, resolve as resolve2 } from "path";
+function expandPath(path2, baseDir) {
+  const actualBaseDir = baseDir ?? getCwd() ?? getFsImplementation().cwd();
+  if (typeof path2 !== "string") {
+    throw new TypeError(`Path must be a string, received ${typeof path2}`);
+  }
+  if (typeof actualBaseDir !== "string") {
+    throw new TypeError(`Base directory must be a string, received ${typeof actualBaseDir}`);
+  }
+  if (path2.includes("\x00") || actualBaseDir.includes("\x00")) {
+    throw new Error("Path contains null bytes");
+  }
+  const trimmedPath = path2.trim();
+  if (!trimmedPath) {
+    return normalize(actualBaseDir).normalize("NFC");
+  }
+  if (trimmedPath === "~") {
+    return homedir().normalize("NFC");
+  }
+  if (trimmedPath.startsWith("~/")) {
+    return join2(homedir(), trimmedPath.slice(2)).normalize("NFC");
+  }
+  let processedPath = trimmedPath;
+  if (getPlatform() === "windows" && trimmedPath.match(/^\/[a-z]\//i)) {
+    try {
+      processedPath = posixPathToWindowsPath(trimmedPath);
+    } catch {
+      processedPath = trimmedPath;
+    }
+  }
+  if (isAbsolute(processedPath)) {
+    return normalize(processedPath).normalize("NFC");
+  }
+  return resolve2(actualBaseDir, processedPath).normalize("NFC");
+}
+function toRelativePath(absolutePath) {
+  const relativePath = relative(getCwd(), absolutePath);
+  return relativePath.startsWith("..") ? absolutePath : relativePath;
+}
+function getDirectoryForPath(path2) {
+  const absolutePath = expandPath(path2);
+  if (absolutePath.startsWith("\\\\") || absolutePath.startsWith("//")) {
+    return dirname2(absolutePath);
+  }
+  try {
+    const stats = getFsImplementation().statSync(absolutePath);
+    if (stats.isDirectory()) {
+      return absolutePath;
+    }
+  } catch {}
+  return dirname2(absolutePath);
+}
+function containsPathTraversal(path2) {
+  return /(?:^|[\\/])\.\.(?:[\\/]|$)/.test(path2);
+}
+function normalizePathForConfigKey(path2) {
+  const normalized = normalize(path2);
+  return normalized.replace(/\\/g, "/");
+}
+var init_path = __esm(() => {
+  init_cwd();
+  init_fsOperations();
+  init_platform();
+  init_windowsPaths();
+  init_sessionStoragePortable();
+});
+
+export { setShellIfWindows, findGitBashPath, windowsPathToPosixPath, posixPathToWindowsPath, init_windowsPaths, expandPath, toRelativePath, getDirectoryForPath, containsPathTraversal, normalizePathForConfigKey, init_path };

package/dist/chunk-935nrvdb.js

@@ -0,0 +1,13 @@
+// @bun
+import {
+  __esm
+} from "./chunk-hhsxm2yr.js";
+
+// src/utils/swarm/constants.ts
+function getSwarmSocketName() {
+  return `claude-swarm-${process.pid}`;
+}
+var TEAM_LEAD_NAME = "team-lead", SWARM_SESSION_NAME = "claude-swarm", SWARM_VIEW_WINDOW_NAME = "swarm-view", TMUX_COMMAND = "tmux", HIDDEN_SESSION_NAME = "claude-hidden", TEAMMATE_COMMAND_ENV_VAR = "CLAUDE_CODE_TEAMMATE_COMMAND";
+var init_constants = () => {};
+
+export { TEAM_LEAD_NAME, SWARM_SESSION_NAME, SWARM_VIEW_WINDOW_NAME, TMUX_COMMAND, HIDDEN_SESSION_NAME, getSwarmSocketName, TEAMMATE_COMMAND_ENV_VAR, init_constants };

package/dist/chunk-93a5my23.js

@@ -0,0 +1,8 @@
+// @bun
+import"./chunk-hhsxm2yr.js";
+
+// src/environment-runner/main.ts
+var environmentRunnerMain = () => Promise.resolve();
+export {
+  environmentRunnerMain
+};

package/dist/chunk-95nc5pzz.js

@@ -0,0 +1,7 @@
+// @bun
+import {
+  require_dist1 as require_dist
+} from "./chunk-s84xxjq6.js";
+import"./chunk-y8jghf88.js";
+import"./chunk-hhsxm2yr.js";
+export default require_dist();

package/dist/chunk-96p9781m.js

@@ -0,0 +1,123 @@
+// @bun
+import {
+  McpStdioServerConfigSchema,
+  init_json,
+  init_types,
+  safeParseJSON
+} from "./chunk-c13w1efw.js";
+import"./chunk-d82xy2py.js";
+import {
+  SUPPORTED_PLATFORMS,
+  getPlatform,
+  init_platform
+} from "./chunk-rey3eqc4.js";
+import"./chunk-ma7acpng.js";
+import"./chunk-rv6qkhq1.js";
+import"./chunk-qbg3frga.js";
+import {
+  init_log,
+  logError
+} from "./chunk-mss2zjet.js";
+import"./chunk-m28vg9w4.js";
+import {
+  getErrnoCode,
+  init_errors
+} from "./chunk-7fxg2tat.js";
+import"./chunk-kb3758f7.js";
+import"./chunk-347yx4gw.js";
+import"./chunk-11q9h2zt.js";
+import"./chunk-aheacmqy.js";
+import"./chunk-kv4bdhp2.js";
+import"./chunk-042vrke6.js";
+import"./chunk-hhsxm2yr.js";
+
+// src/utils/claudeDesktop.ts
+init_types();
+init_errors();
+init_json();
+init_log();
+init_platform();
+import { readdir, readFile, stat } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+async function getClaudeDesktopConfigPath() {
+  const platform = getPlatform();
+  if (!SUPPORTED_PLATFORMS.includes(platform)) {
+    throw new Error(`Unsupported platform: ${platform} - Claude Desktop integration only works on macOS and WSL.`);
+  }
+  if (platform === "macos") {
+    return join(homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  }
+  const windowsHome = process.env.USERPROFILE ? process.env.USERPROFILE.replace(/\\/g, "/") : null;
+  if (windowsHome) {
+    const wslPath = windowsHome.replace(/^[A-Z]:/, "");
+    const configPath = `/mnt/c${wslPath}/AppData/Roaming/Claude/claude_desktop_config.json`;
+    try {
+      await stat(configPath);
+      return configPath;
+    } catch {}
+  }
+  try {
+    const usersDir = "/mnt/c/Users";
+    try {
+      const userDirs = await readdir(usersDir, { withFileTypes: true });
+      for (const user of userDirs) {
+        if (user.name === "Public" || user.name === "Default" || user.name === "Default User" || user.name === "All Users") {
+          continue;
+        }
+        const potentialConfigPath = join(usersDir, user.name, "AppData", "Roaming", "Claude", "claude_desktop_config.json");
+        try {
+          await stat(potentialConfigPath);
+          return potentialConfigPath;
+        } catch {}
+      }
+    } catch {}
+  } catch (dirError) {
+    logError(dirError);
+  }
+  throw new Error("Could not find Claude Desktop config file in Windows. Make sure Claude Desktop is installed on Windows.");
+}
+async function readClaudeDesktopMcpServers() {
+  if (!SUPPORTED_PLATFORMS.includes(getPlatform())) {
+    throw new Error("Unsupported platform - Claude Desktop integration only works on macOS and WSL.");
+  }
+  try {
+    const configPath = await getClaudeDesktopConfigPath();
+    let configContent;
+    try {
+      configContent = await readFile(configPath, { encoding: "utf8" });
+    } catch (e) {
+      const code = getErrnoCode(e);
+      if (code === "ENOENT") {
+        return {};
+      }
+      throw e;
+    }
+    const config = safeParseJSON(configContent);
+    if (!config || typeof config !== "object") {
+      return {};
+    }
+    const mcpServers = config.mcpServers;
+    if (!mcpServers || typeof mcpServers !== "object") {
+      return {};
+    }
+    const servers = {};
+    for (const [name, serverConfig] of Object.entries(mcpServers)) {
+      if (!serverConfig || typeof serverConfig !== "object") {
+        continue;
+      }
+      const result = McpStdioServerConfigSchema().safeParse(serverConfig);
+      if (result.success) {
+        servers[name] = result.data;
+      }
+    }
+    return servers;
+  } catch (error) {
+    logError(error);
+    return {};
+  }
+}
+export {
+  readClaudeDesktopMcpServers,
+  getClaudeDesktopConfigPath
+};