@prover-coder-ai/docker-git 1.0.16 → 1.0.18

package/src/docker-git/menu-input-handler.ts

@@ -1,5 +1,7 @@
+import { handleAuthInput } from "./menu-auth.js"
 import { handleCreateInput } from "./menu-create.js"
 import { handleMenuInput } from "./menu-menu.js"
+import { handleProjectAuthInput } from "./menu-project-auth.js"
 import { handleSelectInput } from "./menu-select.js"
 import type { MenuKeyInput, MenuRunner, MenuState, MenuViewContext, ViewState } from "./menu-types.js"
 
@@ -20,6 +22,8 @@ export type MenuInputContext = MenuViewContext & {
   readonly exit: () => void
 }
 
+type ActiveView = Exclude<ViewState, { readonly _tag: "Menu" }>
+
 const activateInput = (
   input: string,
   key: Pick<MenuKeyInput, "upArrow" | "downArrow" | "return">,
@@ -59,43 +63,79 @@ const shouldHandleMenuInput = (
   return activation.allowProcessing
 }
 
-export const handleUserInput = (
+const handleMenuViewInput = (
   input: string,
   key: MenuKeyInput,
   context: MenuInputContext
 ) => {
-  if (context.busy || context.sshActive) {
+  if (!shouldHandleMenuInput(input, key, context)) {
     return
   }
+  handleMenuInput(input, key, {
+    selected: context.selected,
+    setSelected: context.setSelected,
+    state: context.state,
+    runner: context.runner,
+    exit: context.exit,
+    setView: context.setView,
+    setMessage: context.setMessage,
+    setActiveDir: context.setActiveDir
+  })
+}
 
-  if (context.view._tag === "Menu") {
-    if (!shouldHandleMenuInput(input, key, context)) {
-      return
-    }
-    handleMenuInput(input, key, {
-      selected: context.selected,
-      setSelected: context.setSelected,
-      state: context.state,
-      runner: context.runner,
-      exit: context.exit,
-      setView: context.setView,
-      setMessage: context.setMessage
-    })
-    return
-  }
+const handleCreateViewInput = (
+  input: string,
+  key: MenuKeyInput,
+  view: Extract<ViewState, { readonly _tag: "Create" }>,
+  context: MenuInputContext
+) => {
+  handleCreateInput(input, key, view, {
+    state: context.state,
+    setView: context.setView,
+    setMessage: context.setMessage,
+    runner: context.runner,
+    setActiveDir: context.setActiveDir
+  })
+}
 
-  if (context.view._tag === "Create") {
-    handleCreateInput(input, key, context.view, {
-      state: context.state,
-      setView: context.setView,
-      setMessage: context.setMessage,
-      runner: context.runner,
-      setActiveDir: context.setActiveDir
-    })
-    return
-  }
+const handleAuthViewInput = (
+  input: string,
+  key: MenuKeyInput,
+  view: Extract<ViewState, { readonly _tag: "AuthMenu" | "AuthPrompt" }>,
+  context: MenuInputContext
+) => {
+  handleAuthInput(input, key, view, {
+    state: context.state,
+    setView: context.setView,
+    setMessage: context.setMessage,
+    setActiveDir: context.setActiveDir,
+    runner: context.runner,
+    setSshActive: context.setSshActive,
+    setSkipInputs: context.setSkipInputs
+  })
+}
 
-  handleSelectInput(input, key, context.view, {
+const handleProjectAuthViewInput = (
+  input: string,
+  key: MenuKeyInput,
+  view: Extract<ViewState, { readonly _tag: "ProjectAuthMenu" | "ProjectAuthPrompt" }>,
+  context: MenuInputContext
+) => {
+  handleProjectAuthInput(input, key, view, {
+    runner: context.runner,
+    setView: context.setView,
+    setMessage: context.setMessage,
+    setActiveDir: context.setActiveDir
+  })
+}
+
+const handleSelectViewInput = (
+  input: string,
+  key: MenuKeyInput,
+  view: Extract<ViewState, { readonly _tag: "SelectProject" }>,
+  context: MenuInputContext
+) => {
+  handleSelectInput(input, key, view, {
     setView: context.setView,
     setMessage: context.setMessage,
     setActiveDir: context.setActiveDir,
@@ -105,3 +145,39 @@ export const handleUserInput = (
     setSkipInputs: context.setSkipInputs
   })
 }
+
+const handleActiveViewInput = (
+  input: string,
+  key: MenuKeyInput,
+  view: ActiveView,
+  context: MenuInputContext
+) => {
+  if (view._tag === "Create") {
+    handleCreateViewInput(input, key, view, context)
+    return
+  }
+  if (view._tag === "AuthMenu" || view._tag === "AuthPrompt") {
+    handleAuthViewInput(input, key, view, context)
+    return
+  }
+  if (view._tag === "ProjectAuthMenu" || view._tag === "ProjectAuthPrompt") {
+    handleProjectAuthViewInput(input, key, view, context)
+    return
+  }
+  handleSelectViewInput(input, key, view, context)
+}
+
+export const handleUserInput = (
+  input: string,
+  key: MenuKeyInput,
+  context: MenuInputContext
+) => {
+  if (context.busy || context.sshActive) {
+    return
+  }
+  if (context.view._tag === "Menu") {
+    handleMenuViewInput(input, key, context)
+    return
+  }
+  handleActiveViewInput(input, key, context.view, context)
+}

package/src/docker-git/menu-input-utils.ts

@@ -0,0 +1,85 @@
+export const parseMenuIndex = (input: string): number | null => {
+  const trimmed = input.trim()
+  if (trimmed.length === 0) {
+    return null
+  }
+  const parsed = Number(trimmed)
+  if (!Number.isInteger(parsed)) {
+    return null
+  }
+  const index = parsed - 1
+  return index >= 0 ? index : null
+}
+
+type PromptStep = {
+  readonly key: string
+  readonly label: string
+  readonly required: boolean
+}
+
+type PromptView = {
+  readonly step: number
+  readonly buffer: string
+  readonly values: Readonly<Record<string, string>>
+}
+
+type PromptContext<V extends PromptView> = {
+  readonly setView: (view: V) => void
+  readonly setMessage: (message: string | null) => void
+}
+
+export const submitPromptStep = <V extends PromptView>(
+  view: V,
+  steps: ReadonlyArray<PromptStep>,
+  context: PromptContext<V>,
+  onCancel: () => void,
+  onSubmit: (values: Readonly<Record<string, string>>) => void
+): void => {
+  const step = steps[view.step]
+  if (!step) {
+    onCancel()
+    return
+  }
+
+  const value = view.buffer.trim()
+  if (step.required && value.length === 0) {
+    context.setMessage(`${step.label} is required.`)
+    return
+  }
+
+  const nextValues: Readonly<Record<string, string>> = { ...view.values, [step.key]: value }
+  const nextStep = view.step + 1
+  if (nextStep < steps.length) {
+    context.setView({ ...view, step: nextStep, buffer: "", values: nextValues })
+    context.setMessage(null)
+    return
+  }
+
+  onSubmit(nextValues)
+}
+
+type MenuNumberInputContext = {
+  readonly setMessage: (message: string | null) => void
+}
+
+export const handleMenuNumberInput = <A>(
+  input: string,
+  context: MenuNumberInputContext,
+  actionByIndex: (index: number) => A | null,
+  runAction: (action: A) => void
+): void => {
+  const index = parseMenuIndex(input)
+  if (index === null) {
+    if (input.trim().length > 0) {
+      context.setMessage("Use arrows + Enter, or type a number from the list.")
+    }
+    return
+  }
+
+  const action = actionByIndex(index)
+  if (action === null) {
+    context.setMessage(`Unknown action: ${input.trim()}`)
+    return
+  }
+  runAction(action)
+}

package/src/docker-git/menu-labeled-env.ts

@@ -0,0 +1,37 @@
+import { parseEnvEntries } from "@effect-template/lib/usecases/env-file"
+
+export const normalizeLabel = (value: string): string => {
+  const trimmed = value.trim()
+  if (trimmed.length === 0) {
+    return ""
+  }
+  const normalized = trimmed
+    .toUpperCase()
+    .replaceAll(/[^A-Z0-9]+/g, "_")
+
+  let start = 0
+  while (start < normalized.length && normalized[start] === "_") {
+    start += 1
+  }
+  let end = normalized.length
+  while (end > start && normalized[end - 1] === "_") {
+    end -= 1
+  }
+  const cleaned = normalized.slice(start, end)
+  return cleaned.length > 0 ? cleaned : ""
+}
+
+export const buildLabeledEnvKey = (baseKey: string, label: string): string => {
+  const normalized = normalizeLabel(label)
+  if (normalized.length === 0 || normalized === "DEFAULT") {
+    return baseKey
+  }
+  return `${baseKey}__${normalized}`
+}
+
+export const countKeyEntries = (envText: string, baseKey: string): number => {
+  const prefix = `${baseKey}__`
+  return parseEnvEntries(envText)
+    .filter((entry) => entry.value.trim().length > 0 && (entry.key === baseKey || entry.key.startsWith(prefix)))
+    .length
+}

package/src/docker-git/menu-project-auth-claude.ts

@@ -0,0 +1,70 @@
+import type { PlatformError } from "@effect/platform/Error"
+import type * as FileSystem from "@effect/platform/FileSystem"
+import { Effect } from "effect"
+
+const oauthTokenFileName = ".oauth-token"
+const legacyConfigFileName = ".config.json"
+
+const hasFileAtPath = (
+  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))
+    return info.type === "File"
+  })
+
+const hasNonEmptyOauthToken = (
+  fs: FileSystem.FileSystem,
+  tokenPath: string
+): Effect.Effect<boolean, PlatformError> =>
+  Effect.gen(function*(_) {
+    const hasFile = yield* _(hasFileAtPath(fs, tokenPath))
+    if (!hasFile) {
+      return false
+    }
+    const tokenValue = yield* _(fs.readFileString(tokenPath), Effect.orElseSucceed(() => ""))
+    return tokenValue.trim().length > 0
+  })
+
+const hasLegacyClaudeAuthFile = (
+  fs: FileSystem.FileSystem,
+  accountPath: string
+): Effect.Effect<boolean, PlatformError> =>
+  Effect.gen(function*(_) {
+    const entries = yield* _(fs.readDirectory(accountPath))
+    for (const entry of entries) {
+      if (!entry.startsWith(".claude") || !entry.endsWith(".json")) {
+        continue
+      }
+      const isFile = yield* _(hasFileAtPath(fs, `${accountPath}/${entry}`))
+      if (isFile) {
+        return true
+      }
+    }
+    return false
+  })
+
+export const hasClaudeAccountCredentials = (
+  fs: FileSystem.FileSystem,
+  accountPath: string
+): Effect.Effect<boolean, PlatformError> =>
+  hasFileAtPath(fs, `${accountPath}/${legacyConfigFileName}`).pipe(
+    Effect.flatMap((hasConfig) => {
+      if (hasConfig) {
+        return Effect.succeed(true)
+      }
+      return hasNonEmptyOauthToken(fs, `${accountPath}/${oauthTokenFileName}`).pipe(
+        Effect.flatMap((hasOauthToken) => {
+          if (hasOauthToken) {
+            return Effect.succeed(true)
+          }
+          return hasLegacyClaudeAuthFile(fs, accountPath)
+        })
+      )
+    })
+  )

package/src/docker-git/menu-project-auth-data.ts

@@ -0,0 +1,292 @@
+import * as FileSystem from "@effect/platform/FileSystem"
+import * as Path from "@effect/platform/Path"
+import { Effect, Match, pipe } from "effect"
+
+import { AuthError } from "@effect-template/lib/shell/errors"
+import { normalizeAccountLabel } from "@effect-template/lib/usecases/auth-helpers"
+import { ensureEnvFile, findEnvValue, readEnvText, upsertEnvKey } from "@effect-template/lib/usecases/env-file"
+import type { AppError } from "@effect-template/lib/usecases/errors"
+import { defaultProjectsRoot } from "@effect-template/lib/usecases/menu-helpers"
+import type { ProjectItem } from "@effect-template/lib/usecases/projects"
+import { autoSyncState } from "@effect-template/lib/usecases/state-repo"
+
+import { countAuthAccountDirectories } from "./menu-auth-helpers.js"
+import { buildLabeledEnvKey, countKeyEntries, normalizeLabel } from "./menu-labeled-env.js"
+import { hasClaudeAccountCredentials } from "./menu-project-auth-claude.js"
+import type { MenuEnv, ProjectAuthFlow, ProjectAuthSnapshot } from "./menu-types.js"
+
+export type ProjectAuthMenuAction = ProjectAuthFlow | "Refresh" | "Back"
+
+type ProjectAuthMenuItem = {
+  readonly action: ProjectAuthMenuAction
+  readonly label: string
+}
+
+export type ProjectAuthPromptStep = {
+  readonly key: "label"
+  readonly label: string
+  readonly required: boolean
+  readonly secret: boolean
+}
+
+const projectAuthMenuItems: ReadonlyArray<ProjectAuthMenuItem> = [
+  { action: "ProjectGithubConnect", label: "Project: GitHub connect label" },
+  { action: "ProjectGithubDisconnect", label: "Project: GitHub disconnect" },
+  { action: "ProjectGitConnect", label: "Project: Git connect label" },
+  { action: "ProjectGitDisconnect", label: "Project: Git disconnect" },
+  { action: "ProjectClaudeConnect", label: "Project: Claude connect label" },
+  { action: "ProjectClaudeDisconnect", label: "Project: Claude disconnect" },
+  { action: "Refresh", label: "Refresh snapshot" },
+  { action: "Back", label: "Back to main menu" }
+]
+
+const flowSteps: Readonly<Record<ProjectAuthFlow, ReadonlyArray<ProjectAuthPromptStep>>> = {
+  ProjectGithubConnect: [
+    { key: "label", label: "Label (empty = default)", required: false, secret: false }
+  ],
+  ProjectGithubDisconnect: [],
+  ProjectGitConnect: [
+    { key: "label", label: "Label (empty = default)", required: false, secret: false }
+  ],
+  ProjectGitDisconnect: [],
+  ProjectClaudeConnect: [
+    { key: "label", label: "Label (empty = default)", required: false, secret: false }
+  ],
+  ProjectClaudeDisconnect: []
+}
+
+const resolveCanonicalLabel = (value: string): string => {
+  const normalized = normalizeLabel(value)
+  return normalized.length === 0 || normalized === "DEFAULT" ? "default" : normalized
+}
+
+const githubTokenBaseKey = "GITHUB_TOKEN"
+const gitTokenBaseKey = "GIT_AUTH_TOKEN"
+const gitUserBaseKey = "GIT_AUTH_USER"
+
+const projectGithubLabelKey = "GITHUB_AUTH_LABEL"
+const projectGitLabelKey = "GIT_AUTH_LABEL"
+const projectClaudeLabelKey = "CLAUDE_AUTH_LABEL"
+
+const defaultGitUser = "x-access-token"
+
+type ProjectAuthEnvText = {
+  readonly fs: FileSystem.FileSystem
+  readonly path: Path.Path
+  readonly globalEnvPath: string
+  readonly projectEnvPath: string
+  readonly claudeAuthPath: string
+  readonly globalEnvText: string
+  readonly projectEnvText: string
+}
+
+const buildGlobalEnvPath = (cwd: string): string => `${defaultProjectsRoot(cwd)}/.orch/env/global.env`
+const buildClaudeAuthPath = (cwd: string): string => `${defaultProjectsRoot(cwd)}/.orch/auth/claude`
+
+const loadProjectAuthEnvText = (
+  project: ProjectItem
+): Effect.Effect<ProjectAuthEnvText, AppError, MenuEnv> =>
+  Effect.gen(function*(_) {
+    const fs = yield* _(FileSystem.FileSystem)
+    const path = yield* _(Path.Path)
+    const globalEnvPath = buildGlobalEnvPath(process.cwd())
+    const claudeAuthPath = buildClaudeAuthPath(process.cwd())
+    yield* _(ensureEnvFile(fs, path, globalEnvPath))
+    yield* _(ensureEnvFile(fs, path, project.envProjectPath))
+    const globalEnvText = yield* _(readEnvText(fs, globalEnvPath))
+    const projectEnvText = yield* _(readEnvText(fs, project.envProjectPath))
+    return {
+      fs,
+      path,
+      globalEnvPath,
+      projectEnvPath: project.envProjectPath,
+      claudeAuthPath,
+      globalEnvText,
+      projectEnvText
+    }
+  })
+
+export const readProjectAuthSnapshot = (
+  project: ProjectItem
+): Effect.Effect<ProjectAuthSnapshot, AppError, MenuEnv> =>
+  pipe(
+    loadProjectAuthEnvText(project),
+    Effect.flatMap(({ claudeAuthPath, fs, globalEnvPath, globalEnvText, path, projectEnvPath, projectEnvText }) =>
+      pipe(
+        countAuthAccountDirectories(fs, path, claudeAuthPath),
+        Effect.map((claudeAuthEntries) => ({
+          projectDir: project.projectDir,
+          projectName: project.displayName,
+          envGlobalPath: globalEnvPath,
+          envProjectPath: projectEnvPath,
+          claudeAuthPath,
+          githubTokenEntries: countKeyEntries(globalEnvText, githubTokenBaseKey),
+          gitTokenEntries: countKeyEntries(globalEnvText, gitTokenBaseKey),
+          claudeAuthEntries,
+          activeGithubLabel: findEnvValue(projectEnvText, projectGithubLabelKey),
+          activeGitLabel: findEnvValue(projectEnvText, projectGitLabelKey),
+          activeClaudeLabel: findEnvValue(projectEnvText, projectClaudeLabelKey)
+        }))
+      )
+    )
+  )
+
+const missingSecret = (
+  provider: string,
+  label: string,
+  envPath: string
+): AuthError =>
+  new AuthError({
+    message: `${provider} not connected: label '${label}' not found in ${envPath}`
+  })
+
+type ProjectEnvUpdateSpec = {
+  readonly fs: FileSystem.FileSystem
+  readonly rawLabel: string
+  readonly canonicalLabel: string
+  readonly globalEnvPath: string
+  readonly globalEnvText: string
+  readonly projectEnvText: string
+  readonly claudeAuthPath: string
+}
+
+const updateProjectGithubConnect = (spec: ProjectEnvUpdateSpec): Effect.Effect<string, AppError> => {
+  const key = buildLabeledEnvKey(githubTokenBaseKey, spec.rawLabel)
+  const token = findEnvValue(spec.globalEnvText, key)
+  if (token === null) {
+    return Effect.fail(missingSecret("GitHub token", spec.canonicalLabel, spec.globalEnvPath))
+  }
+  const withGitToken = upsertEnvKey(spec.projectEnvText, "GIT_AUTH_TOKEN", token)
+  const withGhToken = upsertEnvKey(withGitToken, "GH_TOKEN", token)
+  const withoutGitLabel = upsertEnvKey(withGhToken, projectGitLabelKey, "")
+  return Effect.succeed(upsertEnvKey(withoutGitLabel, projectGithubLabelKey, spec.canonicalLabel))
+}
+
+const clearProjectGitLabels = (envText: string): string => {
+  const withoutGhToken = upsertEnvKey(envText, "GH_TOKEN", "")
+  const withoutGitLabel = upsertEnvKey(withoutGhToken, projectGitLabelKey, "")
+  return upsertEnvKey(withoutGitLabel, projectGithubLabelKey, "")
+}
+
+const updateProjectGithubDisconnect = (spec: ProjectEnvUpdateSpec): Effect.Effect<string> => {
+  const withoutGitToken = upsertEnvKey(spec.projectEnvText, "GIT_AUTH_TOKEN", "")
+  return Effect.succeed(clearProjectGitLabels(withoutGitToken))
+}
+
+const updateProjectGitConnect = (spec: ProjectEnvUpdateSpec): Effect.Effect<string, AppError> => {
+  const tokenKey = buildLabeledEnvKey(gitTokenBaseKey, spec.rawLabel)
+  const userKey = buildLabeledEnvKey(gitUserBaseKey, spec.rawLabel)
+  const token = findEnvValue(spec.globalEnvText, tokenKey)
+  if (token === null) {
+    return Effect.fail(missingSecret("Git credentials", spec.canonicalLabel, spec.globalEnvPath))
+  }
+  const defaultUser = findEnvValue(spec.globalEnvText, gitUserBaseKey) ?? defaultGitUser
+  const user = findEnvValue(spec.globalEnvText, userKey) ?? defaultUser
+  const withToken = upsertEnvKey(spec.projectEnvText, "GIT_AUTH_TOKEN", token)
+  const withUser = upsertEnvKey(withToken, "GIT_AUTH_USER", user)
+  const withGhToken = upsertEnvKey(withUser, "GH_TOKEN", token)
+  const withGitLabel = upsertEnvKey(withGhToken, projectGitLabelKey, spec.canonicalLabel)
+  return Effect.succeed(upsertEnvKey(withGitLabel, projectGithubLabelKey, spec.canonicalLabel))
+}
+
+const updateProjectGitDisconnect = (spec: ProjectEnvUpdateSpec): Effect.Effect<string> => {
+  const withoutToken = upsertEnvKey(spec.projectEnvText, "GIT_AUTH_TOKEN", "")
+  const withoutUser = upsertEnvKey(withoutToken, "GIT_AUTH_USER", "")
+  return Effect.succeed(clearProjectGitLabels(withoutUser))
+}
+
+const updateProjectClaudeConnect = (spec: ProjectEnvUpdateSpec): Effect.Effect<string, AppError> => {
+  const accountLabel = normalizeAccountLabel(spec.rawLabel, "default")
+  const accountPath = `${spec.claudeAuthPath}/${accountLabel}`
+  return Effect.gen(function*(_) {
+    const exists = yield* _(spec.fs.exists(accountPath))
+    if (!exists) {
+      return yield* _(Effect.fail(missingSecret("Claude Code login", spec.canonicalLabel, spec.claudeAuthPath)))
+    }
+
+    const hasCredentials = yield* _(
+      hasClaudeAccountCredentials(spec.fs, accountPath),
+      Effect.orElseSucceed(() => false)
+    )
+    if (hasCredentials) {
+      return upsertEnvKey(spec.projectEnvText, projectClaudeLabelKey, spec.canonicalLabel)
+    }
+
+    return yield* _(Effect.fail(missingSecret("Claude Code login", spec.canonicalLabel, spec.claudeAuthPath)))
+  })
+}
+
+const updateProjectClaudeDisconnect = (spec: ProjectEnvUpdateSpec): Effect.Effect<string> => {
+  return Effect.succeed(upsertEnvKey(spec.projectEnvText, projectClaudeLabelKey, ""))
+}
+
+const resolveProjectEnvUpdate = (
+  flow: ProjectAuthFlow,
+  spec: ProjectEnvUpdateSpec
+): Effect.Effect<string, AppError> =>
+  Match.value(flow).pipe(
+    Match.when("ProjectGithubConnect", () => updateProjectGithubConnect(spec)),
+    Match.when("ProjectGithubDisconnect", () => updateProjectGithubDisconnect(spec)),
+    Match.when("ProjectGitConnect", () => updateProjectGitConnect(spec)),
+    Match.when("ProjectGitDisconnect", () => updateProjectGitDisconnect(spec)),
+    Match.when("ProjectClaudeConnect", () => updateProjectClaudeConnect(spec)),
+    Match.when("ProjectClaudeDisconnect", () => updateProjectClaudeDisconnect(spec)),
+    Match.exhaustive
+  )
+
+export const writeProjectAuthFlow = (
+  project: ProjectItem,
+  flow: ProjectAuthFlow,
+  values: Readonly<Record<string, string>>
+): Effect.Effect<void, AppError, MenuEnv> =>
+  pipe(
+    loadProjectAuthEnvText(project),
+    Effect.flatMap(({ claudeAuthPath, fs, globalEnvPath, globalEnvText, projectEnvPath, projectEnvText }) => {
+      const rawLabel = values["label"] ?? ""
+      const canonicalLabel = resolveCanonicalLabel(rawLabel)
+      const spec: ProjectEnvUpdateSpec = {
+        fs,
+        rawLabel,
+        canonicalLabel,
+        globalEnvPath,
+        globalEnvText,
+        projectEnvText,
+        claudeAuthPath
+      }
+      const nextProjectEnv = resolveProjectEnvUpdate(flow, spec)
+      const syncMessage = Match.value(flow).pipe(
+        Match.when("ProjectGithubConnect", () =>
+          `chore(state): project auth gh ${canonicalLabel} ${project.displayName}`),
+        Match.when("ProjectGithubDisconnect", () =>
+          `chore(state): project auth gh logout ${project.displayName}`),
+        Match.when(
+          "ProjectGitConnect",
+          () => `chore(state): project auth git ${canonicalLabel} ${project.displayName}`
+        ),
+        Match.when("ProjectGitDisconnect", () => `chore(state): project auth git logout ${project.displayName}`),
+        Match.when(
+          "ProjectClaudeConnect",
+          () => `chore(state): project auth claude ${canonicalLabel} ${project.displayName}`
+        ),
+        Match.when("ProjectClaudeDisconnect", () => `chore(state): project auth claude logout ${project.displayName}`),
+        Match.exhaustive
+      )
+      return pipe(
+        nextProjectEnv,
+        Effect.flatMap((nextText) => fs.writeFileString(projectEnvPath, nextText)),
+        Effect.zipRight(autoSyncState(syncMessage))
+      )
+    }),
+    Effect.asVoid
+  )
+
+export const projectAuthViewSteps = (flow: ProjectAuthFlow): ReadonlyArray<ProjectAuthPromptStep> => flowSteps[flow]
+
+export const projectAuthMenuLabels = (): ReadonlyArray<string> => projectAuthMenuItems.map((item) => item.label)
+
+export const projectAuthMenuActionByIndex = (index: number): ProjectAuthMenuAction | null => {
+  const item = projectAuthMenuItems[index]
+  return item ? item.action : null
+}
+
+export const projectAuthMenuSize = (): number => projectAuthMenuItems.length