@atomiton-dev/gap-cli 0.0.0-stage → 0.9.0-mvp

package/installer/install.sh

@@ -0,0 +1,252 @@
+#!/usr/bin/env bash
+# Installs the local GAP stack from this folder (macOS, Linux). Safe to run again: secrets stay.
+# Folder contents (#1750, D27): docker-compose.yml, env.template, VERSION, images.tar.gz,
+# install.sh, gap, gap-lib.sh, README.TXT, BUILD-INFO.txt.
+#
+# D28: the installed instance lives in ~/.gap (docker-compose.yml, .env, gap, gap-lib.sh). This
+# folder is only the installer: after a successful run it can be moved or deleted.
+#
+# #1986 (#2011): the same script is the installer of the npm package `@atomiton-dev/gap-cli` (`gap install`), told
+# apart by the CHANNEL file next to it (gap-lib.sh: channel). There the images are pulled from ghcr.io instead of
+# loaded, no launcher and no PATH or rc line is made (npm put `gap` on the PATH), and only docker-compose.yml is
+# copied into ~/.gap, because this folder is the package that provides `gap` and must stay.
+set -u
+
+GAP_SRC=$(cd "$(dirname "$0")" && pwd -P)
+# shellcheck source=gap-lib.sh
+. "$GAP_SRC/gap-lib.sh"
+
+fail() { warn "$1"; shift; for line in "$@"; do printf '%s\n' "$line"; done; exit 1; }
+
+# sync_files: copy what the installed instance needs into GAP_HOME (D28). A newer installer replaces
+# the older compose file and scripts; .env is never touched here.
+sync_files() {
+  local f
+  mkdir -p "$GAP_HOME" || return 1
+  [ "$GAP_SRC" != "$(cd "$GAP_HOME" && pwd -P)" ] || return 0   # running from GAP_HOME itself
+  put_file "$GAP_SRC/docker-compose.yml" "$GAP_HOME/docker-compose.yml" 644 || return 1
+  [ "$(channel)" != npm ] || return 0   # npm: `dc` needs the compose file here; the scripts stay in the package
+  put_file "$GAP_SRC/gap-lib.sh" "$GAP_HOME/gap-lib.sh" 644 || return 1
+  put_file "$GAP_SRC/gap" "$GAP_HOME/gap" 755 || return 1
+}
+
+# reset_db_password: set the Postgres password to the one in .env (D28, replaces the stop of D24).
+# Postgres keeps the password it was first started with, so a lost .env would lock the Kernel out of
+# its own data. The official image trusts connections made on the local socket inside the container
+# (pg_hba.conf: `local all all trust`), so the password can be set without knowing the old one.
+# Starts only postgres. The result is checked over the container's own IP, which (unlike 127.0.0.1)
+# is not trusted, so a wrong password fails there. Leaves the reason in RESET_ERR.
+RESET_ERR=""
+reset_db_password() {
+  local pw id ip out
+  pw=$(env_get GAP_DB_PASSWORD)
+  if ! out=$(dc up -d --wait --wait-timeout 120 postgres 2>&1); then RESET_ERR="postgres did not start: $(printf '%s' "$out" | tail -n 2)"; return 1; fi
+  id=$(dc ps -q postgres | head -n 1)
+  [ -n "$id" ] || { RESET_ERR="postgres container not found"; return 1; }
+  if ! out=$(printf "ALTER USER postgres PASSWORD '%s';\n" "$pw" | docker exec -i "$id" psql -U postgres -v ON_ERROR_STOP=1 -q 2>&1); then
+    RESET_ERR="setting the password failed: $out"; return 1
+  fi
+  ip=$(docker exec "$id" hostname -i 2>/dev/null | awk '{print $1}')
+  [ -n "$ip" ] || { RESET_ERR="could not read the postgres container's IP"; return 1; }
+  if ! out=$(docker exec -e PGPASSWORD="$pw" "$id" psql -h "$ip" -U postgres -tAc 'select 1' 2>&1); then
+    RESET_ERR="the new password was not accepted: $out"; return 1
+  fi
+}
+
+# Makes `gap` runnable from any terminal: a small launcher in ~/.local/bin, and ~/.local/bin on the
+# PATH of new terminals. Never needs sudo. A ~/.local/bin/gap that is not ours (another program
+# called gap, or a symlink) is left alone, and then nothing else is changed either. Sets
+# LAUNCHER_STATE (installed, foreign or failed) and RC_ADDED (the rc files that got the PATH line).
+LAUNCHER_STATE=""
+RC_ADDED=""
+install_launcher() {
+  local rc target="$LAUNCHER_DIR/gap"
+  LAUNCHER_STATE=failed
+  mkdir -p "$LAUNCHER_DIR" 2>/dev/null || return 0
+  if { [ -e "$target" ] || [ -L "$target" ]; } && ! launcher_is_ours "$target"; then
+    LAUNCHER_STATE=foreign; return 0
+  fi
+  # Through a new file and a rename, so an old launcher is replaced, never written into.
+  { launcher_text > "$target.new" && chmod +x "$target.new" && mv -f "$target.new" "$target"; } 2>/dev/null \
+    || { rm -f "$target.new" 2>/dev/null; return 0; }
+  LAUNCHER_STATE=installed
+  case ":$PATH:" in
+    *":$LAUNCHER_DIR:"*) ;;
+    *)
+      while IFS= read -r rc; do
+        if ! grep -qF "$RC_MARKER" "$rc" 2>/dev/null; then
+          mkdir -p "$(dirname "$rc")" 2>/dev/null   # fish: ~/.config/fish may not exist yet
+          # Only a line that was written is reported; braces, so that a refused write stays quiet.
+          if { printf '\n%s\n%s\n' "$RC_MARKER" "$RC_EXPORT" >> "$rc"; } 2>/dev/null; then
+            RC_ADDED="$RC_ADDED $rc"
+          fi
+        fi
+      done < <(rc_files) ;;
+  esac
+}
+
+printf 'Installing GAP from %s\n\n' "$GAP_SRC"
+
+# 1. Prerequisites
+check_prereqs "$(install_cmd)" up || exit 1
+ok "Prerequisites passed"
+
+for f in VERSION docker-compose.yml env.template gap gap-lib.sh; do
+  [ -f "$GAP_SRC/$f" ] || fail "$f is missing in $GAP_SRC" "Download the installer again."
+done
+version=$(tr -d '[:space:]' < "$GAP_SRC/VERSION")
+
+# npm channel: never go back. An older package over a newer GAP would start an old Kernel on a database a newer one has
+# migrated (migrations are not undone), and `gap update` refuses it as well. Only a comparison that can be made refuses:
+# equal, newer, another suffix or an unreadable version run as they always did.
+if [ "$(channel)" = npm ] && is_installed && [ "$(version_cmp "$(installed_version)" "$version" 2>/dev/null)" = 1 ]; then
+  warn "This package ($version) is older than the installed GAP ($(installed_version))"
+  older_package_help
+  printf '    Nothing was changed.\n'
+  exit 1
+fi
+
+# 2. Images. npm channel: pulled from the registry, the missing ones only, before anything is written (the user may
+# not be logged in or allowed, and must then be left with nothing half installed). ZIP channel: from the archive in
+# this folder (no network needed). Postgres is packaged as
+# gap-postgres:16, so loading never moves the user's own postgres:16 tag. The archive is loaded when
+# an image is missing, and also when this package differs from the one loaded last time (its
+# BUILD-INFO.txt is recorded in ~/.gap), so a rebuilt package with the same VERSION still replaces
+# the images. Only missing images make images.tar.gz mandatory.
+pkg_id=""
+need_load=0
+if [ "$(channel)" = npm ]; then
+  pull_images "$version" || exit 1   # has said what to do
+  ok "Images ready"
+else
+  [ -f "$GAP_SRC/BUILD-INFO.txt" ] && pkg_id=$(cksum < "$GAP_SRC/BUILD-INFO.txt" | awk '{print $1 "-" $2}')
+  for img in "gap-kernel:$version" "gap-admin-ui:$version" gap-postgres:16; do
+    docker image inspect "$img" >/dev/null 2>&1 || need_load=1
+  done
+  if [ "$need_load" = 0 ] && [ -n "$pkg_id" ] && [ -f "$GAP_SRC/images.tar.gz" ] \
+     && [ "$(cat "$GAP_HOME/images.loaded" 2>/dev/null)" != "$pkg_id" ]; then
+    need_load=1
+  fi
+  if [ "$need_load" = 1 ]; then
+    [ -f "$GAP_SRC/images.tar.gz" ] || fail "images.tar.gz is missing and the images are not on this machine" "Download the installer again."
+    printf 'Loading images, this can take a minute...\n'
+    load_out=$(docker load -i "$GAP_SRC/images.tar.gz" 2>&1) || fail "Loading images failed" "$load_out"
+  fi
+  ok "Images loaded"
+fi
+
+# 3. The installed instance (D28)
+sync_files || fail "Could not write to $GAP_HOME" "Check the permissions of that folder, then run $(install_name) again."
+if [ "$need_load" = 1 ] && [ -n "$pkg_id" ]; then printf '%s\n' "$pkg_id" > "$GAP_HOME/images.loaded"; fi
+
+# 4. Configuration. First run creates .env with fresh secrets; later runs only update version and
+# port (D23, D9) and keep the password, which Postgres has already stored in its volume.
+had_volume=0
+docker volume inspect "${GAP_PROJECT}_pgdata" >/dev/null 2>&1 && had_volume=1
+if [ -f "$GAP_HOME/.env" ]; then
+  stored_port=$(env_get GAP_UI_PORT)
+  env_set GAP_VERSION "$version"
+else
+  stored_port=""
+  ( umask 077
+    sed -e "s|@GAP_VERSION@|$version|" \
+        -e "s|@GAP_UI_PORT@|0|" \
+        -e "s|@GAP_DB_PASSWORD@|$(od -An -N24 -tx1 /dev/urandom | tr -d ' \n')|" \
+        "$GAP_SRC/env.template" > "$GAP_HOME/.env" )
+  # D28: data from an earlier install is still in the volume but its password is gone with the old
+  # .env (the install folder was moved or deleted). Set the new password inside Postgres.
+  if [ "$had_volume" = 1 ]; then
+    if reset_db_password; then
+      ok "GAP data from an earlier install was found; its lost .env was rebuilt and the data is kept"
+    else
+      rm -f "$GAP_HOME/.env"   # back to "no .env", so the next run starts from the same place
+      fail "GAP data from an earlier install exists, but its database password could not be reset" \
+        "$RESET_ERR" \
+        "Either: put the old .env back into $GAP_HOME and run $(install_name) again," \
+        "or: erase the old data (it is lost for good) with" \
+        "    docker compose -p $GAP_PROJECT down -v" \
+        "and run $(install_name) again."
+    fi
+  fi
+fi
+# Where this channel gets its images from (#1986): the ZIP's own, loaded above under their local names and never
+# pulled (empty prefix, `never`); the npm channel's, pulled above from the registry (its prefix, `missing`). The
+# channel's value, not .env's: written on every run, not only on the first, so that a machine that used another
+# channel (or an older package that did not know these keys) takes this channel's names from now on.
+env_set GAP_IMAGE_PREFIX "$(channel_prefix)"
+env_set GAP_PULL_POLICY "$(channel_pull_policy)"
+port=$(pick_port "$stored_port") || fail "No free port for the Admin UI" "Action: free a port between $GAP_PORT_FIRST and $GAP_PORT_LAST, then run $(install_name) again."
+[ -z "$stored_port" ] || [ "$port" = "$stored_port" ] || warn "Port $stored_port is in use, using $port instead"
+env_set GAP_UI_PORT "$port"
+
+# 5. Start. Both lines are true once the Kernel is healthy: it depends on a healthy Postgres, and
+# its entrypoint finishes the schema before the server that answers /health starts (D16).
+bring_up || exit 1
+ok "Database initialized"
+ok "Migrations completed"
+
+# 6. Health checks through the Admin UI port, the path the user will take.
+health_checks || exit 1   # has said which path did not answer (gap-lib.sh)
+ok "Health checks passed"
+
+# 7. The gap command
+other=$(command -v gap 2>/dev/null || true)
+if [ "$(channel)" = npm ]; then
+  # npm put `gap` on the PATH: no launcher, no PATH or rc line (D5). A launcher left by a ZIP install is only reported (D6).
+  LAUNCHER_STATE=npm
+  if launcher_is_ours "$LAUNCHER_DIR/gap"; then
+    add_note "  Warning: $LAUNCHER_DIR/gap is a launcher from a ZIP install of GAP and may run instead of the npm command."
+    add_note "  Use one channel per machine; the data is shared. To keep only the npm command: rm $LAUNCHER_DIR/gap"
+  fi
+else
+  install_launcher
+fi
+# Does `gap` mean GAP in the user's own terminal? An alias or function of that name (oh-my-zsh has
+# `alias gap='git apply'`) is invisible to this script, so the user's shell is asked, and the user is
+# offered to turn it off (gap-lib.sh). Done before the summary below, so that the summary stays the
+# last thing on the screen.
+asked=1
+if [ "$LAUNCHER_STATE" = installed ] || [ "$LAUNCHER_STATE" = npm ]; then
+  printf 'Checking the gap command in your terminal...\n'
+  check_gap_resolution && asked=0
+fi
+printf '\nGAP Platform is ready!\n\n'
+printf '  Admin UI:  %s\n' "$(ui_url)"
+printf '  Login:     admin@example.com / changeme\n\n'
+case "$LAUNCHER_STATE" in
+  installed|npm)
+    case "$GAP_CHECK_CMD" in
+      "gap status")         also="gap start, gap stop, gap logs" ;;
+      "command gap status") also="command gap start, stop, logs" ;;
+      *)                    also="start, stop, logs" ;;
+    esac
+    printf '  Check it any time with:  %s   (also: %s)\n' "$GAP_CHECK_CMD" "$also"
+    # This terminal still has the alias; only new ones read the line that turns it off.
+    if [ -n "$GAP_FIX_ADDED" ] && [ "$GAP_CHECK_CMD" = "gap status" ]; then
+      printf '  Open a new terminal first; in this one, use: command gap status\n'
+    fi ;;
+  foreign)
+    printf '  Check it any time with:  %s/gap status   (also: start, stop, logs)\n' "$GAP_HOME"
+    printf '  %s/gap already exists and is not from GAP, so it was left alone.\n' "$LAUNCHER_DIR" ;;
+  *)
+    printf '  Check it any time with:  %s/gap status   (also: start, stop, logs)\n' "$GAP_HOME"
+    printf '  Could not write %s/gap; check the permissions of %s.\n' "$LAUNCHER_DIR" "$LAUNCHER_DIR" ;;
+esac
+if [ "$LAUNCHER_STATE" = npm ]; then
+  # $GAP_SRC is the package that provides `gap`: deleting it would remove the command.
+  printf '  GAP now runs from %s. Keep the npm package: it is the gap command.\n' "$GAP_HOME"
+else
+  printf '  GAP now runs from %s; you can delete the installer folder %s\n' "$GAP_HOME" "$GAP_SRC"
+fi
+if [ -n "$RC_ADDED" ]; then
+  printf '  Added %s to the PATH in:%s\n' "$LAUNCHER_DIR" "$RC_ADDED"
+  printf '  Open a new terminal for that to take effect, or run: %s/gap status\n' "$GAP_HOME"
+fi
+[ -z "$GAP_NOTES" ] || printf '%s' "$GAP_NOTES"
+# Only when no shell could be asked, fall back to a gap that this script can see on its own PATH.
+if [ "$LAUNCHER_STATE" = installed ] && [ "$asked" != 0 ] && [ -n "$other" ] && [ "$other" != "$LAUNCHER_DIR/gap" ]; then
+  printf '  Note: another "gap" is already on your PATH (%s) and may run instead; use %s/gap\n' "$other" "$GAP_HOME"
+fi
+
+# 8. Open the browser; a machine without a desktop just ignores it.
+open_url "$(ui_url)"

package/lib/launcher.js

@@ -0,0 +1,31 @@
+'use strict';
+// Pure helpers of the `gap` shell (#1986, #2010). No I/O, so they can be tested on any machine.
+// ES5 on purpose: this file is loaded by bin/gap.js after the Node version check, but keeping it plain
+// costs nothing and keeps it readable on the oldest Node that can still print the message.
+var path = require('path');
+
+var MIN_NODE_MAJOR = 18;
+
+// true when `version` ("18.20.8", no leading "v") names Node 18 or newer; false for anything unreadable.
+function nodeSupported(version) {
+  var m = /^(\d+)\.\d+\.\d+/.exec(String(version === undefined || version === null ? '' : version));
+  return m !== null && parseInt(m[1], 10) >= MIN_NODE_MAJOR;
+}
+
+// The command that runs the installer script for `args`. `gap install ...` runs install.sh / install.ps1
+// (without the word "install"); everything else goes to the `gap` launcher. bash is named explicitly so
+// the result does not depend on the execute bit surviving the npm unpack. Arguments are never joined.
+function buildCommand(opts) {
+  var win = opts.platform === 'win32';
+  var join = win ? path.win32.join : path.posix.join;
+  var args = opts.args.slice();
+  var install = args[0] === 'install';
+  if (install) args.shift();
+  var script = join(opts.pkgRoot, 'installer', install ? (win ? 'install.ps1' : 'install.sh') : (win ? 'gap.ps1' : 'gap'));
+  if (win) {
+    return { cmd: 'powershell', args: ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', script].concat(args) };
+  }
+  return { cmd: 'bash', args: [script].concat(args) };
+}
+
+module.exports = { nodeSupported: nodeSupported, buildCommand: buildCommand, MIN_NODE_MAJOR: MIN_NODE_MAJOR };

package/lib/postinstall.js

@@ -0,0 +1,137 @@
+'use strict';
+// Runs after `npm install -g @atomiton-dev/gap-cli` (#1986, #2012). One job: on a Mac or Linux box with
+// oh-my-zsh, let a NEW terminal run `gap login` at once.
+//
+// Why: oh-my-zsh's git plugin (on by default, plugins=(git)) defines `alias gap='git apply'`. zsh applies an
+// alias before it looks at PATH, so `gap login` ran `git apply login` and failed with "can't open patch 'login'"
+// before any code of ours could run or explain it. A package cannot print a warning at install time (npm 7+ hides
+// the output of install scripts), so the fix has to act.
+//
+// What it does: it creates ONE new file, <oh-my-zsh>/custom/atomiton-gap.zsh. oh-my-zsh reads every custom/*.zsh
+// after its plugins, which is where it expects a user's overrides. The file turns off that one alias, and only
+// while a package it was installed with is still on the disk (npm 7+ runs no uninstall script, so the file cannot
+// remove itself: without the package it does nothing and `gap` is `git apply` again, as the user had it). It lists
+// the packages: with nvm there is one global package per Node version, and removing one must not break the others.
+// The file does not depend on PATH: nvm usually adds the global bin to PATH from .zshrc, after oh-my-zsh has
+// loaded custom/.
+//
+// What it does not do: edit ~/.zshrc or any file it did not create; touch an alias the user made himself
+// (only the exact `git apply` one is turned off); write through a symlink; run for a local install (`npm install`
+// in a project), under sudo, or as root into a directory somebody else owns (a root-owned file in a user's
+// directory); ever fail the install (every error is swallowed, exit 0; package.json adds `|| exit 0` for the
+// case where node itself cannot be found by npm's shell).
+// Not covered: --ignore-scripts, a ZSH_CUSTOM set only in .zshrc, prezto, other shells.
+// ES5, like the rest of the shell: it must run on the oldest Node npm still installs this on.
+var fs = require('fs');
+var os = require('os');
+var path = require('path');
+
+var FILE_NAME = 'atomiton-gap.zsh';
+var OWNER_LINE = '# Written by @atomiton-dev/gap-cli (npm install -g). Delete this file to undo it.';
+
+// A zsh single-quoted string: nothing inside is special, except the quote itself.
+function zshQuote(text) {
+  return "'" + String(text).replace(/'/g, "'\\''") + "'";
+}
+
+// The directory oh-my-zsh reads custom/*.zsh from: ZSH_CUSTOM, else $ZSH/custom, else ~/.oh-my-zsh/custom.
+// Only when it already exists and is an absolute path (a relative one would be read from the folder npm runs this
+// in, not from where the shell means): this never creates an oh-my-zsh directory for somebody who has none.
+function customDir(env, home) {
+  var dir = env.ZSH_CUSTOM || path.join(env.ZSH || path.join(home, '.oh-my-zsh'), 'custom');
+  if (!path.isAbsolute(dir)) return null;
+  try {
+    return fs.statSync(dir).isDirectory() ? dir : null;
+  } catch (e) {
+    return null;
+  }
+}
+
+var PATH_LINE = '# gap-cli package: ';
+
+// The package paths a file of ours lists, one per line, each a JSON string (so a newline in a path cannot break the
+// line, and the file is read back the way it was written).
+function listedPaths(text) {
+  var found = [];
+  text.split('\n').forEach(function (line) {
+    if (line.indexOf(PATH_LINE) !== 0) return;
+    try {
+      var one = JSON.parse(line.slice(PATH_LINE.length));
+      if (typeof one === 'string' && one) found.push(one);
+    } catch (e) {
+      // a line we cannot read is dropped
+    }
+  });
+  return found;
+}
+
+function fileText(binPaths) {
+  var exists = binPaths.map(function (p) { return '-e ' + zshQuote(p); }).join(' || ');
+  return [
+    OWNER_LINE,
+    "# oh-my-zsh's git plugin defines alias gap='git apply'. zsh uses an alias before it looks at PATH, so it hides",
+    '# the `gap` command of GAP. This turns off that one alias, and only while a package listed below is installed.',
+    '# If you uninstall the package, or delete this file, `gap` is `git apply` again.'
+  ].concat(binPaths.map(function (p) { return PATH_LINE + JSON.stringify(p); }), [
+    "if [[ ${aliases[gap]:-} == 'git apply' ]] && [[ " + exists + ' ]]; then unalias gap; fi',
+    ''
+  ]).join('\n');
+}
+
+// Returns the path of the file it wrote, or null when it did nothing (and why is not worth a message).
+function run(env, packageRoot) {
+  if (env.npm_config_global !== 'true') return null;   // a local install must leave the home directory alone
+  if (env.SUDO_UID) return null;
+  var home = env.HOME || os.homedir();
+  if (!home) return null;
+  var dir = customDir(env, home);
+  if (!dir) return null;
+  // su, doas or a root shell that keeps the user's HOME: no SUDO_UID, but a root-owned file would land in his directory
+  if (typeof process.getuid === 'function' && fs.statSync(dir).uid !== process.getuid()) return null;
+  var file = path.join(dir, FILE_NAME);
+  var binPath = path.join(packageRoot, 'bin', 'gap.js');
+  var current = null;
+  var st = null;
+  try {
+    st = fs.lstatSync(file);
+  } catch (e) {
+    st = null;   // not there
+  }
+  if (st) {
+    if (st.isSymbolicLink() || !st.isFile()) return null;   // a link (dotfile managers make them) or a directory: not ours to write through
+    current = fs.readFileSync(file, 'utf8');
+    if (current.indexOf(OWNER_LINE) !== 0) return null;      // somebody else's file: leave it
+  }
+  // the packages of earlier installs that are still on the disk (one per Node version under nvm), then this one
+  var paths = (current === null ? [] : listedPaths(current)).filter(function (p) {
+    return p !== binPath && fs.existsSync(p);
+  });
+  paths.push(binPath);
+  var text = fileText(paths);
+  if (current === text) return file;
+  // written beside it and renamed: a terminal opened meanwhile reads the old file or the new one, not half of one
+  var tmp = file + '.tmp-' + process.pid;
+  try {
+    fs.writeFileSync(tmp, text, { mode: 420 });   // 0644
+    fs.renameSync(tmp, file);
+  } catch (e) {
+    try { fs.unlinkSync(tmp); } catch (e2) { /* nothing to remove */ }
+    throw e;
+  }
+  return file;
+}
+
+module.exports = { run: run, fileText: fileText, zshQuote: zshQuote, FILE_NAME: FILE_NAME };
+
+if (require.main === module) {
+  try {
+    var written = run(process.env, path.resolve(__dirname, '..'));
+    if (written) {
+      process.stdout.write("gap: turned off oh-my-zsh's `gap` alias (git apply) for new terminals, in " + written +
+        '. Delete that file to undo it.\n');
+    }
+  } catch (e) {
+    // never fail the install over a convenience
+  }
+  process.exit(0);
+}

package/package.json

@@ -1,6 +1,33 @@
 {
   "name": "@atomiton-dev/gap-cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.9.0-mvp",
+  "description": "Install and run the GAP platform on your own machine with Docker.",
+  "bin": {
+    "gap": "bin/gap.js"
+  },
+  "scripts": {
+    "postinstall": "node lib/postinstall.js || exit 0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "UNLICENSED",
+  "files": [
+    "bin/gap.js",
+    "lib/launcher.js",
+    "lib/postinstall.js",
+    "installer/VERSION",
+    "installer/CHANNEL",
+    "installer/gap",
+    "installer/gap-lib.sh",
+    "installer/install.sh",
+    "installer/gap.ps1",
+    "installer/gap-lib.ps1",
+    "installer/install.ps1",
+    "installer/docker-compose.yml",
+    "installer/env.template"
+  ]
+}