@great-arrow/cli 0.1.3 → 0.1.4

package/dist/index.js

@@ -4703,6 +4703,271 @@ var updateCommand = new Command("update").description("Update a todo's status").
 var todoCommand = new Command("todo").description("Manage kanban todos").addCommand(listCommand2).addCommand(createCommand2).addCommand(doneCommand).addCommand(updateCommand);
 var todo_default = todoCommand;
 
+// src/commands/doctor.ts
+import { existsSync } from "node:fs";
+import { copyFile, mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname2, join as join2 } from "node:path";
+
+// src/lib/codex-config.ts
+import { execFileSync } from "node:child_process";
+var CODEX_SERVER_NAME = "great-arrow";
+var CODEX_CLIENT_ID = "codex-cli";
+var SAFE_GLOBAL_MCP_SERVERS = /* @__PURE__ */ new Set([
+  CODEX_SERVER_NAME,
+  "great-arrow-kiro-terminal",
+  "chrome-devtools",
+  "node_repl",
+  "playwright",
+  "postman",
+  "stripe",
+  "vercel",
+  "xcodebuildmcp"
+]);
+function normalizeApiUrl(apiUrl) {
+  return apiUrl.replace(/\/+$/, "");
+}
+function mcpEndpoint(apiUrl) {
+  return `${normalizeApiUrl(apiUrl)}/api/mcp`;
+}
+function tomlEscape(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function detectGitOrigin2(cwd = process.cwd()) {
+  try {
+    const env = { ...process.env };
+    for (const key of Object.keys(env)) {
+      if (key.startsWith("GIT_")) delete env[key];
+    }
+    const url = execFileSync(
+      "git",
+      ["-C", cwd, "remote", "get-url", "origin"],
+      {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        env,
+        timeout: 1e3
+      }
+    ).trim();
+    return url || null;
+  } catch {
+    return null;
+  }
+}
+function repoKey(repoUrl) {
+  if (!repoUrl) return null;
+  const trimmed = repoUrl.trim();
+  if (!trimmed) return null;
+  const scpLike = trimmed.match(/^git@([^:]+):(.+)$/);
+  const asUrl = scpLike ? `https://${scpLike[1]}/${scpLike[2]}` : trimmed.replace(/^ssh:\/\/git@/i, "https://");
+  try {
+    const parsed = new URL(asUrl);
+    const host = parsed.hostname.toLowerCase();
+    let path = parsed.pathname.replace(/^\/+/, "").replace(/\/+$/, "");
+    path = path.replace(/\.git$/i, "").toLowerCase();
+    return path ? `${host}/${path}` : null;
+  } catch {
+    return null;
+  }
+}
+function generateCodexConfigToml(apiUrl, repoUrl) {
+  const repoHeader = repoUrl ? `X-Repo-URL = "${tomlEscape(repoUrl)}"
+` : "";
+  return `[mcp_servers.${CODEX_SERVER_NAME}]
+transport = "streamable_http"
+url = "${tomlEscape(mcpEndpoint(apiUrl))}"
+bearer_token_env_var = "GREAT_ARROW_TOKEN"
+
+[mcp_servers.${CODEX_SERVER_NAME}.http_headers]
+X-MCP-Client = "${CODEX_CLIENT_ID}"
+${repoHeader}`;
+}
+function generateCodexEnv(token) {
+  return `GREAT_ARROW_TOKEN=${token}
+`;
+}
+function extractCodexGreatArrowApiUrl(content) {
+  const text = groupedServerText(splitTomlSections(content)).get(
+    CODEX_SERVER_NAME
+  );
+  if (!text) return null;
+  const match = text.match(/^\s*url\s*=\s*"([^"]+)"\s*$/m);
+  if (!match?.[1]) return null;
+  const url = match[1].trim();
+  return url.endsWith("/api/mcp") ? url.slice(0, -"/api/mcp".length) : url.replace(/\/+$/, "");
+}
+function splitTomlSections(content) {
+  const hasTrailingNewline = content.endsWith("\n");
+  const lines = content.split(/\n/);
+  if (hasTrailingNewline) lines.pop();
+  const sections = [];
+  let table = null;
+  let current = [];
+  const flush = () => {
+    if (current.length === 0) return;
+    sections.push({ table, text: `${current.join("\n")}
+` });
+    current = [];
+  };
+  for (const line of lines) {
+    const match = line.match(/^\s*\[([^\]]+)]\s*$/);
+    if (match) {
+      flush();
+      table = match[1] ?? null;
+    }
+    current.push(line);
+  }
+  flush();
+  return sections;
+}
+function tableServerName(table) {
+  if (!table) return null;
+  const match = table.match(/^mcp_servers\.(?:"([^"]+)"|([^.\s]+))(?:\.|$)/);
+  return match?.[1] ?? match?.[2] ?? null;
+}
+function groupedServerText(sections) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const section of sections) {
+    const server = tableServerName(section.table);
+    if (!server) continue;
+    grouped.set(server, `${grouped.get(server) ?? ""}${section.text}`);
+  }
+  return grouped;
+}
+function removeServerSections(content, servers) {
+  const sections = splitTomlSections(content);
+  return sections.filter((section) => {
+    const server = tableServerName(section.table);
+    return !server || !servers.has(server);
+  }).map((section) => section.text).join("").replace(/\n{3,}/g, "\n\n");
+}
+function upsertCodexServerBlock(existingContent, apiUrl, repoUrl) {
+  const block = generateCodexConfigToml(apiUrl, repoUrl).trimEnd();
+  const withoutGreatArrow = removeServerSections(
+    existingContent,
+    /* @__PURE__ */ new Set([CODEX_SERVER_NAME])
+  ).replace(/\s*$/, "");
+  if (!withoutGreatArrow) return `${block}
+`;
+  return `${withoutGreatArrow}
+
+${block}
+`;
+}
+function extractConfiguredRepoKeys(text) {
+  const keys = /* @__PURE__ */ new Set();
+  const repoSetting = /(?:X-Repo-URL|MEMORY_REPO_URL|GAD_REPO_URL)\s*=\s*"([^"]+)"/gi;
+  for (const match of text.matchAll(repoSetting)) {
+    const key = repoKey(match[1]);
+    if (key) keys.add(key);
+  }
+  const gitUrls = /(?:https:\/\/|ssh:\/\/git@|git@)(?:github\.com|gitlab\.com|bitbucket\.org)[:/][^\s"',\]]+/gi;
+  for (const match of text.matchAll(gitUrls)) {
+    const key = repoKey(match[0]);
+    if (key) keys.add(key);
+  }
+  return [...keys];
+}
+function hasJobbyJobMarker(server, text) {
+  return /jobby\s*job|jobbyjob|jobbyjob\.ai/i.test(`${server}
+${text}`);
+}
+function isUnmanagedServer(server) {
+  return !SAFE_GLOBAL_MCP_SERVERS.has(server);
+}
+function inspectCodexConfig(content, expectedRepoUrl) {
+  const expectedRepoKey = repoKey(expectedRepoUrl);
+  const grouped = groupedServerText(splitTomlSections(content));
+  const serverNames = [...grouped.keys()].sort();
+  const greatArrowText = grouped.get(CODEX_SERVER_NAME) ?? "";
+  const hasGreatArrowServer = grouped.has(CODEX_SERVER_NAME);
+  const greatArrowRepoKeys = extractConfiguredRepoKeys(greatArrowText);
+  const greatArrowHasRepoHeader = Boolean(
+    expectedRepoKey && greatArrowRepoKeys.includes(expectedRepoKey)
+  );
+  const unmanagedServers = serverNames.filter(isUnmanagedServer);
+  const staleRepoServers = [];
+  for (const [server, text] of grouped.entries()) {
+    if (server === CODEX_SERVER_NAME) continue;
+    const keys = extractConfiguredRepoKeys(text);
+    const mismatchedExplicitRepo = expectedRepoKey && keys.length > 0 && !keys.some((key) => key === expectedRepoKey);
+    if (mismatchedExplicitRepo || hasJobbyJobMarker(server, text)) {
+      staleRepoServers.push(server);
+    }
+  }
+  staleRepoServers.sort();
+  const issues = [];
+  issues.push(
+    hasGreatArrowServer ? {
+      code: "great_arrow_present",
+      level: "pass",
+      message: "Codex has a Great Arrow MCP server block."
+    } : {
+      code: "great_arrow_missing",
+      level: "fail",
+      message: "Codex is missing the Great Arrow MCP server block.",
+      hint: "Run `gad mcp install codex` from the repo root."
+    }
+  );
+  if (expectedRepoKey) {
+    issues.push(
+      greatArrowHasRepoHeader ? {
+        code: "repo_header_present",
+        level: "pass",
+        message: `Great Arrow is pinned to ${expectedRepoUrl}.`
+      } : {
+        code: "repo_header_missing",
+        level: "warn",
+        message: "Great Arrow is not pinned with X-Repo-URL.",
+        hint: "Run `gad mcp install codex` from the repo root to add repo routing."
+      }
+    );
+  }
+  if (staleRepoServers.length > 0) {
+    issues.push({
+      code: "stale_repo_servers",
+      level: "fail",
+      message: `Found stale repo-scoped MCP server(s): ${staleRepoServers.join(", ")}.`,
+      hint: "Run `gad doctor codex --enforce` to remove the stale server blocks."
+    });
+  } else {
+    issues.push({
+      code: "no_stale_repo_servers",
+      level: "pass",
+      message: "No stale repo-scoped MCP server blocks found."
+    });
+  }
+  if (unmanagedServers.length > 0) {
+    issues.push({
+      code: "unmanaged_servers",
+      level: "warn",
+      message: `Codex has unmanaged MCP server(s): ${unmanagedServers.join(", ")}.`,
+      hint: "Review these manually if they are not intentionally global."
+    });
+  }
+  return {
+    expectedRepoUrl: expectedRepoUrl ?? null,
+    expectedRepoKey,
+    hasGreatArrowServer,
+    greatArrowHasRepoHeader,
+    unmanagedServers,
+    staleRepoServers,
+    issues
+  };
+}
+function repairCodexConfig(content, staleRepoServers) {
+  if (staleRepoServers.length === 0) {
+    return { content, removedServers: [] };
+  }
+  const removed = [...new Set(staleRepoServers)].sort();
+  const repaired = removeServerSections(content, new Set(removed));
+  return {
+    content: repaired.endsWith("\n") ? repaired : `${repaired}
+`,
+    removedServers: removed
+  };
+}
+
 // src/commands/doctor.ts
 function renderCheck(check, color2) {
   const { status, name, message, hint } = check;
@@ -4841,6 +5106,133 @@ async function checkMcp(auth) {
     };
   }
 }
+function defaultCodexConfigPath() {
+  return join2(homedir2(), ".codex", "config.toml");
+}
+function codexIssuesToChecks(issues) {
+  return issues.map((issue) => {
+    const check = {
+      name: `Codex Config: ${issue.code}`,
+      status: issue.level,
+      message: issue.server ? `${issue.message} (${issue.server})` : issue.message
+    };
+    if (issue.hint) check.hint = issue.hint;
+    return check;
+  });
+}
+function codexCommand() {
+  return new Command("codex").description(
+    "Check Codex MCP config for wrong-repo entries and optional repair"
+  ).option(
+    "--config <path>",
+    "Path to Codex config.toml",
+    defaultCodexConfigPath()
+  ).option(
+    "--expected-repo <url>",
+    "Expected repo URL (defaults to current git origin)"
+  ).option(
+    "--enforce",
+    "Back up config, rewrite Great Arrow repo pin, and remove stale repo-scoped MCP servers"
+  ).option("--json", "Output as JSON").option("--quiet", "Suppress decorative output").option("--no-color", "Disable color output").action(
+    async (options, command) => {
+      const g = globalOutputOpts(command);
+      const color2 = createColor(g.noColor);
+      const fmt = createFormatter({
+        json: g.json,
+        quiet: g.quiet,
+        isTTY: isTTY(),
+        noColor: g.noColor
+      });
+      const configPath = options.config ?? defaultCodexConfigPath();
+      const expectedRepoUrl = options.expectedRepo ?? detectGitOrigin2();
+      let content = existsSync(configPath) ? await readFile2(configPath, "utf8") : "";
+      let backupPath = null;
+      let removedServers = [];
+      if (options.enforce) {
+        const apiUrl = extractCodexGreatArrowApiUrl(content) ?? (await resolveAuth()).apiUrl;
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+        await mkdir2(dirname2(configPath), { recursive: true });
+        if (content.trim()) {
+          backupPath = `${configPath}.bak.${timestamp}`;
+          await copyFile(configPath, backupPath);
+        }
+        content = upsertCodexServerBlock(content, apiUrl, expectedRepoUrl);
+        const preRepair = inspectCodexConfig(content, expectedRepoUrl);
+        const repaired = repairCodexConfig(
+          content,
+          preRepair.staleRepoServers
+        );
+        content = repaired.content;
+        removedServers = repaired.removedServers;
+        await writeFile2(configPath, content, "utf8");
+      }
+      const inspection = inspectCodexConfig(content, expectedRepoUrl);
+      const checks = codexIssuesToChecks(inspection.issues);
+      if (options.enforce) {
+        const enforcementCheck = {
+          name: "Codex Config: enforcement",
+          status: "pass",
+          message: removedServers.length > 0 ? `Removed stale server(s): ${removedServers.join(", ")}` : "No stale server blocks needed removal"
+        };
+        if (backupPath) {
+          enforcementCheck.hint = `Backup written to ${backupPath}`;
+        }
+        checks.push(enforcementCheck);
+      }
+      if (g.json) {
+        process.stdout.write(
+          JSON.stringify(
+            {
+              configPath,
+              expectedRepoUrl,
+              enforce: Boolean(options.enforce),
+              backupPath,
+              removedServers,
+              inspection,
+              checks
+            },
+            null,
+            2
+          ) + "\n"
+        );
+      } else {
+        if (!expectedRepoUrl) {
+          process.stdout.write(
+            renderCheck(
+              {
+                name: "Codex Config: repo detection",
+                status: "warn",
+                message: "No git origin detected for this directory",
+                hint: "Run from a repo root or pass --expected-repo."
+              },
+              color2
+            ) + "\n"
+          );
+        }
+        for (const check of checks) {
+          process.stdout.write(renderCheck(check, color2) + "\n");
+        }
+        if (!g.quiet) {
+          const failed = checks.filter((c) => c.status === "fail").length;
+          const warned = checks.filter((c) => c.status === "warn").length;
+          process.stdout.write("\n");
+          if (failed === 0 && warned === 0) {
+            fmt.success("Codex config guard passed");
+          } else if (failed === 0) {
+            fmt.warn(`Codex config guard passed with ${warned} warning(s)`);
+          } else {
+            fmt.error(
+              `Codex config guard found ${failed} failure(s), ${warned} warning(s)`
+            );
+          }
+        }
+      }
+      if (checks.some((check) => check.status === "fail")) {
+        process.exitCode = 1;
+      }
+    }
+  );
+}
 function doctorCommand() {
   const cmd = new Command("doctor").description("Run a comprehensive health check").option("--json", "Output as JSON").option("--quiet", "Suppress decorative output").option("--no-color", "Disable color output").action(async (options, command) => {
     const g = globalOutputOpts(command);
@@ -4889,6 +5281,7 @@ function doctorCommand() {
       }
     }
   });
+  cmd.addCommand(codexCommand());
   return cmd;
 }
 
@@ -5051,26 +5444,20 @@ var SUPPORTED_CLIENTS = [
   "codex",
   "gemini"
 ];
-var MCP_SERVER_NAME = "great-arrow";
+var MCP_SERVER_NAME = CODEX_SERVER_NAME;
 var CLIENT_IDS = {
   claude: "claude-code-cli",
   cursor: "cursor",
   kiro: "kiro",
-  codex: "codex-cli",
+  codex: CODEX_CLIENT_ID,
   gemini: "gemini-cli"
 };
-function normalizeApiUrl(apiUrl) {
-  return apiUrl.replace(/\/+$/, "");
-}
-function mcpEndpoint(apiUrl) {
-  return `${normalizeApiUrl(apiUrl)}/api/mcp`;
-}
 async function createClient3() {
   const auth = await resolveAuth();
   const client = new GadClient({ token: auth.token, apiUrl: auth.apiUrl });
   return { client, apiUrl: auth.apiUrl };
 }
-function generateMcpConfig(client, apiUrl, token) {
+function generateMcpConfig(client, apiUrl, token, repoUrl) {
   const endpoint = mcpEndpoint(apiUrl);
   if (client === "codex") {
     return {
@@ -5084,7 +5471,11 @@ function generateMcpConfig(client, apiUrl, token) {
             MEMORY_API_URL: apiUrl,
             MEMORY_CLIENT_NAME: CLIENT_IDS.codex,
             GAD_TOKEN: token,
-            GAD_API_URL: apiUrl
+            GAD_API_URL: apiUrl,
+            ...repoUrl ? {
+              MEMORY_REPO_URL: repoUrl,
+              GAD_REPO_URL: repoUrl
+            } : {}
           }
         }
       }
@@ -5097,44 +5488,13 @@ function generateMcpConfig(client, apiUrl, token) {
         url: endpoint,
         headers: {
           Authorization: `Bearer ${token}`,
-          "X-MCP-Client": CLIENT_IDS[client]
+          "X-MCP-Client": CLIENT_IDS[client],
+          ...repoUrl ? { "X-Repo-URL": repoUrl } : {}
         }
       }
     }
   };
 }
-function tomlEscape(value) {
-  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
-}
-function generateCodexConfigToml(apiUrl) {
-  return `[mcp_servers.${MCP_SERVER_NAME}]
-transport = "streamable_http"
-url = "${tomlEscape(mcpEndpoint(apiUrl))}"
-bearer_token_env_var = "GREAT_ARROW_TOKEN"
-`;
-}
-function generateCodexEnv(token) {
-  return `GREAT_ARROW_TOKEN=${token}
-`;
-}
-function upsertCodexServerBlock(existingContent, apiUrl) {
-  const block = generateCodexConfigToml(apiUrl).trimEnd();
-  const serverBlockPattern = /^\[mcp_servers\.great-arrow\]\n[\s\S]*?(?=^\[|\s*$)/m;
-  if (!existingContent.trim()) {
-    return `${block}
-`;
-  }
-  if (serverBlockPattern.test(existingContent)) {
-    const updated = existingContent.replace(serverBlockPattern, block);
-    return updated.endsWith("\n") ? updated : `${updated}
-`;
-  }
-  const trimmedRight = existingContent.replace(/\s*$/, "");
-  return `${trimmedRight}
-
-${block}
-`;
-}
 function upsertEnvValue(existingContent, key, value) {
   const lines = existingContent.split(/\r?\n/).filter((line) => line.trim() !== "" && !line.startsWith(`${key}=`));
   lines.push(`${key}=${value}`);
@@ -5150,29 +5510,29 @@ async function pathExists(path) {
     return false;
   }
 }
-async function installCodexConfig(apiUrl, token) {
-  const { homedir: homedir2 } = await import("node:os");
-  const { join: join2 } = await import("node:path");
-  const { chmod, copyFile, mkdir: mkdir2, readFile: readFile2, writeFile: writeFile2 } = await import("node:fs/promises");
-  const codexDir = join2(homedir2(), ".codex");
-  const configPath = join2(codexDir, "config.toml");
-  const envPath = join2(codexDir, ".env");
+async function installCodexConfig(apiUrl, token, repoUrl) {
+  const { homedir: homedir3 } = await import("node:os");
+  const { join: join3 } = await import("node:path");
+  const { chmod, copyFile: copyFile2, mkdir: mkdir3, readFile: readFile3, writeFile: writeFile3 } = await import("node:fs/promises");
+  const codexDir = join3(homedir3(), ".codex");
+  const configPath = join3(codexDir, "config.toml");
+  const envPath = join3(codexDir, ".env");
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  await mkdir2(codexDir, { recursive: true });
-  const existingConfig = await pathExists(configPath) ? await readFile2(configPath, "utf8") : "";
+  await mkdir3(codexDir, { recursive: true });
+  const existingConfig = await pathExists(configPath) ? await readFile3(configPath, "utf8") : "";
   if (existingConfig.trim()) {
-    await copyFile(configPath, `${configPath}.bak.${timestamp}`);
+    await copyFile2(configPath, `${configPath}.bak.${timestamp}`);
   }
-  await writeFile2(
+  await writeFile3(
     configPath,
-    upsertCodexServerBlock(existingConfig, apiUrl),
+    upsertCodexServerBlock(existingConfig, apiUrl, repoUrl),
     "utf8"
   );
-  const existingEnv = await pathExists(envPath) ? await readFile2(envPath, "utf8") : "";
+  const existingEnv = await pathExists(envPath) ? await readFile3(envPath, "utf8") : "";
   if (existingEnv.trim()) {
-    await copyFile(envPath, `${envPath}.bak.${timestamp}`);
+    await copyFile2(envPath, `${envPath}.bak.${timestamp}`);
   }
-  await writeFile2(
+  await writeFile3(
     envPath,
     upsertEnvValue(existingEnv, "GREAT_ARROW_TOKEN", token),
     "utf8"
@@ -5387,54 +5747,62 @@ ${summary}.
 var installCommand = new Command("install").description("Generate MCP configuration for a supported AI client").argument(
   "<client>",
   `AI client to configure (${SUPPORTED_CLIENTS.join(", ")})`
-).option("--stdout", "Print config to stdout instead of writing file").action(async (clientName, options) => {
-  const fmt = createFormatter({
-    json: false,
-    quiet: false,
-    isTTY: isTTY(),
-    noColor: false
-  });
-  if (!SUPPORTED_CLIENTS.includes(clientName)) {
-    fmt.error(
-      `Unsupported client: "${clientName}". Supported clients: ${SUPPORTED_CLIENTS.join(", ")}`
-    );
-    process.exit(3);
-  }
-  const auth = await resolveAuth();
-  if (clientName === "codex") {
-    if (options.stdout) {
-      process.stdout.write(`# ~/.codex/config.toml
+).option("--stdout", "Print config to stdout instead of writing file").option(
+  "--repo-url <url>",
+  "Repo URL to pin MCP requests to (defaults to current git origin)"
+).action(
+  async (clientName, options) => {
+    const fmt = createFormatter({
+      json: false,
+      quiet: false,
+      isTTY: isTTY(),
+      noColor: false
+    });
+    if (!SUPPORTED_CLIENTS.includes(clientName)) {
+      fmt.error(
+        `Unsupported client: "${clientName}". Supported clients: ${SUPPORTED_CLIENTS.join(", ")}`
+      );
+      process.exit(3);
+    }
+    const auth = await resolveAuth();
+    const repoUrl = options.repoUrl ?? detectGitOrigin2();
+    if (clientName === "codex") {
+      if (options.stdout) {
+        process.stdout.write(`# ~/.codex/config.toml
 `);
-      process.stdout.write(generateCodexConfigToml(auth.apiUrl));
-      process.stdout.write(`
+        process.stdout.write(generateCodexConfigToml(auth.apiUrl, repoUrl));
+        process.stdout.write(`
 # ~/.codex/.env
 `);
-      process.stdout.write(generateCodexEnv(auth.token));
+        process.stdout.write(generateCodexEnv(auth.token));
+        return;
+      }
+      const { configPath, envPath } = await installCodexConfig(
+        auth.apiUrl,
+        auth.token,
+        repoUrl
+      );
+      fmt.success(`Wrote Codex MCP config to ${configPath} and ${envPath}`);
       return;
     }
-    const { configPath, envPath } = await installCodexConfig(
+    const config = generateMcpConfig(
+      clientName,
       auth.apiUrl,
-      auth.token
+      auth.token,
+      repoUrl
     );
-    fmt.success(`Wrote Codex MCP config to ${configPath} and ${envPath}`);
-    return;
-  }
-  const config = generateMcpConfig(
-    clientName,
-    auth.apiUrl,
-    auth.token
-  );
-  const configJson = JSON.stringify(config, null, 2);
-  if (options.stdout) {
-    process.stdout.write(configJson + "\n");
-    return;
+    const configJson = JSON.stringify(config, null, 2);
+    if (options.stdout) {
+      process.stdout.write(configJson + "\n");
+      return;
+    }
+    const { writeFile: writeFile3 } = await import("node:fs/promises");
+    const { join: join3 } = await import("node:path");
+    const outputPath = join3(process.cwd(), ".mcp.json");
+    await writeFile3(outputPath, configJson + "\n", "utf-8");
+    fmt.success(`Wrote ${clientName} MCP config to .mcp.json`);
   }
-  const { writeFile: writeFile2 } = await import("node:fs/promises");
-  const { join: join2 } = await import("node:path");
-  const outputPath = join2(process.cwd(), ".mcp.json");
-  await writeFile2(outputPath, configJson + "\n", "utf-8");
-  fmt.success(`Wrote ${clientName} MCP config to .mcp.json`);
-});
+);
 var mcpCommand = new Command("mcp").description("Manage and diagnose the MCP server connection").addCommand(statusCommand).addCommand(logsCommand).addCommand(testCommand).addCommand(installCommand);
 var mcp_default = mcpCommand;
 
@@ -6057,7 +6425,7 @@ if (nodeVersion < 20) {
   console.error("  Upgrade Node.js: https://nodejs.org/");
   process.exit(1);
 }
-var VERSION = "0.1.3";
+var VERSION = "0.1.4";
 var program2 = new Command().name("gad").description("Great Arrow Digital CLI \u2014 terminal access to the GAD platform").version(VERSION, "-v, --version").option("--json", "Output as JSON").option("--quiet", "Suppress decorative output").option("--no-color", "Disable color output");
 program2.addCommand(login_default);
 program2.addCommand(logoutCommand);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@great-arrow/cli",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Great Arrow Digital CLI tool",
   "type": "module",
   "bin": {