@stacksjs/launchpad/dist/services/definitions.d.ts

Like Homebrew, but faster.

import type { ServiceDefinition } from '../types';
/**
 * Get service definition by name
 */
export declare function getServiceDefinition(serviceName: string): ServiceDefinition | undefined;
/**
 * Get all available service definitions
 */
export declare function getAllServiceDefinitions(): ServiceDefinition[];
/**
 * Get service definitions that match a package domain
 */
export declare function getServiceDefinitionsByPackage(packageDomain: string): ServiceDefinition[];
/**
 * Check if a service is supported
 */
export declare function isServiceSupported(serviceName: string): boolean;
/**
 * Detect services based on installed packages
 */
export declare function detectInstalledServices(installedPackages: string[]): ServiceDefinition[];
/**
 * Create default configuration content for a service
 */
export declare function createDefaultServiceConfig(serviceName: string): string | null;
/**
 * Predefined service definitions for common services
 * These services can be automatically detected and managed by Launchpad
 */
export declare const SERVICE_DEFINITIONS: {
  postgres: {
  name: 'postgres';
  displayName: 'PostgreSQL';
  description: 'PostgreSQL database server';
  packageDomain: 'postgresql.org';
  executable: 'postgres';
  args: readonly ['-D', '{dataDir}', '-p', '{port}', '-c', 'listen_addresses=127.0.0.1'];
  env: {
  PGDATA: '{dataDir}'
};
  dataDirectory: unknown;
  logFile: unknown;
  pidFile: unknown;
  port: 5432;
  dependencies: readonly ['openssl.org^1.0.1', 'gnu.org/readline', 'zlib.net', 'lz4.org', 'gnome.org/libxml2~2.13', 'gnome.org/libxslt', 'unicode.org^73'];
  healthCheck: {
  command: readonly ['pg_isready', '-h', '127.0.0.1', '-p', '5432'];
  expectedExitCode: 0;
  timeout: 5;
  interval: 30;
  retries: 3
};
  initCommand: readonly ['initdb', '-D', '{dataDir}', '--auth-local={authMethod}', '--auth-host={authMethod}', '--encoding=UTF8'];
  postStartCommands: readonly [unknown, unknown, unknown, unknown, readonly ['psql', '-h', '127.0.0.1', '-p', '5432', '-d', 'postgres', '-c', 'GRANT CREATE ON SCHEMA public TO {appUser};'], readonly ['psql', '-h', '127.0.0.1', '-p', '5432', '-d', 'postgres', '-c', 'GRANT USAGE ON SCHEMA public TO {appUser};']];
  supportsGracefulShutdown: true;
  config: {
  // Default configuration that can be overridden
      listen_addresses: 'localhost';
  port: 5432;
  max_connections: 100;
  shared_buffers: '128MB';
  log_destination: 'stderr';
  logging_collector: 'on';
  log_directory: 'log';
  log_filename: 'postgresql-%Y-%m-%d_%H%M%S.log';
  log_statement: 'none';
  log_line_prefix: '%t [%p]: [%l-1] user=%u,db=%d,app=%a,client=%h ';
  projectDatabase: '{projectName}';
  // Will be replaced with actual project name
      appUser: '{dbUsername}';
  // Will be replaced with configured username
      appPassword: '{dbPassword}'
}
};
  php: {
  name: 'php';
  displayName: 'PHP';
  description: 'PHP with database extensions (PostgreSQL, MySQL, SQLite)';
  packageDomain: 'php.net';
  executable: 'php';
  args: Array<never>;
  env: {};
  dataDirectory: unknown;
  configFile: unknown;
  dependencies: readonly ['postgresql.org/libpq', unknown];
  supportsGracefulShutdown: false;
  extensions: {
  // Extensions that can be installed via PECL
      pecl: {
  required: readonly ['pdo_pgsql', 'pgsql'];
  // These will be installed automatically when PostgreSQL is needed
        optional: readonly ['redis', 'memcached', 'imagick', 'xdebug'];
  // These can be installed on demand
        buildDependencies: {
  pdo_pgsql: readonly ['postgresql.org/libpq'];
  pgsql: readonly ['postgresql.org/libpq'];
  redis: Array<never>;
  memcached: Array<never>;
  imagick: Array<never>
}
}
};
  config: {
  extensions: readonly ['pdo', 'pdo_sqlite', 'pdo_mysql', 'pdo_pgsql', 'mysqli', 'pgsql', 'sqlite3'];
  memory_limit: '512M';
  max_execution_time: 300;
  upload_max_filesize: '64M';
  post_max_size: '64M';
  display_errors: 'On';
  error_reporting: 'E_ALL'
}
};
  mysql: {
  name: 'mysql';
  displayName: 'MySQL';
  description: 'MySQL database server';
  packageDomain: 'mysql.com';
  executable: 'mysqld_safe';
  args: readonly ['--datadir={dataDir}', '--pid-file={pidFile}'];
  env: {};
  dataDirectory: unknown;
  logFile: unknown;
  pidFile: unknown;
  port: 3306;
  dependencies: Array<never>;
  healthCheck: {
  command: readonly ['mysqladmin', 'ping', '-h', '127.0.0.1', '-P', '3306'];
  expectedExitCode: 0;
  timeout: 5;
  interval: 30;
  retries: 3
};
  initCommand: readonly ['mysqld', '--initialize-insecure', '--datadir={dataDir}', '--user=mysql'];
  postStartCommands: readonly [unknown, readonly ['mysql', '-u', 'root', '-e', 'CREATE USER IF NOT EXISTS \'{dbUsername}\'@\'localhost\' IDENTIFIED BY \'{dbPassword}\';'], readonly ['mysql', '-u', 'root', '-e', 'GRANT ALL PRIVILEGES ON {projectDatabase}.* TO \'{dbUsername}\'@\'localhost\';'], readonly ['mysql', '-u', 'root', '-e', 'FLUSH PRIVILEGES;']];
  supportsGracefulShutdown: true;
  config: {
  bind_address: '127.0.0.1';
  port: 3306;
  max_connections: 100;
  innodb_buffer_pool_size: '128M';
  query_cache_size: '32M';
  tmp_table_size: '32M';
  max_heap_table_size: '32M';
  projectDatabase: '{projectName}';
  // Will be replaced with actual project name
      appUser: '{dbUsername}';
  // Will be replaced with configured username
      appPassword: '{dbPassword}'
}
};
  redis: {
  name: 'redis';
  displayName: 'Redis';
  description: 'Redis in-memory data store';
  packageDomain: 'redis.io';
  executable: 'redis-server';
  args: readonly ['{configFile}'];
  env: {};
  dataDirectory: unknown;
  configFile: unknown;
  logFile: unknown;
  pidFile: unknown;
  port: 6379;
  dependencies: Array<never>;
  healthCheck: {
  command: readonly ['redis-cli', 'ping'];
  expectedExitCode: 0;
  timeout: 5;
  interval: 30;
  retries: 3
};
  supportsGracefulShutdown: true
};
  nginx: {
  name: 'nginx';
  displayName: 'Nginx';
  description: 'Nginx web server';
  packageDomain: 'nginx.org';
  executable: 'nginx';
  args: readonly ['-c', '{configFile}', '-g', 'daemon off;'];
  env: {};
  configFile: unknown;
  logFile: unknown;
  pidFile: unknown;
  port: 8080;
  dependencies: Array<never>;
  healthCheck: {
  command: readonly ['curl', '-f', '-s', 'http://localhost:8080/health'];
  expectedExitCode: 0;
  timeout: 5;
  interval: 30;
  retries: 3
};
  supportsGracefulShutdown: true
};
  memcached: {
  name: 'memcached';
  displayName: 'Memcached';
  description: 'Memcached memory object caching system';
  packageDomain: 'memcached.org';
  executable: 'memcached';
  args: readonly ['-p', '11211', '-m', '64', '-c', '1024'];
  env: {};
  port: 11211;
  dependencies: Array<never>;
  healthCheck: {
  command: readonly ['nc', '-z', 'localhost', '11211'];
  expectedExitCode: 0;
  timeout: 5;
  interval: 30;
  retries: 3
};
  supportsGracefulShutdown: true
};
  mongodb: {
  name: 'mongodb';
  displayName: 'MongoDB';
  description: 'MongoDB document database';
  packageDomain: 'mongodb.com';
  executable: 'mongod';
  args: readonly ['--dbpath', '{dataDir}', '--port', '27017'];
  env: {};
  dataDirectory: unknown;
  logFile: unknown;
  pidFile: unknown;
  port: 27017;
  dependencies: Array<never>;
  healthCheck: {
  command: readonly ['mongo', '--eval', 'db.runCommand("ping")', '--quiet'];
  expectedExitCode: 0;
  timeout: 5;
  interval: 30;
  retries: 3
};
  supportsGracefulShutdown: true
};
  rabbitmq: {
  name: 'rabbitmq';
  displayName: 'RabbitMQ';
  description: 'RabbitMQ message broker';
  packageDomain: 'rabbitmq.com';
  executable: 'rabbitmq-server';
  args: Array<never>;
  env: {
  RABBITMQ_MNESIA_BASE: unknown;
  RABBITMQ_LOG_BASE: unknown
};
  dataDirectory: unknown;
  logFile: unknown;
  port: 5672;
  dependencies: Array<never>;
  healthCheck: {
  command: readonly ['rabbitmqctl', 'status'];
  expectedExitCode: 0;
  timeout: 10;
  interval: 30;
  retries: 3
};
  supportsGracefulShutdown: true
};
  elasticsearch: {
  name: 'elasticsearch';
  displayName: 'Elasticsearch';
  description: 'Elasticsearch search engine';
  packageDomain: 'elastic.co';
  executable: 'elasticsearch';
  args: Array<never>;
  env: {
  ES_PATH_DATA: unknown;
  ES_PATH_LOGS: unknown
};
  dataDirectory: unknown;
  logFile: unknown;
  port: 9200;
  dependencies: Array<never>;
  healthCheck: {
  command: readonly ['curl', '-f', '-s', 'http://localhost:9200/_health'];
  expectedExitCode: 0;
  timeout: 10;
  interval: 30;
  retries: 3
};
  supportsGracefulShutdown: true
};
  caddy: {
  name: 'caddy';
  displayName: 'Caddy';
  description: 'Caddy web server with automatic HTTPS';
  packageDomain: 'caddyserver.com';
  executable: 'caddy';
  args: readonly ['run', '--config', '{configFile}'];
  env: {};
  configFile: unknown;
  logFile: unknown;
  port: 2015;
  dependencies: Array<never>;
  healthCheck: {
  command: readonly ['curl', '-f', '-s', 'http://localhost:2015/health'];
  expectedExitCode: 0;
  timeout: 5;
  interval: 30;
  retries: 3
};
  supportsGracefulShutdown: true
};
  kafka: {
  name: 'kafka';
  displayName: 'Apache Kafka';
  description: 'Distributed event streaming platform';
  packageDomain: 'kafka.apache.org';
  executable: 'kafka-server-start.sh';
  args: readonly ['{configFile}'];
  env: {
  KAFKA_HEAP_OPTS: '-Xmx1G -Xms1G';
  LOG_DIR: unknown
};
  dataDirectory: unknown;
  configFile: unknown;
  logFile: unknown;
  port: 9092;
  dependencies: Array<never>;
  healthCheck: {
  command: readonly ['kafka-broker-api-versions.sh', '--bootstrap-server', 'localhost:9092'];
  expectedExitCode: 0;
  timeout: 10;
  interval: 30;
  retries: 3
};
  supportsGracefulShutdown: true
};
  vault: {
  name: 'vault';
  displayName: 'HashiCorp Vault';
  description: 'Secrets management, encryption as a service, and privileged access management';
  packageDomain: 'vaultproject.io';
  executable: 'vault';
  args: readonly ['server', '-config', '{configFile}'];
  env: {
  VAULT_API_ADDR: 'http://localhost:8200';
  VAULT_ADDR: 'http://localhost:8200'
};
  dataDirectory: unknown;
  configFile: unknown;
  logFile: unknown;
  port: 8200;
  dependencies: Array<never>;
  healthCheck: {
  command: readonly ['vault', 'status'];
  expectedExitCode: 2;
  // Vault returns 2 when sealed but running
      timeout: 5;
  interval: 30;
  retries: 3
};
  supportsGracefulShutdown: true
};
  minio: {
  name: 'minio';
  displayName: 'MinIO';
  description: 'High-performance, S3 compatible object storage';
  packageDomain: 'min.io';
  executable: 'minio';
  args: readonly ['server', '{dataDir}', '--address', 'localhost:9000', '--console-address', 'localhost:9001'];
  env: {
  MINIO_ROOT_USER: 'minioadmin';
  MINIO_ROOT_PASSWORD: 'minioadmin'
};
  dataDirectory: unknown;
  logFile: unknown;
  port: 9000;
  dependencies: Array<never>;
  healthCheck: {
  command: readonly ['curl', '-f', '-s', 'http://localhost:9000/minio/health/live'];
  expectedExitCode: 0;
  timeout: 5;
  interval: 30;
  retries: 3
};
  supportsGracefulShutdown: true
};
  prometheus: {
  name: 'prometheus';
  displayName: 'Prometheus';
  description: 'Monitoring system and time series database';
  packageDomain: 'prometheus.io';
  executable: 'prometheus';
  args: readonly ['--config.file={configFile}', '--storage.tsdb.path={dataDir}', '--web.console.libraries=/usr/share/prometheus/console_libraries', '--web.console.templates=/usr/share/prometheus/consoles'];
  env: {};
  dataDirectory: unknown;
  configFile: unknown;
  logFile: unknown;
  port: 9090;
  dependencies: Array<never>;
  healthCheck: {
  command: readonly ['curl', '-f', '-s', 'http://localhost:9090/-/healthy'];
  expectedExitCode: 0;
  timeout: 5;
  interval: 30;
  retries: 3
};
  supportsGracefulShutdown: true
};
  grafana: {
  name: 'grafana';
  displayName: 'Grafana';
  description: 'Analytics and interactive visualization web application';
  packageDomain: 'grafana.com';
  executable: 'grafana-server';
  args: readonly ['--config={configFile}', '--homepath={dataDir}'];
  env: {
  GF_PATHS_DATA: unknown;
  GF_PATHS_LOGS: unknown
};
  dataDirectory: unknown;
  configFile: unknown;
  logFile: unknown;
  port: 3000;
  dependencies: Array<never>;
  healthCheck: {
  command: readonly ['curl', '-f', '-s', 'http://localhost:3000/api/health'];
  expectedExitCode: 0;
  timeout: 10;
  interval: 30;
  retries: 3
};
  supportsGracefulShutdown: true
};
  jaeger: {
  name: 'jaeger';
  displayName: 'Jaeger';
  description: 'Distributed tracing platform';
  packageDomain: 'jaegertracing.io';
  executable: 'jaeger-all-in-one';
  args: readonly ['--memory.max-traces', '10000'];
  env: {};
  logFile: unknown;
  port: 16686;
  dependencies: Array<never>;
  healthCheck: {
  command: readonly ['curl', '-f', '-s', 'http://localhost:14269/'];
  expectedExitCode: 0;
  timeout: 5;
  interval: 30;
  retries: 3
};
  supportsGracefulShutdown: true
};
  sonarqube: {
  name: 'sonarqube';
  displayName: 'SonarQube';
  description: 'Continuous code quality and security analysis';
  packageDomain: 'sonarqube.org';
  executable: 'sonar.sh';
  args: readonly ['start'];
  env: {
  SONAR_JAVA_PATH: 'java'
};
  dataDirectory: unknown;
  configFile: unknown;
  logFile: unknown;
  port: 9001;
  dependencies: Array<never>;
  healthCheck: {
  command: readonly ['curl', '-f', '-s', 'http://localhost:9000/api/system/status'];
  expectedExitCode: 0;
  timeout: 30;
  interval: 60;
  retries: 5
};
  supportsGracefulShutdown: true
};
  consul: {
  name: 'consul';
  displayName: 'HashiCorp Consul';
  description: 'Service networking platform for service discovery and configuration';
  packageDomain: 'consul.io';
  executable: 'consul';
  args: readonly ['agent', '-dev', '-config-dir', '{configDir}', '-data-dir', '{dataDir}'];
  env: {};
  dataDirectory: unknown;
  configFile: unknown;
  logFile: unknown;
  port: 8500;
  dependencies: Array<never>;
  healthCheck: {
  command: readonly ['consul', 'members'];
  expectedExitCode: 0;
  timeout: 5;
  interval: 30;
  retries: 3
};
  supportsGracefulShutdown: true
};
  etcd: {
  name: 'etcd';
  displayName: 'etcd';
  description: 'Distributed reliable key-value store';
  packageDomain: 'etcd.io';
  executable: 'etcd';
  args: readonly ['--data-dir', '{dataDir}', '--listen-client-urls', 'http://localhost:2379', '--advertise-client-urls', 'http://localhost:2379'];
  env: {};
  dataDirectory: unknown;
  logFile: unknown;
  port: 2379;
  dependencies: Array<never>;
  healthCheck: {
  command: readonly ['etcdctl', 'endpoint', 'health'];
  expectedExitCode: 0;
  timeout: 5;
  interval: 30;
  retries: 3
};
  supportsGracefulShutdown: true
};
  influxdb: {
  name: 'influxdb';
  displayName: 'InfluxDB';
  description: 'Time series database';
  packageDomain: 'influxdata.com';
  executable: 'influxd';
  args: readonly ['--config', '{configFile}'];
  env: {};
  dataDirectory: unknown;
  configFile: unknown;
  logFile: unknown;
  port: 8086;
  dependencies: Array<never>;
  healthCheck: {
  command: readonly ['curl', '-f', '-s', 'http://localhost:8086/ping'];
  expectedExitCode: 0;
  timeout: 5;
  interval: 30;
  retries: 3
};
  supportsGracefulShutdown: true
};
  temporal: {
  name: 'temporal';
  displayName: 'Temporal';
  description: 'Workflow orchestration platform';
  packageDomain: 'temporal.io';
  executable: 'temporal';
  args: readonly ['server', 'start-dev', '--db-filename', '{dataDir}/temporal.db'];
  env: {};
  dataDirectory: unknown;
  logFile: unknown;
  port: 7233;
  dependencies: Array<never>;
  healthCheck: {
  command: readonly ['temporal', 'operator', 'cluster', 'health'];
  expectedExitCode: 0;
  timeout: 10;
  interval: 30;
  retries: 3
};
  supportsGracefulShutdown: true
};
  cockroachdb: {
  name: 'cockroachdb';
  displayName: 'CockroachDB';
  description: 'Distributed SQL database';
  packageDomain: 'cockroachlabs.com';
  executable: 'cockroach';
  args: readonly ['start-single-node', '--insecure', '--store={dataDir}', '--listen-addr=localhost:26257', '--http-addr=localhost:8080'];
  env: {};
  dataDirectory: unknown;
  logFile: unknown;
  port: 26257;
  dependencies: Array<never>;
  healthCheck: {
  command: readonly ['cockroach', 'sql', '--insecure', '--execute=SELECT 1;'];
  expectedExitCode: 0;
  timeout: 10;
  interval: 30;
  retries: 3
};
  supportsGracefulShutdown: true
};
  neo4j: {
  name: 'neo4j';
  displayName: 'Neo4j';
  description: 'Graph database';
  packageDomain: 'neo4j.com';
  executable: 'neo4j';
  args: readonly ['console'];
  env: {
  NEO4J_HOME: unknown;
  NEO4J_DATA: unknown;
  NEO4J_LOGS: unknown
};
  dataDirectory: unknown;
  configFile: unknown;
  logFile: unknown;
  port: 7474;
  dependencies: Array<never>;
  healthCheck: {
  command: readonly ['curl', '-f', '-s', 'http://localhost:7474/db/data/'];
  expectedExitCode: 0;
  timeout: 10;
  interval: 30;
  retries: 3
};
  supportsGracefulShutdown: true
};
  pulsar: {
  name: 'pulsar';
  displayName: 'Apache Pulsar';
  description: 'Cloud-native distributed messaging and streaming platform';
  packageDomain: 'pulsar.apache.org';
  executable: 'pulsar';
  args: readonly ['standalone'];
  env: {
  PULSAR_MEM: '-Xms512m -Xmx512m -XX:MaxDirectMemorySize=256m';
  PULSAR_GC: '-XX:+UseG1GC'
};
  dataDirectory: unknown;
  configFile: unknown;
  logFile: unknown;
  port: 6650;
  dependencies: Array<never>;
  healthCheck: {
  command: readonly ['curl', '-f', '-s', 'http://localhost:8080/admin/v2/clusters'];
  expectedExitCode: 0;
  timeout: 10;
  interval: 30;
  retries: 3
};
  supportsGracefulShutdown: true
};
  nats: {
  name: 'nats';
  displayName: 'NATS';
  description: 'High-performance messaging system';
  packageDomain: 'nats.io';
  executable: 'nats-server';
  args: readonly ['--config', '{configFile}'];
  env: {};
  configFile: unknown;
  logFile: unknown;
  port: 4222;
  dependencies: Array<never>;
  healthCheck: {
  command: readonly ['curl', '-f', '-s', 'http://localhost:8222/varz'];
  expectedExitCode: 0;
  timeout: 5;
  interval: 30;
  retries: 3
};
  supportsGracefulShutdown: true
};
  jenkins: {
  name: 'jenkins';
  displayName: 'Jenkins';
  description: 'Automation server for CI/CD';
  packageDomain: 'jenkins.io';
  executable: 'jenkins';
  args: readonly ['--httpPort=8090', '--webroot={dataDir}/war'];
  env: {
  JENKINS_HOME: unknown;
  JAVA_OPTS: '-Xmx512m'
};
  dataDirectory: unknown;
  logFile: unknown;
  port: 8090;
  dependencies: Array<never>;
  healthCheck: {
  command: readonly ['curl', '-f', '-s', 'http://localhost:8090/login'];
  expectedExitCode: 0;
  timeout: 30;
  interval: 60;
  retries: 5
};
  supportsGracefulShutdown: true
};
  localstack: {
  name: 'localstack';
  displayName: 'LocalStack';
  description: 'Local AWS cloud stack for development';
  packageDomain: 'localstack.cloud';
  executable: 'localstack';
  args: readonly ['start'];
  env: {
  LOCALSTACK_HOST: 'localhost:4566';
  DATA_DIR: unknown;
  TMPDIR: unknown
};
  dataDirectory: unknown;
  logFile: unknown;
  port: 4566;
  dependencies: Array<never>;
  healthCheck: {
  command: readonly ['curl', '-f', '-s', 'http://localhost:4566/_localstack/health'];
  expectedExitCode: 0;
  timeout: 10;
  interval: 30;
  retries: 3
};
  supportsGracefulShutdown: true
};
  hasura: {
  name: 'hasura';
  displayName: 'Hasura';
  description: 'GraphQL API with real-time subscriptions';
  packageDomain: 'hasura.io';
  executable: 'graphql-engine';
  args: readonly ['serve'];
  env: {
  HASURA_GRAPHQL_DATABASE_URL: 'postgres://localhost:5432/postgres';
  HASURA_GRAPHQL_ENABLE_CONSOLE: 'true';
  HASURA_GRAPHQL_DEV_MODE: 'true';
  HASURA_GRAPHQL_ENABLED_LOG_TYPES: 'startup, http-log, webhook-log, websocket-log, query-log';
  HASURA_GRAPHQL_SERVER_PORT: '8085'
};
  logFile: unknown;
  port: 8085;
  dependencies: readonly ['postgres'];
  healthCheck: {
  command: readonly ['curl', '-f', '-s', 'http://localhost:8085/healthz'];
  expectedExitCode: 0;
  timeout: 10;
  interval: 30;
  retries: 3
};
  supportsGracefulShutdown: true
};
  keycloak: {
  name: 'keycloak';
  displayName: 'Keycloak';
  description: 'Identity and access management';
  packageDomain: 'keycloak.org';
  executable: 'kc.sh';
  args: readonly ['start-dev', '--http-port=8088'];
  env: {
  KEYCLOAK_ADMIN: 'admin';
  KEYCLOAK_ADMIN_PASSWORD: 'admin';
  KC_DB: 'dev-file';
  KC_DB_URL_DATABASE: unknown
};
  dataDirectory: unknown;
  logFile: unknown;
  port: 8088;
  dependencies: Array<never>;
  healthCheck: {
  command: readonly ['curl', '-f', '-s', 'http://localhost:8088/health'];
  expectedExitCode: 0;
  timeout: 30;
  interval: 60;
  retries: 5
};
  supportsGracefulShutdown: true
};
  clickhouse: {
  name: 'clickhouse';
  displayName: 'ClickHouse';
  description: 'Columnar database for analytics';
  packageDomain: 'clickhouse.com';
  executable: 'clickhouse-server';
  args: readonly ['--config-file={configFile}'];
  env: {};
  dataDirectory: unknown;
  configFile: unknown;
  logFile: unknown;
  port: 8123;
  dependencies: Array<never>;
  healthCheck: {
  command: readonly ['curl', '-f', '-s', 'http://localhost:8123/ping'];
  expectedExitCode: 0;
  timeout: 10;
  interval: 30;
  retries: 3
};
  supportsGracefulShutdown: true
};
  verdaccio: {
  name: 'verdaccio';
  displayName: 'Verdaccio';
  description: 'Private npm registry';
  packageDomain: 'verdaccio.org';
  executable: 'verdaccio';
  args: readonly ['--config', '{configFile}'];
  env: {};
  dataDirectory: unknown;
  configFile: unknown;
  logFile: unknown;
  port: 4873;
  dependencies: Array<never>;
  healthCheck: {
  command: readonly ['curl', '-f', '-s', 'http://localhost:4873/-/ping'];
  expectedExitCode: 0;
  timeout: 5;
  interval: 30;
  retries: 3
};
  supportsGracefulShutdown: true
};
  meilisearch: {
  name: 'meilisearch';
  displayName: 'Meilisearch';
  description: 'Meilisearch search engine';
  packageDomain: 'meilisearch.com';
  executable: 'meilisearch';
  args: readonly ['--http-addr', '127.0.0.1:{port}', '--db-path', '{dataDir}', '--master-key', '{masterKey}'];
  env: {
  MEILI_HTTP_ADDR: '127.0.0.1:{port}';
  MEILI_DB_PATH: '{dataDir}';
  MEILI_MASTER_KEY: '{masterKey}';
  MEILI_ENV: 'development'
};
  dataDirectory: unknown;
  logFile: unknown;
  port: 7700;
  dependencies: Array<never>;
  healthCheck: {
  command: readonly ['curl', '-f', '-s', 'http://127.0.0.1:7700/health'];
  expectedExitCode: 0;
  timeout: 10;
  interval: 30;
  retries: 3
};
  supportsGracefulShutdown: true;
  config: {
  masterKey: 'launchpad-dev-key-12345678901234567890123456789012';
  httpAddr: '127.0.0.1:7700';
  environment: 'development';
  maxIndexSize: '100 MB';
  maxTaskDbSize: '100 MB';
  httpPayloadSizeLimit: '100 MB';
  logLevel: 'INFO';
  maxIndexingMemory: '2 GB';
  maxIndexingThreads: 4
}
}
};