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

package/src/docker-git/menu.ts

@@ -1,24 +1,18 @@
+import { runDockerPsNames } from "@effect-template/lib/shell/docker"
 import { type InputCancelledError, InputReadError } from "@effect-template/lib/shell/errors"
 import { type AppError, renderError } from "@effect-template/lib/usecases/errors"
+import { listProjectItems } from "@effect-template/lib/usecases/projects"
 import { NodeContext } from "@effect/platform-node"
 import { Effect, pipe } from "effect"
 import { render, useApp, useInput } from "ink"
 import React, { useEffect, useMemo, useState } from "react"
 
-import { handleCreateInput, resolveCreateInputs } from "./menu-create.js"
-import { handleMenuInput } from "./menu-menu.js"
+import { resolveCreateInputs } from "./menu-create.js"
+import { handleUserInput, type InputStage } from "./menu-input-handler.js"
 import { renderCreate, renderMenu, renderSelect, renderStepLabel } from "./menu-render.js"
-import { handleSelectInput } from "./menu-select.js"
 import { leaveTui, resumeTui } from "./menu-shared.js"
-import {
-  createSteps,
-  type MenuEnv,
-  type MenuKeyInput,
-  type MenuRunner,
-  type MenuState,
-  type MenuViewContext,
-  type ViewState
-} from "./menu-types.js"
+import { defaultMenuStartupSnapshot, resolveMenuStartupSnapshot } from "./menu-startup.js"
+import { createSteps, type MenuEnv, type MenuState, type ViewState } from "./menu-types.js"
 
 // CHANGE: keep menu state in the TUI layer
 // WHY: provide a dynamic interface with live selection and inputs
@@ -58,115 +52,11 @@ const useRunner = (
   return { runEffect }
 }
 
-type InputStage = "cold" | "active"
-
-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
-}
-
-const handleUserInput = (
-  input: string,
-  key: MenuKeyInput,
-  context: MenuInputContext
-) => {
-  if (context.busy) {
-    return
-  }
-  if (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
-  })
-}
-
 type RenderContext = {
   readonly state: MenuState
   readonly view: ViewState
   readonly activeDir: string | null
+  readonly runningDockerGitContainers: number
   readonly selected: number
   readonly busy: boolean
   readonly message: string | null
@@ -174,7 +64,14 @@ type RenderContext = {
 
 const renderView = (context: RenderContext) => {
   if (context.view._tag === "Menu") {
-    return renderMenu(context.state.cwd, context.activeDir, context.selected, context.busy, context.message)
+    return renderMenu({
+      cwd: context.state.cwd,
+      activeDir: context.activeDir,
+      runningDockerGitContainers: context.runningDockerGitContainers,
+      selected: context.selected,
+      busy: context.busy,
+      message: context.message
+    })
   }
 
   if (context.view._tag === "Create") {
@@ -198,6 +95,7 @@ const renderView = (context: RenderContext) => {
 
 const useMenuState = () => {
   const [activeDir, setActiveDir] = useState<string | null>(null)
+  const [runningDockerGitContainers, setRunningDockerGitContainers] = useState(0)
   const [selected, setSelected] = useState(0)
   const [busy, setBusy] = useState(false)
   const [message, setMessage] = useState<string | null>(null)
@@ -213,6 +111,8 @@ const useMenuState = () => {
   return {
     activeDir,
     setActiveDir,
+    runningDockerGitContainers,
+    setRunningDockerGitContainers,
     selected,
     setSelected,
     busy,
@@ -245,6 +145,41 @@ const useReadyGate = (setReady: (ready: boolean) => void) => {
   }, [setReady])
 }
 
+const useStartupSnapshot = (
+  setActiveDir: (value: string | null) => void,
+  setRunningDockerGitContainers: (value: number) => void,
+  setMessage: (message: string | null) => void
+) => {
+  useEffect(() => {
+    let cancelled = false
+
+    const startup = pipe(
+      Effect.all([listProjectItems, runDockerPsNames(process.cwd())]),
+      Effect.map(([items, runningNames]) => resolveMenuStartupSnapshot(items, runningNames)),
+      Effect.match({
+        onFailure: () => defaultMenuStartupSnapshot(),
+        onSuccess: (snapshot) => snapshot
+      }),
+      Effect.provide(NodeContext.layer)
+    )
+
+    void Effect.runPromise(startup).then((snapshot) => {
+      if (cancelled) {
+        return
+      }
+      setRunningDockerGitContainers(snapshot.runningDockerGitContainers)
+      setMessage(snapshot.message)
+      if (snapshot.activeDir !== null) {
+        setActiveDir(snapshot.activeDir)
+      }
+    })
+
+    return () => {
+      cancelled = true
+    }
+  }, [setActiveDir, setMessage, setRunningDockerGitContainers])
+}
+
 const useSigintGuard = (exit: () => void, sshActive: boolean) => {
   useEffect(() => {
     const handleSigint = () => {
@@ -265,6 +200,7 @@ const TuiApp = () => {
   const menu = useMenuState()
 
   useReadyGate(menu.setReady)
+  useStartupSnapshot(menu.setActiveDir, menu.setRunningDockerGitContainers, menu.setMessage)
   useSigintGuard(exit, menu.sshActive)
 
   useInput(
@@ -304,6 +240,7 @@ const TuiApp = () => {
     state: menu.state,
     view: menu.view,
     activeDir: menu.activeDir,
+    runningDockerGitContainers: menu.runningDockerGitContainers,
     selected: menu.selected,
     busy: menu.busy,
     message: menu.message

package/tests/docker-git/fixtures/project-item.ts

@@ -0,0 +1,24 @@
+import type { ProjectItem } from "@effect-template/lib/usecases/projects"
+
+export const makeProjectItem = (
+  overrides: Partial<ProjectItem> = {}
+): ProjectItem => ({
+  projectDir: "/home/dev/.docker-git/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/.docker-git/org-repo/.docker-git/authorized_keys",
+  authorizedKeysExists: true,
+  envGlobalPath: "/home/dev/.orch/env/global.env",
+  envProjectPath: "/home/dev/.docker-git/org-repo/.orch/env/project.env",
+  codexAuthPath: "/home/dev/.orch/auth/codex",
+  codexHome: "/home/dev/.codex",
+  ...overrides
+})

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

@@ -2,28 +2,10 @@ 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"
-})
+import { makeProjectItem } from "./fixtures/project-item.js"
 
 const record = (events: Array<string>, entry: string): Effect.Effect<void> =>
   Effect.sync(() => {
@@ -35,16 +17,25 @@ const makeConnectDeps = (events: Array<string>) => ({
   enableMcpPlaywright: (projectDir: string) => record(events, `enable:${projectDir}`)
 })
 
+const workspaceProject = () =>
+  makeProjectItem({
+    projectDir: "/home/dev/provercoderai/docker-git/workspaces/org/repo",
+    authorizedKeysPath: "/home/dev/provercoderai/docker-git/workspaces/org/repo/.docker-git/authorized_keys",
+    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"
+  })
+
 describe("menu-select-connect", () => {
   it("runs Playwright enable before SSH when toggle is ON", () => {
-    const item = makeProjectItem()
+    const item = workspaceProject()
     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 item = workspaceProject()
     const events: Array<string> = []
     Effect.runSync(buildConnectEffect(item, false, makeConnectDeps(events)))
     expect(events).toEqual([`connect:${item.projectDir}`])

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

@@ -0,0 +1,73 @@
+import { describe, expect, it } from "vitest"
+
+import { buildSelectLabels } from "../../src/docker-git/menu-render-select.js"
+import { sortItemsByLaunchTime } from "../../src/docker-git/menu-select-order.js"
+import type { SelectProjectRuntime } from "../../src/docker-git/menu-types.js"
+import { makeProjectItem } from "./fixtures/project-item.js"
+
+const makeRuntime = (
+  overrides: Partial<SelectProjectRuntime> = {}
+): SelectProjectRuntime => ({
+  running: false,
+  sshSessions: 0,
+  startedAtIso: null,
+  startedAtEpochMs: null,
+  ...overrides
+})
+
+const emitProof = (message: string): void => {
+  process.stdout.write(`[issue-57-proof] ${message}\n`)
+}
+
+describe("menu-select order", () => {
+  it("sorts projects by last container start time (newest first)", () => {
+    const newest = makeProjectItem({ projectDir: "/home/dev/.docker-git/newest", displayName: "org/newest" })
+    const older = makeProjectItem({ projectDir: "/home/dev/.docker-git/older", displayName: "org/older" })
+    const neverStarted = makeProjectItem({ projectDir: "/home/dev/.docker-git/never", displayName: "org/never" })
+    const startedNewest = "2026-02-17T11:30:00Z"
+    const startedOlder = "2026-02-16T07:15:00Z"
+    const runtimeByProject: Readonly<Record<string, SelectProjectRuntime>> = {
+      [newest.projectDir]: makeRuntime({
+        running: true,
+        sshSessions: 1,
+        startedAtIso: startedNewest,
+        startedAtEpochMs: Date.parse(startedNewest)
+      }),
+      [older.projectDir]: makeRuntime({
+        running: true,
+        sshSessions: 0,
+        startedAtIso: startedOlder,
+        startedAtEpochMs: Date.parse(startedOlder)
+      }),
+      [neverStarted.projectDir]: makeRuntime()
+    }
+
+    const sorted = sortItemsByLaunchTime([neverStarted, older, newest], runtimeByProject)
+    expect(sorted.map((item) => item.projectDir)).toEqual([
+      newest.projectDir,
+      older.projectDir,
+      neverStarted.projectDir
+    ])
+    emitProof("sorting by launch time works: newest container is selected first")
+  })
+
+  it("shows container launch timestamp in select labels", () => {
+    const item = makeProjectItem({ projectDir: "/home/dev/.docker-git/example", displayName: "org/example" })
+    const startedAtIso = "2026-02-17T09:45:00Z"
+    const runtimeByProject: Readonly<Record<string, SelectProjectRuntime>> = {
+      [item.projectDir]: makeRuntime({
+        running: true,
+        sshSessions: 2,
+        startedAtIso,
+        startedAtEpochMs: Date.parse(startedAtIso)
+      })
+    }
+
+    const connectLabel = buildSelectLabels([item], 0, "Connect", runtimeByProject)[0]
+    const downLabel = buildSelectLabels([item], 0, "Down", runtimeByProject)[0]
+
+    expect(connectLabel).toContain("[started=2026-02-17 09:45 UTC]")
+    expect(downLabel).toContain("running, ssh=2, started=2026-02-17 09:45 UTC")
+    emitProof("UI labels show container start timestamp in Connect and Down views")
+  })
+})

package/tests/docker-git/menu-startup.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, it } from "vitest"
+
+import { resolveMenuStartupSnapshot } from "../../src/docker-git/menu-startup.js"
+import { makeProjectItem } from "./fixtures/project-item.js"
+
+describe("menu-startup", () => {
+  it("returns empty snapshot when no docker-git containers are running", () => {
+    const snapshot = resolveMenuStartupSnapshot([makeProjectItem({})], ["postgres", "redis"])
+
+    expect(snapshot).toEqual({
+      activeDir: null,
+      runningDockerGitContainers: 0,
+      message: null
+    })
+  })
+
+  it("auto-selects active project when exactly one known docker-git container is running", () => {
+    const item = makeProjectItem({})
+    const snapshot = resolveMenuStartupSnapshot([item], [item.containerName])
+
+    expect(snapshot.activeDir).toBe(item.projectDir)
+    expect(snapshot.runningDockerGitContainers).toBe(1)
+    expect(snapshot.message).toContain(item.displayName)
+  })
+
+  it("does not auto-select when multiple docker-git containers are running", () => {
+    const first = makeProjectItem({
+      containerName: "dg-one",
+      displayName: "org/one",
+      projectDir: "/home/dev/.docker-git/org-one"
+    })
+    const second = makeProjectItem({
+      containerName: "dg-two",
+      displayName: "org/two",
+      projectDir: "/home/dev/.docker-git/org-two"
+    })
+    const snapshot = resolveMenuStartupSnapshot([first, second], [first.containerName, second.containerName])
+
+    expect(snapshot.activeDir).toBeNull()
+    expect(snapshot.runningDockerGitContainers).toBe(2)
+    expect(snapshot.message).toContain("Use Select project")
+  })
+
+  it("shows warning when running docker-git containers have no matching configs", () => {
+    const snapshot = resolveMenuStartupSnapshot([], ["dg-unknown", "dg-another"])
+
+    expect(snapshot.activeDir).toBeNull()
+    expect(snapshot.runningDockerGitContainers).toBe(2)
+    expect(snapshot.message).toContain("No matching project config found")
+  })
+})