fix(auth): harden claude oauth login probe path

Author: konard

.github/workflows/check.yml

@@ -257,8 +257,9 @@ jobs:
       DOCKER_GIT_CONTROLLER_BUILD_SKILLER: "0"
       DOCKER_GIT_E2E_REUSE_WORKSPACE_INSTALL: "1"
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10
         with:
+          persist-credentials: false
           submodules: true
       - name: Install dependencies
         uses: ./.github/actions/setup

bun.lock

@@ -27,7 +27,6 @@ services:
       DOCKER_GIT_EXCHANGE_AGENT_COMMAND: ${DOCKER_GIT_EXCHANGE_AGENT_COMMAND:-}
       DOCKER_GIT_EXCHANGE_AGENT_TIMEOUT_MS: ${DOCKER_GIT_EXCHANGE_AGENT_TIMEOUT_MS:-3600000}
       DOCKER_GIT_OUTBOX_POLLING_INTERVAL_MS: ${DOCKER_GIT_OUTBOX_POLLING_INTERVAL_MS:-5000}
-      DOCKER_GIT_CLAUDE_OAUTH_TOKEN: ${DOCKER_GIT_CLAUDE_OAUTH_TOKEN:-}
     ports:
       - "${DOCKER_GIT_API_BIND_HOST:-127.0.0.1}:${DOCKER_GIT_API_PORT:-3334}:${DOCKER_GIT_API_PORT:-3334}"
     dns:

docker-compose.yml

@@ -13,12 +13,14 @@ import type { ControllerBootstrapError } from "./host-errors.js"
 
 export const controllerGpuModeEnvKey = "DOCKER_GIT_CONTROLLER_GPU"
 export const controllerBuildSkillerEnvKey = "DOCKER_GIT_CONTROLLER_BUILD_SKILLER"
+export const controllerComposeExtraFileEnvKey = "DOCKER_GIT_CONTROLLER_COMPOSE_EXTRA_FILE"
 
 export type ControllerGpuMode = "none" | "all"
 export type ControllerBuildSkillerMode = "0" | "1"
 
 export type ControllerComposeFiles = {
   readonly composePath: string
+  readonly extraOverlayPath: string | null
   readonly gpuOverlayPath: string | null
   readonly runtimeOverlayPath: string | null
 }
@@ -114,6 +116,42 @@ const mapSkillerPathError = (error: PlatformError): ControllerBootstrapError =>
 const mapControllerRevisionError = (error: PlatformError): ControllerBootstrapError =>
   controllerBootstrapError(`Failed to compute docker-git controller revision.\nDetails: ${String(error)}`)
 
+// CHANGE: add a verified controller compose overlay boundary for E2E/runtime callers
+// WHY: temporary compose overrides must be part of the explicit docker compose argument vector
+// QUOTE(ТЗ): n/a
+// REF: issue-440-review-compose-overlay
+// SOURCE: n/a
+// FORMAT THEOREM: forall p: env(extra)=p and exists(resolve(p)) -> resolve(extra)=Some(resolve(p))
+// PURITY: SHELL
+// EFFECT: Effect<string | null, ControllerBootstrapError, FileSystem | Path>
+// INVARIANT: non-empty extra compose env values either resolve to an existing file or fail before docker compose
+// COMPLEXITY: O(1)
+const loadControllerComposeExtraPath = (): Effect.Effect<
+  string | null,
+  ControllerBootstrapError,
+  FileSystem.FileSystem | Path.Path
+> =>
+  Effect.gen(function*(_) {
+    const raw = process.env[controllerComposeExtraFileEnvKey]?.trim() ?? ""
+    if (raw.length === 0) {
+      return null
+    }
+
+    const fs = yield* _(FileSystem.FileSystem)
+    const path = yield* _(Path.Path)
+    const extraOverlayPath = path.resolve(raw)
+    const isExists = yield* _(fs.exists(extraOverlayPath).pipe(Effect.mapError(mapComposePathError)))
+    return isExists
+      ? extraOverlayPath
+      : yield* _(
+        Effect.fail(
+          controllerBootstrapError(
+            `${controllerComposeExtraFileEnvKey} points to ${extraOverlayPath}, but it was not found.`
+          )
+        )
+      )
+  })
+
 const skillerSubmoduleCommand = [
   "submodule",
   "update",
@@ -209,19 +247,22 @@ export const ensureSkillerSubmoduleInitialized = (
 export const composeFilesForMode = (
   composePath: string,
   gpuOverlayPath: string | null,
-  runtimeOverlayPath: string | null = null
+  runtimeOverlayPath: string | null = null,
+  extraOverlayPath: string | null = null
 ): ReadonlyArray<string> => [
   "-f",
   composePath,
   ...(runtimeOverlayPath === null ? [] : ["-f", runtimeOverlayPath]),
-  ...(gpuOverlayPath === null ? [] : ["-f", gpuOverlayPath])
+  ...(gpuOverlayPath === null ? [] : ["-f", gpuOverlayPath]),
+  ...(extraOverlayPath === null ? [] : ["-f", extraOverlayPath])
 ]
 
 export const composeFilesToArgs = (composeFiles: ControllerComposeFiles): ReadonlyArray<string> =>
   composeFilesForMode(
     composeFiles.composePath,
     composeFiles.gpuOverlayPath,
-    composeFiles.runtimeOverlayPath
+    composeFiles.runtimeOverlayPath,
+    composeFiles.extraOverlayPath
   )
 
 const requireGpuOverlayPath = (
@@ -246,9 +287,9 @@ const composeFilesForGpuMode = (
   gpuMode: ControllerGpuMode
 ): Effect.Effect<ControllerComposeFiles, ControllerBootstrapError, FileSystem.FileSystem | Path.Path> =>
   gpuMode === "none"
-    ? Effect.succeed({ composePath, gpuOverlayPath: null, runtimeOverlayPath: null })
+    ? Effect.succeed({ composePath, extraOverlayPath: null, gpuOverlayPath: null, runtimeOverlayPath: null })
     : requireGpuOverlayPath(composePath).pipe(
-      Effect.map((gpuOverlayPath) => ({ composePath, gpuOverlayPath, runtimeOverlayPath: null }))
+      Effect.map((gpuOverlayPath) => ({ composePath, extraOverlayPath: null, gpuOverlayPath, runtimeOverlayPath: null }))
     )
 
 type ComposePathAndGpuMode = {
@@ -286,8 +327,9 @@ export const resolveControllerComposeFiles = (): Effect.Effect<
   withComposePathAndGpuMode(({ composePath, dockerRuntime, gpuMode }) =>
     Effect.gen(function*(_) {
       const composeFiles = yield* _(composeFilesForGpuMode(composePath, gpuMode))
+      const extraOverlayPath = yield* _(loadControllerComposeExtraPath())
       const runtimeOverlayPath = yield* _(resolveControllerRuntimeOverlayPath(composePath, dockerRuntime))
-      return { ...composeFiles, runtimeOverlayPath }
+      return { ...composeFiles, extraOverlayPath, runtimeOverlayPath }
     })
   )
 

packages/app/src/docker-git/controller-compose.ts

@@ -8,6 +8,7 @@ import * as fc from "fast-check"
 import { resolveControllerRuntimeOverlayPath } from "../../src/docker-git/controller-compose-runtime.js"
 import {
   controllerBuildSkillerEnvKey,
+  controllerComposeExtraFileEnvKey,
   controllerComposeProjectName,
   controllerGpuModeEnvKey,
   ensureSkillerSubmoduleInitialized,
@@ -61,6 +62,9 @@ const writeMinimalCompose = (rootDir: string) =>
 const writeMinimalIsolatedCompose = (rootDir: string) =>
   writeRootFile(rootDir, "docker-compose.isolated.yml", "services:\n  api:\n    volumes: !override []\n")
 
+const writeMinimalExtraCompose = (rootDir: string) =>
+  writeRootFile(rootDir, "docker-compose.auth-claude-login.yml", "services:\n  api:\n    environment: {}\n")
+
 const writeSkillerPackage = (rootDir: string) =>
   writeRootFile(rootDir, skillerPackageRelativePath, "{\"name\":\"skiller-desktop-skills-manager\"}\n")
 
@@ -159,6 +163,7 @@ const prepareRevisionInTemporaryRoot = ({
       yield* _(
         withControllerEnv([
           [controllerBuildSkillerEnvKey, buildSkillerMode],
+          [controllerComposeExtraFileEnvKey, undefined],
           [controllerDockerRuntimeEnvKey, undefined],
           [controllerGpuModeEnvKey, undefined],
           [controllerRevisionEnvKey, undefined]
@@ -192,6 +197,7 @@ const resolveComposeFilesInTemporaryRoot = (
       yield* _(
         withControllerEnv([
           [controllerBuildSkillerEnvKey, "0"],
+          [controllerComposeExtraFileEnvKey, undefined],
           [controllerDockerRuntimeEnvKey, dockerRuntimeMode],
           [controllerGpuModeEnvKey, undefined]
         ])
@@ -215,6 +221,7 @@ describe("controller compose preparation", () => {
         yield* _(
           withControllerEnv([
             [controllerBuildSkillerEnvKey, "0"],
+            [controllerComposeExtraFileEnvKey, undefined],
             [controllerDockerRuntimeEnvKey, undefined],
             [controllerGpuModeEnvKey, undefined]
           ])
@@ -235,6 +242,42 @@ describe("controller compose preparation", () => {
     ).pipe(Effect.provide(NodeContext.layer))
   })
 
+  it.effect("passes the verified extra compose overlay into controller compose commands", () => {
+    const startedCommands: Array<string> = []
+
+    return withMinimalControllerRoot((rootDir) =>
+      Effect.gen(function*(_) {
+        const path = yield* _(Path.Path)
+        yield* _(writeMinimalExtraCompose(rootDir))
+        const extraComposePath = path.join(rootDir, "docker-compose.auth-claude-login.yml")
+        yield* _(
+          withControllerEnv([
+            [controllerBuildSkillerEnvKey, "0"],
+            [controllerComposeExtraFileEnvKey, extraComposePath],
+            [controllerDockerRuntimeEnvKey, undefined],
+            [controllerGpuModeEnvKey, undefined]
+          ])
+        )
+
+        const composeFiles = yield* _(resolveControllerComposeFiles())
+        expect(composeFiles.extraOverlayPath).toBe(extraComposePath)
+
+        const recordedExecutorLayer = recordedCommandExecutorLayer(startedCommands, emptyCommandResult)
+        yield* _(
+          runCompose(["up", "-d"]).pipe(
+            Effect.provide(recordedExecutorLayer)
+          )
+        )
+
+        const composeCommand = startedCommands.find((command) =>
+          command.startsWith(`docker compose --project-name ${controllerComposeProjectName} -f `)
+        )
+        expect(composeCommand).toBeDefined()
+        expect(composeCommand).toContain(` -f ${extraComposePath} up -d`)
+      })
+    ).pipe(Effect.provide(NodeContext.layer))
+  })
+
   it.effect("does not initialize the Skiller submodule when package metadata already exists", () => {
     const startedCommands: Array<string> = []
 

packages/app/tests/docker-git/controller-compose.test.ts

@@ -32,7 +32,10 @@
   },
   "homepage": "https://github.com/ProverCoderAI/docker-git#readme",
   "devDependencies": {
+    "@effect/vitest": "^0.29.0",
     "@types/node": "^25.9.3",
+    "effect": "^3.21.3",
+    "fast-check": "^4.8.0",
     "typescript": "^6.0.3",
     "vitest": "^4.1.9"
   },

packages/auth-oauth/package.json

@@ -5,14 +5,22 @@ import { fileURLToPath } from "node:url"
 import { spawn } from "node:child_process"
 
 import {
+  claudeOauthTokenFileMode,
   claudeOauthTokenPath,
   classifyClaudeSetupTokenResult,
   extractClaudeOauthToken,
-  formatClaudeOauthTokenFile
+  flushClaudeOauthTokenRedactionState,
+  formatClaudeOauthTokenFile,
+  initialClaudeOauthTokenRedactionState,
+  redactClaudeOauthTokenChunk,
+  type ClaudeOauthTokenRedactionState
 } from "./claude-oauth-token.js"
 
 export const defaultClaudeDockerOauthImage = "docker-git-auth-claude:latest"
 export const defaultClaudeDockerOauthContainerHome = "/claude-home"
+export const claudeDockerOauthBaseImage =
+  "node:24-bookworm-slim@sha256:b31e7a42fdf8b8aa5f5ed477c72d694301273f1069c5a2f71d53c6482e99a2fc"
+export const claudeDockerOauthClaudeCodeVersion = "2.1.195"
 
 export type ClaudeDockerOauthOptions = {
   readonly cwd?: string
@@ -81,23 +89,19 @@ export type ClaudeDockerProbeStatus =
 
 const outputWindowSize = 262_144
 
-const claudeDockerfile = String.raw`FROM ubuntu:24.04
+export const renderClaudeDockerOauthDockerfile = (): string =>
+  String.raw`FROM ${claudeDockerOauthBaseImage}
 ENV DEBIAN_FRONTEND=noninteractive
 RUN apt-get update \
-  && apt-get install -y --no-install-recommends ca-certificates curl bsdutils \
+  && apt-get install -y --no-install-recommends ca-certificates bsdutils \
   && rm -rf /var/lib/apt/lists/*
-RUN curl -fsSL https://deb.nodesource.com/setup_24.x | bash - \
-  && apt-get install -y --no-install-recommends nodejs \
-  && node -v \
+RUN node -v \
   && npm -v \
-  && rm -rf /var/lib/apt/lists/*
-RUN npm install -g @anthropic-ai/claude-code@latest
+  && npm install -g --no-audit --no-fund @anthropic-ai/claude-code@${claudeDockerOauthClaudeCodeVersion} \
+  && claude --version
 ENTRYPOINT ["claude"]
 `
 
-const redactedOauthTokenText = (text: string): string =>
-  text.replaceAll(/sk-ant-[A-Za-z0-9._-]+/gu, "<redacted-oauth-token>")
-
 const appendOutputWindow = (outputWindow: string, chunk: string): string => {
   const next = `${outputWindow}${chunk}`
   return next.length > outputWindowSize ? next.slice(-outputWindowSize) : next
@@ -138,7 +142,7 @@ const ensureClaudeDockerImage = async (
   }
   const contextPath = await mkdtemp(join(tmpdir(), "docker-git-auth-oauth-image-"))
   try {
-    await writeFile(join(contextPath, "Dockerfile"), claudeDockerfile, "utf8")
+    await writeFile(join(contextPath, "Dockerfile"), renderClaudeDockerOauthDockerfile(), "utf8")
     const exitCode = await runBuild({
       dockerCommand,
       args: ["build", "-t", image, contextPath],
@@ -219,17 +223,36 @@ const runDockerSetupToken = (spec: ClaudeDockerSetupTokenSpec): Promise<ClaudeDo
     const decoder = new TextDecoder("utf-8")
     let outputWindow = ""
     let token: string | null = null
+    let stdoutRedactionState: ClaudeOauthTokenRedactionState = initialClaudeOauthTokenRedactionState
+    let stderrRedactionState: ClaudeOauthTokenRedactionState = initialClaudeOauthTokenRedactionState
+
+    const writeOutput = (fd: 1 | 2, output: string): void => {
+      if (output.length === 0) {
+        return
+      }
+      if (fd === 2) {
+        process.stderr.write(output)
+        return
+      }
+      process.stdout.write(output)
+    }
 
     const capture = (chunk: Uint8Array, fd: 1 | 2): void => {
       const text = decoder.decode(chunk)
       outputWindow = appendOutputWindow(outputWindow, text)
       token = token ?? extractClaudeOauthToken(outputWindow)
-      const output = spec.redactLiveOutput ? redactedOauthTokenText(text) : text
-      if (fd === 2) {
-        process.stderr.write(output)
+      if (!spec.redactLiveOutput) {
+        writeOutput(fd, text)
         return
       }
-      process.stdout.write(output)
+      const state = fd === 2 ? stderrRedactionState : stdoutRedactionState
+      const redacted = redactClaudeOauthTokenChunk(state, text)
+      if (fd === 2) {
+        stderrRedactionState = redacted.state
+      } else {
+        stdoutRedactionState = redacted.state
+      }
+      writeOutput(fd, redacted.output)
     }
 
     child.stdout?.on("data", (chunk: Uint8Array) => {
@@ -240,6 +263,10 @@ const runDockerSetupToken = (spec: ClaudeDockerSetupTokenSpec): Promise<ClaudeDo
     })
     child.on("error", reject)
     child.on("close", (code) => {
+      if (spec.redactLiveOutput) {
+        writeOutput(1, flushClaudeOauthTokenRedactionState(stdoutRedactionState))
+        writeOutput(2, flushClaudeOauthTokenRedactionState(stderrRedactionState))
+      }
       resolveResult({ exitCode: code ?? 1, token })
     })
   })
@@ -259,7 +286,7 @@ const runDockerProbe = (spec: ClaudeDockerProbeSpec): Promise<number> =>
 const writeCapturedToken = async (accountPath: string, token: string): Promise<void> => {
   const tokenPath = claudeOauthTokenPath(accountPath)
   await writeFile(tokenPath, formatClaudeOauthTokenFile(token), "utf8")
-  await chmod(tokenPath, 0o600).catch(() => undefined)
+  await chmod(tokenPath, claudeOauthTokenFileMode)
 }
 
 const dockerProbeStatusFromExitCode = (exitCode: number): ClaudeDockerProbeStatus =>
@@ -361,7 +388,7 @@ const isDirectExecution = (): boolean => {
 }
 
 if (isDirectExecution()) {
-  const printToken = !process.argv.includes("--no-print-token")
+  const printToken = process.argv.includes("--print-token")
   const accountPath = readFlagValue(process.argv, "--account-path")
   const dockerHostPath = readFlagValue(process.argv, "--docker-host-path")
   const image = readFlagValue(process.argv, "--image")