@prover-coder-ai/docker-git 1.0.5

package/dist/src/docker-git/menu.js

@@ -0,0 +1,237 @@
+import { InputReadError } from "@effect-template/lib/shell/errors";
+import { renderError } from "@effect-template/lib/usecases/errors";
+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 { renderCreate, renderMenu, renderSelect, renderStepLabel } from "./menu-render.js";
+import { handleSelectInput } from "./menu-select.js";
+import { leaveTui, resumeTui } from "./menu-shared.js";
+import { createSteps } from "./menu-types.js";
+// CHANGE: keep menu state in the TUI layer
+// WHY: provide a dynamic interface with live selection and inputs
+// QUOTE(ТЗ): "TUI? Красивый, удобный"
+// REF: user-request-2026-02-01-tui
+// SOURCE: n/a
+// FORMAT THEOREM: forall s: input(s) -> state'(s)
+// PURITY: SHELL
+// EFFECT: Effect<void, AppError, FileSystem | Path | CommandExecutor>
+// INVARIANT: activeDir updated only after successful create
+// COMPLEXITY: O(1) per keypress
+const useRunner = (setBusy, setMessage) => {
+    const runEffect = function (effect) {
+        setBusy(true);
+        const program = pipe(effect, Effect.matchEffect({
+            onFailure: (error) => Effect.sync(() => {
+                setMessage(renderError(error));
+            }),
+            onSuccess: () => Effect.void
+        }), Effect.ensuring(Effect.sync(() => {
+            setBusy(false);
+        })));
+        void Effect.runPromise(Effect.provide(program, NodeContext.layer));
+    };
+    return { runEffect };
+};
+const activateInput = (input, key, context) => {
+    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, key, context) => {
+    const activation = activateInput(input, key, context);
+    if (activation.activated && !activation.allowProcessing) {
+        return false;
+    }
+    return activation.allowProcessing;
+};
+const handleUserInput = (input, key, context) => {
+    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
+    });
+};
+const renderView = (context) => {
+    if (context.view._tag === "Menu") {
+        return renderMenu(context.state.cwd, context.activeDir, context.selected, context.busy, context.message);
+    }
+    if (context.view._tag === "Create") {
+        const currentDefaults = resolveCreateInputs(context.state.cwd, context.view.values);
+        const step = createSteps[context.view.step] ?? "repoUrl";
+        const label = renderStepLabel(step, currentDefaults);
+        return renderCreate(label, context.view.buffer, context.message, context.view.step, currentDefaults);
+    }
+    return renderSelect(context.view.purpose, context.view.items, context.view.selected, context.view.confirmDelete, context.message);
+};
+const useMenuState = () => {
+    const [activeDir, setActiveDir] = useState(null);
+    const [selected, setSelected] = useState(0);
+    const [busy, setBusy] = useState(false);
+    const [message, setMessage] = useState(null);
+    const [view, setView] = useState({ _tag: "Menu" });
+    const [inputStage, setInputStage] = useState("cold");
+    const [ready, setReady] = useState(false);
+    const [skipInputs, setSkipInputs] = useState(2);
+    const [sshActive, setSshActive] = useState(false);
+    const ignoreUntil = useMemo(() => Date.now() + 400, []);
+    const state = useMemo(() => ({ cwd: process.cwd(), activeDir }), [activeDir]);
+    const runner = useRunner(setBusy, setMessage);
+    return {
+        activeDir,
+        setActiveDir,
+        selected,
+        setSelected,
+        busy,
+        message,
+        setMessage,
+        view,
+        setView,
+        inputStage,
+        setInputStage,
+        ready,
+        setReady,
+        skipInputs,
+        setSkipInputs,
+        sshActive,
+        setSshActive,
+        ignoreUntil,
+        state,
+        runner
+    };
+};
+const useReadyGate = (setReady) => {
+    useEffect(() => {
+        const timer = setTimeout(() => {
+            setReady(true);
+        }, 150);
+        return () => {
+            clearTimeout(timer);
+        };
+    }, [setReady]);
+};
+const useSigintGuard = (exit, sshActive) => {
+    useEffect(() => {
+        const handleSigint = () => {
+            if (sshActive) {
+                return;
+            }
+            exit();
+        };
+        process.on("SIGINT", handleSigint);
+        return () => {
+            process.off("SIGINT", handleSigint);
+        };
+    }, [exit, sshActive]);
+};
+const TuiApp = () => {
+    const { exit } = useApp();
+    const menu = useMenuState();
+    useReadyGate(menu.setReady);
+    useSigintGuard(exit, menu.sshActive);
+    useInput((input, key) => {
+        if (!menu.ready) {
+            return;
+        }
+        if (Date.now() < menu.ignoreUntil) {
+            return;
+        }
+        if (menu.skipInputs > 0) {
+            menu.setSkipInputs((value) => (value > 0 ? value - 1 : 0));
+            return;
+        }
+        handleUserInput(input, key, {
+            busy: menu.busy,
+            view: menu.view,
+            inputStage: menu.inputStage,
+            setInputStage: menu.setInputStage,
+            selected: menu.selected,
+            setSelected: menu.setSelected,
+            setSkipInputs: menu.setSkipInputs,
+            sshActive: menu.sshActive,
+            setSshActive: menu.setSshActive,
+            state: menu.state,
+            runner: menu.runner,
+            exit,
+            setView: menu.setView,
+            setMessage: menu.setMessage,
+            setActiveDir: menu.setActiveDir
+        });
+    }, { isActive: !menu.sshActive });
+    return renderView({
+        state: menu.state,
+        view: menu.view,
+        activeDir: menu.activeDir,
+        selected: menu.selected,
+        busy: menu.busy,
+        message: menu.message
+    });
+};
+// CHANGE: provide an interactive TUI menu for docker-git
+// WHY: allow dynamic selection and inline create flow without raw prompts
+// QUOTE(ТЗ): "TUI? Красивый, удобный"
+// REF: user-request-2026-02-01-tui
+// SOURCE: n/a
+// FORMAT THEOREM: forall s: tui(s) -> state transitions
+// PURITY: SHELL
+// EFFECT: Effect<void, AppError, FileSystem | Path | CommandExecutor>
+// INVARIANT: app exits only on Quit or ctrl+c
+// COMPLEXITY: O(1) per input
+export const runMenu = pipe(Effect.sync(() => {
+    resumeTui();
+}), Effect.zipRight(Effect.tryPromise({
+    try: () => render(React.createElement(TuiApp)).waitUntilExit(),
+    catch: (error) => new InputReadError({ message: error instanceof Error ? error.message : String(error) })
+})), Effect.ensuring(Effect.sync(() => {
+    leaveTui();
+})), Effect.asVoid);

package/dist/src/docker-git/program.js

@@ -0,0 +1,38 @@
+import { createProject } from "@effect-template/lib/usecases/actions";
+import { authCodexLogin, authCodexLogout, authCodexStatus, authGithubLogin, authGithubLogout, authGithubStatus } from "@effect-template/lib/usecases/auth";
+import { renderError } from "@effect-template/lib/usecases/errors";
+import { downAllDockerGitProjects, listProjectStatus } from "@effect-template/lib/usecases/projects";
+import { stateCommit, stateInit, statePath, statePull, statePush, stateStatus, stateSync } from "@effect-template/lib/usecases/state-repo";
+import { killTerminalProcess, listTerminalSessions, tailTerminalLogs } from "@effect-template/lib/usecases/terminal-sessions";
+import { Effect, Match, pipe } from "effect";
+import { readCommand } from "./cli/read-command.js";
+import { attachTmux, listTmuxPanes } from "./tmux.js";
+import { runMenu } from "./menu.js";
+const isParseError = (error) => error._tag === "UnknownCommand" ||
+    error._tag === "UnknownOption" ||
+    error._tag === "MissingOptionValue" ||
+    error._tag === "MissingRequiredOption" ||
+    error._tag === "InvalidOption" ||
+    error._tag === "UnexpectedArgument";
+const setExitCode = (code) => Effect.sync(() => {
+    process.exitCode = code;
+});
+const logWarningAndExit = (error) => pipe(Effect.logWarning(renderError(error)), Effect.tap(() => setExitCode(1)), Effect.asVoid);
+const logErrorAndExit = (error) => pipe(Effect.logError(renderError(error)), Effect.tap(() => setExitCode(1)), Effect.asVoid);
+const handleNonBaseCommand = (command) => Match.value(command).pipe(Match.when({ _tag: "StatePath" }, () => statePath), Match.when({ _tag: "StateInit" }, (cmd) => stateInit(cmd)), Match.when({ _tag: "StateStatus" }, () => stateStatus), Match.when({ _tag: "StatePull" }, () => statePull), Match.when({ _tag: "StateCommit" }, (cmd) => stateCommit(cmd.message)), Match.when({ _tag: "StatePush" }, () => statePush), Match.when({ _tag: "StateSync" }, (cmd) => stateSync(cmd.message)), Match.when({ _tag: "AuthGithubLogin" }, (cmd) => authGithubLogin(cmd)), Match.when({ _tag: "AuthGithubStatus" }, (cmd) => authGithubStatus(cmd)), Match.when({ _tag: "AuthGithubLogout" }, (cmd) => authGithubLogout(cmd)), Match.when({ _tag: "AuthCodexLogin" }, (cmd) => authCodexLogin(cmd)), Match.when({ _tag: "AuthCodexStatus" }, (cmd) => authCodexStatus(cmd)), Match.when({ _tag: "AuthCodexLogout" }, (cmd) => authCodexLogout(cmd)), Match.when({ _tag: "Attach" }, (cmd) => attachTmux(cmd)), Match.when({ _tag: "Panes" }, (cmd) => listTmuxPanes(cmd)), Match.when({ _tag: "SessionsList" }, (cmd) => listTerminalSessions(cmd)), Match.when({ _tag: "SessionsKill" }, (cmd) => killTerminalProcess(cmd)), Match.when({ _tag: "SessionsLogs" }, (cmd) => tailTerminalLogs(cmd)), Match.exhaustive);
+// CHANGE: compose CLI program with typed errors and shell effects
+// WHY: keep a thin entry layer over pure parsing and template generation
+// QUOTE(ТЗ): "CLI команду... создавать докер образы"
+// REF: user-request-2026-01-07
+// SOURCE: n/a
+// FORMAT THEOREM: forall cmd: handle(cmd) terminates with typed outcome
+// PURITY: SHELL
+// EFFECT: Effect<void, AppError, FileSystem | Path | CommandExecutor>
+// INVARIANT: help is printed without side effects beyond logs
+// COMPLEXITY: O(n) where n = |files|
+export const program = pipe(readCommand, Effect.flatMap((command) => Match.value(command).pipe(Match.when({ _tag: "Help" }, ({ message }) => Effect.log(message)), Match.when({ _tag: "Create" }, (create) => createProject(create)), Match.when({ _tag: "Status" }, () => listProjectStatus), Match.when({ _tag: "DownAll" }, () => downAllDockerGitProjects), Match.when({ _tag: "Menu" }, () => runMenu), Match.orElse((cmd) => handleNonBaseCommand(cmd)))), Effect.catchTag("FileExistsError", (error) => pipe(Effect.logWarning(renderError(error)), Effect.asVoid)), Effect.catchTag("DockerCommandError", logWarningAndExit), Effect.catchTag("AuthError", logWarningAndExit), Effect.catchTag("CommandFailedError", logWarningAndExit), Effect.matchEffect({
+    onFailure: (error) => isParseError(error)
+        ? logErrorAndExit(error)
+        : pipe(Effect.logError(renderError(error)), Effect.flatMap(() => Effect.fail(error))),
+    onSuccess: () => Effect.void
+}), Effect.asVoid);

package/dist/src/docker-git/tmux.js

@@ -0,0 +1,176 @@
+import { Effect, pipe } from "effect";
+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 { 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) => ({
+    cwd: process.cwd(),
+    command: "tmux",
+    args
+});
+const runTmux = (args) => runCommandWithExitCodes(makeTmuxSpec(args), tmuxOk, (exitCode) => new CommandFailedError({ command: "tmux", exitCode }));
+const runTmuxExitCode = (args) => runCommandExitCode(makeTmuxSpec(args));
+const runTmuxCapture = (args) => runCommandCapture(makeTmuxSpec(args), tmuxOk, (exitCode) => new CommandFailedError({ command: "tmux", exitCode }));
+const sendKeys = (session, pane, text) => pipe(runTmux(["send-keys", "-t", `${session}:0.${pane}`, "-l", text]), Effect.zipRight(runTmux(["send-keys", "-t", `${session}:0.${pane}`, "C-m"])));
+const shellEscape = (value) => {
+    if (value.length === 0) {
+        return "''";
+    }
+    if (!/[^\w@%+=:,./-]/.test(value)) {
+        return value;
+    }
+    const escaped = value.replaceAll("'", "'\"'\"'");
+    return `'${escaped}'`;
+};
+const wrapBash = (command) => `bash -lc ${shellEscape(command)}`;
+const buildJobsCommand = (containerName) => [
+    "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) => runTmuxCapture(["show-options", "-t", session, "-v", "@docker-git-layout"]).pipe(Effect.map((value) => value.trim()), Effect.catchTag("CommandFailedError", () => Effect.succeed(null)));
+const buildBottomBarCommand = () => [
+    "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) => {
+    const match = /refs\/pull\/(\d+)\/head/.exec(repoRef);
+    const pr = match?.[1];
+    return pr ? `PR#${pr}` : repoRef;
+};
+const formatRepoDisplayName = (repoUrl) => {
+    const parts = deriveRepoPathParts(repoUrl);
+    return parts.pathParts.length > 0 ? parts.pathParts.join("/") : repoUrl;
+};
+const normalizePaneCell = (value) => value?.trim() ?? "-";
+const parsePaneRow = (line) => {
+    const [id, window, title, command] = line.split("\t");
+    return {
+        id: normalizePaneCell(id),
+        window: normalizePaneCell(window),
+        title: normalizePaneCell(title),
+        command: normalizePaneCell(command)
+    };
+};
+const renderPaneRow = (row) => `- ${row.id}  ${row.window}  ${row.title === "-" ? row.command : row.title}  ${row.command}`;
+const configureSession = (session, repoDisplayName, statusRight) => 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) => 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, sshCommand, containerName) => 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) => 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) => 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]));
+});