platformatic 0.24.0 → 0.26.0

package/cli.js

@@ -3,7 +3,9 @@
 import commist from 'commist'
 import minimist from 'minimist'
 import { runDB } from '@platformatic/db/db.mjs'
+import { run as runRuntime } from '@platformatic/runtime/runtime.mjs'
 import { runService } from '@platformatic/service/service.mjs'
+import { runComposer } from '@platformatic/composer/composer.mjs'
 import { startCommand } from '@platformatic/start'
 import { login } from '@platformatic/authenticate/authenticate.js'
 import { command as client } from '@platformatic/client-cli'
@@ -38,12 +40,15 @@ const ensureCommand = async ({ output, help }) => {
 }
 
 program.register('db', async (args) => ensureCommand(await runDB(args)))
+program.register('runtime', async (args) => ensureCommand(await runRuntime(args)))
 program.register('service', async (args) => ensureCommand(await runService(args)))
 program.register('start', startCommand)
+program.register('composer', async (args) => ensureCommand(await runComposer(args)))
 program.register('upgrade', upgrade)
 program.register('client', client)
 program.register('help', help.toStdout)
 program.register('help db', async (args) => runDB(['help', ...args]))
+program.register('help runtime', async (args) => runRuntime(['help', ...args]))
 program.register('help service', async (args) => runService(['help', ...args]))
 program.register({ command: 'login', strict: true }, login)
 program.register('gh', gh)

package/help/deploy.txt

@@ -8,6 +8,7 @@ Options:
 
   -t, --type      static/dynamic  The type of the workspace.
   -c, --config    FILE            Specify a configuration file to use
+  -k, --keys      FILE            Specify a path to the workspace keys file
   -l  --label     TEXT            The deploy label. Only for dynamic workspaces.
   -e  --env       FILE            The environment file to use. Default: ".env"
   -s  --secrets   FILE            The secrets file to use. Default: ".secrets.env"
@@ -16,7 +17,8 @@ Options:
 
 To deploy a Platformatic application to the cloud you should go to the 
 Platformatic cloud dashboard and create a workspace. Then you can get your
-workspace id and key from the workspace settings page.
+workspace id and key from the workspace settings page or download a workspace
+env file and use it with the --keys option.
 
 Tp deploy an application to a dynamic workspace, you will need to specify the
 deploy label. You can get it in you cloud dashboard or specify a new one.

package/help/help.txt

@@ -7,4 +7,5 @@ Welcome to Platformatic. Available commands are:
 * upgrade - upgrade the Platformatic configuration to the latest version.
 * gh - creates a new gh action for Platformatic deployments
 * deploy - deploy a Platformatic application to the cloud
+* runtime - start Platformatic Runtime; type `platformatic runtime help` to know more.
 * start - start a Platformatic application

package/lib/deploy.js

@@ -1,9 +1,11 @@
 'use strict'
 
-import { isAbsolute, dirname, relative } from 'path'
+import { isAbsolute, dirname, relative, join } from 'path'
+import { readFile } from 'fs/promises'
 
 import pino from 'pino'
 import pretty from 'pino-pretty'
+import dotenv from 'dotenv'
 import inquirer from 'inquirer'
 import parseArgs from 'minimist'
 import deployClient from '@platformatic/deploy-client'
@@ -18,11 +20,100 @@ const logger = pino(pretty({
   ignore: 'hostname,pid'
 }))
 
+async function askWorkspaceDetails (args) {
+  let workspaceType = args.type
+  /* c8 ignore next 9 */
+  if (!workspaceType) {
+    const answer = await inquirer.prompt({
+      type: 'list',
+      name: 'workspaceType',
+      message: 'Select workspace type:',
+      choices: WORKSPACE_TYPES
+    })
+    workspaceType = answer.workspaceType
+  }
+
+  if (!WORKSPACE_TYPES.includes(workspaceType)) {
+    throw new Error(
+      `Invalid workspace type provided: "${workspaceType}". ` +
+      `Type must be one of: ${WORKSPACE_TYPES.join(', ')}.`
+    )
+  }
+
+  let workspaceId = args['workspace-id']
+  /* c8 ignore next 8 */
+  if (!workspaceId) {
+    const answer = await inquirer.prompt({
+      type: 'input',
+      name: 'workspaceId',
+      message: 'Enter workspace id:'
+    })
+    workspaceId = answer.workspaceId
+  }
+
+  if (!UUID_REGEX.test(workspaceId)) {
+    throw new Error('Invalid workspace id provided. Workspace id must be a valid uuid.')
+  }
+
+  let workspaceKey = args['workspace-key']
+  /* c8 ignore next 9 */
+  if (!workspaceKey) {
+    const answer = await inquirer.prompt({
+      type: 'password',
+      name: 'workspaceKey',
+      message: 'Enter workspace key:',
+      mask: '*'
+    })
+    workspaceKey = answer.workspaceKey
+  }
+
+  return {
+    workspaceType,
+    workspaceId,
+    workspaceKey
+  }
+}
+
+async function readWorkspaceDetails (workspaceKeysPath) {
+  /* c8 ignore next 3 */
+  if (!isAbsolute(workspaceKeysPath)) {
+    workspaceKeysPath = join(process.cwd(), workspaceKeysPath)
+  }
+
+  const workspaceFile = await readFile(workspaceKeysPath, 'utf8')
+  const workspaceEnvVars = dotenv.parse(workspaceFile)
+
+  if (
+    workspaceEnvVars.PLATFORMATIC_DYNAMIC_WORKSPACE_ID &&
+    workspaceEnvVars.PLATFORMATIC_DYNAMIC_WORKSPACE_API_KEY
+  ) {
+    return {
+      workspaceType: 'dynamic',
+      workspaceId: workspaceEnvVars.PLATFORMATIC_DYNAMIC_WORKSPACE_ID,
+      workspaceKey: workspaceEnvVars.PLATFORMATIC_DYNAMIC_WORKSPACE_API_KEY
+    }
+  }
+
+  if (
+    workspaceEnvVars.PLATFORMATIC_STATIC_WORKSPACE_ID &&
+    workspaceEnvVars.PLATFORMATIC_STATIC_WORKSPACE_API_KEY
+  ) {
+    return {
+      workspaceType: 'static',
+      workspaceId: workspaceEnvVars.PLATFORMATIC_STATIC_WORKSPACE_ID,
+      workspaceKey: workspaceEnvVars.PLATFORMATIC_STATIC_WORKSPACE_API_KEY
+    }
+  }
+
+  throw new Error('Could not find workspace keys in provided file.')
+}
+
 export async function deploy (argv) {
   try {
     const args = parseArgs(argv, {
       alias: {
         config: 'c',
+        keys: 'k',
         type: 't',
         label: 'l',
         env: 'e',
@@ -42,51 +133,12 @@ export async function deploy (argv) {
       }
     })
 
-    let workspaceType = args.type
-    /* c8 ignore next 9 */
-    if (!workspaceType) {
-      const answer = await inquirer.prompt({
-        type: 'list',
-        name: 'workspaceType',
-        message: 'Select workspace type:',
-        choices: WORKSPACE_TYPES
-      })
-      workspaceType = answer.workspaceType
-    }
-
-    if (!WORKSPACE_TYPES.includes(workspaceType)) {
-      throw new Error(
-        `Invalid workspace type provided: "${workspaceType}". ` +
-        `Type must be one of: ${WORKSPACE_TYPES.join(', ')}.`
-      )
-    }
-
-    let workspaceId = args['workspace-id']
-    /* c8 ignore next 8 */
-    if (!workspaceId) {
-      const answer = await inquirer.prompt({
-        type: 'input',
-        name: 'workspaceId',
-        message: 'Enter workspace id:'
-      })
-      workspaceId = answer.workspaceId
-    }
+    const workspaceKeysPath = args.keys
+    const workspaceDetails = workspaceKeysPath
+      ? await readWorkspaceDetails(workspaceKeysPath)
+      : await askWorkspaceDetails(args)
 
-    if (!UUID_REGEX.test(workspaceId)) {
-      throw new Error('Invalid workspace id provided. Workspace id must be a valid uuid.')
-    }
-
-    let workspaceKey = args['workspace-key']
-    /* c8 ignore next 9 */
-    if (!workspaceKey) {
-      const answer = await inquirer.prompt({
-        type: 'password',
-        name: 'workspaceKey',
-        message: 'Enter workspace key:',
-        mask: '*'
-      })
-      workspaceKey = answer.workspaceKey
-    }
+    const { workspaceType, workspaceId, workspaceKey } = workspaceDetails
 
     let label = args.label
     if (workspaceType === 'dynamic') {

package/lib/gh.js

@@ -9,12 +9,12 @@ import pino from 'pino'
 import pretty from 'pino-pretty'
 import ConfigManager from '@platformatic/config'
 
-export const createGHAction = async (logger, workspaceId, env, config, buildTS, type, projectDir = process.cwd()) => {
+export const createGHAction = async (logger, env, config, buildTS, type, projectDir = process.cwd()) => {
   if (type === 'static') {
-    await createStaticWorkspaceGHAction(logger, workspaceId, env, config, projectDir, buildTS)
+    await createStaticWorkspaceGHAction(logger, env, config, projectDir, buildTS)
     return
   }
-  await createDynamicWorkspaceGHAction(logger, workspaceId, env, config, projectDir, buildTS)
+  await createDynamicWorkspaceGHAction(logger, env, config, projectDir, buildTS)
 }
 
 const logger = pino(pretty({
@@ -43,18 +43,11 @@ export const gh = async (argv) => {
       config: 'c',
       type: 't',
       help: 'h',
-      build: 'b',
-      workspace: 'w'
+      build: 'b'
     },
     boolean: ['build']
   })
 
-  // Validations:
-  if (!args.workspace) {
-    logger.error('Workspace ID is required')
-    process.exit(1)
-  }
-
   if (!['static', 'dynamic'].includes(args.type)) {
     logger.error(`Invalid type: [${args.type}]. Type must be either static or dynamic`)
     process.exit(1)
@@ -80,8 +73,9 @@ export const gh = async (argv) => {
     plt_custom_variable: 'change-me',
     custom_variable1: 'change-me'
   }
-  await createGHAction(logger, args.workspace, env, configFilename, args.build, args.type)
+  await createGHAction(logger, env, configFilename, args.build, args.type)
 
+  const workspaceName = args.type === 'static' ? 'PLATFORMATIC_STATIC_WORKSPACE_ID ' : 'PLATFORMATIC_DYNAMIC_WORKSPACE_ID'
   const secretName = args.type === 'static' ? 'PLATFORMATIC_STATIC_WORKSPACE_API_KEY' : 'PLATFORMATIC_DYNAMIC_WORKSPACE_API_KEY'
-  logger.info(`Github action successfully created for workspace ${args.workspace}, please add ${secretName} as repository secret.`)
+  logger.info(`Github action successfully created please add ${workspaceName} and ${secretName} as repository secrets.`)
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "platformatic",
-  "version": "0.24.0",
+  "version": "0.26.0",
   "description": "Platformatic CLI",
   "main": "cli.js",
   "type": "module",
@@ -36,30 +36,33 @@
     "split2": "^4.2.0",
     "standard": "^17.0.0",
     "tap": "^16.3.4",
-    "undici": "^5.22.0"
+    "undici": "^5.22.1"
   },
   "dependencies": {
     "colorette": "^2.0.20",
     "commist": "^3.2.0",
     "desm": "^1.3.0",
+    "dotenv": "^16.1.1",
     "help-me": "^4.2.0",
-    "inquirer": "^9.2.0",
+    "inquirer": "^9.2.6",
     "minimist": "^1.2.8",
-    "pino": "^8.12.0",
+    "pino": "^8.14.1",
     "pino-pretty": "^10.0.0",
-    "@platformatic/authenticate": "0.24.0",
-    "@platformatic/client-cli": "0.24.0",
-    "@platformatic/config": "0.24.0",
-    "@platformatic/db": "0.24.0",
-    "@platformatic/deploy-client": "0.24.0",
-    "@platformatic/metaconfig": "0.24.0",
-    "@platformatic/service": "0.24.0",
-    "@platformatic/start": "0.24.0",
-    "create-platformatic": "0.24.0"
+    "@platformatic/authenticate": "0.26.0",
+    "@platformatic/client-cli": "0.26.0",
+    "@platformatic/config": "0.26.0",
+    "@platformatic/composer": "0.26.0",
+    "@platformatic/db": "0.26.0",
+    "@platformatic/deploy-client": "0.26.0",
+    "@platformatic/metaconfig": "0.26.0",
+    "@platformatic/runtime": "0.26.0",
+    "@platformatic/service": "0.26.0",
+    "@platformatic/start": "0.26.0",
+    "create-platformatic": "0.26.0"
   },
   "scripts": {
     "test": "standard | snazzy && c8 --100 tap --no-coverage test/*.test.js",
     "lint": "standard | snazzy",
-    "license": "license-checker --production --onlyAllow 'Apache-2.0;MIT;ISC;BSD-2-Clause'"
+    "license": "license-checker --production --onlyAllow 'Apache-2.0;MIT;ISC;BSD-2-Clause;BSD-3-Clause'"
   }
 }

package/test/deploy.test.js

@@ -29,6 +29,9 @@ test('should deploy to a static workspace to the cloud', async (t) => {
       t.same(
         request.body,
         {
+          metadata: {
+            appType: 'db'
+          },
           variables: {
             PLT_ENV_VARIABLE1: 'platformatic_variable1',
             PLT_ENV_VARIABLE2: 'platformatic_variable2'
@@ -80,6 +83,9 @@ test('should deploy to a dynamic workspace to the cloud', async (t) => {
         request.body,
         {
           label,
+          metadata: {
+            appType: 'db'
+          },
           variables: {
             PLT_ENV_VARIABLE1: 'platformatic_variable1',
             PLT_ENV_VARIABLE2: 'platformatic_variable2'
@@ -174,6 +180,9 @@ test('should deploy to a dynamic workspace to the cloud', async (t) => {
         request.body,
         {
           label,
+          metadata: {
+            appType: 'db'
+          },
           variables: {
             PLT_ENV_VARIABLE1: 'platformatic_variable1',
             PLT_ENV_VARIABLE2: 'platformatic_variable2'
@@ -198,3 +207,177 @@ test('should deploy to a dynamic workspace to the cloud', async (t) => {
     '--deploy-service-host', deployServiceHost
   ])
 })
+
+test('should deploy to a static workspace with a keys option', async (t) => {
+  const workspaceId = 'b3d7f7e0-8c03-11e8-9eb6-529269fb1459'
+  const workspaceKey = 'b3d7f7e08c0311e89eb6529269fb1459'
+
+  const pathToConfig = join(import.meta.url, './fixtures/app-to-deploy/platformatic.db.json')
+  const pathToKeys = join(import.meta.url, './fixtures/app-to-deploy/static.txt')
+
+  const machineHost = await startMachine(t)
+  const deployServiceHost = await startDeployService(t, {
+    createBundleCallback: (request, reply) => {
+      t.equal(request.headers['x-platformatic-workspace-id'], workspaceId)
+      t.equal(request.headers['x-platformatic-api-key'], workspaceKey)
+      t.match(request.body, {
+        bundle: {
+          appType: 'db',
+          configPath: 'platformatic.db.json'
+        }
+      })
+      t.ok(request.body.bundle.checksum)
+    },
+    createDeploymentCallback: (request, reply) => {
+      t.equal(request.headers['x-platformatic-workspace-id'], workspaceId)
+      t.equal(request.headers['x-platformatic-api-key'], workspaceKey)
+      t.same(
+        request.body,
+        {
+          metadata: {
+            appType: 'db'
+          },
+          variables: {
+            PLT_ENV_VARIABLE1: 'platformatic_variable1',
+            PLT_ENV_VARIABLE2: 'platformatic_variable2'
+          },
+          secrets: {
+            PLT_SECRET_1: 'platformatic_secret_1',
+            PLT_SECRET_2: 'platformatic_secret_2'
+          }
+        }
+      )
+      reply.code(200).send({ entryPointUrl: machineHost })
+    }
+  })
+
+  await execa('node', [
+    cliPath, 'deploy',
+    '--keys', pathToKeys,
+    '--config', pathToConfig,
+    '--deploy-service-host', deployServiceHost
+  ])
+})
+
+test('should deploy to a static workspace with a keys option', async (t) => {
+  const workspaceId = 'b3d7f7e0-8c03-11e8-9eb6-529269fb1459'
+  const workspaceKey = 'b3d7f7e08c0311e89eb6529269fb1459'
+
+  const pathToConfig = join(import.meta.url, './fixtures/app-to-deploy/platformatic.db.json')
+  const pathToKeys = './static.txt'
+
+  const machineHost = await startMachine(t)
+  const deployServiceHost = await startDeployService(t, {
+    createBundleCallback: (request, reply) => {
+      t.equal(request.headers['x-platformatic-workspace-id'], workspaceId)
+      t.equal(request.headers['x-platformatic-api-key'], workspaceKey)
+      t.match(request.body, {
+        bundle: {
+          appType: 'db',
+          configPath: 'platformatic.db.json'
+        }
+      })
+      t.ok(request.body.bundle.checksum)
+    },
+    createDeploymentCallback: (request, reply) => {
+      t.equal(request.headers['x-platformatic-workspace-id'], workspaceId)
+      t.equal(request.headers['x-platformatic-api-key'], workspaceKey)
+      t.same(
+        request.body,
+        {
+          metadata: {
+            appType: 'db'
+          },
+          variables: {
+            PLT_ENV_VARIABLE1: 'platformatic_variable1',
+            PLT_ENV_VARIABLE2: 'platformatic_variable2'
+          },
+          secrets: {
+            PLT_SECRET_1: 'platformatic_secret_1',
+            PLT_SECRET_2: 'platformatic_secret_2'
+          }
+        }
+      )
+      reply.code(200).send({ entryPointUrl: machineHost })
+    }
+  })
+
+  await execa('node', [
+    cliPath, 'deploy',
+    '--keys', pathToKeys,
+    '--config', pathToConfig,
+    '--deploy-service-host', deployServiceHost
+  ], {
+    cwd: join(import.meta.url, './fixtures/app-to-deploy')
+  })
+})
+
+test('should deploy to a dynamic workspace with a keys option', async (t) => {
+  const workspaceId = 'b3d7f7e0-8c03-11e8-9eb6-529269fb1459'
+  const workspaceKey = 'b3d7f7e08c0311e89eb6529269fb1459'
+  const label = 'cli:deploy-2'
+
+  const pathToConfig = join(import.meta.url, './fixtures/app-to-deploy/platformatic.db.json')
+  const pathToKeys = join(import.meta.url, './fixtures/app-to-deploy/dynamic.txt')
+
+  const machineHost = await startMachine(t)
+  const deployServiceHost = await startDeployService(t, {
+    createBundleCallback: (request, reply) => {
+      t.equal(request.headers['x-platformatic-workspace-id'], workspaceId)
+      t.equal(request.headers['x-platformatic-api-key'], workspaceKey)
+      t.match(request.body, {
+        bundle: {
+          appType: 'db',
+          configPath: 'platformatic.db.json'
+        }
+      })
+      t.ok(request.body.bundle.checksum)
+    },
+    createDeploymentCallback: (request, reply) => {
+      t.equal(request.headers['x-platformatic-workspace-id'], workspaceId)
+      t.equal(request.headers['x-platformatic-api-key'], workspaceKey)
+      t.same(
+        request.body,
+        {
+          label,
+          metadata: {
+            appType: 'db'
+          },
+          variables: {
+            PLT_ENV_VARIABLE1: 'platformatic_variable1',
+            PLT_ENV_VARIABLE2: 'platformatic_variable2'
+          },
+          secrets: {
+            PLT_SECRET_1: 'platformatic_secret_1',
+            PLT_SECRET_2: 'platformatic_secret_2'
+          }
+        }
+      )
+      reply.code(200).send({ entryPointUrl: machineHost })
+    }
+  })
+
+  await execa('node', [
+    cliPath, 'deploy',
+    '--keys', pathToKeys,
+    '--config', pathToConfig,
+    '--label', label,
+    '--deploy-service-host', deployServiceHost
+  ])
+})
+
+test('should throw if workspace env file is wrong', async (t) => {
+  const pathToConfig = join(import.meta.url, './fixtures/app-to-deploy/platformatic.db.json')
+  const pathToKeys = join(import.meta.url, './fixtures/app-to-deploy/wrong.txt')
+
+  try {
+    await execa('node', [
+      cliPath, 'deploy',
+      '--keys', pathToKeys,
+      '--config', pathToConfig
+    ])
+    t.fail('should have failed')
+  } catch (err) {
+    t.ok(err.message.includes('Could not find workspace keys in provided file.'))
+  }
+})

package/test/fixtures/app-to-deploy/dynamic.txt

@@ -0,0 +1,2 @@
+PLATFORMATIC_DYNAMIC_WORKSPACE_ID=b3d7f7e0-8c03-11e8-9eb6-529269fb1459
+PLATFORMATIC_DYNAMIC_WORKSPACE_API_KEY=b3d7f7e08c0311e89eb6529269fb1459

package/test/fixtures/app-to-deploy/static.txt

@@ -0,0 +1,2 @@
+PLATFORMATIC_STATIC_WORKSPACE_ID=b3d7f7e0-8c03-11e8-9eb6-529269fb1459
+PLATFORMATIC_STATIC_WORKSPACE_API_KEY=b3d7f7e08c0311e89eb6529269fb1459

package/test/fixtures/app-to-deploy/wrong.txt

@@ -0,0 +1,2 @@
+WRONG_DYNAMIC_WORKSPACE_ID=b3d7f7e0-8c03-11e8-9eb6-529269fb1459
+WRONG_DYNAMIC_WORKSPACE_API_KEY=b3d7f7e08c0311e89eb6529269fb1459

package/test/fixtures/platformatic.runtime.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "https://platformatic.dev/schemas/v0.23.0/runtime",
+  "entrypoint": "serviceApp",
+  "services": [
+    {
+      "id": "serviceApp",
+      "path": "../",
+      "config": "platformatic.service.json"
+    }
+  ]
+}

package/test/gh.test.js

@@ -8,23 +8,23 @@ import { dirname, join } from 'path'
 import mkdirp from 'mkdirp'
 
 let count = 0
-const workspaceId = 'WORKSPACE-ID-TEST'
 
 test('creates a deploy config for static workspace', async (t) => {
   const dest = join(tmpdir(), `test-cli-gh-${process.pid}-${count++}`)
 
+  t.comment(`working in ${dest}`)
   await mkdirp(dest)
   await cp(
     join(dirname(fileURLToPath(import.meta.url)), 'fixtures', 'v0.16.0.db.json'),
     join(dest, 'platformatic.db.json'))
 
-  await execa('node', [cliPath, 'gh', '-w', workspaceId], {
+  await execa('node', [cliPath, 'gh'], {
     cwd: dest
   })
 
   const deployWorkflow = await readFile(join(dest, '.github', 'workflows', 'platformatic-static-workspace-deploy.yml'), 'utf8')
+  t.ok(deployWorkflow.indexOf('PLATFORMATIC_STATIC_WORKSPACE_ID') !== -1)
   t.ok(deployWorkflow.indexOf('PLATFORMATIC_STATIC_WORKSPACE_API_KEY') !== -1)
-  t.ok(deployWorkflow.indexOf('WORKSPACE-ID-TEST') !== -1)
 })
 
 test('creates a deploy config for dynamic workspace', async (t) => {
@@ -35,31 +35,13 @@ test('creates a deploy config for dynamic workspace', async (t) => {
     join(dirname(fileURLToPath(import.meta.url)), 'fixtures', 'v0.16.0.db.json'),
     join(dest, 'platformatic.db.json'))
 
-  await execa('node', [cliPath, 'gh', '-w', workspaceId, '-t', 'dynamic'], {
+  await execa('node', [cliPath, 'gh', '-t', 'dynamic'], {
     cwd: dest
   })
 
   const deployWorkflow = await readFile(join(dest, '.github', 'workflows', 'platformatic-dynamic-workspace-deploy.yml'), 'utf8')
+  t.ok(deployWorkflow.indexOf('PLATFORMATIC_DYNAMIC_WORKSPACE_ID') !== -1)
   t.ok(deployWorkflow.indexOf('PLATFORMATIC_DYNAMIC_WORKSPACE_API_KEY') !== -1)
-  t.ok(deployWorkflow.indexOf('WORKSPACE-ID-TEST') !== -1)
-})
-
-test('creation fails if workspace is missing', async (t) => {
-  const dest = join(tmpdir(), `test-cli-gh-${process.pid}-${count++}`)
-
-  await mkdirp(dest)
-  await cp(
-    join(dirname(fileURLToPath(import.meta.url)), 'fixtures', 'v0.16.0.db.json'),
-    join(dest, 'platformatic.db.json'))
-
-  try {
-    await execa('node', [cliPath, 'gh'], {
-      cwd: dest
-    })
-    t.fail('should have failed')
-  } catch ({ stdout }) {
-    t.ok(stdout.indexOf('Workspace ID is required') !== -1)
-  }
 })
 
 test('creation fails if workspace type is not static or dynamic', async (t) => {
@@ -71,7 +53,7 @@ test('creation fails if workspace type is not static or dynamic', async (t) => {
     join(dest, 'platformatic.db.json'))
 
   try {
-    await execa('node', [cliPath, 'gh', '-w', workspaceId, '-t', 'XXXXX'], {
+    await execa('node', [cliPath, 'gh', '-t', 'XXXXX'], {
       cwd: dest
     })
     t.fail('should have failed')
@@ -84,7 +66,7 @@ test('creation fails if no config file is found', async (t) => {
   const dest = join(tmpdir(), `test-cli-gh-${process.pid}-${count++}`)
   await mkdirp(dest)
   try {
-    await execa('node', [cliPath, 'gh', '-w', workspaceId], {
+    await execa('node', [cliPath, 'gh'], {
       cwd: dest
     })
     t.fail('should have failed')
@@ -103,7 +85,7 @@ test('creates a deploy must warn that a .env exists', async (t) => {
 
   await writeFile(join(dest, '.env'), 'TEST=1')
 
-  const { stdout } = await execa('node', [cliPath, 'gh', '-w', workspaceId], {
+  const { stdout } = await execa('node', [cliPath, 'gh'], {
     cwd: dest
   })
   t.ok(stdout.indexOf('Found .env file') !== -1)

package/test/platformatic.test.js

@@ -22,6 +22,9 @@ const help = await readFile(join(import.meta.url, '..', 'help', 'help.txt'), 'ut
 // This reads a file from packages/db
 const helpDB = await readFile(join(import.meta.url, '..', '..', 'db', 'help', 'help.txt'), 'utf8')
 
+// This reads a file from packages/runtime
+const helpRuntime = await readFile(join(import.meta.url, '..', '..', 'runtime', 'help', 'help.txt'), 'utf8')
+
 // This reads a file from packages/service
 const helpService = await readFile(join(import.meta.url, '..', '..', 'service', 'help', 'help.txt'), 'utf8')
 
@@ -39,6 +42,15 @@ test('db', async (t) => {
   }
 })
 
+test('runtime', async (t) => {
+  try {
+    await execa('node', [cliPath, 'runtime', 'start'])
+    t.fail('bug')
+  } catch (err) {
+    t.ok(err.stderr.includes('Missing config file'))
+  }
+})
+
 test('login', async (t) => {
   try {
     await execa('node', [cliPath, 'login'])
@@ -105,6 +117,11 @@ test('prints the help if not commands are specified', async (t) => {
   t.equal(stdout + EOL, help)
 })
 
+test('prints the help of runtime', async (t) => {
+  const { stdout } = await execa('node', [cliPath, 'help', 'runtime'])
+  t.equal(stdout + EOL, helpRuntime)
+})
+
 test('prints the help of service', async (t) => {
   const { stdout } = await execa('node', [cliPath, 'help', 'service'])
   t.equal(stdout + EOL, helpService)

package/test/start.test.js

@@ -1,3 +1,4 @@
+import assert from 'node:assert'
 import { spawn } from 'node:child_process'
 import { cp } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
@@ -38,3 +39,44 @@ test('starts a server', async ({ teardown }) => {
     }
   }
 })
+
+test('starts a runtime application', async ({ teardown }) => {
+  const srcDir = join(dirname(fileURLToPath(import.meta.url)), 'fixtures')
+  const destDir = join(tmpdir(), `test-cli-${process.pid}-${count++}`)
+  let found = false
+
+  await cp(
+    join(srcDir, 'platformatic.runtime.json'),
+    join(destDir, 'platformatic.runtime.json')
+  )
+  await cp(
+    join(srcDir, 'platformatic.service.json'),
+    join(destDir, 'platformatic.service.json')
+  )
+
+  const child = spawn(process.execPath, [cliPath, 'start'], {
+    cwd: destDir,
+    timeout: 10_000
+  })
+
+  teardown(async () => {
+    try {
+      child.kill('SIGKILL')
+    } catch {} // Ignore error.
+  })
+
+  let stdout = ''
+
+  child.stdout.setEncoding('utf8')
+
+  for await (const chunk of child.stdout) {
+    stdout += chunk
+
+    if (/server listening at/i.test(stdout)) {
+      found = true
+      break
+    }
+  }
+
+  assert(found)
+})