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

package/src/docker-git/tmux.ts

@@ -1,292 +0,0 @@
-import type * as CommandExecutor from "@effect/platform/CommandExecutor"
-import type { PlatformError } from "@effect/platform/Error"
-import type * as FileSystem from "@effect/platform/FileSystem"
-import type * as Path from "@effect/platform/Path"
-import { Effect, pipe } from "effect"
-
-import type { AttachCommand, PanesCommand } from "@effect-template/lib/core/domain"
-import { deriveRepoPathParts, deriveRepoSlug } from "@effect-template/lib/core/domain"
-import {
-  runCommandCapture,
-  runCommandExitCode,
-  runCommandWithExitCodes
-} from "@effect-template/lib/shell/command-runner"
-import { readProjectConfig } from "@effect-template/lib/shell/config"
-import type {
-  ConfigDecodeError,
-  ConfigNotFoundError,
-  DockerCommandError,
-  FileExistsError,
-  PortProbeError
-} from "@effect-template/lib/shell/errors"
-import { CommandFailedError } from "@effect-template/lib/shell/errors"
-import { resolveBaseDir } from "@effect-template/lib/shell/paths"
-import { findSshPrivateKey } from "@effect-template/lib/usecases/path-helpers"
-import { buildSshCommand } from "@effect-template/lib/usecases/projects"
-import { runDockerComposeUpWithPortCheck } from "@effect-template/lib/usecases/projects-up"
-
-const tmuxOk = [0]
-const layoutVersion = "v14"
-
-const makeTmuxSpec = (args: ReadonlyArray<string>) => ({
-  cwd: process.cwd(),
-  command: "tmux",
-  args
-})
-
-const runTmux = (
-  args: ReadonlyArray<string>
-): Effect.Effect<void, CommandFailedError | PlatformError, CommandExecutor.CommandExecutor> =>
-  runCommandWithExitCodes(
-    makeTmuxSpec(args),
-    tmuxOk,
-    (exitCode) => new CommandFailedError({ command: "tmux", exitCode })
-  )
-
-const runTmuxExitCode = (
-  args: ReadonlyArray<string>
-): Effect.Effect<number, PlatformError, CommandExecutor.CommandExecutor> => runCommandExitCode(makeTmuxSpec(args))
-
-const runTmuxCapture = (
-  args: ReadonlyArray<string>
-): Effect.Effect<string, CommandFailedError | PlatformError, CommandExecutor.CommandExecutor> =>
-  runCommandCapture(
-    makeTmuxSpec(args),
-    tmuxOk,
-    (exitCode) => new CommandFailedError({ command: "tmux", exitCode })
-  )
-
-const sendKeys = (
-  session: string,
-  pane: string,
-  text: string
-): Effect.Effect<void, CommandFailedError | PlatformError, CommandExecutor.CommandExecutor> =>
-  pipe(
-    runTmux(["send-keys", "-t", `${session}:0.${pane}`, "-l", text]),
-    Effect.zipRight(runTmux(["send-keys", "-t", `${session}:0.${pane}`, "C-m"]))
-  )
-
-const shellEscape = (value: string): string => {
-  if (value.length === 0) {
-    return "''"
-  }
-  if (!/[^\w@%+=:,./-]/.test(value)) {
-    return value
-  }
-  const escaped = value.replaceAll("'", "'\"'\"'")
-  return `'${escaped}'`
-}
-
-const wrapBash = (command: string): string => `bash -lc ${shellEscape(command)}`
-
-const buildJobsCommand = (containerName: string): string =>
-  [
-    "while true; do",
-    "clear",
-    "echo \"LIVE TERMINALS / JOBS (container, refresh 1s)\"",
-    "echo \"\"",
-    `docker exec ${containerName} ps -eo pid,tty,cmd,etime --sort=start_time 2>/dev/null | awk 'NR==1 {print; next} $2 != "?" && $3 !~ /(sshd|^-?bash$|^bash$|^sh$|^zsh$|^fish$)/ {print; found=1} END { if (!found) print "(no interactive jobs)" }'`,
-    "|| echo \"container not running\"",
-    "sleep 1",
-    "done"
-  ].join("; ")
-
-const readLayoutVersion = (
-  session: string
-): Effect.Effect<string | null, PlatformError, CommandExecutor.CommandExecutor> =>
-  runTmuxCapture(["show-options", "-t", session, "-v", "@docker-git-layout"]).pipe(
-    Effect.map((value) => value.trim()),
-    Effect.catchTag("CommandFailedError", () => Effect.succeed(null))
-  )
-
-const buildBottomBarCommand = (): string =>
-  [
-    "clear",
-    "echo \"[Focus: Alt+1/2/3] [Select: Alt+s] [Detach: Alt+d]\"",
-    "echo \"Tip: Mouse click = focus pane, Ctrl+a z = zoom\"",
-    "while true; do sleep 3600; done"
-  ].join("; ")
-
-const formatRepoRefLabel = (repoRef: string): string => {
-  const match = /refs\/pull\/(\d+)\/head/.exec(repoRef)
-  const pr = match?.[1]
-  return pr ? `PR#${pr}` : repoRef
-}
-
-const formatRepoDisplayName = (repoUrl: string): string => {
-  const parts = deriveRepoPathParts(repoUrl)
-  return parts.pathParts.length > 0 ? parts.pathParts.join("/") : repoUrl
-}
-
-type PaneRow = {
-  readonly id: string
-  readonly window: string
-  readonly title: string
-  readonly command: string
-}
-
-const normalizePaneCell = (value: string | undefined): string => value?.trim() ?? "-"
-
-const parsePaneRow = (line: string): PaneRow => {
-  const [id, window, title, command] = line.split("\t")
-  return {
-    id: normalizePaneCell(id),
-    window: normalizePaneCell(window),
-    title: normalizePaneCell(title),
-    command: normalizePaneCell(command)
-  }
-}
-
-const renderPaneRow = (row: PaneRow): string =>
-  `- ${row.id}  ${row.window}  ${row.title === "-" ? row.command : row.title}  ${row.command}`
-
-const configureSession = (
-  session: string,
-  repoDisplayName: string,
-  statusRight: string
-): Effect.Effect<void, CommandFailedError | PlatformError, CommandExecutor.CommandExecutor> =>
-  Effect.gen(function*(_) {
-    yield* _(runTmux(["set-option", "-t", session, "@docker-git-layout", layoutVersion]))
-    yield* _(runTmux(["set-option", "-t", session, "window-size", "largest"]))
-    yield* _(runTmux(["set-option", "-t", session, "aggressive-resize", "on"]))
-    yield* _(runTmux(["set-option", "-t", session, "mouse", "on"]))
-    yield* _(runTmux(["set-option", "-t", session, "focus-events", "on"]))
-    yield* _(runTmux(["set-option", "-t", session, "prefix", "C-a"]))
-    yield* _(runTmux(["unbind-key", "C-b"]))
-    yield* _(runTmux(["set-option", "-t", session, "status", "on"]))
-    yield* _(runTmux(["set-option", "-t", session, "status-position", "top"]))
-    yield* _(runTmux(["set-option", "-t", session, "status-left", ` docker-git :: ${repoDisplayName} `]))
-    yield* _(runTmux(["set-option", "-t", session, "status-right", ` ${statusRight} `]))
-  })
-
-const createLayout = (
-  session: string
-): Effect.Effect<void, CommandFailedError | PlatformError, CommandExecutor.CommandExecutor> =>
-  Effect.gen(function*(_) {
-    yield* _(runTmux(["new-session", "-d", "-s", session, "-n", "main"]))
-    yield* _(runTmux(["split-window", "-v", "-p", "12", "-t", `${session}:0`]))
-    yield* _(runTmux(["split-window", "-h", "-p", "35", "-t", `${session}:0.0`]))
-  })
-
-const setupPanes = (
-  session: string,
-  sshCommand: string,
-  containerName: string
-): Effect.Effect<void, CommandFailedError | PlatformError, CommandExecutor.CommandExecutor> =>
-  Effect.gen(function*(_) {
-    const leftPane = "0"
-    const bottomPane = "1"
-    const rightPane = "2"
-    yield* _(sendKeys(session, leftPane, sshCommand))
-    yield* _(sendKeys(session, rightPane, wrapBash(buildJobsCommand(containerName))))
-    yield* _(sendKeys(session, bottomPane, wrapBash(buildBottomBarCommand())))
-    yield* _(runTmux(["bind-key", "-n", "M-1", "select-pane", "-t", `${session}:0.${leftPane}`]))
-    yield* _(runTmux(["bind-key", "-n", "M-2", "select-pane", "-t", `${session}:0.${rightPane}`]))
-    yield* _(runTmux(["bind-key", "-n", "M-3", "select-pane", "-t", `${session}:0.${bottomPane}`]))
-    yield* _(runTmux(["bind-key", "-n", "M-d", "detach-client"]))
-    yield* _(runTmux(["bind-key", "-n", "M-s", "choose-tree", "-Z"]))
-    yield* _(runTmux(["select-pane", "-t", `${session}:0.${leftPane}`]))
-  })
-
-// CHANGE: list tmux panes for a docker-git project
-// WHY: allow non-interactive inspection of terminal panes (CI/automation friendly)
-// QUOTE(ТЗ): "сделай команду ... которая отобразит терминалы в докере"
-// REF: user-request-2026-02-02-panes
-// SOURCE: n/a
-// FORMAT THEOREM: forall p: panes(p) -> deterministic output
-// PURITY: SHELL
-// EFFECT: Effect<void, CommandFailedError | ConfigNotFoundError | ConfigDecodeError | PlatformError, CommandExecutor | FileSystem | Path>
-// INVARIANT: session name is deterministic from repo url
-// COMPLEXITY: O(n) where n = number of panes
-export const listTmuxPanes = (
-  command: PanesCommand
-): Effect.Effect<
-  void,
-  CommandFailedError | ConfigNotFoundError | ConfigDecodeError | PlatformError,
-  CommandExecutor.CommandExecutor | FileSystem.FileSystem | Path.Path
-> =>
-  Effect.gen(function*(_) {
-    const { resolved } = yield* _(resolveBaseDir(command.projectDir))
-    const config = yield* _(readProjectConfig(resolved))
-    const session = `dg-${deriveRepoSlug(config.template.repoUrl)}`
-    const hasSessionCode = yield* _(runTmuxExitCode(["has-session", "-t", session]))
-    if (hasSessionCode !== 0) {
-      yield* _(Effect.logWarning(`tmux session ${session} not found. Run 'docker-git attach' first.`))
-      return
-    }
-    const raw = yield* _(
-      runTmuxCapture([
-        "list-panes",
-        "-s",
-        "-t",
-        session,
-        "-F",
-        "#{pane_id}\t#{window_name}\t#{pane_title}\t#{pane_current_command}"
-      ])
-    )
-    const lines = raw
-      .split(/\r?\n/)
-      .map((line) => line.trimEnd())
-      .filter((line) => line.length > 0)
-    const rows = lines.map((line) => parsePaneRow(line))
-    yield* _(Effect.log(`Project: ${resolved}`))
-    yield* _(Effect.log(`Session: ${session}`))
-    if (rows.length === 0) {
-      yield* _(Effect.log("No panes found."))
-      return
-    }
-    for (const row of rows) {
-      yield* _(Effect.log(renderPaneRow(row)))
-    }
-  })
-
-// CHANGE: attach a tmux workspace for a docker-git project
-// WHY: provide multi-pane terminal layout for sandbox work
-// QUOTE(ТЗ): "окей Давай подключим tmux"
-// REF: user-request-2026-02-02-tmux
-// SOURCE: n/a
-// FORMAT THEOREM: forall p: attach(p) -> tmux(p)
-// PURITY: SHELL
-// EFFECT: Effect<void, CommandFailedError | DockerCommandError | ConfigNotFoundError | ConfigDecodeError | FileExistsError | PortProbeError | PlatformError, CommandExecutor | FileSystem | Path>
-// INVARIANT: tmux session name is deterministic from repo url
-// COMPLEXITY: O(1)
-export const attachTmux = (
-  command: AttachCommand
-): Effect.Effect<
-  void,
-  | CommandFailedError
-  | DockerCommandError
-  | ConfigNotFoundError
-  | ConfigDecodeError
-  | FileExistsError
-  | PortProbeError
-  | PlatformError,
-  CommandExecutor.CommandExecutor | FileSystem.FileSystem | Path.Path
-> =>
-  Effect.gen(function*(_) {
-    const { fs, path, resolved } = yield* _(resolveBaseDir(command.projectDir))
-    const sshKey = yield* _(findSshPrivateKey(fs, path, process.cwd()))
-    const template = yield* _(runDockerComposeUpWithPortCheck(resolved))
-    const sshCommand = buildSshCommand(template, sshKey)
-    const repoDisplayName = formatRepoDisplayName(template.repoUrl)
-    const refLabel = formatRepoRefLabel(template.repoRef)
-    const statusRight =
-      `SSH: ${template.sshUser}@localhost:${template.sshPort} | Repo: ${repoDisplayName} | Ref: ${refLabel} | Status: Running`
-    const session = `dg-${deriveRepoSlug(template.repoUrl)}`
-    const hasSessionCode = yield* _(runTmuxExitCode(["has-session", "-t", session]))
-
-    if (hasSessionCode === 0) {
-      const existingLayout = yield* _(readLayoutVersion(session))
-      if (existingLayout === layoutVersion) {
-        yield* _(runTmux(["attach", "-t", session]))
-        return
-      }
-      yield* _(Effect.logWarning(`tmux session ${session} uses an old layout; recreating.`))
-      yield* _(runTmux(["kill-session", "-t", session]))
-    }
-
-    yield* _(createLayout(session))
-    yield* _(configureSession(session, repoDisplayName, statusRight))
-    yield* _(setupPanes(session, sshCommand, template.containerName))
-    yield* _(runTmux(["attach", "-t", session]))
-  })

package/tests/app/main.test.ts

@@ -1,65 +0,0 @@
-import { NodeContext } from "@effect/platform-node"
-import { describe, expect, it } from "@effect/vitest"
-import { Effect, pipe } from "effect"
-import { vi } from "vitest"
-
-import { program } from "../../src/app/program.js"
-
-const withLogSpy = Effect.acquireRelease(
-  Effect.sync(() => vi.spyOn(console, "log").mockImplementation(() => {})),
-  (spy) =>
-    Effect.sync(() => {
-      spy.mockRestore()
-    })
-)
-
-const withArgv = (nextArgv: ReadonlyArray<string>) =>
-  Effect.acquireRelease(
-    Effect.sync(() => {
-      const previous = process.argv
-      process.argv = [...nextArgv]
-      return previous
-    }),
-    (previous) =>
-      Effect.sync(() => {
-        process.argv = previous
-      })
-  )
-
-type UsageCase = {
-  readonly argv: ReadonlyArray<string>
-  readonly needle: string
-}
-
-const usageCases: ReadonlyArray<UsageCase> = [
-  { argv: ["node", "main"], needle: "pnpm docker-git" },
-  { argv: ["node", "main", "Alice"], needle: "Usage:" }
-]
-
-const runUsageCase = ({
-  argv,
-  needle
-}: UsageCase) =>
-  Effect.scoped(
-    Effect.gen(function*(_) {
-      const logSpy = yield* _(withLogSpy)
-      yield* _(withArgv(argv))
-      yield* _(pipe(program, Effect.provide(NodeContext.layer)))
-      yield* _(
-        Effect.sync(() => {
-          expect(logSpy).toHaveBeenCalledTimes(1)
-          expect(logSpy).toHaveBeenLastCalledWith(
-            expect.stringContaining(needle)
-          )
-        })
-      )
-    })
-  )
-
-describe("main program", () => {
-  it.effect("prints usage for invalid invocations", () =>
-    pipe(
-      Effect.forEach(usageCases, runUsageCase, { concurrency: 1 }),
-      Effect.asVoid
-    ))
-})

package/tests/docker-git/entrypoint-auth.test.ts

@@ -1,40 +0,0 @@
-import { describe, expect, it } from "@effect/vitest"
-import { Effect } from "effect"
-
-import { defaultTemplateConfig } from "@effect-template/lib/core/domain"
-import { renderEntrypoint } from "@effect-template/lib/core/templates-entrypoint"
-
-describe("renderEntrypoint auth bridge", () => {
-  it.effect("maps GH token fallback to git auth and sets git credential helper", () =>
-    Effect.sync(() => {
-      const entrypoint = renderEntrypoint({
-        ...defaultTemplateConfig,
-        repoUrl: "https://github.com/org/repo.git",
-        enableMcpPlaywright: false
-      })
-
-      expect(entrypoint).toContain(
-        "GIT_AUTH_TOKEN=\"${GIT_AUTH_TOKEN:-${GITHUB_TOKEN:-${GH_TOKEN:-}}}\""
-      )
-      expect(entrypoint).toContain("GITHUB_TOKEN=\"${GITHUB_TOKEN:-${GH_TOKEN:-}}\"")
-      expect(entrypoint).toContain("AUTH_LABEL_RAW=\"${GIT_AUTH_LABEL:-${GITHUB_AUTH_LABEL:-}}\"")
-      expect(entrypoint).toContain("LABELED_GITHUB_TOKEN_KEY=\"GITHUB_TOKEN__$RESOLVED_AUTH_LABEL\"")
-      expect(entrypoint).toContain("LABELED_GIT_TOKEN_KEY=\"GIT_AUTH_TOKEN__$RESOLVED_AUTH_LABEL\"")
-      expect(entrypoint).toContain("if [[ -n \"$EFFECTIVE_GH_TOKEN\" ]]; then")
-      expect(entrypoint).toContain(String.raw`printf "export GITHUB_TOKEN=%q\n" "$EFFECTIVE_GITHUB_TOKEN"`)
-      expect(entrypoint).toContain(String.raw`printf "export GH_TOKEN=%q\n" "$EFFECTIVE_GH_TOKEN"`)
-      expect(entrypoint).toContain(String.raw`printf "export GIT_AUTH_TOKEN=%q\n" "$EFFECTIVE_GITHUB_TOKEN"`)
-      expect(entrypoint).toContain("docker_git_upsert_ssh_env \"GITHUB_TOKEN\" \"$EFFECTIVE_GITHUB_TOKEN\"")
-      expect(entrypoint).toContain("docker_git_upsert_ssh_env \"GH_TOKEN\" \"$EFFECTIVE_GH_TOKEN\"")
-      expect(entrypoint).toContain("docker_git_upsert_ssh_env \"GIT_AUTH_TOKEN\" \"$EFFECTIVE_GITHUB_TOKEN\"")
-      expect(entrypoint).toContain("GIT_CREDENTIAL_HELPER_PATH=\"/usr/local/bin/docker-git-credential-helper\"")
-      expect(entrypoint).toContain("CLAUDE_REAL_BIN=\"/usr/local/bin/.docker-git-claude-real\"")
-      expect(entrypoint).toContain("CLAUDE_WRAPPER_BIN=\"/usr/local/bin/claude\"")
-      expect(entrypoint).toContain("cat <<'EOF' > \"$CLAUDE_WRAPPER_BIN\"")
-      expect(entrypoint).toContain("CLAUDE_CONFIG_DIR=\"${CLAUDE_CONFIG_DIR:-$HOME/.claude}\"")
-      expect(entrypoint).toContain("token=\"${GITHUB_TOKEN:-}\"")
-      expect(entrypoint).toContain("token=\"${GH_TOKEN:-}\"")
-      expect(entrypoint).toContain(String.raw`printf "%s\n" "password=$token"`)
-      expect(entrypoint).toContain("git config --global credential.helper")
-    }))
-})

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

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

@@ -1,55 +0,0 @@
-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"
-import { makeProjectItem } from "./fixtures/project-item.js"
-
-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}`)
-})
-
-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 = 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 = workspaceProject()
-    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)")
-  })
-})

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

@@ -1,84 +0,0 @@
-import { describe, expect, it } from "vitest"
-
-import { buildSelectLabels, buildSelectListWindow } 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")
-  })
-
-  it("keeps full list visible when projects fit into viewport", () => {
-    const window = buildSelectListWindow(8, 3, 12)
-    expect(window).toEqual({ start: 0, end: 8 })
-  })
-
-  it("computes a scrolling window around selected project", () => {
-    expect(buildSelectListWindow(30, 0, 10)).toEqual({ start: 0, end: 10 })
-    expect(buildSelectListWindow(30, 15, 10)).toEqual({ start: 10, end: 20 })
-    expect(buildSelectListWindow(30, 29, 10)).toEqual({ start: 20, end: 30 })
-  })
-})

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

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

package/tests/docker-git/parser-network-options.test.ts

@@ -1,47 +0,0 @@
-import { describe, expect, it } from "@effect/vitest"
-import { Effect, Either } from "effect"
-
-import { parseArgs } from "../../src/docker-git/cli/parser.js"
-
-describe("parseArgs network options", () => {
-  it.effect("parses create network mode options", () =>
-    Effect.sync(() => {
-      const parsed = parseArgs([
-        "create",
-        "--repo-url",
-        "https://github.com/org/repo.git",
-        "--network-mode",
-        "project",
-        "--shared-network",
-        "ignored-shared-network"
-      ])
-      if (Either.isLeft(parsed)) {
-        throw new Error(`unexpected parse error: ${parsed.left._tag}`)
-      }
-      const command = parsed.right
-      if (command._tag !== "Create") {
-        throw new Error("expected Create command")
-      }
-      expect(command.config.dockerNetworkMode).toBe("project")
-      expect(command.config.dockerSharedNetworkName).toBe("ignored-shared-network")
-    }))
-
-  it.effect("fails on invalid network mode", () =>
-    Effect.sync(() => {
-      const command = parseArgs([
-        "create",
-        "--repo-url",
-        "https://github.com/org/repo.git",
-        "--network-mode",
-        "invalid"
-      ])
-      Either.match(command, {
-        onLeft: (error) => {
-          expect(error._tag).toBe("InvalidOption")
-        },
-        onRight: () => {
-          throw new Error("expected parse error")
-        }
-      })
-    }))
-})