@prover-coder-ai/docker-git 1.0.23 → 1.0.24

package/src/docker-git/cli/read-command.ts

@@ -1,26 +0,0 @@
-import { Effect, Either, pipe } from "effect"
-
-import { type Command, type ParseError } from "@effect-template/lib/core/domain"
-
-import { parseArgs } from "./parser.js"
-
-// CHANGE: read and parse CLI arguments from process.argv
-// WHY: keep IO at the boundary and delegate parsing to CORE
-// QUOTE(ТЗ): "Надо написать CLI команду"
-// REF: user-request-2026-01-07
-// SOURCE: n/a
-// FORMAT THEOREM: forall argv: read(argv) -> parse(argv)
-// PURITY: SHELL
-// EFFECT: Effect<Command, ParseError, never>
-// INVARIANT: errors are typed as ParseError
-// COMPLEXITY: O(n) where n = |argv|
-export const readCommand: Effect.Effect<Command, ParseError> = pipe(
-  Effect.sync(() => process.argv.slice(2)),
-  Effect.map((args) => parseArgs(args)),
-  Effect.flatMap((result) =>
-    Either.match(result, {
-      onLeft: (error) => Effect.fail(error),
-      onRight: (command) => Effect.succeed(command)
-    })
-  )
-)

package/src/docker-git/cli/usage.ts

@@ -1,131 +0,0 @@
-import { Match } from "effect"
-
-import type { ParseError } from "@effect-template/lib/core/domain"
-
-export const usageText = `docker-git menu
-docker-git create [--repo-url <url>] [options]
-docker-git clone <url> [options]
-docker-git open [<url>] [options]
-docker-git apply [<url>] [options]
-docker-git mcp-playwright [<url>] [options]
-docker-git attach [<url>] [options]
-docker-git panes [<url>] [options]
-docker-git scrap <action> [<url>] [options]
-docker-git sessions [list] [<url>] [options]
-docker-git sessions kill <pid> [<url>] [options]
-docker-git sessions logs <pid> [<url>] [options]
-docker-git ps
-docker-git down-all
-docker-git auth <provider> <action> [options]
-docker-git state <action> [options]
-
-Commands:
-  menu                Interactive menu (default when no args)
-  create, init        Generate docker development environment (repo URL optional)
-  clone               Create + run container and clone repo
-  open                Open existing docker-git project workspace
-  apply               Apply docker-git config to an existing project/container (current dir by default)
-  mcp-playwright      Enable Playwright MCP + Chromium sidecar for an existing project dir
-  attach, tmux        Alias for open
-  panes, terms        List tmux panes for a docker-git project
-  scrap               Export/import project scrap (session snapshot + rebuildable deps)
-  sessions            List/kill/log container terminal processes
-  ps, status          Show docker compose status for all docker-git projects
-  down-all            Stop all docker-git containers (docker compose down)
-  auth                Manage GitHub/Codex/Claude Code auth for docker-git
-  state               Manage docker-git state directory via git (sync across machines)
-
-Options:
-  --repo-url <url>          Repository URL (create: optional; clone: required via positional arg or flag)
-  --repo-ref <ref>          Git ref/branch (default: main)
-  --branch, -b <ref>        Alias for --repo-ref
-  --target-dir <path>       Target dir inside container (create default: /home/dev/app, clone default: ~/workspaces/<org>/<repo>[/issue-<id>|/pr-<id>])
-  --ssh-port <port>         Local SSH port (default: 2222)
-  --ssh-user <user>         SSH user inside container (default: dev)
-  --container-name <name>   Docker container name (default: dg-<repo>)
-  --service-name <name>     Compose service name (default: dg-<repo>)
-  --volume-name <name>      Docker volume name (default: dg-<repo>-home)
-  --authorized-keys <path>  Host path to authorized_keys (default: <projectsRoot>/authorized_keys)
-  --env-global <path>       Host path to shared env file (default: <projectsRoot>/.orch/env/global.env)
-  --env-project <path>      Host path to project env file (default: ./.orch/env/project.env)
-  --codex-auth <path>       Host path for Codex auth cache (default: <projectsRoot>/.orch/auth/codex)
-  --codex-home <path>       Container path for Codex auth (default: /home/dev/.codex)
-  --network-mode <mode>     Compose network mode: shared|project (default: shared)
-  --shared-network <name>   Shared Docker network name when network-mode=shared (default: docker-git-shared)
-  --out-dir <path>          Output directory (default: <projectsRoot>/<org>/<repo>[/issue-<id>|/pr-<id>])
-  --project-dir <path>      Project directory for open/attach (default: .)
-  --archive <path>          Scrap snapshot directory (default: .orch/scrap/session)
-  --mode <session>          Scrap mode (default: session)
-  --git-token <label>       Token label for clone/create (maps to GITHUB_TOKEN__<LABEL>, example: agiens)
-  --codex-token <label>     Codex auth label for clone/create (maps to CODEX_AUTH_LABEL, example: agien)
-  --claude-token <label>    Claude auth label for clone/create (maps to CLAUDE_AUTH_LABEL, example: agien)
-  --wipe | --no-wipe        Wipe workspace before scrap import (default: --wipe)
-  --lines <n>               Tail last N lines for sessions logs (default: 200)
-  --include-default         Show default/system processes in sessions list
-  --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)
-  --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
-
-Container runtime env (set via .orch/env/project.env):
-  CODEX_SHARE_AUTH=1|0                  Share Codex auth.json across projects (default: 1)
-  CODEX_AUTO_UPDATE=1|0                 Auto-update Codex CLI on container start (default: 1)
-  DOCKER_GIT_ZSH_AUTOSUGGEST=1|0        Enable zsh-autosuggestions (default: 1)
-  DOCKER_GIT_ZSH_AUTOSUGGEST_STYLE=...  zsh-autosuggestions highlight style (default: fg=8,italic)
-  DOCKER_GIT_ZSH_AUTOSUGGEST_STRATEGY=...  Suggestion sources (default: history completion)
-  MCP_PLAYWRIGHT_ISOLATED=1|0           Isolated browser contexts (recommended for many Codex; default: 1)
-  MCP_PLAYWRIGHT_CDP_ENDPOINT=http://...  Override CDP endpoint (default: http://dg-<repo>-browser:9223)
-
-Auth providers:
-  github, gh         GitHub CLI auth (tokens saved to env file)
-  codex             Codex CLI auth (stored under .orch/auth/codex)
-  claude, cc        Claude Code CLI auth (OAuth cache stored under .orch/auth/claude)
-
-Auth actions:
-  login             Run login flow and store credentials
-  status            Show current auth status
-  logout            Remove stored credentials
-
-Auth options:
-  --label <label>        Account label (default: default)
-  --token <token>        GitHub token override (login only; useful for non-interactive/CI)
-  --web                 Force OAuth web flow (login only; ignores --token)
-  --scopes <scopes>      GitHub scopes (login only, default: repo,workflow,read:org)
-  --env-global <path>    Env file path for GitHub tokens (default: <projectsRoot>/.orch/env/global.env)
-  --codex-auth <path>    Codex auth root path (default: <projectsRoot>/.orch/auth/codex)
-
-State actions:
-  state path                         Print current projects root (default: ~/.docker-git; override via DOCKER_GIT_PROJECTS_ROOT)
-  state init --repo-url <url> [-b]   Init / bind state dir to a git remote (use a private repo)
-  state status                       Show git status for the state dir
-  state pull                         git pull (state dir)
-  state commit -m <message>          Commit all changes in the state dir
-  state sync [-m <message>]          Commit (if needed) + fetch/rebase + push (state dir); on conflict pushes a PR branch
-  state push                         git push (state dir)
-
-State options:
-  --message, -m <message>    Commit message for state commit
-`
-
-// CHANGE: normalize parse errors into user-facing messages
-// WHY: keep formatting deterministic and centralized
-// QUOTE(ТЗ): "Надо написать CLI команду"
-// REF: user-request-2026-01-07
-// SOURCE: n/a
-// FORMAT THEOREM: forall e: format(e) = s -> deterministic(s)
-// PURITY: CORE
-// EFFECT: Effect<string, never, never>
-// INVARIANT: each ParseError maps to exactly one message
-// COMPLEXITY: O(1)
-export const formatParseError = (error: ParseError): string =>
-  Match.value(error).pipe(
-    Match.when({ _tag: "UnknownCommand" }, ({ command }) => `Unknown command: ${command}`),
-    Match.when({ _tag: "UnknownOption" }, ({ option }) => `Unknown option: ${option}`),
-    Match.when({ _tag: "MissingOptionValue" }, ({ option }) => `Missing value for option: ${option}`),
-    Match.when({ _tag: "MissingRequiredOption" }, ({ option }) => `Missing required option: ${option}`),
-    Match.when({ _tag: "InvalidOption" }, ({ option, reason }) => `Invalid option ${option}: ${reason}`),
-    Match.when({ _tag: "UnexpectedArgument" }, ({ value }) => `Unexpected argument: ${value}`),
-    Match.exhaustive
-  )

package/src/docker-git/main.ts

@@ -1,18 +0,0 @@
-import { NodeContext, NodeRuntime } from "@effect/platform-node"
-import { Effect } from "effect"
-
-import { program } from "./program.js"
-
-// CHANGE: run docker-git CLI through the Node runtime
-// WHY: ensure platform services (FS, Path, Command) are available in app CLI
-// QUOTE(ТЗ): "CLI (отображение, фронт) это app"
-// REF: user-request-2026-01-28-cli-move
-// SOURCE: n/a
-// FORMAT THEOREM: forall env: runMain(program, env) -> exit
-// PURITY: SHELL
-// EFFECT: Effect<void, unknown, NodeContext>
-// INVARIANT: program runs with NodeContext.layer
-// COMPLEXITY: O(n)
-const main = Effect.provide(program, NodeContext.layer)
-
-NodeRuntime.runMain(main)

package/src/docker-git/menu-actions.ts

@@ -1,273 +0,0 @@
-import { type MenuAction, type ProjectConfig } from "@effect-template/lib/core/domain"
-import { readProjectConfig } from "@effect-template/lib/shell/config"
-import { runDockerComposeDown, runDockerComposeLogs, runDockerComposePs } from "@effect-template/lib/shell/docker"
-import type { AppError } from "@effect-template/lib/usecases/errors"
-import { renderError } from "@effect-template/lib/usecases/errors"
-import {
-  downAllDockerGitProjects,
-  listProjectItems,
-  listProjectStatus,
-  listRunningProjectItems
-} from "@effect-template/lib/usecases/projects"
-import { gcProjectNetworkByTemplate } from "@effect-template/lib/usecases/docker-network-gc"
-import { runDockerComposeUpWithPortCheck } from "@effect-template/lib/usecases/projects-up"
-import { Effect, Match, pipe } from "effect"
-
-import { openAuthMenu } from "./menu-auth.js"
-import { startCreateView } from "./menu-create.js"
-import { loadSelectView } from "./menu-select-load.js"
-import { withSuspendedTui, writeErrorAndPause } from "./menu-shared.js"
-import { type MenuEnv, type MenuRunner, type MenuState, type MenuViewContext } from "./menu-types.js"
-
-// CHANGE: keep menu actions and input parsing in a dedicated module
-// WHY: reduce cognitive complexity in the TUI entry
-// QUOTE(ТЗ): "TUI? Красивый, удобный"
-// REF: user-request-2026-02-01-tui
-// SOURCE: n/a
-// FORMAT THEOREM: forall a: action(a) -> effect(a)
-// PURITY: SHELL
-// EFFECT: Effect<void, AppError, MenuEnv>
-// INVARIANT: menu selection runs exactly one action
-// COMPLEXITY: O(1) per keypress
-
-const continueOutcome = (state: MenuState): { readonly _tag: "Continue"; readonly state: MenuState } => ({
-  _tag: "Continue",
-  state
-})
-
-const quitOutcome: { readonly _tag: "Quit" } = { _tag: "Quit" }
-
-export type MenuContext = {
-  readonly state: MenuState
-  readonly runner: MenuRunner
-  readonly exit: () => void
-} & MenuViewContext
-
-export type MenuSelectionContext = MenuContext & {
-  readonly selected: number
-  readonly setSelected: (update: (value: number) => number) => void
-}
-
-const actionLabel = (action: MenuAction): string =>
-  Match.value(action).pipe(
-    Match.when({ _tag: "Auth" }, () => "Auth profiles"),
-    Match.when({ _tag: "ProjectAuth" }, () => "Project auth"),
-    Match.when({ _tag: "Up" }, () => "docker compose up"),
-    Match.when({ _tag: "Status" }, () => "docker compose ps"),
-    Match.when({ _tag: "Logs" }, () => "docker compose logs"),
-    Match.when({ _tag: "Down" }, () => "docker compose down"),
-    Match.when({ _tag: "DownAll" }, () => "docker compose down (all projects)"),
-    Match.orElse(() => "action")
-  )
-
-const runWithSuspendedTui = (
-  effect: Effect.Effect<void, AppError, MenuEnv>,
-  context: MenuContext,
-  label: string
-) => {
-  context.runner.runEffect(
-    pipe(
-      Effect.sync(() => {
-        context.setMessage(`${label}...`)
-      }),
-      Effect.zipRight(withSuspendedTui(effect, { onError: (error) => writeErrorAndPause(renderError(error)) })),
-      Effect.tap(() =>
-        Effect.sync(() => {
-          context.setMessage(`${label} finished.`)
-        })
-      ),
-      Effect.asVoid
-    )
-  )
-}
-
-const requireActiveProject = (context: MenuContext): boolean => {
-  if (context.state.activeDir) {
-    return true
-  }
-  context.setMessage(
-    "No active project. Use Create or paste a repo URL to set one before running this action."
-  )
-  return false
-}
-
-const handleMissingConfig = (
-  state: MenuState,
-  setMessage: (message: string | null) => void,
-  error: AppError
-) =>
-  pipe(
-    Effect.sync(() => {
-      setMessage(renderError(error))
-    }),
-    Effect.as(continueOutcome(state))
-  )
-
-const withProjectConfig = <R>(
-  state: MenuState,
-  setMessage: (message: string | null) => void,
-  f: (config: ProjectConfig) => Effect.Effect<void, AppError, R>
-) =>
-  pipe(
-    readProjectConfig(state.activeDir ?? state.cwd),
-    Effect.matchEffect({
-      onFailure: (error) =>
-        error._tag === "ConfigNotFoundError" || error._tag === "ConfigDecodeError"
-          ? handleMissingConfig(state, setMessage, error)
-          : Effect.fail(error),
-      onSuccess: (config) =>
-        pipe(
-          f(config),
-          Effect.as(continueOutcome(state))
-        )
-    })
-  )
-
-const handleMenuAction = (
-  state: MenuState,
-  setMessage: (message: string | null) => void,
-  action: MenuAction
-): Effect.Effect<
-  { readonly _tag: "Continue"; readonly state: MenuState } | { readonly _tag: "Quit" },
-  AppError,
-  MenuEnv
-> =>
-  Match.value(action).pipe(
-    Match.when({ _tag: "Quit" }, () => Effect.succeed(quitOutcome)),
-    Match.when({ _tag: "Create" }, () => Effect.succeed(continueOutcome(state))),
-    Match.when({ _tag: "Select" }, () => Effect.succeed(continueOutcome(state))),
-    Match.when({ _tag: "Auth" }, () => Effect.succeed(continueOutcome(state))),
-    Match.when({ _tag: "ProjectAuth" }, () => Effect.succeed(continueOutcome(state))),
-    Match.when({ _tag: "Info" }, () => Effect.succeed(continueOutcome(state))),
-    Match.when({ _tag: "Delete" }, () => Effect.succeed(continueOutcome(state))),
-    Match.when({ _tag: "Up" }, () =>
-      withProjectConfig(state, setMessage, () =>
-        runDockerComposeUpWithPortCheck(state.activeDir ?? state.cwd).pipe(Effect.asVoid))),
-    Match.when({ _tag: "Status" }, () =>
-      withProjectConfig(state, setMessage, () =>
-        runDockerComposePs(state.activeDir ?? state.cwd))),
-    Match.when({ _tag: "Logs" }, () =>
-      withProjectConfig(state, setMessage, () =>
-        runDockerComposeLogs(state.activeDir ?? state.cwd))),
-    Match.when({ _tag: "Down" }, () =>
-      withProjectConfig(state, setMessage, (config) =>
-        runDockerComposeDown(state.activeDir ?? state.cwd).pipe(
-          Effect.zipRight(gcProjectNetworkByTemplate(state.activeDir ?? state.cwd, config.template))
-        ))),
-    Match.when({ _tag: "DownAll" }, () =>
-      pipe(
-        downAllDockerGitProjects,
-        Effect.as(continueOutcome(state))
-      )),
-    Match.exhaustive
-  )
-
-const runCreateAction = (context: MenuContext) => {
-  startCreateView(context.setView, context.setMessage)
-}
-
-const runSelectAction = (context: MenuContext) => {
-  context.setMessage(null)
-  context.runner.runEffect(loadSelectView(listProjectItems, "Connect", context))
-}
-
-const runAuthProfilesAction = (context: MenuContext) => {
-  context.setMessage(null)
-  openAuthMenu({
-    state: context.state,
-    runner: context.runner,
-    setView: context.setView,
-    setMessage: context.setMessage,
-    setActiveDir: context.setActiveDir
-  })
-}
-
-const runProjectAuthAction = (context: MenuContext) => {
-  context.setMessage(null)
-  context.runner.runEffect(loadSelectView(listProjectItems, "Auth", context))
-}
-
-const runDownAllAction = (context: MenuContext) => {
-  context.setMessage(null)
-  runWithSuspendedTui(downAllDockerGitProjects, context, "Stopping all docker-git containers")
-}
-
-const runDownAction = (context: MenuContext, action: MenuAction) => {
-  context.setMessage(null)
-  if (context.state.activeDir === null) {
-    context.runner.runEffect(loadSelectView(listRunningProjectItems, "Down", context))
-    return
-  }
-  runComposeAction(action, context)
-}
-
-const runInfoAction = (context: MenuContext) => {
-  context.setMessage(null)
-  context.runner.runEffect(loadSelectView(listProjectItems, "Info", context))
-}
-
-const runDeleteAction = (context: MenuContext) => {
-  context.setMessage(null)
-  context.runner.runEffect(loadSelectView(listProjectItems, "Delete", context))
-}
-
-const runComposeAction = (action: MenuAction, context: MenuContext) => {
-  if (action._tag === "Status" && context.state.activeDir === null) {
-    runWithSuspendedTui(listProjectStatus, context, "docker compose ps (all projects)")
-    return
-  }
-  if (!requireActiveProject(context)) {
-    return
-  }
-  const effect = pipe(handleMenuAction(context.state, context.setMessage, action), Effect.asVoid)
-  runWithSuspendedTui(effect, context, actionLabel(action))
-}
-
-const runQuitAction = (context: MenuContext, action: MenuAction) => {
-  context.runner.runEffect(
-    pipe(handleMenuAction(context.state, context.setMessage, action), Effect.asVoid)
-  )
-  context.exit()
-}
-
-export const handleMenuActionSelection = (action: MenuAction, context: MenuContext) => {
-  Match.value(action).pipe(
-    Match.when({ _tag: "Create" }, () => {
-      runCreateAction(context)
-    }),
-    Match.when({ _tag: "Select" }, () => {
-      runSelectAction(context)
-    }),
-    Match.when({ _tag: "Auth" }, () => {
-      runAuthProfilesAction(context)
-    }),
-    Match.when({ _tag: "ProjectAuth" }, () => {
-      runProjectAuthAction(context)
-    }),
-    Match.when({ _tag: "Info" }, () => {
-      runInfoAction(context)
-    }),
-    Match.when({ _tag: "Delete" }, () => {
-      runDeleteAction(context)
-    }),
-    Match.when({ _tag: "Up" }, (selected) => {
-      runComposeAction(selected, context)
-    }),
-    Match.when({ _tag: "Status" }, (selected) => {
-      runComposeAction(selected, context)
-    }),
-    Match.when({ _tag: "Logs" }, (selected) => {
-      runComposeAction(selected, context)
-    }),
-    Match.when({ _tag: "Down" }, (selected) => {
-      runDownAction(context, selected)
-    }),
-    Match.when({ _tag: "DownAll" }, () => {
-      runDownAllAction(context)
-    }),
-    Match.when({ _tag: "Quit" }, (selected) => {
-      runQuitAction(context, selected)
-    }),
-    Match.exhaustive
-  )
-}

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

@@ -1,184 +0,0 @@
-import * as FileSystem from "@effect/platform/FileSystem"
-import * as Path from "@effect/platform/Path"
-import { Effect, Match, pipe } from "effect"
-
-import { ensureEnvFile, parseEnvEntries, 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 { 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 type { AuthFlow, AuthSnapshot, MenuEnv } from "./menu-types.js"
-
-export type AuthMenuAction = AuthFlow | "Refresh" | "Back"
-
-type AuthMenuItem = {
-  readonly action: AuthMenuAction
-  readonly label: string
-}
-
-export type AuthEnvFlow = Extract<AuthFlow, "GithubRemove" | "GitSet" | "GitRemove">
-
-export type AuthPromptStep = {
-  readonly key: "label" | "token" | "user"
-  readonly label: string
-  readonly required: boolean
-  readonly secret: boolean
-}
-
-const authMenuItems: ReadonlyArray<AuthMenuItem> = [
-  { action: "GithubOauth", label: "GitHub: login via OAuth (web)" },
-  { action: "GithubRemove", label: "GitHub: remove token" },
-  { action: "GitSet", label: "Git: add/update credentials" },
-  { action: "GitRemove", label: "Git: remove credentials" },
-  { action: "ClaudeOauth", label: "Claude Code: login via OAuth (web)" },
-  { action: "ClaudeLogout", label: "Claude Code: logout (clear cache)" },
-  { action: "Refresh", label: "Refresh snapshot" },
-  { action: "Back", label: "Back to main menu" }
-]
-
-const flowSteps: Readonly<Record<AuthFlow, ReadonlyArray<AuthPromptStep>>> = {
-  GithubOauth: [
-    { key: "label", label: "Label (empty = default)", required: false, secret: false }
-  ],
-  GithubRemove: [
-    { key: "label", label: "Label to remove (empty = default)", required: false, secret: false }
-  ],
-  GitSet: [
-    { key: "label", label: "Label (empty = default)", required: false, secret: false },
-    { key: "token", label: "Git auth token", required: true, secret: true },
-    { key: "user", label: "Git auth user (empty = x-access-token)", required: false, secret: false }
-  ],
-  GitRemove: [
-    { key: "label", label: "Label to remove (empty = default)", required: false, secret: false }
-  ],
-  ClaudeOauth: [
-    { key: "label", label: "Label (empty = default)", required: false, secret: false }
-  ],
-  ClaudeLogout: [
-    { key: "label", label: "Label to logout (empty = default)", required: false, secret: false }
-  ]
-}
-
-const flowTitle = (flow: AuthFlow): string =>
-  Match.value(flow).pipe(
-    Match.when("GithubOauth", () => "GitHub OAuth"),
-    Match.when("GithubRemove", () => "GitHub remove"),
-    Match.when("GitSet", () => "Git credentials"),
-    Match.when("GitRemove", () => "Git remove"),
-    Match.when("ClaudeOauth", () => "Claude Code OAuth"),
-    Match.when("ClaudeLogout", () => "Claude Code logout"),
-    Match.exhaustive
-  )
-
-export const successMessage = (flow: AuthFlow, label: string): string =>
-  Match.value(flow).pipe(
-    Match.when("GithubOauth", () => `Saved GitHub token (${label}).`),
-    Match.when("GithubRemove", () => `Removed GitHub token (${label}).`),
-    Match.when("GitSet", () => `Saved Git credentials (${label}).`),
-    Match.when("GitRemove", () => `Removed Git credentials (${label}).`),
-    Match.when("ClaudeOauth", () => `Saved Claude Code login (${label}).`),
-    Match.when("ClaudeLogout", () => `Logged out Claude Code (${label}).`),
-    Match.exhaustive
-  )
-
-const buildGlobalEnvPath = (cwd: string): string => `${defaultProjectsRoot(cwd)}/.orch/env/global.env`
-const buildClaudeAuthPath = (cwd: string): string => `${defaultProjectsRoot(cwd)}/.orch/auth/claude`
-
-type AuthEnvText = {
-  readonly fs: FileSystem.FileSystem
-  readonly path: Path.Path
-  readonly globalEnvPath: string
-  readonly claudeAuthPath: string
-  readonly envText: string
-}
-
-const loadAuthEnvText = (
-  cwd: string
-): Effect.Effect<AuthEnvText, AppError, MenuEnv> =>
-  Effect.gen(function*(_) {
-    const fs = yield* _(FileSystem.FileSystem)
-    const path = yield* _(Path.Path)
-    const globalEnvPath = buildGlobalEnvPath(cwd)
-    const claudeAuthPath = buildClaudeAuthPath(cwd)
-    yield* _(ensureEnvFile(fs, path, globalEnvPath))
-    const envText = yield* _(readEnvText(fs, globalEnvPath))
-    return { fs, path, globalEnvPath, claudeAuthPath, envText }
-  })
-
-export const readAuthSnapshot = (
-  cwd: string
-): Effect.Effect<AuthSnapshot, AppError, MenuEnv> =>
-  pipe(
-    loadAuthEnvText(cwd),
-    Effect.flatMap(({ claudeAuthPath, envText, fs, globalEnvPath, path }) =>
-      pipe(
-        countAuthAccountDirectories(fs, path, claudeAuthPath),
-        Effect.map((claudeAuthEntries) => ({
-          globalEnvPath,
-          claudeAuthPath,
-          totalEntries: parseEnvEntries(envText).filter((entry) => entry.value.trim().length > 0).length,
-          githubTokenEntries: countKeyEntries(envText, "GITHUB_TOKEN"),
-          gitTokenEntries: countKeyEntries(envText, "GIT_AUTH_TOKEN"),
-          gitUserEntries: countKeyEntries(envText, "GIT_AUTH_USER"),
-          claudeAuthEntries
-        }))
-      )
-    )
-  )
-
-export const writeAuthFlow = (
-  cwd: string,
-  flow: AuthEnvFlow,
-  values: Readonly<Record<string, string>>
-): Effect.Effect<void, AppError, MenuEnv> =>
-  pipe(
-    loadAuthEnvText(cwd),
-    Effect.flatMap(({ envText, fs, globalEnvPath }) => {
-      const label = values["label"] ?? ""
-      const canonicalLabel = (() => {
-        const normalized = normalizeLabel(label)
-        return normalized.length === 0 || normalized === "DEFAULT" ? "default" : normalized
-      })()
-      const token = (values["token"] ?? "").trim()
-      const user = (values["user"] ?? "").trim()
-      const nextText = Match.value(flow).pipe(
-        Match.when("GithubRemove", () => upsertEnvKey(envText, buildLabeledEnvKey("GITHUB_TOKEN", label), "")),
-        Match.when("GitSet", () => {
-          const withToken = upsertEnvKey(envText, buildLabeledEnvKey("GIT_AUTH_TOKEN", label), token)
-          const resolvedUser = user.length > 0 ? user : "x-access-token"
-          return upsertEnvKey(withToken, buildLabeledEnvKey("GIT_AUTH_USER", label), resolvedUser)
-        }),
-        Match.when("GitRemove", () => {
-          const withoutToken = upsertEnvKey(envText, buildLabeledEnvKey("GIT_AUTH_TOKEN", label), "")
-          return upsertEnvKey(withoutToken, buildLabeledEnvKey("GIT_AUTH_USER", label), "")
-        }),
-        Match.exhaustive
-      )
-      const syncMessage = Match.value(flow).pipe(
-        Match.when("GithubRemove", () => `chore(state): auth gh logout ${canonicalLabel}`),
-        Match.when("GitSet", () => `chore(state): auth git ${canonicalLabel}`),
-        Match.when("GitRemove", () => `chore(state): auth git logout ${canonicalLabel}`),
-        Match.exhaustive
-      )
-      return pipe(
-        fs.writeFileString(globalEnvPath, nextText),
-        Effect.zipRight(autoSyncState(syncMessage))
-      )
-    }),
-    Effect.asVoid
-  )
-
-export const authViewTitle = (flow: AuthFlow): string => flowTitle(flow)
-
-export const authViewSteps = (flow: AuthFlow): ReadonlyArray<AuthPromptStep> => flowSteps[flow]
-
-export const authMenuLabels = (): ReadonlyArray<string> => authMenuItems.map((item) => item.label)
-
-export const authMenuActionByIndex = (index: number): AuthMenuAction | null => {
-  const item = authMenuItems[index]
-  return item ? item.action : null
-}
-
-export const authMenuSize = (): number => authMenuItems.length

package/src/docker-git/menu-auth-helpers.ts

@@ -1,30 +0,0 @@
-import type * as FileSystem from "@effect/platform/FileSystem"
-import type * as Path from "@effect/platform/Path"
-import { Effect } from "effect"
-
-import type { AppError } from "@effect-template/lib/usecases/errors"
-
-export const countAuthAccountDirectories = (
-  fs: FileSystem.FileSystem,
-  path: Path.Path,
-  root: string
-): Effect.Effect<number, AppError> =>
-  Effect.gen(function*(_) {
-    const exists = yield* _(fs.exists(root))
-    if (!exists) {
-      return 0
-    }
-    const entries = yield* _(fs.readDirectory(root))
-    let count = 0
-    for (const entry of entries) {
-      if (entry === ".image") {
-        continue
-      }
-      const fullPath = path.join(root, entry)
-      const info = yield* _(fs.stat(fullPath))
-      if (info.type === "Directory") {
-        count += 1
-      }
-    }
-    return count
-  })