@prover-coder-ai/docker-git 1.0.15 → 1.0.17

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

@@ -0,0 +1,30 @@
+import { Box, Text } from "ink"
+import React from "react"
+
+const renderMessage = (message: string | null): React.ReactElement | null => {
+  if (!message) {
+    return null
+  }
+  return React.createElement(
+    Box,
+    { marginTop: 1 },
+    React.createElement(Text, { color: "magenta" }, message)
+  )
+}
+
+export const renderLayout = (
+  title: string,
+  body: ReadonlyArray<React.ReactElement>,
+  message: string | null
+): React.ReactElement => {
+  const el = React.createElement
+  const messageView = renderMessage(message)
+  const tail = messageView ? [messageView] : []
+  return el(
+    Box,
+    { flexDirection: "column", padding: 1, borderStyle: "round" },
+    el(Text, { color: "cyan", bold: true }, title),
+    ...body,
+    ...tail
+  )
+}

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

@@ -0,0 +1,70 @@
+import { Box, Text } from "ink"
+import React from "react"
+
+import { projectAuthMenuLabels, projectAuthViewSteps } from "./menu-project-auth-data.js"
+import {
+  renderMenuHelp,
+  renderPromptLayout,
+  renderSelectableMenuList,
+  resolvePromptState
+} from "./menu-render-common.js"
+import { renderLayout } from "./menu-render-layout.js"
+import type { ProjectAuthSnapshot, ViewState } from "./menu-types.js"
+
+const renderActiveLabel = (value: string | null): string => value ?? "(not set)"
+
+const renderCountLine = (title: string, count: number): string => `${title}: ${count}`
+
+export const renderProjectAuthMenu = (
+  snapshot: ProjectAuthSnapshot,
+  selected: number,
+  message: string | null
+): React.ReactElement => {
+  const el = React.createElement
+  const list = renderSelectableMenuList(projectAuthMenuLabels(), selected)
+
+  return renderLayout(
+    "docker-git / Project auth",
+    [
+      el(Text, null, `Project: ${snapshot.projectName}`),
+      el(Text, { color: "gray" }, `Dir: ${snapshot.projectDir}`),
+      el(Text, { color: "gray" }, `Project env: ${snapshot.envProjectPath}`),
+      el(Text, { color: "gray" }, `Global env: ${snapshot.envGlobalPath}`),
+      el(Text, { color: "gray" }, `Claude auth: ${snapshot.claudeAuthPath}`),
+      el(
+        Box,
+        { marginTop: 1, flexDirection: "column" },
+        el(Text, { color: "gray" }, `GitHub label: ${renderActiveLabel(snapshot.activeGithubLabel)}`),
+        el(Text, { color: "gray" }, renderCountLine("Available GitHub tokens", snapshot.githubTokenEntries)),
+        el(Text, { color: "gray" }, `Git label: ${renderActiveLabel(snapshot.activeGitLabel)}`),
+        el(Text, { color: "gray" }, renderCountLine("Available Git tokens", snapshot.gitTokenEntries)),
+        el(Text, { color: "gray" }, `Claude label: ${renderActiveLabel(snapshot.activeClaudeLabel)}`),
+        el(Text, { color: "gray" }, renderCountLine("Available Claude logins", snapshot.claudeAuthEntries))
+      ),
+      el(Box, { flexDirection: "column", marginTop: 1 }, ...list),
+      renderMenuHelp("Use arrows + Enter, or type a number from the list.")
+    ],
+    message
+  )
+}
+
+export const renderProjectAuthPrompt = (
+  view: Extract<ViewState, { readonly _tag: "ProjectAuthPrompt" }>,
+  message: string | null
+): React.ReactElement => {
+  const el = React.createElement
+  const { prompt, visibleBuffer } = resolvePromptState(projectAuthViewSteps(view.flow), view.step, view.buffer)
+
+  return renderPromptLayout({
+    title: "docker-git / Project auth / Set label",
+    header: [
+      el(Text, { color: "gray" }, `Project: ${view.snapshot.projectName}`),
+      el(Text, { color: "gray" }, `Project env: ${view.snapshot.envProjectPath}`),
+      el(Text, { color: "gray" }, `Global env: ${view.snapshot.envGlobalPath}`)
+    ],
+    prompt,
+    visibleBuffer,
+    helpLine: "Enter = apply, Esc = cancel.",
+    message
+  })
+}

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

@@ -5,7 +5,7 @@ import type React from "react"
 import type { ProjectItem } from "@effect-template/lib/usecases/projects"
 import type { SelectProjectRuntime } from "./menu-types.js"
 
-export type SelectPurpose = "Connect" | "Down" | "Info" | "Delete"
+export type SelectPurpose = "Connect" | "Down" | "Info" | "Delete" | "Auth"
 
 const formatRepoRef = (repoRef: string): string => {
   const trimmed = repoRef.trim()
@@ -18,7 +18,30 @@ const formatRepoRef = (repoRef: string): string => {
   return trimmed.length > 0 ? trimmed : "main"
 }
 
-const stoppedRuntime = (): SelectProjectRuntime => ({ running: false, sshSessions: 0 })
+const stoppedRuntime = (): SelectProjectRuntime => ({
+  running: false,
+  sshSessions: 0,
+  startedAtIso: null,
+  startedAtEpochMs: null
+})
+
+const pad2 = (value: number): string => value.toString().padStart(2, "0")
+
+const formatUtcTimestamp = (epochMs: number, withSeconds: boolean): string => {
+  const date = new Date(epochMs)
+  const seconds = withSeconds ? `:${pad2(date.getUTCSeconds())}` : ""
+  return `${date.getUTCFullYear()}-${pad2(date.getUTCMonth() + 1)}-${pad2(date.getUTCDate())} ${
+    pad2(
+      date.getUTCHours()
+    )
+  }:${pad2(date.getUTCMinutes())}${seconds} UTC`
+}
+
+const renderStartedAtCompact = (runtime: SelectProjectRuntime): string =>
+  runtime.startedAtEpochMs === null ? "-" : formatUtcTimestamp(runtime.startedAtEpochMs, false)
+
+const renderStartedAtDetailed = (runtime: SelectProjectRuntime): string =>
+  runtime.startedAtEpochMs === null ? "not available" : formatUtcTimestamp(runtime.startedAtEpochMs, true)
 
 const runtimeForProject = (
   runtimeByProject: Readonly<Record<string, SelectProjectRuntime>>,
@@ -26,11 +49,16 @@ const runtimeForProject = (
 ): SelectProjectRuntime => runtimeByProject[item.projectDir] ?? stoppedRuntime()
 
 const renderRuntimeLabel = (runtime: SelectProjectRuntime): string =>
-  `${runtime.running ? "running" : "stopped"}, ssh=${runtime.sshSessions}`
+  `${runtime.running ? "running" : "stopped"}, ssh=${runtime.sshSessions}, started=${
+    renderStartedAtCompact(
+      runtime
+    )
+  }`
 
 export const selectTitle = (purpose: SelectPurpose): string =>
   Match.value(purpose).pipe(
     Match.when("Connect", () => "docker-git / Select project"),
+    Match.when("Auth", () => "docker-git / Project auth"),
     Match.when("Down", () => "docker-git / Stop container"),
     Match.when("Info", () => "docker-git / Show connection info"),
     Match.when("Delete", () => "docker-git / Delete project"),
@@ -46,6 +74,7 @@ export const selectHint = (
       "Connect",
       () => `Enter = select + SSH, P = toggle Playwright MCP (${connectEnableMcpPlaywright ? "on" : "off"}), Esc = back`
     ),
+    Match.when("Auth", () => "Enter = open project auth menu, 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"),
@@ -61,9 +90,10 @@ export const buildSelectLabels = (
   items.map((item, index) => {
     const prefix = index === selected ? ">" : " "
     const refLabel = formatRepoRef(item.repoRef)
+    const runtime = runtimeForProject(runtimeByProject, item)
     const runtimeSuffix = purpose === "Down" || purpose === "Delete"
-      ? ` [${renderRuntimeLabel(runtimeForProject(runtimeByProject, item))}]`
-      : ""
+      ? ` [${renderRuntimeLabel(runtime)}]`
+      : ` [started=${renderStartedAtCompact(runtime)}]`
     return `${prefix} ${index + 1}. ${item.displayName} (${refLabel})${runtimeSuffix}`
   })
 
@@ -101,6 +131,7 @@ const commonRows = (
   el(Text, { wrap: "wrap" }, `Project directory: ${context.item.projectDir}`),
   el(Text, { wrap: "wrap" }, `Container: ${context.item.containerName}`),
   el(Text, { wrap: "wrap" }, `State: ${context.runtime.running ? "running" : "stopped"}`),
+  el(Text, { wrap: "wrap" }, `Started at: ${renderStartedAtDetailed(context.runtime)}`),
   el(Text, { wrap: "wrap" }, `SSH sessions now: ${context.sshSessionsLabel}`)
 ]
 
@@ -167,6 +198,14 @@ export const renderSelectDetails = (
 
   return Match.value(purpose).pipe(
     Match.when("Connect", () => renderConnectDetails(el, context, common, connectEnableMcpPlaywright)),
+    Match.when("Auth", () => [
+      titleRow(el, "Project auth"),
+      ...common,
+      el(Text, { wrap: "wrap" }, `Repo: ${context.item.repoUrl} (${context.refLabel})`),
+      el(Text, { wrap: "wrap" }, `Env global: ${context.item.envGlobalPath}`),
+      el(Text, { wrap: "wrap" }, `Env project: ${context.item.envProjectPath}`),
+      el(Text, { color: "gray", wrap: "wrap" }, "Press Enter to manage labels for this project.")
+    ]),
     Match.when("Info", () => renderInfoDetails(el, context, common)),
     Match.when("Down", () => [
       titleRow(el, "Stop container"),

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

@@ -3,6 +3,7 @@ import { Box, Text } from "ink"
 import React from "react"
 
 import type { ProjectItem } from "@effect-template/lib/usecases/projects"
+import { renderLayout } from "./menu-render-layout.js"
 import {
   buildSelectLabels,
   renderSelectDetails,
@@ -41,34 +42,6 @@ export const renderStepLabel = (step: CreateStep, defaults: CreateInputs): strin
     Match.exhaustive
   )
 
-const renderMessage = (message: string | null): React.ReactElement | null => {
-  if (!message) {
-    return null
-  }
-  return React.createElement(
-    Box,
-    { marginTop: 1 },
-    React.createElement(Text, { color: "magenta" }, message)
-  )
-}
-
-const renderLayout = (
-  title: string,
-  body: ReadonlyArray<React.ReactElement>,
-  message: string | null
-): React.ReactElement => {
-  const el = React.createElement
-  const messageView = renderMessage(message)
-  const tail = messageView ? [messageView] : []
-  return el(
-    Box,
-    { flexDirection: "column", padding: 1, borderStyle: "round" },
-    el(Text, { color: "cyan", bold: true }, title),
-    ...body,
-    ...tail
-  )
-}
-
 const compactElements = (
   items: ReadonlyArray<React.ReactElement | null>
 ): ReadonlyArray<React.ReactElement> => items.filter((item): item is React.ReactElement => item !== null)
@@ -82,7 +55,7 @@ const renderMenuHints = (el: typeof React.createElement): React.ReactElement =>
     el(
       Text,
       { color: "gray" },
-      "  - Aliases: create/c, select/s, info/i, status/ps, logs/l, down/d, down-all/da, delete/del, quit/q"
+      "  - Aliases: create/c, select/s, auth/a, project-auth/pa, info/i, status/ps, logs/l, down/d, down-all/da, delete/del, quit/q"
     ),
     el(Text, { color: "gray" }, "  - Use arrows and Enter to run.")
   )
@@ -181,6 +154,9 @@ export const renderCreate = (
   )
 }
 
+export { renderAuthMenu, renderAuthPrompt } from "./menu-render-auth.js"
+export { renderProjectAuthMenu, renderProjectAuthPrompt } from "./menu-render-project-auth.js"
+
 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)

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

@@ -0,0 +1,150 @@
+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-load.ts

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,37 @@
+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

@@ -7,9 +7,20 @@ import type { MenuEnv, SelectProjectRuntime, ViewState } from "./menu-types.js"
 
 const emptyRuntimeByProject = (): Readonly<Record<string, SelectProjectRuntime>> => ({})
 
-const stoppedRuntime = (): SelectProjectRuntime => ({ running: false, sshSessions: 0 })
+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)
@@ -19,6 +30,21 @@ const parseSshSessionCount = (raw: string): number => {
   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>> => {
@@ -48,16 +74,35 @@ const countContainerSshSessions = (
     })
   )
 
+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)}
+// FORMAT THEOREM: forall p: runtime(p) -> {running(p), ssh_sessions(p), started_at(p)}
 // PURITY: SHELL
 // EFFECT: Effect<Record<string, SelectProjectRuntime>, never, MenuEnv>
-// INVARIANT: stopped containers always have sshSessions = 0
-// COMPLEXITY: O(n + docker_ps + docker_exec)
+// 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> =>
@@ -68,13 +113,17 @@ export const loadRuntimeByProject = (
         items,
         (item) => {
           const running = runningNames.includes(item.containerName)
-          if (!running) {
-            const entry: readonly [string, SelectProjectRuntime] = [item.projectDir, stoppedRuntime()]
-            return Effect.succeed(entry)
-          }
+          const sshSessionsEffect = running
+            ? countContainerSshSessions(item.containerName)
+            : Effect.succeed(0)
           return pipe(
-            countContainerSshSessions(item.containerName),
-            Effect.map((sshSessions): SelectProjectRuntime => ({ running: true, sshSessions })),
+            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])
           )
         },

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

@@ -0,0 +1,25 @@
+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
+  })
+}