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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prover-coder-ai/docker-git",
-  "version": "1.0.20",
+  "version": "1.0.22",
   "description": "Minimal Vite-powered TypeScript console starter using Effect",
   "main": "dist/src/docker-git/main.js",
   "bin": {
@@ -35,8 +35,7 @@
     "@effect/schema": "^0.75.5",
     "effect": "^3.19.14",
     "ink": "^5.0.1",
-    "react": "^18.3.1",
-    "@effect-template/lib": "1.0.0"
+    "react": "^18.3.1"
   },
   "scripts": {
     "prebuild": "pnpm -C ../lib build",
@@ -48,7 +47,7 @@
     "lint:tests": "PATH=../../scripts:$PATH vibecode-linter tests/",
     "lint:effect": "PATH=../../scripts:$PATH eslint --config eslint.effect-ts-check.config.mjs .",
     "prebuild:docker-git": "pnpm -C ../lib build",
-    "build:docker-git": "tsc -p tsconfig.build.json",
+    "build:docker-git": "vite build --config vite.docker-git.config.ts",
     "check": "pnpm run typecheck",
     "clone": "pnpm -C ../.. run clone",
     "docker-git": "node dist/src/docker-git/main.js",

package/src/docker-git/cli/parser-apply.ts

@@ -0,0 +1,28 @@
+import { Either } from "effect"
+
+import { type ApplyCommand, type ParseError } from "@effect-template/lib/core/domain"
+
+import { parseProjectDirWithOptions } from "./parser-shared.js"
+
+// CHANGE: parse "apply" command for existing docker-git projects
+// WHY: update managed docker-git config on the current project/container without creating a new project
+// QUOTE(ТЗ): "Не создавать новый... а прямо в текущем обновить её на актуальную"
+// REF: issue-72-followup-apply-current-config
+// SOURCE: n/a
+// FORMAT THEOREM: forall argv: parseApply(argv) = cmd -> deterministic(cmd)
+// PURITY: CORE
+// EFFECT: Effect<ApplyCommand, ParseError, never>
+// INVARIANT: projectDir is never empty
+// COMPLEXITY: O(n) where n = |argv|
+export const parseApply = (
+  args: ReadonlyArray<string>
+): Either.Either<ApplyCommand, ParseError> =>
+  Either.map(parseProjectDirWithOptions(args), ({ projectDir, raw }) => ({
+    _tag: "Apply",
+    projectDir,
+    runUp: raw.up ?? true,
+    gitTokenLabel: raw.gitTokenLabel,
+    codexTokenLabel: raw.codexTokenLabel,
+    claudeTokenLabel: raw.claudeTokenLabel,
+    enableMcpPlaywright: raw.enableMcpPlaywright
+  }))

package/src/docker-git/cli/parser-clone.ts

@@ -2,12 +2,7 @@ import { Either } from "effect"
 
 import { buildCreateCommand, nonEmpty } from "@effect-template/lib/core/command-builders"
 import type { RawOptions } from "@effect-template/lib/core/command-options"
-import {
-  type Command,
-  defaultTemplateConfig,
-  type ParseError,
-  resolveRepoInput
-} from "@effect-template/lib/core/domain"
+import { type Command, type ParseError, resolveRepoInput } from "@effect-template/lib/core/domain"
 
 import { parseRawOptions } from "./parser-options.js"
 import { resolveWorkspaceRepoPath, splitPositionalRepo } from "./parser-shared.js"
@@ -18,13 +13,12 @@ const applyCloneDefaults = (
   resolvedRepo: ReturnType<typeof resolveRepoInput>
 ): RawOptions => {
   const repoPath = resolveWorkspaceRepoPath(resolvedRepo)
-  const sshUser = raw.sshUser?.trim() ?? defaultTemplateConfig.sshUser
-  const homeDir = `/home/${sshUser}`
+  const targetHome = "~"
   return {
     ...raw,
     repoUrl: rawRepoUrl,
     outDir: raw.outDir ?? `.docker-git/${repoPath}`,
-    targetDir: raw.targetDir ?? `${homeDir}/${repoPath}`
+    targetDir: raw.targetDir ?? `${targetHome}/workspaces/${repoPath}`
   }
 }
 

package/src/docker-git/cli/parser-options.ts

@@ -20,9 +20,14 @@ interface ValueOptionSpec {
     | "envProjectPath"
     | "codexAuthPath"
     | "codexHome"
+    | "dockerNetworkMode"
+    | "dockerSharedNetworkName"
     | "archivePath"
     | "scrapMode"
     | "label"
+    | "gitTokenLabel"
+    | "codexTokenLabel"
+    | "claudeTokenLabel"
     | "token"
     | "scopes"
     | "message"
@@ -48,9 +53,14 @@ const valueOptionSpecs: ReadonlyArray<ValueOptionSpec> = [
   { flag: "--env-project", key: "envProjectPath" },
   { flag: "--codex-auth", key: "codexAuthPath" },
   { flag: "--codex-home", key: "codexHome" },
+  { flag: "--network-mode", key: "dockerNetworkMode" },
+  { flag: "--shared-network", key: "dockerSharedNetworkName" },
   { flag: "--archive", key: "archivePath" },
   { flag: "--mode", key: "scrapMode" },
   { flag: "--label", key: "label" },
+  { flag: "--git-token", key: "gitTokenLabel" },
+  { flag: "--codex-token", key: "codexTokenLabel" },
+  { flag: "--claude-token", key: "claudeTokenLabel" },
   { flag: "--token", key: "token" },
   { flag: "--scopes", key: "scopes" },
   { flag: "--message", key: "message" },
@@ -96,9 +106,14 @@ const valueFlagUpdaters: { readonly [K in ValueKey]: (raw: RawOptions, value: st
   envProjectPath: (raw, value) => ({ ...raw, envProjectPath: value }),
   codexAuthPath: (raw, value) => ({ ...raw, codexAuthPath: value }),
   codexHome: (raw, value) => ({ ...raw, codexHome: value }),
+  dockerNetworkMode: (raw, value) => ({ ...raw, dockerNetworkMode: value }),
+  dockerSharedNetworkName: (raw, value) => ({ ...raw, dockerSharedNetworkName: value }),
   archivePath: (raw, value) => ({ ...raw, archivePath: value }),
   scrapMode: (raw, value) => ({ ...raw, scrapMode: value }),
   label: (raw, value) => ({ ...raw, label: value }),
+  gitTokenLabel: (raw, value) => ({ ...raw, gitTokenLabel: value }),
+  codexTokenLabel: (raw, value) => ({ ...raw, codexTokenLabel: value }),
+  claudeTokenLabel: (raw, value) => ({ ...raw, claudeTokenLabel: value }),
   token: (raw, value) => ({ ...raw, token: value }),
   scopes: (raw, value) => ({ ...raw, scopes: value }),
   message: (raw, value) => ({ ...raw, message: value }),
@@ -126,34 +141,68 @@ export const applyCommandValueFlag = (
   return Either.right(update(raw, value))
 }
 
+type ParseRawOptionsStep =
+  | { readonly _tag: "ok"; readonly raw: RawOptions; readonly nextIndex: number }
+  | { readonly _tag: "error"; readonly error: ParseError }
+
+const parseInlineValueToken = (
+  raw: RawOptions,
+  token: string
+): Either.Either<RawOptions, ParseError> | null => {
+  const equalIndex = token.indexOf("=")
+  if (equalIndex <= 0 || !token.startsWith("-")) {
+    return null
+  }
+
+  const flag = token.slice(0, equalIndex)
+  const inlineValue = token.slice(equalIndex + 1)
+  return applyCommandValueFlag(raw, flag, inlineValue)
+}
+
+const parseRawOptionsStep = (
+  args: ReadonlyArray<string>,
+  index: number,
+  raw: RawOptions
+): ParseRawOptionsStep => {
+  const token = args[index] ?? ""
+  const inlineApplied = parseInlineValueToken(raw, token)
+  if (inlineApplied !== null) {
+    return Either.isLeft(inlineApplied)
+      ? { _tag: "error", error: inlineApplied.left }
+      : { _tag: "ok", raw: inlineApplied.right, nextIndex: index + 1 }
+  }
+
+  const booleanApplied = applyCommandBooleanFlag(raw, token)
+  if (booleanApplied !== null) {
+    return { _tag: "ok", raw: booleanApplied, nextIndex: index + 1 }
+  }
+
+  if (!token.startsWith("-")) {
+    return { _tag: "error", error: { _tag: "UnexpectedArgument", value: token } }
+  }
+
+  const value = args[index + 1]
+  if (value === undefined) {
+    return { _tag: "error", error: { _tag: "MissingOptionValue", option: token } }
+  }
+
+  const nextRaw = applyCommandValueFlag(raw, token, value)
+  return Either.isLeft(nextRaw)
+    ? { _tag: "error", error: nextRaw.left }
+    : { _tag: "ok", raw: nextRaw.right, nextIndex: index + 2 }
+}
+
 export const parseRawOptions = (args: ReadonlyArray<string>): Either.Either<RawOptions, ParseError> => {
   let index = 0
   let raw: RawOptions = {}
 
   while (index < args.length) {
-    const token = args[index] ?? ""
-    const booleanApplied = applyCommandBooleanFlag(raw, token)
-    if (booleanApplied !== null) {
-      raw = booleanApplied
-      index += 1
-      continue
-    }
-
-    if (!token.startsWith("-")) {
-      return Either.left({ _tag: "UnexpectedArgument", value: token })
-    }
-
-    const value = args[index + 1]
-    if (value === undefined) {
-      return Either.left({ _tag: "MissingOptionValue", option: token })
-    }
-
-    const nextRaw = applyCommandValueFlag(raw, token, value)
-    if (Either.isLeft(nextRaw)) {
-      return Either.left(nextRaw.left)
+    const step = parseRawOptionsStep(args, index, raw)
+    if (step._tag === "error") {
+      return Either.left(step.error)
     }
-    raw = nextRaw.right
-    index += 2
+    raw = step.raw
+    index = step.nextIndex
   }
 
   return Either.right(raw)

package/src/docker-git/cli/parser.ts

@@ -2,6 +2,7 @@ import { Either, Match } from "effect"
 
 import { type Command, type ParseError } from "@effect-template/lib/core/domain"
 
+import { parseApply } from "./parser-apply.js"
 import { parseAttach } from "./parser-attach.js"
 import { parseAuth } from "./parser-auth.js"
 import { parseClone } from "./parser-clone.js"
@@ -74,6 +75,7 @@ export const parseArgs = (args: ReadonlyArray<string>): Either.Either<Command, P
       Match.when("auth", () => parseAuth(rest))
     )
     .pipe(
+      Match.when("apply", () => parseApply(rest)),
       Match.when("state", () => parseState(rest)),
       Match.orElse(() => Either.left(unknownCommandError))
     )

package/src/docker-git/cli/usage.ts

@@ -3,8 +3,9 @@ import { Match } from "effect"
 import type { ParseError } from "@effect-template/lib/core/domain"
 
 export const usageText = `docker-git menu
-docker-git create --repo-url <url> [options]
+docker-git create [--repo-url <url>] [options]
 docker-git clone <url> [options]
+docker-git apply [<url>] [options]
 docker-git mcp-playwright [<url>] [options]
 docker-git attach [<url>] [options]
 docker-git panes [<url>] [options]
@@ -19,8 +20,9 @@ docker-git state <action> [options]
 
 Commands:
   menu                Interactive menu (default when no args)
-  create, init        Generate docker development environment
+  create, init        Generate docker development environment (repo URL optional)
   clone               Create + run container and clone repo
+  apply               Apply docker-git config to an existing project/container (current dir by default)
   mcp-playwright      Enable Playwright MCP + Chromium sidecar for an existing project dir
   attach, tmux        Open tmux workspace for a docker-git project
   panes, terms        List tmux panes for a docker-git project
@@ -32,9 +34,10 @@ Commands:
   state               Manage docker-git state directory via git (sync across machines)
 
 Options:
+  --repo-url <url>          Repository URL (create: optional; clone: required via positional arg or flag)
   --repo-ref <ref>          Git ref/branch (default: main)
   --branch, -b <ref>        Alias for --repo-ref
-  --target-dir <path>       Target dir inside container (create default: /home/dev/app, clone default: /home/dev/<org>/<repo>[/issue-<id>|/pr-<id>])
+  --target-dir <path>       Target dir inside container (create default: /home/dev/app, clone default: ~/workspaces/<org>/<repo>[/issue-<id>|/pr-<id>])
   --ssh-port <port>         Local SSH port (default: 2222)
   --ssh-user <user>         SSH user inside container (default: dev)
   --container-name <name>   Docker container name (default: dg-<repo>)
@@ -45,10 +48,15 @@ Options:
   --env-project <path>      Host path to project env file (default: ./.orch/env/project.env)
   --codex-auth <path>       Host path for Codex auth cache (default: <projectsRoot>/.orch/auth/codex)
   --codex-home <path>       Container path for Codex auth (default: /home/dev/.codex)
+  --network-mode <mode>     Compose network mode: shared|project (default: shared)
+  --shared-network <name>   Shared Docker network name when network-mode=shared (default: docker-git-shared)
   --out-dir <path>          Output directory (default: <projectsRoot>/<org>/<repo>[/issue-<id>|/pr-<id>])
   --project-dir <path>      Project directory for attach (default: .)
   --archive <path>          Scrap snapshot directory (default: .orch/scrap/session)
   --mode <session>          Scrap mode (default: session)
+  --git-token <label>       Token label for clone/create (maps to GITHUB_TOKEN__<LABEL>, example: agiens)
+  --codex-token <label>     Codex auth label for clone/create (maps to CODEX_AUTH_LABEL, example: agien)
+  --claude-token <label>    Claude auth label for clone/create (maps to CLAUDE_AUTH_LABEL, example: agien)
   --wipe | --no-wipe        Wipe workspace before scrap import (default: --wipe)
   --lines <n>               Tail last N lines for sessions logs (default: 200)
   --include-default         Show default/system processes in sessions list

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

@@ -9,6 +9,7 @@ import {
   listProjectStatus,
   listRunningProjectItems
 } from "@effect-template/lib/usecases/projects"
+import { gcProjectNetworkByTemplate } from "@effect-template/lib/usecases/docker-network-gc"
 import { runDockerComposeUpWithPortCheck } from "@effect-template/lib/usecases/projects-up"
 import { Effect, Match, pipe } from "effect"
 
@@ -149,8 +150,10 @@ const handleMenuAction = (
       withProjectConfig(state, setMessage, () =>
         runDockerComposeLogs(state.activeDir ?? state.cwd))),
     Match.when({ _tag: "Down" }, () =>
-      withProjectConfig(state, setMessage, () =>
-        runDockerComposeDown(state.activeDir ?? state.cwd))),
+      withProjectConfig(state, setMessage, (config) =>
+        runDockerComposeDown(state.activeDir ?? state.cwd).pipe(
+          Effect.zipRight(gcProjectNetworkByTemplate(state.activeDir ?? state.cwd, config.template))
+        ))),
     Match.when({ _tag: "DownAll" }, () =>
       pipe(
         downAllDockerGitProjects,

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

@@ -46,11 +46,16 @@ type CreateReturnContext = CreateContext & {
 }
 
 export const buildCreateArgs = (input: CreateInputs): ReadonlyArray<string> => {
-  const args: Array<string> = ["create", "--repo-url", input.repoUrl]
+  const args: Array<string> = ["create"]
+  if (input.repoUrl.length > 0) {
+    args.push("--repo-url", input.repoUrl)
+  }
   if (input.repoRef.length > 0) {
     args.push("--repo-ref", input.repoRef)
   }
-  args.push("--out-dir", input.outDir)
+  if (input.outDir.length > 0) {
+    args.push("--out-dir", input.outDir)
+  }
   if (!input.runUp) {
     args.push("--no-up")
   }
@@ -106,8 +111,8 @@ export const resolveCreateInputs = (
   values: Partial<CreateInputs>
 ): CreateInputs => {
   const repoUrl = values.repoUrl ?? ""
-  const resolvedRepoRef = repoUrl.length > 0 ? resolveRepoInput(repoUrl).repoRef : undefined
-  const outDir = values.outDir ?? (repoUrl.length > 0 ? resolveDefaultOutDir(cwd, repoUrl) : "")
+  const resolvedRepoRef = resolveRepoInput(repoUrl).repoRef
+  const outDir = values.outDir ?? resolveDefaultOutDir(cwd, repoUrl)
 
   return {
     repoUrl,
@@ -179,10 +184,6 @@ const applyCreateStep = (input: {
 }): boolean =>
   Match.value(input.step).pipe(
     Match.when("repoUrl", () => {
-      if (input.buffer.length === 0) {
-        input.setMessage("Repo URL is required.")
-        return false
-      }
       input.nextValues.repoUrl = input.buffer
       input.nextValues.outDir = resolveDefaultOutDir(input.cwd, input.buffer)
       return true
@@ -222,11 +223,6 @@ const finalizeCreateFlow = (input: {
   readonly setActiveDir: (dir: string | null) => void
 }) => {
   const inputs = resolveCreateInputs(input.state.cwd, input.nextValues)
-  if (inputs.repoUrl.length === 0) {
-    input.setMessage("Repo URL is required.")
-    return
-  }
-
   const parsed = parseArgs(buildCreateArgs(inputs))
   if (Either.isLeft(parsed)) {
     input.setMessage(formatParseError(parsed.left))

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

@@ -28,7 +28,7 @@ import { createSteps, menuItems } from "./menu-types.js"
 
 export const renderStepLabel = (step: CreateStep, defaults: CreateInputs): string =>
   Match.value(step).pipe(
-    Match.when("repoUrl", () => "Repo URL"),
+    Match.when("repoUrl", () => "Repo URL (optional for empty workspace)"),
     Match.when("repoRef", () => `Repo ref [${defaults.repoRef}]`),
     Match.when("outDir", () => `Output dir [${defaults.outDir}]`),
     Match.when("runUp", () => `Run docker compose up now? [${defaults.runUp ? "Y" : "n"}]`),

package/src/docker-git/program.ts

@@ -1,5 +1,6 @@
 import type { Command, ParseError } from "@effect-template/lib/core/domain"
 import { createProject } from "@effect-template/lib/usecases/actions"
+import { applyProjectConfig } from "@effect-template/lib/usecases/apply"
 import {
   authClaudeLogin,
   authClaudeLogout,
@@ -97,6 +98,7 @@ const handleNonBaseCommand = (command: NonBaseCommand) =>
       Match.when({ _tag: "SessionsKill" }, (cmd) => killTerminalProcess(cmd))
     )
     .pipe(
+      Match.when({ _tag: "Apply" }, (cmd) => applyProjectConfig(cmd)),
       Match.when({ _tag: "SessionsLogs" }, (cmd) => tailTerminalLogs(cmd)),
       Match.when({ _tag: "ScrapExport" }, (cmd) => exportScrap(cmd)),
       Match.when({ _tag: "ScrapImport" }, (cmd) => importScrap(cmd)),

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

@@ -17,12 +17,23 @@ describe("renderEntrypoint auth bridge", () => {
         "GIT_AUTH_TOKEN=\"${GIT_AUTH_TOKEN:-${GITHUB_TOKEN:-${GH_TOKEN:-}}}\""
       )
       expect(entrypoint).toContain("GITHUB_TOKEN=\"${GITHUB_TOKEN:-${GH_TOKEN:-}}\"")
-      expect(entrypoint).toContain("if [[ -n \"$GH_TOKEN\" || -n \"$GITHUB_TOKEN\" ]]; then")
+      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("token=\"$GITHUB_TOKEN\"")
-      expect(entrypoint).toContain("token=\"$GH_TOKEN\"")
+      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/parser-network-options.test.ts

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