@prover-coder-ai/docker-git 1.0.5

package/src/docker-git/tmux.ts

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

@@ -0,0 +1,60 @@
+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
+      })
+  )
+
+const usageCases = [
+  { argv: ["node", "main"], needle: "pnpm docker-git" as const },
+  { argv: ["node", "main", "Alice"], needle: "Usage:" as const }
+] as const
+
+const runUsageCase = ({
+  argv,
+  needle
+}: (typeof usageCases)[number]) =>
+  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

@@ -0,0 +1,29 @@
+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("if [[ -n \"$GH_TOKEN\" || -n \"$GITHUB_TOKEN\" ]]; then")
+      expect(entrypoint).toContain(String.raw`printf "export GITHUB_TOKEN=%q\n" "$EFFECTIVE_GITHUB_TOKEN"`)
+      expect(entrypoint).toContain(String.raw`printf "%s\n" "GITHUB_TOKEN=$EFFECTIVE_GITHUB_TOKEN" >> "$SSH_ENV_PATH"`)
+      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(String.raw`printf "%s\n" "password=$token"`)
+      expect(entrypoint).toContain("git config --global credential.helper")
+    }))
+})

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

@@ -0,0 +1,172 @@
+import { describe, expect, it } from "@effect/vitest"
+import { Effect, Either } from "effect"
+
+import { type Command, defaultTemplateConfig } from "@effect-template/lib/core/domain"
+import { parseArgs } from "../../src/docker-git/cli/parser.js"
+
+type CreateCommand = Extract<Command, { _tag: "Create" }>
+
+const parseOrThrow = (args: ReadonlyArray<string>): Command => {
+  const parsed = parseArgs(args)
+  return Either.match(parsed, {
+    onLeft: (error) => {
+      throw new Error(`unexpected error ${error._tag}`)
+    },
+    onRight: (command) => command
+  })
+}
+
+const expectCreateCommand = (
+  args: ReadonlyArray<string>,
+  onRight: (command: CreateCommand) => void
+) =>
+  Effect.sync(() => {
+    const command = parseOrThrow(args)
+    if (command._tag !== "Create") {
+      throw new Error("expected Create command")
+    }
+    onRight(command)
+  })
+
+const expectCreateDefaults = (command: CreateCommand) => {
+  expect(command.config.repoUrl).toBe("https://github.com/org/repo.git")
+  expect(command.config.repoRef).toBe(defaultTemplateConfig.repoRef)
+  expect(command.outDir).toBe(".docker-git/org/repo")
+  expect(command.runUp).toBe(true)
+  expect(command.forceEnv).toBe(false)
+}
+
+describe("parseArgs", () => {
+  it.effect("parses create command with defaults", () =>
+    expectCreateCommand(["create", "--repo-url", "https://github.com/org/repo.git"], (command) => {
+      expectCreateDefaults(command)
+      expect(command.config.containerName).toBe("dg-repo")
+      expect(command.config.serviceName).toBe("dg-repo")
+      expect(command.config.volumeName).toBe("dg-repo-home")
+      expect(command.config.sshPort).toBe(defaultTemplateConfig.sshPort)
+    }))
+
+  it.effect("parses create command with issue url into isolated defaults", () =>
+    expectCreateCommand(["create", "--repo-url", "https://github.com/org/repo/issues/9"], (command) => {
+      expect(command.config.repoUrl).toBe("https://github.com/org/repo.git")
+      expect(command.config.repoRef).toBe("issue-9")
+      expect(command.outDir).toBe(".docker-git/org/repo/issue-9")
+      expect(command.config.containerName).toBe("dg-repo-issue-9")
+      expect(command.config.serviceName).toBe("dg-repo-issue-9")
+      expect(command.config.volumeName).toBe("dg-repo-issue-9-home")
+    }))
+
+  it.effect("fails on missing repo url", () =>
+    Effect.sync(() => {
+      Either.match(parseArgs(["create"]), {
+        onLeft: (error) => {
+          expect(error._tag).toBe("MissingRequiredOption")
+        },
+        onRight: () => {
+          throw new Error("expected parse error")
+        }
+      })
+    }))
+
+  it.effect("parses clone command with positional repo url", () =>
+    expectCreateCommand(["clone", "https://github.com/org/repo.git"], (command) => {
+      expectCreateDefaults(command)
+      expect(command.config.targetDir).toBe("/home/dev/org/repo")
+    }))
+
+  it.effect("parses clone branch alias", () =>
+    expectCreateCommand(["clone", "https://github.com/org/repo.git", "--branch", "feature-x"], (command) => {
+      expect(command.config.repoRef).toBe("feature-x")
+    }))
+
+  it.effect("parses force-env flag for clone", () =>
+    expectCreateCommand(["clone", "https://github.com/org/repo.git", "--force-env"], (command) => {
+      expect(command.force).toBe(false)
+      expect(command.forceEnv).toBe(true)
+    }))
+
+  it.effect("supports force + force-env together", () =>
+    expectCreateCommand(["clone", "https://github.com/org/repo.git", "--force", "--force-env"], (command) => {
+      expect(command.force).toBe(true)
+      expect(command.forceEnv).toBe(true)
+    }))
+
+  it.effect("parses GitHub tree url as repo + ref", () =>
+    expectCreateCommand(["clone", "https://github.com/agiens/crm/tree/vova-fork"], (command) => {
+      expect(command.config.repoUrl).toBe("https://github.com/agiens/crm.git")
+      expect(command.config.repoRef).toBe("vova-fork")
+      expect(command.outDir).toBe(".docker-git/agiens/crm")
+      expect(command.config.targetDir).toBe("/home/dev/agiens/crm")
+    }))
+
+  it.effect("parses GitHub issue url as isolated project + issue branch", () =>
+    expectCreateCommand(["clone", "https://github.com/org/repo/issues/5"], (command) => {
+      expect(command.config.repoUrl).toBe("https://github.com/org/repo.git")
+      expect(command.config.repoRef).toBe("issue-5")
+      expect(command.outDir).toBe(".docker-git/org/repo/issue-5")
+      expect(command.config.targetDir).toBe("/home/dev/org/repo/issue-5")
+      expect(command.config.containerName).toBe("dg-repo-issue-5")
+      expect(command.config.serviceName).toBe("dg-repo-issue-5")
+      expect(command.config.volumeName).toBe("dg-repo-issue-5-home")
+    }))
+
+  it.effect("parses GitHub PR url as isolated project", () =>
+    expectCreateCommand(["clone", "https://github.com/org/repo/pull/42"], (command) => {
+      expect(command.config.repoUrl).toBe("https://github.com/org/repo.git")
+      expect(command.config.repoRef).toBe("refs/pull/42/head")
+      expect(command.outDir).toBe(".docker-git/org/repo/pr-42")
+      expect(command.config.targetDir).toBe("/home/dev/org/repo/pr-42")
+      expect(command.config.containerName).toBe("dg-repo-pr-42")
+      expect(command.config.serviceName).toBe("dg-repo-pr-42")
+      expect(command.config.volumeName).toBe("dg-repo-pr-42-home")
+    }))
+
+  it.effect("parses attach with GitHub issue url into issue workspace", () =>
+    Effect.sync(() => {
+      const command = parseOrThrow(["attach", "https://github.com/org/repo/issues/7"])
+      if (command._tag !== "Attach") {
+        throw new Error("expected Attach command")
+      }
+      expect(command.projectDir).toBe(".docker-git/org/repo/issue-7")
+    }))
+
+  it.effect("parses down-all command", () =>
+    Effect.sync(() => {
+      const command = parseOrThrow(["down-all"])
+      expect(command._tag).toBe("DownAll")
+    }))
+
+  it.effect("parses state path command", () =>
+    Effect.sync(() => {
+      const command = parseOrThrow(["state", "path"])
+      expect(command._tag).toBe("StatePath")
+    }))
+
+  it.effect("parses state init command", () =>
+    Effect.sync(() => {
+      const command = parseOrThrow(["state", "init", "--repo-url", "https://github.com/org/state.git"])
+      if (command._tag !== "StateInit") {
+        throw new Error("expected StateInit command")
+      }
+      expect(command.repoUrl).toBe("https://github.com/org/state.git")
+      expect(command.repoRef).toBe("main")
+    }))
+
+  it.effect("parses state commit command", () =>
+    Effect.sync(() => {
+      const command = parseOrThrow(["state", "commit", "-m", "sync state"])
+      if (command._tag !== "StateCommit") {
+        throw new Error("expected StateCommit command")
+      }
+      expect(command.message).toBe("sync state")
+    }))
+
+  it.effect("parses state sync command", () =>
+    Effect.sync(() => {
+      const command = parseOrThrow(["state", "sync", "-m", "sync state"])
+      if (command._tag !== "StateSync") {
+        throw new Error("expected StateSync command")
+      }
+      expect(command.message).toBe("sync state")
+    }))
+})

package/tsconfig.build.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "types": []
+  },
+  "include": ["src/**/*"],
+  "exclude": ["dist", "node_modules", "tests/**/*", "vite.config.ts", "vitest.config.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+	"extends": "../../tsconfig.base.json",
+	"compilerOptions": {
+		"rootDir": ".",
+		"outDir": "dist",
+		"types": ["vitest"],
+		"jsx": "react-jsx",
+		"baseUrl": ".",
+		"paths": {
+			"@/*": ["src/*"]
+		}
+	},
+	"include": [
+		"src/**/*",
+		"tests/**/*",
+		"vite.config.ts",
+		"vitest.config.ts"
+	],
+	"exclude": ["dist", "node_modules"]
+}

package/vite.config.ts

@@ -0,0 +1,32 @@
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+import { defineConfig } from "vite"
+import tsconfigPaths from "vite-tsconfig-paths"
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+export default defineConfig({
+  plugins: [tsconfigPaths()],
+  publicDir: false,
+  resolve: {
+    alias: {
+      "@": path.resolve(__dirname, "src")
+    }
+  },
+  build: {
+    target: "node20",
+    outDir: "dist",
+    sourcemap: true,
+    ssr: "src/app/main.ts",
+    rollupOptions: {
+      output: {
+        format: "es",
+        entryFileNames: "main.js"
+      }
+    }
+  },
+  ssr: {
+    target: "node"
+  }
+})