@prover-coder-ai/docker-git 1.0.15 → 1.0.17

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

@@ -0,0 +1,66 @@
+import { runDockerComposeDown } from "@effect-template/lib/shell/docker";
+import { renderError } from "@effect-template/lib/usecases/errors";
+import { mcpPlaywrightUp } from "@effect-template/lib/usecases/mcp-playwright";
+import { connectProjectSshWithUp, deleteDockerGitProject, listRunningProjectItems } from "@effect-template/lib/usecases/projects";
+import { Effect, pipe } from "effect";
+import { openProjectAuthMenu } from "./menu-project-auth.js";
+import { buildConnectEffect } from "./menu-select-connect.js";
+import { loadRuntimeByProject } from "./menu-select-runtime.js";
+import { startSelectView } from "./menu-select-view.js";
+import { pauseOnError, resetToMenu, resumeSshWithSkipInputs, resumeWithSkipInputs, withSuspendedTui } from "./menu-shared.js";
+export const runConnectSelection = (selected, context, enableMcpPlaywright) => {
+    context.setMessage(enableMcpPlaywright
+        ? `Enabling Playwright MCP for ${selected.displayName}, then connecting...`
+        : `Connecting to ${selected.displayName}...`);
+    context.setSshActive(true);
+    context.runner.runEffect(pipe(withSuspendedTui(buildConnectEffect(selected, enableMcpPlaywright, {
+        connectWithUp: (item) => connectProjectSshWithUp(item).pipe(Effect.mapError((error) => error)),
+        enableMcpPlaywright: (projectDir) => mcpPlaywrightUp({ _tag: "McpPlaywrightUp", projectDir, runUp: false }).pipe(Effect.asVoid, Effect.mapError((error) => error))
+    }), {
+        onError: pauseOnError(renderError),
+        onResume: resumeSshWithSkipInputs(context)
+    }), Effect.tap(() => Effect.sync(() => {
+        context.setMessage("SSH session ended. Press Esc to return to the menu.");
+    })), Effect.asVoid));
+};
+export const runDownSelection = (selected, context) => {
+    context.setMessage(`Stopping ${selected.displayName}...`);
+    context.runner.runEffect(withSuspendedTui(pipe(runDockerComposeDown(selected.projectDir), Effect.zipRight(listRunningProjectItems), Effect.flatMap((items) => pipe(loadRuntimeByProject(items), Effect.map((runtimeByProject) => ({ items, runtimeByProject })))), Effect.tap(({ items, runtimeByProject }) => Effect.sync(() => {
+        if (items.length === 0) {
+            resetToMenu(context);
+            context.setMessage("No running docker-git containers.");
+            return;
+        }
+        startSelectView(items, "Down", context, runtimeByProject);
+        context.setMessage("Container stopped. Select another to stop, or Esc to return.");
+    })), Effect.asVoid), {
+        onError: pauseOnError(renderError),
+        onResume: resumeWithSkipInputs(context)
+    }));
+};
+export const runInfoSelection = (selected, context) => {
+    context.setMessage(`Details for ${selected.displayName} are shown on the right. Press Esc to return to the menu.`);
+};
+export const runAuthSelection = (selected, context) => {
+    openProjectAuthMenu({
+        project: selected,
+        runner: context.runner,
+        setView: context.setView,
+        setMessage: context.setMessage,
+        setActiveDir: context.setActiveDir
+    });
+};
+export const runDeleteSelection = (selected, context) => {
+    context.setMessage(`Deleting ${selected.displayName}...`);
+    context.runner.runEffect(pipe(withSuspendedTui(deleteDockerGitProject(selected).pipe(Effect.tap(() => Effect.sync(() => {
+        if (context.activeDir === selected.projectDir) {
+            context.setActiveDir(null);
+        }
+        context.setView({ _tag: "Menu" });
+    })), Effect.asVoid), {
+        onError: pauseOnError(renderError),
+        onResume: resumeWithSkipInputs(context)
+    }), Effect.tap(() => Effect.sync(() => {
+        context.setMessage("Project deleted.");
+    })), Effect.asVoid));
+};

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

@@ -0,0 +1,12 @@
+import { Effect, pipe } from "effect";
+import { loadRuntimeByProject } from "./menu-select-runtime.js";
+import { startSelectView } from "./menu-select.js";
+export const loadSelectView = (effect, purpose, context) => pipe(effect, Effect.flatMap((items) => pipe(loadRuntimeByProject(items), Effect.flatMap((runtimeByProject) => Effect.sync(() => {
+    if (items.length === 0) {
+        context.setMessage(purpose === "Down"
+            ? "No running docker-git containers."
+            : "No docker-git projects found.");
+        return;
+    }
+    startSelectView(items, purpose, context, runtimeByProject);
+})))));

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

@@ -0,0 +1,21 @@
+const defaultRuntime = () => ({
+    running: false,
+    sshSessions: 0,
+    startedAtIso: null,
+    startedAtEpochMs: null
+});
+const runtimeForSort = (runtimeByProject, item) => runtimeByProject[item.projectDir] ?? defaultRuntime();
+const startedAtEpochForSort = (runtime) => runtime.startedAtEpochMs ?? Number.NEGATIVE_INFINITY;
+export const sortItemsByLaunchTime = (items, runtimeByProject) => items.toSorted((left, right) => {
+    const leftRuntime = runtimeForSort(runtimeByProject, left);
+    const rightRuntime = runtimeForSort(runtimeByProject, right);
+    const leftStartedAt = startedAtEpochForSort(leftRuntime);
+    const rightStartedAt = startedAtEpochForSort(rightRuntime);
+    if (leftStartedAt !== rightStartedAt) {
+        return rightStartedAt - leftStartedAt;
+    }
+    if (leftRuntime.running !== rightRuntime.running) {
+        return leftRuntime.running ? -1 : 1;
+    }
+    return left.displayName.localeCompare(right.displayName);
+});

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

@@ -2,8 +2,14 @@ import { runCommandCapture } from "@effect-template/lib/shell/command-runner";
 import { runDockerPsNames } from "@effect-template/lib/shell/docker";
 import { Effect, pipe } from "effect";
 const emptyRuntimeByProject = () => ({});
-const stoppedRuntime = () => ({ running: false, sshSessions: 0 });
+const stoppedRuntime = () => ({
+    running: false,
+    sshSessions: 0,
+    startedAtIso: null,
+    startedAtEpochMs: null
+});
 const countSshSessionsScript = "who -u 2>/dev/null | wc -l | tr -d '[:space:]'";
+const dockerZeroStartedAt = "0001-01-01T00:00:00Z";
 const parseSshSessionCount = (raw) => {
     const parsed = Number.parseInt(raw.trim(), 10);
     if (Number.isNaN(parsed) || parsed < 0) {
@@ -11,6 +17,20 @@ const parseSshSessionCount = (raw) => {
     }
     return parsed;
 };
+const parseContainerStartedAt = (raw) => {
+    const trimmed = raw.trim();
+    if (trimmed.length === 0 || trimmed === dockerZeroStartedAt) {
+        return null;
+    }
+    const startedAtEpochMs = Date.parse(trimmed);
+    if (Number.isNaN(startedAtEpochMs)) {
+        return null;
+    }
+    return {
+        startedAtIso: trimmed,
+        startedAtEpochMs
+    };
+};
 const toRuntimeMap = (entries) => {
     const runtimeByProject = {};
     for (const [projectDir, runtime] of entries) {
@@ -26,23 +46,35 @@ const countContainerSshSessions = (containerName) => pipe(runCommandCapture({
     onFailure: () => 0,
     onSuccess: (raw) => parseSshSessionCount(raw)
 }));
+const inspectContainerStartedAt = (containerName) => pipe(runCommandCapture({
+    cwd: process.cwd(),
+    command: "docker",
+    args: ["inspect", "--format", "{{.State.StartedAt}}", containerName]
+}, [0], (exitCode) => ({ _tag: "CommandFailedError", command: "docker inspect .State.StartedAt", exitCode })), Effect.match({
+    onFailure: () => null,
+    onSuccess: (raw) => parseContainerStartedAt(raw)
+}));
 // CHANGE: enrich select items with runtime state and SSH session counts
 // WHY: prevent stopping/deleting containers that are currently used via SSH
 // QUOTE(ТЗ): "писать скок SSH подключений к контейнеру сейчас"
 // REF: issue-47
 // SOURCE: n/a
-// FORMAT THEOREM: forall p: runtime(p) -> {running(p), ssh_sessions(p)}
+// FORMAT THEOREM: forall p: runtime(p) -> {running(p), ssh_sessions(p), started_at(p)}
 // PURITY: SHELL
 // EFFECT: Effect<Record<string, SelectProjectRuntime>, never, MenuEnv>
-// INVARIANT: stopped containers always have sshSessions = 0
-// COMPLEXITY: O(n + docker_ps + docker_exec)
+// INVARIANT: projects without a known container start have startedAt = null
+// COMPLEXITY: O(n + docker_ps + docker_exec + docker_inspect)
 export const loadRuntimeByProject = (items) => pipe(runDockerPsNames(process.cwd()), Effect.flatMap((runningNames) => Effect.forEach(items, (item) => {
     const running = runningNames.includes(item.containerName);
-    if (!running) {
-        const entry = [item.projectDir, stoppedRuntime()];
-        return Effect.succeed(entry);
-    }
-    return pipe(countContainerSshSessions(item.containerName), Effect.map((sshSessions) => ({ running: true, sshSessions })), Effect.map((runtime) => [item.projectDir, runtime]));
+    const sshSessionsEffect = running
+        ? countContainerSshSessions(item.containerName)
+        : Effect.succeed(0);
+    return pipe(Effect.all([sshSessionsEffect, inspectContainerStartedAt(item.containerName)]), Effect.map(([sshSessions, startedAt]) => ({
+        running,
+        sshSessions,
+        startedAtIso: startedAt?.startedAtIso ?? null,
+        startedAtEpochMs: startedAt?.startedAtEpochMs ?? null
+    })), Effect.map((runtime) => [item.projectDir, runtime]));
 }, { concurrency: 4 })), Effect.map((entries) => toRuntimeMap(entries)), Effect.match({
     onFailure: () => emptyRuntimeByProject(),
     onSuccess: (runtimeByProject) => runtimeByProject

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

@@ -0,0 +1,15 @@
+import { sortItemsByLaunchTime } from "./menu-select-order.js";
+const emptyRuntimeByProject = () => ({});
+export const startSelectView = (items, purpose, context, runtimeByProject = emptyRuntimeByProject()) => {
+    const sortedItems = sortItemsByLaunchTime(items, runtimeByProject);
+    context.setMessage(null);
+    context.setView({
+        _tag: "SelectProject",
+        purpose,
+        items: sortedItems,
+        runtimeByProject,
+        selected: 0,
+        confirmDelete: false,
+        connectEnableMcpPlaywright: false
+    });
+};

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

@@ -1,23 +1,9 @@
-import { runDockerComposeDown } from "@effect-template/lib/shell/docker";
-import { mcpPlaywrightUp } from "@effect-template/lib/usecases/mcp-playwright";
-import { connectProjectSshWithUp, deleteDockerGitProject, listRunningProjectItems } from "@effect-template/lib/usecases/projects";
-import { Effect, Match, pipe } from "effect";
-import { buildConnectEffect, isConnectMcpToggleInput } from "./menu-select-connect.js";
-import { loadRuntimeByProject, runtimeForSelection } from "./menu-select-runtime.js";
-import { resetToMenu, resumeTui, suspendTui } from "./menu-shared.js";
-const emptyRuntimeByProject = () => ({});
-export const startSelectView = (items, purpose, context, runtimeByProject = emptyRuntimeByProject()) => {
-    context.setMessage(null);
-    context.setView({
-        _tag: "SelectProject",
-        purpose,
-        items,
-        runtimeByProject,
-        selected: 0,
-        confirmDelete: false,
-        connectEnableMcpPlaywright: false
-    });
-};
+import { Match } from "effect";
+import { runAuthSelection, runConnectSelection, runDeleteSelection, runDownSelection, runInfoSelection } from "./menu-select-actions.js";
+import { isConnectMcpToggleInput } from "./menu-select-connect.js";
+import { runtimeForSelection } from "./menu-select-runtime.js";
+import { resetToMenu } from "./menu-shared.js";
+export { startSelectView } from "./menu-select-view.js";
 const clampIndex = (value, size) => {
     if (size <= 0) {
         return 0;
@@ -73,56 +59,7 @@ const handleSelectNavigation = (key, view, context) => {
     }
     return false;
 };
-const runWithSuspendedTui = (context, effect, onResume, doneMessage) => {
-    context.runner.runEffect(pipe(Effect.sync(suspendTui), Effect.zipRight(effect), Effect.ensuring(Effect.sync(() => {
-        resumeTui();
-        onResume();
-        context.setSkipInputs(() => 2);
-    })), Effect.tap(() => Effect.sync(() => {
-        context.setMessage(doneMessage);
-    }))));
-};
-const runConnectSelection = (selected, context, enableMcpPlaywright) => {
-    context.setMessage(enableMcpPlaywright
-        ? `Enabling Playwright MCP for ${selected.displayName}, then connecting...`
-        : `Connecting to ${selected.displayName}...`);
-    context.setSshActive(true);
-    runWithSuspendedTui(context, buildConnectEffect(selected, enableMcpPlaywright, {
-        connectWithUp: (item) => connectProjectSshWithUp(item).pipe(Effect.mapError((error) => error)),
-        enableMcpPlaywright: (projectDir) => mcpPlaywrightUp({ _tag: "McpPlaywrightUp", projectDir, runUp: false }).pipe(Effect.asVoid, Effect.mapError((error) => error))
-    }), () => {
-        context.setSshActive(false);
-    }, "SSH session ended. Press Esc to return to the menu.");
-};
-const runDownSelection = (selected, context) => {
-    context.setMessage(`Stopping ${selected.displayName}...`);
-    context.runner.runEffect(pipe(Effect.sync(suspendTui), Effect.zipRight(runDockerComposeDown(selected.projectDir)), Effect.zipRight(listRunningProjectItems), Effect.flatMap((items) => pipe(loadRuntimeByProject(items), Effect.map((runtimeByProject) => ({ items, runtimeByProject })))), Effect.tap(({ items, runtimeByProject }) => Effect.sync(() => {
-        if (items.length === 0) {
-            resetToMenu(context);
-            context.setMessage("No running docker-git containers.");
-            return;
-        }
-        startSelectView(items, "Down", context, runtimeByProject);
-        context.setMessage("Container stopped. Select another to stop, or Esc to return.");
-    })), Effect.ensuring(Effect.sync(() => {
-        resumeTui();
-        context.setSkipInputs(() => 2);
-    })), Effect.asVoid));
-};
-const runInfoSelection = (selected, context) => {
-    context.setMessage(`Details for ${selected.displayName} are shown on the right. Press Esc to return to the menu.`);
-};
-const runDeleteSelection = (selected, context) => {
-    context.setMessage(`Deleting ${selected.displayName}...`);
-    runWithSuspendedTui(context, deleteDockerGitProject(selected).pipe(Effect.tap(() => Effect.sync(() => {
-        if (context.activeDir === selected.projectDir) {
-            context.setActiveDir(null);
-        }
-        context.setView({ _tag: "Menu" });
-    }))), () => {
-        // Only return to menu on success (see Effect.tap above).
-    }, "Project deleted.");
-};
+const formatSshSessionsLabel = (sshSessions) => sshSessions === 1 ? "1 active SSH session" : `${sshSessions} active SSH sessions`;
 const handleSelectReturn = (view, context) => {
     const selected = view.items[view.selected];
     if (!selected) {
@@ -131,12 +68,13 @@ const handleSelectReturn = (view, context) => {
         return;
     }
     const selectedRuntime = runtimeForSelection(view, selected);
-    const sshSessionsLabel = selectedRuntime.sshSessions === 1
-        ? "1 active SSH session"
-        : `${selectedRuntime.sshSessions} active SSH sessions`;
+    const sshSessionsLabel = formatSshSessionsLabel(selectedRuntime.sshSessions);
     Match.value(view.purpose).pipe(Match.when("Connect", () => {
         context.setActiveDir(selected.projectDir);
         runConnectSelection(selected, context, view.connectEnableMcpPlaywright);
+    }), Match.when("Auth", () => {
+        context.setActiveDir(selected.projectDir);
+        runAuthSelection(selected, context);
     }), Match.when("Down", () => {
         if (selectedRuntime.sshSessions > 0 && !view.confirmDelete) {
             context.setMessage(`${selected.containerName} has ${sshSessionsLabel}. Press Enter again to stop, Esc to cancel.`);
@@ -158,12 +96,3 @@ const handleSelectReturn = (view, context) => {
         runDeleteSelection(selected, context);
     }), Match.exhaustive);
 };
-export const loadSelectView = (effect, purpose, context) => pipe(effect, Effect.flatMap((items) => pipe(loadRuntimeByProject(items), Effect.flatMap((runtimeByProject) => Effect.sync(() => {
-    if (items.length === 0) {
-        context.setMessage(purpose === "Down"
-            ? "No running docker-git containers."
-            : "No docker-git projects found.");
-        return;
-    }
-    startSelectView(items, purpose, context, runtimeByProject);
-})))));

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

@@ -1,5 +1,21 @@
+import { Effect, pipe } from "effect";
 let stdoutPatched = false;
 let stdoutMuted = false;
+let baseStdoutWrite = null;
+let baseStderrWrite = null;
+const wrapWrite = (baseWrite) => (chunk, encoding, cb) => {
+    if (stdoutMuted) {
+        const callback = typeof encoding === "function" ? encoding : cb;
+        if (typeof callback === "function") {
+            callback();
+        }
+        return true;
+    }
+    if (typeof encoding === "function") {
+        return baseWrite(chunk, encoding);
+    }
+    return baseWrite(chunk, encoding, cb);
+};
 const disableMouseModes = () => {
     // Disable xterm/urxvt mouse tracking and "alternate scroll" mode (wheel -> arrow keys).
     process.stdout.write("\u001B[?1000l\u001B[?1002l\u001B[?1003l\u001B[?1005l\u001B[?1006l\u001B[?1015l\u001B[?1007l");
@@ -18,23 +34,72 @@ const ensureStdoutPatched = () => {
     if (stdoutPatched) {
         return;
     }
-    const baseWrite = process.stdout.write.bind(process.stdout);
-    const mutedWrite = (chunk, encoding, cb) => {
-        if (stdoutMuted) {
-            const callback = typeof encoding === "function" ? encoding : cb;
-            if (typeof callback === "function") {
-                callback();
-            }
-            return true;
-        }
-        if (typeof encoding === "function") {
-            return baseWrite(chunk, encoding);
-        }
-        return baseWrite(chunk, encoding, cb);
-    };
-    process.stdout.write = mutedWrite;
+    baseStdoutWrite = process.stdout.write.bind(process.stdout);
+    baseStderrWrite = process.stderr.write.bind(process.stderr);
+    process.stdout.write = wrapWrite(baseStdoutWrite);
+    process.stderr.write = wrapWrite(baseStderrWrite);
     stdoutPatched = true;
 };
+// CHANGE: allow writing to the terminal even while stdout is muted
+// WHY: we mute Ink renders during interactive commands, but still need to show prompts/errors
+// REF: user-request-2026-02-18-tui-output-hidden
+// SOURCE: n/a
+// PURITY: SHELL
+// EFFECT: n/a
+// INVARIANT: bypasses the mute wrapper safely
+export const writeToTerminal = (text) => {
+    ensureStdoutPatched();
+    const write = baseStdoutWrite ?? process.stdout.write.bind(process.stdout);
+    write(text);
+};
+// CHANGE: keep the user on the primary screen until they acknowledge
+// WHY: otherwise output from failed docker/gh commands gets hidden again when TUI resumes
+// REF: user-request-2026-02-18-tui-output-hidden
+// SOURCE: n/a
+// PURITY: SHELL
+// EFFECT: Effect<void, never, never>
+// INVARIANT: no-op when stdin/stdout aren't TTY (CI/e2e)
+export const pauseForEnter = (prompt = "Press Enter to return to docker-git...") => {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        return Effect.void;
+    }
+    return Effect.async((resume) => {
+        // Ensure the prompt isn't glued to the last command line.
+        writeToTerminal(`\n${prompt}\n`);
+        process.stdin.resume();
+        const cleanup = () => {
+            process.stdin.off("data", onData);
+        };
+        const onData = () => {
+            cleanup();
+            resume(Effect.void);
+        };
+        process.stdin.on("data", onData);
+        return Effect.sync(() => {
+            cleanup();
+        });
+    }).pipe(Effect.asVoid);
+};
+export const writeErrorAndPause = (renderedError) => pipe(Effect.sync(() => {
+    writeToTerminal(`\n[docker-git] ${renderedError}\n`);
+}), Effect.zipRight(pauseForEnter()), Effect.asVoid);
+export const withSuspendedTui = (effect, options) => {
+    const withError = options?.onError
+        ? pipe(effect, Effect.tapError((error) => Effect.ignore(options.onError?.(error) ?? Effect.void)))
+        : effect;
+    return pipe(Effect.sync(suspendTui), Effect.zipRight(withError), Effect.ensuring(Effect.sync(() => {
+        resumeTui();
+        options?.onResume?.();
+    })));
+};
+export const resumeWithSkipInputs = (context, extra) => () => {
+    extra?.();
+    context.setSkipInputs(() => 2);
+};
+export const resumeSshWithSkipInputs = (context) => resumeWithSkipInputs(context, () => {
+    context.setSshActive(false);
+});
+export const pauseOnError = (render) => (error) => writeErrorAndPause(render(error));
 // CHANGE: toggle stdout write muting for Ink rendering
 // WHY: allow SSH sessions to own the terminal without TUI redraws
 // QUOTE(ТЗ): "при изменении разершения он всё ломает?"
@@ -67,7 +132,9 @@ export const suspendTui = () => {
     if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
         process.stdin.setRawMode(false);
     }
-    process.stdout.write("\u001B[?1049l\u001B[2J\u001B[H");
+    // Switch back to the primary screen so interactive commands (ssh/gh/codex)
+    // can render normally. Do not clear it: users may need scrollback (OAuth codes/URLs).
+    process.stdout.write("\u001B[?1049l");
     setStdoutMuted(true);
 };
 // CHANGE: restore TUI rendering after interactive commands
@@ -86,6 +153,7 @@ export const resumeTui = () => {
     }
     setStdoutMuted(false);
     disableMouseModes();
+    // Return to the alternate screen for Ink rendering.
     process.stdout.write("\u001B[?1049h\u001B[2J\u001B[H");
     if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
         process.stdin.setRawMode(true);
@@ -99,7 +167,8 @@ export const leaveTui = () => {
     // Ensure we don't leave the terminal in a broken "mouse reporting" mode.
     setStdoutMuted(false);
     disableMouseModes();
-    process.stdout.write("\u001B[?1049l\u001B[2J\u001B[H");
+    // Restore the primary screen on exit without clearing it (keeps useful scrollback).
+    process.stdout.write("\u001B[?1049l");
     if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
         process.stdin.setRawMode(false);
     }

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

@@ -9,6 +9,8 @@ export const createSteps = [
 export const menuItems = [
     { id: { _tag: "Create" }, label: "Create project" },
     { id: { _tag: "Select" }, label: "Select project" },
+    { id: { _tag: "Auth" }, label: "Auth profiles (keys)" },
+    { id: { _tag: "ProjectAuth" }, label: "Project auth (bind labels)" },
     { id: { _tag: "Info" }, label: "Show connection info" },
     { id: { _tag: "Status" }, label: "docker compose ps" },
     { id: { _tag: "Logs" }, label: "docker compose logs --tail=200" },

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

@@ -8,7 +8,7 @@ import { render, useApp, useInput } from "ink";
 import React, { useEffect, useMemo, useState } from "react";
 import { resolveCreateInputs } from "./menu-create.js";
 import { handleUserInput } from "./menu-input-handler.js";
-import { renderCreate, renderMenu, renderSelect, renderStepLabel } from "./menu-render.js";
+import { renderAuthMenu, renderAuthPrompt, renderCreate, renderMenu, renderProjectAuthMenu, renderProjectAuthPrompt, renderSelect, renderStepLabel } from "./menu-render.js";
 import { leaveTui, resumeTui } from "./menu-shared.js";
 import { defaultMenuStartupSnapshot, resolveMenuStartupSnapshot } from "./menu-startup.js";
 import { createSteps } from "./menu-types.js";
@@ -54,6 +54,18 @@ const renderView = (context) => {
         const label = renderStepLabel(step, currentDefaults);
         return renderCreate(label, context.view.buffer, context.message, context.view.step, currentDefaults);
     }
+    if (context.view._tag === "AuthMenu") {
+        return renderAuthMenu(context.view.snapshot, context.view.selected, context.message);
+    }
+    if (context.view._tag === "AuthPrompt") {
+        return renderAuthPrompt(context.view, context.message);
+    }
+    if (context.view._tag === "ProjectAuthMenu") {
+        return renderProjectAuthMenu(context.view.snapshot, context.view.selected, context.message);
+    }
+    if (context.view._tag === "ProjectAuthPrompt") {
+        return renderProjectAuthPrompt(context.view, context.message);
+    }
     return renderSelect({
         purpose: context.view.purpose,
         items: context.view.items,

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

@@ -1,5 +1,5 @@
 import { createProject } from "@effect-template/lib/usecases/actions";
-import { authCodexLogin, authCodexLogout, authCodexStatus, authGithubLogin, authGithubLogout, authGithubStatus } from "@effect-template/lib/usecases/auth";
+import { authClaudeLogin, authClaudeLogout, authClaudeStatus, authCodexLogin, authCodexLogout, authCodexStatus, authGithubLogin, authGithubLogout, authGithubStatus } from "@effect-template/lib/usecases/auth";
 import { renderError } from "@effect-template/lib/usecases/errors";
 import { mcpPlaywrightUp } from "@effect-template/lib/usecases/mcp-playwright";
 import { downAllDockerGitProjects, listProjectStatus } from "@effect-template/lib/usecases/projects";
@@ -22,8 +22,8 @@ const setExitCode = (code) => Effect.sync(() => {
 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.when({ _tag: "ScrapExport" }, (cmd) => exportScrap(cmd)), Match.when({ _tag: "ScrapImport" }, (cmd) => importScrap(cmd)))
-    .pipe(Match.when({ _tag: "McpPlaywrightUp" }, (cmd) => mcpPlaywrightUp(cmd)), Match.exhaustive);
+    .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: "AuthClaudeLogin" }, (cmd) => authClaudeLogin(cmd)), Match.when({ _tag: "AuthClaudeStatus" }, (cmd) => authClaudeStatus(cmd)), Match.when({ _tag: "AuthClaudeLogout" }, (cmd) => authClaudeLogout(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)))
+    .pipe(Match.when({ _tag: "SessionsLogs" }, (cmd) => tailTerminalLogs(cmd)), Match.when({ _tag: "ScrapExport" }, (cmd) => exportScrap(cmd)), Match.when({ _tag: "ScrapImport" }, (cmd) => importScrap(cmd)), Match.when({ _tag: "McpPlaywrightUp" }, (cmd) => mcpPlaywrightUp(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 команду... создавать докер образы"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prover-coder-ai/docker-git",
-  "version": "1.0.15",
+  "version": "1.0.17",
   "description": "Minimal Vite-powered TypeScript console starter using Effect",
   "main": "dist/src/docker-git/main.js",
   "bin": {

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

@@ -1,21 +1,18 @@
 import { Either, Match } from "effect"
 
 import type { RawOptions } from "@effect-template/lib/core/command-options"
-import {
-  type AuthCommand,
-  type Command,
-  defaultTemplateConfig,
-  type ParseError
-} from "@effect-template/lib/core/domain"
+import { type AuthCommand, type Command, type ParseError } from "@effect-template/lib/core/domain"
 
 import { parseRawOptions } from "./parser-options.js"
 
 type AuthOptions = {
   readonly envGlobalPath: string
   readonly codexAuthPath: string
+  readonly claudeAuthPath: string
   readonly label: string | null
   readonly token: string | null
   readonly scopes: string | null
+  readonly authWeb: boolean
 }
 
 const missingArgument = (name: string): ParseError => ({
@@ -34,24 +31,32 @@ const normalizeLabel = (value: string | undefined): string | null => {
   return trimmed.length === 0 ? null : trimmed
 }
 
+const defaultEnvGlobalPath = ".docker-git/.orch/env/global.env"
+const defaultCodexAuthPath = ".docker-git/.orch/auth/codex"
+const defaultClaudeAuthPath = ".docker-git/.orch/auth/claude"
+
 const resolveAuthOptions = (raw: RawOptions): AuthOptions => ({
-  envGlobalPath: raw.envGlobalPath ?? defaultTemplateConfig.envGlobalPath,
-  codexAuthPath: raw.codexAuthPath ?? defaultTemplateConfig.codexAuthPath,
+  envGlobalPath: raw.envGlobalPath ?? defaultEnvGlobalPath,
+  codexAuthPath: raw.codexAuthPath ?? defaultCodexAuthPath,
+  claudeAuthPath: defaultClaudeAuthPath,
   label: normalizeLabel(raw.label),
   token: normalizeLabel(raw.token),
-  scopes: normalizeLabel(raw.scopes)
+  scopes: normalizeLabel(raw.scopes),
+  authWeb: raw.authWeb === true
 })
 
 const buildGithubCommand = (action: string, options: AuthOptions): Either.Either<AuthCommand, ParseError> =>
   Match.value(action).pipe(
     Match.when("login", () =>
-      Either.right<AuthCommand>({
-        _tag: "AuthGithubLogin",
-        label: options.label,
-        token: options.token,
-        scopes: options.scopes,
-        envGlobalPath: options.envGlobalPath
-      })),
+      options.authWeb && options.token !== null
+        ? Either.left(invalidArgument("--token", "cannot be combined with --web"))
+        : Either.right<AuthCommand>({
+          _tag: "AuthGithubLogin",
+          label: options.label,
+          token: options.authWeb ? null : options.token,
+          scopes: options.scopes,
+          envGlobalPath: options.envGlobalPath
+        })),
     Match.when("status", () =>
       Either.right<AuthCommand>({
         _tag: "AuthGithubStatus",
@@ -89,6 +94,29 @@ const buildCodexCommand = (action: string, options: AuthOptions): Either.Either<
     Match.orElse(() => Either.left(invalidArgument("auth action", `unknown action '${action}'`)))
   )
 
+const buildClaudeCommand = (action: string, options: AuthOptions): Either.Either<AuthCommand, ParseError> =>
+  Match.value(action).pipe(
+    Match.when("login", () =>
+      Either.right<AuthCommand>({
+        _tag: "AuthClaudeLogin",
+        label: options.label,
+        claudeAuthPath: options.claudeAuthPath
+      })),
+    Match.when("status", () =>
+      Either.right<AuthCommand>({
+        _tag: "AuthClaudeStatus",
+        label: options.label,
+        claudeAuthPath: options.claudeAuthPath
+      })),
+    Match.when("logout", () =>
+      Either.right<AuthCommand>({
+        _tag: "AuthClaudeLogout",
+        label: options.label,
+        claudeAuthPath: options.claudeAuthPath
+      })),
+    Match.orElse(() => Either.left(invalidArgument("auth action", `unknown action '${action}'`)))
+  )
+
 const buildAuthCommand = (
   provider: string,
   action: string,
@@ -98,6 +126,8 @@ const buildAuthCommand = (
     Match.when("github", () => buildGithubCommand(action, options)),
     Match.when("gh", () => buildGithubCommand(action, options)),
     Match.when("codex", () => buildCodexCommand(action, options)),
+    Match.when("claude", () => buildClaudeCommand(action, options)),
+    Match.when("cc", () => buildClaudeCommand(action, options)),
     Match.orElse(() => Either.left(invalidArgument("auth provider", `unknown provider '${provider}'`)))
   )
 

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

@@ -22,4 +22,3 @@ export const parseMcpPlaywright = (
     projectDir,
     runUp: raw.up ?? true
   }))
-

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

@@ -22,7 +22,7 @@ const statusCommand: Command = { _tag: "Status" }
 const downAllCommand: Command = { _tag: "DownAll" }
 
 const parseCreate = (args: ReadonlyArray<string>): Either.Either<Command, ParseError> =>
-  Either.flatMap(parseRawOptions(args), buildCreateCommand)
+  Either.flatMap(parseRawOptions(args), (raw) => buildCreateCommand(raw))
 
 // CHANGE: parse CLI arguments into a typed command
 // WHY: enforce deterministic, pure parsing before any effects run