fix(auth): isolate Claude probes and state sync locks

Author: skulidropek

packages/auth-oauth/src/claude-docker-oauth.ts

@@ -18,6 +18,7 @@ import {
 
 export const defaultClaudeDockerOauthImage = "docker-git-auth-claude:latest"
 export const defaultClaudeDockerOauthContainerHome = "/claude-home"
+const claudeDockerOauthProbeConfigDir = "/tmp/docker-git-claude-probe"
 export const claudeDockerOauthBaseImage =
   "node:24-bookworm-slim@sha256:b31e7a42fdf8b8aa5f5ed477c72d694301273f1069c5a2f71d53c6482e99a2fc"
 export const claudeDockerOauthClaudeCodeVersion = "2.1.195"
@@ -186,10 +187,20 @@ const buildDockerSetupTokenArgs = (
   return args
 }
 
+// CHANGE: probe captured OAuth tokens without reading persisted account settings
+// WHY: account settings may enable bypassPermissions for real sessions, but Claude rejects that mode in privileged probe contexts
+// QUOTE(ТЗ): "почему не работает команда bun run docker-git auth claude login"
+// REF: user-report-2026-07-01-claude-auth-login
+// SOURCE: n/a
+// FORMAT THEOREM: forall token: probe(token) uses env(token) and not account(settings.json)
+// PURITY: CORE
+// INVARIANT: setup-token validation cannot fail because of account permission settings
+// COMPLEXITY: O(1)
 const buildDockerProbeArgs = (
   image: string,
   hostPath: string,
-  containerPath: string
+  containerPath: string,
+  oauthToken: string
 ): ReadonlyArray<string> => {
   const args: Array<string> = [
     "run",
@@ -204,9 +215,11 @@ const buildDockerProbeArgs = (
   }
   args.push(
     "-e",
-    `CLAUDE_CONFIG_DIR=${containerPath}`,
+    `CLAUDE_CONFIG_DIR=${claudeDockerOauthProbeConfigDir}`,
     "-e",
-    `HOME=${containerPath}`,
+    `HOME=${claudeDockerOauthProbeConfigDir}`,
+    "-e",
+    `CLAUDE_CODE_OAUTH_TOKEN=${oauthToken}`,
     image,
     "-p",
     "ping"
@@ -341,7 +354,7 @@ export const runClaudeDockerOauth = async (
       await writeCapturedToken(accountPath, result.token)
       const probeExitCode = await (options.runProbe ?? runDockerProbe)({
         dockerCommand,
-        args: buildDockerProbeArgs(image, dockerHostPath, containerPath),
+        args: buildDockerProbeArgs(image, dockerHostPath, containerPath, result.token),
         cwd
       })
       return {

packages/auth-oauth/tests/claude-docker-oauth.test.ts

@@ -40,6 +40,8 @@ const oauthTokenArbitrary = fc.array(fc.constantFrom(
   minLength: 24,
   maxLength: 64
 }).map((chars) => `${oauthTokenPrefix}${chars.join("")}`)
+const dockerEnvEntries = (args: ReadonlyArray<string>): ReadonlyArray<string> =>
+  args.flatMap((arg, index) => args[index - 1] === "-e" ? [arg] : [])
 
 const temporaryAccountPath = (prefix: string) =>
   Effect.acquireRelease(
@@ -98,6 +100,13 @@ describe("Claude Docker OAuth runner", () => {
       expect(setupRuns[0]?.args.join(" ")).toContain(accountPath)
       expect(probeRuns).toHaveLength(1)
       expect(probeRuns[0]?.args.slice(-3)).toEqual(["claude-test:latest", "-p", "ping"])
+      expect(dockerEnvEntries(probeRuns[0]?.args ?? [])).toEqual(
+        expect.arrayContaining([
+          "CLAUDE_CONFIG_DIR=/tmp/docker-git-claude-probe",
+          "HOME=/tmp/docker-git-claude-probe",
+          `CLAUDE_CODE_OAUTH_TOKEN=${oauthToken}`
+        ])
+      )
       const tokenMode = yield* _(Effect.tryPromise(() => stat(claudeOauthTokenPath(accountPath))))
       expect(tokenMode.mode & 0o777).toBe(claudeOauthTokenFileMode)
     })))

packages/lib/src/usecases/auth-claude.ts

@@ -8,7 +8,7 @@ import {
   formatClaudeOauthTokenFile
 } from "@prover-coder-ai/docker-git-auth-oauth/claude-oauth-token"
 import { renderClaudeDockerOauthDockerfile } from "@prover-coder-ai/docker-git-auth-oauth/claude-docker-oauth"
-import { Effect } from "effect"
+import { Effect, Match } from "effect"
 
 import type { AuthClaudeLoginCommand, AuthClaudeLogoutCommand, AuthClaudeStatusCommand } from "../core/domain.js"
 import { defaultTemplateConfig } from "../core/domain.js"
@@ -27,6 +27,9 @@ import { readFileStringIfPresent, writeFileStringEnsuringParent } from "./volati
 
 type ClaudeRuntime = FileSystem.FileSystem | Path.Path | CommandExecutor.CommandExecutor
 type ClaudeAuthMethod = "none" | "oauth-token" | "claude-ai-session"
+type ClaudeProbeAuth =
+  | { readonly _tag: "ClaudeProbeAccountConfig" }
+  | { readonly _tag: "ClaudeProbeOauthToken"; readonly token: string }
 
 type ClaudeAccountContext = {
   readonly accountLabel: string
@@ -41,6 +44,7 @@ export const claudeAuthRoot = ".docker-git/.orch/auth/claude"
 const claudeImageName = "docker-git-auth-claude:latest"
 const claudeImageDir = ".docker-git/.orch/auth/claude/.image"
 const claudeContainerHomeDir = "/claude-home"
+const claudeProbeConfigDir = "/tmp/docker-git-claude-probe"
 const claudeConfigFileName = ".claude.json"
 const claudeCredentialsFileName = ".credentials.json"
 const claudeCredentialsDirName = ".claude"
@@ -178,6 +182,26 @@ const buildClaudeAuthEnv = (
   ...(oauthToken === null ? [] : [`CLAUDE_CODE_OAUTH_TOKEN=${oauthToken}`])
 ]
 
+// CHANGE: isolate non-interactive Claude OAuth probes from account settings
+// WHY: account settings may intentionally use bypassPermissions for real sessions, but Claude rejects that mode under root/sudo probe contexts
+// QUOTE(ТЗ): "почему не работает команда bun run docker-git auth claude login"
+// REF: user-report-2026-07-01-claude-auth-login
+// SOURCE: n/a
+// FORMAT THEOREM: forall token: probe(token) reads token env and not account(settings.json)
+// PURITY: CORE
+// INVARIANT: probe uses the persisted OAuth token without inheriting account permission settings
+// COMPLEXITY: O(1)
+const buildClaudeProbeEnv = (auth: ClaudeProbeAuth): ReadonlyArray<string> =>
+  Match.value(auth).pipe(
+    Match.when({ _tag: "ClaudeProbeAccountConfig" }, () => buildClaudeAuthEnv(false)),
+    Match.when({ _tag: "ClaudeProbeOauthToken" }, ({ token }) => [
+      `HOME=${claudeProbeConfigDir}`,
+      `CLAUDE_CONFIG_DIR=${claudeProbeConfigDir}`,
+      `CLAUDE_CODE_OAUTH_TOKEN=${token}`
+    ]),
+    Match.exhaustive
+  )
+
 const ensureClaudeOrchLayout = (
   cwd: string
 ): Effect.Effect<void, PlatformError, FileSystem.FileSystem | Path.Path> =>
@@ -252,15 +276,15 @@ const runClaudeLogout = (
 const runClaudePingProbeExitCode = (
   cwd: string,
   accountPath: string,
-  oauthToken: string | null
+  auth: ClaudeProbeAuth
 ): Effect.Effect<number, PlatformError, CommandExecutor.CommandExecutor> =>
   runDockerAuthExitCode(
     buildDockerAuthSpec({
       cwd,
       image: claudeImageName,
       hostPath: accountPath,
       containerPath: claudeContainerHomeDir,
-      env: buildClaudeAuthEnv(false, oauthToken),
+      env: buildClaudeProbeEnv(auth),
       args: ["-p", "ping"],
       interactive: false
     })
@@ -288,7 +312,10 @@ export const authClaudeLogin = (
       }),
       persistToken: (token) => persistClaudeOauthToken(fs, path, accountPath, token),
       normalizeStoredCredentials: resolveClaudeAuthMethod(fs, path, accountPath).pipe(Effect.asVoid),
-      probeToken: (token) => runClaudePingProbeExitCode(cwd, accountPath, token),
+      probeToken: (token) => runClaudePingProbeExitCode(cwd, accountPath, {
+        _tag: "ClaudeProbeOauthToken",
+        token
+      }),
       syncState: autoSyncState(`chore(state): auth claude ${accountLabel}`)
     }).pipe(Effect.asVoid))
 
@@ -314,7 +341,10 @@ export const authClaudeStatus = (
       }
 
       const oauthToken = method === "oauth-token" ? yield* _(readOauthToken(fs, accountPath)) : null
-      const probeExitCode = yield* _(runClaudePingProbeExitCode(cwd, accountPath, oauthToken))
+      const probeAuth: ClaudeProbeAuth = method === "oauth-token" && oauthToken !== null
+        ? { _tag: "ClaudeProbeOauthToken", token: oauthToken }
+        : { _tag: "ClaudeProbeAccountConfig" }
+      const probeExitCode = yield* _(runClaudePingProbeExitCode(cwd, accountPath, probeAuth))
       if (probeExitCode === 0) {
         yield* _(Effect.log(`Claude connected (${accountLabel}, ${method}).`))
         return

packages/lib/src/usecases/state-repo.ts

@@ -42,7 +42,24 @@ import { withStateGitLock } from "./state-repo/lock.js"
 
 type StateRepoEnv = FileSystem.FileSystem | Path.Path | CommandExecutor.CommandExecutor
 const resolveStateRoot = (path: Path.Path, cwd: string): string => path.resolve(defaultProjectsRoot(cwd))
+const resolveGitIndexLockPath = (path: Path.Path, root: string): string => path.join(root, ".git", "index.lock")
 const managedRepositoryCachePaths: ReadonlyArray<string> = [".cache/git-mirrors", ".cache/packages"]
+
+const renderStateSyncFailure = (error: CommandFailedError | PlatformError): string =>
+  error._tag === "CommandFailedError"
+    ? `${error.command} (exit ${error.exitCode})`
+    : String(error)
+
+const logStateAutoSyncFailure = (
+  error: CommandFailedError | PlatformError
+): Effect.Effect<void> =>
+  Effect.logWarning(`State auto-sync failed: ${renderStateSyncFailure(error)}`)
+
+const logStateAutoPullFailure = (
+  error: CommandFailedError | PlatformError
+): Effect.Effect<void> =>
+  Effect.logWarning(`State auto-pull failed: ${renderStateSyncFailure(error)}`)
+
 const ensureStateIgnoreAndUntrackCaches = (
   fs: FileSystem.FileSystem,
   path: Path.Path,
@@ -107,6 +124,7 @@ export const stateSync = (message: string | null) => withStateGitLock(stateSyncR
 
 const autoSyncStateRaw = (message: string): Effect.Effect<void, never, StateRepoEnv> =>
   Effect.gen(function*(_) {
+    const fs = yield* _(FileSystem.FileSystem)
     const path = yield* _(Path.Path)
     const root = resolveStateRoot(path, process.cwd())
     const isRepoOk = yield* _(isGitRepo(root))
@@ -120,6 +138,18 @@ const autoSyncStateRaw = (message: string): Effect.Effect<void, never, StateRepo
     }
     const strictValue = process.env[autoSyncStrictEnvKey]
     const isStrict = strictValue !== undefined && strictValue.trim().length > 0 ? isTruthyEnv(strictValue) : false
+    if (!isStrict) {
+      const indexLockPath = resolveGitIndexLockPath(path, root)
+      const hasIndexLock = yield* _(fs.exists(indexLockPath))
+      if (hasIndexLock) {
+        yield* _(
+          Effect.logWarning(
+            `State auto-sync skipped: git index lock exists at ${indexLockPath}. Another git process may be running; retry later.`
+          )
+        )
+        return
+      }
+    }
     const effect = stateSyncRaw(message)
     if (isStrict) {
       yield* _(effect)
@@ -128,14 +158,7 @@ const autoSyncStateRaw = (message: string): Effect.Effect<void, never, StateRepo
     yield* _(
       effect.pipe(
         Effect.matchEffect({
-          onFailure: (error) =>
-            Effect.logWarning(
-              `State auto-sync failed: ${
-                error._tag === "CommandFailedError"
-                  ? `${error.command} (exit ${error.exitCode})`
-                  : String(error)
-              }`
-            ),
+          onFailure: logStateAutoSyncFailure,
           onSuccess: () => Effect.void
         })
       )
@@ -184,15 +207,28 @@ const autoPullStateRaw: Effect.Effect<void, never, StateRepoEnv> = Effect.gen(fu
   )
 }).pipe(
   Effect.matchEffect({
-    onFailure: (error) => Effect.logWarning(`State auto-pull failed: ${String(error)}`),
+    onFailure: logStateAutoPullFailure,
     onSuccess: () => Effect.void
   }),
   Effect.asVoid
 )
 
-export const autoSyncState = (message: string) => withStateGitLock(autoSyncStateRaw(message))
+export const autoSyncState = (message: string): Effect.Effect<void, never, StateRepoEnv> =>
+  withStateGitLock(autoSyncStateRaw(message)).pipe(
+    Effect.matchEffect({
+      onFailure: logStateAutoSyncFailure,
+      onSuccess: () => Effect.void
+    }),
+    Effect.asVoid
+  )
 
-export const autoPullState: Effect.Effect<void, never, StateRepoEnv> = withStateGitLock(autoPullStateRaw)
+export const autoPullState: Effect.Effect<void, never, StateRepoEnv> = withStateGitLock(autoPullStateRaw).pipe(
+  Effect.matchEffect({
+    onFailure: logStateAutoPullFailure,
+    onSuccess: () => Effect.void
+  }),
+  Effect.asVoid
+)
 
 // Internal pull that takes an already-resolved root, reusing auth logic from pull-push.
 const statePullInternal = (

packages/lib/src/usecases/state-repo/lock.ts

@@ -1,6 +1,49 @@
-import { Effect } from "effect"
+import type { PlatformError } from "@effect/platform/Error"
+import * as FileSystem from "@effect/platform/FileSystem"
+import * as Path from "@effect/platform/Path"
+import { Duration, Effect } from "effect"
+
+import { CommandFailedError } from "../../shell/errors.js"
+import { defaultProjectsRoot } from "../menu-helpers.js"
 
 const stateGitLock = Effect.unsafeMakeSemaphore(1)
+const stateGitLockRetryDelay = Duration.millis(100)
+const stateGitLockMaxAttempts = 50
+const stateGitLockBusyExitCode = 75
+
+const resolveStateRoot = (path: Path.Path, cwd: string): string => path.resolve(defaultProjectsRoot(cwd))
+const resolveStateLockPath = (root: string): string => `${root}.lock`
+
+const isStateFileLockBusy = (error: Extract<PlatformError, { readonly _tag: "SystemError" }>): boolean =>
+  error.reason === "AlreadyExists" || error.reason === "Busy"
+
+const acquireStateFileLock = (
+  fs: FileSystem.FileSystem,
+  lockPath: string,
+  attempt: number = 0
+): Effect.Effect<string, CommandFailedError | PlatformError> =>
+  fs.makeDirectory(lockPath).pipe(
+    Effect.as(lockPath),
+    Effect.catchTag("SystemError", (error) => {
+      if (!isStateFileLockBusy(error)) {
+        return Effect.fail(error)
+      }
+      if (attempt >= stateGitLockMaxAttempts) {
+        return Effect.fail(new CommandFailedError({ command: "state git lock", exitCode: stateGitLockBusyExitCode }))
+      }
+      return Effect.sleep(stateGitLockRetryDelay).pipe(
+        Effect.zipRight(acquireStateFileLock(fs, lockPath, attempt + 1))
+      )
+    })
+  )
+
+const releaseStateFileLock = (
+  fs: FileSystem.FileSystem,
+  lockPath: string
+): Effect.Effect<void> =>
+  fs.remove(lockPath, { recursive: true, force: true }).pipe(
+    Effect.orElseSucceed(() => void 0)
+  )
 
 /**
  * Serializes git operations against the shared `.docker-git` working tree.
@@ -16,16 +59,29 @@ const stateGitLock = Effect.unsafeMakeSemaphore(1)
  * @complexity O(effect)
  * @throws Never - failures remain in the Effect error channel.
  */
-// CHANGE: serialize state repository git effects
-// WHY: inventory auto-pull and create auto-sync can otherwise race on one git working tree
-// QUOTE(ТЗ): "project not synchronized"
-// REF: issue-372
-// SOURCE: https://github.com/ProverCoderAI/docker-git/issues/372
-// FORMAT THEOREM: forall a,b in StateGitOps: overlap(guard(a), guard(b)) = false
+// CHANGE: serialize state repository git effects across process and fiber boundaries
+// WHY: auth auto-sync can run from separate docker-git processes and otherwise race on one git index
+// QUOTE(ТЗ): "fatal: Unable to create '/home/dev/.docker-git/.git/index.lock': File exists."
+// REF: user-report-2026-07-01-claude-auth-login
+// SOURCE: n/a
+// FORMAT THEOREM: forall a,b in StateGitOps: overlap(file_guard(a), file_guard(b)) = false
 // PURITY: SHELL
-// EFFECT: Effect<A, E, R>
-// INVARIANT: a single process-local permit protects the shared state repo
+// EFFECT: Effect<A, E | CommandFailedError | PlatformError, R | FileSystem | Path>
+// INVARIANT: a single process-local permit and a state-root lock directory protect the shared state repo
 // COMPLEXITY: O(effect)
 export const withStateGitLock = <A, E, R>(
   effect: Effect.Effect<A, E, R>
-): Effect.Effect<A, E, R> => effect.pipe(stateGitLock.withPermits(1))
+): Effect.Effect<A, E | CommandFailedError | PlatformError, R | FileSystem.FileSystem | Path.Path> =>
+  Effect.gen(function*(_) {
+    const fs = yield* _(FileSystem.FileSystem)
+    const path = yield* _(Path.Path)
+    const root = resolveStateRoot(path, process.cwd())
+    const lockPath = resolveStateLockPath(root)
+    return yield* _(
+      Effect.acquireUseRelease(
+        acquireStateFileLock(fs, lockPath),
+        () => effect,
+        (acquiredLockPath) => releaseStateFileLock(fs, acquiredLockPath)
+      )
+    )
+  }).pipe(stateGitLock.withPermits(1))