@prover-coder-ai/docker-git 1.0.21 → 1.0.23

package/dist/main.js

@@ -1,930 +0,0 @@
-import { NodeContext, NodeRuntime } from "@effect/platform-node";
-import { Data, Match, Effect, pipe, 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;
-};
-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 DockerAccessError extends Data.TaggedError("DockerAccessError") {
-}
-class CloneFailedError extends Data.TaggedError("CloneFailedError") {
-}
-class PortProbeError extends Data.TaggedError("PortProbeError") {
-}
-class CommandFailedError extends Data.TaggedError("CommandFailedError") {
-}
-class AuthError extends Data.TaggedError("AuthError") {
-}
-class ScrapArchiveNotFoundError extends Data.TaggedError("ScrapArchiveNotFoundError") {
-}
-class ScrapArchiveInvalidError extends Data.TaggedError("ScrapArchiveInvalidError") {
-}
-class ScrapTargetDirUnsupportedError extends Data.TaggedError("ScrapTargetDirUnsupportedError") {
-}
-class ScrapWipeRefusedError extends Data.TaggedError("ScrapWipeRefusedError") {
-}
-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 = {
-  dockerGitPath: "./.docker-git",
-  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);
-}));
-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,
-  gitTokenLabel: Schema.optional(Schema.String),
-  codexAuthLabel: Schema.optional(Schema.String),
-  claudeAuthLabel: Schema.optional(Schema.String),
-  targetDir: Schema.String,
-  volumeName: Schema.String,
-  dockerGitPath: Schema.optionalWith(Schema.String, {
-    default: () => defaultTemplateConfig.dockerGitPath
-  }),
-  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 isParseError = (error) => error._tag === "UnknownCommand" || error._tag === "UnknownOption" || error._tag === "MissingOptionValue" || error._tag === "MissingRequiredOption" || error._tag === "InvalidOption" || error._tag === "UnexpectedArgument";
-const renderDockerAccessHeadline = (issue) => issue === "PermissionDenied" ? "Cannot access Docker daemon socket: permission denied." : "Cannot connect to Docker daemon.";
-const renderDockerAccessActionPlan = (issue) => {
-  const permissionDeniedPlan = [
-    "Action plan:",
-    "1) In the same shell, run: `groups $USER` and make sure group `docker` is present.",
-    "2) Re-login to refresh group memberships and run command again.",
-    "3) If DOCKER_HOST is set to rootless socket, keep running: `export DOCKER_HOST=unix:///run/user/$UID/docker.sock`.",
-    "4) If using a dedicated socket not in /run/user, set DOCKER_HOST explicitly and re-run.",
-    "Tip: this app now auto-tries a rootless socket fallback on first permission error."
-  ];
-  const daemonUnavailablePlan = [
-    "Action plan:",
-    "1) Check daemon status: `systemctl --user status docker` or `systemctl status docker`.",
-    "2) Start daemon: `systemctl --user start docker` (or `systemctl start docker` for system Docker).",
-    "3) Retry command in a new shell."
-  ];
-  return issue === "PermissionDenied" ? permissionDeniedPlan.join("\n") : daemonUnavailablePlan.join("\n");
-};
-const renderPrimaryError = (error) => Match.value(error).pipe(Match.when({ _tag: "FileExistsError" }, ({ path }) => `File already exists: ${path} (use --force to overwrite)`), Match.when({ _tag: "DockerCommandError" }, ({ exitCode }) => [
-  `docker compose failed with exit code ${exitCode}`,
-  "Hint: ensure Docker daemon is running and current user can access /var/run/docker.sock (for example via the docker group).",
-  "Hint: if output above contains 'port is already allocated', retry with a free SSH port via --ssh-port <port> (for example --ssh-port 2235), or stop the conflicting project/container."
-].join("\n")), Match.when({ _tag: "DockerAccessError" }, ({ details, issue }) => [
-  renderDockerAccessHeadline(issue),
-  "Hint: ensure Docker daemon is running and current user can access the docker socket.",
-  "Hint: if you use rootless Docker, set DOCKER_HOST to your user socket (for example unix:///run/user/$UID/docker.sock).",
-  renderDockerAccessActionPlan(issue),
-  `Details: ${details}`
-].join("\n")), Match.when({ _tag: "CloneFailedError" }, ({ repoRef, repoUrl, targetDir }) => `Clone failed for ${repoUrl} (${repoRef}) into ${targetDir}`), Match.when({ _tag: "PortProbeError" }, ({ message, port }) => `SSH port check failed for ${port}: ${message}`), Match.when({ _tag: "CommandFailedError" }, ({ command, exitCode }) => `${command} failed with exit code ${exitCode}`), Match.when({ _tag: "ScrapArchiveNotFoundError" }, ({ path }) => `Scrap archive not found: ${path} (run docker-git scrap export first)`), Match.when({ _tag: "ScrapArchiveInvalidError" }, ({ message, path }) => `Invalid scrap archive: ${path}
-Details: ${message}`), Match.when({ _tag: "ScrapTargetDirUnsupportedError" }, ({ reason, targetDir }) => [
-  `Cannot use scrap with targetDir ${targetDir}.`,
-  `Reason: ${reason}`,
-  `Hint: scrap currently supports workspaces under the ssh home directory only (for example: ~/repo).`
-].join("\n")), Match.when({ _tag: "ScrapWipeRefusedError" }, ({ reason, targetDir }) => [
-  `Refusing to wipe workspace for scrap import (targetDir ${targetDir}).`,
-  `Reason: ${reason}`,
-  "Hint: re-run with --no-wipe, or set a narrower --target-dir when creating the project."
-].join("\n")), Match.when({ _tag: "AuthError" }, ({ message }) => message), Match.orElse(() => 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 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 isDockerGitConfig = (entry) => entry.endsWith("docker-git.json");
-const shouldSkipDir = (entry) => entry === ".git" || entry === ".orch" || entry === ".docker-git" || entry === ".cache";
-const isNotFoundStatError = (error) => error._tag === "SystemError" && error.reason === "NotFound";
-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).pipe(Effect.catchTag("SystemError", (error) => isNotFoundStatError(error) ? Effect.succeed(null) : Effect.fail(error))));
-  if (info === null) {
-    return;
-  }
-  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 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));
-})));
-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 candidates = [
-    // Canonical layout: ~/.docker-git/.orch/env/global.env
-    path.join(root, ".orch", "env", "global.env"),
-    // Legacy layout (kept for backward compatibility): ~/.docker-git/secrets/global.env
-    path.join(root, "secrets", "global.env")
-  ];
-  for (const envPath of candidates) {
-    const exists = yield* _(fs.exists(envPath));
-    if (!exists) {
-      continue;
-    }
-    const text = yield* _(fs.readFileString(envPath));
-    const token = findTokenInEnvEntries(parseEnvEntries(text));
-    if (token !== null) {
-      return token;
-    }
-  }
-  return null;
-});
-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 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) => pipe(gitCapture(root, ["rev-parse", "--abbrev-ref", "HEAD"], env), Effect.map((value) => value.trim()), Effect.map((branch) => branch === "HEAD" ? "main" : branch), Effect.flatMap((branch) => git(root, ["push", "--no-verify", originUrl, `HEAD:refs/heads/${branch}`], env)))) : git(root, ["push", "--no-verify", "-u", "origin", "HEAD"], gitBaseEnv);
-  yield* _(effect);
-}).pipe(Effect.asVoid);
-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 ClaudeAuthStatusSchema = Schema.Struct({
-  loggedIn: Schema.Boolean,
-  authMethod: Schema.optional(Schema.String),
-  apiProvider: Schema.optional(Schema.String)
-});
-Schema.parseJson(ClaudeAuthStatusSchema);
-const ChunkManifestSchema = Schema.Struct({
-  original: Schema.String,
-  originalSize: Schema.Number,
-  parts: Schema.Array(Schema.String),
-  splitAt: Schema.Number,
-  partsCount: Schema.Number,
-  createdAt: Schema.String
-});
-Schema.parseJson(ChunkManifestSchema);
-const SessionManifestSchema = Schema.Struct({
-  schemaVersion: Schema.Literal(1),
-  mode: Schema.Literal("session"),
-  snapshotId: Schema.String,
-  createdAtUtc: Schema.String,
-  repo: Schema.Struct({
-    originUrl: Schema.String,
-    head: Schema.String,
-    branch: Schema.String
-  }),
-  artifacts: Schema.Struct({
-    worktreePatchChunks: Schema.String,
-    codexChunks: Schema.String,
-    codexSharedChunks: Schema.String,
-    envGlobalFile: Schema.optionalWith(Schema.Union(Schema.String, Schema.Null), { default: () => null }),
-    envProjectFile: Schema.optionalWith(Schema.Union(Schema.String, Schema.Null), { default: () => null })
-  }),
-  rebuild: Schema.optionalWith(Schema.Struct({
-    commands: Schema.Array(Schema.String)
-  }), { default: () => ({ commands: [] }) })
-});
-Schema.parseJson(SessionManifestSchema);
-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