openship 0.2.3 → 0.4.0

package/dist/chunk-HFYDYK4D.js

@@ -0,0 +1,1092 @@
+import {
+  assembleGitClone,
+  localGitSshWriter,
+  materializeGitSsh,
+  sq
+} from "./chunk-YL67EWYZ.js";
+import {
+  getTarCreateEnv,
+  prepareSourceTarArgs
+} from "./chunk-4MG3BVHE.js";
+import {
+  packageManagerEnsureCommand
+} from "./chunk-JZLNHGLW.js";
+import {
+  __commonJS,
+  __toESM
+} from "./chunk-4VNS5WPM.js";
+
+// ../../node_modules/ignore/index.js
+var require_ignore = __commonJS({
+  "../../node_modules/ignore/index.js"(exports, module) {
+    "use strict";
+    function makeArray(subject) {
+      return Array.isArray(subject) ? subject : [subject];
+    }
+    var UNDEFINED = void 0;
+    var EMPTY = "";
+    var SPACE = " ";
+    var ESCAPE = "\\";
+    var REGEX_TEST_BLANK_LINE = /^\s+$/;
+    var REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
+    var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
+    var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
+    var REGEX_SPLITALL_CRLF = /\r?\n/g;
+    var REGEX_TEST_INVALID_PATH = /^\.{0,2}\/|^\.{1,2}$/;
+    var REGEX_TEST_TRAILING_SLASH = /\/$/;
+    var SLASH = "/";
+    var TMP_KEY_IGNORE = "node-ignore";
+    if (typeof Symbol !== "undefined") {
+      TMP_KEY_IGNORE = /* @__PURE__ */ Symbol.for("node-ignore");
+    }
+    var KEY_IGNORE = TMP_KEY_IGNORE;
+    var define = (object, key, value) => {
+      Object.defineProperty(object, key, { value });
+      return value;
+    };
+    var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
+    var RETURN_FALSE = () => false;
+    var sanitizeRange = (range) => range.replace(
+      REGEX_REGEXP_RANGE,
+      (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : EMPTY
+    );
+    var cleanRangeBackSlash = (slashes) => {
+      const { length } = slashes;
+      return slashes.slice(0, length - length % 2);
+    };
+    var REPLACERS = [
+      [
+        // Remove BOM
+        // TODO:
+        // Other similar zero-width characters?
+        /^\uFEFF/,
+        () => EMPTY
+      ],
+      // > Trailing spaces are ignored unless they are quoted with backslash ("\")
+      [
+        // (a\ ) -> (a )
+        // (a  ) -> (a)
+        // (a ) -> (a)
+        // (a \ ) -> (a  )
+        /((?:\\\\)*?)(\\?\s+)$/,
+        (_, m1, m2) => m1 + (m2.indexOf("\\") === 0 ? SPACE : EMPTY)
+      ],
+      // Replace (\ ) with ' '
+      // (\ ) -> ' '
+      // (\\ ) -> '\\ '
+      // (\\\ ) -> '\\ '
+      [
+        /(\\+?)\s/g,
+        (_, m1) => {
+          const { length } = m1;
+          return m1.slice(0, length - length % 2) + SPACE;
+        }
+      ],
+      // Escape metacharacters
+      // which is written down by users but means special for regular expressions.
+      // > There are 12 characters with special meanings:
+      // > - the backslash \,
+      // > - the caret ^,
+      // > - the dollar sign $,
+      // > - the period or dot .,
+      // > - the vertical bar or pipe symbol |,
+      // > - the question mark ?,
+      // > - the asterisk or star *,
+      // > - the plus sign +,
+      // > - the opening parenthesis (,
+      // > - the closing parenthesis ),
+      // > - and the opening square bracket [,
+      // > - the opening curly brace {,
+      // > These special characters are often called "metacharacters".
+      [
+        /[\\$.|*+(){^]/g,
+        (match) => `\\${match}`
+      ],
+      [
+        // > a question mark (?) matches a single character
+        /(?!\\)\?/g,
+        () => "[^/]"
+      ],
+      // leading slash
+      [
+        // > A leading slash matches the beginning of the pathname.
+        // > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
+        // A leading slash matches the beginning of the pathname
+        /^\//,
+        () => "^"
+      ],
+      // replace special metacharacter slash after the leading slash
+      [
+        /\//g,
+        () => "\\/"
+      ],
+      [
+        // > A leading "**" followed by a slash means match in all directories.
+        // > For example, "**/foo" matches file or directory "foo" anywhere,
+        // > the same as pattern "foo".
+        // > "**/foo/bar" matches file or directory "bar" anywhere that is directly
+        // >   under directory "foo".
+        // Notice that the '*'s have been replaced as '\\*'
+        /^\^*\\\*\\\*\\\//,
+        // '**/foo' <-> 'foo'
+        () => "^(?:.*\\/)?"
+      ],
+      // starting
+      [
+        // there will be no leading '/'
+        //   (which has been replaced by section "leading slash")
+        // If starts with '**', adding a '^' to the regular expression also works
+        /^(?=[^^])/,
+        function startingReplacer() {
+          return !/\/(?!$)/.test(this) ? "(?:^|\\/)" : "^";
+        }
+      ],
+      // two globstars
+      [
+        // Use lookahead assertions so that we could match more than one `'/**'`
+        /\\\/\\\*\\\*(?=\\\/|$)/g,
+        // Zero, one or several directories
+        // should not use '*', or it will be replaced by the next replacer
+        // Check if it is not the last `'/**'`
+        (_, index, str) => index + 6 < str.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
+      ],
+      // normal intermediate wildcards
+      [
+        // Never replace escaped '*'
+        // ignore rule '\*' will match the path '*'
+        // 'abc.*/' -> go
+        // 'abc.*'  -> skip this rule,
+        //    coz trailing single wildcard will be handed by [trailing wildcard]
+        /(^|[^\\]+)(\\\*)+(?=.+)/g,
+        // '*.js' matches '.js'
+        // '*.js' doesn't match 'abc'
+        (_, p1, p2) => {
+          const unescaped = p2.replace(/\\\*/g, "[^\\/]*");
+          return p1 + unescaped;
+        }
+      ],
+      [
+        // unescape, revert step 3 except for back slash
+        // For example, if a user escape a '\\*',
+        // after step 3, the result will be '\\\\\\*'
+        /\\\\\\(?=[$.|*+(){^])/g,
+        () => ESCAPE
+      ],
+      [
+        // '\\\\' -> '\\'
+        /\\\\/g,
+        () => ESCAPE
+      ],
+      [
+        // > The range notation, e.g. [a-zA-Z],
+        // > can be used to match one of the characters in a range.
+        // `\` is escaped by step 3
+        /(\\)?\[([^\]/]*?)(\\*)($|\])/g,
+        (match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${sanitizeRange(range)}${endEscape}]` : "[]" : "[]"
+      ],
+      // ending
+      [
+        // 'js' will not match 'js.'
+        // 'ab' will not match 'abc'
+        /(?:[^*])$/,
+        // WTF!
+        // https://git-scm.com/docs/gitignore
+        // changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1)
+        // which re-fixes #24, #38
+        // > If there is a separator at the end of the pattern then the pattern
+        // > will only match directories, otherwise the pattern can match both
+        // > files and directories.
+        // 'js*' will not match 'a.js'
+        // 'js/' will not match 'a.js'
+        // 'js' will match 'a.js' and 'a.js/'
+        (match) => /\/$/.test(match) ? `${match}$` : `${match}(?=$|\\/$)`
+      ]
+    ];
+    var REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\/)?\\\*$/;
+    var MODE_IGNORE = "regex";
+    var MODE_CHECK_IGNORE = "checkRegex";
+    var UNDERSCORE = "_";
+    var TRAILING_WILD_CARD_REPLACERS = {
+      [MODE_IGNORE](_, p1) {
+        const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
+        return `${prefix}(?=$|\\/$)`;
+      },
+      [MODE_CHECK_IGNORE](_, p1) {
+        const prefix = p1 ? `${p1}[^/]*` : "[^/]*";
+        return `${prefix}(?=$|\\/$)`;
+      }
+    };
+    var makeRegexPrefix = (pattern) => REPLACERS.reduce(
+      (prev, [matcher, replacer]) => prev.replace(matcher, replacer.bind(pattern)),
+      pattern
+    );
+    var isString = (subject) => typeof subject === "string";
+    var checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
+    var splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF).filter(Boolean);
+    var IgnoreRule = class {
+      constructor(pattern, mark, body, ignoreCase, negative, prefix) {
+        this.pattern = pattern;
+        this.mark = mark;
+        this.negative = negative;
+        define(this, "body", body);
+        define(this, "ignoreCase", ignoreCase);
+        define(this, "regexPrefix", prefix);
+      }
+      get regex() {
+        const key = UNDERSCORE + MODE_IGNORE;
+        if (this[key]) {
+          return this[key];
+        }
+        return this._make(MODE_IGNORE, key);
+      }
+      get checkRegex() {
+        const key = UNDERSCORE + MODE_CHECK_IGNORE;
+        if (this[key]) {
+          return this[key];
+        }
+        return this._make(MODE_CHECK_IGNORE, key);
+      }
+      _make(mode, key) {
+        const str = this.regexPrefix.replace(
+          REGEX_REPLACE_TRAILING_WILDCARD,
+          // It does not need to bind pattern
+          TRAILING_WILD_CARD_REPLACERS[mode]
+        );
+        const regex = this.ignoreCase ? new RegExp(str, "i") : new RegExp(str);
+        return define(this, key, regex);
+      }
+    };
+    var createRule = ({
+      pattern,
+      mark
+    }, ignoreCase) => {
+      let negative = false;
+      let body = pattern;
+      if (body.indexOf("!") === 0) {
+        negative = true;
+        body = body.substr(1);
+      }
+      body = body.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
+      const regexPrefix = makeRegexPrefix(body);
+      return new IgnoreRule(
+        pattern,
+        mark,
+        body,
+        ignoreCase,
+        negative,
+        regexPrefix
+      );
+    };
+    var RuleManager = class {
+      constructor(ignoreCase) {
+        this._ignoreCase = ignoreCase;
+        this._rules = [];
+      }
+      _add(pattern) {
+        if (pattern && pattern[KEY_IGNORE]) {
+          this._rules = this._rules.concat(pattern._rules._rules);
+          this._added = true;
+          return;
+        }
+        if (isString(pattern)) {
+          pattern = {
+            pattern
+          };
+        }
+        if (checkPattern(pattern.pattern)) {
+          const rule = createRule(pattern, this._ignoreCase);
+          this._added = true;
+          this._rules.push(rule);
+        }
+      }
+      // @param {Array<string> | string | Ignore} pattern
+      add(pattern) {
+        this._added = false;
+        makeArray(
+          isString(pattern) ? splitPattern(pattern) : pattern
+        ).forEach(this._add, this);
+        return this._added;
+      }
+      // Test one single path without recursively checking parent directories
+      //
+      // - checkUnignored `boolean` whether should check if the path is unignored,
+      //   setting `checkUnignored` to `false` could reduce additional
+      //   path matching.
+      // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
+      // @returns {TestResult} true if a file is ignored
+      test(path, checkUnignored, mode) {
+        let ignored = false;
+        let unignored = false;
+        let matchedRule;
+        this._rules.forEach((rule) => {
+          const { negative } = rule;
+          if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
+            return;
+          }
+          const matched = rule[mode].test(path);
+          if (!matched) {
+            return;
+          }
+          ignored = !negative;
+          unignored = negative;
+          matchedRule = negative ? UNDEFINED : rule;
+        });
+        const ret = {
+          ignored,
+          unignored
+        };
+        if (matchedRule) {
+          ret.rule = matchedRule;
+        }
+        return ret;
+      }
+    };
+    var throwError = (message, Ctor) => {
+      throw new Ctor(message);
+    };
+    var checkPath = (path, originalPath, doThrow) => {
+      if (!isString(path)) {
+        return doThrow(
+          `path must be a string, but got \`${originalPath}\``,
+          TypeError
+        );
+      }
+      if (!path) {
+        return doThrow(`path must not be empty`, TypeError);
+      }
+      if (checkPath.isNotRelative(path)) {
+        const r = "`path.relative()`d";
+        return doThrow(
+          `path should be a ${r} string, but got "${originalPath}"`,
+          RangeError
+        );
+      }
+      return true;
+    };
+    var isNotRelative = (path) => REGEX_TEST_INVALID_PATH.test(path);
+    checkPath.isNotRelative = isNotRelative;
+    checkPath.convert = (p) => p;
+    var Ignore = class {
+      constructor({
+        ignorecase = true,
+        ignoreCase = ignorecase,
+        allowRelativePaths = false
+      } = {}) {
+        define(this, KEY_IGNORE, true);
+        this._rules = new RuleManager(ignoreCase);
+        this._strictPathCheck = !allowRelativePaths;
+        this._initCache();
+      }
+      _initCache() {
+        this._ignoreCache = /* @__PURE__ */ Object.create(null);
+        this._testCache = /* @__PURE__ */ Object.create(null);
+      }
+      add(pattern) {
+        if (this._rules.add(pattern)) {
+          this._initCache();
+        }
+        return this;
+      }
+      // legacy
+      addPattern(pattern) {
+        return this.add(pattern);
+      }
+      // @returns {TestResult}
+      _test(originalPath, cache, checkUnignored, slices) {
+        const path = originalPath && checkPath.convert(originalPath);
+        checkPath(
+          path,
+          originalPath,
+          this._strictPathCheck ? throwError : RETURN_FALSE
+        );
+        return this._t(path, cache, checkUnignored, slices);
+      }
+      checkIgnore(path) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path)) {
+          return this.test(path);
+        }
+        const slices = path.split(SLASH).filter(Boolean);
+        slices.pop();
+        if (slices.length) {
+          const parent = this._t(
+            slices.join(SLASH) + SLASH,
+            this._testCache,
+            true,
+            slices
+          );
+          if (parent.ignored) {
+            return parent;
+          }
+        }
+        return this._rules.test(path, false, MODE_CHECK_IGNORE);
+      }
+      _t(path, cache, checkUnignored, slices) {
+        if (path in cache) {
+          return cache[path];
+        }
+        if (!slices) {
+          slices = path.split(SLASH).filter(Boolean);
+        }
+        slices.pop();
+        if (!slices.length) {
+          return cache[path] = this._rules.test(path, checkUnignored, MODE_IGNORE);
+        }
+        const parent = this._t(
+          slices.join(SLASH) + SLASH,
+          cache,
+          checkUnignored,
+          slices
+        );
+        return cache[path] = parent.ignored ? parent : this._rules.test(path, checkUnignored, MODE_IGNORE);
+      }
+      ignores(path) {
+        return this._test(path, this._ignoreCache, false).ignored;
+      }
+      createFilter() {
+        return (path) => !this.ignores(path);
+      }
+      filter(paths) {
+        return makeArray(paths).filter(this.createFilter());
+      }
+      // @returns {TestResult}
+      test(path) {
+        return this._test(path, this._testCache, true);
+      }
+    };
+    var factory = (options) => new Ignore(options);
+    var isPathValid = (path) => checkPath(path && checkPath.convert(path), path, RETURN_FALSE);
+    var setupWindows = () => {
+      const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
+      checkPath.convert = makePosix;
+      const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
+      checkPath.isNotRelative = (path) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path) || isNotRelative(path);
+    };
+    if (
+      // Detect `process` so that it can run in browsers.
+      typeof process !== "undefined" && process.platform === "win32"
+    ) {
+      setupWindows();
+    }
+    module.exports = factory;
+    factory.default = factory;
+    module.exports.isPathValid = isPathValid;
+    define(module.exports, /* @__PURE__ */ Symbol.for("setupWindows"), setupWindows);
+  }
+});
+
+// ../../packages/adapters/src/runtime/docker-paths.ts
+import { access, readdir } from "fs/promises";
+import { isAbsolute, join, relative, sep } from "path";
+function toPosixPath(value) {
+  return value.split(sep).filter(Boolean).join("/");
+}
+function normalizeDockerRelativePath(value) {
+  const normalized = value?.trim().replace(/^\.\//, "").replace(/^\/+|\/+$/g, "");
+  if (!normalized || normalized === ".") {
+    return "";
+  }
+  return normalized.split(/[\\/]/).filter(Boolean).join("/");
+}
+function normalizeDockerRootDirectory(rootDirectory, localPath) {
+  let normalized = rootDirectory?.trim() ?? "";
+  if (!normalized) {
+    return "";
+  }
+  if (localPath && isAbsolute(normalized)) {
+    const relativePath = relative(localPath, normalized);
+    if (!relativePath || relativePath === ".") {
+      return "";
+    }
+    if (!relativePath.startsWith("..") && !isAbsolute(relativePath)) {
+      normalized = relativePath;
+    }
+  }
+  normalized = normalized.replace(/^\.\//, "").replace(/^\/+|\/+$/g, "");
+  if (!normalized || normalized === ".") {
+    return "";
+  }
+  return toPosixPath(normalized);
+}
+function resolveExplicitDockerfileCandidate(rootDirectory, dockerfilePath) {
+  const normalizedRootDirectory = normalizeDockerRelativePath(rootDirectory);
+  const normalizedDockerfilePath = normalizeDockerRelativePath(dockerfilePath);
+  if (!normalizedDockerfilePath) {
+    return "";
+  }
+  if (!normalizedRootDirectory) {
+    return normalizedDockerfilePath;
+  }
+  if (normalizedDockerfilePath.startsWith(`${normalizedRootDirectory}/`)) {
+    return normalizedDockerfilePath;
+  }
+  return `${normalizedRootDirectory}/${normalizedDockerfilePath}`;
+}
+function resolveDockerfileCandidates(rootDirectory, explicitDockerfilePath) {
+  const normalizedRootDirectory = normalizeDockerRelativePath(rootDirectory);
+  return [
+    resolveExplicitDockerfileCandidate(rootDirectory, explicitDockerfilePath),
+    normalizedRootDirectory ? `${normalizedRootDirectory}/Dockerfile` : "Dockerfile",
+    "Dockerfile"
+  ].filter(
+    (candidate, index, values) => Boolean(candidate) && values.indexOf(candidate) === index
+  );
+}
+var ROOT_MANIFESTS = [
+  "package.json",
+  "pyproject.toml",
+  "requirements.txt",
+  "Pipfile",
+  "go.mod",
+  "Cargo.toml",
+  "Gemfile",
+  "composer.json",
+  "pom.xml",
+  "build.gradle",
+  "build.gradle.kts",
+  "mix.exs",
+  "Dockerfile"
+];
+var IGNORED_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".next",
+  ".nuxt",
+  ".output",
+  ".turbo",
+  ".venv",
+  "__pycache__",
+  "build",
+  "dist",
+  "target",
+  "vendor"
+]);
+async function pathExists(path) {
+  return access(path).then(() => true).catch(() => false);
+}
+async function manifestCount(dir) {
+  let count = 0;
+  for (const file of ROOT_MANIFESTS) {
+    if (await pathExists(join(dir, file))) {
+      count += 1;
+    }
+  }
+  return count;
+}
+function pathSegments(path) {
+  return path.toLowerCase().split("/").filter(Boolean);
+}
+function scorePathHints(relativePath) {
+  const segments = pathSegments(relativePath);
+  let score = 0;
+  for (const segment of segments) {
+    if (["app", "apps", "site", "sites", "web", "www", "service", "services"].includes(segment)) {
+      score += 12;
+    }
+    if (["docs", "example", "examples", "test", "tests", "storybook"].includes(segment)) {
+      score -= 18;
+    }
+  }
+  return score;
+}
+async function scoreCandidate(dir, relativePath) {
+  let score = scorePathHints(relativePath);
+  score += await manifestCount(dir) * 20;
+  if (relativePath) {
+    score += 6;
+  }
+  return score;
+}
+async function collectCandidates(rootDir, currentDir, depth, candidates) {
+  const relativePath = toPosixPath(relative(rootDir, currentDir));
+  if (await manifestCount(currentDir) > 0) {
+    candidates.push({
+      path: relativePath,
+      score: await scoreCandidate(currentDir, relativePath)
+    });
+  }
+  if (depth >= 6) {
+    return;
+  }
+  const entries = await readdir(currentDir, { withFileTypes: true }).catch(() => []);
+  for (const entry of entries) {
+    if (!entry.isDirectory() || IGNORED_DIRS.has(entry.name)) {
+      continue;
+    }
+    await collectCandidates(rootDir, join(currentDir, entry.name), depth + 1, candidates);
+  }
+}
+async function resolveDockerRootDirectory(contextDir, rootDirectory, localPath) {
+  const hasExplicitRootDirectory = typeof rootDirectory === "string";
+  const normalized = normalizeDockerRootDirectory(rootDirectory, localPath);
+  if (hasExplicitRootDirectory) {
+    return normalized;
+  }
+  if (normalized) {
+    return normalized;
+  }
+  const candidates = [];
+  await collectCandidates(contextDir, contextDir, 0, candidates);
+  if (candidates.length === 0) {
+    return "";
+  }
+  candidates.sort((left, right) => right.score - left.score);
+  const bestNonRoot = candidates.find((candidate) => candidate.path);
+  if (bestNonRoot && bestNonRoot.score > 0) {
+    return bestNonRoot.path;
+  }
+  return candidates[0]?.path ?? "";
+}
+
+// ../../packages/adapters/src/runtime/docker-build-plan.ts
+var DOCKER_BUILD_EVENT_PREFIX = "[openship-build]";
+var INLINE_BUILD_ENV_EXCLUDES = /* @__PURE__ */ new Set(["FORCE_COLOR", "TERM"]);
+function formatDockerBuildEvent(step, status) {
+  return `${DOCKER_BUILD_EVENT_PREFIX} step=${step} status=${status}`;
+}
+function normalizeRelativePath(value) {
+  const normalized = value?.trim().replace(/^\.\//, "").replace(/^\/+|\/+$/g, "");
+  if (!normalized || normalized === ".") {
+    return "";
+  }
+  return normalized;
+}
+function builderSourceDir(rootDirectory) {
+  const normalized = normalizeDockerRootDirectory(rootDirectory);
+  return normalized ? `/workspace/${normalized}` : "/workspace";
+}
+function buildEnvPrefix(envVars) {
+  const assignments = Object.entries(envVars).filter(([key]) => !INLINE_BUILD_ENV_EXCLUDES.has(key)).filter(([key]) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(key)).map(([key, value]) => `${key}=${sq(value)}`);
+  if (!envVars.NO_COLOR) {
+    assignments.push("NO_COLOR='1'");
+  }
+  if (assignments.length === 0) {
+    return "";
+  }
+  return `export ${assignments.join(" ")} && `;
+}
+function buildRunCommand(command, envPrefix) {
+  return `${envPrefix}${command}`;
+}
+function runtimeCopyDirectives(config, sourceDir) {
+  if (config.productionPaths && config.productionPaths.length > 0) {
+    return config.productionPaths.map((path) => {
+      const normalized = normalizeRelativePath(path);
+      const source = normalized ? `${sourceDir}/${normalized}` : sourceDir;
+      const target = normalized ? `/app/${normalized}` : "/app";
+      return `COPY --from=builder ${source} ${target}`;
+    });
+  }
+  return [`COPY --from=builder ${sourceDir} /app`];
+}
+function needsMultiStage(config) {
+  return config.buildImage !== config.runtimeImage;
+}
+function workspacePrepareRunLine(config, envPrefix, workspacePrepare) {
+  const pmEnsure = packageManagerEnsureCommand(config.packageManager);
+  const body = pmEnsure ? `${pmEnsure} && ${workspacePrepare}` : workspacePrepare;
+  return `RUN ${envPrefix}${body}`;
+}
+function installBuildRunLine(config, envPrefix) {
+  const steps = [];
+  const pmEnsure = packageManagerEnsureCommand(config.packageManager);
+  if (pmEnsure && (config.installCommand || config.buildCommand)) {
+    steps.push(pmEnsure);
+  }
+  if (config.installCommand) {
+    steps.push(`printf '${formatDockerBuildEvent("install", "running")}\\n'`);
+    steps.push(buildRunCommand(config.installCommand, envPrefix));
+    steps.push(`printf '${formatDockerBuildEvent("install", "completed")}\\n'`);
+  }
+  if (config.buildCommand) {
+    steps.push(`printf '${formatDockerBuildEvent("build", "running")}\\n'`);
+    steps.push(buildRunCommand(config.buildCommand, envPrefix));
+    steps.push(`printf '${formatDockerBuildEvent("build", "completed")}\\n'`);
+  }
+  return steps.length > 0 ? `RUN ${steps.join(" && ")}` : null;
+}
+function isPhpRuntime(config) {
+  return /^php:/.test(config.runtimeImage);
+}
+var PHP_NGINX_TEMPLATE_LINES = [
+  "server {",
+  "    listen ${PORT} default_server;",
+  "    root /app/public;",
+  "    index index.php index.html;",
+  "    location / { try_files $uri $uri/ /index.php?$query_string; }",
+  "    location ~ \\.php$ {",
+  "        fastcgi_pass 127.0.0.1:9000;",
+  "        fastcgi_index index.php;",
+  "        include fastcgi_params;",
+  "        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;",
+  "    }",
+  "}"
+];
+function generatePhpDockerfile(config) {
+  const sourceDir = builderSourceDir(
+    normalizeDockerRootDirectory(config.rootDirectory, config.localPath)
+  );
+  const envPrefix = buildEnvPrefix(config.envVars);
+  const stepsLine = installBuildRunLine(config, envPrefix);
+  const nginxTemplate = PHP_NGINX_TEMPLATE_LINES.map((line) => `'${line}'`).join(" ");
+  const lines = [
+    `FROM ${config.buildImage} AS builder`,
+    `WORKDIR /workspace`,
+    `COPY . /workspace`,
+    // php:*-cli ships no Composer — pull the binary from the official image.
+    `COPY --from=composer:2 /usr/bin/composer /usr/bin/composer`,
+    // pdo_mysql is the common denominator (Laravel/Symfony + MySQL/MariaDB);
+    // app-specific extensions are a per-project follow-on.
+    `RUN docker-php-ext-install pdo_mysql > /dev/null`,
+    `WORKDIR ${sourceDir}`
+  ];
+  if (stepsLine) lines.push(stepsLine);
+  lines.push(
+    `FROM ${config.runtimeImage} AS runtime`,
+    `RUN apt-get update && apt-get install -y --no-install-recommends nginx gettext-base && rm -rf /var/lib/apt/lists/* && rm -f /etc/nginx/sites-enabled/default && docker-php-ext-install pdo_mysql > /dev/null`,
+    `COPY --from=builder ${sourceDir} /app`,
+    `WORKDIR /app`,
+    `RUN printf '%s\\n' ${nginxTemplate} > /etc/nginx/app.conf.template`,
+    `EXPOSE ${config.port}`
+  );
+  if (config.startCommand) {
+    lines.push(`CMD ["sh", "-c", ${JSON.stringify(config.startCommand)}]`);
+  }
+  return lines.join("\n");
+}
+function staticNginxTemplateLines(port) {
+  return [
+    "server {",
+    `    listen ${port} default_server;`,
+    "    root /usr/share/nginx/html;",
+    "    index index.html;",
+    "    location / { try_files $uri $uri/ /index.html; }",
+    "}"
+  ];
+}
+function generateStaticDockerfile(config) {
+  const sourceDir = builderSourceDir(
+    normalizeDockerRootDirectory(config.rootDirectory, config.localPath)
+  );
+  const envPrefix = buildEnvPrefix(config.envVars);
+  const workspacePrepare = config.workspacePrepareCommand?.trim();
+  const output = normalizeRelativePath(config.outputDirectory);
+  const outputPath = output ? `${sourceDir}/${output}` : sourceDir;
+  const nginxTemplate = staticNginxTemplateLines(config.port).map((line) => `'${line}'`).join(" ");
+  const lines = [
+    `FROM ${config.buildImage} AS builder`,
+    `WORKDIR /workspace`,
+    `COPY . /workspace`
+  ];
+  if (workspacePrepare) {
+    lines.push(workspacePrepareRunLine(config, envPrefix, workspacePrepare));
+  }
+  lines.push(`WORKDIR ${sourceDir}`);
+  const stepsLine = installBuildRunLine(config, envPrefix);
+  if (stepsLine) lines.push(stepsLine);
+  lines.push(
+    `FROM nginx:alpine AS runtime`,
+    `RUN rm -f /etc/nginx/conf.d/default.conf`,
+    `COPY --from=builder ${outputPath} /usr/share/nginx/html`,
+    `RUN printf '%s\\n' ${nginxTemplate} > /etc/nginx/conf.d/app.conf`,
+    `EXPOSE ${config.port}`,
+    `CMD ["nginx", "-g", "daemon off;"]`
+  );
+  return lines.join("\n");
+}
+function generateDockerfile(config) {
+  if (config.isStatic) {
+    return generateStaticDockerfile(config);
+  }
+  if (isPhpRuntime(config) && needsMultiStage(config)) {
+    return generatePhpDockerfile(config);
+  }
+  const sourceDir = builderSourceDir(
+    normalizeDockerRootDirectory(config.rootDirectory, config.localPath)
+  );
+  const multiStage = needsMultiStage(config);
+  const envPrefix = buildEnvPrefix(config.envVars);
+  const workspacePrepare = config.workspacePrepareCommand?.trim();
+  const lines = multiStage ? [
+    `FROM ${config.buildImage} AS builder`,
+    `WORKDIR /workspace`,
+    `COPY . /workspace`
+  ] : [
+    `FROM ${config.runtimeImage}`,
+    `WORKDIR /workspace`,
+    `COPY . /workspace`
+  ];
+  if (workspacePrepare) {
+    lines.push(workspacePrepareRunLine(config, envPrefix, workspacePrepare));
+  }
+  lines.push(`WORKDIR ${sourceDir}`);
+  const stepsLine = installBuildRunLine(config, envPrefix);
+  if (stepsLine) {
+    lines.push(stepsLine);
+  }
+  if (multiStage) {
+    lines.push(`FROM ${config.runtimeImage} AS runtime`);
+    lines.push(...runtimeCopyDirectives(config, sourceDir));
+    lines.push(`WORKDIR /app`);
+  }
+  lines.push(`EXPOSE ${config.port}`);
+  if (config.startCommand) {
+    lines.push(`CMD ["sh", "-c", ${JSON.stringify(config.startCommand)}]`);
+  }
+  return lines.join("\n");
+}
+
+// ../../packages/adapters/src/runtime/docker-build-context.ts
+var import_ignore = __toESM(require_ignore(), 1);
+import { spawn } from "child_process";
+import { access as access2, mkdtemp, readdir as readdir2, readFile, rm, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join2, relative as relative2, sep as sep2 } from "path";
+var GIT_CLONE_IDLE_TIMEOUT_MS = 5 * 6e4;
+var GIT_CHECKOUT_IDLE_TIMEOUT_MS = 6e4;
+function spawnGit(args, opts) {
+  return new Promise((resolve, reject) => {
+    const child = spawn("git", args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      env: {
+        ...process.env,
+        GIT_TERMINAL_PROMPT: "0",
+        GIT_ASKPASS: "/bin/echo",
+        ...opts.env
+      }
+    });
+    let stderr = "";
+    const emit = opts.onLog;
+    const flushLine = (line) => {
+      const trimmed = line.trimEnd();
+      if (!trimmed) return;
+      if (emit) {
+        emit({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), message: trimmed, level: "info" });
+      }
+    };
+    let idleTimer;
+    const armIdle = () => {
+      clearTimeout(idleTimer);
+      idleTimer = setTimeout(() => {
+        child.kill("SIGKILL");
+        reject(
+          new Error(
+            `git ${args.find((a) => !a.startsWith("-")) ?? "command"} stalled \u2014 no progress for ${Math.round(
+              opts.timeoutMs / 1e3
+            )}s`
+          )
+        );
+      }, opts.timeoutMs);
+    };
+    child.stdout?.on("data", (buf) => {
+      armIdle();
+      for (const ln of buf.toString().split(/\r?\n/)) flushLine(ln);
+    });
+    child.stderr?.on("data", (buf) => {
+      armIdle();
+      const text = buf.toString();
+      stderr += text;
+      for (const ln of text.split(/\r?\n/)) flushLine(ln);
+    });
+    armIdle();
+    child.on("error", (err) => {
+      clearTimeout(idleTimer);
+      reject(err);
+    });
+    child.on("close", (code) => {
+      clearTimeout(idleTimer);
+      if (code === 0) resolve();
+      else reject(new Error(`git exited with code ${code}: ${stderr.trim().slice(-500) || "no stderr"}`));
+    });
+  });
+}
+var GENERATED_DOCKERFILE_NAME = "Dockerfile.openship";
+function toPosixPath2(value) {
+  return value.split(sep2).filter(Boolean).join("/");
+}
+async function loadDockerignoreMatcher(rootPath) {
+  try {
+    return (0, import_ignore.default)().add(await readFile(join2(rootPath, ".dockerignore"), "utf-8"));
+  } catch {
+    return void 0;
+  }
+}
+async function applyDockerignore(contextDir) {
+  const matcher = await loadDockerignoreMatcher(contextDir);
+  if (!matcher) return;
+  const prune = async (currentPath) => {
+    const entries = await readdir2(currentPath, { withFileTypes: true });
+    await Promise.all(
+      entries.map(async (entry) => {
+        const absolutePath = join2(currentPath, entry.name);
+        const relativePath = relative2(contextDir, absolutePath);
+        if (matcher.ignores(toPosixPath2(relativePath))) {
+          await rm(absolutePath, { recursive: true, force: true });
+          return;
+        }
+        if (entry.isDirectory()) await prune(absolutePath);
+      })
+    );
+  };
+  await prune(contextDir);
+}
+async function materializeLocalSource(sourcePath, targetPath) {
+  const { args, cleanup } = await prepareSourceTarArgs(sourcePath);
+  try {
+    await new Promise((resolve, reject) => {
+      const create = spawn("tar", args, { env: getTarCreateEnv() });
+      const extract = spawn("tar", ["-xzf", "-", "-C", targetPath]);
+      let err = "";
+      create.stderr.on("data", (d) => err += d.toString());
+      extract.stderr.on("data", (d) => err += d.toString());
+      create.on("error", reject);
+      extract.on("error", reject);
+      create.stdout.pipe(extract.stdin);
+      extract.on(
+        "close",
+        (code) => code === 0 ? resolve() : reject(new Error(`context materialize failed (tar ${code}): ${err.trim().slice(-500)}`))
+      );
+    });
+  } finally {
+    await cleanup();
+  }
+}
+async function resolveDockerfileName(contextDir, rootDirectory, explicitDockerfilePath) {
+  const candidates = resolveDockerfileCandidates(rootDirectory, explicitDockerfilePath);
+  for (const candidate of candidates) {
+    const candidatePath = join2(contextDir, ...candidate.split("/"));
+    const exists = await access2(candidatePath).then(() => true).catch(() => false);
+    if (exists) {
+      return candidate;
+    }
+  }
+  return null;
+}
+async function cloneGitSource(config, targetPath, onLog) {
+  let sshMaterial;
+  if (config.gitSsh) {
+    sshMaterial = await materializeGitSsh(
+      localGitSshWriter(),
+      await mkdtemp(join2(tmpdir(), "opsh-ghkey-")),
+      config.gitSsh
+    );
+  }
+  const { cloneUrl, env: gitEnv, credArgs } = assembleGitClone({
+    repoUrl: config.repoUrl,
+    gitToken: config.gitToken,
+    ssh: sshMaterial
+  });
+  try {
+    await spawnGit(
+      [
+        ...credArgs,
+        "clone",
+        "--progress",
+        "--depth",
+        config.commitSha ? "50" : "1",
+        "--branch",
+        config.branch,
+        cloneUrl,
+        targetPath
+      ],
+      { timeoutMs: GIT_CLONE_IDLE_TIMEOUT_MS, onLog, env: gitEnv }
+    );
+    if (config.commitSha) {
+      await spawnGit([...credArgs, "-C", targetPath, "checkout", config.commitSha], {
+        timeoutMs: GIT_CHECKOUT_IDLE_TIMEOUT_MS,
+        onLog,
+        env: gitEnv
+      });
+    }
+    await rm(join2(targetPath, ".git"), { recursive: true, force: true });
+  } finally {
+    await sshMaterial?.cleanup();
+  }
+}
+async function prepareSourceTree(config, opts) {
+  const contextDir = await mkdtemp(join2(tmpdir(), "openship-docker-context-"));
+  try {
+    if (config.localPath) {
+      await materializeLocalSource(config.localPath, contextDir);
+    } else {
+      await cloneGitSource(config, contextDir, opts?.onLog);
+    }
+    await applyDockerignore(contextDir);
+    return {
+      contextDir,
+      cleanup: async () => {
+        await rm(contextDir, { recursive: true, force: true }).catch(() => {
+        });
+      }
+    };
+  } catch (error) {
+    await rm(contextDir, { recursive: true, force: true }).catch(() => {
+    });
+    throw error;
+  }
+}
+async function resolveServiceDockerfile(contextDir, config, opts) {
+  const requireRepositoryDockerfile = opts?.requireRepositoryDockerfile ?? false;
+  const generatedName = opts?.generatedName ?? GENERATED_DOCKERFILE_NAME;
+  const resolvedRootDirectory = await resolveDockerRootDirectory(
+    contextDir,
+    config.rootDirectory,
+    config.localPath
+  );
+  const repositoryDockerfileName = await resolveDockerfileName(
+    contextDir,
+    resolvedRootDirectory,
+    config.dockerfilePath
+  );
+  const hasRepositoryDockerfile = repositoryDockerfileName !== null;
+  if (!hasRepositoryDockerfile && requireRepositoryDockerfile) {
+    const expectedDockerfile = config.dockerfilePath?.trim() || "Dockerfile";
+    throw new Error(
+      `No Dockerfile found for this build context. Expected ${expectedDockerfile}${config.rootDirectory ? ` under ${config.rootDirectory}` : ""}.`
+    );
+  }
+  if (!hasRepositoryDockerfile) {
+    await writeFile(
+      join2(contextDir, generatedName),
+      generateDockerfile({
+        ...config,
+        rootDirectory: resolvedRootDirectory
+      }),
+      "utf-8"
+    );
+  }
+  const contextEntries = await readdir2(contextDir);
+  return {
+    contextEntries,
+    dockerfileName: repositoryDockerfileName ?? generatedName,
+    rootDirectory: resolvedRootDirectory,
+    usesRepositoryDockerfile: hasRepositoryDockerfile
+  };
+}
+async function createDockerBuildContext(config, opts) {
+  const tree = await prepareSourceTree(config, { onLog: opts?.onLog });
+  try {
+    const resolved = await resolveServiceDockerfile(tree.contextDir, config, {
+      requireRepositoryDockerfile: opts?.requireRepositoryDockerfile
+    });
+    return {
+      contextDir: tree.contextDir,
+      contextEntries: resolved.contextEntries,
+      dockerfileName: resolved.dockerfileName,
+      rootDirectory: resolved.rootDirectory,
+      usesRepositoryDockerfile: resolved.usesRepositoryDockerfile,
+      cleanup: tree.cleanup
+    };
+  } catch (error) {
+    await tree.cleanup();
+    throw error;
+  }
+}
+
+export {
+  normalizeDockerRelativePath,
+  resolveDockerfileCandidates,
+  generateDockerfile,
+  prepareSourceTree,
+  resolveServiceDockerfile,
+  createDockerBuildContext
+};