@prover-coder-ai/docker-git 1.0.12 → 1.0.13

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

@@ -3,7 +3,14 @@ import { Box, Text } from "ink"
 import React from "react"
 
 import type { ProjectItem } from "@effect-template/lib/usecases/projects"
-import type { CreateInputs, CreateStep } from "./menu-types.js"
+import {
+  buildSelectLabels,
+  renderSelectDetails,
+  selectHint,
+  type SelectPurpose,
+  selectTitle
+} from "./menu-render-select.js"
+import type { CreateInputs, CreateStep, SelectProjectRuntime } from "./menu-types.js"
 import { createSteps, menuItems } from "./menu-types.js"
 
 // CHANGE: render menu views with Ink without JSX
@@ -168,91 +175,6 @@ export const renderCreate = (
   )
 }
 
-const formatRepoRef = (repoRef: string): string => {
-  const trimmed = repoRef.trim()
-  const prPrefix = "refs/pull/"
-  if (trimmed.startsWith(prPrefix)) {
-    const rest = trimmed.slice(prPrefix.length)
-    const number = rest.split("/")[0] ?? rest
-    return `PR#${number}`
-  }
-  return trimmed.length > 0 ? trimmed : "main"
-}
-
-const renderSelectDetails = (
-  el: typeof React.createElement,
-  purpose: SelectPurpose,
-  item: ProjectItem | undefined
-): ReadonlyArray<React.ReactElement> => {
-  if (!item) {
-    return [el(Text, { color: "gray", wrap: "truncate" }, "No project selected.")]
-  }
-
-  const refLabel = formatRepoRef(item.repoRef)
-  const authSuffix = item.authorizedKeysExists ? "" : " (missing)"
-
-  return Match.value(purpose).pipe(
-    Match.when("Info", () => [
-      el(Text, { color: "cyan", bold: true, wrap: "truncate" }, "Connection info"),
-      el(Text, { wrap: "wrap" }, `Project directory: ${item.projectDir}`),
-      el(Text, { wrap: "wrap" }, `Container: ${item.containerName}`),
-      el(Text, { wrap: "wrap" }, `Service: ${item.serviceName}`),
-      el(Text, { wrap: "wrap" }, `SSH command: ${item.sshCommand}`),
-      el(Text, { wrap: "wrap" }, `Repo: ${item.repoUrl} (${refLabel})`),
-      el(Text, { wrap: "wrap" }, `Workspace: ${item.targetDir}`),
-      el(Text, { wrap: "wrap" }, `Authorized keys: ${item.authorizedKeysPath}${authSuffix}`),
-      el(Text, { wrap: "wrap" }, `Env global: ${item.envGlobalPath}`),
-      el(Text, { wrap: "wrap" }, `Env project: ${item.envProjectPath}`),
-      el(Text, { wrap: "wrap" }, `Codex auth: ${item.codexAuthPath} -> ${item.codexHome}`)
-    ]),
-    Match.when("Delete", () => [
-      el(Text, { color: "cyan", bold: true, wrap: "truncate" }, "Delete project"),
-      el(Text, { wrap: "wrap" }, `Project directory: ${item.projectDir}`),
-      el(Text, { wrap: "wrap" }, `Container: ${item.containerName}`),
-      el(Text, { wrap: "wrap" }, `Repo: ${item.repoUrl} (${refLabel})`),
-      el(Text, { wrap: "wrap" }, "Removes the project folder (no git history rewrite).")
-    ]),
-    Match.orElse(() => [
-      el(Text, { color: "cyan", bold: true, wrap: "truncate" }, "Details"),
-      el(Text, { wrap: "truncate" }, `Repo: ${item.repoUrl}`),
-      el(Text, { wrap: "truncate" }, `Ref: ${item.repoRef}`),
-      el(Text, { wrap: "truncate" }, `Project dir: ${item.projectDir}`),
-      el(Text, { wrap: "truncate" }, `Workspace: ${item.targetDir}`),
-      el(Text, { wrap: "truncate" }, `SSH: ${item.sshCommand}`)
-    ])
-  )
-}
-
-type SelectPurpose = "Connect" | "Down" | "Info" | "Delete"
-
-const selectTitle = (purpose: SelectPurpose): string =>
-  Match.value(purpose).pipe(
-    Match.when("Connect", () => "docker-git / Select project"),
-    Match.when("Down", () => "docker-git / Stop container"),
-    Match.when("Info", () => "docker-git / Show connection info"),
-    Match.when("Delete", () => "docker-git / Delete project"),
-    Match.exhaustive
-  )
-
-const selectHint = (purpose: SelectPurpose): string =>
-  Match.value(purpose).pipe(
-    Match.when("Connect", () => "Enter = select + SSH, Esc = back"),
-    Match.when("Down", () => "Enter = stop container, Esc = back"),
-    Match.when("Info", () => "Use arrows to browse details, Enter = set active, Esc = back"),
-    Match.when("Delete", () => "Enter = ask/confirm delete, Esc = cancel"),
-    Match.exhaustive
-  )
-
-const buildSelectLabels = (
-  items: ReadonlyArray<ProjectItem>,
-  selected: number
-): ReadonlyArray<string> =>
-  items.map((item, index) => {
-    const prefix = index === selected ? ">" : " "
-    const refLabel = formatRepoRef(item.repoRef)
-    return `${prefix} ${index + 1}. ${item.displayName} (${refLabel})`
-  })
-
 const computeListWidth = (labels: ReadonlyArray<string>): number => {
   const maxLabelWidth = labels.length > 0 ? Math.max(...labels.map((label) => label.length)) : 24
   return Math.min(Math.max(maxLabelWidth + 2, 28), 54)
@@ -284,13 +206,25 @@ const renderSelectListBox = (
   )
 }
 
+type SelectDetailsBoxInput = {
+  readonly purpose: SelectPurpose
+  readonly items: ReadonlyArray<ProjectItem>
+  readonly selected: number
+  readonly runtimeByProject: Readonly<Record<string, SelectProjectRuntime>>
+  readonly connectEnableMcpPlaywright: boolean
+}
+
 const renderSelectDetailsBox = (
   el: typeof React.createElement,
-  purpose: SelectPurpose,
-  items: ReadonlyArray<ProjectItem>,
-  selected: number
+  input: SelectDetailsBoxInput
 ): React.ReactElement => {
-  const details = renderSelectDetails(el, purpose, items[selected])
+  const details = renderSelectDetails(
+    el,
+    input.purpose,
+    input.items[input.selected],
+    input.runtimeByProject,
+    input.connectEnableMcpPlaywright
+  )
   return el(
     Box,
     { flexDirection: "column", marginLeft: 2, flexGrow: 1 },
@@ -299,22 +233,39 @@ const renderSelectDetailsBox = (
 }
 
 export const renderSelect = (
-  purpose: SelectPurpose,
-  items: ReadonlyArray<ProjectItem>,
-  selected: number,
-  confirmDelete: boolean,
-  message: string | null
+  input: {
+    readonly purpose: SelectPurpose
+    readonly items: ReadonlyArray<ProjectItem>
+    readonly selected: number
+    readonly runtimeByProject: Readonly<Record<string, SelectProjectRuntime>>
+    readonly confirmDelete: boolean
+    readonly connectEnableMcpPlaywright: boolean
+    readonly message: string | null
+  }
 ): React.ReactElement => {
+  const { confirmDelete, connectEnableMcpPlaywright, items, message, purpose, runtimeByProject, selected } = input
   const el = React.createElement
-  const listLabels = buildSelectLabels(items, selected)
+  const listLabels = buildSelectLabels(items, selected, purpose, runtimeByProject)
   const listWidth = computeListWidth(listLabels)
   const listBox = renderSelectListBox(el, items, selected, listLabels, listWidth)
-  const detailsBox = renderSelectDetailsBox(el, purpose, items, selected)
-  const baseHint = selectHint(purpose)
-  const deleteHint = purpose === "Delete" && confirmDelete
-    ? "Confirm mode: Enter = delete now, Esc = cancel"
-    : baseHint
-  const hints = el(Box, { marginTop: 1 }, el(Text, { color: "gray" }, deleteHint))
+  const detailsBox = renderSelectDetailsBox(el, {
+    purpose,
+    items,
+    selected,
+    runtimeByProject,
+    connectEnableMcpPlaywright
+  })
+  const baseHint = selectHint(purpose, connectEnableMcpPlaywright)
+  const confirmHint = (() => {
+    if (purpose === "Delete" && confirmDelete) {
+      return "Confirm mode: Enter = delete now, Esc = cancel"
+    }
+    if (purpose === "Down" && confirmDelete) {
+      return "Confirm mode: Enter = stop now, Esc = cancel"
+    }
+    return baseHint
+  })()
+  const hints = el(Box, { marginTop: 1 }, el(Text, { color: "gray" }, confirmHint))
 
   return renderLayout(
     selectTitle(purpose),

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

@@ -0,0 +1,27 @@
+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-runtime.ts

@@ -0,0 +1,94 @@
+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 })
+
+const countSshSessionsScript = "who -u 2>/dev/null | wc -l | tr -d '[:space:]'"
+
+const parseSshSessionCount = (raw: string): number => {
+  const parsed = Number.parseInt(raw.trim(), 10)
+  if (Number.isNaN(parsed) || parsed < 0) {
+    return 0
+  }
+  return parsed
+}
+
+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)
+    })
+  )
+
+// 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)}
+// PURITY: SHELL
+// EFFECT: Effect<Record<string, SelectProjectRuntime>, never, MenuEnv>
+// INVARIANT: stopped containers always have sshSessions = 0
+// COMPLEXITY: O(n + docker_ps + docker_exec)
+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)
+          if (!running) {
+            const entry: readonly [string, SelectProjectRuntime] = [item.projectDir, stoppedRuntime()]
+            return Effect.succeed(entry)
+          }
+          return pipe(
+            countContainerSshSessions(item.containerName),
+            Effect.map((sshSessions): SelectProjectRuntime => ({ running: true, sshSessions })),
+            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.ts

@@ -1,5 +1,6 @@
 import { runDockerComposeDown } from "@effect-template/lib/shell/docker"
 import type { AppError } from "@effect-template/lib/usecases/errors"
+import { mcpPlaywrightUp } from "@effect-template/lib/usecases/mcp-playwright"
 import {
   connectProjectSshWithUp,
   deleteDockerGitProject,
@@ -9,19 +10,17 @@ import {
 
 import { Effect, Match, pipe } from "effect"
 
+import { buildConnectEffect, isConnectMcpToggleInput } from "./menu-select-connect.js"
+import { loadRuntimeByProject, runtimeForSelection } from "./menu-select-runtime.js"
 import { resetToMenu, resumeTui, suspendTui } from "./menu-shared.js"
-import type { MenuEnv, MenuKeyInput, MenuRunner, MenuViewContext, ViewState } from "./menu-types.js"
-
-// CHANGE: handle project selection flow in TUI
-// WHY: allow selecting active project without manual typing
-// QUOTE(ТЗ): "А ты можешь сделать удобный выбор проектов?"
-// REF: user-request-2026-02-02-select-project
-// SOURCE: n/a
-// FORMAT THEOREM: forall p: select(p) -> activeDir(p)
-// PURITY: SHELL
-// EFFECT: Effect<void, never, never>
-// INVARIANT: selected index always within items length
-// COMPLEXITY: O(1) per keypress
+import type {
+  MenuEnv,
+  MenuKeyInput,
+  MenuRunner,
+  MenuViewContext,
+  SelectProjectRuntime,
+  ViewState
+} from "./menu-types.js"
 
 type SelectContext = MenuViewContext & {
   readonly activeDir: string | null
@@ -30,13 +29,24 @@ type SelectContext = MenuViewContext & {
   readonly setSkipInputs: (update: (value: number) => number) => void
 }
 
+const emptyRuntimeByProject = (): Readonly<Record<string, SelectProjectRuntime>> => ({})
+
 export const startSelectView = (
   items: ReadonlyArray<ProjectItem>,
   purpose: "Connect" | "Down" | "Info" | "Delete",
-  context: Pick<SelectContext, "setView" | "setMessage">
+  context: Pick<SelectContext, "setView" | "setMessage">,
+  runtimeByProject: Readonly<Record<string, SelectProjectRuntime>> = emptyRuntimeByProject()
 ) => {
   context.setMessage(null)
-  context.setView({ _tag: "SelectProject", purpose, items, selected: 0, confirmDelete: false })
+  context.setView({
+    _tag: "SelectProject",
+    purpose,
+    items,
+    runtimeByProject,
+    selected: 0,
+    confirmDelete: false,
+    connectEnableMcpPlaywright: false
+  })
 }
 
 const clampIndex = (value: number, size: number): number => {
@@ -62,6 +72,9 @@ export const handleSelectInput = (
     resetToMenu(context)
     return
   }
+  if (handleConnectOptionToggle(input, view, context)) {
+    return
+  }
   if (handleSelectNavigation(key, view, context)) {
     return
   }
@@ -69,7 +82,27 @@ export const handleSelectInput = (
     handleSelectReturn(view, context)
     return
   }
-  handleSelectHint(input, context)
+  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 = (
@@ -116,12 +149,30 @@ const runWithSuspendedTui = (
   )
 }
 
-const runConnectSelection = (selected: ProjectItem, context: SelectContext) => {
-  context.setMessage(`Connecting to ${selected.displayName}...`)
+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)
   runWithSuspendedTui(
     context,
-    connectProjectSshWithUp(selected),
+    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)
+        )
+    }),
     () => {
       context.setSshActive(false)
     },
@@ -136,14 +187,20 @@ const runDownSelection = (selected: ProjectItem, context: SelectContext) => {
       Effect.sync(suspendTui),
       Effect.zipRight(runDockerComposeDown(selected.projectDir)),
       Effect.zipRight(listRunningProjectItems),
-      Effect.tap((items) =>
+      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)
+          startSelectView(items, "Down", context, runtimeByProject)
           context.setMessage("Container stopped. Select another to stop, or Esc to return.")
         })
       ),
@@ -193,13 +250,24 @@ const handleSelectReturn = (
     resetToMenu(context)
     return
   }
+  const selectedRuntime = runtimeForSelection(view, selected)
+  const sshSessionsLabel = selectedRuntime.sshSessions === 1
+    ? "1 active SSH session"
+    : `${selectedRuntime.sshSessions} active SSH sessions`
 
   Match.value(view.purpose).pipe(
     Match.when("Connect", () => {
       context.setActiveDir(selected.projectDir)
-      runConnectSelection(selected, context)
+      runConnectSelection(selected, context, view.connectEnableMcpPlaywright)
     }),
     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)
     }),
@@ -209,8 +277,9 @@ const handleSelectReturn = (
     }),
     Match.when("Delete", () => {
       if (!view.confirmDelete) {
+        const activeSshWarning = selectedRuntime.sshSessions > 0 ? ` ${sshSessionsLabel}.` : ""
         context.setMessage(
-          `Really delete ${selected.displayName}? Press Enter again to confirm, Esc to cancel.`
+          `Really delete ${selected.displayName}?${activeSshWarning} Press Enter again to confirm, Esc to cancel.`
         )
         context.setView({ ...view, confirmDelete: true })
         return
@@ -221,12 +290,6 @@ const handleSelectReturn = (
   )
 }
 
-const handleSelectHint = (input: string, context: SelectContext) => {
-  if (input.trim().length > 0) {
-    context.setMessage("Use arrows + Enter to select a project, Esc to cancel.")
-  }
-}
-
 export const loadSelectView = <E>(
   effect: Effect.Effect<ReadonlyArray<ProjectItem>, E, MenuEnv>,
   purpose: "Connect" | "Down" | "Info" | "Delete",
@@ -235,16 +298,21 @@ export const loadSelectView = <E>(
   pipe(
     effect,
     Effect.flatMap((items) =>
-      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)
-      })
+      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-types.ts

@@ -77,10 +77,17 @@ export type ViewState =
     readonly _tag: "SelectProject"
     readonly purpose: "Connect" | "Down" | "Info" | "Delete"
     readonly items: ReadonlyArray<ProjectItem>
+    readonly runtimeByProject: Readonly<Record<string, SelectProjectRuntime>>
     readonly selected: number
     readonly confirmDelete: boolean
+    readonly connectEnableMcpPlaywright: boolean
   }
 
+export type SelectProjectRuntime = {
+  readonly running: boolean
+  readonly sshSessions: number
+}
+
 export const menuItems: ReadonlyArray<{ readonly id: MenuAction; readonly label: string }> = [
   { id: { _tag: "Create" }, label: "Create project" },
   { id: { _tag: "Select" }, label: "Select project" },

package/src/docker-git/menu.ts

@@ -185,13 +185,15 @@ const renderView = (context: RenderContext) => {
     return renderCreate(label, context.view.buffer, context.message, context.view.step, currentDefaults)
   }
 
-  return renderSelect(
-    context.view.purpose,
-    context.view.items,
-    context.view.selected,
-    context.view.confirmDelete,
-    context.message
-  )
+  return renderSelect({
+    purpose: context.view.purpose,
+    items: context.view.items,
+    selected: context.view.selected,
+    runtimeByProject: context.view.runtimeByProject,
+    confirmDelete: context.view.confirmDelete,
+    connectEnableMcpPlaywright: context.view.connectEnableMcpPlaywright,
+    message: context.message
+  })
 }
 
 const useMenuState = () => {

package/tests/docker-git/menu-select-connect.test.ts

@@ -0,0 +1,64 @@
+import { Effect } from "effect"
+import { describe, expect, it } from "vitest"
+
+import type { ProjectItem } from "@effect-template/lib/usecases/projects"
+import { selectHint } from "../../src/docker-git/menu-render-select.js"
+import { buildConnectEffect, isConnectMcpToggleInput } from "../../src/docker-git/menu-select-connect.js"
+
+const makeProjectItem = (): ProjectItem => ({
+  projectDir: "/home/dev/provercoderai/docker-git/workspaces/org/repo",
+  displayName: "org/repo",
+  repoUrl: "https://github.com/org/repo.git",
+  repoRef: "main",
+  containerName: "dg-repo",
+  serviceName: "dg-repo",
+  sshUser: "dev",
+  sshPort: 2222,
+  targetDir: "/home/dev/org/repo",
+  sshCommand: "ssh -p 2222 dev@localhost",
+  sshKeyPath: null,
+  authorizedKeysPath: "/home/dev/provercoderai/docker-git/workspaces/org/repo/.docker-git/authorized_keys",
+  authorizedKeysExists: true,
+  envGlobalPath: "/home/dev/provercoderai/docker-git/.orch/env/global.env",
+  envProjectPath: "/home/dev/provercoderai/docker-git/workspaces/org/repo/.orch/env/project.env",
+  codexAuthPath: "/home/dev/provercoderai/docker-git/.orch/auth/codex",
+  codexHome: "/home/dev/.codex"
+})
+
+const record = (events: Array<string>, entry: string): Effect.Effect<void> =>
+  Effect.sync(() => {
+    events.push(entry)
+  })
+
+const makeConnectDeps = (events: Array<string>) => ({
+  connectWithUp: (selected: ProjectItem) => record(events, `connect:${selected.projectDir}`),
+  enableMcpPlaywright: (projectDir: string) => record(events, `enable:${projectDir}`)
+})
+
+describe("menu-select-connect", () => {
+  it("runs Playwright enable before SSH when toggle is ON", () => {
+    const item = makeProjectItem()
+    const events: Array<string> = []
+    Effect.runSync(buildConnectEffect(item, true, makeConnectDeps(events)))
+    expect(events).toEqual([`enable:${item.projectDir}`, `connect:${item.projectDir}`])
+  })
+
+  it("skips Playwright enable when toggle is OFF", () => {
+    const item = makeProjectItem()
+    const events: Array<string> = []
+    Effect.runSync(buildConnectEffect(item, false, makeConnectDeps(events)))
+    expect(events).toEqual([`connect:${item.projectDir}`])
+  })
+
+  it("parses connect toggle key from user input", () => {
+    expect(isConnectMcpToggleInput("p")).toBe(true)
+    expect(isConnectMcpToggleInput(" P ")).toBe(true)
+    expect(isConnectMcpToggleInput("x")).toBe(false)
+    expect(isConnectMcpToggleInput("")).toBe(false)
+  })
+
+  it("renders connect hint with current Playwright toggle state", () => {
+    expect(selectHint("Connect", true)).toContain("toggle Playwright MCP (on)")
+    expect(selectHint("Connect", false)).toContain("toggle Playwright MCP (off)")
+  })
+})