@botpress/cli 4.17.14 → 4.17.15

package/dist/command-implementations/init-command.d.ts

@@ -0,0 +1,17 @@
+import type commandDefinitions from '../command-definitions';
+import { GlobalCommand } from './global-command';
+export type InitCommandDefinition = typeof commandDefinitions.init;
+export declare class InitCommand extends GlobalCommand<InitCommandDefinition> {
+    run(): Promise<void>;
+    private _promptWorkspaceHandle;
+    private _promptProjectType;
+    private _initPlugin;
+    private _getOrPromptForTemplate;
+    private _promptForTemplate;
+    private _getFullNameAndShortName;
+    private _initBot;
+    private _initIntegration;
+    private _getName;
+    private _copy;
+    private _checkIfDestinationCanBeUsed;
+}

package/dist/command-implementations/integration-commands.d.ts

@@ -0,0 +1,15 @@
+import type commandDefinitions from '../command-definitions';
+import { GlobalCommand } from './global-command';
+export type GetIntegrationCommandDefinition = typeof commandDefinitions.integrations.subcommands.get;
+export declare class GetIntegrationCommand extends GlobalCommand<GetIntegrationCommandDefinition> {
+    run(): Promise<void>;
+}
+export type ListIntegrationsCommandDefinition = typeof commandDefinitions.integrations.subcommands.list;
+export declare class ListIntegrationsCommand extends GlobalCommand<ListIntegrationsCommandDefinition> {
+    run(): Promise<void>;
+}
+export type DeleteIntegrationCommandDefinition = typeof commandDefinitions.integrations.subcommands.delete;
+export declare class DeleteIntegrationCommand extends GlobalCommand<DeleteIntegrationCommandDefinition> {
+    run(): Promise<void>;
+    private _findIntegration;
+}

package/dist/command-implementations/interface-commands.d.ts

@@ -0,0 +1,14 @@
+import type commandDefinitions from '../command-definitions';
+import { GlobalCommand } from './global-command';
+export type GetInterfaceCommandDefinition = typeof commandDefinitions.interfaces.subcommands.get;
+export declare class GetInterfaceCommand extends GlobalCommand<GetInterfaceCommandDefinition> {
+    run(): Promise<void>;
+}
+export type ListInterfacesCommandDefinition = typeof commandDefinitions.interfaces.subcommands.list;
+export declare class ListInterfacesCommand extends GlobalCommand<ListInterfacesCommandDefinition> {
+    run(): Promise<void>;
+}
+export type DeleteInterfaceCommandDefinition = typeof commandDefinitions.interfaces.subcommands.delete;
+export declare class DeleteInterfaceCommand extends GlobalCommand<DeleteInterfaceCommandDefinition> {
+    run(): Promise<void>;
+}

package/dist/command-implementations/lint-command.d.ts

@@ -0,0 +1,15 @@
+import type commandDefinitions from '../command-definitions';
+import { ProjectCommand } from './project-command';
+export type LintCommandDefinition = typeof commandDefinitions.lint;
+export declare class LintCommand extends ProjectCommand<LintCommandDefinition> {
+    run(): Promise<void>;
+    private _runLintForInterface;
+    private _runLintForBot;
+    private _stripAutoGeneratedContentFromBot;
+    private _runLintForIntegration;
+    private _stripAutoGeneratedContentFromIntegration;
+    private _getAutoGeneratedContentOfIntegration;
+    private _dereferenceActionDefinition;
+    private _dereferenceEventDefinition;
+    private _replaceRef;
+}

package/dist/command-implementations/login-command.d.ts

@@ -0,0 +1,6 @@
+import type commandDefinitions from '../command-definitions';
+import { GlobalCommand } from './global-command';
+export type LoginCommandDefinition = typeof commandDefinitions.login;
+export declare class LoginCommand extends GlobalCommand<LoginCommandDefinition> {
+    run(): Promise<void>;
+}

package/dist/command-implementations/logout-command.d.ts

@@ -0,0 +1,6 @@
+import type commandDefinitions from '../command-definitions';
+import { GlobalCommand } from './global-command';
+export type LogoutCommandDefinition = typeof commandDefinitions.logout;
+export declare class LogoutCommand extends GlobalCommand<LogoutCommandDefinition> {
+    run(): Promise<void>;
+}

package/dist/command-implementations/plugin-commands.d.ts

@@ -0,0 +1,14 @@
+import type commandDefinitions from '../command-definitions';
+import { GlobalCommand } from './global-command';
+export type GetPluginCommandDefinition = typeof commandDefinitions.plugins.subcommands.get;
+export declare class GetPluginCommand extends GlobalCommand<GetPluginCommandDefinition> {
+    run(): Promise<void>;
+}
+export type ListPluginsCommandDefinition = typeof commandDefinitions.plugins.subcommands.list;
+export declare class ListPluginsCommand extends GlobalCommand<ListPluginsCommandDefinition> {
+    run(): Promise<void>;
+}
+export type DeletePluginCommandDefinition = typeof commandDefinitions.plugins.subcommands.delete;
+export declare class DeletePluginCommand extends GlobalCommand<DeletePluginCommandDefinition> {
+    run(): Promise<void>;
+}

package/dist/command-implementations/profile-commands.d.ts

@@ -0,0 +1,14 @@
+import type commandDefinitions from '../command-definitions';
+import { GlobalCommand } from './global-command';
+export type ActiveProfileCommandDefinition = typeof commandDefinitions.profiles.subcommands.active;
+export declare class ActiveProfileCommand extends GlobalCommand<ActiveProfileCommandDefinition> {
+    run(): Promise<void>;
+}
+export type ListProfilesCommandDefinition = typeof commandDefinitions.profiles.subcommands.list;
+export declare class ListProfilesCommand extends GlobalCommand<ListProfilesCommandDefinition> {
+    run(): Promise<void>;
+}
+export type UseProfileCommandDefinition = typeof commandDefinitions.profiles.subcommands.use;
+export declare class UseProfileCommand extends GlobalCommand<UseProfileCommandDefinition> {
+    run(): Promise<void>;
+}

package/dist/command-implementations/project-command.d.ts

@@ -0,0 +1,67 @@
+import type * as client from '@botpress/client';
+import type * as sdk from '@botpress/sdk';
+import type { YargsConfig } from '@bpinternal/yargs-extra';
+import * as apiUtils from '../api';
+import * as config from '../config';
+import * as consts from '../consts';
+import type { CommandArgv, CommandDefinition } from '../typings';
+import * as utils from '../utils';
+import { GlobalCommand } from './global-command';
+export type ProjectCommandDefinition = CommandDefinition<typeof config.schemas.project>;
+export type ProjectCache = {
+    botId: string;
+    devId: string;
+    tunnelId: string;
+};
+type ConfigurableProjectPaths = {
+    workDir: string;
+};
+type ConstantProjectPaths = typeof consts.fromWorkDir;
+type AllProjectPaths = ConfigurableProjectPaths & ConstantProjectPaths;
+type LintIgnoredConfig = {
+    bpLintDisabled?: boolean;
+};
+export type ProjectType = ProjectDefinition['type'];
+export type ProjectDefinition = LintIgnoredConfig & ({
+    type: 'integration';
+    definition: sdk.IntegrationDefinition;
+} | {
+    type: 'interface';
+    definition: sdk.InterfaceDefinition;
+} | {
+    type: 'bot';
+    definition: sdk.BotDefinition;
+} | {
+    type: 'plugin';
+    definition: sdk.PluginDefinition;
+});
+type UpdatedBot = client.Bot;
+declare class ProjectPaths extends utils.path.PathStore<keyof AllProjectPaths> {
+    constructor(argv: CommandArgv<ProjectCommandDefinition>);
+}
+export declare abstract class ProjectCommand<C extends ProjectCommandDefinition> extends GlobalCommand<C> {
+    protected bootstrap(): Promise<void>;
+    protected get projectPaths(): ProjectPaths;
+    protected get projectCache(): utils.cache.FSKeyValueCache<ProjectCache>;
+    protected readProjectDefinitionFromFS(): Promise<ProjectDefinition>;
+    private _readIntegrationDefinitionFromFS;
+    private _readInterfaceDefinitionFromFS;
+    private _readBotDefinitionFromFS;
+    private _readPluginDefinitionFromFS;
+    private _isBpLintDisabled;
+    protected displayWebhookUrls(bot: client.Bot): void;
+    protected promptSecrets(integrationDef: sdk.IntegrationDefinition, argv: YargsConfig<typeof config.schemas.secrets>, opts?: {
+        formatEnv?: boolean;
+        knownSecrets?: string[];
+    }): Promise<Record<string, string | null>>;
+    protected prepareCreateIntegrationBody(integrationDef: sdk.IntegrationDefinition): Promise<apiUtils.CreateIntegrationRequestBody>;
+    protected prepareBotDependencies(botDef: sdk.BotDefinition, api: apiUtils.ApiClient): Promise<Partial<apiUtils.UpdateBotRequestBody>>;
+    protected prepareIntegrationDependencies(integrationDef: sdk.IntegrationDefinition, api: apiUtils.ApiClient): Promise<Partial<apiUtils.CreateIntegrationRequestBody>>;
+    protected preparePluginDependencies(pluginDef: sdk.PluginDefinition, api: apiUtils.ApiClient): Promise<Partial<apiUtils.CreatePluginRequestBody>>;
+    private _fetchDependencies;
+    protected readProjectFile: (filePath: string | undefined, encoding?: BufferEncoding) => Promise<string | undefined>;
+    private _parseArgvSecrets;
+    private _notifyUpdateSdk;
+    protected validateIntegrationRegistration(updatedBot: UpdatedBot, onFailCallback: (failedIntegrations: UpdatedBot['integrations']) => void): void;
+}
+export {};

package/dist/command-implementations/read-command.d.ts

@@ -0,0 +1,10 @@
+import commandDefinitions from '../command-definitions';
+import { ProjectCommand } from './project-command';
+export type ReadCommandDefinition = typeof commandDefinitions.read;
+export declare class ReadCommand extends ProjectCommand<ReadCommandDefinition> {
+    run(): Promise<void>;
+    private _parseIntegration;
+    private _parseInterface;
+    private _parseBot;
+    private _parsePlugin;
+}

package/dist/command-implementations/serve-command.d.ts

@@ -0,0 +1,6 @@
+import type commandDefinitions from '../command-definitions';
+import { ProjectCommand } from './project-command';
+export type ServeCommandDefinition = typeof commandDefinitions.serve;
+export declare class ServeCommand extends ProjectCommand<ServeCommandDefinition> {
+    run(): Promise<void>;
+}

package/dist/command-tree.d.ts

@@ -0,0 +1,39 @@
+import type * as typings from './typings';
+export type DefinitionSubTree = {
+    description: string;
+    subcommands: DefinitionTree;
+};
+export type DefinitionTree = {
+    [key: string]: DefinitionTreeNode;
+};
+export type DefinitionTreeNode = typings.CommandDefinition | DefinitionSubTree;
+export type ImplementationSubTree<D extends DefinitionSubTree = DefinitionSubTree> = {
+    subcommands: ImplementationTree<D['subcommands']>;
+};
+export type ImplementationTreeNode<N extends DefinitionTreeNode = DefinitionTreeNode> = N extends typings.CommandDefinition ? typings.CommandImplementation<N> : N extends DefinitionSubTree ? ImplementationSubTree<N> : never;
+export type ImplementationTree<D extends DefinitionTree = DefinitionTree> = {
+    [K in keyof D]: ImplementationTreeNode<D[K]>;
+};
+export type CommandSubTree<D extends DefinitionSubTree = DefinitionSubTree> = {
+    description: string;
+    subcommands: CommandTree<D['subcommands']>;
+};
+export type CommandTreeNode<N extends DefinitionTreeNode = DefinitionTreeNode> = N extends typings.CommandDefinition ? typings.CommandLeaf<N> : N extends DefinitionSubTree ? CommandSubTree<N> : never;
+export type CommandTree<D extends DefinitionTree = DefinitionTree> = {
+    [K in keyof D]: CommandTreeNode<D[K]>;
+};
+export declare const guards: {
+    definition: {
+        isDef: (x: DefinitionTreeNode) => x is typings.CommandDefinition;
+        isSubTree: (x: DefinitionTreeNode) => x is DefinitionSubTree;
+    };
+    implementation: {
+        isImpl: (x: ImplementationTreeNode) => x is typings.CommandImplementation;
+        isSubTree: (x: ImplementationTreeNode) => x is ImplementationSubTree;
+    };
+    command: {
+        isLeaf: (x: CommandTreeNode) => x is typings.CommandLeaf;
+        isSubTree: (x: CommandTreeNode) => x is CommandSubTree;
+    };
+};
+export declare const zipTree: <T extends DefinitionTree>(defTree: T, implTree: ImplementationTree<T>) => CommandTree<T>;