feat(cli): apply docker-git config to existing project

Author: skulidropek

packages/app/src/docker-git/cli/parser-apply.ts

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

packages/app/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))
     )

packages/app/src/docker-git/cli/usage.ts

@@ -5,6 +5,7 @@ import type { ParseError } from "@effect-template/lib/core/domain"
 export const usageText = `docker-git menu
 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]
@@ -21,6 +22,7 @@ Commands:
   menu                Interactive menu (default when no args)
   create, init        Generate docker development environment
   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

packages/app/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)),

packages/app/tests/docker-git/parser.test.ts

@@ -196,6 +196,34 @@ describe("parseArgs", () => {
       expect(command.projectDir).toBe(".docker-git/org/repo")
     }))
 
+  it.effect("parses apply command in current directory", () =>
+    Effect.sync(() => {
+      const command = parseOrThrow(["apply"])
+      if (command._tag !== "Apply") {
+        throw new Error("expected Apply command")
+      }
+      expect(command.projectDir).toBe(".")
+      expect(command.runUp).toBe(true)
+    }))
+
+  it.effect("parses apply command with --no-up", () =>
+    Effect.sync(() => {
+      const command = parseOrThrow(["apply", "--no-up"])
+      if (command._tag !== "Apply") {
+        throw new Error("expected Apply command")
+      }
+      expect(command.runUp).toBe(false)
+    }))
+
+  it.effect("parses apply with positional repo url into project dir", () =>
+    Effect.sync(() => {
+      const command = parseOrThrow(["apply", "https://github.com/org/repo.git"])
+      if (command._tag !== "Apply") {
+        throw new Error("expected Apply command")
+      }
+      expect(command.projectDir).toBe(".docker-git/org/repo")
+    }))
+
   it.effect("parses down-all command", () =>
     Effect.sync(() => {
       const command = parseOrThrow(["down-all"])

packages/lib/src/core/domain.ts

@@ -106,6 +106,12 @@ export interface McpPlaywrightUpCommand {
   readonly runUp: boolean
 }
 
+export interface ApplyCommand {
+  readonly _tag: "Apply"
+  readonly projectDir: string
+  readonly runUp: boolean
+}
+
 export interface HelpCommand {
   readonly _tag: "Help"
   readonly message: string
@@ -243,6 +249,7 @@ export type Command =
   | SessionsCommand
   | ScrapCommand
   | McpPlaywrightUpCommand
+  | ApplyCommand
   | HelpCommand
   | StatusCommand
   | DownAllCommand

packages/lib/src/usecases/apply.ts

@@ -0,0 +1,75 @@
+import type { CommandExecutor } from "@effect/platform/CommandExecutor"
+import type { PlatformError } from "@effect/platform/Error"
+import type { FileSystem } from "@effect/platform/FileSystem"
+import type { Path } from "@effect/platform/Path"
+import { Effect } from "effect"
+
+import type { ApplyCommand, TemplateConfig } from "../core/domain.js"
+import { readProjectConfig } from "../shell/config.js"
+import { ensureDockerDaemonAccess } from "../shell/docker.js"
+import type * as ShellErrors from "../shell/errors.js"
+import { writeProjectFiles } from "../shell/files.js"
+import { ensureCodexConfigFile } from "./auth-sync.js"
+import { runDockerComposeUpWithPortCheck } from "./projects-up.js"
+
+type ApplyProjectFilesError =
+  | ShellErrors.ConfigNotFoundError
+  | ShellErrors.ConfigDecodeError
+  | ShellErrors.FileExistsError
+  | PlatformError
+type ApplyProjectFilesEnv = FileSystem | Path
+
+// CHANGE: apply existing docker-git.json to managed files in an already created project
+// WHY: allow updating current project/container config without creating a new project directory
+// QUOTE(ТЗ): "Не создавать новый... а прямо в текущем обновить её на актуальную"
+// REF: issue-72-followup-apply-current-config
+// SOURCE: n/a
+// FORMAT THEOREM: forall p: apply_files(p) -> files(p) = plan(read_config(p))
+// PURITY: SHELL
+// EFFECT: Effect<TemplateConfig, ConfigNotFoundError | ConfigDecodeError | FileExistsError | PlatformError, FileSystem | Path>
+// INVARIANT: rewrites only managed files from docker-git.json
+// COMPLEXITY: O(n) where n = |managed_files|
+export const applyProjectFiles = (
+  projectDir: string
+): Effect.Effect<TemplateConfig, ApplyProjectFilesError, ApplyProjectFilesEnv> =>
+  Effect.gen(function*(_) {
+    yield* _(Effect.log(`Applying docker-git config files in ${projectDir}...`))
+    const config = yield* _(readProjectConfig(projectDir))
+    yield* _(writeProjectFiles(projectDir, config.template, true))
+    yield* _(ensureCodexConfigFile(projectDir, config.template.codexAuthPath))
+    return config.template
+  })
+
+export type ApplyProjectConfigError =
+  | ApplyProjectFilesError
+  | ShellErrors.DockerAccessError
+  | ShellErrors.DockerCommandError
+  | ShellErrors.PortProbeError
+
+type ApplyProjectConfigEnv = ApplyProjectFilesEnv | CommandExecutor
+
+const applyProjectWithUp = (
+  projectDir: string
+): Effect.Effect<TemplateConfig, ApplyProjectConfigError, ApplyProjectConfigEnv> =>
+  Effect.gen(function*(_) {
+    yield* _(Effect.log(`Applying docker-git config and refreshing container in ${projectDir}...`))
+    yield* _(ensureDockerDaemonAccess(process.cwd()))
+    return yield* _(runDockerComposeUpWithPortCheck(projectDir))
+  })
+
+// CHANGE: add command handler to apply docker-git config on an existing project
+// WHY: update current project/container config without running create/clone again
+// QUOTE(ТЗ): "Не создавать новый... а прямо в текущем обновить её на актуальную"
+// REF: issue-72-followup-apply-current-config
+// SOURCE: n/a
+// FORMAT THEOREM: forall c: apply(c) -> updated(project(c)) && (c.runUp -> container_refreshed(c))
+// PURITY: SHELL
+// EFFECT: Effect<TemplateConfig, ApplyProjectConfigError, FileSystem | Path | CommandExecutor>
+// INVARIANT: project path remains unchanged; command only updates managed artifacts
+// COMPLEXITY: O(n) + O(command)
+export const applyProjectConfig = (
+  command: ApplyCommand
+): Effect.Effect<TemplateConfig, ApplyProjectConfigError, ApplyProjectConfigEnv> =>
+  command.runUp
+    ? applyProjectWithUp(command.projectDir)
+    : applyProjectFiles(command.projectDir)

packages/lib/tests/usecases/apply.test.ts

@@ -0,0 +1,106 @@
+import * as FileSystem from "@effect/platform/FileSystem"
+import * as Path from "@effect/platform/Path"
+import { NodeContext } from "@effect/platform-node"
+import { describe, expect, it } from "@effect/vitest"
+import { Effect } from "effect"
+
+import type { TemplateConfig } from "../../src/core/domain.js"
+import { applyProjectFiles } from "../../src/usecases/apply.js"
+import { prepareProjectFiles } from "../../src/usecases/actions/prepare-files.js"
+
+const withTempDir = <A, E, R>(
+  use: (tempDir: string) => Effect.Effect<A, E, R>
+): Effect.Effect<A, E, R | FileSystem.FileSystem> =>
+  Effect.scoped(
+    Effect.gen(function*(_) {
+      const fs = yield* _(FileSystem.FileSystem)
+      const tempDir = yield* _(
+        fs.makeTempDirectoryScoped({
+          prefix: "docker-git-apply-config-"
+        })
+      )
+      return yield* _(use(tempDir))
+    })
+  )
+
+const makeTemplateConfig = (
+  root: string,
+  outDir: string,
+  path: Path.Path,
+  targetDir: string
+): TemplateConfig => ({
+  containerName: "dg-test",
+  serviceName: "dg-test",
+  sshUser: "dev",
+  sshPort: 2222,
+  repoUrl: "https://github.com/org/repo.git",
+  repoRef: "main",
+  targetDir,
+  volumeName: "dg-test-home",
+  dockerGitPath: path.join(root, ".docker-git"),
+  authorizedKeysPath: path.join(root, "authorized_keys"),
+  envGlobalPath: path.join(root, ".orch/env/global.env"),
+  envProjectPath: path.join(outDir, ".orch/env/project.env"),
+  codexAuthPath: path.join(root, ".orch/auth/codex"),
+  codexSharedAuthPath: path.join(root, ".orch/auth/codex-shared"),
+  codexHome: "/home/dev/.codex",
+  enableMcpPlaywright: false,
+  pnpmVersion: "10.27.0"
+})
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null
+
+const rewriteTargetDirInConfig = (source: string, targetDir: string): string => {
+  const parsed: unknown = JSON.parse(source)
+  if (!isRecord(parsed)) {
+    throw new Error("invalid docker-git.json root")
+  }
+  const template = parsed["template"]
+  if (!isRecord(template)) {
+    throw new Error("invalid docker-git.json template")
+  }
+  const next = { ...parsed, template: { ...template, targetDir } }
+  return `${JSON.stringify(next, null, 2)}\n`
+}
+
+describe("applyProjectFiles", () => {
+  it.effect("applies updated docker-git.json to managed files in existing project", () =>
+    withTempDir((root) =>
+      Effect.gen(function*(_) {
+        const fs = yield* _(FileSystem.FileSystem)
+        const path = yield* _(Path.Path)
+        const outDir = path.join(root, "project")
+        const initialTargetDir = "/home/dev/workspaces/org/repo"
+        const updatedTargetDir = "/home/dev/workspaces/org/repo-updated"
+        const globalConfig = makeTemplateConfig(root, outDir, path, initialTargetDir)
+        const projectConfig = makeTemplateConfig(root, outDir, path, initialTargetDir)
+
+        yield* _(
+          prepareProjectFiles(outDir, root, globalConfig, projectConfig, {
+            force: false,
+            forceEnv: false
+          })
+        )
+
+        const envProjectPath = path.join(outDir, ".orch/env/project.env")
+        yield* _(fs.writeFileString(envProjectPath, "# custom env\nCUSTOM_KEY=1\n"))
+
+        const configPath = path.join(outDir, "docker-git.json")
+        const configBefore = yield* _(fs.readFileString(configPath))
+        yield* _(fs.writeFileString(configPath, rewriteTargetDirInConfig(configBefore, updatedTargetDir)))
+
+        const appliedTemplate = yield* _(applyProjectFiles(outDir))
+        expect(appliedTemplate.targetDir).toBe(updatedTargetDir)
+
+        const composeAfter = yield* _(fs.readFileString(path.join(outDir, "docker-compose.yml")))
+        expect(composeAfter).toContain(`TARGET_DIR: "${updatedTargetDir}"`)
+
+        const dockerfileAfter = yield* _(fs.readFileString(path.join(outDir, "Dockerfile")))
+        expect(dockerfileAfter).toContain(`RUN mkdir -p ${updatedTargetDir}`)
+
+        const envAfter = yield* _(fs.readFileString(envProjectPath))
+        expect(envAfter).toContain("CUSTOM_KEY=1")
+      })
+    ).pipe(Effect.provide(NodeContext.layer)))
+})