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

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

@@ -0,0 +1,47 @@
+export const parseMenuIndex = (input) => {
+    const trimmed = input.trim();
+    if (trimmed.length === 0) {
+        return null;
+    }
+    const parsed = Number(trimmed);
+    if (!Number.isInteger(parsed)) {
+        return null;
+    }
+    const index = parsed - 1;
+    return index >= 0 ? index : null;
+};
+export const submitPromptStep = (view, steps, context, onCancel, onSubmit) => {
+    const step = steps[view.step];
+    if (!step) {
+        onCancel();
+        return;
+    }
+    const value = view.buffer.trim();
+    if (step.required && value.length === 0) {
+        context.setMessage(`${step.label} is required.`);
+        return;
+    }
+    const nextValues = { ...view.values, [step.key]: value };
+    const nextStep = view.step + 1;
+    if (nextStep < steps.length) {
+        context.setView({ ...view, step: nextStep, buffer: "", values: nextValues });
+        context.setMessage(null);
+        return;
+    }
+    onSubmit(nextValues);
+};
+export const handleMenuNumberInput = (input, context, actionByIndex, runAction) => {
+    const index = parseMenuIndex(input);
+    if (index === null) {
+        if (input.trim().length > 0) {
+            context.setMessage("Use arrows + Enter, or type a number from the list.");
+        }
+        return;
+    }
+    const action = actionByIndex(index);
+    if (action === null) {
+        context.setMessage(`Unknown action: ${input.trim()}`);
+        return;
+    }
+    runAction(action);
+};

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

@@ -0,0 +1,33 @@
+import { parseEnvEntries } from "@effect-template/lib/usecases/env-file";
+export const normalizeLabel = (value) => {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        return "";
+    }
+    const normalized = trimmed
+        .toUpperCase()
+        .replaceAll(/[^A-Z0-9]+/g, "_");
+    let start = 0;
+    while (start < normalized.length && normalized[start] === "_") {
+        start += 1;
+    }
+    let end = normalized.length;
+    while (end > start && normalized[end - 1] === "_") {
+        end -= 1;
+    }
+    const cleaned = normalized.slice(start, end);
+    return cleaned.length > 0 ? cleaned : "";
+};
+export const buildLabeledEnvKey = (baseKey, label) => {
+    const normalized = normalizeLabel(label);
+    if (normalized.length === 0 || normalized === "DEFAULT") {
+        return baseKey;
+    }
+    return `${baseKey}__${normalized}`;
+};
+export const countKeyEntries = (envText, baseKey) => {
+    const prefix = `${baseKey}__`;
+    return parseEnvEntries(envText)
+        .filter((entry) => entry.value.trim().length > 0 && (entry.key === baseKey || entry.key.startsWith(prefix)))
+        .length;
+};

package/dist/src/docker-git/menu-project-auth-claude.js

@@ -0,0 +1,43 @@
+import { Effect } from "effect";
+const oauthTokenFileName = ".oauth-token";
+const legacyConfigFileName = ".config.json";
+const hasFileAtPath = (fs, filePath) => Effect.gen(function* (_) {
+    const exists = yield* _(fs.exists(filePath));
+    if (!exists) {
+        return false;
+    }
+    const info = yield* _(fs.stat(filePath));
+    return info.type === "File";
+});
+const hasNonEmptyOauthToken = (fs, tokenPath) => Effect.gen(function* (_) {
+    const hasFile = yield* _(hasFileAtPath(fs, tokenPath));
+    if (!hasFile) {
+        return false;
+    }
+    const tokenValue = yield* _(fs.readFileString(tokenPath), Effect.orElseSucceed(() => ""));
+    return tokenValue.trim().length > 0;
+});
+const hasLegacyClaudeAuthFile = (fs, accountPath) => Effect.gen(function* (_) {
+    const entries = yield* _(fs.readDirectory(accountPath));
+    for (const entry of entries) {
+        if (!entry.startsWith(".claude") || !entry.endsWith(".json")) {
+            continue;
+        }
+        const isFile = yield* _(hasFileAtPath(fs, `${accountPath}/${entry}`));
+        if (isFile) {
+            return true;
+        }
+    }
+    return false;
+});
+export const hasClaudeAccountCredentials = (fs, accountPath) => hasFileAtPath(fs, `${accountPath}/${legacyConfigFileName}`).pipe(Effect.flatMap((hasConfig) => {
+    if (hasConfig) {
+        return Effect.succeed(true);
+    }
+    return hasNonEmptyOauthToken(fs, `${accountPath}/${oauthTokenFileName}`).pipe(Effect.flatMap((hasOauthToken) => {
+        if (hasOauthToken) {
+            return Effect.succeed(true);
+        }
+        return hasLegacyClaudeAuthFile(fs, accountPath);
+    }));
+}));

package/dist/src/docker-git/menu-project-auth-data.js

@@ -0,0 +1,165 @@
+import * as FileSystem from "@effect/platform/FileSystem";
+import * as Path from "@effect/platform/Path";
+import { Effect, Match, pipe } from "effect";
+import { AuthError } from "@effect-template/lib/shell/errors";
+import { normalizeAccountLabel } from "@effect-template/lib/usecases/auth-helpers";
+import { ensureEnvFile, findEnvValue, readEnvText, upsertEnvKey } from "@effect-template/lib/usecases/env-file";
+import { defaultProjectsRoot } from "@effect-template/lib/usecases/menu-helpers";
+import { autoSyncState } from "@effect-template/lib/usecases/state-repo";
+import { countAuthAccountDirectories } from "./menu-auth-helpers.js";
+import { buildLabeledEnvKey, countKeyEntries, normalizeLabel } from "./menu-labeled-env.js";
+import { hasClaudeAccountCredentials } from "./menu-project-auth-claude.js";
+const projectAuthMenuItems = [
+    { action: "ProjectGithubConnect", label: "Project: GitHub connect label" },
+    { action: "ProjectGithubDisconnect", label: "Project: GitHub disconnect" },
+    { action: "ProjectGitConnect", label: "Project: Git connect label" },
+    { action: "ProjectGitDisconnect", label: "Project: Git disconnect" },
+    { action: "ProjectClaudeConnect", label: "Project: Claude connect label" },
+    { action: "ProjectClaudeDisconnect", label: "Project: Claude disconnect" },
+    { action: "Refresh", label: "Refresh snapshot" },
+    { action: "Back", label: "Back to main menu" }
+];
+const flowSteps = {
+    ProjectGithubConnect: [
+        { key: "label", label: "Label (empty = default)", required: false, secret: false }
+    ],
+    ProjectGithubDisconnect: [],
+    ProjectGitConnect: [
+        { key: "label", label: "Label (empty = default)", required: false, secret: false }
+    ],
+    ProjectGitDisconnect: [],
+    ProjectClaudeConnect: [
+        { key: "label", label: "Label (empty = default)", required: false, secret: false }
+    ],
+    ProjectClaudeDisconnect: []
+};
+const resolveCanonicalLabel = (value) => {
+    const normalized = normalizeLabel(value);
+    return normalized.length === 0 || normalized === "DEFAULT" ? "default" : normalized;
+};
+const githubTokenBaseKey = "GITHUB_TOKEN";
+const gitTokenBaseKey = "GIT_AUTH_TOKEN";
+const gitUserBaseKey = "GIT_AUTH_USER";
+const projectGithubLabelKey = "GITHUB_AUTH_LABEL";
+const projectGitLabelKey = "GIT_AUTH_LABEL";
+const projectClaudeLabelKey = "CLAUDE_AUTH_LABEL";
+const defaultGitUser = "x-access-token";
+const buildGlobalEnvPath = (cwd) => `${defaultProjectsRoot(cwd)}/.orch/env/global.env`;
+const buildClaudeAuthPath = (cwd) => `${defaultProjectsRoot(cwd)}/.orch/auth/claude`;
+const loadProjectAuthEnvText = (project) => Effect.gen(function* (_) {
+    const fs = yield* _(FileSystem.FileSystem);
+    const path = yield* _(Path.Path);
+    const globalEnvPath = buildGlobalEnvPath(process.cwd());
+    const claudeAuthPath = buildClaudeAuthPath(process.cwd());
+    yield* _(ensureEnvFile(fs, path, globalEnvPath));
+    yield* _(ensureEnvFile(fs, path, project.envProjectPath));
+    const globalEnvText = yield* _(readEnvText(fs, globalEnvPath));
+    const projectEnvText = yield* _(readEnvText(fs, project.envProjectPath));
+    return {
+        fs,
+        path,
+        globalEnvPath,
+        projectEnvPath: project.envProjectPath,
+        claudeAuthPath,
+        globalEnvText,
+        projectEnvText
+    };
+});
+export const readProjectAuthSnapshot = (project) => pipe(loadProjectAuthEnvText(project), Effect.flatMap(({ claudeAuthPath, fs, globalEnvPath, globalEnvText, path, projectEnvPath, projectEnvText }) => pipe(countAuthAccountDirectories(fs, path, claudeAuthPath), Effect.map((claudeAuthEntries) => ({
+    projectDir: project.projectDir,
+    projectName: project.displayName,
+    envGlobalPath: globalEnvPath,
+    envProjectPath: projectEnvPath,
+    claudeAuthPath,
+    githubTokenEntries: countKeyEntries(globalEnvText, githubTokenBaseKey),
+    gitTokenEntries: countKeyEntries(globalEnvText, gitTokenBaseKey),
+    claudeAuthEntries,
+    activeGithubLabel: findEnvValue(projectEnvText, projectGithubLabelKey),
+    activeGitLabel: findEnvValue(projectEnvText, projectGitLabelKey),
+    activeClaudeLabel: findEnvValue(projectEnvText, projectClaudeLabelKey)
+})))));
+const missingSecret = (provider, label, envPath) => new AuthError({
+    message: `${provider} not connected: label '${label}' not found in ${envPath}`
+});
+const updateProjectGithubConnect = (spec) => {
+    const key = buildLabeledEnvKey(githubTokenBaseKey, spec.rawLabel);
+    const token = findEnvValue(spec.globalEnvText, key);
+    if (token === null) {
+        return Effect.fail(missingSecret("GitHub token", spec.canonicalLabel, spec.globalEnvPath));
+    }
+    const withGitToken = upsertEnvKey(spec.projectEnvText, "GIT_AUTH_TOKEN", token);
+    const withGhToken = upsertEnvKey(withGitToken, "GH_TOKEN", token);
+    const withoutGitLabel = upsertEnvKey(withGhToken, projectGitLabelKey, "");
+    return Effect.succeed(upsertEnvKey(withoutGitLabel, projectGithubLabelKey, spec.canonicalLabel));
+};
+const clearProjectGitLabels = (envText) => {
+    const withoutGhToken = upsertEnvKey(envText, "GH_TOKEN", "");
+    const withoutGitLabel = upsertEnvKey(withoutGhToken, projectGitLabelKey, "");
+    return upsertEnvKey(withoutGitLabel, projectGithubLabelKey, "");
+};
+const updateProjectGithubDisconnect = (spec) => {
+    const withoutGitToken = upsertEnvKey(spec.projectEnvText, "GIT_AUTH_TOKEN", "");
+    return Effect.succeed(clearProjectGitLabels(withoutGitToken));
+};
+const updateProjectGitConnect = (spec) => {
+    const tokenKey = buildLabeledEnvKey(gitTokenBaseKey, spec.rawLabel);
+    const userKey = buildLabeledEnvKey(gitUserBaseKey, spec.rawLabel);
+    const token = findEnvValue(spec.globalEnvText, tokenKey);
+    if (token === null) {
+        return Effect.fail(missingSecret("Git credentials", spec.canonicalLabel, spec.globalEnvPath));
+    }
+    const defaultUser = findEnvValue(spec.globalEnvText, gitUserBaseKey) ?? defaultGitUser;
+    const user = findEnvValue(spec.globalEnvText, userKey) ?? defaultUser;
+    const withToken = upsertEnvKey(spec.projectEnvText, "GIT_AUTH_TOKEN", token);
+    const withUser = upsertEnvKey(withToken, "GIT_AUTH_USER", user);
+    const withGhToken = upsertEnvKey(withUser, "GH_TOKEN", token);
+    const withGitLabel = upsertEnvKey(withGhToken, projectGitLabelKey, spec.canonicalLabel);
+    return Effect.succeed(upsertEnvKey(withGitLabel, projectGithubLabelKey, spec.canonicalLabel));
+};
+const updateProjectGitDisconnect = (spec) => {
+    const withoutToken = upsertEnvKey(spec.projectEnvText, "GIT_AUTH_TOKEN", "");
+    const withoutUser = upsertEnvKey(withoutToken, "GIT_AUTH_USER", "");
+    return Effect.succeed(clearProjectGitLabels(withoutUser));
+};
+const updateProjectClaudeConnect = (spec) => {
+    const accountLabel = normalizeAccountLabel(spec.rawLabel, "default");
+    const accountPath = `${spec.claudeAuthPath}/${accountLabel}`;
+    return Effect.gen(function* (_) {
+        const exists = yield* _(spec.fs.exists(accountPath));
+        if (!exists) {
+            return yield* _(Effect.fail(missingSecret("Claude Code login", spec.canonicalLabel, spec.claudeAuthPath)));
+        }
+        const hasCredentials = yield* _(hasClaudeAccountCredentials(spec.fs, accountPath), Effect.orElseSucceed(() => false));
+        if (hasCredentials) {
+            return upsertEnvKey(spec.projectEnvText, projectClaudeLabelKey, spec.canonicalLabel);
+        }
+        return yield* _(Effect.fail(missingSecret("Claude Code login", spec.canonicalLabel, spec.claudeAuthPath)));
+    });
+};
+const updateProjectClaudeDisconnect = (spec) => {
+    return Effect.succeed(upsertEnvKey(spec.projectEnvText, projectClaudeLabelKey, ""));
+};
+const resolveProjectEnvUpdate = (flow, spec) => Match.value(flow).pipe(Match.when("ProjectGithubConnect", () => updateProjectGithubConnect(spec)), Match.when("ProjectGithubDisconnect", () => updateProjectGithubDisconnect(spec)), Match.when("ProjectGitConnect", () => updateProjectGitConnect(spec)), Match.when("ProjectGitDisconnect", () => updateProjectGitDisconnect(spec)), Match.when("ProjectClaudeConnect", () => updateProjectClaudeConnect(spec)), Match.when("ProjectClaudeDisconnect", () => updateProjectClaudeDisconnect(spec)), Match.exhaustive);
+export const writeProjectAuthFlow = (project, flow, values) => pipe(loadProjectAuthEnvText(project), Effect.flatMap(({ claudeAuthPath, fs, globalEnvPath, globalEnvText, projectEnvPath, projectEnvText }) => {
+    const rawLabel = values["label"] ?? "";
+    const canonicalLabel = resolveCanonicalLabel(rawLabel);
+    const spec = {
+        fs,
+        rawLabel,
+        canonicalLabel,
+        globalEnvPath,
+        globalEnvText,
+        projectEnvText,
+        claudeAuthPath
+    };
+    const nextProjectEnv = resolveProjectEnvUpdate(flow, spec);
+    const syncMessage = Match.value(flow).pipe(Match.when("ProjectGithubConnect", () => `chore(state): project auth gh ${canonicalLabel} ${project.displayName}`), Match.when("ProjectGithubDisconnect", () => `chore(state): project auth gh logout ${project.displayName}`), Match.when("ProjectGitConnect", () => `chore(state): project auth git ${canonicalLabel} ${project.displayName}`), Match.when("ProjectGitDisconnect", () => `chore(state): project auth git logout ${project.displayName}`), Match.when("ProjectClaudeConnect", () => `chore(state): project auth claude ${canonicalLabel} ${project.displayName}`), Match.when("ProjectClaudeDisconnect", () => `chore(state): project auth claude logout ${project.displayName}`), Match.exhaustive);
+    return pipe(nextProjectEnv, Effect.flatMap((nextText) => fs.writeFileString(projectEnvPath, nextText)), Effect.zipRight(autoSyncState(syncMessage)));
+}), Effect.asVoid);
+export const projectAuthViewSteps = (flow) => flowSteps[flow];
+export const projectAuthMenuLabels = () => projectAuthMenuItems.map((item) => item.label);
+export const projectAuthMenuActionByIndex = (index) => {
+    const item = projectAuthMenuItems[index];
+    return item ? item.action : null;
+};
+export const projectAuthMenuSize = () => projectAuthMenuItems.length;

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

@@ -0,0 +1,124 @@
+import { Effect, Match, pipe } from "effect";
+import { nextBufferValue } from "./menu-buffer-input.js";
+import { handleMenuNumberInput, submitPromptStep } from "./menu-input-utils.js";
+import { projectAuthMenuActionByIndex, projectAuthMenuSize, projectAuthViewSteps, readProjectAuthSnapshot, writeProjectAuthFlow } from "./menu-project-auth-data.js";
+import { resetToMenu } from "./menu-shared.js";
+const startProjectAuthMenu = (project, snapshot, context) => {
+    context.setView({ _tag: "ProjectAuthMenu", selected: 0, project, snapshot });
+    context.setMessage(null);
+};
+const startProjectAuthPrompt = (project, snapshot, flow, context) => {
+    context.setView({
+        _tag: "ProjectAuthPrompt",
+        flow,
+        step: 0,
+        buffer: "",
+        values: {},
+        project,
+        snapshot
+    });
+    context.setMessage(null);
+};
+const loadProjectAuthMenuView = (project, context) => pipe(readProjectAuthSnapshot(project), Effect.tap((snapshot) => Effect.sync(() => {
+    startProjectAuthMenu(project, snapshot, context);
+})), Effect.asVoid);
+const successMessage = (flow, label) => Match.value(flow).pipe(Match.when("ProjectGithubConnect", () => `Connected GitHub label (${label}) to project.`), Match.when("ProjectGithubDisconnect", () => "Disconnected GitHub from project."), Match.when("ProjectGitConnect", () => `Connected Git label (${label}) to project.`), Match.when("ProjectGitDisconnect", () => "Disconnected Git from project."), Match.when("ProjectClaudeConnect", () => `Connected Claude label (${label}) to project.`), Match.when("ProjectClaudeDisconnect", () => "Disconnected Claude from project."), Match.exhaustive);
+const runProjectAuthEffect = (project, flow, values, label, context) => {
+    context.runner.runEffect(pipe(writeProjectAuthFlow(project, flow, values), Effect.zipRight(readProjectAuthSnapshot(project)), Effect.tap((snapshot) => Effect.sync(() => {
+        startProjectAuthMenu(project, snapshot, context);
+        context.setMessage(successMessage(flow, label));
+    })), Effect.asVoid));
+};
+const submitProjectAuthPrompt = (view, context) => {
+    const steps = projectAuthViewSteps(view.flow);
+    submitPromptStep(view, steps, context, () => {
+        startProjectAuthMenu(view.project, view.snapshot, context);
+    }, (nextValues) => {
+        const rawLabel = (nextValues["label"] ?? "").trim();
+        const label = rawLabel.length > 0 ? rawLabel : "default";
+        runProjectAuthEffect(view.project, view.flow, nextValues, label, context);
+    });
+};
+const runProjectAuthAction = (action, view, context) => {
+    if (action === "Back") {
+        resetToMenu(context);
+        return;
+    }
+    if (action === "Refresh") {
+        context.runner.runEffect(loadProjectAuthMenuView(view.project, context));
+        return;
+    }
+    if (action === "ProjectGithubDisconnect" || action === "ProjectGitDisconnect" || action === "ProjectClaudeDisconnect") {
+        runProjectAuthEffect(view.project, action, {}, "default", context);
+        return;
+    }
+    startProjectAuthPrompt(view.project, view.snapshot, action, context);
+};
+const setProjectAuthMenuSelection = (view, selected, context) => {
+    context.setView({ ...view, selected });
+};
+const shiftProjectAuthMenuSelection = (view, delta, context) => {
+    const menuSize = projectAuthMenuSize();
+    const selected = (view.selected + delta + menuSize) % menuSize;
+    setProjectAuthMenuSelection(view, selected, context);
+};
+const runProjectAuthMenuSelection = (selected, view, context) => {
+    const action = projectAuthMenuActionByIndex(selected);
+    if (action === null) {
+        return;
+    }
+    runProjectAuthAction(action, view, context);
+};
+const handleProjectAuthMenuNumberInput = (input, view, context) => {
+    handleMenuNumberInput(input, context, projectAuthMenuActionByIndex, (action) => {
+        runProjectAuthAction(action, view, context);
+    });
+};
+const handleProjectAuthMenuInput = (input, key, view, context) => {
+    if (key.escape) {
+        resetToMenu(context);
+        return;
+    }
+    if (key.upArrow) {
+        shiftProjectAuthMenuSelection(view, -1, context);
+        return;
+    }
+    if (key.downArrow) {
+        shiftProjectAuthMenuSelection(view, 1, context);
+        return;
+    }
+    if (key.return) {
+        runProjectAuthMenuSelection(view.selected, view, context);
+        return;
+    }
+    handleProjectAuthMenuNumberInput(input, view, context);
+};
+const setProjectAuthPromptBuffer = (args) => {
+    const nextBuffer = nextBufferValue(args.input, args.key, args.view.buffer);
+    if (nextBuffer === null) {
+        return;
+    }
+    args.context.setView({ ...args.view, buffer: nextBuffer });
+};
+const handleProjectAuthPromptInput = (input, key, view, context) => {
+    if (key.escape) {
+        startProjectAuthMenu(view.project, view.snapshot, context);
+        return;
+    }
+    if (key.return) {
+        submitProjectAuthPrompt(view, context);
+        return;
+    }
+    setProjectAuthPromptBuffer({ input, key, view, context });
+};
+export const openProjectAuthMenu = (context) => {
+    context.setMessage(`Loading project auth (${context.project.displayName})...`);
+    context.runner.runEffect(loadProjectAuthMenuView(context.project, context));
+};
+export const handleProjectAuthInput = (input, key, view, context) => {
+    if (view._tag === "ProjectAuthMenu") {
+        handleProjectAuthMenuInput(input, key, view, context);
+        return;
+    }
+    handleProjectAuthPromptInput(input, key, view, context);
+};

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

@@ -0,0 +1,45 @@
+import { Box, Text } from "ink";
+import React from "react";
+import { authMenuLabels, authViewSteps, authViewTitle } from "./menu-auth-data.js";
+import { renderMenuHelp, renderPromptLayout, renderSelectableMenuList, resolvePromptState } from "./menu-render-common.js";
+import { renderLayout } from "./menu-render-layout.js";
+const renderCountLine = (title, count) => `${title}: ${count}`;
+export const renderAuthMenu = (snapshot, selected, message) => {
+    const el = React.createElement;
+    const list = renderSelectableMenuList(authMenuLabels(), selected);
+    return renderLayout("docker-git / Auth profiles", [
+        el(Text, null, `Global env: ${snapshot.globalEnvPath}`),
+        el(Text, null, `Claude auth: ${snapshot.claudeAuthPath}`),
+        el(Text, { color: "gray" }, renderCountLine("Entries", snapshot.totalEntries)),
+        el(Text, { color: "gray" }, renderCountLine("GitHub tokens", snapshot.githubTokenEntries)),
+        el(Text, { color: "gray" }, renderCountLine("Git tokens", snapshot.gitTokenEntries)),
+        el(Text, { color: "gray" }, renderCountLine("Git users", snapshot.gitUserEntries)),
+        el(Text, { color: "gray" }, renderCountLine("Claude logins", snapshot.claudeAuthEntries)),
+        el(Box, { flexDirection: "column", marginTop: 1 }, ...list),
+        renderMenuHelp("Use arrows + Enter, or type a number.")
+    ], message);
+};
+export const renderAuthPrompt = (view, message) => {
+    const el = React.createElement;
+    const { prompt, visibleBuffer } = resolvePromptState(authViewSteps(view.flow), view.step, view.buffer);
+    let helpLine = "Enter = next, Esc = cancel.";
+    if (view.flow === "GithubOauth" || view.flow === "ClaudeOauth") {
+        helpLine = "Enter = start OAuth, Esc = cancel.";
+    }
+    else if (view.flow === "ClaudeLogout") {
+        helpLine = "Enter = logout, Esc = cancel.";
+    }
+    return renderPromptLayout({
+        title: `docker-git / Auth / ${authViewTitle(view.flow)}`,
+        header: [
+            el(Text, { color: "gray" }, `Global env: ${view.snapshot.globalEnvPath}`),
+            ...(view.flow === "ClaudeOauth" || view.flow === "ClaudeLogout"
+                ? [el(Text, { color: "gray" }, `Claude auth: ${view.snapshot.claudeAuthPath}`)]
+                : [])
+        ],
+        prompt,
+        visibleBuffer,
+        helpLine,
+        message
+    });
+};

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

@@ -0,0 +1,26 @@
+import { Box, Text } from "ink";
+import React from "react";
+import { renderLayout } from "./menu-render-layout.js";
+export const renderSelectableMenuList = (labels, selected) => {
+    const el = React.createElement;
+    return labels.map((label, index) => el(Text, { key: `${index}-${label}`, color: index === selected ? "green" : "white" }, `${index === selected ? ">" : " "} ${index + 1}) ${label}`));
+};
+export const renderMenuHelp = (primaryLine) => {
+    const el = React.createElement;
+    return el(Box, { marginTop: 1, flexDirection: "column" }, el(Text, { color: "gray" }, primaryLine), el(Text, { color: "gray" }, "Esc returns to the main menu."));
+};
+export const resolvePromptState = (steps, step, buffer) => {
+    const current = steps[step];
+    const prompt = current?.label ?? "Value";
+    const isSecret = current?.secret === true;
+    const visibleBuffer = isSecret ? "*".repeat(buffer.length) : buffer;
+    return { prompt, visibleBuffer };
+};
+export const renderPromptLayout = (args) => {
+    const el = React.createElement;
+    return renderLayout(args.title, [
+        ...args.header,
+        el(Box, { marginTop: 1 }, el(Text, null, `${args.prompt}: `), el(Text, { color: "green" }, args.visibleBuffer)),
+        el(Box, { marginTop: 1, flexDirection: "column" }, el(Text, { color: "gray" }, args.helpLine))
+    ], args.message);
+};

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

@@ -0,0 +1,14 @@
+import { Box, Text } from "ink";
+import React from "react";
+const renderMessage = (message) => {
+    if (!message) {
+        return null;
+    }
+    return React.createElement(Box, { marginTop: 1 }, React.createElement(Text, { color: "magenta" }, message));
+};
+export const renderLayout = (title, body, message) => {
+    const el = React.createElement;
+    const messageView = renderMessage(message);
+    const tail = messageView ? [messageView] : [];
+    return el(Box, { flexDirection: "column", padding: 1, borderStyle: "round" }, el(Text, { color: "cyan", bold: true }, title), ...body, ...tail);
+};

package/dist/src/docker-git/menu-render-project-auth.js

@@ -0,0 +1,37 @@
+import { Box, Text } from "ink";
+import React from "react";
+import { projectAuthMenuLabels, projectAuthViewSteps } from "./menu-project-auth-data.js";
+import { renderMenuHelp, renderPromptLayout, renderSelectableMenuList, resolvePromptState } from "./menu-render-common.js";
+import { renderLayout } from "./menu-render-layout.js";
+const renderActiveLabel = (value) => value ?? "(not set)";
+const renderCountLine = (title, count) => `${title}: ${count}`;
+export const renderProjectAuthMenu = (snapshot, selected, message) => {
+    const el = React.createElement;
+    const list = renderSelectableMenuList(projectAuthMenuLabels(), selected);
+    return renderLayout("docker-git / Project auth", [
+        el(Text, null, `Project: ${snapshot.projectName}`),
+        el(Text, { color: "gray" }, `Dir: ${snapshot.projectDir}`),
+        el(Text, { color: "gray" }, `Project env: ${snapshot.envProjectPath}`),
+        el(Text, { color: "gray" }, `Global env: ${snapshot.envGlobalPath}`),
+        el(Text, { color: "gray" }, `Claude auth: ${snapshot.claudeAuthPath}`),
+        el(Box, { marginTop: 1, flexDirection: "column" }, el(Text, { color: "gray" }, `GitHub label: ${renderActiveLabel(snapshot.activeGithubLabel)}`), el(Text, { color: "gray" }, renderCountLine("Available GitHub tokens", snapshot.githubTokenEntries)), el(Text, { color: "gray" }, `Git label: ${renderActiveLabel(snapshot.activeGitLabel)}`), el(Text, { color: "gray" }, renderCountLine("Available Git tokens", snapshot.gitTokenEntries)), el(Text, { color: "gray" }, `Claude label: ${renderActiveLabel(snapshot.activeClaudeLabel)}`), el(Text, { color: "gray" }, renderCountLine("Available Claude logins", snapshot.claudeAuthEntries))),
+        el(Box, { flexDirection: "column", marginTop: 1 }, ...list),
+        renderMenuHelp("Use arrows + Enter, or type a number from the list.")
+    ], message);
+};
+export const renderProjectAuthPrompt = (view, message) => {
+    const el = React.createElement;
+    const { prompt, visibleBuffer } = resolvePromptState(projectAuthViewSteps(view.flow), view.step, view.buffer);
+    return renderPromptLayout({
+        title: "docker-git / Project auth / Set label",
+        header: [
+            el(Text, { color: "gray" }, `Project: ${view.snapshot.projectName}`),
+            el(Text, { color: "gray" }, `Project env: ${view.snapshot.envProjectPath}`),
+            el(Text, { color: "gray" }, `Global env: ${view.snapshot.envGlobalPath}`)
+        ],
+        prompt,
+        visibleBuffer,
+        helpLine: "Enter = apply, Esc = cancel.",
+        message
+    });
+};

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

@@ -26,8 +26,8 @@ const renderStartedAtCompact = (runtime) => runtime.startedAtEpochMs === null ?
 const renderStartedAtDetailed = (runtime) => runtime.startedAtEpochMs === null ? "not available" : formatUtcTimestamp(runtime.startedAtEpochMs, true);
 const runtimeForProject = (runtimeByProject, item) => runtimeByProject[item.projectDir] ?? stoppedRuntime();
 const renderRuntimeLabel = (runtime) => `${runtime.running ? "running" : "stopped"}, ssh=${runtime.sshSessions}, started=${renderStartedAtCompact(runtime)}`;
-export const selectTitle = (purpose) => Match.value(purpose).pipe(Match.when("Connect", () => "docker-git / Select project"), Match.when("Down", () => "docker-git / Stop container"), Match.when("Info", () => "docker-git / Show connection info"), Match.when("Delete", () => "docker-git / Delete project"), Match.exhaustive);
-export const selectHint = (purpose, connectEnableMcpPlaywright) => Match.value(purpose).pipe(Match.when("Connect", () => `Enter = select + SSH, P = toggle Playwright MCP (${connectEnableMcpPlaywright ? "on" : "off"}), Esc = back`), Match.when("Down", () => "Enter = stop container, Esc = back"), Match.when("Info", () => "Use arrows to browse details, Enter = set active, Esc = back"), Match.when("Delete", () => "Enter = ask/confirm delete, Esc = cancel"), Match.exhaustive);
+export const selectTitle = (purpose) => Match.value(purpose).pipe(Match.when("Connect", () => "docker-git / Select project"), Match.when("Auth", () => "docker-git / Project auth"), Match.when("Down", () => "docker-git / Stop container"), Match.when("Info", () => "docker-git / Show connection info"), Match.when("Delete", () => "docker-git / Delete project"), Match.exhaustive);
+export const selectHint = (purpose, connectEnableMcpPlaywright) => Match.value(purpose).pipe(Match.when("Connect", () => `Enter = select + SSH, P = toggle Playwright MCP (${connectEnableMcpPlaywright ? "on" : "off"}), Esc = back`), Match.when("Auth", () => "Enter = open project auth menu, Esc = back"), Match.when("Down", () => "Enter = stop container, Esc = back"), Match.when("Info", () => "Use arrows to browse details, Enter = set active, Esc = back"), Match.when("Delete", () => "Enter = ask/confirm delete, Esc = cancel"), Match.exhaustive);
 export const buildSelectLabels = (items, selected, purpose, runtimeByProject) => items.map((item, index) => {
     const prefix = index === selected ? ">" : " ";
     const refLabel = formatRepoRef(item.repoRef);
@@ -92,7 +92,14 @@ export const renderSelectDetails = (el, purpose, item, runtimeByProject, connect
     }
     const context = buildDetailsContext(item, runtimeByProject);
     const common = commonRows(el, context);
-    return Match.value(purpose).pipe(Match.when("Connect", () => renderConnectDetails(el, context, common, connectEnableMcpPlaywright)), Match.when("Info", () => renderInfoDetails(el, context, common)), Match.when("Down", () => [
+    return Match.value(purpose).pipe(Match.when("Connect", () => renderConnectDetails(el, context, common, connectEnableMcpPlaywright)), Match.when("Auth", () => [
+        titleRow(el, "Project auth"),
+        ...common,
+        el(Text, { wrap: "wrap" }, `Repo: ${context.item.repoUrl} (${context.refLabel})`),
+        el(Text, { wrap: "wrap" }, `Env global: ${context.item.envGlobalPath}`),
+        el(Text, { wrap: "wrap" }, `Env project: ${context.item.envProjectPath}`),
+        el(Text, { color: "gray", wrap: "wrap" }, "Press Enter to manage labels for this project.")
+    ]), Match.when("Info", () => renderInfoDetails(el, context, common)), Match.when("Down", () => [
         titleRow(el, "Stop container"),
         ...common,
         el(Text, { wrap: "wrap" }, `Repo: ${context.item.repoUrl} (${context.refLabel})`)

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

@@ -1,6 +1,7 @@
 import { Match } from "effect";
 import { Box, Text } from "ink";
 import React from "react";
+import { renderLayout } from "./menu-render-layout.js";
 import { buildSelectLabels, renderSelectDetails, selectHint, selectTitle } from "./menu-render-select.js";
 import { createSteps, menuItems } from "./menu-types.js";
 // CHANGE: render menu views with Ink without JSX
@@ -14,20 +15,8 @@ import { createSteps, menuItems } from "./menu-types.js";
 // INVARIANT: menu renders all items once
 // COMPLEXITY: O(n)
 export const renderStepLabel = (step, defaults) => Match.value(step).pipe(Match.when("repoUrl", () => "Repo URL"), Match.when("repoRef", () => `Repo ref [${defaults.repoRef}]`), Match.when("outDir", () => `Output dir [${defaults.outDir}]`), Match.when("runUp", () => `Run docker compose up now? [${defaults.runUp ? "Y" : "n"}]`), Match.when("mcpPlaywright", () => `Enable Playwright MCP (Chromium sidecar)? [${defaults.enableMcpPlaywright ? "y" : "N"}]`), Match.when("force", () => `Force recreate (overwrite files + wipe volumes)? [${defaults.force ? "y" : "N"}]`), Match.exhaustive);
-const renderMessage = (message) => {
-    if (!message) {
-        return null;
-    }
-    return React.createElement(Box, { marginTop: 1 }, React.createElement(Text, { color: "magenta" }, message));
-};
-const renderLayout = (title, body, message) => {
-    const el = React.createElement;
-    const messageView = renderMessage(message);
-    const tail = messageView ? [messageView] : [];
-    return el(Box, { flexDirection: "column", padding: 1, borderStyle: "round" }, el(Text, { color: "cyan", bold: true }, title), ...body, ...tail);
-};
 const compactElements = (items) => items.filter((item) => item !== null);
-const renderMenuHints = (el) => el(Box, { marginTop: 1, flexDirection: "column" }, el(Text, { color: "gray" }, "Hints:"), el(Text, { color: "gray" }, "  - Paste repo URL to create directly."), el(Text, { color: "gray" }, "  - Aliases: create/c, select/s, info/i, status/ps, logs/l, down/d, down-all/da, delete/del, quit/q"), el(Text, { color: "gray" }, "  - Use arrows and Enter to run."));
+const renderMenuHints = (el) => el(Box, { marginTop: 1, flexDirection: "column" }, el(Text, { color: "gray" }, "Hints:"), el(Text, { color: "gray" }, "  - Paste repo URL to create directly."), el(Text, { color: "gray" }, "  - Aliases: create/c, select/s, auth/a, project-auth/pa, info/i, status/ps, logs/l, down/d, down-all/da, delete/del, quit/q"), el(Text, { color: "gray" }, "  - Use arrows and Enter to run."));
 const renderMenuMessage = (el, message) => {
     if (!message || message.length === 0) {
         return null;
@@ -71,6 +60,8 @@ export const renderCreate = (label, buffer, message, stepIndex, defaults) => {
         el(Box, { marginTop: 1 }, el(Text, { color: "gray" }, "Enter = next, Esc = cancel."))
     ], message);
 };
+export { renderAuthMenu, renderAuthPrompt } from "./menu-render-auth.js";
+export { renderProjectAuthMenu, renderProjectAuthPrompt } from "./menu-render-project-auth.js";
 const computeListWidth = (labels) => {
     const maxLabelWidth = labels.length > 0 ? Math.max(...labels.map((label) => label.length)) : 24;
     return Math.min(Math.max(maxLabelWidth + 2, 28), 54);