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

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

@@ -0,0 +1,107 @@
+import { handleCreateInput } from "./menu-create.js"
+import { handleMenuInput } from "./menu-menu.js"
+import { handleSelectInput } from "./menu-select.js"
+import type { MenuKeyInput, MenuRunner, MenuState, MenuViewContext, ViewState } from "./menu-types.js"
+
+export type InputStage = "cold" | "active"
+
+export type MenuInputContext = MenuViewContext & {
+  readonly busy: boolean
+  readonly view: ViewState
+  readonly inputStage: InputStage
+  readonly setInputStage: (stage: InputStage) => void
+  readonly selected: number
+  readonly setSelected: (update: (value: number) => number) => void
+  readonly setSkipInputs: (update: (value: number) => number) => void
+  readonly sshActive: boolean
+  readonly setSshActive: (active: boolean) => void
+  readonly state: MenuState
+  readonly runner: MenuRunner
+  readonly exit: () => void
+}
+
+const activateInput = (
+  input: string,
+  key: Pick<MenuKeyInput, "upArrow" | "downArrow" | "return">,
+  context: Pick<MenuInputContext, "inputStage" | "setInputStage">
+): { readonly activated: boolean; readonly allowProcessing: boolean } => {
+  if (context.inputStage === "active") {
+    return { activated: false, allowProcessing: true }
+  }
+
+  if (input.trim().length > 0) {
+    context.setInputStage("active")
+    return { activated: true, allowProcessing: true }
+  }
+
+  if (key.upArrow || key.downArrow || key.return) {
+    context.setInputStage("active")
+    return { activated: true, allowProcessing: false }
+  }
+
+  if (input.length > 0) {
+    context.setInputStage("active")
+    return { activated: true, allowProcessing: true }
+  }
+
+  return { activated: false, allowProcessing: false }
+}
+
+const shouldHandleMenuInput = (
+  input: string,
+  key: Pick<MenuKeyInput, "upArrow" | "downArrow" | "return">,
+  context: Pick<MenuInputContext, "inputStage" | "setInputStage">
+): boolean => {
+  const activation = activateInput(input, key, context)
+  if (activation.activated && !activation.allowProcessing) {
+    return false
+  }
+  return activation.allowProcessing
+}
+
+export const handleUserInput = (
+  input: string,
+  key: MenuKeyInput,
+  context: MenuInputContext
+) => {
+  if (context.busy || context.sshActive) {
+    return
+  }
+
+  if (context.view._tag === "Menu") {
+    if (!shouldHandleMenuInput(input, key, context)) {
+      return
+    }
+    handleMenuInput(input, key, {
+      selected: context.selected,
+      setSelected: context.setSelected,
+      state: context.state,
+      runner: context.runner,
+      exit: context.exit,
+      setView: context.setView,
+      setMessage: context.setMessage
+    })
+    return
+  }
+
+  if (context.view._tag === "Create") {
+    handleCreateInput(input, key, context.view, {
+      state: context.state,
+      setView: context.setView,
+      setMessage: context.setMessage,
+      runner: context.runner,
+      setActiveDir: context.setActiveDir
+    })
+    return
+  }
+
+  handleSelectInput(input, key, context.view, {
+    setView: context.setView,
+    setMessage: context.setMessage,
+    setActiveDir: context.setActiveDir,
+    activeDir: context.state.activeDir,
+    runner: context.runner,
+    setSshActive: context.setSshActive,
+    setSkipInputs: context.setSkipInputs
+  })
+}

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

@@ -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,7 +49,11 @@ 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(
@@ -61,9 +88,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 +129,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}`)
 ]
 

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

@@ -103,15 +103,20 @@ const renderMenuMessage = (
   )
 }
 
-export const renderMenu = (
-  cwd: string,
-  activeDir: string | null,
-  selected: number,
-  busy: boolean,
-  message: string | null
-): React.ReactElement => {
+type MenuRenderInput = {
+  readonly cwd: string
+  readonly activeDir: string | null
+  readonly runningDockerGitContainers: number
+  readonly selected: number
+  readonly busy: boolean
+  readonly message: string | null
+}
+
+export const renderMenu = (input: MenuRenderInput): React.ReactElement => {
+  const { activeDir, busy, cwd, message, runningDockerGitContainers, selected } = input
   const el = React.createElement
   const activeLabel = `Active: ${activeDir ?? "(none)"}`
+  const runningLabel = `Running docker-git containers: ${runningDockerGitContainers}`
   const cwdLabel = `CWD: ${cwd}`
   const items = menuItems.map((item, index) => {
     const indexLabel = `${index + 1})`
@@ -134,6 +139,7 @@ export const renderMenu = (
     "docker-git",
     compactElements([
       el(Text, null, activeLabel),
+      el(Text, null, runningLabel),
       el(Text, null, cwdLabel),
       el(Box, { flexDirection: "column", marginTop: 1 }, ...items),
       hints,

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",
+  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.ts

@@ -7,10 +7,9 @@ import {
   listRunningProjectItems,
   type ProjectItem
 } from "@effect-template/lib/usecases/projects"
-
 import { Effect, Match, pipe } from "effect"
-
 import { buildConnectEffect, isConnectMcpToggleInput } from "./menu-select-connect.js"
+import { sortItemsByLaunchTime } from "./menu-select-order.js"
 import { loadRuntimeByProject, runtimeForSelection } from "./menu-select-runtime.js"
 import { resetToMenu, resumeTui, suspendTui } from "./menu-shared.js"
 import type {
@@ -37,11 +36,12 @@ export const startSelectView = (
   context: Pick<SelectContext, "setView" | "setMessage">,
   runtimeByProject: Readonly<Record<string, SelectProjectRuntime>> = emptyRuntimeByProject()
 ) => {
+  const sortedItems = sortItemsByLaunchTime(items, runtimeByProject)
   context.setMessage(null)
   context.setView({
     _tag: "SelectProject",
     purpose,
-    items,
+    items: sortedItems,
     runtimeByProject,
     selected: 0,
     confirmDelete: false,
@@ -289,30 +289,3 @@ const handleSelectReturn = (
     Match.exhaustive
   )
 }
-
-export const loadSelectView = <E>(
-  effect: Effect.Effect<ReadonlyArray<ProjectItem>, E, MenuEnv>,
-  purpose: "Connect" | "Down" | "Info" | "Delete",
-  context: Pick<SelectContext, "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-startup.ts

@@ -0,0 +1,83 @@
+import type { ProjectItem } from "@effect-template/lib/usecases/projects"
+
+export type MenuStartupSnapshot = {
+  readonly activeDir: string | null
+  readonly runningDockerGitContainers: number
+  readonly message: string | null
+}
+
+const dockerGitContainerPrefix = "dg-"
+
+const emptySnapshot = (): MenuStartupSnapshot => ({
+  activeDir: null,
+  runningDockerGitContainers: 0,
+  message: null
+})
+
+const uniqueDockerGitContainerNames = (
+  runningContainerNames: ReadonlyArray<string>
+): ReadonlyArray<string> => [
+  ...new Set(runningContainerNames.filter((name) => name.startsWith(dockerGitContainerPrefix)))
+]
+
+const detectKnownRunningProjects = (
+  items: ReadonlyArray<ProjectItem>,
+  runningDockerGitNames: ReadonlyArray<string>
+): ReadonlyArray<ProjectItem> => {
+  const runningSet = new Set(runningDockerGitNames)
+  return items.filter((item) => runningSet.has(item.containerName))
+}
+
+const renderRunningHint = (runningCount: number): string =>
+  runningCount === 1
+    ? "Detected 1 running docker-git container."
+    : `Detected ${runningCount} running docker-git containers.`
+
+// CHANGE: infer initial menu state from currently running docker-git containers
+// WHY: avoid "(none)" confusion when containers are already up outside this TUI session
+// QUOTE(ISSUE): "У меня запущены контейнеры от docker-git но он говорит что они не запущены"
+// REF: issue-13
+// SOURCE: n/a
+// FORMAT THEOREM: forall startupState: snapshot(startupState) -> deterministic(menuState)
+// PURITY: CORE
+// EFFECT: n/a
+// INVARIANT: activeDir is set only when exactly one known project is running
+// COMPLEXITY: O(|containers| + |projects|)
+export const resolveMenuStartupSnapshot = (
+  items: ReadonlyArray<ProjectItem>,
+  runningContainerNames: ReadonlyArray<string>
+): MenuStartupSnapshot => {
+  const runningDockerGitNames = uniqueDockerGitContainerNames(runningContainerNames)
+  if (runningDockerGitNames.length === 0) {
+    return emptySnapshot()
+  }
+
+  const knownRunningProjects = detectKnownRunningProjects(items, runningDockerGitNames)
+  if (knownRunningProjects.length === 1 && runningDockerGitNames.length === 1) {
+    const selected = knownRunningProjects[0]
+    if (!selected) {
+      return emptySnapshot()
+    }
+    return {
+      activeDir: selected.projectDir,
+      runningDockerGitContainers: 1,
+      message: `Auto-selected active project: ${selected.displayName}.`
+    }
+  }
+
+  if (knownRunningProjects.length === 0) {
+    return {
+      activeDir: null,
+      runningDockerGitContainers: runningDockerGitNames.length,
+      message: `${renderRunningHint(runningDockerGitNames.length)} No matching project config found.`
+    }
+  }
+
+  return {
+    activeDir: null,
+    runningDockerGitContainers: runningDockerGitNames.length,
+    message: `${renderRunningHint(runningDockerGitNames.length)} Use Select project to choose active.`
+  }
+}
+
+export const defaultMenuStartupSnapshot = emptySnapshot

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

@@ -86,6 +86,8 @@ export type ViewState =
 export type SelectProjectRuntime = {
   readonly running: boolean
   readonly sshSessions: number
+  readonly startedAtIso: string | null
+  readonly startedAtEpochMs: number | null
 }
 
 export const menuItems: ReadonlyArray<{ readonly id: MenuAction; readonly label: string }> = [