@platformatic/control 3.0.0-alpha.1 → 3.0.0-alpha.2

package/control.js

@@ -1,85 +0,0 @@
-#! /usr/bin/env node
-
-const { join } = require('node:path')
-const { parseArgs } = require('node:util')
-const commist = require('commist')
-const helpMe = require('help-me')
-
-const runtimeMetricsCommand = require('./lib/metrics')
-const getRuntimesCommand = require('./lib/ps')
-const getRuntimesEnvCommand = require('./lib/env')
-const getRuntimeServicesCommand = require('./lib/services')
-const getRuntimeConfigCommand = require('./lib/config')
-const stopRuntimeCommand = require('./lib/stop')
-const reloadRuntimeCommand = require('./lib/reload')
-const restartRuntimeCommand = require('./lib/restart')
-const injectRuntimeCommand = require('./lib/inject')
-const streamRuntimeLogsCommand = require('./lib/logs')
-
-const help = helpMe({
-  dir: join(__dirname, 'help'),
-  ext: '.txt',
-})
-
-const program = commist({ maxDistance: 2 })
-
-program.register('ps', wrapCommand(getRuntimesCommand))
-program.register('stop', wrapCommand(stopRuntimeCommand))
-program.register('reload', wrapCommand(reloadRuntimeCommand))
-program.register('restart', wrapCommand(restartRuntimeCommand))
-program.register('logs', wrapCommand(streamRuntimeLogsCommand))
-program.register('metrics', wrapCommand(runtimeMetricsCommand))
-program.register('env', wrapCommand(getRuntimesEnvCommand))
-program.register('services', wrapCommand(getRuntimeServicesCommand))
-program.register('config', wrapCommand(getRuntimeConfigCommand))
-program.register('inject', wrapCommand(injectRuntimeCommand))
-program.register('help', help.toStdout)
-
-async function runControl (argv) {
-  if (argv.length === 0) {
-    help.toStdout()
-    return {}
-  }
-
-  const args = parseArgs({
-    args: argv,
-    options: {
-      version: { type: 'boolean', short: 'v' },
-    },
-    strict: false,
-  }).values
-
-  if (args.version && argv[0] !== 'inject') {
-    const packageJson = require(join(__dirname, 'package.json'))
-    console.log(packageJson.version)
-    process.exit(0)
-  }
-
-  const output = await program.parseAsync(argv)
-  return { output }
-}
-
-if (require.main === module) {
-  runControl(process.argv.slice(2))
-}
-
-function wrapCommand (fn) {
-  return async function (...args) {
-    try {
-      return await fn(...args)
-    } catch (err) {
-      console.log(err.message)
-    }
-  }
-}
-
-module.exports = {
-  runControl,
-  getRuntimesCommand,
-  getRuntimesEnvCommand,
-  getRuntimeServicesCommand,
-  stopRuntimeCommand,
-  restartRuntimeCommand,
-  injectRuntimeCommand,
-  streamRuntimeLogsCommand,
-}

package/help/config.txt

@@ -1,16 +0,0 @@
-Prints runtime or runtime service config file
-
-``` bash
-  $ platformatic ctl config -n runtime-name
-```
-
-Options:
-
-* `-p, --pid <number>` - The process id of the runtime.
-* `-n, --name <string>` - The name of the runtime.
-
-The `config` command uses the Platformatic Runtime Management API. To enable it
-set the `managementApi` option to `true` in the runtime configuration file.
-
-To get the list of runtimes with enabled management API use the
-`platformatic ctl ps` command.

package/help/env.txt

@@ -1,16 +0,0 @@
-Lists platformatic runtime application environment variables
-
-``` bash
-  $ platformatic ctl env -n runtime-name
-```
-
-Options:
-
-* `-p, --pid <number>` - The process id of the runtime.
-* `-n, --name <string>` - The name of the runtime.
-
-The `env` command uses the Platformatic Runtime Management API. To enable it
-set the `managementApi` option to `true` in the runtime configuration file.
-
-To get the list of runtimes with enabled management API use the
-`platformatic ctl ps` command.

package/help/help.txt

@@ -1,11 +0,0 @@
-Available commands:
-
-* `ps` - lists all platformatic runtime applications.
-* `stop` - stops a platformatic runtime application.
-* `restart` - restarts all platformatic runtime services.
-* `reload` - reloads all platformatic runtime services.
-* `services` - lists the runtime services.
-* `config` - prints runtime or runtime service config file.
-* `env` - lists the runtime environment variables.
-* `logs` - shows the runtime logs.
-* `inject` - injects a request to the runtime service.

package/help/inject.txt

@@ -1,30 +0,0 @@
-Injects a request to the platformatic runtime service.
-
-``` bash
-  $ platformatic ctl inject -n runtime-name /hello
-     -X POST
-     -H "Content-Type: application/json"
-     -d '{"key": "value"}'
-```
-
-Options:
-
-* `-p, --pid <number>` - The process id of the runtime.
-* `-n, --name <string>` - The name of the runtime.
-* `-s, --service <string>` - The name of the runtime service.
-* `-X, --request <string>` - The request HTTP method. Default is `GET`.
-* `-H, --header <string>` - The request header. Can be used multiple times.
-* `-d, --data <string>` - The request data.
-* `-i, --include <boolean>` - Include the response headers in the output. Default is `false`.
-* `-v, --verbose <boolean>` - Make the operation more talkative. Default is `false`.
-* `-o, --output <file>` - Write the response to the specified file.
-
-The `inject` command sends a request to the runtime service and prints the
-response to the standard output. If the `--service` option is not specified the
-request is sent to the runtime entrypoint.
-
-The `inject` command uses the Platformatic Runtime Management API. To enable it
-set the `managementApi` option to `true` in the runtime configuration file.
-
-To get the list of runtimes with enabled management API use the
-`platformatic ctl ps` command.

package/help/logs.txt

@@ -1,21 +0,0 @@
-Streams logs from the platformatic runtime application.
-
-``` bash
-  $ platformatic ctl logs -n runtime-name
-```
-
-Options:
-
-* `-p, --pid <number>` - The process id of the runtime.
-* `-n, --name <string>` - The name of the runtime.
-* `-l, --level <string>` - The pino log level to stream. Default is `info`.
-* `-s, --service <string>` - The name of the service to stream logs from.
-* `--pretty <boolean>` - Pretty print the logs. Default is `true`.
-
-If `--service` is not specified, the command will stream logs from all services.
-
-The `logs` command uses the Platformatic Runtime Management API. To enable it
-set the `managementApi` option to `true` in the runtime configuration file.
-
-To get the list of runtimes with enabled management API use the
-`platformatic ctl ps` command.

package/help/metrics.txt

@@ -1,14 +0,0 @@
-Get metrics from the platformatic runtime application.
-
-``` bash
-  $ platformatic ctl metrics
-```
-
-Options:
-
-* `-p, --pid <number>` - The process id of the runtime.
-* `-f, --format <string>` - The format of the metrics, which should be either `text` or `json` (default to `json`).
-
-If `--pid` is not specified, the command will get metrics from the first available matching runtime.
-
-To see the list of all available control commands, run `platformatic ctl help`.

package/help/ps.txt

@@ -1,10 +0,0 @@
-Lists all running platformatic runtime applications.
-
-``` bash
-  $ platformatic ctl ps
-```
-
-To see the list of all available control commands, run `platformatic ctl help`.
-
-The `ps` command uses the Platformatic Runtime Management API. To enable it
-set the `managementApi` option to `true` in the runtime configuration file.

package/help/reload.txt

@@ -1,19 +0,0 @@
-Reloads a platformatic runtime application.
-
-``` bash
-  $ platformatic ctl reload -n runtime-name
-```
-
-Options:
-
-* `-p, --pid <number>` - The process id of the runtime to reload.
-* `-n, --name <string>` - The name of the runtime to reload.
-
-The difference between `reload` and `restart` is that `reload` does not kill
-the runtime process. It stops and starts all the runtime services.
-
-The `reload` command uses the Platformatic Runtime Management API. To enable it
-set the `managementApi` option to `true` in the runtime configuration file.
-
-To get the list of runtimes with enabled management API use the
-`platformatic ctl ps` command.

package/help/restart.txt

@@ -1,16 +0,0 @@
-Restarts a platformatic runtime application.
-
-``` bash
-  $ platformatic ctl restart -n runtime-name
-```
-
-Options:
-
-* `-p, --pid <number>` - The process id of the runtime to restart.
-* `-n, --name <string>` - The name of the runtime to restart.
-
-The `restart` command uses the Platformatic Runtime Management API. To enable it
-set the `managementApi` option to `true` in the runtime configuration file.
-
-To get the list of runtimes with enabled management API use the
-`platformatic ctl ps` command.

package/help/services.txt

@@ -1,16 +0,0 @@
-Lists the platformatic runtime services.
-
-``` bash
-  $ platformatic ctl services -n runtime-name
-```
-
-Options:
-
-* `-p, --pid <number>` - The process id of the runtime.
-* `-n, --name <string>` - The name of the runtime.
-
-The `services` command uses the Platformatic Runtime Management API. To enable it
-set the `managementApi` option to `true` in the runtime configuration file.
-
-To get the list of runtimes with enabled management API use the
-`platformatic ctl ps` command.

package/help/stop.txt

@@ -1,16 +0,0 @@
-Stops a platformatic runtime application.
-
-``` bash
-  $ platformatic ctl stop -n runtime-name
-```
-
-Options:
-
-* `-p, --pid <number>` - The process id of the runtime to stop.
-* `-n, --name <string>` - The name of the runtime to stop.
-
-The `stop` command uses the Platformatic Runtime Management API. To enable it
-set the `managementApi` option to `true` in the runtime configuration file.
-
-To get the list of runtimes with enabled management API use the
-`platformatic ctl ps` command.

package/index.d.ts

@@ -1,151 +0,0 @@
-import { ChildProcess } from "node:child_process";
-import BodyReadable from "undici/types/readable";
-import { FastifyError } from "@fastify/error";
-import { Readable } from "node:stream";
-import { HttpHeader } from 'fastify/types/utils'
-import WebSocket from "ws";
-
-declare namespace control {
-  class WebSocketStream extends Readable {
-    constructor(url: string);
-    ws: WebSocket;
-  }
-
-  interface Runtime {
-    pid: number,
-    cwd: string,
-    argv: string[],
-    uptimeSeconds: number,
-    execPath: string,
-    nodeVersion: string,
-    projectDir: string,
-    packageName: string | null,
-    packageVersion: string | null,
-    url: string | null,
-    platformaticVersion: string
-  }
-
-  interface RuntimeServices {
-    entrypoint: string,
-    production: boolean,
-    services: ({
-      id: string;
-      type: string;
-      status: string;
-      version: string;
-      localUrl: string;
-      entrypoint: boolean;
-      url?: string;
-      workers?: number;
-      dependencies: {
-        id: string;
-        url: string;
-        local: boolean;
-      }[];
-    } | {
-      id: string;
-      status: string;
-    })[]
-  }
-
-  interface MetricValue {
-    value: number,
-    labels: {
-      route?: string,
-      quantile?: number,
-      method?: string,
-      status_code?: number,
-      telemetry_id?: string,
-      type?: string,
-      space?: string,
-      version?: string,
-      major?: number,
-      minor?: number,
-      patch?: number,
-      le?: number | string,
-      kind?: string,
-      serviceId: string,
-      workerId?: number
-    },
-    metricName?: string,
-    exemplar?: unknown
-  }
-  
-  interface Metric {
-    help: string,
-    name: string,
-    type: string,
-    values: MetricValue[],
-    aggregator: string
-  }
-
-  export class RuntimeApiClient {
-    getMatchingRuntime(options?: { pid?: string; name?: string }): Promise<Runtime>;
-    getRuntimes(): Promise<Runtime[]>;
-    getRuntimeMetadata(pid: number): Promise<Runtime>;
-    getRuntimeServices(pid: number): Promise<RuntimeServices>;
-    getRuntimeConfig(pid: number): Promise<void>;
-    getRuntimeServiceConfig(pid: number, serviceId?: string): Promise<void>;
-    getRuntimeEnv(pid: number): Promise<void>;
-    getRuntimeOpenapi(pid: number, serviceId: string): Promise<unknown>;
-    getRuntimeServiceEnv(pid: number, serviceId: string): Promise<unknown>;
-    reloadRuntime(pid: number, options?: object): Promise<ChildProcess>;
-    restartRuntime(pid: number): Promise<void>;
-    stopRuntime(pid: number): Promise<void>;
-    getRuntimeMetrics<T extends { format?: "text" | "json" }>(
-      pid: number,
-      options?: T
-    ): Promise<T extends { format: "text" } ? string : Metric[]>;
-    getRuntimeLiveMetricsStream(pid: number): WebSocketStream;
-    getRuntimeLiveLogsStream(
-      pid: number,
-      startLogIndex?: number
-    ): WebSocketStream;
-    getRuntimeLogsStream(
-      pid: number,
-      logsId: string,
-      options?: { runtimePID?: number }
-    ): Promise<BodyReadable>;
-    getRuntimeAllLogsStream(
-      pid: number,
-      options?: { runtimePID?: number }
-    ): Promise<BodyReadable>;
-    getRuntimeLogIndexes(
-      pid: number,
-      options?: { all?: boolean }
-    ): Promise<unknown>;
-    injectRuntime(
-      pid: number,
-      serviceId: string,
-      options: {
-        url: string;
-        method: string;
-        headers: object;
-        body: unknown;
-      }
-    ): Promise<{ headers: Record<string, HttpHeader>, statusCode: number, body: unknown }>;
-    close(): Promise<void>;
-  }
-
-  export module errors {
-    export const RuntimeNotFound: FastifyError;
-    export const ServiceNotFound: FastifyError;
-    export const MissingRequestURL: FastifyError;
-    export const FailedToGetRuntimeMetadata: FastifyError;
-    export const FailedToGetRuntimeServices: FastifyError;
-    export const FailedToGetRuntimeEnv: FastifyError;
-    export const FailedToGetRuntimeOpenapi: FastifyError;
-    export const FailedToStreamRuntimeLogs: FastifyError;
-    export const FailedToStopRuntime: FastifyError;
-    export const FailedToReloadRuntime: FastifyError;
-    export const FailedToGetRuntimeConfig: FastifyError;
-    export const FailedToGetRuntimeServiceEnv: FastifyError;
-    export const FailedToGetRuntimeServiceConfig: FastifyError;
-    export const FailedToGetRuntimeHistoryLogs: FastifyError;
-    export const FailedToGetRuntimeAllLogs: FastifyError;
-    export const FailedToGetRuntimeLogIndexes: FastifyError;
-    export const FailedToGetRuntimeMetrics: FastifyError;
-  }
-}
-
-export = control;

package/index.js

@@ -1,9 +0,0 @@
-'use strict'
-
-const RuntimeApiClient = require('./lib/runtime-api-client')
-const errors = require('./lib/errors')
-
-module.exports = {
-  RuntimeApiClient,
-  errors
-}

package/index.test-d.ts

@@ -1,63 +0,0 @@
-import { expectAssignable, expectError, expectType } from 'tsd'
-import { errors, Metric, Runtime, RuntimeApiClient, RuntimeServices } from '.'
-import { FastifyError } from '@fastify/error'
-
-// RuntimeApiClient
-let runtime = {} as Runtime
-let service = {} as RuntimeServices
-let metric = {} as Metric
-const api = new RuntimeApiClient()
-expectType<Promise<Runtime>>(api.getMatchingRuntime())
-expectType<Promise<Metric[]>>(api.getRuntimeMetrics(runtime.pid))
-expectType<Promise<Metric[]>>(api.getRuntimeMetrics(runtime.pid, {}))
-expectType<Promise<Metric[]>>(api.getRuntimeMetrics(runtime.pid, { format: 'json' }))
-expectType<Promise<string>>(api.getRuntimeMetrics(runtime.pid, { format: 'text' }))
-expectType<Promise<Runtime[]>>(api.getRuntimes())
-
-async () => {
-  const result = await api.injectRuntime(0, '', { body: {}, headers: {}, method: 'PUT', url: '/foo' })
-
-  expectType<unknown>(result.body)
-  expectType<number>(result.statusCode)
-  expectAssignable<Record<string, unknown>>(result.headers)
-  return result
-}
-
-const [service1] = service.services
-expectType<Promise<unknown>>(api.getRuntimeOpenapi(runtime.pid, service1.id))
-expectType<string[]>(runtime.argv)
-expectType<number>(runtime.uptimeSeconds)
-expectType<string | null>(runtime.packageVersion)
-expectType<Promise<{
-  entrypoint: string,
-  production: boolean,
-  services: RuntimeServices['services']
-}>>(api.getRuntimeServices(45))
-expectType<string>(service1.id)
-expectType<string>(service1.status)
-
-if ('url' in service1) {
-  expectType<string | undefined>(service1.url)
-  expectType<number | undefined>(service1.workers)
-}
-
-expectType<string>(metric.aggregator)
-expectType<string>(metric.values[0].labels.serviceId)
-expectType<number | undefined>(metric.values[0].labels?.quantile)
-expectType<string | undefined>(metric.values[0].labels?.route)
-expectType<string | undefined>(metric.values[0].labels?.method)
-expectType<number | undefined>(metric.values[0].labels?.status_code)
-expectType<string | undefined>(metric.values[0].labels?.telemetry_id)
-expectType<number | undefined>(metric.values[0].labels?.workerId)
-expectType<string | undefined>(metric.values[0].metricName)
-expectType<unknown | undefined>(metric.values[0].exemplar)
-expectType<Promise<void>>(api.close())
-
-// errors
-expectType<FastifyError>(errors.FailedToGetRuntimeAllLogs)
-expectType<FastifyError>(errors.FailedToGetRuntimeConfig)
-expectType<FastifyError>(errors.FailedToGetRuntimeEnv)
-expectType<FastifyError>(errors.FailedToGetRuntimeOpenapi)
-expectType<FastifyError>(errors.FailedToGetRuntimeHistoryLogs)
-expectError<string>(errors.FailedToGetRuntimeHistoryLogs)
-expectError<number>(errors.FailedToGetRuntimeHistoryLogs)

package/lib/config.js

@@ -1,29 +0,0 @@
-'use strict'
-
-const { parseArgs } = require('node:util')
-const RuntimeApiClient = require('./runtime-api-client')
-
-async function getRuntimeConfigCommand (argv) {
-  const args = parseArgs({
-    args: argv,
-    options: {
-      pid: { type: 'string', short: 'p' },
-      name: { type: 'string', short: 'n' },
-      service: { type: 'string', short: 's' },
-    },
-    strict: false,
-  }).values
-
-  const client = new RuntimeApiClient()
-  const runtime = await client.getMatchingRuntime(args)
-
-  const config = args.service
-    ? await client.getRuntimeServiceConfig(runtime.pid, args.service)
-    : await client.getRuntimeConfig(runtime.pid)
-
-  console.log(JSON.stringify(config, null, 2))
-
-  await client.close()
-}
-
-module.exports = getRuntimeConfigCommand

package/lib/env.js

@@ -1,29 +0,0 @@
-'use strict'
-
-const { parseArgs } = require('node:util')
-const RuntimeApiClient = require('./runtime-api-client')
-
-async function getRuntimeEnvCommand (argv) {
-  const args = parseArgs({
-    args: argv,
-    options: {
-      pid: { type: 'string', short: 'p' },
-      name: { type: 'string', short: 'n' },
-    },
-    strict: false,
-  }).values
-
-  const client = new RuntimeApiClient()
-  const runtime = await client.getMatchingRuntime(args)
-
-  const runtimeEnv = await client.getRuntimeEnv(runtime.pid)
-  let output = ''
-  for (const key in runtimeEnv) {
-    output += `${key}=${runtimeEnv[key]}\n`
-  }
-  console.log(output)
-
-  await client.close()
-}
-
-module.exports = getRuntimeEnvCommand

package/lib/inject.js

@@ -1,102 +0,0 @@
-'use strict'
-
-const { parseArgs } = require('node:util')
-const { writeFile } = require('node:fs/promises')
-const RuntimeApiClient = require('./runtime-api-client')
-const errors = require('./errors')
-
-async function injectRuntimeCommand (argv) {
-  const { values: args, positionals } = parseArgs({
-    args: argv,
-    options: {
-      pid: { type: 'string', short: 'p' },
-      name: { type: 'string', short: 'n' },
-      service: { type: 'string', short: 's' },
-      request: { type: 'string', short: 'X', default: 'GET' },
-      header: { type: 'string', short: 'H', multiple: true },
-      data: { type: 'string', short: 'd' },
-      include: { type: 'boolean', short: 'i', default: false },
-      verbose: { type: 'boolean', short: 'v', default: false },
-      output: { type: 'string', short: 'o' },
-    },
-    strict: false,
-  })
-
-  const client = new RuntimeApiClient()
-  const runtime = await client.getMatchingRuntime(args)
-
-  let serviceId = args.service
-  if (!serviceId) {
-    const runtimeServices = await client.getRuntimeServices(runtime.pid)
-    serviceId = runtimeServices.entrypoint
-  }
-
-  if (positionals.length === 0) {
-    throw errors.MissingRequestURL()
-  }
-
-  let result = ''
-
-  const fullUrl = new URL(positionals[0], runtime.url)
-  const injectPath = fullUrl.href.slice(runtime.url.length)
-
-  const method = args.request
-  const body = args.data
-
-  if (args.verbose) {
-    result += `> ${method} ${injectPath} HTTP/1.1\n`
-  }
-
-  const headers = {}
-  for (const header of args.header || []) {
-    const [name, value] = header.split(':')
-    headers[name] = value
-
-    if (args.verbose) {
-      result += `> ${name}: ${value}\n`
-    }
-  }
-
-  if (args.verbose && args.header.length > 0) {
-    result += '> \n'
-  }
-
-  const injectOptions = { url: injectPath, method, headers, body }
-
-  const response = await client.injectRuntime(runtime.pid, serviceId, injectOptions)
-
-  if (args.verbose) {
-    result += `< HTTP/1.1 ${response.statusCode}\n`
-  }
-  if (args.include) {
-    result += `HTTP/1.1 ${response.statusCode}\n`
-  }
-
-  for (const header in response.headers) {
-    if (args.verbose) {
-      result += `< ${header}: ${response.headers[header]}\n`
-    }
-    if (args.include) {
-      result += `${header}: ${response.headers[header]}\n`
-    }
-  }
-
-  if (args.verbose) {
-    result += '< \n'
-  }
-  if (args.include) {
-    result += '\n'
-  }
-
-  result += await response.body.text()
-
-  if (args.output) {
-    await writeFile(args.output, result)
-  } else {
-    console.log(result)
-  }
-
-  await client.close()
-}
-
-module.exports = injectRuntimeCommand