fix(worktree): handle double-quoted escapes in git config value parsing

Author: kenryu42

src/core/worktree.ts

@@ -1,5 +1,6 @@
 import { existsSync, lstatSync, readFileSync, realpathSync, statSync } from 'node:fs';
-import { dirname, isAbsolute, join, parse as parsePath, resolve, sep } from 'node:path';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
+import { resolveChdirTarget } from '@/core/path';
 
 export const GIT_GLOBAL_OPTS_WITH_VALUE: ReadonlySet<string> = new Set([
   '-c',
@@ -18,6 +19,14 @@ export const GIT_CONTEXT_ENV_OVERRIDES = [
   'GIT_INDEX_FILE',
 ] as const;
 
+export const GIT_CONFIG_AFFECTING_ENV_NAMES: ReadonlySet<string> = new Set([
+  'GIT_CONFIG_GLOBAL',
+  'GIT_CONFIG_NOSYSTEM',
+  'GIT_CONFIG_SYSTEM',
+  'HOME',
+  'XDG_CONFIG_HOME',
+]);
+
 export interface GitExecutionContext {
   gitCwd: string | null;
   hasExplicitGitContext: boolean;
@@ -246,62 +255,66 @@ function readCoreWorktree(configPath: string): string | null {
 
     const match = trimmed.match(/^worktree\s*=\s*(.*)$/i);
     if (match) {
-      configuredWorktree = unquoteGitConfigValue(match[1] ?? '');
+      configuredWorktree = parseGitConfigValue(match[1] ?? '');
     }
   }
 
   return configuredWorktree;
 }
 
-function unquoteGitConfigValue(value: string): string {
+function parseGitConfigValue(value: string): string {
   const trimmed = value.trim();
-  if (
-    (trimmed.startsWith('"') && trimmed.endsWith('"')) ||
-    (trimmed.startsWith("'") && trimmed.endsWith("'"))
-  ) {
-    return trimmed.slice(1, -1);
+  if (!trimmed.startsWith('"') || !trimmed.endsWith('"')) {
+    return trimmed;
   }
-  return trimmed;
+  return unescapeDoubleQuotedGitConfigValue(trimmed.slice(1, -1));
 }
 
-function resolveGitCwd(baseCwd: string, target: string): string | null {
-  try {
-    const resolved = resolveChdirTarget(baseCwd, target);
-    return isDirectory(resolved) ? resolved : null;
-  } catch {
-    return null;
-  }
-}
-
-function resolveChdirTarget(baseCwd: string, target: string): string {
-  const root = isAbsolute(target) ? getPathRoot(target) : '';
-  let current = root || baseCwd;
-  for (const component of getPathComponents(root ? target.slice(root.length) : target)) {
-    if (component === '' || component === '.') {
+function unescapeDoubleQuotedGitConfigValue(value: string): string {
+  let result = '';
+  for (let i = 0; i < value.length; i++) {
+    const char = value[i];
+    if (char !== '\\') {
+      result += char;
       continue;
     }
-    if (component === '..') {
-      current = dirname(current);
+
+    const next = value[i + 1];
+    if (next === undefined) {
+      result += char;
       continue;
     }
 
-    const candidate = appendPathWithoutNormalizing(current, component);
-    current = lstatSync(candidate).isSymbolicLink() ? realpathSync(candidate) : candidate;
+    switch (next) {
+      case '\\':
+      case '"':
+        result += next;
+        break;
+      case 'n':
+        result += '\n';
+        break;
+      case 't':
+        result += '\t';
+        break;
+      case 'b':
+        result += '\b';
+        break;
+      default:
+        result += `\\${next}`;
+        break;
+    }
+    i++;
   }
-  return current;
+  return result;
 }
 
-function appendPathWithoutNormalizing(base: string, target: string): string {
-  return base.endsWith('/') || base.endsWith('\\') ? `${base}${target}` : `${base}${sep}${target}`;
-}
-
-function getPathRoot(target: string): string {
-  return parsePath(target).root;
-}
-
-function getPathComponents(target: string): string[] {
-  const separator = process.platform === 'win32' ? /[\\/]+/ : /\/+/;
-  return target.split(separator);
+function resolveGitCwd(baseCwd: string, target: string): string | null {
+  try {
+    const resolved = resolveChdirTarget(baseCwd, target);
+    return isDirectory(resolved) ? resolved : null;
+  } catch {
+    return null;
+  }
 }
 
 function isDirectory(path: string): boolean {
@@ -333,3 +346,6 @@ function findDotGit(cwd: string): string | null {
     current = parent;
   }
 }
+
+/** @internal Exported for testing */
+export { parseGitConfigValue as _parseGitConfigValue };

tests/core/worktree.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from 'bun:test';
+import { execFileSync } from 'node:child_process';
 import {
   mkdirSync,
   mkdtempSync,
@@ -11,6 +12,7 @@ import {
 import { tmpdir } from 'node:os';
 import { dirname, isAbsolute, join, resolve } from 'node:path';
 import {
+  _parseGitConfigValue,
   getGitExecutionContext,
   hasGitContextEnvOverride,
   isLinkedWorktree,
@@ -181,6 +183,16 @@ describe('worktree env context overrides', () => {
 });
 
 describe('linked worktree detection', () => {
+  test('parses double-quoted git config escapes', () => {
+    expect(_parseGitConfigValue('"/tmp/with \\"quotes\\""')).toBe('/tmp/with "quotes"');
+    expect(_parseGitConfigValue('"/tmp/backslash\\\\path"')).toBe('/tmp/backslash\\path');
+    expect(_parseGitConfigValue('"line\\nfeed\\ttab\\bbackspace"')).toBe(
+      'line\nfeed\ttab\bbackspace',
+    );
+    expect(_parseGitConfigValue('"unknown\\xpath"')).toBe('unknown\\xpath');
+    expect(_parseGitConfigValue("'/tmp/single'")).toBe("'/tmp/single'");
+  });
+
   test('normalizes Windows native realpath prefixes for comparison', () => {
     expect(normalizePathForComparison('\\\\?\\C:\\Temp\\Linked\\.git\\')).toBe(
       process.platform === 'win32' ? 'c:/temp/linked/.git' : 'C:/Temp/Linked/.git',
@@ -273,4 +285,42 @@ describe('linked worktree detection', () => {
       fixture.cleanup();
     }
   });
+
+  test.skipIf(process.platform === 'win32')(
+    'accepts double-quoted escaped core.worktree values',
+    () => {
+      const fixture = createLinkedWorktreeFixture();
+      const quotedWorktree = join(fixture.rootDir, 'linked"quoted');
+      execFileSync(
+        'git',
+        ['worktree', 'add', '-b', 'feature/quoted-worktree-test', quotedWorktree],
+        {
+          cwd: fixture.mainWorktree,
+          stdio: 'ignore',
+        },
+      );
+      const gitDir = getLinkedGitDir(quotedWorktree);
+      const escapedWorktree = quotedWorktree.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+      writeFileSync(join(gitDir, 'config.worktree'), `[core]\n\tworktree = "${escapedWorktree}"\n`);
+      try {
+        expect(isLinkedWorktree(quotedWorktree)).toBe(true);
+      } finally {
+        fixture.cleanup();
+      }
+    },
+  );
+
+  test('treats single-quoted core.worktree values as literal paths', () => {
+    const fixture = createLinkedWorktreeFixture();
+    const gitDir = getLinkedGitDir(fixture.linkedWorktree);
+    writeFileSync(
+      join(gitDir, 'config.worktree'),
+      `[core]\n\tworktree = '${fixture.linkedWorktree}'\n`,
+    );
+    try {
+      expect(isLinkedWorktree(fixture.linkedWorktree)).toBe(false);
+    } finally {
+      fixture.cleanup();
+    }
+  });
 });