fix(auto): cover api and selection edge cases

Author: skulidropek

packages/api/src/api/contracts.ts

@@ -49,6 +49,7 @@ export type CreateProjectRequest = {
   readonly gitTokenLabel?: string | undefined
   readonly codexTokenLabel?: string | undefined
   readonly claudeTokenLabel?: string | undefined
+  readonly agentAutoMode?: string | undefined
   readonly up?: boolean | undefined
   readonly openSsh?: boolean | undefined
   readonly force?: boolean | undefined

packages/api/src/api/schema.ts

@@ -25,6 +25,7 @@ export const CreateProjectRequestSchema = Schema.Struct({
   gitTokenLabel: OptionalString,
   codexTokenLabel: OptionalString,
   claudeTokenLabel: OptionalString,
+  agentAutoMode: OptionalString,
   up: OptionalBoolean,
   openSsh: OptionalBoolean,
   force: OptionalBoolean,

packages/api/src/services/projects.ts

@@ -199,6 +199,7 @@ export const createProjectFromRequest = (
       ...(request.gitTokenLabel === undefined ? {} : { gitTokenLabel: request.gitTokenLabel }),
       ...(request.codexTokenLabel === undefined ? {} : { codexTokenLabel: request.codexTokenLabel }),
       ...(request.claudeTokenLabel === undefined ? {} : { claudeTokenLabel: request.claudeTokenLabel }),
+      ...(request.agentAutoMode === undefined ? {} : { agentAutoMode: request.agentAutoMode }),
       ...(request.up === undefined ? {} : { up: request.up }),
       ...(request.openSsh === undefined ? {} : { openSsh: request.openSsh }),
       ...(request.force === undefined ? {} : { force: request.force }),

packages/app/src/docker-git/cli/usage.ts

@@ -65,7 +65,7 @@ Options:
   --up | --no-up            Run docker compose up after init (default: --up)
   --ssh | --no-ssh          Auto-open SSH after create/clone (default: clone=--ssh, create=--no-ssh)
   --mcp-playwright | --no-mcp-playwright  Enable Playwright MCP + Chromium sidecar (default: --no-mcp-playwright)
-  --auto[=claude|codex]     Auto-execute an agent; without value picks one by available auth
+  --auto[=claude|codex]     Auto-execute an agent; without value picks by auth, random if both are available
   --force                   Overwrite existing files and wipe compose volumes (docker compose down -v)
   --force-env               Reset project env defaults only (keep workspace volume/data)
   -h, --help                Show this help

packages/app/tests/docker-git/parser.test.ts

@@ -128,6 +128,9 @@ describe("parseArgs", () => {
   it.effect("rejects legacy --claude flag", () =>
     expectParseErrorTag(["clone", "https://github.com/org/repo.git", "--claude", "--auto"], "InvalidOption"))
 
+  it.effect("rejects legacy --codex flag", () =>
+    expectParseErrorTag(["clone", "https://github.com/org/repo.git", "--codex", "--auto"], "InvalidOption"))
+
   it.effect("rejects invalid --auto value", () =>
     expectParseErrorTag(["clone", "https://github.com/org/repo.git", "--auto=foo"], "InvalidOption"))
 

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

@@ -212,6 +212,9 @@ const runCreateProject = (
 
     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 { globalConfig, projectConfig } = buildProjectConfigs(path, ctx.baseDir, resolvedOutDir, finalConfig)
 

packages/lib/tests/usecases/agent-auto-select.test.ts

@@ -3,6 +3,7 @@ import * as Path from "@effect/platform/Path"
 import { NodeContext } from "@effect/platform-node"
 import { describe, expect, it } from "@effect/vitest"
 import { Effect } from "effect"
+import { vi } from "vitest"
 
 import type { TemplateConfig } from "../../src/core/domain.js"
 import { resolveAutoAgentMode } from "../../src/usecases/agent-auto-select.js"
@@ -62,6 +63,22 @@ describe("resolveAutoAgentMode", () => {
       })
     ).pipe(Effect.provide(NodeContext.layer)))
 
+  it.effect("keeps explicit Claude mode when Claude auth exists", () =>
+    withTempDir((root) =>
+      Effect.gen(function*(_) {
+        const fs = yield* _(FileSystem.FileSystem)
+        const path = yield* _(Path.Path)
+        const config = { ...makeConfig(root, path), agentMode: "claude" as const }
+        const claudeRoot = path.join(root, ".orch/auth/claude/default")
+
+        yield* _(fs.makeDirectory(claudeRoot, { recursive: true }))
+        yield* _(fs.writeFileString(path.join(claudeRoot, ".oauth-token"), "token\n"))
+
+        const mode = yield* _(resolveAutoAgentMode(config))
+        expect(mode).toBe("claude")
+      })
+    ).pipe(Effect.provide(NodeContext.layer)))
+
   it.effect("chooses Codex when only Codex auth exists", () =>
     withTempDir((root) =>
       Effect.gen(function*(_) {
@@ -78,6 +95,89 @@ describe("resolveAutoAgentMode", () => {
       })
     ).pipe(Effect.provide(NodeContext.layer)))
 
+  it.effect("keeps explicit Codex mode when Codex auth exists", () =>
+    withTempDir((root) =>
+      Effect.gen(function*(_) {
+        const fs = yield* _(FileSystem.FileSystem)
+        const path = yield* _(Path.Path)
+        const config = { ...makeConfig(root, path), agentMode: "codex" as const }
+        const codexRoot = path.join(root, ".orch/auth/codex")
+
+        yield* _(fs.makeDirectory(codexRoot, { recursive: true }))
+        yield* _(fs.writeFileString(path.join(codexRoot, "auth.json"), "{\"ok\":true}\n"))
+
+        const mode = yield* _(resolveAutoAgentMode(config))
+        expect(mode).toBe("codex")
+      })
+    ).pipe(Effect.provide(NodeContext.layer)))
+
+  it.effect("chooses randomly when both Claude and Codex auth exist", () =>
+    withTempDir((root) =>
+      Effect.gen(function*(_) {
+        const fs = yield* _(FileSystem.FileSystem)
+        const path = yield* _(Path.Path)
+        const config = makeConfig(root, path)
+        const claudeRoot = path.join(root, ".orch/auth/claude/default")
+        const codexRoot = path.join(root, ".orch/auth/codex")
+
+        yield* _(fs.makeDirectory(claudeRoot, { recursive: true }))
+        yield* _(fs.makeDirectory(codexRoot, { recursive: true }))
+        yield* _(fs.writeFileString(path.join(claudeRoot, ".oauth-token"), "token\n"))
+        yield* _(fs.writeFileString(path.join(codexRoot, "auth.json"), "{\"ok\":true}\n"))
+
+        const previousRandom = Math.random
+        yield* _(Effect.addFinalizer(() =>
+          Effect.sync(() => {
+            Math.random = previousRandom
+          })
+        ))
+
+        yield* _(Effect.sync(() => {
+          Math.random = vi.fn(() => 0.1)
+        }))
+        const claudeMode = yield* _(resolveAutoAgentMode(config))
+        expect(claudeMode).toBe("claude")
+
+        yield* _(Effect.sync(() => {
+          Math.random = vi.fn(() => 0.9)
+        }))
+        const codexMode = yield* _(resolveAutoAgentMode(config))
+        expect(codexMode).toBe("codex")
+      })
+    ).pipe(Effect.provide(NodeContext.layer)))
+
+  it.effect("fails explicit Claude mode when Claude auth is missing", () =>
+    withTempDir((root) =>
+      Effect.gen(function*(_) {
+        const path = yield* _(Path.Path)
+        const config = { ...makeConfig(root, path), agentMode: "claude" as const }
+
+        const exit = yield* _(
+          resolveAutoAgentMode(config).pipe(
+            Effect.flip,
+            Effect.map((error) => error._tag)
+          )
+        )
+        expect(exit).toBe("InvalidOption")
+      })
+    ).pipe(Effect.provide(NodeContext.layer)))
+
+  it.effect("fails explicit Codex mode when Codex auth is missing", () =>
+    withTempDir((root) =>
+      Effect.gen(function*(_) {
+        const path = yield* _(Path.Path)
+        const config = { ...makeConfig(root, path), agentMode: "codex" as const }
+
+        const exit = yield* _(
+          resolveAutoAgentMode(config).pipe(
+            Effect.flip,
+            Effect.map((error) => error._tag)
+          )
+        )
+        expect(exit).toBe("InvalidOption")
+      })
+    ).pipe(Effect.provide(NodeContext.layer)))
+
   it.effect("fails when no auth exists", () =>
     withTempDir((root) =>
       Effect.gen(function*(_) {