Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

26.1 KB
Raw Blame
/** 手动集成验证:pnpm --filter @cindy/device-link-relay run interop:nginx。
 * Docker 内运行真实 Nginx、CLI、中转、TLS/WS/媒体;不连接用户服务器,不读取本机凭证。
 * 容器与构建目录仅属于本次验证,结束时精确清理。证书只在容器的临时文件系统生成。
 */
import assert from 'node:assert/strict';
import { execFileSync, spawn } from 'node:child_process';
import { randomUUID } from 'node:crypto';
import fs from 'node:fs';
import https from 'node:https';
import os from 'node:os';
import path from 'node:path';
import { fileURLToPath } from 'node:url';
import WebSocket from 'ws';
import { createRelaySigningKey, issueRelayDeviceCert } from '@cindy/device-link';
import { nodeRelayAuthCrypto } from '@cindy/device-link/node-relay-crypto';
import { createDeviceCredential, initializeRelay, startRelayServer } from '../src/index';
import { startChallengeServer } from '../src/certificates';

function command(file: string, args: string[]) {
  return execFileSync(file, args, {
    encoding: 'utf8',
    stdio: ['ignore', 'pipe', 'pipe'],
    timeout: 60_000,
  });
}

async function retry<T>(check: () => Promise<T>, accepted: (value: T) => boolean, label = ''): Promise<T> {
  const deadline = Date.now() + 10_000;
  let last = '';
  while (Date.now() < deadline) {
    try {
      const value = await check();
      if (accepted(value)) return value;
      last = String(value).slice(0, 120);
    } catch (error) {
      last = String(error);
      /* Nginx graceful reload */
    }
    await new Promise((resolve) => setTimeout(resolve, 50));
  }
  throw new Error(`Nginx interop condition timed out (${label}): ${last}`);
}

async function inside() {
  assert.equal(process.env.CINDY_NGINX_INTEROP_CONTAINER, '1');
  assert.equal(fs.readFileSync('/proc/1/cmdline', 'utf8').replace(/\0/g, ' ').trim(), 'sleep infinity');
  const dataDir = '/var/lib/cindy-relay';
  const main = '/etc/nginx/nginx.conf';
  const site = '/etc/nginx/conf.d/website.conf';
  fs.mkdirSync('/tmp/website', { recursive: true });
  fs.mkdirSync('/tmp/acme/.well-known/acme-challenge', { recursive: true });
  fs.writeFileSync('/tmp/acme/.well-known/acme-challenge/other-client', 'other-client-proof');
  function certificate(name: string, san: string) {
    const dir = `/tmp/${name}`;
    fs.mkdirSync(dir, { recursive: true });
    fs.writeFileSync(`${dir}/openssl.cnf`, '[req]\ndistinguished_name = dn\n[dn]\n');
    command('openssl', [
      'req',
      '-config',
      `${dir}/openssl.cnf`,
      '-x509',
      '-newkey',
      'rsa:2048',
      '-nodes',
      '-days',
      '2',
      '-keyout',
      `${dir}/key.pem`,
      '-out',
      `${dir}/cert.pem`,
      '-subj',
      '/CN=Cindy interop',
      '-addext',
      `subjectAltName=${san}`,
    ]);
    return {
      key: fs.readFileSync(`${dir}/key.pem`, 'utf8'),
      cert: fs.readFileSync(`${dir}/cert.pem`, 'utf8'),
    };
  }
  const websiteMaterial = certificate('website-tls', 'DNS:website.example.test');
  const initialMain =
    'user nobody nogroup; worker_processes 1; pid /tmp/nginx.pid; error_log /tmp/nginx-error.log; events { worker_connections 128; } http { access_log /tmp/nginx-access.log; error_page 502 /custom-error; recursive_error_pages on; include /etc/nginx/conf.d/website.conf; }\n';
  const initialSite = `server { listen 80 default_server; server_name website.example.test;
    location / { return 200 "website-home"; }
    location = /website-offline { return 502; }
    location = /custom-error { recursive_error_pages off; return 502 "website-custom-error"; }
    location ^~ /.well-known/acme-challenge/ { root /tmp/acme; try_files $uri =404; }
  }
  server { listen 443 ssl default_server; server_name _;
    ssl_certificate /tmp/website-tls/cert.pem; ssl_certificate_key /tmp/website-tls/key.pem;
    location / { return 200 "website-home"; }
    location = /website-offline { return 502; }
    location = /custom-error { recursive_error_pages off; return 502 "website-custom-error"; }
  }\n`;
  fs.writeFileSync(main, initialMain);
  fs.writeFileSync(site, initialSite);
  const startNginx = () => spawn('nginx', ['-c', main, '-g', 'daemon off;'], {
    stdio: 'ignore',
  });
  let nginx = startNginx();
  const restartFixture = async () => {
    // 仅重建本容器内独立用例的初始监听布局;被测生产部署始终只发送 HUP。
    await new Promise<void>((resolve) => { nginx.once('exit', () => resolve()); nginx.kill('SIGQUIT'); });
    nginx = startNginx();
  };
  const trackReload = (label: string) => {
    const master = fs.readFileSync('/tmp/nginx.pid', 'utf8').trim();
    const oldWorkers = fs.readFileSync(`/proc/${master}/task/${master}/children`, 'utf8').trim().split(/\s+/).filter(Boolean);
    return () => retry(async () => oldWorkers.every((pid) => !fs.existsSync(`/proc/${pid}`)), Boolean, label);
  };
  await retry(
    () => fetch('http://127.0.0.1').then((r) => r.text()),
    (value) => value === 'website-home',
  );
  const cli = (action: string, flags: string[] = []): Record<string, any> =>
    JSON.parse(command(process.execPath, ['/tmp/relay.mjs', 'nginx', '--action', action, ...flags]).trim());
  const prepare = (existing = false, address = '127.0.0.1') =>
    cli('prepare', ['--address', address, ...(existing ? ['--existing-certificate'] : [])]);
  const owner = createDeviceCredential();
  const ownerKey = createRelaySigningKey(nodeRelayAuthCrypto);
  const relayId = randomUUID();
  await initializeRelay({
    dataDir,
    name: 'Nginx interop',
    ownerUserId: 'interop-owner',
    ownerDeviceId: 'owner-pc',
    ownerDeviceName: 'PC',
    ownerCredentialHash: owner.credentialHash,
    relayId,
    ownerPublicKey: ownerKey.publicKey,
    ownerCert: issueRelayDeviceCert(nodeRelayAuthCrypto, ownerKey.seed, {
      relayId,
      deviceId: 'owner-pc',
      publicKey: ownerKey.publicKey,
      role: 'owner',
      issuedAt: Date.now(),
    }),
  });
  let material = certificate('relay-one', 'IP:127.0.0.1');
  const saveMaterial = () => {
    fs.mkdirSync(`${dataDir}/tls`, { recursive: true, mode: 0o700 });
    fs.writeFileSync(`${dataDir}/tls/material.json`, JSON.stringify(material), {
      mode: 0o600,
    });
  };
  let servername: string | undefined;
  const get = (pathname: string, method = 'GET', body?: Buffer, headers: Record<string, string> = {}, localAddress?: string) =>
    new Promise<{ status: number; body: Buffer }>((resolve, reject) => {
      const req = https.request(
        `https://127.0.0.1${pathname}`,
        { method, ca: material.cert, agent: false, servername, localAddress, headers: { ...headers, ...(servername ? { Host: servername } : {}) } },
        (res) => {
          const chunks: Buffer[] = [];
          res.on('data', (chunk) => chunks.push(chunk));
          res.on('end', () => resolve({ status: res.statusCode!, body: Buffer.concat(chunks) }));
        },
      );
      req.on('error', reject);
      req.end(body);
    });
  const checkPairingSources = async () => {
    for (let i = 0; i < 20; i++) {
      assert.equal((await get('/api/device-link/relay/pair', 'POST', Buffer.from('{}'), { 'X-Forwarded-For': `203.0.113.${i + 1}` })).status, 400);
    }
    assert.equal((await get('/api/device-link/relay/pair', 'POST', Buffer.from('{}'), { 'X-Forwarded-For': '198.51.100.1' })).status, 429);
    assert.equal((await get('/api/device-link/relay/pair', 'POST', Buffer.from('{}'), { 'X-Forwarded-For': '198.51.100.1' }, '127.0.0.2')).status, 400);
  };
  let relay: Awaited<ReturnType<typeof startRelayServer>> | undefined;
  let challenge: Awaited<ReturnType<typeof startChallengeServer>> | undefined;
  try {
    fs.writeFileSync(site, initialSite.slice(initialSite.indexOf('server { listen 443')));
    command('nginx', ['-t']);
    await restartFixture();
    const httpsOnly = prepare();
    challenge = await startChallengeServer({
      host: '127.0.0.1',
      port: httpsOnly.challengePort,
      challenges: new Map([['https-only', 'https-only-proof']]),
    });
    await retry(
      () => fetch('http://127.0.0.1/.well-known/acme-challenge/https-only').then((r) => r.text()),
      (value) => value === 'https-only-proof',
      'HTTPS-only HTTP-01',
    );
    cli('rollback');
    await challenge.close();
    challenge = undefined;
    fs.writeFileSync(site, initialSite);
    command('nginx', ['-t']);
    await restartFixture();
    const plan = prepare();
    challenge = await startChallengeServer({
      host: '127.0.0.1',
      port: plan.challengePort,
      challenges: new Map([['cindy-token', 'cindy-proof']]),
    });
    await retry(
      () => fetch('http://127.0.0.1/.well-known/acme-challenge/cindy-token').then((r) => r.text()),
      (value) => value === 'cindy-proof',
      'HTTP-01',
    );
    await retry(
      () => fetch('http://127.0.0.1/.well-known/acme-challenge/other-client').then((r) => r.text()),
      (value) => value === 'other-client-proof',
      'other ACME live',
    );
    await challenge.close();
    challenge = undefined;
    await retry(
      () => fetch('http://127.0.0.1/.well-known/acme-challenge/other-client').then((r) => r.text()),
      (value) => value === 'other-client-proof',
      'other ACME offline',
    );
    saveMaterial();
    relay = await startRelayServer({
      dataDir,
      host: '127.0.0.1',
      port: plan.port,
      tls: material,
      publicUrl: 'https://127.0.0.1',
      trustProxyHeaders: true,
    });
    const initialReloaded = trackReload('initial TLS workers replaced');
    cli('activate');
    // 首个新 worker 能响应时,旧 worker 可能尚在退出;后续写请求须等旧证书监听停止接收。
    await initialReloaded();
    await retry(
      () => get('/api/device-link/relay/info'),
      (value) => value.status === 200,
      'initial relay HTTPS',
    );
    assert.equal(JSON.parse((await get('/api/device-link/relay/info')).body.toString()).relayId, relayId);
    assert.equal((await get('/')).body.toString(), 'website-home');
    const originalWebsite = await new Promise<string>((resolve, reject) => {
      const req = https.get(
        {
          hostname: '127.0.0.1',
          servername: 'website.example.test',
          headers: { Host: 'website.example.test' },
          ca: websiteMaterial.cert,
          agent: false,
        },
        (res) => {
          let body = '';
          res.on('data', (chunk) => {
            body += chunk;
          });
          res.on('end', () => resolve(body));
        },
      );
      req.on('error', reject);
    });
    assert.equal(originalWebsite, 'website-home');
    cli('commit');
    await checkPairingSources();
    const socket = new WebSocket('wss://127.0.0.1/api/device-link/ws', {
      ca: material.cert,
      headers: { Authorization: `CindyRelay ${owner.credential}` },
    });
    await new Promise<void>((resolve, reject) => {
      socket.once('open', resolve);
      socket.once('error', reject);
    });
    socket.close();
    const bytes = Buffer.alloc(1_100_000, 42);
    const auth = {
      Authorization: `CindyRelay ${owner.credential}`,
      'Content-Type': 'application/json',
    };
    const upload = await get(
      '/api/device-link/media/presign-put',
      'POST',
      Buffer.from(
        JSON.stringify({
          size: bytes.length,
          ext: 'bin',
          contentType: 'application/octet-stream',
        }),
      ),
      auth,
    );
    assert.equal(upload.status, 200);
    const { putUrl } = JSON.parse(upload.body.toString());
    const signedPath = new URL(putUrl).pathname + new URL(putUrl).search;
    assert.equal(
      (await get(new URL(putUrl).pathname + new URL(putUrl).search, 'PUT', bytes, { 'Content-Type': 'application/octet-stream' })).status,
      200,
    );
    console.log('[nginx-interop] IP TLS, REST, authenticated WebSocket, >1 MB upload, original website and other ACME client passed');
    material = certificate('relay-two', 'IP:127.0.0.1');
    saveMaterial();
    relay.updateTls(material);
    cli('renew');
    await retry(
      () => get('/api/device-link/relay/info'),
      (value) => value.status === 200,
    );
    prepare();
    cli('rollback');
    await retry(
      () => get('/api/device-link/relay/info'),
      (value) => value.status === 200,
    );
    cli('remove');
    assert.equal(fs.readFileSync(main, 'utf8'), initialMain);
    assert.equal(fs.readFileSync(site, 'utf8'), initialSite);
    await relay.close();
    relay = undefined;
    challenge = undefined;
    // 已有可信 HTTPS 时:保留原证书管理,中转自动改为回环 HTTP。
    fs.writeFileSync('/tmp/website-tls/cert.pem', material.cert);
    fs.writeFileSync('/tmp/website-tls/key.pem', material.key);
    command('nginx', ['-t']);
    await restartFixture();
    await retry(() => get('/'), (value) => value.body.toString() === 'website-home', 'existing HTTPS initial website');
    const existingReloaded = trackReload('existing HTTPS workers replaced');
    const existing = prepare(true);
    assert.equal(existing.existingCertificate, true);
    relay = await startRelayServer({
      dataDir,
      host: '127.0.0.1',
      port: existing.port,
      publicUrl: 'https://127.0.0.1',
      trustProxyHeaders: true,
    });
    cli('activate');
    cli('commit');
    await existingReloaded();
    await retry(
      () => get('/api/device-link/relay/info'),
      (value) => value.status === 200,
    );
    await checkPairingSources();
    await relay.close();
    relay = undefined;
    assert.equal((await get(signedPath)).status, 502);
    const websiteError = await get('/website-offline');
    assert.equal(websiteError.status, 502);
    assert.equal(websiteError.body.toString(), 'website-custom-error');
    await retry(
      async () => fs.readFileSync('/tmp/nginx-access.log', 'utf8'),
      (value) => value.includes('GET / HTTP/1.1'),
      'original website logging',
    );
    for (const log of ['/tmp/nginx-access.log', '/tmp/nginx-error.log']) {
      assert.ok(!fs.readFileSync(log, 'utf8').includes('/api/device-link/'), 'relay paths and signed queries must not enter inherited logs');
    }
    cli('remove');
    assert.equal(fs.readFileSync(site, 'utf8'), initialSite);
    const httpOnlySite = initialSite.slice(0, initialSite.indexOf('server { listen 443'))
      .replace('listen 80 default_server;', '').replace('server_name website.example.test;', 'server_name _;');
    fs.writeFileSync(site, httpOnlySite);
    command('nginx', ['-t']);
    await restartFixture();
    await retry(() => fetch('http://127.0.0.1').then((res) => res.text()), (value) => value === 'website-home', 'implicit HTTP initial website');
    const implicitReloaded = trackReload('implicit HTTP workers replaced');
    const httpOnly = prepare();
    await implicitReloaded();
    assert.equal(await fetch('http://127.0.0.1').then((res) => res.text()), 'website-home');
    relay = await startRelayServer({ dataDir, host: '127.0.0.1', port: httpOnly.port, tls: material, publicUrl: 'https://127.0.0.1' });
    cli('activate');
    cli('commit');
    await retry(
      () => get('/api/device-link/relay/info'),
      (value) => value.status === 200,
    );
    assert.equal((await get('/')).body.toString(), 'website-home');
    cli('remove');
    assert.equal(fs.readFileSync(site, 'utf8'), httpOnlySite);
    console.log('[nginx-interop] HTTP-only and HTTPS-only installations passed');
    await relay.close();
    relay = undefined;
    fs.appendFileSync('/etc/hosts', '\n127.0.0.1 relay.example.test\n');
    fs.writeFileSync('/tmp/website-tls/cert.pem', websiteMaterial.cert);
    fs.writeFileSync('/tmp/website-tls/key.pem', websiteMaterial.key);
    const unrelated = `server { listen 127.0.0.2:443 ssl; server_name first.example.test;
      ssl_certificate /tmp/website-tls/cert.pem; ssl_certificate_key /tmp/website-tls/key.pem; return 200 "other-first"; }
    server { listen 127.0.0.2:443 ssl default_server; server_name _;
      ssl_certificate /tmp/website-tls/cert.pem; ssl_certificate_key /tmp/website-tls/key.pem; return 200 "other-default"; }\n`;
    const specificSite =
      initialSite
        .replace('listen 80 default_server;', 'listen 127.0.0.1:80;')
        .replace('listen 443 ssl default_server;', 'listen 127.0.0.1:443 ssl;') + unrelated;
    for (const address of ['127.0.0.1', 'relay.example.test']) {
      fs.writeFileSync(site, specificSite);
      command('nginx', ['-t']);
      await restartFixture();
      material = certificate(
        address === '127.0.0.1' ? 'specific-ip' : 'domain',
        address === '127.0.0.1' ? 'IP:127.0.0.1' : 'DNS:relay.example.test',
      );
      saveMaterial();
      const specific = prepare(false, address);
      relay = await startRelayServer({ dataDir, host: '127.0.0.1', port: specific.port, tls: material, publicUrl: `https://${address}` });
      servername = address === '127.0.0.1' ? undefined : address;
      cli('activate');
      cli('commit');
      await retry(
        () => get('/api/device-link/relay/info'),
        (value) => value.status === 200,
      );
      assert.equal((await get('/')).body.toString(), 'website-home');
      assert.ok(fs.readFileSync(site, 'utf8').includes(unrelated));
      for (const [hostname, expected] of [
        ['127.0.0.1', 'website-home'],
        ['127.0.0.2', 'other-default'],
      ]) {
        await retry(
          () =>
            new Promise<string>((resolve, reject) => {
              const req = https.get(
                {
                  hostname,
                  servername: 'website.example.test',
                  headers: { Host: 'website.example.test' },
                  ca: websiteMaterial.cert,
                  agent: false,
                },
                (res) => {
                  let body = '';
                  res.on('data', (chunk) => {
                    body += chunk;
                  });
                  res.on('end', () => resolve(body));
                },
              );
              req.on('error', reject);
            }),
          (value) => value === expected,
        );
      }
      cli('remove');
      assert.equal(fs.readFileSync(site, 'utf8'), specificSite);
      await relay.close();
      relay = undefined;
    }
    const sharedMaterial = certificate('shared-website', 'DNS:relay.example.test');
    fs.writeFileSync('/tmp/website-tls/cert.pem', sharedMaterial.cert);
    fs.writeFileSync('/tmp/website-tls/key.pem', sharedMaterial.key);
    const sharedSite = `server { listen 127.0.0.2:443 ssl default_server; server_name _;
      ssl_certificate /tmp/website-tls/cert.pem; ssl_certificate_key /tmp/website-tls/key.pem; return 200 "other-default"; }
    server { listen 127.0.0.1:80; listen 127.0.0.1:443 ssl; listen 127.0.0.2:443 ssl; server_name relay.example.test;
      ssl_certificate /tmp/website-tls/cert.pem; ssl_certificate_key /tmp/website-tls/key.pem; return 200 "shared-website"; }\n`;
    fs.writeFileSync(site, sharedSite);
    await restartFixture();
    material = certificate('shared-relay', 'DNS:relay.example.test');
    saveMaterial();
    const shared = prepare(false, 'relay.example.test');
    relay = await startRelayServer({ dataDir, host: '127.0.0.1', port: shared.port, tls: material, publicUrl: 'https://relay.example.test' });
    servername = 'relay.example.test';
    cli('activate');
    cli('commit');
    await retry(() => get('/api/device-link/relay/info'), (value) => value.status === 200, 'shared server target');
    const otherSocket = await new Promise<string>((resolve, reject) => {
      const req = https.get({
        hostname: '127.0.0.2', servername, headers: { Host: servername! }, ca: sharedMaterial.cert, agent: false,
      }, (res) => {
        let text = '';
        res.on('data', (chunk) => { text += chunk; });
        res.on('end', () => resolve(text));
      });
      req.on('error', reject);
    });
    assert.equal(otherSocket, 'shared-website');
    assert.equal(await fetch('http://127.0.0.1', { headers: { Host: servername } }).then((res) => res.text()), 'shared-website');
    cli('remove');
    assert.equal(fs.readFileSync(site, 'utf8'), sharedSite);
    await relay.close();
    relay = undefined;
    fs.appendFileSync('/etc/hosts', '\n203.0.113.10 nat-relay.example.test\n');
    fs.writeFileSync(site, httpOnlySite);
    await restartFixture();
    material = certificate('nat-relay', 'DNS:nat-relay.example.test');
    saveMaterial();
    const nat = prepare(false, 'nat-relay.example.test');
    relay = await startRelayServer({ dataDir, host: '127.0.0.1', port: nat.port, tls: material, publicUrl: 'https://nat-relay.example.test' });
    servername = 'nat-relay.example.test';
    cli('activate');
    cli('commit');
    await retry(() => get('/api/device-link/relay/info'), (value) => value.status === 200, 'NAT public address on a wildcard');
    cli('remove');
    assert.equal(fs.readFileSync(site, 'utf8'), httpOnlySite);
    await relay.close();
    relay = undefined;
    console.log('[nginx-interop] NAT public DNS, shared server names, isolated pairing sources and signed URL log privacy passed');
    console.log('[nginx-interop] specific IP sockets, domain implicit TLS default and unrelated IP website preservation passed');
    console.log('[nginx-interop] renewal, interrupted deployment rollback, existing HTTPS reuse and exact uninstall restoration passed');
  } catch (error) {
    console.error('[nginx-interop] fixture configuration:', fs.readFileSync(site, 'utf8'), fs.existsSync('/etc/cindy-relay/nginx/http.conf') ? fs.readFileSync('/etc/cindy-relay/nginx/http.conf', 'utf8') : 'not prepared');
    throw error;
  } finally {
    await relay?.close();
    await challenge?.close();
    nginx.kill('SIGQUIT');
  }
}

async function docker() {
  const esbuild = await import('esbuild');
  const packageRoot = fileURLToPath(new URL('../', import.meta.url));
  const temp = fs.mkdtempSync(path.join(os.tmpdir(), 'cindy-nginx-interop-'));
  const container = `cindy-nginx-interop-${randomUUID()}`;
  const sources: string[] = [];
  let started = false;
  try {
    await esbuild.build({
      entryPoints: [fileURLToPath(import.meta.url)],
      bundle: true,
      platform: 'node',
      target: 'node22',
      format: 'esm',
      outfile: path.join(temp, 'nginx-interop.mjs'),
      external: ['esbuild', 'bufferutil', 'utf-8-validate'],
      banner: {
        js: "import {createRequire} from 'node:module';const require=createRequire(import.meta.url);",
      },
    });
    fs.copyFileSync(path.join(packageRoot, 'dist', 'relay.mjs'), path.join(temp, 'relay.mjs'));
    command('docker', ['run', '-d', '--name', container, '--label', 'cindy-test=nginx-interop', '--env', 'CINDY_NGINX_INTEROP_CONTAINER=1', 'node:22-slim', 'sleep', 'infinity']);
    started = true;
    console.log('[nginx-interop] isolated container started; loading tools from official images');
    command('docker', [
      'exec',
      container,
      'mkdir',
      '-p',
      '/etc/nginx/conf.d',
      '/var/log/nginx',
      '/var/cache/nginx',
      '/usr/sbin',
      '/opt/cindy-test',
    ]);
    // 不在测试中访问软件源或安装系统包;从官方镜像复制工具及其依赖,使用独立 musl 搜索路径。
    // 这些文件全部在本次容器内,不修改宿主环境;三个镜像缓存后可完全离线复跑。
    const stage = (image: string, binary: string, name: string) => {
      const source = command('docker', ['create', '--label', 'cindy-test=nginx-interop', image]).trim();
      sources.push(source);
      const listing = command('docker', ['run', '--rm', '--entrypoint', 'ldd', image, binary]);
      const loader = /^\s*(\/lib\/ld-musl-\S+)/m.exec(listing)?.[1];
      if (!loader) throw new Error('Expected an Alpine musl tool image');
      const libraries = [...new Set([...listing.matchAll(/=> (\/\S+)/g)].map((m) => m[1]))];
      const resolvedLibraries = command('docker', [
        'run',
        '--rm',
        '--entrypoint',
        'sh',
        image,
        '-c',
        'for library do readlink -f "$library"; done',
        'libraries',
        ...libraries,
      ])
        .trim()
        .split('\n');
      const folder = path.join(temp, `${name}-libs`);
      fs.mkdirSync(folder);
      for (const [index, library] of libraries.entries())
        command('docker', ['cp', `${source}:${resolvedLibraries[index]}`, path.join(folder, path.posix.basename(library))]);
      command('docker', ['cp', '-L', `${source}:${binary}`, path.join(temp, name)]);
      command('docker', ['cp', folder, `${container}:/opt/cindy-test/`]);
      command('docker', ['cp', path.join(temp, name), `${container}:/opt/cindy-test/${name}`]);
      if (name === 'nginx') {
        command('docker', ['cp', '-L', `${source}:${loader}`, path.join(temp, 'musl-loader')]);
        command('docker', ['cp', path.join(temp, 'musl-loader'), `${container}:${loader}`]);
        const arch = path.posix.basename(loader).slice('ld-musl-'.length, -'.so.1'.length);
        command('docker', [
          'exec',
          container,
          'node',
          '-e',
          `require('node:fs').writeFileSync('/etc/ld-musl-${arch}.path','/opt/cindy-test/nginx-libs');require('node:fs').symlinkSync('/opt/cindy-test/nginx','/usr/sbin/nginx')`,
        ]);
      }
    };
    stage('nginx:alpine', '/usr/sbin/nginx', 'nginx');
    stage('certbot/certbot:latest', '/usr/bin/openssl', 'openssl');
    const opensslWrapper = path.join(temp, 'openssl-wrapper');
    fs.writeFileSync(opensslWrapper, '#!/bin/sh\nLD_LIBRARY_PATH=/opt/cindy-test/openssl-libs exec /opt/cindy-test/openssl "$@"\n');
    command('docker', ['cp', opensslWrapper, `${container}:/usr/local/bin/openssl`]);
    command('docker', ['exec', container, 'chmod', '755', '/usr/local/bin/openssl']);
    command('docker', ['cp', path.join(temp, 'relay.mjs'), `${container}:/tmp/relay.mjs`]);
    command('docker', ['cp', path.join(temp, 'nginx-interop.mjs'), `${container}:/tmp/nginx-interop.mjs`]);
    execFileSync('docker', ['exec', container, 'node', '/tmp/nginx-interop.mjs', '--inside'], { stdio: 'inherit', timeout: 120_000 });
  } finally {
    for (const source of sources) execFileSync('docker', ['rm', '-f', source], { stdio: 'ignore' });
    if (started) execFileSync('docker', ['rm', '-f', container], { stdio: 'ignore' });
    const resolved = path.resolve(temp);
    if (path.dirname(resolved) === path.resolve(os.tmpdir()) && path.basename(resolved).startsWith('cindy-nginx-interop-'))
      fs.rmSync(resolved, { recursive: true, force: true });
  }
}

(process.argv.includes('--inside') ? inside() : docker()).catch((error) => {
  console.error(error);
  process.exitCode = 1;
});