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

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

@@ -1,150 +0,0 @@
-import { runDockerComposeDown } from "@effect-template/lib/shell/docker"
-import type { AppError } from "@effect-template/lib/usecases/errors"
-import { renderError } from "@effect-template/lib/usecases/errors"
-import { mcpPlaywrightUp } from "@effect-template/lib/usecases/mcp-playwright"
-import {
-  connectProjectSshWithUp,
-  deleteDockerGitProject,
-  listRunningProjectItems,
-  type ProjectItem
-} from "@effect-template/lib/usecases/projects"
-import { Effect, pipe } from "effect"
-
-import { openProjectAuthMenu } from "./menu-project-auth.js"
-import { buildConnectEffect } from "./menu-select-connect.js"
-import { loadRuntimeByProject } from "./menu-select-runtime.js"
-import { startSelectView } from "./menu-select-view.js"
-import {
-  pauseOnError,
-  resetToMenu,
-  resumeSshWithSkipInputs,
-  resumeWithSkipInputs,
-  withSuspendedTui
-} from "./menu-shared.js"
-import type { MenuRunner, MenuViewContext } from "./menu-types.js"
-
-export type SelectContext = MenuViewContext & {
-  readonly activeDir: string | null
-  readonly runner: MenuRunner
-  readonly setSshActive: (active: boolean) => void
-  readonly setSkipInputs: (update: (value: number) => number) => void
-}
-
-export const runConnectSelection = (
-  selected: ProjectItem,
-  context: SelectContext,
-  enableMcpPlaywright: boolean
-) => {
-  context.setMessage(
-    enableMcpPlaywright
-      ? `Enabling Playwright MCP for ${selected.displayName}, then connecting...`
-      : `Connecting to ${selected.displayName}...`
-  )
-  context.setSshActive(true)
-  context.runner.runEffect(
-    pipe(
-      withSuspendedTui(
-        buildConnectEffect(selected, enableMcpPlaywright, {
-          connectWithUp: (item) =>
-            connectProjectSshWithUp(item).pipe(
-              Effect.mapError((error): AppError => error)
-            ),
-          enableMcpPlaywright: (projectDir) =>
-            mcpPlaywrightUp({ _tag: "McpPlaywrightUp", projectDir, runUp: false }).pipe(
-              Effect.asVoid,
-              Effect.mapError((error): AppError => error)
-            )
-        }),
-        {
-          onError: pauseOnError(renderError),
-          onResume: resumeSshWithSkipInputs(context)
-        }
-      ),
-      Effect.tap(() =>
-        Effect.sync(() => {
-          context.setMessage("SSH session ended. Press Esc to return to the menu.")
-        })
-      ),
-      Effect.asVoid
-    )
-  )
-}
-
-export const runDownSelection = (selected: ProjectItem, context: SelectContext) => {
-  context.setMessage(`Stopping ${selected.displayName}...`)
-  context.runner.runEffect(
-    withSuspendedTui(
-      pipe(
-        runDockerComposeDown(selected.projectDir),
-        Effect.zipRight(listRunningProjectItems),
-        Effect.flatMap((items) =>
-          pipe(
-            loadRuntimeByProject(items),
-            Effect.map((runtimeByProject) => ({ items, runtimeByProject }))
-          )
-        ),
-        Effect.tap(({ items, runtimeByProject }) =>
-          Effect.sync(() => {
-            if (items.length === 0) {
-              resetToMenu(context)
-              context.setMessage("No running docker-git containers.")
-              return
-            }
-            startSelectView(items, "Down", context, runtimeByProject)
-            context.setMessage("Container stopped. Select another to stop, or Esc to return.")
-          })
-        ),
-        Effect.asVoid
-      ),
-      {
-        onError: pauseOnError(renderError),
-        onResume: resumeWithSkipInputs(context)
-      }
-    )
-  )
-}
-
-export const runInfoSelection = (selected: ProjectItem, context: SelectContext) => {
-  context.setMessage(`Details for ${selected.displayName} are shown on the right. Press Esc to return to the menu.`)
-}
-
-export const runAuthSelection = (selected: ProjectItem, context: SelectContext) => {
-  openProjectAuthMenu({
-    project: selected,
-    runner: context.runner,
-    setView: context.setView,
-    setMessage: context.setMessage,
-    setActiveDir: context.setActiveDir
-  })
-}
-
-export const runDeleteSelection = (selected: ProjectItem, context: SelectContext) => {
-  context.setMessage(`Deleting ${selected.displayName}...`)
-  context.runner.runEffect(
-    pipe(
-      withSuspendedTui(
-        deleteDockerGitProject(selected).pipe(
-          Effect.tap(() =>
-            Effect.sync(() => {
-              if (context.activeDir === selected.projectDir) {
-                context.setActiveDir(null)
-              }
-              context.setView({ _tag: "Menu" })
-            })
-          ),
-          Effect.asVoid
-        ),
-        {
-          onError: pauseOnError(renderError),
-          onResume: resumeWithSkipInputs(context)
-        }
-      ),
-      Effect.tap(() =>
-        Effect.sync(() => {
-          context.setMessage("Project deleted.")
-        })
-      ),
-      Effect.asVoid
-    )
-  )
-}

package/src/docker-git/menu-select-connect.ts

@@ -1,27 +0,0 @@
-import { Effect } from "effect"
-
-import type { ProjectItem } from "@effect-template/lib/usecases/projects"
-
-type ConnectDeps<E, R> = {
-  readonly connectWithUp: (
-    item: ProjectItem
-  ) => Effect.Effect<void, E, R>
-  readonly enableMcpPlaywright: (
-    projectDir: string
-  ) => Effect.Effect<void, E, R>
-}
-
-const normalizedInput = (input: string): string => input.trim().toLowerCase()
-
-export const isConnectMcpToggleInput = (input: string): boolean => normalizedInput(input) === "p"
-
-export const buildConnectEffect = <E, R>(
-  selected: ProjectItem,
-  enableMcpPlaywright: boolean,
-  deps: ConnectDeps<E, R>
-): Effect.Effect<void, E, R> =>
-  enableMcpPlaywright
-    ? deps.enableMcpPlaywright(selected.projectDir).pipe(
-      Effect.zipRight(deps.connectWithUp(selected))
-    )
-    : deps.connectWithUp(selected)

package/src/docker-git/menu-select-load.ts

@@ -1,33 +0,0 @@
-import type { ProjectItem } from "@effect-template/lib/usecases/projects"
-import { Effect, pipe } from "effect"
-
-import { loadRuntimeByProject } from "./menu-select-runtime.js"
-import { startSelectView } from "./menu-select.js"
-import type { MenuEnv, MenuViewContext } from "./menu-types.js"
-
-export const loadSelectView = <E>(
-  effect: Effect.Effect<ReadonlyArray<ProjectItem>, E, MenuEnv>,
-  purpose: "Connect" | "Down" | "Info" | "Delete" | "Auth",
-  context: Pick<MenuViewContext, "setView" | "setMessage">
-): Effect.Effect<void, E, MenuEnv> =>
-  pipe(
-    effect,
-    Effect.flatMap((items) =>
-      pipe(
-        loadRuntimeByProject(items),
-        Effect.flatMap((runtimeByProject) =>
-          Effect.sync(() => {
-            if (items.length === 0) {
-              context.setMessage(
-                purpose === "Down"
-                  ? "No running docker-git containers."
-                  : "No docker-git projects found."
-              )
-              return
-            }
-            startSelectView(items, purpose, context, runtimeByProject)
-          })
-        )
-      )
-    )
-  )

package/src/docker-git/menu-select-order.ts

@@ -1,37 +0,0 @@
-import type { ProjectItem } from "@effect-template/lib/usecases/projects"
-
-import type { SelectProjectRuntime } from "./menu-types.js"
-
-const defaultRuntime = (): SelectProjectRuntime => ({
-  running: false,
-  sshSessions: 0,
-  startedAtIso: null,
-  startedAtEpochMs: null
-})
-
-const runtimeForSort = (
-  runtimeByProject: Readonly<Record<string, SelectProjectRuntime>>,
-  item: ProjectItem
-): SelectProjectRuntime => runtimeByProject[item.projectDir] ?? defaultRuntime()
-
-const startedAtEpochForSort = (runtime: SelectProjectRuntime): number =>
-  runtime.startedAtEpochMs ?? Number.NEGATIVE_INFINITY
-
-export const sortItemsByLaunchTime = (
-  items: ReadonlyArray<ProjectItem>,
-  runtimeByProject: Readonly<Record<string, SelectProjectRuntime>>
-): ReadonlyArray<ProjectItem> =>
-  items.toSorted((left, right) => {
-    const leftRuntime = runtimeForSort(runtimeByProject, left)
-    const rightRuntime = runtimeForSort(runtimeByProject, right)
-    const leftStartedAt = startedAtEpochForSort(leftRuntime)
-    const rightStartedAt = startedAtEpochForSort(rightRuntime)
-
-    if (leftStartedAt !== rightStartedAt) {
-      return rightStartedAt - leftStartedAt
-    }
-    if (leftRuntime.running !== rightRuntime.running) {
-      return leftRuntime.running ? -1 : 1
-    }
-    return left.displayName.localeCompare(right.displayName)
-  })

package/src/docker-git/menu-select-runtime.ts

@@ -1,143 +0,0 @@
-import { runCommandCapture } from "@effect-template/lib/shell/command-runner"
-import { runDockerPsNames } from "@effect-template/lib/shell/docker"
-import type { ProjectItem } from "@effect-template/lib/usecases/projects"
-import { Effect, pipe } from "effect"
-
-import type { MenuEnv, SelectProjectRuntime, ViewState } from "./menu-types.js"
-
-const emptyRuntimeByProject = (): Readonly<Record<string, SelectProjectRuntime>> => ({})
-
-const stoppedRuntime = (): SelectProjectRuntime => ({
-  running: false,
-  sshSessions: 0,
-  startedAtIso: null,
-  startedAtEpochMs: null
-})
-
-const countSshSessionsScript = "who -u 2>/dev/null | wc -l | tr -d '[:space:]'"
-const dockerZeroStartedAt = "0001-01-01T00:00:00Z"
-
-type ContainerStartTime = {
-  readonly startedAtIso: string
-  readonly startedAtEpochMs: number
-}
-
-const parseSshSessionCount = (raw: string): number => {
-  const parsed = Number.parseInt(raw.trim(), 10)
-  if (Number.isNaN(parsed) || parsed < 0) {
-    return 0
-  }
-  return parsed
-}
-
-const parseContainerStartedAt = (raw: string): ContainerStartTime | null => {
-  const trimmed = raw.trim()
-  if (trimmed.length === 0 || trimmed === dockerZeroStartedAt) {
-    return null
-  }
-  const startedAtEpochMs = Date.parse(trimmed)
-  if (Number.isNaN(startedAtEpochMs)) {
-    return null
-  }
-  return {
-    startedAtIso: trimmed,
-    startedAtEpochMs
-  }
-}
-
-const toRuntimeMap = (
-  entries: ReadonlyArray<readonly [string, SelectProjectRuntime]>
-): Readonly<Record<string, SelectProjectRuntime>> => {
-  const runtimeByProject: Record<string, SelectProjectRuntime> = {}
-  for (const [projectDir, runtime] of entries) {
-    runtimeByProject[projectDir] = runtime
-  }
-  return runtimeByProject
-}
-
-const countContainerSshSessions = (
-  containerName: string
-): Effect.Effect<number, never, MenuEnv> =>
-  pipe(
-    runCommandCapture(
-      {
-        cwd: process.cwd(),
-        command: "docker",
-        args: ["exec", containerName, "bash", "-lc", countSshSessionsScript]
-      },
-      [0],
-      (exitCode) => ({ _tag: "CommandFailedError", command: "docker exec who -u", exitCode })
-    ),
-    Effect.match({
-      onFailure: () => 0,
-      onSuccess: (raw) => parseSshSessionCount(raw)
-    })
-  )
-
-const inspectContainerStartedAt = (
-  containerName: string
-): Effect.Effect<ContainerStartTime | null, never, MenuEnv> =>
-  pipe(
-    runCommandCapture(
-      {
-        cwd: process.cwd(),
-        command: "docker",
-        args: ["inspect", "--format", "{{.State.StartedAt}}", containerName]
-      },
-      [0],
-      (exitCode) => ({ _tag: "CommandFailedError", command: "docker inspect .State.StartedAt", exitCode })
-    ),
-    Effect.match({
-      onFailure: () => null,
-      onSuccess: (raw) => parseContainerStartedAt(raw)
-    })
-  )
-
-// CHANGE: enrich select items with runtime state and SSH session counts
-// WHY: prevent stopping/deleting containers that are currently used via SSH
-// QUOTE(ТЗ): "писать скок SSH подключений к контейнеру сейчас"
-// REF: issue-47
-// SOURCE: n/a
-// FORMAT THEOREM: forall p: runtime(p) -> {running(p), ssh_sessions(p), started_at(p)}
-// PURITY: SHELL
-// EFFECT: Effect<Record<string, SelectProjectRuntime>, never, MenuEnv>
-// INVARIANT: projects without a known container start have startedAt = null
-// COMPLEXITY: O(n + docker_ps + docker_exec + docker_inspect)
-export const loadRuntimeByProject = (
-  items: ReadonlyArray<ProjectItem>
-): Effect.Effect<Readonly<Record<string, SelectProjectRuntime>>, never, MenuEnv> =>
-  pipe(
-    runDockerPsNames(process.cwd()),
-    Effect.flatMap((runningNames) =>
-      Effect.forEach(
-        items,
-        (item) => {
-          const running = runningNames.includes(item.containerName)
-          const sshSessionsEffect = running
-            ? countContainerSshSessions(item.containerName)
-            : Effect.succeed(0)
-          return pipe(
-            Effect.all([sshSessionsEffect, inspectContainerStartedAt(item.containerName)]),
-            Effect.map(([sshSessions, startedAt]): SelectProjectRuntime => ({
-              running,
-              sshSessions,
-              startedAtIso: startedAt?.startedAtIso ?? null,
-              startedAtEpochMs: startedAt?.startedAtEpochMs ?? null
-            })),
-            Effect.map((runtime): readonly [string, SelectProjectRuntime] => [item.projectDir, runtime])
-          )
-        },
-        { concurrency: 4 }
-      )
-    ),
-    Effect.map((entries) => toRuntimeMap(entries)),
-    Effect.match({
-      onFailure: () => emptyRuntimeByProject(),
-      onSuccess: (runtimeByProject) => runtimeByProject
-    })
-  )
-
-export const runtimeForSelection = (
-  view: Extract<ViewState, { readonly _tag: "SelectProject" }>,
-  selected: ProjectItem
-): SelectProjectRuntime => view.runtimeByProject[selected.projectDir] ?? stoppedRuntime()

package/src/docker-git/menu-select-view.ts

@@ -1,25 +0,0 @@
-import type { ProjectItem } from "@effect-template/lib/usecases/projects"
-
-import { sortItemsByLaunchTime } from "./menu-select-order.js"
-import type { MenuViewContext, SelectProjectRuntime } from "./menu-types.js"
-
-const emptyRuntimeByProject = (): Readonly<Record<string, SelectProjectRuntime>> => ({})
-
-export const startSelectView = (
-  items: ReadonlyArray<ProjectItem>,
-  purpose: "Connect" | "Down" | "Info" | "Delete" | "Auth",
-  context: Pick<MenuViewContext, "setView" | "setMessage">,
-  runtimeByProject: Readonly<Record<string, SelectProjectRuntime>> = emptyRuntimeByProject()
-) => {
-  const sortedItems = sortItemsByLaunchTime(items, runtimeByProject)
-  context.setMessage(null)
-  context.setView({
-    _tag: "SelectProject",
-    purpose,
-    items: sortedItems,
-    runtimeByProject,
-    selected: 0,
-    confirmDelete: false,
-    connectEnableMcpPlaywright: false
-  })
-}

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

@@ -1,145 +0,0 @@
-import { Match } from "effect"
-
-import {
-  runAuthSelection,
-  runConnectSelection,
-  runDeleteSelection,
-  runDownSelection,
-  runInfoSelection,
-  type SelectContext
-} from "./menu-select-actions.js"
-import { isConnectMcpToggleInput } from "./menu-select-connect.js"
-import { runtimeForSelection } from "./menu-select-runtime.js"
-import { resetToMenu } from "./menu-shared.js"
-import type { MenuKeyInput, ViewState } from "./menu-types.js"
-
-export { startSelectView } from "./menu-select-view.js"
-
-const clampIndex = (value: number, size: number): number => {
-  if (size <= 0) {
-    return 0
-  }
-  if (value < 0) {
-    return 0
-  }
-  if (value >= size) {
-    return size - 1
-  }
-  return value
-}
-
-export const handleSelectInput = (
-  input: string,
-  key: MenuKeyInput,
-  view: Extract<ViewState, { readonly _tag: "SelectProject" }>,
-  context: SelectContext
-) => {
-  if (key.escape) {
-    resetToMenu(context)
-    return
-  }
-  if (handleConnectOptionToggle(input, view, context)) {
-    return
-  }
-  if (handleSelectNavigation(key, view, context)) {
-    return
-  }
-  if (key.return) {
-    handleSelectReturn(view, context)
-    return
-  }
-  if (input.trim().length > 0) {
-    context.setMessage("Use arrows + Enter to select a project, Esc to cancel.")
-  }
-}
-
-const handleConnectOptionToggle = (
-  input: string,
-  view: Extract<ViewState, { readonly _tag: "SelectProject" }>,
-  context: Pick<SelectContext, "setView" | "setMessage">
-): boolean => {
-  if (view.purpose !== "Connect" || !isConnectMcpToggleInput(input)) {
-    return false
-  }
-  const nextValue = !view.connectEnableMcpPlaywright
-  context.setView({ ...view, connectEnableMcpPlaywright: nextValue, confirmDelete: false })
-  context.setMessage(
-    nextValue
-      ? "Playwright MCP will be enabled before SSH (press Enter to connect)."
-      : "Playwright MCP toggle is OFF (press Enter to connect without changes)."
-  )
-  return true
-}
-
-const handleSelectNavigation = (
-  key: MenuKeyInput,
-  view: Extract<ViewState, { readonly _tag: "SelectProject" }>,
-  context: SelectContext
-): boolean => {
-  if (key.upArrow) {
-    const next = clampIndex(view.selected - 1, view.items.length)
-    context.setView({ ...view, selected: next, confirmDelete: false })
-    return true
-  }
-  if (key.downArrow) {
-    const next = clampIndex(view.selected + 1, view.items.length)
-    context.setView({ ...view, selected: next, confirmDelete: false })
-    return true
-  }
-  return false
-}
-
-const formatSshSessionsLabel = (sshSessions: number): string =>
-  sshSessions === 1 ? "1 active SSH session" : `${sshSessions} active SSH sessions`
-
-const handleSelectReturn = (
-  view: Extract<ViewState, { readonly _tag: "SelectProject" }>,
-  context: SelectContext
-) => {
-  const selected = view.items[view.selected]
-  if (!selected) {
-    context.setMessage("No project selected.")
-    resetToMenu(context)
-    return
-  }
-  const selectedRuntime = runtimeForSelection(view, selected)
-  const sshSessionsLabel = formatSshSessionsLabel(selectedRuntime.sshSessions)
-
-  Match.value(view.purpose).pipe(
-    Match.when("Connect", () => {
-      context.setActiveDir(selected.projectDir)
-      runConnectSelection(selected, context, view.connectEnableMcpPlaywright)
-    }),
-    Match.when("Auth", () => {
-      context.setActiveDir(selected.projectDir)
-      runAuthSelection(selected, context)
-    }),
-    Match.when("Down", () => {
-      if (selectedRuntime.sshSessions > 0 && !view.confirmDelete) {
-        context.setMessage(
-          `${selected.containerName} has ${sshSessionsLabel}. Press Enter again to stop, Esc to cancel.`
-        )
-        context.setView({ ...view, confirmDelete: true })
-        return
-      }
-      context.setActiveDir(selected.projectDir)
-      runDownSelection(selected, context)
-    }),
-    Match.when("Info", () => {
-      context.setActiveDir(selected.projectDir)
-      runInfoSelection(selected, context)
-    }),
-    Match.when("Delete", () => {
-      if (!view.confirmDelete) {
-        const activeSshWarning = selectedRuntime.sshSessions > 0 ? ` ${sshSessionsLabel}.` : ""
-        context.setMessage(
-          `Really delete ${selected.displayName}?${activeSshWarning} Press Enter again to confirm, Esc to cancel.`
-        )
-        context.setView({ ...view, confirmDelete: true })
-        return
-      }
-      runDeleteSelection(selected, context)
-    }),
-    Match.exhaustive
-  )
-}