@botpress/cli 2.1.0 → 2.1.2

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>
-}