@yibi/newapi-sub2api-stack 0.1.0

package/README.md

@@ -0,0 +1,110 @@
+# New API + Sub2API Stack Installer
+
+An npm CLI that installs the upstream New API and Sub2API Docker stacks on a
+Linux host. It generates credentials locally, creates two isolated Compose
+networks, pulls upstream images, starts the services, and verifies their HTTP
+health endpoints.
+
+## Requirements
+
+- Linux with Node.js 20 or newer and `npx`
+- Docker Engine with a running daemon
+- Docker Compose plugin (`docker compose`)
+- The current user must be able to run `docker info` without `sudo`
+- Network access to the npm registry and Docker Hub
+
+Node.js is only needed to run this installer. The applications themselves run
+entirely in Docker.
+
+## Run Locally
+
+From this package directory:
+
+```bash
+npx --yes . install
+```
+
+Until the package is published, it can also be run by absolute directory:
+
+```bash
+npx --yes /home/ubuntu/newapi-sub2api-installer install
+```
+
+After publication to npm:
+
+```bash
+npx --yes @yibi/newapi-sub2api-stack@0.1.0 install
+```
+
+Production automation should specify an exact npm package version instead of
+`@latest`.
+
+## Commands
+
+```bash
+api-stack install
+api-stack status
+api-stack logs
+api-stack logs --service new-api
+api-stack update
+api-stack uninstall
+api-stack uninstall --purge --confirm-purge
+```
+
+The default installation directory is `~/.local/share/api-stack`. Override it
+for every command with `--install-dir`, or set `API_STACK_INSTALL_DIR`.
+
+Example unattended installation:
+
+```bash
+npx --yes @yibi/newapi-sub2api-stack@0.1.0 install \
+  --new-api-host 0.0.0.0 \
+  --new-api-port 3000 \
+  --sub2api-host 127.0.0.1 \
+  --sub2api-port 8081 \
+  --timezone Asia/Shanghai
+```
+
+## Installed Services
+
+The generated Compose project contains two isolated networks:
+
+```text
+new-api-network                 sub2api-network
+  new-api                        sub2api
+  new-api-postgres               sub2api-postgres
+  new-api-redis                  sub2api-redis
+```
+
+Defaults follow the upstream deployment layouts:
+
+- `calciumion/new-api:latest`, PostgreSQL 15, and Redis
+- `weishaw/sub2api:latest`, PostgreSQL 18 Alpine, and Redis 8 Alpine
+- New API listens on `0.0.0.0:3000`
+- Sub2API listens on `127.0.0.1:8081`
+- Databases and Redis are not exposed on host ports
+
+Use `--new-api-image` and `--sub2api-image` to pin application tags or digests.
+
+## Credentials and Data
+
+Credentials are generated with Node's cryptographic random generator and
+stored in `.env` with mode `0600`. They are never embedded in
+`docker-compose.yml` or printed by the installer. The generated Sub2API admin
+password is stored as `SUB2API_ADMIN_PASSWORD` in that file. New API completes
+its initial administrator setup in the web interface.
+
+`uninstall` preserves all volumes and configuration. Permanent removal requires
+both `--purge` and `--confirm-purge`.
+
+## Publishing
+
+Verify the package before publishing:
+
+```bash
+npm test
+npm pack --dry-run
+npm publish
+```
+
+The package is published publicly under the `@yibi` npm organization scope.

package/bin/api-stack.js

@@ -0,0 +1,284 @@
+#!/usr/bin/env node
+
+import { spawnSync } from 'node:child_process';
+import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import process from 'node:process';
+import { createSecrets, DEFAULTS, renderCompose, renderEnv } from '../lib/config.js';
+
+const PROJECT_NAME = 'api-stack';
+const STATE_FILE = 'state.json';
+
+function usage() {
+  console.log(`Usage: api-stack <command> [options]
+
+Commands:
+  install      Create configuration, pull images, and start both stacks
+  status       Show container and HTTP health status
+  logs         Follow logs (use --service <name> to select one service)
+  update       Pull current configured images and recreate containers
+  uninstall    Stop containers while preserving data and configuration
+  help         Show this help
+
+Install options:
+  --install-dir <path>          Default: ${DEFAULTS.installDir}
+  --new-api-port <port>         Default: ${DEFAULTS.newApiPort}
+  --new-api-host <address>      Default: ${DEFAULTS.newApiHost}
+  --sub2api-port <port>         Default: ${DEFAULTS.sub2apiPort}
+  --sub2api-host <address>      Default: ${DEFAULTS.sub2apiHost}
+  --timezone <timezone>         Default: ${DEFAULTS.timezone}
+  --new-api-image <image>       Default: ${DEFAULTS.newApiImage}
+  --sub2api-image <image>       Default: ${DEFAULTS.sub2apiImage}
+  --sub2api-admin-email <email> Default: ${DEFAULTS.sub2apiAdminEmail}
+
+Uninstall options:
+  --purge --confirm-purge       Also delete volumes and local configuration
+`);
+}
+
+function parseArgs(argv) {
+  if (argv.length === 0 || ['help', '--help', '-h'].includes(argv[0])) {
+    return { command: 'help', flags: {} };
+  }
+  const command = argv[0] && !argv[0].startsWith('-') ? argv[0] : 'help';
+  const rest = argv.slice(1);
+  const flags = {};
+  for (let index = 0; index < rest.length; index += 1) {
+    const arg = rest[index];
+    if (!arg.startsWith('--')) throw new Error(`unexpected argument: ${arg}`);
+    const key = arg.slice(2);
+    if (['purge', 'confirm-purge'].includes(key)) {
+      flags[key] = true;
+      continue;
+    }
+    const value = rest[index + 1];
+    if (!value || value.startsWith('--')) throw new Error(`missing value for ${arg}`);
+    flags[key] = value;
+    index += 1;
+  }
+  return { command, flags };
+}
+
+function expandHome(path) {
+  if (path === '~') return homedir();
+  if (path.startsWith('~/')) return join(homedir(), path.slice(2));
+  return resolve(path);
+}
+
+function installDir(flags) {
+  return expandHome(flags['install-dir'] || process.env.API_STACK_INSTALL_DIR || DEFAULTS.installDir);
+}
+
+function parsePort(value, name) {
+  const port = Number(value);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error(`${name} must be an integer between 1 and 65535`);
+  }
+  return port;
+}
+
+function installOptions(flags) {
+  return {
+    timezone: flags.timezone || DEFAULTS.timezone,
+    newApiImage: flags['new-api-image'] || DEFAULTS.newApiImage,
+    sub2apiImage: flags['sub2api-image'] || DEFAULTS.sub2apiImage,
+    newApiHost: flags['new-api-host'] || DEFAULTS.newApiHost,
+    newApiPort: parsePort(flags['new-api-port'] || DEFAULTS.newApiPort, '--new-api-port'),
+    sub2apiHost: flags['sub2api-host'] || DEFAULTS.sub2apiHost,
+    sub2apiPort: parsePort(flags['sub2api-port'] || DEFAULTS.sub2apiPort, '--sub2api-port'),
+    sub2apiAdminEmail: flags['sub2api-admin-email'] || DEFAULTS.sub2apiAdminEmail,
+  };
+}
+
+function run(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    cwd: options.cwd,
+    encoding: 'utf8',
+    stdio: options.capture ? 'pipe' : 'inherit',
+  });
+  if (result.error) throw result.error;
+  if (result.status !== 0 && !options.allowFailure) {
+    const detail = options.capture ? `\n${result.stderr || result.stdout}` : '';
+    throw new Error(`${command} exited with status ${result.status}${detail}`);
+  }
+  return result;
+}
+
+function requireDocker() {
+  if (process.platform !== 'linux') throw new Error('this installer currently supports Linux only');
+  if (Number(process.versions.node.split('.')[0]) < 20) throw new Error('Node.js 20 or newer is required');
+  run('docker', ['info'], { capture: true });
+  run('docker', ['compose', 'version'], { capture: true });
+}
+
+function composeArgs(dir, args) {
+  return ['compose', '--project-name', PROJECT_NAME, '--env-file', join(dir, '.env'), '-f', join(dir, 'docker-compose.yml'), ...args];
+}
+
+function compose(dir, args, options = {}) {
+  return run('docker', composeArgs(dir, args), { cwd: dir, ...options });
+}
+
+function writeSecure(path, content, mode) {
+  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+  writeFileSync(path, content, { encoding: 'utf8', flag: 'wx', mode });
+  chmodSync(path, mode);
+}
+
+function readState(dir) {
+  const path = join(dir, STATE_FILE);
+  if (!existsSync(path)) return null;
+  return JSON.parse(readFileSync(path, 'utf8'));
+}
+
+function writeState(dir, state) {
+  const path = join(dir, STATE_FILE);
+  writeFileSync(path, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 });
+  chmodSync(path, 0o600);
+}
+
+async function waitForHttp(name, url, predicate, attempts = 60) {
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    try {
+      const response = await fetch(url, { signal: AbortSignal.timeout(5000) });
+      if (response.ok && await predicate(response)) {
+        console.log(`${name}: healthy (${url})`);
+        return true;
+      }
+    } catch {
+      // The container may still be starting.
+    }
+    await new Promise((resolvePromise) => setTimeout(resolvePromise, 2000));
+  }
+  console.error(`${name}: health check timed out (${url})`);
+  return false;
+}
+
+async function health(options) {
+  const newApiHealthy = await waitForHttp(
+    'new-api',
+    `http://127.0.0.1:${options.newApiPort}/api/status`,
+    async (response) => (await response.json()).success === true,
+  );
+  const sub2apiHealthy = await waitForHttp(
+    'sub2api',
+    `http://127.0.0.1:${options.sub2apiPort}/health`,
+    async (response) => (await response.json()).status === 'ok',
+  );
+  return newApiHealthy && sub2apiHealthy;
+}
+
+async function install(flags) {
+  requireDocker();
+  const dir = installDir(flags);
+  const existing = readState(dir);
+  let state;
+
+  if (existing?.installed) {
+    throw new Error(`already installed in ${dir}; use update or status`);
+  }
+
+  if (existing) {
+    for (const file of ['.env', 'docker-compose.yml']) {
+      if (!existsSync(join(dir, file))) throw new Error(`incomplete installation: missing ${join(dir, file)}`);
+    }
+    state = existing;
+    console.log(`resuming incomplete installation in ${dir}`);
+  } else {
+    const options = installOptions(flags);
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    chmodSync(dir, 0o700);
+    mkdirSync(join(dir, 'data', 'new-api'), { recursive: true, mode: 0o700 });
+    mkdirSync(join(dir, 'data', 'new-api-logs'), { recursive: true, mode: 0o700 });
+    writeSecure(join(dir, '.env'), renderEnv(createSecrets()), 0o600);
+    writeSecure(join(dir, 'docker-compose.yml'), renderCompose(options), 0o600);
+    state = { version: 1, installed: false, createdAt: new Date().toISOString(), options };
+    writeState(dir, state);
+    console.log(`configuration created in ${dir}`);
+  }
+
+  compose(dir, ['config', '--quiet']);
+  compose(dir, ['pull']);
+  compose(dir, ['up', '-d', '--remove-orphans']);
+  if (!await health(state.options)) throw new Error('containers started, but one or more health checks failed');
+
+  state.installed = true;
+  state.installedAt = new Date().toISOString();
+  writeState(dir, state);
+  console.log(`\nInstallation complete.
+New API: http://${state.options.newApiHost === '0.0.0.0' ? '127.0.0.1' : state.options.newApiHost}:${state.options.newApiPort}
+Sub2API: http://${state.options.sub2apiHost === '0.0.0.0' ? '127.0.0.1' : state.options.sub2apiHost}:${state.options.sub2apiPort}
+Sub2API credentials are stored in ${join(dir, '.env')}`);
+}
+
+function requireInstallation(flags) {
+  const dir = installDir(flags);
+  const state = readState(dir);
+  if (!state) throw new Error(`no installation found in ${dir}`);
+  return { dir, state };
+}
+
+async function status(flags) {
+  requireDocker();
+  const { dir, state } = requireInstallation(flags);
+  compose(dir, ['ps']);
+  const ok = await health(state.options);
+  if (!ok) process.exitCode = 1;
+}
+
+function logs(flags) {
+  requireDocker();
+  const { dir } = requireInstallation(flags);
+  const args = ['logs', '--follow', '--tail', '200'];
+  if (flags.service) args.push(flags.service);
+  compose(dir, args);
+}
+
+async function update(flags) {
+  requireDocker();
+  const { dir, state } = requireInstallation(flags);
+  compose(dir, ['pull']);
+  compose(dir, ['up', '-d', '--remove-orphans']);
+  if (!await health(state.options)) throw new Error('update completed, but one or more health checks failed');
+  state.updatedAt = new Date().toISOString();
+  writeState(dir, state);
+}
+
+function uninstall(flags) {
+  requireDocker();
+  const { dir } = requireInstallation(flags);
+  if (flags.purge && !flags['confirm-purge']) {
+    throw new Error('--purge permanently deletes databases; repeat with --purge --confirm-purge');
+  }
+  if (flags.purge) {
+    const normalized = resolve(dir);
+    const depth = normalized.split('/').filter(Boolean).length;
+    if (normalized === resolve(homedir()) || depth < 2) {
+      throw new Error(`refusing to purge unsafe installation directory: ${normalized}`);
+    }
+  }
+  compose(dir, flags.purge ? ['down', '--volumes', '--remove-orphans'] : ['down', '--remove-orphans']);
+  if (flags.purge) {
+    rmSync(dir, { recursive: true, force: true });
+    console.log(`deleted containers, volumes, and ${dir}`);
+  } else {
+    console.log(`containers stopped; configuration and data were preserved in ${dir}`);
+  }
+}
+
+async function main() {
+  const { command, flags } = parseArgs(process.argv.slice(2));
+  if (command === 'help' || command === '--help' || command === '-h') return usage();
+  if (command === 'install') return install(flags);
+  if (command === 'status') return status(flags);
+  if (command === 'logs') return logs(flags);
+  if (command === 'update') return update(flags);
+  if (command === 'uninstall') return uninstall(flags);
+  throw new Error(`unknown command: ${command}`);
+}
+
+main().catch((error) => {
+  console.error(`error: ${error.message}`);
+  process.exitCode = 1;
+});

package/lib/config.js

@@ -0,0 +1,230 @@
+import { randomBytes } from 'node:crypto';
+
+export const DEFAULTS = Object.freeze({
+  installDir: '~/.local/share/api-stack',
+  timezone: 'Asia/Shanghai',
+  newApiImage: 'calciumion/new-api:latest',
+  sub2apiImage: 'weishaw/sub2api:latest',
+  newApiHost: '0.0.0.0',
+  newApiPort: 3000,
+  sub2apiHost: '127.0.0.1',
+  sub2apiPort: 8081,
+  sub2apiAdminEmail: 'admin@sub2api.local',
+});
+
+const SECRET_KEYS = Object.freeze([
+  'NEW_API_POSTGRES_PASSWORD',
+  'NEW_API_REDIS_PASSWORD',
+  'NEW_API_SESSION_SECRET',
+  'NEW_API_CRYPTO_SECRET',
+  'SUB2API_POSTGRES_PASSWORD',
+  'SUB2API_REDIS_PASSWORD',
+  'SUB2API_JWT_SECRET',
+  'SUB2API_TOTP_ENCRYPTION_KEY',
+  'SUB2API_ADMIN_PASSWORD',
+]);
+
+function secret(bytes = 32) {
+  return randomBytes(bytes).toString('hex');
+}
+
+export function createSecrets() {
+  return {
+    NEW_API_POSTGRES_PASSWORD: secret(),
+    NEW_API_REDIS_PASSWORD: secret(),
+    NEW_API_SESSION_SECRET: secret(),
+    NEW_API_CRYPTO_SECRET: secret(),
+    SUB2API_POSTGRES_PASSWORD: secret(),
+    SUB2API_REDIS_PASSWORD: secret(),
+    SUB2API_JWT_SECRET: secret(),
+    SUB2API_TOTP_ENCRYPTION_KEY: secret(),
+    SUB2API_ADMIN_PASSWORD: randomBytes(24).toString('base64url'),
+  };
+}
+
+export function renderEnv(secrets) {
+  for (const key of SECRET_KEYS) {
+    if (!secrets[key] || !/^[A-Za-z0-9_-]+$/.test(secrets[key])) {
+      throw new Error(`invalid generated secret: ${key}`);
+    }
+  }
+  return `${SECRET_KEYS.map((key) => `${key}=${secrets[key]}`).join('\n')}\n`;
+}
+
+function yamlString(value) {
+  return JSON.stringify(String(value));
+}
+
+export function renderCompose(options) {
+  const o = { ...DEFAULTS, ...options };
+  return `# Generated by newapi-sub2api-stack. Do not put secrets in this file.
+services:
+  new-api:
+    image: ${yamlString(o.newApiImage)}
+    container_name: new-api
+    restart: always
+    command: ["--log-dir", "/app/logs"]
+    ports:
+      - ${yamlString(`${o.newApiHost}:${o.newApiPort}:3000`)}
+    volumes:
+      - ./data/new-api:/data
+      - ./data/new-api-logs:/app/logs
+    environment:
+      SQL_DSN: "postgresql://newapi:\${NEW_API_POSTGRES_PASSWORD:?missing NEW_API_POSTGRES_PASSWORD}@new-api-postgres:5432/new-api"
+      REDIS_CONN_STRING: "redis://:\${NEW_API_REDIS_PASSWORD:?missing NEW_API_REDIS_PASSWORD}@new-api-redis:6379"
+      SESSION_SECRET: "\${NEW_API_SESSION_SECRET:?missing NEW_API_SESSION_SECRET}"
+      CRYPTO_SECRET: "\${NEW_API_CRYPTO_SECRET:?missing NEW_API_CRYPTO_SECRET}"
+      TZ: ${yamlString(o.timezone)}
+      ERROR_LOG_ENABLED: "true"
+      BATCH_UPDATE_ENABLED: "true"
+      NODE_NAME: "new-api-node-1"
+    depends_on:
+      new-api-postgres:
+        condition: service_healthy
+      new-api-redis:
+        condition: service_healthy
+    networks:
+      - new-api-network
+    healthcheck:
+      test: ["CMD-SHELL", "wget -q -O - http://localhost:3000/api/status | grep -q '\\"success\\":true'"]
+      interval: 30s
+      timeout: 10s
+      retries: 5
+      start_period: 30s
+
+  new-api-postgres:
+    image: postgres:15
+    container_name: new-api-postgres
+    restart: always
+    environment:
+      POSTGRES_USER: newapi
+      POSTGRES_PASSWORD: "\${NEW_API_POSTGRES_PASSWORD:?missing NEW_API_POSTGRES_PASSWORD}"
+      POSTGRES_DB: new-api
+      TZ: ${yamlString(o.timezone)}
+    volumes:
+      - new_api_postgres_data:/var/lib/postgresql/data
+    networks:
+      - new-api-network
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U newapi -d new-api"]
+      interval: 10s
+      timeout: 5s
+      retries: 10
+
+  new-api-redis:
+    image: redis:latest
+    container_name: new-api-redis
+    restart: always
+    command: ["redis-server", "--appendonly", "yes", "--requirepass", "\${NEW_API_REDIS_PASSWORD:?missing NEW_API_REDIS_PASSWORD}"]
+    environment:
+      REDISCLI_AUTH: "\${NEW_API_REDIS_PASSWORD:?missing NEW_API_REDIS_PASSWORD}"
+      TZ: ${yamlString(o.timezone)}
+    volumes:
+      - new_api_redis_data:/data
+    networks:
+      - new-api-network
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 10s
+      timeout: 5s
+      retries: 10
+
+  sub2api:
+    image: ${yamlString(o.sub2apiImage)}
+    container_name: sub2api
+    restart: unless-stopped
+    ulimits:
+      nofile:
+        soft: 100000
+        hard: 100000
+    ports:
+      - ${yamlString(`${o.sub2apiHost}:${o.sub2apiPort}:8080`)}
+    volumes:
+      - sub2api_data:/app/data
+    environment:
+      AUTO_SETUP: "true"
+      SERVER_HOST: "0.0.0.0"
+      SERVER_PORT: "8080"
+      SERVER_MODE: "release"
+      RUN_MODE: "standard"
+      DATABASE_HOST: "sub2api-postgres"
+      DATABASE_PORT: "5432"
+      DATABASE_USER: "sub2api"
+      DATABASE_PASSWORD: "\${SUB2API_POSTGRES_PASSWORD:?missing SUB2API_POSTGRES_PASSWORD}"
+      DATABASE_DBNAME: "sub2api"
+      DATABASE_SSLMODE: "disable"
+      REDIS_HOST: "sub2api-redis"
+      REDIS_PORT: "6379"
+      REDIS_PASSWORD: "\${SUB2API_REDIS_PASSWORD:?missing SUB2API_REDIS_PASSWORD}"
+      REDIS_DB: "0"
+      ADMIN_EMAIL: ${yamlString(o.sub2apiAdminEmail)}
+      ADMIN_PASSWORD: "\${SUB2API_ADMIN_PASSWORD:?missing SUB2API_ADMIN_PASSWORD}"
+      JWT_SECRET: "\${SUB2API_JWT_SECRET:?missing SUB2API_JWT_SECRET}"
+      TOTP_ENCRYPTION_KEY: "\${SUB2API_TOTP_ENCRYPTION_KEY:?missing SUB2API_TOTP_ENCRYPTION_KEY}"
+      TZ: ${yamlString(o.timezone)}
+    depends_on:
+      sub2api-postgres:
+        condition: service_healthy
+      sub2api-redis:
+        condition: service_healthy
+    networks:
+      - sub2api-network
+    healthcheck:
+      test: ["CMD", "wget", "-q", "-T", "5", "-O", "/dev/null", "http://localhost:8080/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 5
+      start_period: 30s
+
+  sub2api-postgres:
+    image: postgres:18-alpine
+    container_name: sub2api-postgres
+    restart: unless-stopped
+    environment:
+      PGDATA: "/var/lib/postgresql/data"
+      POSTGRES_USER: "sub2api"
+      POSTGRES_PASSWORD: "\${SUB2API_POSTGRES_PASSWORD:?missing SUB2API_POSTGRES_PASSWORD}"
+      POSTGRES_DB: "sub2api"
+      TZ: ${yamlString(o.timezone)}
+    volumes:
+      - sub2api_postgres_data:/var/lib/postgresql/data
+    networks:
+      - sub2api-network
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U sub2api -d sub2api"]
+      interval: 10s
+      timeout: 5s
+      retries: 10
+
+  sub2api-redis:
+    image: redis:8-alpine
+    container_name: sub2api-redis
+    restart: unless-stopped
+    command: ["redis-server", "--save", "60", "1", "--appendonly", "yes", "--appendfsync", "everysec", "--requirepass", "\${SUB2API_REDIS_PASSWORD:?missing SUB2API_REDIS_PASSWORD}"]
+    environment:
+      REDISCLI_AUTH: "\${SUB2API_REDIS_PASSWORD:?missing SUB2API_REDIS_PASSWORD}"
+      TZ: ${yamlString(o.timezone)}
+    volumes:
+      - sub2api_redis_data:/data
+    networks:
+      - sub2api-network
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 10s
+      timeout: 5s
+      retries: 10
+
+volumes:
+  new_api_postgres_data:
+  new_api_redis_data:
+  sub2api_data:
+  sub2api_postgres_data:
+  sub2api_redis_data:
+
+networks:
+  new-api-network:
+    driver: bridge
+  sub2api-network:
+    driver: bridge
+`;
+}

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@yibi/newapi-sub2api-stack",
+  "version": "0.1.0",
+  "description": "One-command Docker Compose installer for upstream New API and Sub2API",
+  "type": "module",
+  "bin": {
+    "api-stack": "bin/api-stack.js"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "node --test",
+    "check": "node --check bin/api-stack.js && node --check lib/config.js"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "MIT"
+}