@botpress/cli 2.0.4 → 2.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botpress/cli",
-  "version": "2.0.4",
+  "version": "2.1.1",
   "description": "Botpress CLI",
   "scripts": {
     "build": "pnpm run bundle && pnpm run template:gen",
@@ -21,8 +21,9 @@
   "main": "dist/index.js",
   "dependencies": {
     "@apidevtools/json-schema-ref-parser": "^11.7.0",
-    "@botpress/client": "0.37.1",
-    "@botpress/sdk": "2.0.3",
+    "@botpress/chat": "0.4.4",
+    "@botpress/client": "0.38.0",
+    "@botpress/sdk": "2.0.4",
     "@bpinternal/const": "^0.0.20",
     "@bpinternal/tunnel": "^0.1.1",
     "@bpinternal/yargs-extra": "^0.0.3",

package/templates/empty-bot/package.json

@@ -5,8 +5,8 @@
   },
   "private": true,
   "dependencies": {
-    "@botpress/client": "0.37.1",
-    "@botpress/sdk": "2.0.3"
+    "@botpress/client": "0.38.0",
+    "@botpress/sdk": "2.0.4"
   },
   "devDependencies": {
     "@types/node": "^18.19.67",

package/templates/empty-integration/package.json

@@ -6,8 +6,8 @@
   },
   "private": true,
   "dependencies": {
-    "@botpress/client": "0.37.1",
-    "@botpress/sdk": "2.0.3"
+    "@botpress/client": "0.38.0",
+    "@botpress/sdk": "2.0.4"
   },
   "devDependencies": {
     "@types/node": "^18.19.67",

package/templates/empty-plugin/package.json

@@ -6,7 +6,7 @@
   },
   "private": true,
   "dependencies": {
-    "@botpress/sdk": "2.0.3"
+    "@botpress/sdk": "2.0.4"
   },
   "devDependencies": {
     "@types/node": "^18.19.67",

package/templates/hello-world/package.json

@@ -6,8 +6,8 @@
   },
   "private": true,
   "dependencies": {
-    "@botpress/client": "0.37.1",
-    "@botpress/sdk": "2.0.3"
+    "@botpress/client": "0.38.0",
+    "@botpress/sdk": "2.0.4"
   },
   "devDependencies": {
     "@types/node": "^18.19.67",

package/templates/webhook-message/package.json

@@ -6,8 +6,8 @@
   },
   "private": true,
   "dependencies": {
-    "@botpress/client": "0.37.1",
-    "@botpress/sdk": "2.0.3",
+    "@botpress/client": "0.38.0",
+    "@botpress/sdk": "2.0.4",
     "axios": "^1.6.8"
   },
   "devDependencies": {

package/e2e/api.ts

@@ -1,25 +0,0 @@
-import { Client } from '@botpress/client'
-
-export type ApiBot = Awaited<ReturnType<Client['listBots']>>['bots'][0]
-export const fetchAllBots = async (client: Client): Promise<ApiBot[]> => {
-  let allBots: ApiBot[] = []
-  let nextToken: string | undefined
-  do {
-    const { bots, meta } = await client.listBots({ nextToken })
-    allBots = [...allBots, ...bots]
-    nextToken = meta.nextToken
-  } while (nextToken)
-  return allBots
-}
-
-export type ApiIntegration = Awaited<ReturnType<Client['listIntegrations']>>['integrations'][0]
-export const fetchAllIntegrations = async (client: Client): Promise<ApiIntegration[]> => {
-  let allIntegrations: ApiIntegration[] = []
-  let nextToken: string | undefined
-  do {
-    const { integrations, meta } = await client.listIntegrations({ nextToken })
-    allIntegrations = [...allIntegrations, ...integrations]
-    nextToken = meta.nextToken
-  } while (nextToken)
-  return allIntegrations
-}

package/e2e/defaults.ts

@@ -1,20 +0,0 @@
-const noBuild = false
-const secrets = [] satisfies string[]
-const sourceMap = false
-const verbose = false
-const confirm = true
-const json = false
-const allowDeprecated = false
-const isPublic = false
-const minify = true
-export default {
-  minify,
-  noBuild,
-  secrets,
-  sourceMap,
-  verbose,
-  confirm,
-  json,
-  allowDeprecated,
-  public: isPublic,
-}

package/e2e/index.ts

@@ -1,118 +0,0 @@
-import { Logger } from '@bpinternal/log4bot'
-import yargs, { YargsConfig, YargsSchema } from '@bpinternal/yargs-extra'
-import * as consts from '../src/consts'
-import { createDeployBot } from './tests/create-deploy-bot'
-import { createDeployIntegration } from './tests/create-deploy-integration'
-import { devBot } from './tests/dev-bot'
-import { installAllInterfaces } from './tests/install-interfaces'
-import { addIntegration } from './tests/install-package'
-import { requiredSecrets } from './tests/integration-secrets'
-import { prependWorkspaceHandle, enforceWorkspaceHandle } from './tests/manage-workspace-handle'
-import { Test } from './typings'
-import { sleep, TmpDirectory } from './utils'
-
-const tests: Test[] = [
-  createDeployBot,
-  createDeployIntegration,
-  devBot,
-  requiredSecrets,
-  prependWorkspaceHandle,
-  enforceWorkspaceHandle,
-  addIntegration,
-  installAllInterfaces,
-]
-
-const timeout = (ms: number) =>
-  sleep(ms).then(() => {
-    throw new Error(`Timeout after ${ms}ms`)
-  })
-
-const TIMEOUT = 45_000
-
-const configSchema = {
-  timeout: {
-    type: 'number',
-    default: TIMEOUT,
-  },
-  verbose: {
-    type: 'boolean',
-    default: false,
-    alias: 'v',
-  },
-  filter: {
-    type: 'string',
-  },
-  workspaceId: {
-    type: 'string',
-    demandOption: true,
-  },
-  workspaceHandle: {
-    type: 'string',
-    demandOption: true,
-  },
-  token: {
-    type: 'string',
-    demandOption: true,
-  },
-  apiUrl: {
-    type: 'string',
-    default: consts.defaultBotpressApiUrl,
-  },
-  tunnelUrl: {
-    type: 'string',
-    default: consts.defaultTunnelUrl,
-  },
-  sdkPath: {
-    type: 'string',
-    description: 'Path to the Botpress SDK to install; Allows using a version not released on NPM yet.',
-  },
-  clientPath: {
-    type: 'string',
-    description: 'Path to the Botpress Client to install; Allows using a version not released on NPM yet.',
-  },
-} satisfies YargsSchema
-
-const main = async (argv: YargsConfig<typeof configSchema>): Promise<never> => {
-  const logger = new Logger('e2e', { level: argv.verbose ? 'debug' : 'info' })
-
-  const filterRegex = argv.filter ? new RegExp(argv.filter) : null
-  const filteredTests = tests.filter(({ name }) => (filterRegex ? filterRegex.test(name) : true))
-  logger.info(`Running ${filteredTests.length} / ${tests.length} tests`)
-
-  const dependencies = { '@botpress/sdk': argv.sdkPath, '@botpress/client': argv.clientPath } satisfies Record<
-    string,
-    string | undefined
-  >
-
-  for (const { name, handler } of filteredTests) {
-    const logLine = `### Running test: "${name}" ###`
-    const logPad = '#'.repeat(logLine.length)
-    logger.info(logPad)
-    logger.info(logLine)
-    logger.info(logPad + '\n')
-
-    const loggerNamespace = name.replace(/ /g, '_').replace(/[^a-zA-Z0-9_]/g, '')
-
-    const tmpDir = TmpDirectory.create()
-    try {
-      const t0 = Date.now()
-      await Promise.race([
-        handler({ tmpDir: tmpDir.path, dependencies, logger: logger.sub(loggerNamespace), ...argv }),
-        timeout(argv.timeout),
-      ])
-      const t1 = Date.now()
-      logger.info(`SUCCESS: "${name}" (${t1 - t0}ms)`)
-    } catch (thrown) {
-      const err = thrown instanceof Error ? thrown : new Error(`${thrown}`)
-      logger.attachError(err).error(`FAILURE: "${name}"`)
-      process.exit(1)
-    } finally {
-      tmpDir.cleanup()
-    }
-  }
-
-  logger.info('All tests passed')
-  process.exit(0)
-}
-
-void yargs.command('$0', 'Run E2E Tests', configSchema, main).parse()

package/e2e/tests/create-deploy-bot.ts

@@ -1,51 +0,0 @@
-import { Client } from '@botpress/client'
-import pathlib from 'path'
-import * as uuid from 'uuid'
-import impl from '../../src/command-implementations'
-import { ApiBot, fetchAllBots } from '../api'
-import defaults from '../defaults'
-import { Test } from '../typings'
-import * as utils from '../utils'
-
-const fetchBot = async (client: Client, botName: string): Promise<ApiBot | undefined> => {
-  const bots = await fetchAllBots(client)
-  return bots.find(({ name }) => name === botName)
-}
-
-export const createDeployBot: Test = {
-  name: 'cli should allow creating, building, deploying and mannaging a bot',
-  handler: async ({ tmpDir, dependencies, ...creds }) => {
-    const botpressHomeDir = pathlib.join(tmpDir, '.botpresshome')
-    const baseDir = pathlib.join(tmpDir, 'bots')
-    const botName = uuid.v4()
-    const botDir = pathlib.join(baseDir, botName)
-
-    const argv = {
-      ...defaults,
-      botpressHome: botpressHomeDir,
-      confirm: true,
-      ...creds,
-    }
-
-    const client = new Client({ apiUrl: creds.apiUrl, token: creds.token, workspaceId: creds.workspaceId })
-
-    await impl.init({ ...argv, workDir: baseDir, name: botName, type: 'bot' }).then(utils.handleExitCode)
-    await utils.fixBotpressDependencies({ workDir: botDir, target: dependencies })
-    await utils.npmInstall({ workDir: botDir }).then(utils.handleExitCode)
-    await impl.build({ ...argv, workDir: botDir }).then(utils.handleExitCode)
-    await impl.login({ ...argv }).then(utils.handleExitCode)
-    await impl.bots.subcommands.create({ ...argv, name: botName, ifNotExists: false }).then(utils.handleExitCode)
-
-    const bot = await fetchBot(client, botName)
-    if (!bot) {
-      throw new Error(`Bot ${botName} should have been created`)
-    }
-
-    await impl.deploy({ ...argv, workDir: botDir, createNewBot: false, botId: bot.id }).then(utils.handleExitCode)
-    await impl.bots.subcommands.delete({ ...argv, botRef: bot.id }).then(utils.handleExitCode)
-
-    if (await fetchBot(client, botName)) {
-      throw new Error(`Bot ${botName} should have been deleted`)
-    }
-  },
-}

package/e2e/tests/create-deploy-integration.ts

@@ -1,62 +0,0 @@
-import { Client } from '@botpress/client'
-
-import pathlib from 'path'
-import * as uuid from 'uuid'
-import impl from '../../src/command-implementations'
-import { ApiIntegration, fetchAllIntegrations } from '../api'
-import defaults from '../defaults'
-import { Test } from '../typings'
-import * as utils from '../utils'
-
-const fetchIntegration = async (client: Client, integrationName: string): Promise<ApiIntegration | undefined> => {
-  const integrations = await fetchAllIntegrations(client)
-  return integrations.find(({ name }) => name === integrationName)
-}
-
-export const createDeployIntegration: Test = {
-  name: 'cli should allow creating, building, deploying and mannaging an integration',
-  handler: async ({ tmpDir, dependencies, workspaceHandle, logger, ...creds }) => {
-    const botpressHomeDir = pathlib.join(tmpDir, '.botpresshome')
-    const baseDir = pathlib.join(tmpDir, 'integrations')
-
-    const integrationSuffix = uuid.v4().replace(/-/g, '')
-    const name = `myintegration${integrationSuffix}`
-    const integrationName = `${workspaceHandle}/${name}`
-    const integrationDirName = `${workspaceHandle}-${name}`
-    const integrationDir = pathlib.join(baseDir, integrationDirName)
-
-    const argv = {
-      ...defaults,
-      botpressHome: botpressHomeDir,
-      confirm: true,
-      ...creds,
-    }
-
-    const client = new Client({ apiUrl: creds.apiUrl, token: creds.token, workspaceId: creds.workspaceId })
-
-    await impl
-      .init({ ...argv, workDir: baseDir, name: integrationName, type: 'integration' })
-      .then(utils.handleExitCode)
-    await utils.fixBotpressDependencies({ workDir: integrationDir, target: dependencies })
-    await utils.npmInstall({ workDir: integrationDir }).then(utils.handleExitCode)
-    await impl.build({ ...argv, workDir: integrationDir }).then(utils.handleExitCode)
-    await impl.login({ ...argv }).then(utils.handleExitCode)
-
-    await impl
-      .deploy({ ...argv, createNewBot: undefined, botId: undefined, workDir: integrationDir })
-      .then(utils.handleExitCode)
-
-    logger.debug(`Fetching integration "${integrationName}"`)
-    const integration = await fetchIntegration(client, integrationName)
-    if (!integration) {
-      throw new Error(`Integration ${integrationName} should have been created`)
-    }
-
-    logger.debug(`Deleting integration "${integrationName}"`)
-    await impl.integrations.subcommands.delete({ ...argv, integrationRef: integration.id }).then(utils.handleExitCode)
-
-    if (await fetchIntegration(client, integrationName)) {
-      throw new Error(`Integration ${integrationName} should have been deleted`)
-    }
-  },
-}

package/e2e/tests/dev-bot.ts

@@ -1,59 +0,0 @@
-import findProcess from 'find-process'
-import pathlib from 'path'
-import * as uuid from 'uuid'
-import impl from '../../src/command-implementations'
-import defaults from '../defaults'
-import { Test } from '../typings'
-import * as utils from '../utils'
-
-const handleExitCode = ({ exitCode }: { exitCode: number }) => {
-  if (exitCode !== 0) {
-    throw new Error(`Command exited with code ${exitCode}`)
-  }
-}
-
-const PORT = 8075
-
-export const devBot: Test = {
-  name: 'cli should allow creating and running a bot locally',
-  handler: async ({ tmpDir, tunnelUrl, dependencies, ...creds }) => {
-    const botpressHomeDir = pathlib.join(tmpDir, '.botpresshome')
-    const baseDir = pathlib.join(tmpDir, 'bots')
-    const botName = uuid.v4()
-    const botDir = pathlib.join(baseDir, botName)
-
-    const argv = {
-      ...defaults,
-      botpressHome: botpressHomeDir,
-      confirm: true,
-      ...creds,
-    }
-
-    await impl.init({ ...argv, workDir: baseDir, name: botName, type: 'bot' }).then(handleExitCode)
-    await utils.fixBotpressDependencies({ workDir: botDir, target: dependencies })
-    await utils.npmInstall({ workDir: botDir }).then(handleExitCode)
-    await impl.login({ ...argv }).then(handleExitCode)
-
-    const cmdPromise = impl.dev({ ...argv, workDir: botDir, port: PORT, tunnelUrl }).then(handleExitCode)
-    await utils.sleep(5000)
-
-    const allProcess = await findProcess('port', PORT)
-
-    const [botProcess] = allProcess
-    if (allProcess.length > 1) {
-      throw new Error(`Expected to find only one process listening on port ${PORT}`)
-    }
-    if (!botProcess) {
-      throw new Error(`Expected to find a process listening on port ${PORT}`)
-    }
-
-    /**
-     * TODO:
-     * - try calling the Bot locally to see if it works
-     * - allow listing dev bots in API and find the one we just created (by name)
-     */
-
-    process.kill(botProcess.pid)
-    await cmdPromise
-  },
-}

package/e2e/tests/install-interfaces.ts

@@ -1,49 +0,0 @@
-import pathlib from 'path'
-import impl from '../../src/command-implementations'
-import defaults from '../defaults'
-import { Test } from '../typings'
-import * as utils from '../utils'
-
-export const installAllInterfaces: Test = {
-  name: 'cli should allow installing public interfaces',
-  handler: async ({ tmpDir, logger, ...creds }) => {
-    const botpressHomeDir = pathlib.join(tmpDir, '.botpresshome')
-    const baseDir = pathlib.join(tmpDir, 'interfaces')
-
-    const argv = {
-      ...defaults,
-      botpressHome: botpressHomeDir,
-      confirm: true,
-      ...creds,
-    }
-
-    await impl.login({ ...argv }).then(utils.handleExitCode)
-
-    const interfaces: string[] = [
-      'creatable',
-      'deletable',
-      'hitl',
-      'listable',
-      'llm',
-      'readable',
-      'speechToText',
-      'textToImage',
-      'typingIndicator',
-      'updatable',
-    ]
-
-    for (const iface of interfaces) {
-      logger.info(`Installing interface: ${iface}`)
-      await impl
-        .add({
-          ...argv,
-          packageRef: iface,
-          packageType: 'interface',
-          installPath: baseDir,
-          useDev: false,
-        })
-        .then(utils.handleExitCode)
-      // TODO: also run a type check on the installed interface
-    }
-  },
-}

package/e2e/tests/install-package.ts

@@ -1,164 +0,0 @@
-import * as client from '@botpress/client'
-import * as sdk from '@botpress/sdk'
-import * as fslib from 'fs'
-import * as pathlib from 'path'
-import * as uuid from 'uuid'
-import * as apiUtils from '../../src/api'
-import impl from '../../src/command-implementations'
-import defaults from '../defaults'
-import { Test, TestProps } from '../typings'
-import * as utils from '../utils'
-
-const issueSchema = sdk.z.object({
-  id: sdk.z.string(),
-  priority: sdk.z.enum(['high', 'medium', 'low']),
-  title: sdk.z.string(),
-  body: sdk.z.string(),
-})
-const INTEGRATION = {
-  version: '0.0.1',
-  title: 'An Integration',
-  description: 'An integration',
-  user: { tags: { id: { title: 'ID', description: 'The user ID' } } },
-  configuration: { schema: sdk.z.object({}), identifier: { required: true, linkTemplateScript: '' } },
-  configurations: {
-    token: {
-      title: 'API Token',
-      description: 'The token to authenticate with',
-      schema: sdk.z.object({ token: sdk.z.string() }),
-    },
-  },
-  actions: {
-    getIssue: {
-      input: { schema: sdk.z.object({ id: sdk.z.string() }) },
-      output: { schema: issueSchema },
-    },
-  },
-  events: {
-    issueCreated: {
-      title: 'Issue Created',
-      description: 'An issue was created',
-      schema: issueSchema,
-    },
-  },
-  channels: {
-    issueComment: {
-      title: 'Issue Comment',
-      description: 'Comment on an issue',
-      messages: { text: sdk.messages.defaults.text },
-      conversation: { tags: { id: { title: 'ID', description: 'The issue ID' } } },
-      message: { tags: { id: { title: 'ID', description: 'The issue comment ID' } } },
-    },
-  },
-  entities: {
-    issue: {
-      title: 'Issue',
-      description: 'An issue',
-      schema: issueSchema,
-    },
-  },
-  states: {
-    lastCreatedIssue: {
-      type: 'integration',
-      schema: issueSchema,
-    },
-  },
-  identifier: {
-    extractScript: '',
-  },
-} satisfies Omit<sdk.IntegrationDefinitionProps, 'name'>
-
-const getHomeDir = (props: { tmpDir: string }) => pathlib.join(props.tmpDir, '.botpresshome')
-const initBot = async (props: TestProps, definitionFile: string) => {
-  const { tmpDir, dependencies, ...creds } = props
-  const argv = {
-    ...defaults,
-    botpressHome: getHomeDir(props),
-    confirm: true,
-    ...creds,
-  }
-  const botName = uuid.v4().replace(/-/g, '')
-  const botDir = pathlib.join(tmpDir, botName)
-  await impl.init({ ...argv, workDir: tmpDir, name: botName, type: 'bot' }).then(utils.handleExitCode)
-  await utils.fixBotpressDependencies({ workDir: botDir, target: dependencies })
-  await utils.npmInstall({ workDir: botDir }).then(utils.handleExitCode)
-  await fslib.promises.writeFile(pathlib.join(botDir, 'bot.definition.ts'), definitionFile)
-  return { botDir }
-}
-
-// TODO: add an equivalent test with an interface once interfaces can be created by any workspace
-
-export const addIntegration: Test = {
-  name: 'cli should allow installing an integration',
-  handler: async (props) => {
-    const { tmpDir, workspaceHandle, logger, ...creds } = props
-    const argv = {
-      ...defaults,
-      botpressHome: getHomeDir({ tmpDir }),
-      confirm: true,
-      ...creds,
-    }
-
-    const bpClient = new client.Client({ apiUrl: creds.apiUrl, token: creds.token, workspaceId: creds.workspaceId })
-
-    const integrationSuffix = uuid.v4().replace(/-/g, '')
-    const name = `myintegration${integrationSuffix}`
-    const integrationName = `${workspaceHandle}/${name}`
-
-    const createIntegrationBody = await apiUtils.prepareCreateIntegrationBody(
-      new sdk.IntegrationDefinition({
-        ...INTEGRATION,
-        name: integrationName,
-      })
-    )
-
-    const { integration } = await bpClient.createIntegration({
-      ...createIntegrationBody,
-      dev: true, // this way we ensure the integration will eventually be janitored if the test fails
-      url: creds.apiUrl,
-    })
-
-    try {
-      logger.info('Initializing bot')
-      const { botDir } = await initBot(
-        props,
-        [
-          'import * as sdk from "@botpress/sdk"',
-          `import anIntegration from "./bp_modules/${workspaceHandle}-${name}"`,
-          'export default new sdk.BotDefinition({}).addIntegration(anIntegration, {',
-          '  enabled: true,',
-          '  configurationType: null,',
-          '  configuration: {},',
-          '})',
-        ].join('\n')
-      )
-
-      logger.info('Logging in')
-      await impl.login(argv).then(utils.handleExitCode)
-
-      logger.info('Installing integration')
-      await impl
-        .add({
-          ...argv,
-          packageType: undefined,
-          installPath: botDir,
-          packageRef: integration.id,
-          useDev: false,
-        })
-        .then(utils.handleExitCode)
-
-      logger.info('Building bot')
-      await impl.build({ ...argv, workDir: botDir }).then(utils.handleExitCode)
-      await utils.tscCheck({ workDir: botDir }).then(utils.handleExitCode)
-    } finally {
-      await impl.integrations.subcommands
-        .delete({
-          ...argv,
-          integrationRef: integration.id,
-        })
-        .catch(() => {
-          logger.warn(`Failed to delete integration ${integration.id}`) // this is not the purpose of the test
-        })
-    }
-  },
-}

package/e2e/tests/integration-secrets.ts

@@ -1,102 +0,0 @@
-import { Client } from '@botpress/client'
-import * as sdk from '@botpress/sdk'
-import fs from 'fs'
-import pathlib from 'path'
-import * as uuid from 'uuid'
-import impl from '../../src/command-implementations'
-import { fetchAllIntegrations, ApiIntegration } from '../api'
-import defaults from '../defaults'
-import { Test } from '../typings'
-import * as utils from '../utils'
-
-type SecretDef = NonNullable<sdk.IntegrationDefinitionProps['secrets']>
-
-const fetchIntegration = async (client: Client, integrationName: string): Promise<ApiIntegration | undefined> => {
-  const integrations = await fetchAllIntegrations(client)
-  return integrations.find(({ name }) => name === integrationName)
-}
-
-const appendSecretDefinition = (originalTsContent: string, secrets: SecretDef): string => {
-  const regex = /( *)version: (['"].*['"]),/
-  const replacement = [
-    'version: $2,',
-    'secrets: {',
-    ...Object.entries(secrets).map(([secretName, secretDef]) => `  ${secretName}: ${JSON.stringify(secretDef)},`),
-    '},',
-  ]
-    .map((s) => `$1${s}`) // for indentation
-    .join('\n')
-
-  const modifiedTsContent = originalTsContent.replace(regex, replacement)
-  return modifiedTsContent
-}
-
-export const requiredSecrets: Test = {
-  name: 'cli should require required secrets',
-  handler: async ({ tmpDir, workspaceHandle, dependencies, ...creds }) => {
-    const botpressHomeDir = pathlib.join(tmpDir, '.botpresshome')
-    const baseDir = pathlib.join(tmpDir, 'integrations')
-
-    const integrationSuffix = uuid.v4().replace(/-/g, '')
-    const name = `myintegration${integrationSuffix}`
-    const integrationName = `${workspaceHandle}/${name}`
-    const integrationDirName = `${workspaceHandle}-${name}`
-    const integrationDir = pathlib.join(baseDir, integrationDirName)
-
-    const definitionPath = pathlib.join(integrationDir, 'integration.definition.ts')
-
-    const argv = {
-      ...defaults,
-      botpressHome: botpressHomeDir,
-      confirm: true,
-      ...creds,
-    }
-
-    const client = new Client({ apiUrl: creds.apiUrl, token: creds.token, workspaceId: creds.workspaceId })
-
-    await impl
-      .init({ ...argv, workDir: baseDir, name: integrationName, type: 'integration' })
-      .then(utils.handleExitCode)
-
-    const originalDefinition: string = fs.readFileSync(definitionPath, 'utf-8')
-    const modifiedDefinition = appendSecretDefinition(originalDefinition, {
-      REQUIRED_SECRET: {},
-      OPTIONAL_SECRET: { optional: true },
-    })
-    fs.writeFileSync(definitionPath, modifiedDefinition, 'utf-8')
-    await impl.build({ ...argv, workDir: integrationDir }).then(utils.handleExitCode)
-
-    await utils.fixBotpressDependencies({ workDir: integrationDir, target: dependencies })
-    await utils.npmInstall({ workDir: integrationDir }).then(utils.handleExitCode)
-    await impl.build({ ...argv, workDir: integrationDir }).then(utils.handleExitCode)
-    await impl.login({ ...argv }).then(utils.handleExitCode)
-
-    const { exitCode } = await impl.deploy({
-      ...argv,
-      workDir: integrationDir,
-      secrets: ['OPTIONAL_SECRET=lol'],
-      botId: undefined,
-      createNewBot: undefined,
-    })
-    if (exitCode === 0) {
-      throw new Error('Expected deploy to fail')
-    }
-
-    await impl
-      .deploy({
-        ...argv,
-        workDir: integrationDir,
-        secrets: ['REQUIRED_SECRET=lol'],
-        botId: undefined,
-        createNewBot: undefined,
-      })
-      .then(utils.handleExitCode)
-
-    // cleanup deployed integration
-    const integration = await fetchIntegration(client, integrationName)
-    if (!integration) {
-      throw new Error(`Integration ${integrationName} should have been created`)
-    }
-    await client.deleteIntegration({ id: integration.id })
-  },
-}

package/e2e/tests/manage-workspace-handle.ts

@@ -1,105 +0,0 @@
-import { Client } from '@botpress/client'
-import pathlib from 'path'
-import impl from '../../src/command-implementations'
-import { ApiIntegration, fetchAllIntegrations } from '../api'
-import defaults from '../defaults'
-import { Test } from '../typings'
-import * as utils from '../utils'
-
-const fetchIntegration = async (client: Client, integrationName: string): Promise<ApiIntegration | undefined> => {
-  const integrations = await fetchAllIntegrations(client)
-  return integrations.find(({ name }) => name === integrationName)
-}
-
-export const prependWorkspaceHandle: Test = {
-  name: 'cli should automatically preprend the workspace handle to the integration name when deploying',
-  handler: async ({ tmpDir, dependencies, workspaceHandle, logger, ...creds }) => {
-    const botpressHomeDir = pathlib.join(tmpDir, '.botpresshome')
-    const baseDir = pathlib.join(tmpDir, 'integrations')
-
-    const integrationSuffix = utils.getUUID()
-    const integrationName = `myintegration${integrationSuffix}`
-    const integrationDirName = integrationName
-    const integrationDir = pathlib.join(baseDir, integrationDirName)
-
-    const argv = {
-      ...defaults,
-      botpressHome: botpressHomeDir,
-      confirm: true,
-      ...creds,
-    }
-
-    const client = new Client({ apiUrl: creds.apiUrl, token: creds.token, workspaceId: creds.workspaceId })
-
-    await impl
-      .init({ ...argv, workDir: baseDir, name: integrationName, type: 'integration' })
-      .then(utils.handleExitCode)
-    await utils.fixBotpressDependencies({ workDir: integrationDir, target: dependencies })
-    await utils.npmInstall({ workDir: integrationDir }).then(utils.handleExitCode)
-    await impl.build({ ...argv, workDir: integrationDir }).then(utils.handleExitCode)
-    await impl.login({ ...argv }).then(utils.handleExitCode)
-
-    await impl
-      .deploy({ ...argv, createNewBot: undefined, botId: undefined, workDir: integrationDir })
-      .then(utils.handleExitCode)
-
-    logger.debug(`Fetching integration "${integrationName}"`)
-    let integration = await fetchIntegration(client, integrationName)
-    if (integration) {
-      throw new Error(`Integration ${integrationName} should not have been created`)
-    }
-
-    const expectedIntegrationName = `${workspaceHandle}/${integrationName}`
-    logger.debug(`Fetching integration "${expectedIntegrationName}"`)
-    integration = await fetchIntegration(client, expectedIntegrationName)
-    if (!integration) {
-      throw new Error(`Integration ${expectedIntegrationName} should have been created`)
-    }
-
-    logger.debug(`Deleting integration "${integrationName}"`)
-    await impl.integrations.subcommands.delete({ ...argv, integrationRef: integration.id }).then(({ exitCode }) => {
-      exitCode !== 0 && logger.warn(`Failed to delete integration "${integrationName}"`) // not enough to fail the test
-    })
-  },
-}
-
-export const enforceWorkspaceHandle: Test = {
-  name: 'cli should fail when attempting to deploy an integration with incorrect workspace handle',
-  handler: async ({ tmpDir, dependencies, ...creds }) => {
-    const botpressHomeDir = pathlib.join(tmpDir, '.botpresshome')
-    const baseDir = pathlib.join(tmpDir, 'integrations')
-
-    const randomSuffix = utils.getUUID().slice(0, 8)
-
-    const name = 'myintegration'
-    const handle = `myhandle${randomSuffix}`
-    const integrationName = `${handle}/${name}`
-    const integrationDirName = `${handle}-${name}`
-    const integrationDir = pathlib.join(baseDir, integrationDirName)
-
-    const argv = {
-      ...defaults,
-      botpressHome: botpressHomeDir,
-      confirm: true,
-      ...creds,
-    }
-
-    await impl
-      .init({ ...argv, workDir: baseDir, name: integrationName, type: 'integration' })
-      .then(utils.handleExitCode)
-    await utils.fixBotpressDependencies({ workDir: integrationDir, target: dependencies })
-    await utils.npmInstall({ workDir: integrationDir }).then(utils.handleExitCode)
-    await impl.login({ ...argv }).then(utils.handleExitCode)
-
-    const { exitCode } = await impl.deploy({
-      ...argv,
-      createNewBot: undefined,
-      botId: undefined,
-      workDir: integrationDir,
-    })
-
-    if (exitCode === 0) {
-      throw new Error(`Integration ${integrationName} should not have been deployed`)
-    }
-  },
-}

package/e2e/typings.ts

@@ -1,17 +0,0 @@
-import { Logger } from '@bpinternal/log4bot'
-
-export type TestProps = {
-  logger: Logger
-  tmpDir: string
-  workspaceId: string
-  workspaceHandle: string
-  token: string
-  apiUrl: string
-  tunnelUrl: string
-  dependencies: Record<string, string | undefined>
-}
-
-export type Test = {
-  name: string
-  handler: (props: TestProps) => Promise<void>
-}

package/e2e/utils.ts

@@ -1,99 +0,0 @@
-import childprocess from 'child_process'
-import fs from 'fs'
-import _ from 'lodash'
-import pathlib from 'path'
-import tmp from 'tmp'
-import * as uuid from 'uuid'
-
-type PackageJson = {
-  name: string
-  version?: string
-  description?: string
-  scripts?: Record<string, string>
-  dependencies?: Record<string, string>
-  devDependencies?: Record<string, string>
-  peerDependencies?: Record<string, string>
-}
-
-export const sleep = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms))
-
-export class TmpDirectory {
-  private _closed = false
-
-  public static create() {
-    return new TmpDirectory(tmp.dirSync({ unsafeCleanup: true }))
-  }
-
-  private constructor(private _res: tmp.DirResult) {}
-
-  public get path() {
-    if (this._closed) {
-      throw new Error('Cannot access tmp directory after cleanup')
-    }
-    return this._res.name
-  }
-
-  public cleanup() {
-    if (this._closed) {
-      return
-    }
-    this._res.removeCallback()
-  }
-}
-
-export type RunCommandOptions = {
-  workDir: string
-}
-
-export type RunCommandOutput = {
-  exitCode: number
-}
-
-export const runCommand = async (cmd: string, { workDir }: RunCommandOptions): Promise<RunCommandOutput> => {
-  const [program, ...args] = cmd.split(' ')
-  if (!program) {
-    throw new Error('Cannot run empty command')
-  }
-  const { error, status } = childprocess.spawnSync(program, args, {
-    cwd: workDir,
-    stdio: 'inherit',
-  })
-  if (error) {
-    throw error
-  }
-  return { exitCode: status ?? 0 }
-}
-
-export const npmInstall = ({ workDir }: RunCommandOptions): Promise<RunCommandOutput> => {
-  return runCommand('pnpm install', { workDir })
-}
-
-export const tscCheck = ({ workDir }: RunCommandOptions): Promise<RunCommandOutput> => {
-  return runCommand('tsc --noEmit', { workDir })
-}
-
-export const fixBotpressDependencies = async ({
-  workDir,
-  target,
-}: {
-  workDir: string
-  target: Record<string, string | undefined>
-}) => {
-  const packageJsonPath = pathlib.join(workDir, 'package.json')
-  const originalPackageJson: PackageJson = require(packageJsonPath)
-
-  const newPackageJson = {
-    ...originalPackageJson,
-    dependencies: _.mapValues(originalPackageJson.dependencies ?? {}, (version, name) => target[name] ?? version),
-  }
-
-  fs.writeFileSync(packageJsonPath, JSON.stringify(newPackageJson, null, 2))
-}
-
-export const handleExitCode = ({ exitCode }: { exitCode: number }) => {
-  if (exitCode !== 0) {
-    throw new Error(`Command exited with code ${exitCode}`)
-  }
-}
-
-export const getUUID = () => uuid.v4().replace(/-/g, '')