@prover-coder-ai/docker-git 1.0.5

package/dist/main.js

@@ -0,0 +1,847 @@
+import { NodeContext, NodeRuntime } from "@effect/platform-node";
+import { Match, Effect, pipe, Data, Either, Duration, Console } from "effect";
+import * as CommandExecutor from "@effect/platform/CommandExecutor";
+import { ExitCode } from "@effect/platform/CommandExecutor";
+import * as Path from "@effect/platform/Path";
+import * as Command from "@effect/platform/Command";
+import * as Chunk from "effect/Chunk";
+import * as Stream from "effect/Stream";
+import * as ParseResult from "@effect/schema/ParseResult";
+import * as Schema from "@effect/schema/Schema";
+import * as TreeFormatter from "@effect/schema/TreeFormatter";
+import * as FileSystem from "@effect/platform/FileSystem";
+const emptyRequest = { _tag: "None" };
+const toCloneRequest = (args) => ({
+  _tag: "Clone",
+  args
+});
+const resolveCloneRequest = (argv, npmLifecycleEvent) => {
+  if (npmLifecycleEvent === "clone") {
+    if (argv.length > 0) {
+      const [first, ...rest] = argv;
+      return first === "clone" ? toCloneRequest(rest) : toCloneRequest(argv);
+    }
+    return toCloneRequest([]);
+  }
+  if (argv.length > 0 && argv[0] === "clone") {
+    return toCloneRequest(argv.slice(1));
+  }
+  return emptyRequest;
+};
+const trimLeftChar = (value, char) => {
+  let start = 0;
+  while (start < value.length && value[start] === char) {
+    start += 1;
+  }
+  return value.slice(start);
+};
+const trimRightChar = (value, char) => {
+  let end = value.length;
+  while (end > 0 && value[end - 1] === char) {
+    end -= 1;
+  }
+  return value.slice(0, end);
+};
+const slugify = (value) => {
+  const normalized = value.trim().toLowerCase().replaceAll(/[^a-z0-9_-]+/g, "-").replaceAll(/-+/g, "-");
+  const withoutLeading = trimLeftChar(normalized, "-");
+  const cleaned = trimRightChar(withoutLeading, "-");
+  return cleaned.length > 0 ? cleaned : "app";
+};
+const deriveRepoSlug = (repoUrl) => {
+  const trimmed = trimRightChar(repoUrl.trim(), "/");
+  if (trimmed.length === 0) {
+    return "app";
+  }
+  const lastSlash = trimmed.lastIndexOf("/");
+  const lastColon = trimmed.lastIndexOf(":");
+  const pivot = Math.max(lastSlash, lastColon);
+  const segment = pivot >= 0 ? trimmed.slice(pivot + 1) : trimmed;
+  const withoutGit = segment.endsWith(".git") ? segment.slice(0, -4) : segment;
+  return slugify(withoutGit);
+};
+const stripGitSuffix = (segment) => segment.endsWith(".git") ? segment.slice(0, -4) : segment;
+const normalizePathParts = (pathPart) => {
+  const cleaned = trimLeftChar(pathPart, "/");
+  if (cleaned.length === 0) {
+    return [];
+  }
+  const rawParts = cleaned.split("/").filter(Boolean);
+  return rawParts.map((part, index) => index === rawParts.length - 1 ? stripGitSuffix(part) : part);
+};
+const extractFromScheme = (trimmed) => {
+  const schemeIndex = trimmed.indexOf("://");
+  if (schemeIndex === -1) {
+    return null;
+  }
+  const afterScheme = trimmed.slice(schemeIndex + 3);
+  const firstSlash = afterScheme.indexOf("/");
+  if (firstSlash === -1) {
+    return [];
+  }
+  return normalizePathParts(afterScheme.slice(firstSlash + 1));
+};
+const extractFromColon = (trimmed) => {
+  const colonIndex = trimmed.indexOf(":");
+  if (colonIndex === -1) {
+    return null;
+  }
+  return normalizePathParts(trimmed.slice(colonIndex + 1));
+};
+const extractFromSlash = (trimmed) => {
+  const slashIndex = trimmed.indexOf("/");
+  if (slashIndex === -1) {
+    return null;
+  }
+  return normalizePathParts(trimmed.slice(slashIndex + 1));
+};
+const extractRepoPathParts = (repoUrl) => {
+  const trimmed = trimRightChar(repoUrl.trim(), "/");
+  if (trimmed.length === 0) {
+    return [];
+  }
+  const fromScheme = extractFromScheme(trimmed);
+  if (fromScheme !== null) {
+    return fromScheme;
+  }
+  const fromColon = extractFromColon(trimmed);
+  if (fromColon !== null) {
+    return fromColon;
+  }
+  const fromSlash = extractFromSlash(trimmed);
+  if (fromSlash !== null) {
+    return fromSlash;
+  }
+  return [stripGitSuffix(trimmed)];
+};
+const normalizeRepoSegment = (segment, fallback) => {
+  const normalized = slugify(segment);
+  return normalized.length > 0 ? normalized : fallback;
+};
+const deriveRepoPathParts = (repoUrl) => {
+  const repoSlug = deriveRepoSlug(repoUrl);
+  const rawParts = extractRepoPathParts(repoUrl);
+  if (rawParts.length === 0) {
+    return { ownerParts: [], repo: repoSlug, pathParts: [repoSlug] };
+  }
+  const rawRepo = rawParts.at(-1) ?? repoSlug;
+  const repo = normalizeRepoSegment(rawRepo, repoSlug);
+  const ownerParts = rawParts.slice(0, -1).map((part) => normalizeRepoSegment(part, "org")).filter((part) => part.length > 0);
+  const pathParts = ownerParts.length > 0 ? [...ownerParts, repo] : [repo];
+  return { ownerParts, repo, pathParts };
+};
+const defaultTemplateConfig = {
+  envGlobalPath: "./.docker-git/.orch/env/global.env",
+  envProjectPath: "./.orch/env/project.env",
+  codexSharedAuthPath: "./.docker-git/.orch/auth/codex",
+  enableMcpPlaywright: false
+};
+const formatParseError = (error) => Match.value(error).pipe(Match.when({ _tag: "UnknownCommand" }, ({ command }) => `Unknown command: ${command}`), Match.when({ _tag: "UnknownOption" }, ({ option }) => `Unknown option: ${option}`), Match.when({ _tag: "MissingOptionValue" }, ({ option }) => `Missing value for option: ${option}`), Match.when({ _tag: "MissingRequiredOption" }, ({ option }) => `Missing required option: ${option}`), Match.when({ _tag: "InvalidOption" }, ({ option, reason }) => `Invalid option ${option}: ${reason}`), Match.when({ _tag: "UnexpectedArgument" }, ({ value }) => `Unexpected argument: ${value}`), Match.exhaustive);
+const buildCommand = (spec, stdout, stderr, stdin = "pipe") => pipe(Command.make(spec.command, ...spec.args), Command.workingDirectory(spec.cwd), spec.env ? Command.env(spec.env) : (value) => value, Command.stdin(stdin), Command.stdout(stdout), Command.stderr(stderr));
+const ensureExitCode = (exitCode, okExitCodes, onFailure) => okExitCodes.includes(exitCode) ? Effect.succeed(exitCode) : Effect.fail(onFailure(exitCode));
+const runCommandWithExitCodes = (spec, okExitCodes, onFailure) => Effect.gen(function* (_) {
+  const exitCode = yield* _(Command.exitCode(buildCommand(spec, "inherit", "inherit", "inherit")));
+  const numericExitCode = Number(exitCode);
+  yield* _(ensureExitCode(numericExitCode, okExitCodes, onFailure));
+});
+const runCommandExitCode = (spec) => Effect.map(Command.exitCode(buildCommand(spec, "pipe", "pipe", "inherit")), Number);
+const collectUint8Array = (chunks) => Chunk.reduce(chunks, new Uint8Array(), (acc, curr) => {
+  const next = new Uint8Array(acc.length + curr.length);
+  next.set(acc);
+  next.set(curr, acc.length);
+  return next;
+});
+const runCommandCapture = (spec, okExitCodes, onFailure) => Effect.scoped(Effect.gen(function* (_) {
+  const executor = yield* _(CommandExecutor.CommandExecutor);
+  const process2 = yield* _(executor.start(buildCommand(spec, "pipe", "pipe", "pipe")));
+  const bytes = yield* _(pipe(process2.stdout, Stream.runCollect, Effect.map((chunks) => collectUint8Array(chunks))));
+  const exitCode = yield* _(process2.exitCode);
+  yield* _(ensureExitCode(Number(exitCode), okExitCodes, onFailure));
+  return new TextDecoder("utf-8").decode(bytes);
+}));
+class FileExistsError extends Data.TaggedError("FileExistsError") {
+}
+class ConfigNotFoundError extends Data.TaggedError("ConfigNotFoundError") {
+}
+class ConfigDecodeError extends Data.TaggedError("ConfigDecodeError") {
+}
+class InputCancelledError extends Data.TaggedError("InputCancelledError") {
+}
+class InputReadError extends Data.TaggedError("InputReadError") {
+}
+class DockerCommandError extends Data.TaggedError("DockerCommandError") {
+}
+class CloneFailedError extends Data.TaggedError("CloneFailedError") {
+}
+class PortProbeError extends Data.TaggedError("PortProbeError") {
+}
+class CommandFailedError extends Data.TaggedError("CommandFailedError") {
+}
+class AuthError extends Data.TaggedError("AuthError") {
+}
+const successExitCode$1 = Number(ExitCode(0));
+const readCloneRequest = Effect.sync(() => resolveCloneRequest(process.argv.slice(2), process.env["npm_lifecycle_event"]));
+const runDockerGitClone = (args) => Effect.gen(function* (_) {
+  const path = yield* _(Path.Path);
+  const workspaceRoot = process.cwd();
+  const appRoot = path.join(workspaceRoot, "packages", "app");
+  const dockerGitCli = path.join(appRoot, "dist", "src", "docker-git", "main.js");
+  const buildLabel = `pnpm -C ${appRoot} build:docker-git`;
+  const cloneLabel = `node ${dockerGitCli} clone`;
+  yield* _(runCommandWithExitCodes({ cwd: workspaceRoot, command: "pnpm", args: ["-C", appRoot, "build:docker-git"] }, [successExitCode$1], (exitCode) => new CommandFailedError({ command: buildLabel, exitCode })));
+  yield* _(runCommandWithExitCodes({ cwd: workspaceRoot, command: "node", args: [dockerGitCli, "clone", ...args] }, [successExitCode$1], (exitCode) => new CommandFailedError({ command: cloneLabel, exitCode })));
+});
+const resolveBaseDir = (baseDir) => Effect.gen(function* (_) {
+  const fs = yield* _(FileSystem.FileSystem);
+  const path = yield* _(Path.Path);
+  const resolved = path.resolve(baseDir);
+  return { fs, path, resolved };
+});
+const TemplateConfigSchema = Schema.Struct({
+  containerName: Schema.String,
+  serviceName: Schema.String,
+  sshUser: Schema.String,
+  sshPort: Schema.Number.pipe(Schema.int()),
+  repoUrl: Schema.String,
+  repoRef: Schema.String,
+  targetDir: Schema.String,
+  volumeName: Schema.String,
+  authorizedKeysPath: Schema.String,
+  envGlobalPath: Schema.optionalWith(Schema.String, {
+    default: () => defaultTemplateConfig.envGlobalPath
+  }),
+  envProjectPath: Schema.optionalWith(Schema.String, {
+    default: () => defaultTemplateConfig.envProjectPath
+  }),
+  codexAuthPath: Schema.String,
+  codexSharedAuthPath: Schema.optionalWith(Schema.String, {
+    default: () => defaultTemplateConfig.codexSharedAuthPath
+  }),
+  codexHome: Schema.String,
+  enableMcpPlaywright: Schema.optionalWith(Schema.Boolean, {
+    default: () => defaultTemplateConfig.enableMcpPlaywright
+  }),
+  pnpmVersion: Schema.String
+});
+const ProjectConfigSchema = Schema.Struct({
+  schemaVersion: Schema.Literal(1),
+  template: TemplateConfigSchema
+});
+const ProjectConfigJsonSchema = Schema.parseJson(ProjectConfigSchema);
+const decodeProjectConfig = (path, input) => Either.match(ParseResult.decodeUnknownEither(ProjectConfigJsonSchema)(input), {
+  onLeft: (issue) => Effect.fail(new ConfigDecodeError({
+    path,
+    message: TreeFormatter.formatIssueSync(issue)
+  })),
+  onRight: (value) => Effect.succeed(value)
+});
+const readProjectConfig = (baseDir) => Effect.gen(function* (_) {
+  const { fs, path, resolved } = yield* _(resolveBaseDir(baseDir));
+  const configPath = path.join(resolved, "docker-git.json");
+  const exists = yield* _(fs.exists(configPath));
+  if (!exists) {
+    return yield* _(Effect.fail(new ConfigNotFoundError({ path: configPath })));
+  }
+  const contents = yield* _(fs.readFileString(configPath));
+  return yield* _(decodeProjectConfig(configPath, contents));
+});
+const composeSpec = (cwd, args) => ({
+  cwd,
+  command: "docker",
+  args: ["compose", "--ansi", "never", "--progress", "plain", ...args]
+});
+const runCompose = (cwd, args, okExitCodes) => runCommandWithExitCodes(composeSpec(cwd, args), okExitCodes, (exitCode) => new DockerCommandError({ exitCode }));
+const runComposeCapture = (cwd, args, okExitCodes) => runCommandCapture(composeSpec(cwd, args), okExitCodes, (exitCode) => new DockerCommandError({ exitCode }));
+const runDockerComposeDown = (cwd) => runCompose(cwd, ["down"], [Number(ExitCode(0))]);
+const runDockerComposePsFormatted = (cwd) => runComposeCapture(cwd, ["ps", "--format", "{{.Name}}	{{.Status}}	{{.Ports}}	{{.Image}}"], [Number(ExitCode(0))]);
+const runDockerPsNames = (cwd) => pipe(runCommandCapture({
+  cwd,
+  command: "docker",
+  args: ["ps", "--format", "{{.Names}}"]
+}, [Number(ExitCode(0))], (exitCode) => new CommandFailedError({ command: "docker ps", exitCode })), Effect.map((output) => output.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0)));
+const splitLines = (input) => input.replaceAll("\r\n", "\n").replaceAll("\r", "\n").split("\n");
+const isAlpha = (char) => {
+  const code = char.codePointAt(0) ?? 0;
+  return code >= 65 && code <= 90 || code >= 97 && code <= 122;
+};
+const isDigit = (char) => {
+  const code = char.codePointAt(0) ?? 0;
+  return code >= 48 && code <= 57;
+};
+const isValidFirstChar = (char) => isAlpha(char) || char === "_";
+const isValidEnvChar = (char) => isAlpha(char) || isDigit(char) || char === "_";
+const hasOnlyValidChars = (value) => {
+  for (const char of value) {
+    if (!isValidEnvChar(char)) {
+      return false;
+    }
+  }
+  return true;
+};
+const isEnvKey = (value) => {
+  if (value.length === 0) {
+    return false;
+  }
+  const first = value[0] ?? "";
+  if (!isValidFirstChar(first)) {
+    return false;
+  }
+  return hasOnlyValidChars(value.slice(1));
+};
+const parseEnvLine = (line) => {
+  const trimmed = line.trim();
+  if (trimmed.length === 0 || trimmed.startsWith("#")) {
+    return null;
+  }
+  const raw = trimmed.startsWith("export ") ? trimmed.slice("export ".length).trimStart() : trimmed;
+  const eqIndex = raw.indexOf("=");
+  if (eqIndex <= 0) {
+    return null;
+  }
+  const key = raw.slice(0, eqIndex).trim();
+  if (!isEnvKey(key)) {
+    return null;
+  }
+  const value = raw.slice(eqIndex + 1).trim();
+  return { key, value };
+};
+const parseEnvEntries = (input) => {
+  const entries = [];
+  for (const line of splitLines(input)) {
+    const parsed = parseEnvLine(line);
+    if (parsed) {
+      entries.push(parsed);
+    }
+  }
+  return entries;
+};
+const resolveAuthorizedKeysPath = (path, baseDir, authorizedKeysPath) => path.isAbsolute(authorizedKeysPath) ? authorizedKeysPath : path.resolve(baseDir, authorizedKeysPath);
+const resolveHomeDir = () => {
+  const raw = process.env["HOME"] ?? process.env["USERPROFILE"];
+  const home = raw?.trim() ?? "";
+  return home.length > 0 ? home : null;
+};
+const expandHome = (value, home) => {
+  if (home === null) {
+    return value;
+  }
+  if (value === "~") {
+    return home;
+  }
+  if (value.startsWith("~/") || value.startsWith("~\\")) {
+    return `${home}${value.slice(1)}`;
+  }
+  return value;
+};
+const trimTrailingSlash = (value) => {
+  let end = value.length;
+  while (end > 0) {
+    const char = value[end - 1];
+    if (char !== "/" && char !== "\\") {
+      break;
+    }
+    end -= 1;
+  }
+  return value.slice(0, end);
+};
+const defaultProjectsRoot = (cwd) => {
+  const home = resolveHomeDir();
+  const explicit = process.env["DOCKER_GIT_PROJECTS_ROOT"]?.trim();
+  if (explicit && explicit.length > 0) {
+    return expandHome(explicit, home);
+  }
+  if (home !== null) {
+    return `${trimTrailingSlash(home)}/.docker-git`;
+  }
+  return `${cwd}/.docker-git`;
+};
+const normalizeRelativePath = (value) => value.replaceAll("\\", "/").replace(/^\.\//, "").trim();
+const resolvePathFromCwd = (path, cwd, targetPath) => path.isAbsolute(targetPath) ? targetPath : (() => {
+  const projectsRoot = path.resolve(defaultProjectsRoot(cwd));
+  const normalized = normalizeRelativePath(targetPath);
+  if (normalized === ".docker-git") {
+    return projectsRoot;
+  }
+  const prefix = ".docker-git/";
+  if (normalized.startsWith(prefix)) {
+    return path.join(projectsRoot, normalized.slice(prefix.length));
+  }
+  return path.resolve(cwd, targetPath);
+})();
+const findExistingUpwards = (fs, path, startDir, fileName, maxDepth) => Effect.gen(function* (_) {
+  let current = startDir;
+  for (let depth = 0; depth <= maxDepth; depth += 1) {
+    const candidate = path.join(current, fileName);
+    const exists = yield* _(fs.exists(candidate));
+    if (exists) {
+      return candidate;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+  return null;
+});
+const resolveEnvPath = (key) => {
+  const value = process.env[key]?.trim();
+  return value && value.length > 0 ? value : null;
+};
+const findExistingPath = (fs, candidate) => candidate === null ? Effect.succeed(null) : Effect.flatMap(fs.exists(candidate), (exists) => exists ? Effect.succeed(candidate) : Effect.succeed(null));
+const findFirstExisting = (fs, candidates) => Effect.gen(function* (_) {
+  for (const candidate of candidates) {
+    const existing = yield* _(findExistingPath(fs, candidate));
+    if (existing !== null) {
+      return existing;
+    }
+  }
+  return null;
+});
+const findKeyByPriority = (fs, path, cwd, spec) => Effect.gen(function* (_) {
+  const envPath = resolveEnvPath(spec.envVar);
+  const envExisting = yield* _(findExistingPath(fs, envPath));
+  if (envExisting !== null) {
+    return envExisting;
+  }
+  const devKey = yield* _(findExistingUpwards(fs, path, cwd, spec.devKeyName, 6));
+  if (devKey !== null) {
+    return devKey;
+  }
+  if (spec.fallbackName !== void 0) {
+    const fallback = yield* _(findExistingUpwards(fs, path, cwd, spec.fallbackName, 6));
+    if (fallback !== null) {
+      return fallback;
+    }
+  }
+  const home = resolveEnvPath("HOME");
+  if (home === null) {
+    return null;
+  }
+  return yield* _(findFirstExisting(fs, spec.homeCandidates.map((candidate) => path.join(home, ".ssh", candidate))));
+});
+const sshPrivateKeySpec = {
+  envVar: "DOCKER_GIT_SSH_KEY",
+  devKeyName: "dev_ssh_key",
+  homeCandidates: ["id_ed25519", "id_rsa"]
+};
+const makeKeyFinder = (spec) => (fs, path, cwd) => findKeyByPriority(fs, path, cwd, spec);
+const findSshPrivateKey = makeKeyFinder(sshPrivateKeySpec);
+const withFsPathContext = (run) => Effect.gen(function* (_) {
+  const fs = yield* _(FileSystem.FileSystem);
+  const path = yield* _(Path.Path);
+  return yield* _(run({ fs, path, cwd: process.cwd() }));
+});
+const formatConnectionInfo = (cwd, config, authorizedKeysPath, authorizedKeysExists, sshCommand) => `Project directory: ${cwd}
+Container: ${config.template.containerName}
+Service: ${config.template.serviceName}
+SSH command: ${sshCommand}
+Repo: ${config.template.repoUrl} (${config.template.repoRef})
+Workspace: ${config.template.targetDir}
+Authorized keys: ${authorizedKeysPath}${authorizedKeysExists ? "" : " (missing)"}
+Env global: ${config.template.envGlobalPath}
+Env project: ${config.template.envProjectPath}
+Codex auth: ${config.template.codexAuthPath} -> ${config.template.codexHome}`;
+const successExitCode = Number(ExitCode(0));
+const gitBaseEnv = {
+  // Avoid blocking on interactive credential prompts in CI / TUI contexts.
+  GIT_TERMINAL_PROMPT: "0"
+};
+const git = (cwd, args, env = gitBaseEnv) => runCommandWithExitCodes({ cwd, command: "git", args, env }, [successExitCode], (exitCode) => new CommandFailedError({ command: `git ${args[0] ?? ""}`, exitCode }));
+const gitExitCode = (cwd, args, env = gitBaseEnv) => runCommandExitCode({ cwd, command: "git", args, env });
+const gitCapture = (cwd, args, env = gitBaseEnv) => runCommandCapture({ cwd, command: "git", args, env }, [successExitCode], (exitCode) => new CommandFailedError({ command: `git ${args[0] ?? ""}`, exitCode }));
+const githubTokenKey = "GITHUB_TOKEN";
+const isGithubHttpsRemote = (url) => /^https:\/\/github\.com\//.test(url.trim());
+const resolveTokenFromProcessEnv = () => {
+  const github = process.env["GITHUB_TOKEN"];
+  if (github !== void 0) {
+    const trimmed = github.trim();
+    if (trimmed.length > 0) {
+      return trimmed;
+    }
+  }
+  const gh = process.env["GH_TOKEN"];
+  if (gh !== void 0) {
+    const trimmed = gh.trim();
+    if (trimmed.length > 0) {
+      return trimmed;
+    }
+  }
+  return null;
+};
+const findTokenInEnvEntries = (entries) => {
+  const directEntry = entries.find((e) => e.key === githubTokenKey);
+  if (directEntry !== void 0) {
+    const direct = directEntry.value.trim();
+    if (direct.length > 0) {
+      return direct;
+    }
+  }
+  const labeledEntry = entries.find((e) => e.key.startsWith("GITHUB_TOKEN__"));
+  if (labeledEntry !== void 0) {
+    const labeled = labeledEntry.value.trim();
+    if (labeled.length > 0) {
+      return labeled;
+    }
+  }
+  return null;
+};
+const resolveGithubToken = (fs, path, root) => Effect.gen(function* (_) {
+  const fromEnv = resolveTokenFromProcessEnv();
+  if (fromEnv !== null) {
+    return fromEnv;
+  }
+  const envPath = path.join(root, ".orch", "env", "global.env");
+  const exists = yield* _(fs.exists(envPath));
+  if (!exists) {
+    return null;
+  }
+  const text = yield* _(fs.readFileString(envPath));
+  return findTokenInEnvEntries(parseEnvEntries(text));
+});
+const withGithubAskpassEnv = (token, use) => Effect.scoped(Effect.gen(function* (_) {
+  const fs = yield* _(FileSystem.FileSystem);
+  const askpassPath = yield* _(fs.makeTempFileScoped({ prefix: "docker-git-askpass-" }));
+  const contents = [
+    "#!/bin/sh",
+    'case "$1" in',
+    '  *Username*) echo "x-access-token" ;;',
+    '  *Password*) echo "${DOCKER_GIT_GITHUB_TOKEN}" ;;',
+    '  *) echo "${DOCKER_GIT_GITHUB_TOKEN}" ;;',
+    "esac",
+    ""
+  ].join("\n");
+  yield* _(fs.writeFileString(askpassPath, contents));
+  yield* _(fs.chmod(askpassPath, 448));
+  const env = {
+    ...gitBaseEnv,
+    DOCKER_GIT_GITHUB_TOKEN: token,
+    GIT_ASKPASS: askpassPath,
+    GIT_ASKPASS_REQUIRE: "force"
+  };
+  return yield* _(use(env));
+}));
+const isDockerGitConfig = (entry) => entry.endsWith("docker-git.json");
+const shouldSkipDir = (entry) => entry === ".git" || entry === ".orch";
+const processDockerGitEntry = (fs, path, dir, entry, state) => Effect.gen(function* (_) {
+  if (shouldSkipDir(entry)) {
+    return;
+  }
+  const resolved = path.join(dir, entry);
+  const info = yield* _(fs.stat(resolved));
+  if (info.type === "Directory") {
+    state.stack.push(resolved);
+    return;
+  }
+  if (info.type === "File" && isDockerGitConfig(entry)) {
+    state.results.push(resolved);
+  }
+}).pipe(Effect.asVoid);
+const findDockerGitConfigPaths = (fs, path, rootDir) => Effect.gen(function* (_) {
+  const exists = yield* _(fs.exists(rootDir));
+  if (!exists) {
+    return [];
+  }
+  const results = [];
+  const stack = [rootDir];
+  const state = { stack, results };
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    if (dir === void 0) {
+      break;
+    }
+    const entries = yield* _(fs.readDirectory(dir));
+    for (const entry of entries) {
+      yield* _(processDockerGitEntry(fs, path, dir, entry, state));
+    }
+  }
+  return results;
+});
+const resolveStateRoot = (path, cwd) => path.resolve(defaultProjectsRoot(cwd));
+Effect.gen(function* (_) {
+  const path = yield* _(Path.Path);
+  const cwd = process.cwd();
+  const root = resolveStateRoot(path, cwd);
+  yield* _(Effect.log(root));
+}).pipe(Effect.asVoid);
+Effect.gen(function* (_) {
+  const path = yield* _(Path.Path);
+  const root = resolveStateRoot(path, process.cwd());
+  const output = yield* _(gitCapture(root, ["status", "-sb", "--porcelain=v1"], gitBaseEnv));
+  yield* _(Effect.log(output.trim().length > 0 ? output.trimEnd() : "(clean)"));
+}).pipe(Effect.asVoid);
+Effect.gen(function* (_) {
+  const fs = yield* _(FileSystem.FileSystem);
+  const path = yield* _(Path.Path);
+  const root = resolveStateRoot(path, process.cwd());
+  const originUrlExit = yield* _(gitExitCode(root, ["remote", "get-url", "origin"], gitBaseEnv));
+  if (originUrlExit !== successExitCode) {
+    yield* _(git(root, ["pull", "--rebase"], gitBaseEnv));
+    return;
+  }
+  const originUrl = yield* _(gitCapture(root, ["remote", "get-url", "origin"], gitBaseEnv).pipe(Effect.map((value) => value.trim())));
+  const token = yield* _(resolveGithubToken(fs, path, root));
+  const effect = token && token.length > 0 && isGithubHttpsRemote(originUrl) ? withGithubAskpassEnv(token, (env) => git(root, ["pull", "--rebase"], env)) : git(root, ["pull", "--rebase"], gitBaseEnv);
+  yield* _(effect);
+}).pipe(Effect.asVoid);
+Effect.gen(function* (_) {
+  const fs = yield* _(FileSystem.FileSystem);
+  const path = yield* _(Path.Path);
+  const root = resolveStateRoot(path, process.cwd());
+  const originUrlExit = yield* _(gitExitCode(root, ["remote", "get-url", "origin"], gitBaseEnv));
+  if (originUrlExit !== successExitCode) {
+    yield* _(git(root, ["push", "-u", "origin", "HEAD"], gitBaseEnv));
+    return;
+  }
+  const originUrl = yield* _(gitCapture(root, ["remote", "get-url", "origin"], gitBaseEnv).pipe(Effect.map((value) => value.trim())));
+  const token = yield* _(resolveGithubToken(fs, path, root));
+  const effect = token && token.length > 0 && isGithubHttpsRemote(originUrl) ? withGithubAskpassEnv(token, (env) => git(root, ["push", "-u", "origin", "HEAD"], env)) : git(root, ["push", "-u", "origin", "HEAD"], gitBaseEnv);
+  yield* _(effect);
+}).pipe(Effect.asVoid);
+const isParseError = (error) => error._tag === "UnknownCommand" || error._tag === "UnknownOption" || error._tag === "MissingOptionValue" || error._tag === "MissingRequiredOption" || error._tag === "InvalidOption" || error._tag === "UnexpectedArgument";
+const renderPrimaryError = (error) => {
+  if (error._tag === "FileExistsError") {
+    return `File already exists: ${error.path} (use --force to overwrite)`;
+  }
+  if (error._tag === "DockerCommandError") {
+    return [
+      `docker compose failed with exit code ${error.exitCode}`,
+      "Hint: ensure Docker daemon is running and current user can access /var/run/docker.sock (for example via the docker group)."
+    ].join("\n");
+  }
+  if (error._tag === "CloneFailedError") {
+    return `Clone failed for ${error.repoUrl} (${error.repoRef}) into ${error.targetDir}`;
+  }
+  if (error._tag === "PortProbeError") {
+    return `SSH port check failed for ${error.port}: ${error.message}`;
+  }
+  if (error._tag === "CommandFailedError") {
+    return `${error.command} failed with exit code ${error.exitCode}`;
+  }
+  if (error._tag === "AuthError") {
+    return error.message;
+  }
+  return null;
+};
+const renderConfigError = (error) => {
+  if (error._tag === "ConfigNotFoundError") {
+    return `docker-git.json not found: ${error.path} (run docker-git create in that directory)`;
+  }
+  if (error._tag === "ConfigDecodeError") {
+    return `Invalid docker-git.json at ${error.path}: ${error.message}`;
+  }
+  return null;
+};
+const renderInputError = (error) => {
+  if (error._tag === "InputCancelledError") {
+    return "Input cancelled.";
+  }
+  if (error._tag === "InputReadError") {
+    return `Input error: ${error.message}`;
+  }
+  return null;
+};
+const renderNonParseError = (error) => renderPrimaryError(error) ?? renderConfigError(error) ?? renderInputError(error) ?? error.message;
+const renderError = (error) => {
+  if (isParseError(error)) {
+    return formatParseError(error);
+  }
+  return renderNonParseError(error);
+};
+const sshOptions = "-tt -Y -o LogLevel=ERROR -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null";
+const buildSshCommand = (config, sshKey) => sshKey === null ? `ssh ${sshOptions} -p ${config.sshPort} ${config.sshUser}@localhost` : `ssh -i ${sshKey} ${sshOptions} -p ${config.sshPort} ${config.sshUser}@localhost`;
+const loadProjectBase = (configPath) => Effect.gen(function* (_) {
+  const { fs, path, resolved } = yield* _(resolveBaseDir(configPath));
+  const projectDir = path.dirname(resolved);
+  const config = yield* _(readProjectConfig(projectDir));
+  return { fs, path, projectDir, config };
+});
+const findProjectConfigPaths = (projectsRoot) => withFsPathContext(({ fs, path }) => findDockerGitConfigPaths(fs, path, path.resolve(projectsRoot)));
+const loadProjectSummary = (configPath, sshKey) => Effect.gen(function* (_) {
+  const { config, fs, path, projectDir } = yield* _(loadProjectBase(configPath));
+  const resolvedAuthorizedKeys = resolveAuthorizedKeysPath(path, projectDir, config.template.authorizedKeysPath);
+  const authExists = yield* _(fs.exists(resolvedAuthorizedKeys));
+  const sshCommand = buildSshCommand(config.template, sshKey);
+  return {
+    projectDir,
+    config,
+    sshCommand,
+    authorizedKeysPath: resolvedAuthorizedKeys,
+    authorizedKeysExists: authExists
+  };
+});
+const loadProjectStatus = (configPath) => Effect.gen(function* (_) {
+  const { config, projectDir } = yield* _(loadProjectBase(configPath));
+  return { projectDir, config };
+});
+const renderProjectSummary = (summary) => formatConnectionInfo(summary.projectDir, summary.config, summary.authorizedKeysPath, summary.authorizedKeysExists, summary.sshCommand);
+const formatDisplayName = (repoUrl) => {
+  const parts = deriveRepoPathParts(repoUrl);
+  if (parts.pathParts.length > 0) {
+    return parts.pathParts.join("/");
+  }
+  return repoUrl;
+};
+const loadProjectItem = (configPath, sshKey) => Effect.gen(function* (_) {
+  const { config, fs, path, projectDir } = yield* _(loadProjectBase(configPath));
+  const template = config.template;
+  const resolvedAuthorizedKeys = resolveAuthorizedKeysPath(path, projectDir, template.authorizedKeysPath);
+  const authExists = yield* _(fs.exists(resolvedAuthorizedKeys));
+  const sshCommand = buildSshCommand(template, sshKey);
+  const displayName = formatDisplayName(template.repoUrl);
+  return {
+    projectDir,
+    displayName,
+    repoUrl: template.repoUrl,
+    repoRef: template.repoRef,
+    containerName: template.containerName,
+    serviceName: template.serviceName,
+    sshUser: template.sshUser,
+    sshPort: template.sshPort,
+    targetDir: template.targetDir,
+    sshCommand,
+    sshKeyPath: sshKey,
+    authorizedKeysPath: resolvedAuthorizedKeys,
+    authorizedKeysExists: authExists,
+    envGlobalPath: resolvePathFromCwd(path, projectDir, template.envGlobalPath),
+    envProjectPath: resolvePathFromCwd(path, projectDir, template.envProjectPath),
+    codexAuthPath: resolvePathFromCwd(path, projectDir, template.codexAuthPath),
+    codexHome: template.codexHome
+  };
+});
+const renderProjectStatusHeader = (status) => `Project: ${status.projectDir}`;
+const skipWithWarning = (configPath) => (error) => pipe(Effect.logWarning(`Skipping ${configPath}: ${renderError(error)}`), Effect.as(null));
+const forEachProjectStatus = (configPaths, run) => Effect.gen(function* (_) {
+  for (const configPath of configPaths) {
+    const status = yield* _(loadProjectStatus(configPath).pipe(Effect.matchEffect({
+      onFailure: skipWithWarning(configPath),
+      onSuccess: (value) => Effect.succeed(value)
+    })));
+    if (status === null) {
+      continue;
+    }
+    yield* _(run(status));
+  }
+}).pipe(Effect.asVoid);
+const normalizeCell = (value) => value?.trim() ?? "-";
+const parseComposeLine = (line) => {
+  const [name, status, ports, image] = line.split("	");
+  return {
+    name: normalizeCell(name),
+    status: normalizeCell(status),
+    ports: normalizeCell(ports),
+    image: normalizeCell(image)
+  };
+};
+const parseComposePsOutput = (raw) => {
+  const lines = raw.split(/\r?\n/).map((line) => line.trimEnd()).filter((line) => line.length > 0);
+  return lines.map((line) => parseComposeLine(line));
+};
+const padRight = (value, width) => value.length >= width ? value : `${value}${" ".repeat(width - value.length)}`;
+const formatComposeRows = (entries) => {
+  if (entries.length === 0) {
+    return "  status: not running";
+  }
+  const nameWidth = Math.min(24, Math.max(...entries.map((row) => row.name.length), "name".length));
+  const statusWidth = Math.min(28, Math.max(...entries.map((row) => row.status.length), "status".length));
+  const portsWidth = Math.min(28, Math.max(...entries.map((row) => row.ports.length), "ports".length));
+  const header = `  ${padRight("name", nameWidth)}  ${padRight("status", statusWidth)}  ${padRight("ports", portsWidth)}  image`;
+  const lines = entries.map((row) => `  ${padRight(row.name, nameWidth)}  ${padRight(row.status, statusWidth)}  ${padRight(row.ports, portsWidth)}  ${row.image}`);
+  return [header, ...lines].join("\n");
+};
+const loadProjectIndex = () => Effect.gen(function* (_) {
+  const projectsRoot = defaultProjectsRoot(process.cwd());
+  const configPaths = yield* _(findProjectConfigPaths(projectsRoot));
+  if (configPaths.length === 0) {
+    yield* _(Effect.log(`No docker-git projects found in ${projectsRoot}`));
+    return null;
+  }
+  return { projectsRoot, configPaths };
+});
+const withProjectIndexAndSsh = (run) => pipe(loadProjectIndex(), Effect.flatMap((index) => index === null ? Effect.succeed(null) : Effect.gen(function* (_) {
+  const fs = yield* _(FileSystem.FileSystem);
+  const path = yield* _(Path.Path);
+  const sshKey = yield* _(findSshPrivateKey(fs, path, process.cwd()));
+  return yield* _(run(index, sshKey));
+})));
+pipe(loadProjectIndex(), Effect.flatMap((index) => index === null ? Effect.void : forEachProjectStatus(index.configPaths, (status) => pipe(Effect.log(renderProjectStatusHeader(status)), Effect.zipRight(runDockerComposeDown(status.projectDir).pipe(Effect.catchTag("DockerCommandError", (error) => Effect.logWarning(`docker compose down failed for ${status.projectDir}: ${renderError(error)}`))))))), Effect.asVoid);
+const listProjects = pipe(withProjectIndexAndSsh((index, sshKey) => Effect.gen(function* (_) {
+  const available = [];
+  for (const configPath of index.configPaths) {
+    const summary = yield* _(loadProjectSummary(configPath, sshKey).pipe(Effect.matchEffect({
+      onFailure: skipWithWarning(configPath),
+      onSuccess: (value) => Effect.succeed(value)
+    })));
+    if (summary !== null) {
+      available.push(summary);
+    }
+  }
+  if (available.length === 0) {
+    yield* _(Effect.log(`No readable docker-git projects found in ${index.projectsRoot}`));
+    return;
+  }
+  yield* _(Effect.log(`Found ${available.length} docker-git project(s) in ${index.projectsRoot}`));
+  for (const summary of available) {
+    yield* _(Effect.log(renderProjectSummary(summary)));
+  }
+})), Effect.asVoid);
+const emptySummaries = () => [];
+const emptyItems = () => [];
+const collectProjectValues = (configPaths, sshKey, load, toValue) => Effect.gen(function* (_) {
+  const available = [];
+  for (const configPath of configPaths) {
+    const value = yield* _(load(configPath, sshKey).pipe(Effect.matchEffect({
+      onFailure: () => Effect.succeed(null),
+      onSuccess: (item) => Effect.succeed(toValue(item))
+    })));
+    if (value !== null) {
+      available.push(value);
+    }
+  }
+  return available;
+});
+const listProjectValues = (load, toValue, empty) => pipe(withProjectIndexAndSsh((index, sshKey) => collectProjectValues(index.configPaths, sshKey, load, toValue)), Effect.map((values) => values ?? empty()));
+listProjectValues(loadProjectSummary, renderProjectSummary, emptySummaries);
+const listProjectItems = listProjectValues(loadProjectItem, (value) => value, emptyItems);
+pipe(Effect.all([listProjectItems, runDockerPsNames(process.cwd())]), Effect.map(([items, runningNames]) => items.filter((item) => runningNames.includes(item.containerName))));
+Effect.asVoid(withProjectIndexAndSsh((index, sshKey) => forEachProjectStatus(index.configPaths, (status) => pipe(Effect.log(renderProjectStatusHeader(status)), Effect.zipRight(Effect.log(`SSH access: ${buildSshCommand(status.config.template, sshKey)}`)), Effect.zipRight(runDockerComposePsFormatted(status.projectDir).pipe(Effect.map((raw) => parseComposePsOutput(raw)), Effect.map((rows) => formatComposeRows(rows)), Effect.flatMap((text) => Effect.log(text)), Effect.matchEffect({
+  onFailure: (error) => Effect.logWarning(`docker compose ps failed for ${status.projectDir}: ${renderError(error)}`),
+  onSuccess: () => Effect.void
+})))))));
+Duration.seconds(1);
+const usageText = [
+  "Usage:",
+  "  pnpm docker-git",
+  "  pnpm clone <repo-url> [ref]",
+  "  pnpm list",
+  "",
+  "Notes:",
+  "  - docker-git is the interactive TUI.",
+  "  - clone builds + runs docker-git clone for you."
+].join("\n");
+const runHelp = Console.log(usageText);
+const runDockerGit = pipe(
+  readCloneRequest,
+  Effect.flatMap(
+    (request) => Match.value(request).pipe(
+      Match.when({ _tag: "Clone" }, ({ args }) => runDockerGitClone(args)),
+      Match.when({ _tag: "None" }, () => runHelp),
+      Match.exhaustive
+    )
+  )
+);
+const readListFlag = Effect.sync(() => {
+  const command = process.argv.slice(2)[0] ?? "";
+  return command === "list" || command === "ls";
+});
+const program = Effect.gen(function* (_) {
+  const isList = yield* _(readListFlag);
+  if (isList) {
+    yield* _(listProjects);
+    return;
+  }
+  yield* _(runDockerGit);
+});
+const main = pipe(program, Effect.provide(NodeContext.layer));
+NodeRuntime.runMain(main);
+//# sourceMappingURL=main.js.map