@florianpat/lando-core 3.23.22 → 3.23.27-1florianPat.0

package/CHANGELOG.md

@@ -1,6 +1,28 @@
 ## {{ UNRELEASED_VERSION }} - [{{ UNRELEASED_DATE }}]({{ UNRELEASED_LINK }})
 
-## v3.23.22 - [January 6, 2025](https://github.com/florianPat/lando-core/releases/tag/v3.23.22)
+## v3.23.27-1florianPat.0 - [February 17, 2025](https://github.com/florianPat/lando-core/releases/tag/v3.23.27-1florianPat.0)
+
+## v3.23.26 - [January 24, 2025](https://github.com/lando/core/releases/tag/v3.23.26)
+
+* Fixed bug where an app’s services were inadvertently reaped if the app’s path included a comma [#322](https://github.com/lando/core/issues/322)
+
+## v3.23.25 - [January 18, 2025](https://github.com/lando/core/releases/tag/v3.23.25)
+
+* Fixed bug causing `--accept-license` flag to not work when installing Docker Desktop on macOS
+* Updated default Docker Desktop version to `4.37.1|2`
+* Updated default Docker Engine version to `27.5.0`
+* Updated default Docker Compose version to `2.31.0`
+* Updated recommended Docker Desktop range to `>=4.37.0`
+* Updated tested Docker Desktop range to `<=4.37`
+* Updated tested Docker Compose range to `<=2.32`
+
+## v3.23.24 - [January 14, 2025](https://github.com/lando/core/releases/tag/v3.23.24)
+
+* Fixed bug causing service script moving to fail when receiving non-stringy inputs
+
+## v3.23.23 - [January 14, 2025](https://github.com/lando/core/releases/tag/v3.23.23)
+
+* Fixed bug causing service script loading collisions
 
 ## v3.23.22 - [December 17, 2024](https://github.com/lando/core/releases/tag/v3.23.22)
 

package/app.js

@@ -240,6 +240,8 @@ module.exports = async (app, lando) => {
       BITNAMI_DEBUG: 'true',
     },
     labels: {
+      'io.lando.landofiles': app.configFiles.map(file => path.basename(file)).join(','),
+      'io.lando.root': app.root,
       'io.lando.src': app.configFiles.join(','),
       'io.lando.http-ports': '80,443',
     },

package/builders/_lando.js

@@ -41,6 +41,7 @@ module.exports = {
         refreshCerts = false,
         remoteFiles = {},
         scripts = [],
+        scriptsDir = false,
         sport = '443',
         ssl = false,
         sslExpose = true,
@@ -68,16 +69,25 @@ module.exports = {
         console.error(color.yellow(`${type} version ${version} is a legacy version! We recommend upgrading.`));
       }
 
+      // normalize scripts dir if needed
+      if (typeof scriptsDir === 'string' && !path.isAbsolute(scriptsDir)) scriptsDir = path.resolve(root, scriptsDir);
+
+      // Get some basic locations
+      const globalScriptsDir = path.join(userConfRoot, 'scripts');
+      const serviceScriptsDir = path.join(userConfRoot, 'helpers', project, type, name);
+      const entrypointScript = path.join(globalScriptsDir, 'lando-entrypoint.sh');
+      const addCertsScript = path.join(globalScriptsDir, 'add-cert.sh');
+      const refreshCertsScript = path.join(globalScriptsDir, 'refresh-certs.sh');
+
       // Move our config into the userconfroot if we have some
       // NOTE: we need to do this because on macOS and Windows not all host files
       // are shared into the docker vm
       if (fs.existsSync(confSrc)) require('../utils/move-config')(confSrc, confDest);
 
-      // Get some basic locations
-      const scriptsDir = path.join(userConfRoot, 'scripts');
-      const entrypointScript = path.join(scriptsDir, 'lando-entrypoint.sh');
-      const addCertsScript = path.join(scriptsDir, 'add-cert.sh');
-      const refreshCertsScript = path.join(scriptsDir, 'refresh-certs.sh');
+      // ditto for service helpers
+      if (!require('../utils/is-disabled')(scriptsDir) && typeof scriptsDir === 'string' && fs.existsSync(scriptsDir)) {
+        require('../utils/move-config')(scriptsDir, serviceScriptsDir);
+      }
 
       // Handle Environment
       const environment = {
@@ -100,10 +110,13 @@ module.exports = {
       // Handle volumes
       const volumes = [
         `${userConfRoot}:/lando:cached`,
-        `${scriptsDir}:/helpers`,
+        `${globalScriptsDir}:/helpers`,
         `${entrypointScript}:/lando-entrypoint.sh`,
       ];
 
+      // add in service helpers if we have them
+      if (fs.existsSync(serviceScriptsDir)) volumes.push(`${serviceScriptsDir}:/etc/lando/service/helpers`);
+
       // Handle ssl
       if (ssl) {
         // also expose the sport

package/builders/lando-v4.js

@@ -443,7 +443,10 @@ module.exports = {
       const labels = merge({}, app.labels, {
         'dev.lando.container': 'TRUE',
         'dev.lando.id': lando.config.id,
+        'dev.lando.landofiles': app.configFiles.map(file => path.basename(file)).join(','),
+        'dev.lando.root': app.root,
         'dev.lando.src': app.root,
+        'io.lando.http-ports': '80,443',
       }, config.labels);
 
       // add it all 2getha

package/config.yml

@@ -13,21 +13,21 @@ dockerSupportedVersions:
   compose:
     satisfies: "1.x.x || 2.x.x"
     recommendUpdate: "<=2.24.6"
-    tested: "<=2.30.99"
+    tested: "<=2.32.99"
     link:
       linux: https://docs.docker.com/compose/install/#install-compose-on-linux-systems
       darwin: https://docs.docker.com/desktop/install/mac-install/
       win32: https://docs.docker.com/desktop/install/windows-install/
   desktop:
     satisfies: ">=4.0.0 <5"
-    tested: "<=4.36.99"
-    recommendUpdate: "<=4.34.0"
+    tested: "<=4.37.99"
+    recommendUpdate: "<=4.36"
     link:
       darwin: https://docs.docker.com/desktop/install/mac-install/
       win32: https://docs.docker.com/desktop/install/windows-install/
       wsl: https://docs.docker.com/desktop/install/windows-install/
   engine:
     satisfies: ">=18 <28"
-    tested: "<=27.3.1"
+    tested: "<=27.5.99"
     link:
       linux: https://docs.docker.com/engine/install/debian/#install-using-the-convenience-script

package/hooks/app-run-events.js

@@ -7,6 +7,28 @@ const formatters = require('../lib/formatters');
 
 module.exports = async (app, lando, cmds, data, event) => {
   const eventCommands = require('./../utils/parse-events-config')(cmds, app, data, lando);
+  // add perm sweeping to all v3 services
+  if (!_.isEmpty(eventCommands)) {
+    const permsweepers = _(eventCommands)
+      .filter(command => command.api === 3)
+      .map(command => ({id: command.id, services: _.get(command, 'opts.services', [])}))
+      .uniqBy('id')
+      .value();
+    lando.log.debug('added preemptive perm sweeping to evented v3 services %j', permsweepers.map(s => s.id));
+    _.forEach(permsweepers, ({id, services}) => {
+      eventCommands.unshift({
+        id,
+        cmd: '/helpers/user-perms.sh --silent',
+        compose: app.compose,
+        project: app.project,
+        opts: {
+          mode: 'attach',
+          user: 'root',
+          services,
+        },
+      });
+    });
+  }
   const injectable = _.has(app, 'engine') ? app : lando;
 
   const splitEventCommands = [];

package/hooks/lando-setup-build-engine-darwin.js

@@ -10,6 +10,9 @@ const semver = require('semver');
 const {color} = require('listr2');
 
 const buildIds = {
+  '4.37.2': '179585',
+  '4.37.1': '178610',
+  '4.37.0': '178034',
   '4.36.0': '175267',
   '4.35.1': '173168',
   '4.35.0': '172550',

package/hooks/lando-setup-build-engine-win32.js

@@ -10,6 +10,8 @@ const {color} = require('listr2');
 const {nanoid} = require('nanoid');
 
 const buildIds = {
+  '4.37.1': '178610',
+  '4.37.0': '178034',
   '4.36.0': '175267',
   '4.35.1': '173168',
   '4.35.0': '172550',

package/hooks/lando-setup-build-engine-wsl.js

@@ -12,6 +12,8 @@ const {color} = require('listr2');
 const {nanoid} = require('nanoid');
 
 const buildIds = {
+  '4.37.1': '178610',
+  '4.37.0': '178034',
   '4.36.0': '175267',
   '4.35.1': '173168',
   '4.35.0': '172550',

package/hooks/lando-setup-orchestrator.js

@@ -7,7 +7,7 @@ const path = require('path');
 /*
  * Helper to get docker compose v2 download url
  */
-const getComposeDownloadUrl = (version = '2.30.3') => {
+const getComposeDownloadUrl = (version = '2.31.0') => {
   const mv = version.split('.')[0] > 1 ? '2' : '1';
   const arch = process.arch === 'arm64' ? 'aarch64' : 'x86_64';
   const toggle = `${process.platform}-${mv}`;
@@ -31,7 +31,7 @@ const getComposeDownloadUrl = (version = '2.30.3') => {
 /*
  * Helper to get docker compose v2 download destination
  */
-const getComposeDownloadDest = (base, version = '2.30.3') => {
+const getComposeDownloadDest = (base, version = '2.31.0') => {
   switch (process.platform) {
     case 'linux':
     case 'darwin':

package/lib/daemon.js

@@ -53,7 +53,7 @@ module.exports = class LandoDaemon {
       log = new Log(),
       context = 'node',
       compose = require('../utils/get-compose-x')(),
-      orchestratorVersion = '2.30.3',
+      orchestratorVersion = '2.31.0',
       userConfRoot = path.join(os.homedir(), '.lando'),
   ) {
     this.cache = cache;

package/lib/updates.js

@@ -127,7 +127,15 @@ module.exports = class UpdateManager {
           const {data, status, url} = await octokit.rest.repos.listReleases({owner: 'lando', repo: 'core'});
           this.debug('retrieved cli information from %o [%o]', url, status);
 
-          const newestCoreVersion = semver.clean((await this.plugins.find(plugin => plugin.core)?.check4Update())?.update?.version ?? '');
+          const corePlugin = await this.plugins.find(plugin => plugin.core);
+          if (undefined === corePlugin) {
+            throw new Error('We should find a core!');
+          }
+          let newestCoreVersion = corePlugin.check4Update()?.update?.version ?? corePlugin.version;
+          if (undefined === newestCoreVersion) {
+            throw new Error('Could not obtain the next lando core version!');
+          }
+          newestCoreVersion = semver.clean(newestCoreVersion);
 
           const versions = data
             .map(release => ({...release, version: semver.clean(release.tag_name)}))

package/netlify.toml

@@ -20,6 +20,7 @@
       "https://docs.google.com/document",
       "https://docs.google.com/forms",
       "https://github.com",
+      "https://www.drupal.org/community/events",
       "/v/"
     ]
     skipPatterns = [

package/node_modules/undici/docs/docs/api/Dispatcher.md

@@ -986,6 +986,57 @@ client.dispatch(
 );
 ```
 
+##### `dns`
+
+The `dns` interceptor enables you to cache DNS lookups for a given duration, per origin.
+
+>It is well suited for scenarios where you want to cache DNS lookups to avoid the overhead of resolving the same domain multiple times
+
+**Options**
+- `maxTTL` - The maximum time-to-live (in milliseconds) of the DNS cache. It should be a positive integer. Default: `10000`.
+  - Set `0` to disable TTL.
+- `maxItems` - The maximum number of items to cache. It should be a positive integer. Default: `Infinity`.
+- `dualStack` - Whether to resolve both IPv4 and IPv6 addresses. Default: `true`.
+  - It will also attempt a happy-eyeballs-like approach to connect to the available addresses in case of a connection failure.
+- `affinity` - Whether to use IPv4 or IPv6 addresses. Default: `4`.
+  - It can be either `'4` or `6`.
+  - It will only take effect if `dualStack` is `false`.
+- `lookup: (hostname: string, options: LookupOptions, callback: (err: NodeJS.ErrnoException | null, addresses: DNSInterceptorRecord[]) => void) => void` - Custom lookup function. Default: `dns.lookup`.
+  - For more info see [dns.lookup](https://nodejs.org/api/dns.html#dns_dns_lookup_hostname_options_callback).
+- `pick: (origin: URL, records: DNSInterceptorRecords, affinity: 4 | 6) => DNSInterceptorRecord` - Custom pick function. Default: `RoundRobin`.
+  - The function should return a single record from the records array.
+  - By default a simplified version of Round Robin is used.
+  - The `records` property can be mutated to store the state of the balancing algorithm.
+
+> The `Dispatcher#options` also gets extended with the options `dns.affinity`, `dns.dualStack`, `dns.lookup` and `dns.pick` which can be used to configure the interceptor at a request-per-request basis.
+
+
+**DNSInterceptorRecord**
+It represents a DNS record.
+- `family` - (`number`) The IP family of the address. It can be either `4` or `6`.
+- `address` - (`string`) The IP address.
+
+**DNSInterceptorOriginRecords**
+It represents a map of DNS IP addresses records for a single origin.
+- `4.ips` - (`DNSInterceptorRecord[] | null`) The IPv4 addresses.
+- `6.ips` - (`DNSInterceptorRecord[] | null`) The IPv6 addresses.
+
+**Example - Basic DNS Interceptor**
+
+```js
+const { Client, interceptors } = require("undici");
+const { dns } = interceptors;
+
+const client = new Agent().compose([
+  dns({ ...opts })
+])
+
+const response = await client.request({
+  origin: `http://localhost:3030`,
+  ...requestOpts
+})
+```
+
 ##### `Response Error Interceptor`
 
 **Introduction**

package/node_modules/undici/index.js

@@ -41,7 +41,8 @@ module.exports.createRedirectInterceptor = createRedirectInterceptor
 module.exports.interceptors = {
   redirect: require('./lib/interceptor/redirect'),
   retry: require('./lib/interceptor/retry'),
-  dump: require('./lib/interceptor/dump')
+  dump: require('./lib/interceptor/dump'),
+  dns: require('./lib/interceptor/dns')
 }
 
 module.exports.buildConnector = buildConnector

package/node_modules/undici/lib/api/api-request.js

@@ -73,7 +73,7 @@ class RequestHandler extends AsyncResource {
         this.removeAbortListener = util.addAbortListener(this.signal, () => {
           this.reason = this.signal.reason ?? new RequestAbortedError()
           if (this.res) {
-            util.destroy(this.res, this.reason)
+            util.destroy(this.res.on('error', util.nop), this.reason)
           } else if (this.abort) {
             this.abort(this.reason)
           }

package/node_modules/undici/lib/core/connect.js

@@ -220,6 +220,11 @@ const setupConnectTimeout = process.platform === 'win32'
  * @param {number} opts.port
  */
 function onConnectTimeout (socket, opts) {
+  // The socket could be already garbage collected
+  if (socket == null) {
+    return
+  }
+
   let message = 'Connect Timeout Error'
   if (Array.isArray(socket.autoSelectFamilyAttemptedAddresses)) {
     message += ` (attempted addresses: ${socket.autoSelectFamilyAttemptedAddresses.join(', ')},`

package/node_modules/undici/lib/dispatcher/client-h2.js

@@ -31,6 +31,8 @@ const {
 
 const kOpenStreams = Symbol('open streams')
 
+let extractBody
+
 // Experimental
 let h2ExperimentalWarned = false
 
@@ -240,11 +242,12 @@ function onHTTP2GoAway (code) {
   util.destroy(this[kSocket], err)
 
   // Fail head of pipeline.
-  const request = client[kQueue][client[kRunningIdx]]
-  client[kQueue][client[kRunningIdx]++] = null
-  util.errorRequest(client, request, err)
-
-  client[kPendingIdx] = client[kRunningIdx]
+  if (client[kRunningIdx] < client[kQueue].length) {
+    const request = client[kQueue][client[kRunningIdx]]
+    client[kQueue][client[kRunningIdx]++] = null
+    util.errorRequest(client, request, err)
+    client[kPendingIdx] = client[kRunningIdx]
+  }
 
   assert(client[kRunning] === 0)
 
@@ -260,7 +263,8 @@ function shouldSendContentLength (method) {
 
 function writeH2 (client, request) {
   const session = client[kHTTP2Session]
-  const { body, method, path, host, upgrade, expectContinue, signal, headers: reqHeaders } = request
+  const { method, path, host, upgrade, expectContinue, signal, headers: reqHeaders } = request
+  let { body } = request
 
   if (upgrade) {
     util.errorRequest(client, request, new Error('Upgrade not supported for H2'))
@@ -381,6 +385,16 @@ function writeH2 (client, request) {
 
   let contentLength = util.bodyLength(body)
 
+  if (util.isFormDataLike(body)) {
+    extractBody ??= require('../web/fetch/body.js').extractBody
+
+    const [bodyStream, contentType] = extractBody(body)
+    headers['content-type'] = contentType
+
+    body = bodyStream.stream
+    contentLength = bodyStream.length
+  }
+
   if (contentLength == null) {
     contentLength = request.contentLength
   }

package/node_modules/undici/lib/handler/retry-handler.js

@@ -229,7 +229,7 @@ class RetryHandler {
         return false
       }
 
-      const { start, size, end = size } = contentRange
+      const { start, size, end = size - 1 } = contentRange
 
       assert(this.start === start, 'content-range mismatch')
       assert(this.end == null || this.end === end, 'content-range mismatch')
@@ -252,7 +252,7 @@ class RetryHandler {
           )
         }
 
-        const { start, size, end = size } = range
+        const { start, size, end = size - 1 } = range
         assert(
           start != null && Number.isFinite(start),
           'content-range mismatch'
@@ -266,7 +266,7 @@ class RetryHandler {
       // We make our best to checkpoint the body for further range headers
       if (this.end == null) {
         const contentLength = headers['content-length']
-        this.end = contentLength != null ? Number(contentLength) : null
+        this.end = contentLength != null ? Number(contentLength) - 1 : null
       }
 
       assert(Number.isFinite(this.start))

package/node_modules/undici/lib/interceptor/dns.js

@@ -0,0 +1,375 @@
+'use strict'
+const { isIP } = require('node:net')
+const { lookup } = require('node:dns')
+const DecoratorHandler = require('../handler/decorator-handler')
+const { InvalidArgumentError, InformationalError } = require('../core/errors')
+const maxInt = Math.pow(2, 31) - 1
+
+class DNSInstance {
+  #maxTTL = 0
+  #maxItems = 0
+  #records = new Map()
+  dualStack = true
+  affinity = null
+  lookup = null
+  pick = null
+
+  constructor (opts) {
+    this.#maxTTL = opts.maxTTL
+    this.#maxItems = opts.maxItems
+    this.dualStack = opts.dualStack
+    this.affinity = opts.affinity
+    this.lookup = opts.lookup ?? this.#defaultLookup
+    this.pick = opts.pick ?? this.#defaultPick
+  }
+
+  get full () {
+    return this.#records.size === this.#maxItems
+  }
+
+  runLookup (origin, opts, cb) {
+    const ips = this.#records.get(origin.hostname)
+
+    // If full, we just return the origin
+    if (ips == null && this.full) {
+      cb(null, origin.origin)
+      return
+    }
+
+    const newOpts = {
+      affinity: this.affinity,
+      dualStack: this.dualStack,
+      lookup: this.lookup,
+      pick: this.pick,
+      ...opts.dns,
+      maxTTL: this.#maxTTL,
+      maxItems: this.#maxItems
+    }
+
+    // If no IPs we lookup
+    if (ips == null) {
+      this.lookup(origin, newOpts, (err, addresses) => {
+        if (err || addresses == null || addresses.length === 0) {
+          cb(err ?? new InformationalError('No DNS entries found'))
+          return
+        }
+
+        this.setRecords(origin, addresses)
+        const records = this.#records.get(origin.hostname)
+
+        const ip = this.pick(
+          origin,
+          records,
+          newOpts.affinity
+        )
+
+        let port
+        if (typeof ip.port === 'number') {
+          port = `:${ip.port}`
+        } else if (origin.port !== '') {
+          port = `:${origin.port}`
+        } else {
+          port = ''
+        }
+
+        cb(
+          null,
+          `${origin.protocol}//${
+            ip.family === 6 ? `[${ip.address}]` : ip.address
+          }${port}`
+        )
+      })
+    } else {
+      // If there's IPs we pick
+      const ip = this.pick(
+        origin,
+        ips,
+        newOpts.affinity
+      )
+
+      // If no IPs we lookup - deleting old records
+      if (ip == null) {
+        this.#records.delete(origin.hostname)
+        this.runLookup(origin, opts, cb)
+        return
+      }
+
+      let port
+      if (typeof ip.port === 'number') {
+        port = `:${ip.port}`
+      } else if (origin.port !== '') {
+        port = `:${origin.port}`
+      } else {
+        port = ''
+      }
+
+      cb(
+        null,
+        `${origin.protocol}//${
+          ip.family === 6 ? `[${ip.address}]` : ip.address
+        }${port}`
+      )
+    }
+  }
+
+  #defaultLookup (origin, opts, cb) {
+    lookup(
+      origin.hostname,
+      {
+        all: true,
+        family: this.dualStack === false ? this.affinity : 0,
+        order: 'ipv4first'
+      },
+      (err, addresses) => {
+        if (err) {
+          return cb(err)
+        }
+
+        const results = new Map()
+
+        for (const addr of addresses) {
+          // On linux we found duplicates, we attempt to remove them with
+          // the latest record
+          results.set(`${addr.address}:${addr.family}`, addr)
+        }
+
+        cb(null, results.values())
+      }
+    )
+  }
+
+  #defaultPick (origin, hostnameRecords, affinity) {
+    let ip = null
+    const { records, offset } = hostnameRecords
+
+    let family
+    if (this.dualStack) {
+      if (affinity == null) {
+        // Balance between ip families
+        if (offset == null || offset === maxInt) {
+          hostnameRecords.offset = 0
+          affinity = 4
+        } else {
+          hostnameRecords.offset++
+          affinity = (hostnameRecords.offset & 1) === 1 ? 6 : 4
+        }
+      }
+
+      if (records[affinity] != null && records[affinity].ips.length > 0) {
+        family = records[affinity]
+      } else {
+        family = records[affinity === 4 ? 6 : 4]
+      }
+    } else {
+      family = records[affinity]
+    }
+
+    // If no IPs we return null
+    if (family == null || family.ips.length === 0) {
+      return ip
+    }
+
+    if (family.offset == null || family.offset === maxInt) {
+      family.offset = 0
+    } else {
+      family.offset++
+    }
+
+    const position = family.offset % family.ips.length
+    ip = family.ips[position] ?? null
+
+    if (ip == null) {
+      return ip
+    }
+
+    if (Date.now() - ip.timestamp > ip.ttl) { // record TTL is already in ms
+      // We delete expired records
+      // It is possible that they have different TTL, so we manage them individually
+      family.ips.splice(position, 1)
+      return this.pick(origin, hostnameRecords, affinity)
+    }
+
+    return ip
+  }
+
+  setRecords (origin, addresses) {
+    const timestamp = Date.now()
+    const records = { records: { 4: null, 6: null } }
+    for (const record of addresses) {
+      record.timestamp = timestamp
+      if (typeof record.ttl === 'number') {
+        // The record TTL is expected to be in ms
+        record.ttl = Math.min(record.ttl, this.#maxTTL)
+      } else {
+        record.ttl = this.#maxTTL
+      }
+
+      const familyRecords = records.records[record.family] ?? { ips: [] }
+
+      familyRecords.ips.push(record)
+      records.records[record.family] = familyRecords
+    }
+
+    this.#records.set(origin.hostname, records)
+  }
+
+  getHandler (meta, opts) {
+    return new DNSDispatchHandler(this, meta, opts)
+  }
+}
+
+class DNSDispatchHandler extends DecoratorHandler {
+  #state = null
+  #opts = null
+  #dispatch = null
+  #handler = null
+  #origin = null
+
+  constructor (state, { origin, handler, dispatch }, opts) {
+    super(handler)
+    this.#origin = origin
+    this.#handler = handler
+    this.#opts = { ...opts }
+    this.#state = state
+    this.#dispatch = dispatch
+  }
+
+  onError (err) {
+    switch (err.code) {
+      case 'ETIMEDOUT':
+      case 'ECONNREFUSED': {
+        if (this.#state.dualStack) {
+          // We delete the record and retry
+          this.#state.runLookup(this.#origin, this.#opts, (err, newOrigin) => {
+            if (err) {
+              return this.#handler.onError(err)
+            }
+
+            const dispatchOpts = {
+              ...this.#opts,
+              origin: newOrigin
+            }
+
+            this.#dispatch(dispatchOpts, this)
+          })
+
+          // if dual-stack disabled, we error out
+          return
+        }
+
+        this.#handler.onError(err)
+        return
+      }
+      case 'ENOTFOUND':
+        this.#state.deleteRecord(this.#origin)
+      // eslint-disable-next-line no-fallthrough
+      default:
+        this.#handler.onError(err)
+        break
+    }
+  }
+}
+
+module.exports = interceptorOpts => {
+  if (
+    interceptorOpts?.maxTTL != null &&
+    (typeof interceptorOpts?.maxTTL !== 'number' || interceptorOpts?.maxTTL < 0)
+  ) {
+    throw new InvalidArgumentError('Invalid maxTTL. Must be a positive number')
+  }
+
+  if (
+    interceptorOpts?.maxItems != null &&
+    (typeof interceptorOpts?.maxItems !== 'number' ||
+      interceptorOpts?.maxItems < 1)
+  ) {
+    throw new InvalidArgumentError(
+      'Invalid maxItems. Must be a positive number and greater than zero'
+    )
+  }
+
+  if (
+    interceptorOpts?.affinity != null &&
+    interceptorOpts?.affinity !== 4 &&
+    interceptorOpts?.affinity !== 6
+  ) {
+    throw new InvalidArgumentError('Invalid affinity. Must be either 4 or 6')
+  }
+
+  if (
+    interceptorOpts?.dualStack != null &&
+    typeof interceptorOpts?.dualStack !== 'boolean'
+  ) {
+    throw new InvalidArgumentError('Invalid dualStack. Must be a boolean')
+  }
+
+  if (
+    interceptorOpts?.lookup != null &&
+    typeof interceptorOpts?.lookup !== 'function'
+  ) {
+    throw new InvalidArgumentError('Invalid lookup. Must be a function')
+  }
+
+  if (
+    interceptorOpts?.pick != null &&
+    typeof interceptorOpts?.pick !== 'function'
+  ) {
+    throw new InvalidArgumentError('Invalid pick. Must be a function')
+  }
+
+  const dualStack = interceptorOpts?.dualStack ?? true
+  let affinity
+  if (dualStack) {
+    affinity = interceptorOpts?.affinity ?? null
+  } else {
+    affinity = interceptorOpts?.affinity ?? 4
+  }
+
+  const opts = {
+    maxTTL: interceptorOpts?.maxTTL ?? 10e3, // Expressed in ms
+    lookup: interceptorOpts?.lookup ?? null,
+    pick: interceptorOpts?.pick ?? null,
+    dualStack,
+    affinity,
+    maxItems: interceptorOpts?.maxItems ?? Infinity
+  }
+
+  const instance = new DNSInstance(opts)
+
+  return dispatch => {
+    return function dnsInterceptor (origDispatchOpts, handler) {
+      const origin =
+        origDispatchOpts.origin.constructor === URL
+          ? origDispatchOpts.origin
+          : new URL(origDispatchOpts.origin)
+
+      if (isIP(origin.hostname) !== 0) {
+        return dispatch(origDispatchOpts, handler)
+      }
+
+      instance.runLookup(origin, origDispatchOpts, (err, newOrigin) => {
+        if (err) {
+          return handler.onError(err)
+        }
+
+        let dispatchOpts = null
+        dispatchOpts = {
+          ...origDispatchOpts,
+          servername: origin.hostname, // For SNI on TLS
+          origin: newOrigin,
+          headers: {
+            host: origin.hostname,
+            ...origDispatchOpts.headers
+          }
+        }
+
+        dispatch(
+          dispatchOpts,
+          instance.getHandler({ origin, dispatch, handler }, origDispatchOpts)
+        )
+      })
+
+      return true
+    }
+  }
+}

package/node_modules/undici/lib/web/cache/cache.js

@@ -37,6 +37,7 @@ class Cache {
       webidl.illegalConstructor()
     }
 
+    webidl.util.markAsUncloneable(this)
     this.#relevantRequestResponseList = arguments[1]
   }
 

package/node_modules/undici/lib/web/cache/cachestorage.js

@@ -16,6 +16,8 @@ class CacheStorage {
     if (arguments[0] !== kConstruct) {
       webidl.illegalConstructor()
     }
+
+    webidl.util.markAsUncloneable(this)
   }
 
   async match (request, options = {}) {

package/node_modules/undici/lib/web/eventsource/eventsource.js

@@ -105,6 +105,8 @@ class EventSource extends EventTarget {
     // 1. Let ev be a new EventSource object.
     super()
 
+    webidl.util.markAsUncloneable(this)
+
     const prefix = 'EventSource constructor'
     webidl.argumentLengthCheck(arguments, 1, prefix)
 

package/node_modules/undici/lib/web/fetch/body.js

@@ -20,6 +20,14 @@ const { isErrored, isDisturbed } = require('node:stream')
 const { isArrayBuffer } = require('node:util/types')
 const { serializeAMimeType } = require('./data-url')
 const { multipartFormDataParser } = require('./formdata-parser')
+let random
+
+try {
+  const crypto = require('node:crypto')
+  random = (max) => crypto.randomInt(0, max)
+} catch {
+  random = (max) => Math.floor(Math.random(max))
+}
 
 const textEncoder = new TextEncoder()
 function noop () {}
@@ -113,7 +121,7 @@ function extractBody (object, keepalive = false) {
     // Set source to a copy of the bytes held by object.
     source = new Uint8Array(object.buffer.slice(object.byteOffset, object.byteOffset + object.byteLength))
   } else if (util.isFormDataLike(object)) {
-    const boundary = `----formdata-undici-0${`${Math.floor(Math.random() * 1e11)}`.padStart(11, '0')}`
+    const boundary = `----formdata-undici-0${`${random(1e11)}`.padStart(11, '0')}`
     const prefix = `--${boundary}\r\nContent-Disposition: form-data`
 
     /*! formdata-polyfill. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */

package/node_modules/undici/lib/web/fetch/formdata.js

@@ -14,6 +14,8 @@ const File = globalThis.File ?? NativeFile
 // https://xhr.spec.whatwg.org/#formdata
 class FormData {
   constructor (form) {
+    webidl.util.markAsUncloneable(this)
+
     if (form !== undefined) {
       throw webidl.errors.conversionFailed({
         prefix: 'FormData constructor',

package/node_modules/undici/lib/web/fetch/headers.js

@@ -359,6 +359,8 @@ class Headers {
   #headersList
 
   constructor (init = undefined) {
+    webidl.util.markAsUncloneable(this)
+
     if (init === kConstruct) {
       return
     }

package/node_modules/undici/lib/web/fetch/index.js

@@ -2137,7 +2137,7 @@ async function httpNetworkFetch (
 
           // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Encoding
           if (codings.length !== 0 && request.method !== 'HEAD' && request.method !== 'CONNECT' && !nullBodyStatus.includes(status) && !willFollow) {
-            for (let i = 0; i < codings.length; ++i) {
+            for (let i = codings.length - 1; i >= 0; --i) {
               const coding = codings[i]
               // https://www.rfc-editor.org/rfc/rfc9112.html#section-7.2
               if (coding === 'x-gzip' || coding === 'gzip') {

package/node_modules/undici/lib/web/fetch/request.js

@@ -82,6 +82,7 @@ let patchMethodWarning = false
 class Request {
   // https://fetch.spec.whatwg.org/#dom-request
   constructor (input, init = {}) {
+    webidl.util.markAsUncloneable(this)
     if (input === kConstruct) {
       return
     }

package/node_modules/undici/lib/web/fetch/response.js

@@ -110,6 +110,7 @@ class Response {
 
   // https://fetch.spec.whatwg.org/#dom-response
   constructor (body = null, init = {}) {
+    webidl.util.markAsUncloneable(this)
     if (body === kConstruct) {
       return
     }

package/node_modules/undici/lib/web/fetch/webidl.js

@@ -1,6 +1,7 @@
 'use strict'
 
 const { types, inspect } = require('node:util')
+const { markAsUncloneable } = require('node:worker_threads')
 const { toUSVString } = require('../../core/util')
 
 /** @type {import('../../../types/webidl').Webidl} */
@@ -86,6 +87,7 @@ webidl.util.Type = function (V) {
   }
 }
 
+webidl.util.markAsUncloneable = markAsUncloneable || (() => {})
 // https://webidl.spec.whatwg.org/#abstract-opdef-converttoint
 webidl.util.ConvertToInt = function (V, bitLength, signedness, opts) {
   let upperBound

package/node_modules/undici/lib/web/websocket/events.js

@@ -14,6 +14,7 @@ class MessageEvent extends Event {
   constructor (type, eventInitDict = {}) {
     if (type === kConstruct) {
       super(arguments[1], arguments[2])
+      webidl.util.markAsUncloneable(this)
       return
     }
 
@@ -26,6 +27,7 @@ class MessageEvent extends Event {
     super(type, eventInitDict)
 
     this.#eventInit = eventInitDict
+    webidl.util.markAsUncloneable(this)
   }
 
   get data () {
@@ -112,6 +114,7 @@ class CloseEvent extends Event {
     super(type, eventInitDict)
 
     this.#eventInit = eventInitDict
+    webidl.util.markAsUncloneable(this)
   }
 
   get wasClean () {
@@ -142,6 +145,7 @@ class ErrorEvent extends Event {
     webidl.argumentLengthCheck(arguments, 1, prefix)
 
     super(type, eventInitDict)
+    webidl.util.markAsUncloneable(this)
 
     type = webidl.converters.DOMString(type, prefix, 'type')
     eventInitDict = webidl.converters.ErrorEventInit(eventInitDict ?? {})

package/node_modules/undici/lib/web/websocket/websocket.js

@@ -51,6 +51,8 @@ class WebSocket extends EventTarget {
   constructor (url, protocols = []) {
     super()
 
+    webidl.util.markAsUncloneable(this)
+
     const prefix = 'WebSocket constructor'
     webidl.argumentLengthCheck(arguments, 1, prefix)
 

package/node_modules/undici/package.json

@@ -1,6 +1,6 @@
 {
   "name": "undici",
-  "version": "6.20.1",
+  "version": "6.21.1",
   "description": "An HTTP/1.1 client, written from scratch for Node.js",
   "homepage": "https://undici.nodejs.org",
   "bugs": {

package/node_modules/undici/types/interceptors.d.ts

@@ -1,3 +1,5 @@
+import { LookupOptions } from 'node:dns'
+
 import Dispatcher from "./dispatcher";
 import RetryHandler from "./retry-handler";
 
@@ -9,6 +11,18 @@ declare namespace Interceptors {
   export type RedirectInterceptorOpts = { maxRedirections?: number }
   export type ResponseErrorInterceptorOpts = { throwOnError: boolean }
 
+  // DNS interceptor
+  export type DNSInterceptorRecord = { address: string, ttl: number, family: 4 | 6 }
+  export type DNSInterceptorOriginRecords = { 4: { ips: DNSInterceptorRecord[] } | null, 6: { ips: DNSInterceptorRecord[] } | null }
+  export type DNSInterceptorOpts = {
+    maxTTL?: number
+    maxItems?: number
+    lookup?: (hostname: string, options: LookupOptions, callback: (err: NodeJS.ErrnoException | null, addresses: DNSInterceptorRecord[]) => void) => void
+    pick?: (origin: URL, records: DNSInterceptorOriginRecords, affinity: 4 | 6) => DNSInterceptorRecord
+    dualStack?: boolean
+    affinity?: 4 | 6
+  }
+
   export function createRedirectInterceptor(opts: RedirectInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
   export function dump(opts?: DumpInterceptorOpts): Dispatcher.DispatcherComposeInterceptor
   export function retry(opts?: RetryInterceptorOpts): Dispatcher.DispatcherComposeInterceptor

package/node_modules/undici/types/retry-handler.d.ts

@@ -32,7 +32,7 @@ declare namespace RetryHandler {
       };
     },
     callback: OnRetryCallback
-  ) => number | null;
+  ) => void
 
   export interface RetryOptions {
     /**

package/node_modules/undici/types/webidl.d.ts

@@ -67,6 +67,12 @@ interface WebidlUtil {
    * Stringifies {@param V}
    */
   Stringify (V: any): string
+
+  /**
+   * Mark a value as uncloneable for Node.js.
+   * This is only effective in some newer Node.js versions.
+   */
+  markAsUncloneable (V: any): void
 }
 
 interface WebidlConverters {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@florianpat/lando-core",
   "description": "The libraries that power all of Lando. Fork by flo for compose integration",
-  "version": "3.23.22",
+  "version": "3.23.27-1florianPat.0",
   "author": "Florian Patruck @florianPat",
   "license": "GPL-3.0",
   "repository": "florianPat/lando-core",
@@ -168,7 +168,7 @@
   "devDependencies": {
     "@babel/eslint-parser": "^7.16.0",
     "@lando/leia": "^1.0.0-beta.4",
-    "@lando/vitepress-theme-default-plus": "github:lando/vitepress-theme-default-plus#main",
+    "@lando/vitepress-theme-default-plus": "^1.1.1",
     "@yao-pkg/pkg": "^5.16.1",
     "chai": "^4.3.4",
     "chai-as-promised": "^7.1.1",
@@ -247,9 +247,9 @@
     "yargs-parser"
   ],
   "dist": {
-    "integrity": "sha512-7Ak4ffLOApUfus6mu06+SGYIHKtpDFx45ACv5gQhuNtY8JgE/xyPL5EwCabkQXkZhwHKkN8nQXRUdFk9d7Tq/w==",
-    "shasum": "1f59804c71e8e5ddad072d8fa102ad50d6f3d956",
-    "filename": "florianpat-lando-core-3.23.22.tgz",
-    "unpackedSize": 60948228
+    "integrity": "sha512-EF8oq87DSgrav9p/64DkDyDuudJ/hW3soeFWiiuZzhjIIZ52UV98g6DGiIjVVyowcVtuAL6sAf/cidZkv7s+tQ==",
+    "shasum": "7fa58d190ddcacde2bb53ede9fffc5d92c0bb42c",
+    "filename": "florianpat-lando-core-3.23.27-1florianPat.0.tgz",
+    "unpackedSize": 60965868
   }
 }

package/release-aliases/3-EDGE

@@ -1 +1 @@
-v3.24.0-beta.8
+v3.24.0-beta.12

package/release-aliases/3-STABLE

@@ -1 +1 @@
-v3.23.22
+v3.23.26

package/scripts/install-docker-desktop.sh

@@ -59,7 +59,7 @@ debug "INSTALLER: $INSTALLER"
 debug "USER: $USER"
 
 # add accept license if set
-if [ "${DEBUG}" == 1 ]; then OPTS="$OPTS --accept-license"; fi
+if [ "${ACCEPT_LICENSE}" == 1 ]; then OPTS="$OPTS --accept-license"; fi
 
 # run
 hdiutil attach "$INSTALLER"

package/scripts/install-docker-engine.sh

@@ -3,7 +3,7 @@ set -eo pipefail
 
 DEBUG=0
 INSTALLER="get-docker.sh"
-VERSION="27.3.1"
+VERSION="27.5.0"
 OPTS=
 
 debug() {

package/scripts/lando-entrypoint.sh

@@ -62,7 +62,7 @@ if [ -d "/scripts" ] && [ -z ${LANDO_NO_SCRIPTS+x} ]; then
 
   # Keep this for backwards compat and fallback opts
   chmod +x /scripts/* || true
-  find /scripts/ -type f -name "*.sh" -exec {} \;
+  find /scripts/ -type f \( -name "*.sh" -o ! -name "*.*" \) -exec {} \;
 fi;
 
 # Run any bash scripts that we've loaded into the mix for autorun unless we've

package/utils/get-compose-x.js

@@ -27,7 +27,7 @@ const getDockerBin = (bin, base, pathFallback = true) => {
   }
 };
 
-module.exports = ({orchestratorVersion = '2.30.3', userConfRoot = os.tmpdir()} = {}) => {
+module.exports = ({orchestratorVersion = '2.31.0', userConfRoot = os.tmpdir()} = {}) => {
   const orchestratorBin = `docker-compose-v${orchestratorVersion}`;
   switch (process.platform) {
     case 'darwin':

package/utils/get-config-defaults.js

@@ -8,20 +8,20 @@ const os = require('os');
 const getBuildEngineVersion = (platform = process.landoPlatform ?? process.platform) => {
   switch (platform) {
     case 'darwin':
-      return '4.36.0';
+      return '4.37.2';
     case 'linux':
-      return '27.3.1';
+      return '27.5.0';
     case 'win32':
-      return '4.36.0';
+      return '4.37.1';
     case 'wsl':
-      return '4.36.0';
+      return '4.37.1';
   }
 };
 
 // Default config
 const defaultConfig = options => ({
   orchestratorSeparator: '_',
-  orchestratorVersion: '2.30.3',
+  orchestratorVersion: '2.31.0',
   configSources: [],
   coreBase: path.resolve(__dirname, '..'),
   disablePlugins: [],

package/utils/to-lando-container.js

@@ -1,22 +1,36 @@
 'use strict';
 
-module.exports = ({Labels, Id, Status}, separator = '_') => {
+const path = require('path');
+
+module.exports = ({Labels, Id, Status}, separator = '_', src = []) => {
   // Get name of docker container.
   const app = Labels['com.docker.compose.project'];
   const service = Labels['com.docker.compose.service'];
   const num = Labels['com.docker.compose.container-number'];
   const lando = Labels['io.lando.container'];
   const special = Labels['io.lando.service-container'];
+
+  // if we have io.lando.root and io.lando.
+  if (Labels['io.lando.root'] && Labels['io.lando.landofiles']) {
+    src = Labels['io.lando.landofiles'].split(',').map(landofile => path.join(Labels['io.lando.root'], landofile));
+
+  // or legacy support for Labels['io.lando.src']
+  } else if (Labels['io.lando.src']) {
+    src = Labels['io.lando.src'].split(',');
+
+  // or its just unknown
+  } else src = 'unknown';
+
   // Build generic container.
   return {
     id: Id,
     service: service,
     name: [app, service, num].join(separator),
     app: (special !== 'TRUE') ? app : '_global_',
-    src: (Labels['io.lando.src']) ? Labels['io.lando.src'].split(',') : 'unknown',
     kind: (special !== 'TRUE') ? 'app' : 'service',
     lando: (lando === 'TRUE') ? true : false,
     instance: Labels['io.lando.id'] || 'unknown',
     status: Status,
+    src,
   };
 };