fix(ci): stabilize auto agent selection checks

Author: skulidropek

packages/app/src/docker-git/cli/parser-options.ts

@@ -181,17 +181,34 @@ const legacyAgentFlagError = (token: string): ParseError | null => {
   return null
 }
 
-const parseRawOptionsStep = (
-  args: ReadonlyArray<string>,
-  index: number,
-  raw: RawOptions
+const toParseStep = (
+  parsed: Either.Either<RawOptions, ParseError>,
+  nextIndex: number
+): ParseRawOptionsStep =>
+  Either.isLeft(parsed)
+    ? { _tag: "error", error: parsed.left }
+    : { _tag: "ok", raw: parsed.right, nextIndex }
+
+const parseValueOptionStep = (
+  raw: RawOptions,
+  token: string,
+  value: string | undefined,
+  index: number
 ): ParseRawOptionsStep => {
-  const token = args[index] ?? ""
+  if (value === undefined) {
+    return { _tag: "error", error: { _tag: "MissingOptionValue", option: token } }
+  }
+  return toParseStep(applyCommandValueFlag(raw, token, value), index + 2)
+}
+
+const parseSpecialFlagStep = (
+  raw: RawOptions,
+  token: string,
+  index: number
+): ParseRawOptionsStep | null => {
   const inlineApplied = parseInlineValueToken(raw, token)
   if (inlineApplied !== null) {
-    return Either.isLeft(inlineApplied)
-      ? { _tag: "error", error: inlineApplied.left }
-      : { _tag: "ok", raw: inlineApplied.right, nextIndex: index + 1 }
+    return toParseStep(inlineApplied, index + 1)
   }
 
   const booleanApplied = applyCommandBooleanFlag(raw, token)
@@ -204,19 +221,25 @@ const parseRawOptionsStep = (
     return { _tag: "error", error: deprecatedAgentFlag }
   }
 
-  if (!token.startsWith("-")) {
-    return { _tag: "error", error: { _tag: "UnexpectedArgument", value: token } }
+  return null
+}
+
+const parseRawOptionsStep = (
+  args: ReadonlyArray<string>,
+  index: number,
+  raw: RawOptions
+): ParseRawOptionsStep => {
+  const token = args[index] ?? ""
+  const specialStep = parseSpecialFlagStep(raw, token, index)
+  if (specialStep !== null) {
+    return specialStep
   }
 
-  const value = args[index + 1]
-  if (value === undefined) {
-    return { _tag: "error", error: { _tag: "MissingOptionValue", option: token } }
+  if (!token.startsWith("-")) {
+    return { _tag: "error", error: { _tag: "UnexpectedArgument", value: token } }
   }
 
-  const nextRaw = applyCommandValueFlag(raw, token, value)
-  return Either.isLeft(nextRaw)
-    ? { _tag: "error", error: nextRaw.left }
-    : { _tag: "ok", raw: nextRaw.right, nextIndex: index + 2 }
+  return parseValueOptionStep(raw, token, args[index + 1], index)
 }
 
 export const parseRawOptions = (args: ReadonlyArray<string>): Either.Either<RawOptions, ParseError> => {

packages/lib/src/core/auto-agent-flags.ts

@@ -0,0 +1,24 @@
+import { Either } from "effect"
+
+import type { RawOptions } from "./command-options.js"
+import type { AgentMode, ParseError } from "./domain.js"
+
+export const resolveAutoAgentFlags = (
+  raw: RawOptions
+): Either.Either<{ readonly agentMode: AgentMode | undefined; readonly agentAuto: boolean }, ParseError> => {
+  const requested = raw.agentAutoMode
+  if (requested === undefined) {
+    return Either.right({ agentMode: undefined, agentAuto: false })
+  }
+  if (requested === "auto") {
+    return Either.right({ agentMode: undefined, agentAuto: true })
+  }
+  if (requested === "claude" || requested === "codex") {
+    return Either.right({ agentMode: requested, agentAuto: true })
+  }
+  return Either.left({
+    _tag: "InvalidOption",
+    option: "--auto",
+    reason: "expected one of: claude, codex"
+  })
+}

packages/lib/src/core/command-builders.ts

@@ -1,6 +1,7 @@
 import { Either } from "effect"
 
 import { expandContainerHome } from "../usecases/scrap-path.js"
+import { resolveAutoAgentFlags } from "./auto-agent-flags.js"
 import { type RawOptions } from "./command-options.js"
 import {
   type AgentMode,
@@ -231,26 +232,6 @@ type BuildTemplateConfigInput = {
   readonly agentAuto: boolean
 }
 
-const resolveAutoAgentFlags = (
-  raw: RawOptions
-): Either.Either<{ readonly agentMode: AgentMode | undefined; readonly agentAuto: boolean }, ParseError> => {
-  const requested = raw.agentAutoMode
-  if (requested === undefined) {
-    return Either.right({ agentMode: undefined, agentAuto: false })
-  }
-  if (requested === "auto") {
-    return Either.right({ agentMode: undefined, agentAuto: true })
-  }
-  if (requested === "claude" || requested === "codex") {
-    return Either.right({ agentMode: requested, agentAuto: true })
-  }
-  return Either.left({
-    _tag: "InvalidOption",
-    option: "--auto",
-    reason: "expected one of: claude, codex"
-  })
-}
-
 const buildTemplateConfig = ({
   agentAuto,
   agentMode,

packages/lib/src/core/templates/dockerfile.ts

@@ -64,7 +64,17 @@ RUN claude --version`
 
 const renderDockerfileOpenCode = (): string =>
   `# Tooling: OpenCode (binary)
-RUN curl -fsSL https://opencode.ai/install | HOME=/usr/local bash -s -- --no-modify-path
+RUN set -eu; \
+  for attempt in 1 2 3 4 5; do \
+    if curl -fsSL --retry 5 --retry-all-errors --retry-delay 2 https://opencode.ai/install \
+      | HOME=/usr/local bash -s -- --no-modify-path; then \
+      exit 0; \
+    fi; \
+    echo "opencode install attempt \${attempt} failed; retrying..." >&2; \
+    sleep $((attempt * 2)); \
+  done; \
+  echo "opencode install failed after retries" >&2; \
+  exit 1
 RUN ln -sf /usr/local/.opencode/bin/opencode /usr/local/bin/opencode
 RUN opencode --version`
 

packages/lib/src/usecases/actions/create-project.ts

@@ -198,6 +198,31 @@ const maybeOpenSsh = (
     yield* _(openSshBestEffort(projectConfig, remoteCommand))
   }).pipe(Effect.asVoid)
 
+const resolveFinalAgentConfig = (
+  resolvedConfig: CreateCommand["config"]
+): Effect.Effect<CreateCommand["config"], ParseError | PlatformError, FileSystem.FileSystem | Path.Path> =>
+  Effect.gen(function*(_) {
+    const resolvedAgentMode = yield* _(resolveAutoAgentMode(resolvedConfig))
+    if (
+      (resolvedConfig.agentAuto ?? false) && resolvedConfig.agentMode === undefined && resolvedAgentMode !== undefined
+    ) {
+      yield* _(Effect.log(`Auto agent selected: ${resolvedAgentMode}`))
+    }
+    return resolvedAgentMode === undefined ? resolvedConfig : { ...resolvedConfig, agentMode: resolvedAgentMode }
+  })
+
+const maybeCleanupAfterAgent = (
+  waitForAgent: boolean,
+  resolvedOutDir: string
+): Effect.Effect<void, DockerCommandError | PlatformError, CommandExecutor.CommandExecutor> =>
+  Effect.gen(function*(_) {
+    if (!waitForAgent) {
+      return
+    }
+    yield* _(Effect.log("Agent finished. Cleaning up container..."))
+    yield* _(runDockerDownCleanup(resolvedOutDir))
+  })
+
 const runCreateProject = (
   path: Path.Path,
   command: CreateCommand
@@ -211,15 +236,7 @@ const runCreateProject = (
     const resolvedOutDir = path.resolve(ctx.resolveRootPath(command.outDir))
 
     const resolvedConfig = yield* _(resolveCreateConfig(command, ctx, resolvedOutDir))
-    const resolvedAgentMode = yield* _(resolveAutoAgentMode(resolvedConfig))
-    if (
-      (resolvedConfig.agentAuto ?? false) && resolvedConfig.agentMode === undefined && resolvedAgentMode !== undefined
-    ) {
-      yield* _(Effect.log(`Auto agent selected: ${resolvedAgentMode}`))
-    }
-    const finalConfig = resolvedAgentMode === undefined
-      ? resolvedConfig
-      : { ...resolvedConfig, agentMode: resolvedAgentMode }
+    const finalConfig = yield* _(resolveFinalAgentConfig(resolvedConfig))
     const { globalConfig, projectConfig } = buildProjectConfigs(path, ctx.baseDir, resolvedOutDir, finalConfig)
 
     yield* _(migrateProjectOrchLayout(ctx.baseDir, globalConfig, ctx.resolveRootPath))
@@ -248,10 +265,7 @@ const runCreateProject = (
       yield* _(logDockerAccessInfo(resolvedOutDir, projectConfig))
     }
 
-    if (waitForAgent) {
-      yield* _(Effect.log("Agent finished. Cleaning up container..."))
-      yield* _(runDockerDownCleanup(resolvedOutDir))
-    }
+    yield* _(maybeCleanupAfterAgent(waitForAgent, resolvedOutDir))
 
     yield* _(autoSyncState(`chore(state): update ${formatStateSyncLabel(projectConfig.repoUrl)}`))
     yield* _(maybeOpenSsh(command, hasAgent, waitForAgent, projectConfig))

packages/lib/src/usecases/agent-auto-select.ts

@@ -5,30 +5,14 @@ import { Effect } from "effect"
 
 import type { AgentMode, ParseError, TemplateConfig } from "../core/domain.js"
 import { normalizeAccountLabel } from "./auth-helpers.js"
+import { hasNonEmptyFile } from "./auth-sync-helpers.js"
 
 const autoOptionError = (reason: string): ParseError => ({
   _tag: "InvalidOption",
   option: "--auto",
   reason
 })
 
-const isNonEmptyFile = (
-  fs: FileSystem.FileSystem,
-  filePath: string
-): Effect.Effect<boolean, PlatformError> =>
-  Effect.gen(function*(_) {
-    const exists = yield* _(fs.exists(filePath))
-    if (!exists) {
-      return false
-    }
-    const info = yield* _(fs.stat(filePath))
-    if (info.type !== "File") {
-      return false
-    }
-    const text = yield* _(fs.readFileString(filePath), Effect.orElseSucceed(() => ""))
-    return text.trim().length > 0
-  })
-
 const isRegularFile = (
   fs: FileSystem.FileSystem,
   filePath: string
@@ -51,7 +35,7 @@ const hasCodexAuth = (
   const authPath = normalized === "default"
     ? `${rootPath}/auth.json`
     : `${rootPath}/${normalized}/auth.json`
-  return isNonEmptyFile(fs, authPath)
+  return hasNonEmptyFile(fs, authPath)
 }
 
 const resolveClaudeAccountPath = (rootPath: string, label: string | undefined): ReadonlyArray<string> => {
@@ -69,7 +53,7 @@ const hasClaudeAuth = (
 ): Effect.Effect<boolean, PlatformError> =>
   Effect.gen(function*(_) {
     for (const accountPath of resolveClaudeAccountPath(rootPath, label)) {
-      const oauthToken = yield* _(isNonEmptyFile(fs, `${accountPath}/.oauth-token`))
+      const oauthToken = yield* _(hasNonEmptyFile(fs, `${accountPath}/.oauth-token`))
       if (oauthToken) {
         return true
       }
@@ -88,6 +72,53 @@ const hasClaudeAuth = (
     return false
   })
 
+const resolveClaudeRoot = (codexSharedAuthPath: string): string =>
+  `${codexSharedAuthPath.slice(0, codexSharedAuthPath.lastIndexOf("/"))}/claude`
+
+const resolveAvailableAgentAuth = (
+  fs: FileSystem.FileSystem,
+  config: Pick<TemplateConfig, "claudeAuthLabel" | "codexAuthLabel" | "codexSharedAuthPath">
+): Effect.Effect<{ readonly claudeAvailable: boolean; readonly codexAvailable: boolean }, PlatformError> =>
+  Effect.gen(function*(_) {
+    const claudeAvailable = yield* _(
+      hasClaudeAuth(fs, resolveClaudeRoot(config.codexSharedAuthPath), config.claudeAuthLabel)
+    )
+    const codexAvailable = yield* _(hasCodexAuth(fs, config.codexSharedAuthPath, config.codexAuthLabel))
+    return { claudeAvailable, codexAvailable }
+  })
+
+const resolveExplicitAutoAgentMode = (
+  available: { readonly claudeAvailable: boolean; readonly codexAvailable: boolean },
+  mode: AgentMode | undefined
+): Effect.Effect<AgentMode | undefined, ParseError> => {
+  if (mode === "claude") {
+    return available.claudeAvailable
+      ? Effect.succeed("claude")
+      : Effect.fail(autoOptionError("Claude auth not found"))
+  }
+  if (mode === "codex") {
+    return available.codexAvailable
+      ? Effect.succeed("codex")
+      : Effect.fail(autoOptionError("Codex auth not found"))
+  }
+  return Effect.sync(() => mode)
+}
+
+const pickRandomAutoAgentMode = (
+  available: { readonly claudeAvailable: boolean; readonly codexAvailable: boolean }
+): Effect.Effect<AgentMode, ParseError> => {
+  if (!available.claudeAvailable && !available.codexAvailable) {
+    return Effect.fail(autoOptionError("no Claude or Codex auth found"))
+  }
+  if (available.claudeAvailable && !available.codexAvailable) {
+    return Effect.succeed("claude")
+  }
+  if (!available.claudeAvailable && available.codexAvailable) {
+    return Effect.succeed("codex")
+  }
+  return Effect.sync(() => (process.hrtime.bigint() % 2n === 0n ? "claude" : "codex"))
+}
+
 export const resolveAutoAgentMode = (
   config: Pick<TemplateConfig, "agentAuto" | "agentMode" | "claudeAuthLabel" | "codexAuthLabel" | "codexSharedAuthPath">
 ): Effect.Effect<AgentMode | undefined, ParseError | PlatformError, FileSystem.FileSystem | Path.Path> =>
@@ -98,36 +129,11 @@ export const resolveAutoAgentMode = (
       return config.agentMode
     }
 
-    if (config.agentMode === "claude") {
-      const claudeRoot = `${config.codexSharedAuthPath.slice(0, config.codexSharedAuthPath.lastIndexOf("/"))}/claude`
-      const available = yield* _(hasClaudeAuth(fs, claudeRoot, config.claudeAuthLabel))
-      if (!available) {
-        return yield* _(Effect.fail(autoOptionError("Claude auth not found")))
-      }
-      return "claude"
-    }
-
-    if (config.agentMode === "codex") {
-      const available = yield* _(hasCodexAuth(fs, config.codexSharedAuthPath, config.codexAuthLabel))
-      if (!available) {
-        return yield* _(Effect.fail(autoOptionError("Codex auth not found")))
-      }
-      return "codex"
-    }
-
-    const claudeRoot = `${config.codexSharedAuthPath.slice(0, config.codexSharedAuthPath.lastIndexOf("/"))}/claude`
-    const claudeAvailable = yield* _(hasClaudeAuth(fs, claudeRoot, config.claudeAuthLabel))
-    const codexAvailable = yield* _(hasCodexAuth(fs, config.codexSharedAuthPath, config.codexAuthLabel))
-
-    if (!claudeAvailable && !codexAvailable) {
-      return yield* _(Effect.fail(autoOptionError("no Claude or Codex auth found")))
-    }
-    if (claudeAvailable && !codexAvailable) {
-      return "claude"
-    }
-    if (!claudeAvailable && codexAvailable) {
-      return "codex"
+    const available = yield* _(resolveAvailableAgentAuth(fs, config))
+    const explicitMode = yield* _(resolveExplicitAutoAgentMode(available, config.agentMode))
+    if (explicitMode !== undefined) {
+      return explicitMode
     }
 
-    return process.hrtime.bigint() % 2n === 0n ? "claude" : "codex"
+    return yield* _(pickRandomAutoAgentMode(available))
   })

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

@@ -6,6 +6,7 @@ import { Effect } from "effect"
 import {
   hasClaudeCredentials,
   hasClaudeOauthAccount,
+  hasNonEmptyFile,
   parseJsonRecord,
   resolvePathFromBase
 } from "./auth-sync-helpers.js"
@@ -95,25 +96,6 @@ const syncClaudeCredentialsJson = (
     updateLabel: "Claude credentials"
   })
 
-const hasNonEmptyFile = (
-  fs: FileSystem.FileSystem,
-  filePath: string
-): Effect.Effect<boolean, PlatformError> =>
-  Effect.gen(function*(_) {
-    const exists = yield* _(fs.exists(filePath))
-    if (!exists) {
-      return false
-    }
-
-    const info = yield* _(fs.stat(filePath))
-    if (info.type !== "File") {
-      return false
-    }
-
-    const text = yield* _(fs.readFileString(filePath), Effect.orElseSucceed(() => ""))
-    return text.trim().length > 0
-  })
-
 // CHANGE: seed docker-git Claude auth store from host-level Claude files
 // WHY: Claude Code (v2+) keeps OAuth session in ~/.claude.json and ~/.claude/.credentials.json
 // QUOTE(ТЗ): "глобальная авторизация для клода ... должна сама везде настроиться"