@ezmodo/mcp-server 0.13.5 → 0.14.1

package/lib/cli-credential.js

@@ -23,19 +23,10 @@
 
 import { execFileSync } from 'child_process';
 import { existsSync, readFileSync } from 'fs';
-import { homedir } from 'os';
 import { join } from 'path';
-
-// `.config/ezmodo` is current, `.config/zephly` the pre-rebrand name still
-// present in older installs. Current wins; legacy is a read fallback only.
-function configDirs() {
-  const home = homedir();
-  if (process.platform === 'win32') {
-    const base = process.env.APPDATA || home;
-    return [join(base, 'ezmodo'), join(base, 'zephly')];
-  }
-  return [join(home, '.config', 'ezmodo'), join(home, '.config', 'zephly')];
-}
+// Shared with lib/token-store.js so the two cannot disagree about where the
+// ezmodo config directory is — they write files side by side there.
+import { configDirs } from './user-paths.js';
 
 /** The Linux/Windows path: a 0600 JSON file written by `ezmodo auth login`. */
 function fromCredentialsFile() {

package/lib/create-server.js

@@ -22,10 +22,19 @@ import {
 
 import { TOOLS } from '../tools/index.js';
 import { HANDLERS } from '../handlers/index.js';
-import { PROMPTS, getPromptContent } from '../prompts/index.js';
+import { listPrompts, getPromptContent } from '../prompts/index.js';
 import { MCP_VERSION } from './version.js';
 import { getLogger } from './logger.js';
 import { isRemoteSafe } from './remote-tools.js';
+import {
+  EMAIL_ALREADY_REGISTERED,
+  NOT_AUTHENTICATED,
+  NO_ORGANIZATION,
+  emailAlreadyRegistered,
+  organizationRequired,
+  signInRequired,
+} from './auth-guidance.js';
+import { getInstructions } from './instructions.js';
 
 /**
  * @param {object} [options]
@@ -34,6 +43,44 @@ import { isRemoteSafe } from './remote-tools.js';
  *   'remote' excludes tools that operate on the local filesystem or git — see
  *   lib/remote-tools.js for why that is an allowlist and not a denylist.
  */
+/**
+ * Whether a failure means "nobody is signed in" rather than "the call went
+ * wrong".
+ *
+ * 401 counts as well as the no-credential case: a credential that WAS valid can
+ * stop being so — a revoked API key, or a refresh token whose grant expired
+ * while the editor sat open overnight — and telling the user to sign in is the
+ * right answer to both.
+ *
+ * 403 deliberately does NOT count. That means signed in but not permitted,
+ * most often a new account in no organization yet, and sending someone back
+ * through a sign-in that cannot fix it is worse than saying nothing. That case
+ * gets its own answer below — saying nothing was the placeholder, not the plan.
+ */
+function isAuthFailure(error) {
+  return error?.code === NOT_AUTHENTICATED || error?.status === 401;
+}
+
+/**
+ * Whether a failure means "signed in, but in no organization" (#2639).
+ *
+ * Keyed on the API's code, never on the message: the API owns the wording and
+ * will improve it, and a prose match that silently stops matching degrades to
+ * the bare 403 this exists to replace — the failure would be invisible, since
+ * the call still fails either way, just uselessly.
+ */
+function isNoOrganization(error) {
+  return error?.code === NO_ORGANIZATION;
+}
+
+/**
+ * Whether a failure means "signed in, but this email is already spoken for"
+ * (#2652). Same keying, and the same reason for it.
+ */
+function isEmailAlreadyRegistered(error) {
+  return error?.code === EMAIL_ALREADY_REGISTERED;
+}
+
 export function createServer({ surface = 'local' } = {}) {
   const log = getLogger();
 
@@ -46,7 +93,14 @@ export function createServer({ surface = 'local' } = {}) {
 
   const server = new Server(
     { name: 'ezmodo-mcp-server', version: MCP_VERSION },
-    { capabilities: { tools: {}, prompts: {} } }
+    {
+      capabilities: { tools: {}, prompts: {} },
+      // Reaches every client on every session, which is what makes it the one
+      // place the work-tracking discipline can live without a per-editor
+      // plugin (#2633). Varies by surface for the same reason the tool list
+      // does.
+      instructions: getInstructions(surface),
+    }
   );
 
   server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools }));
@@ -83,6 +137,41 @@ export function createServer({ surface = 'local' } = {}) {
     } catch (error) {
       const errMsg = error.message || String(error);
       log.error('Tool call failed', { tool: name, error: errMsg, durationMs: Date.now() - start });
+
+      // An authentication failure is not an error the model should relay as
+      // one — it is a request for the user to do something. Funnelled HERE, at
+      // the single dispatch point, for the same reason the surface filter is:
+      // every tool goes through it, so none of them can be missed or drift
+      // (#2632). Only on the local surface; over the connector Claude owns the
+      // OAuth and this advice would be wrong.
+      if (surface !== 'remote' && isAuthFailure(error)) {
+        return {
+          content: [{ type: 'text', text: JSON.stringify(signInRequired({ reason: errMsg }), null, 2) }],
+          isError: true,
+        };
+      }
+      // Answered on EVERY surface, unlike the sign-in prompt above. Sign-in
+      // advice is surface-specific because over the connector Claude owns the
+      // OAuth; a missing workspace is ours either way, and a claude.ai user
+      // hits it exactly as a local one does.
+      if (isNoOrganization(error)) {
+        return {
+          content: [
+            { type: 'text', text: JSON.stringify(organizationRequired({ reason: errMsg }), null, 2) },
+          ],
+          isError: true,
+        };
+      }
+      // Checked separately from the branch above, never merged into it: these
+      // two look alike from outside and their answers point opposite ways.
+      if (isEmailAlreadyRegistered(error)) {
+        return {
+          content: [
+            { type: 'text', text: JSON.stringify(emailAlreadyRegistered({ reason: errMsg }), null, 2) },
+          ],
+          isError: true,
+        };
+      }
       // Returned as content rather than thrown: a tool that fails is a result
       // the model can read and act on, not a transport error.
       return {
@@ -92,10 +181,14 @@ export function createServer({ surface = 'local' } = {}) {
     }
   });
 
-  server.setRequestHandler(ListPromptsRequestSchema, async () => ({ prompts: PROMPTS }));
+  // Filtered by surface exactly as tools are, and for the same reason: `submit`
+  // reads git SHAs and links commits, which a hosted server cannot do.
+  server.setRequestHandler(ListPromptsRequestSchema, async () => ({
+    prompts: listPrompts(surface),
+  }));
 
   server.setRequestHandler(GetPromptRequestSchema, async (request) => {
-    const content = getPromptContent(request.params.name);
+    const content = getPromptContent(request.params.name, request.params.arguments, surface);
     if (!content) {
       throw new Error(`Unknown prompt: ${request.params.name}`);
     }

package/lib/credentials.js

@@ -0,0 +1,106 @@
+/**
+ * The one place that decides which credential a request is made with.
+ *
+ * Four sources, and the ORDER is the contract (#2631):
+ *
+ *   1. The request context. Only ever set by the HTTP transport, where one
+ *      process serves many callers and the credential belongs to the request
+ *      rather than the process (#2599). Over stdio this is always empty.
+ *   2. EZMODO_API_KEY (or legacy ZEPHLY_API_KEY). An EXPLICIT credential must
+ *      beat an implicit one, or overriding the key for a single project becomes
+ *      impossible to reason about — and this is what keeps CI, containers and
+ *      anything headless working exactly as before OAuth existed.
+ *   3. The OAuth token this server obtained for itself, refreshed if stale.
+ *      The zero-configuration path: nothing to paste, nothing in a profile.
+ *   4. The credential `ezmodo auth login` stored. Last because it belongs to
+ *      another program: a server that silently authenticates as whoever the
+ *      CLI happens to be logged in as should do so only when nothing else
+ *      said otherwise.
+ *
+ * 3 above 4 is the deliberate part. Both are implicit, so neither "wins" on
+ * explicitness; what separates them is that the OAuth token is THIS server's
+ * own, obtained by a person who was shown a consent screen naming this
+ * connector, while the CLI's key is a credential borrowed from a different
+ * tool. Prefer the one whose grant the user actually saw.
+ */
+
+import { getApiKey } from './env.js';
+import { getRequestContext, resolveApiKey } from './request-context.js';
+import { getAccessToken, getSignedInIdentity } from './oauth.js';
+import { readCliCredential } from './cli-credential.js';
+
+/**
+ * The CLI credential, looked up at most once.
+ *
+ * Memoized because reading it is not free: on macOS it shells out to
+ * `security` to read the login Keychain, and doing that on every API call
+ * would put a subprocess spawn — and a possible ACL prompt — on the hot path.
+ * `undefined` means "not looked up yet"; `null` means "looked up, nothing
+ * there".
+ */
+let cachedCliCredential;
+
+function cliCredential() {
+  if (cachedCliCredential === undefined) {
+    cachedCliCredential = readCliCredential() ?? null;
+  }
+  return cachedCliCredential;
+}
+
+/**
+ * Resolve the credential for the call in flight.
+ *
+ * Returns null rather than throwing when there is nothing to use. Every caller
+ * is on the path of a tool call, and "sign in first" is something an agent can
+ * act on; an exception is not.
+ *
+ * @returns {Promise<{ token: string, source: string }|null>}
+ */
+export async function resolveCredential() {
+  // Steps 1 and 2 together. Deliberately NOT re-implemented here:
+  // resolveApiKey() already means "request context, else environment", and a
+  // second copy of that precedence is how the two drift apart.
+  const explicit = resolveApiKey();
+  if (explicit) {
+    const fromRequest = Boolean(getRequestContext()?.apiKey);
+    return { token: explicit, source: fromRequest ? 'request' : 'EZMODO_API_KEY' };
+  }
+
+  const fromOAuth = await getAccessToken();
+  if (fromOAuth) {
+    const identity = getSignedInIdentity();
+    return { token: fromOAuth, source: identity?.email ? `OAuth (${identity.email})` : 'OAuth' };
+  }
+
+  const fromCli = cliCredential();
+  if (fromCli) return { token: fromCli.key, source: fromCli.source };
+
+  return null;
+}
+
+/**
+ * What the startup banner reports, without triggering a network refresh.
+ *
+ * Startup must not block on Keycloak: an expired token at boot would make the
+ * server hang before it ever spoke MCP, and the refresh happens on the first
+ * call anyway.
+ *
+ * @returns {{ source: string, detail?: string }|null}
+ */
+export function describeCredentialSync() {
+  const fromEnv = getApiKey();
+  if (fromEnv) return { source: 'EZMODO_API_KEY', detail: `${fromEnv.substring(0, 12)}...` };
+
+  const identity = getSignedInIdentity();
+  if (identity) return { source: 'OAuth', detail: identity.email };
+
+  const fromCli = cliCredential();
+  if (fromCli) return { source: fromCli.source, detail: `${fromCli.key.substring(0, 12)}...` };
+
+  return null;
+}
+
+/** Test seam: forget the memoized CLI lookup. */
+export function resetCredentialCache() {
+  cachedCliCredential = undefined;
+}

package/lib/git-helpers.js

@@ -3,26 +3,60 @@
  * Utility functions for git operations used by worktree tools
  */
 
-import { execSync } from 'child_process';
+import { execFileSync } from 'child_process';
 
 /**
- * Execute git command with proper error handling
- * @param {string} command - Git command to execute
+ * Run git with an ARGUMENT ARRAY — never a command string, and never a shell.
+ *
+ * This used to be `execSync(command)`, with callers building the command by
+ * interpolating branch names and paths into a template. #2614 stopped the
+ * remote transport from reaching any of it, which removed the internet-facing
+ * blast radius; this closes the hole itself, so the same mistake cannot be made
+ * again by a future caller who is not thinking about shells.
+ *
+ * execFileSync spawns git directly, so the arguments are passed as-is: a value
+ * containing `;`, a backtick or a quote is a literal branch name that git will
+ * simply not find, rather than a second command. Nothing in this file quotes
+ * anything any more, because there is no shell left to quote for.
+ *
+ * @param {string[]} args - Arguments to git, one element per argument
  * @param {string} cwd - Working directory
- * @returns {string} Command output
+ * @returns {string} Command output, trimmed
  */
-export function execGit(command, cwd) {
+export function execGit(args, cwd) {
+  if (!Array.isArray(args)) {
+    throw new TypeError('execGit takes an argument array, not a command string');
+  }
   try {
-    return execSync(command, {
+    return execFileSync('git', args, {
       cwd,
       encoding: 'utf-8',
       stdio: 'pipe',
     }).trim();
   } catch (error) {
-    throw new Error(`Git command failed: ${command}\n${error.message}`);
+    throw new Error(`Git command failed: git ${args.join(' ')}\n${error.message}`);
   }
 }
 
+/**
+ * Reject a value that git would read as an OPTION rather than as a name.
+ *
+ * The residual risk after dropping the shell is not injection, it is option
+ * injection: `--exec=...` in a branch-name position is still one argument, and
+ * git still honours it. Callers pass user-supplied refs and paths, so the
+ * values that land in those positions are checked here.
+ *
+ * @param {string} value - The candidate branch name, ref or path
+ * @param {string} label - What it is, for the error message
+ * @returns {string} The value, unchanged
+ */
+function assertNotOption(value, label) {
+  if (typeof value !== 'string' || value.startsWith('-')) {
+    throw new Error(`Invalid ${label}: ${value}`);
+  }
+  return value;
+}
+
 /**
  * Check if directory is a git repository
  * @param {string} dir - Directory path
@@ -30,11 +64,7 @@ export function execGit(command, cwd) {
  */
 export function isGitRepository(dir) {
   try {
-    execSync('git rev-parse --git-dir', {
-      cwd: dir,
-      encoding: 'utf-8',
-      stdio: 'pipe',
-    });
+    execGit(['rev-parse', '--git-dir'], dir);
     return true;
   } catch {
     return false;
@@ -48,11 +78,7 @@ export function isGitRepository(dir) {
  */
 export function getRepositoryRoot(dir) {
   try {
-    return execSync('git rev-parse --show-toplevel', {
-      cwd: dir,
-      encoding: 'utf-8',
-      stdio: 'pipe',
-    }).trim();
+    return execGit(['rev-parse', '--show-toplevel'], dir);
   } catch {
     return null;
   }
@@ -65,7 +91,7 @@ export function getRepositoryRoot(dir) {
  */
 export function getRemoteUrl(repoPath) {
   try {
-    return execGit('git config --get remote.origin.url', repoPath);
+    return execGit(['config', '--get', 'remote.origin.url'], repoPath);
   } catch {
     return null;
   }
@@ -78,7 +104,7 @@ export function getRemoteUrl(repoPath) {
  */
 export function getCurrentBranch(repoPath) {
   try {
-    return execGit('git branch --show-current', repoPath);
+    return execGit(['branch', '--show-current'], repoPath);
   } catch {
     return null;
   }
@@ -93,15 +119,17 @@ export function getCurrentBranch(repoPath) {
 export function branchExists(repoPath, branchName) {
   const result = { local: false, remote: false };
 
+  assertNotOption(branchName, 'branch name');
+
   try {
-    execGit(`git show-ref --verify refs/heads/${branchName}`, repoPath);
+    execGit(['show-ref', '--verify', `refs/heads/${branchName}`], repoPath);
     result.local = true;
   } catch {
     // Branch doesn't exist locally
   }
 
   try {
-    execGit(`git show-ref --verify refs/remotes/origin/${branchName}`, repoPath);
+    execGit(['show-ref', '--verify', `refs/remotes/origin/${branchName}`], repoPath);
     result.remote = true;
   } catch {
     // Branch doesn't exist remotely
@@ -118,18 +146,21 @@ export function branchExists(repoPath, branchName) {
  * @returns {string} Commit hash
  */
 export function createBranch(repoPath, branchName, baseBranch) {
+  assertNotOption(branchName, 'branch name');
+  assertNotOption(baseBranch, 'base branch');
+
   // Ensure base branch is up to date
   try {
-    execGit(`git fetch origin ${baseBranch}`, repoPath);
+    execGit(['fetch', 'origin', baseBranch], repoPath);
   } catch {
     // Fetch might fail if no remote, that's ok
   }
 
   // Create branch
-  execGit(`git branch ${branchName} ${baseBranch}`, repoPath);
+  execGit(['branch', branchName, baseBranch], repoPath);
 
   // Get commit hash
-  return execGit(`git rev-parse ${branchName}`, repoPath);
+  return execGit(['rev-parse', branchName], repoPath);
 }
 
 /**
@@ -141,8 +172,23 @@ export function createBranch(repoPath, branchName, baseBranch) {
  * @returns {void}
  */
 export function createWorktree(repoPath, worktreePath, branchName, createBranch = false) {
-  const branchFlag = createBranch ? '-b' : '';
-  execGit(`git worktree add ${branchFlag} "${worktreePath}" ${branchName}`, repoPath);
+  assertNotOption(worktreePath, 'worktree path');
+  assertNotOption(branchName, 'branch name');
+
+  // `git worktree add -b <new-branch> <path>` — the branch name comes FIRST
+  // after -b. The string-building version had it the other way round
+  // (`add -b "<path>" <branch>`), so git read the path as the branch name and
+  // refused it. Nothing caught that because every caller in worktree-tools.js
+  // passes createBranch = false, having created the branch already; this path
+  // has never worked. Corrected here rather than left as a trap, since the
+  // whole point of moving to an argument array is that the arguments are now
+  // legible.
+  execGit(
+    createBranch
+      ? ['worktree', 'add', '-b', branchName, worktreePath]
+      : ['worktree', 'add', worktreePath, branchName],
+    repoPath
+  );
 }
 
 /**
@@ -152,7 +198,7 @@ export function createWorktree(repoPath, worktreePath, branchName, createBranch
  */
 export function listWorktrees(repoPath) {
   try {
-    const output = execGit('git worktree list --porcelain', repoPath);
+    const output = execGit(['worktree', 'list', '--porcelain'], repoPath);
     const worktrees = [];
     const lines = output.split('\n');
 
@@ -190,8 +236,9 @@ export function listWorktrees(repoPath) {
  * @returns {void}
  */
 export function removeWorktree(repoPath, worktreePath, force = false) {
-  const forceFlag = force ? '--force' : '';
-  execGit(`git worktree remove ${forceFlag} "${worktreePath}"`, repoPath);
+  assertNotOption(worktreePath, 'worktree path');
+
+  execGit(['worktree', 'remove', ...(force ? ['--force'] : []), worktreePath], repoPath);
 }
 
 /**
@@ -209,7 +256,7 @@ export function getWorktreeStatus(worktreePath) {
   };
 
   try {
-    const output = execGit('git status --porcelain', worktreePath);
+    const output = execGit(['status', '--porcelain'], worktreePath);
 
     if (output) {
       status.isDirty = true;
@@ -248,19 +295,22 @@ export function getAheadBehindCounts(worktreePath, localBranch, remoteBranch) {
   const counts = { ahead: 0, behind: 0 };
 
   try {
+    assertNotOption(localBranch, 'local branch');
+    assertNotOption(remoteBranch, 'remote branch');
+
     // Fetch latest
-    execGit('git fetch origin', worktreePath);
+    execGit(['fetch', 'origin'], worktreePath);
 
     // Get ahead count
     const aheadOutput = execGit(
-      `git rev-list --count ${remoteBranch}..${localBranch}`,
+      ['rev-list', '--count', `${remoteBranch}..${localBranch}`],
       worktreePath
     );
     counts.ahead = parseInt(aheadOutput, 10) || 0;
 
     // Get behind count
     const behindOutput = execGit(
-      `git rev-list --count ${localBranch}..${remoteBranch}`,
+      ['rev-list', '--count', `${localBranch}..${remoteBranch}`],
       worktreePath
     );
     counts.behind = parseInt(behindOutput, 10) || 0;
@@ -280,7 +330,7 @@ export function checkForConflicts(worktreePath) {
   const result = { hasConflicts: false, files: [] };
 
   try {
-    const output = execGit('git status --porcelain', worktreePath);
+    const output = execGit(['status', '--porcelain'], worktreePath);
     const lines = output.split('\n').filter(l => l);
 
     for (const line of lines) {
@@ -310,8 +360,9 @@ export function checkForConflicts(worktreePath) {
  * @returns {void}
  */
 export function deleteBranch(repoPath, branchName, force = false) {
-  const flag = force ? '-D' : '-d';
-  execGit(`git branch ${flag} ${branchName}`, repoPath);
+  assertNotOption(branchName, 'branch name');
+
+  execGit(['branch', force ? '-D' : '-d', branchName], repoPath);
 }
 
 /**
@@ -323,7 +374,9 @@ export function deleteBranch(repoPath, branchName, force = false) {
  */
 export function isBranchMerged(repoPath, branchName, baseBranch) {
   try {
-    const output = execGit(`git branch --merged ${baseBranch}`, repoPath);
+    assertNotOption(baseBranch, 'base branch');
+
+    const output = execGit(['branch', '--merged', baseBranch], repoPath);
     return output.includes(branchName);
   } catch {
     return false;
@@ -338,10 +391,12 @@ export function isBranchMerged(repoPath, branchName, baseBranch) {
  */
 export function getLastCommit(repoPath, branchName) {
   try {
-    const hash = execGit(`git rev-parse ${branchName}`, repoPath);
-    const author = execGit(`git log -1 --format=%an ${branchName}`, repoPath);
-    const timestamp = execGit(`git log -1 --format=%ct ${branchName}`, repoPath);
-    const message = execGit(`git log -1 --format=%s ${branchName}`, repoPath);
+    assertNotOption(branchName, 'branch name');
+
+    const hash = execGit(['rev-parse', branchName], repoPath);
+    const author = execGit(['log', '-1', '--format=%an', branchName], repoPath);
+    const timestamp = execGit(['log', '-1', '--format=%ct', branchName], repoPath);
+    const message = execGit(['log', '-1', '--format=%s', branchName], repoPath);
 
     return {
       hash,
@@ -397,7 +452,10 @@ export function generateBranchName(task, defaultPrefix = 'feature') {
  */
 export function getMergeBase(repoPath, branch1, branch2) {
   try {
-    return execGit(`git merge-base ${branch1} ${branch2}`, repoPath);
+    assertNotOption(branch1, 'branch');
+    assertNotOption(branch2, 'branch');
+
+    return execGit(['merge-base', branch1, branch2], repoPath);
   } catch {
     return null;
   }
@@ -411,16 +469,16 @@ export function getMergeBase(repoPath, branch1, branch2) {
 export function getDefaultBranch(repoPath) {
   // Try to get from remote HEAD
   try {
-    const ref = execGit('git symbolic-ref refs/remotes/origin/HEAD', repoPath);
+    const ref = execGit(['symbolic-ref', 'refs/remotes/origin/HEAD'], repoPath);
     return ref.replace('refs/remotes/origin/', '');
   } catch {
     // Fall back to checking if main or master exists
     try {
-      execGit('git show-ref --verify refs/heads/main', repoPath);
+      execGit(['show-ref', '--verify', 'refs/heads/main'], repoPath);
       return 'main';
     } catch {
       try {
-        execGit('git show-ref --verify refs/heads/master', repoPath);
+        execGit(['show-ref', '--verify', 'refs/heads/master'], repoPath);
         return 'master';
       } catch {
         return 'main'; // Default fallback
@@ -439,13 +497,17 @@ export function getDefaultBranch(repoPath) {
 export function getCommitsSince(repoPath, sinceCommit, branchName) {
   try {
     // Format: hash|short|author|email|timestamp|subject
+    assertNotOption(branchName, 'branch name');
+    if (sinceCommit) {
+      assertNotOption(sinceCommit, 'commit');
+    }
+
+    // No quotes around the format: there is no shell to strip them, so a
+    // quoted format string would reach git verbatim and appear in the output.
     const format = '%H|%h|%an|%ae|%ct|%s';
     const range = sinceCommit ? `${sinceCommit}..${branchName}` : branchName;
 
-    const output = execGit(
-      `git log --format="${format}" ${range}`,
-      repoPath
-    );
+    const output = execGit(['log', `--format=${format}`, range], repoPath);
 
     if (!output) {
       return [];
@@ -469,8 +531,9 @@ export function getCommitsSince(repoPath, sinceCommit, branchName) {
 }
 
 /**
- * A commit SHA, and nothing else. The value reaches execGit inside a shell
- * string, so anything that is not hex never gets there.
+ * A commit SHA, and nothing else. Kept after execGit stopped using a shell
+ * (#2614 step 5): it is still the cheapest way to tell a real hash from a ref
+ * that would make diff-tree mean something other than "this commit".
  */
 const SHA_PATTERN = /^[0-9a-f]{7,40}$/i;
 
@@ -497,7 +560,7 @@ export function getCommitFiles(repoPath, sha) {
   }
   try {
     const output = execGit(
-      `git diff-tree --no-commit-id --name-only -r ${sha}`,
+      ['diff-tree', '--no-commit-id', '--name-only', '-r', sha],
       repoPath
     );
     return output ? output.split('\n').map(line => line.trim()).filter(Boolean) : [];