@chatbotkit/cli 1.8.0 → 1.9.1

package/dist/cjs/solution/index.cjs

@@ -0,0 +1,325 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getArrayBackedObject = exports.ArrayBackedObject = exports.Solution = exports.SitemapIntegrationResource = exports.WidgetIntegrationResource = exports.SkillsetResource = exports.DatasetResource = exports.BotResource = exports.Resource = exports.SolutionConfigSchema = exports.ResourceConfigSchema = exports.SitemapIntegrationResourceConfigSchema = exports.WidgetIntegrationResourceConfigSchema = exports.SkillsetResourceConfigSchema = exports.DatasetResourceConfigSchema = exports.BotResourceConfigSchema = exports.BasicResourceConfigSchema = exports.replaceEnvVars = exports.getSolutionFileNameAndPath = exports.getSolutionFilePath = exports.getSolutionFileName = exports.getSolutionFolderPath = void 0;
+const tslib_1 = require("tslib");
+const env_js_1 = require("../env.cjs");
+const output_js_1 = require("../output.cjs");
+const sdk_1 = tslib_1.__importDefault(require("@chatbotkit/sdk"));
+const promises_1 = tslib_1.__importDefault(require("fs/promises"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const zod_1 = require("zod");
+function getSolutionFolderPath() {
+    const folderPath = path_1.default.join('.chatbotkit', 'solutions');
+    return folderPath;
+}
+exports.getSolutionFolderPath = getSolutionFolderPath;
+function getSolutionFileName(name) {
+    const fileName = name.toLowerCase().replace(/\W/g, '_').replace(/_+/g, '_') + '.json';
+    return fileName;
+}
+exports.getSolutionFileName = getSolutionFileName;
+function getSolutionFilePath(name) {
+    const fileName = getSolutionFileName(name);
+    const filePath = path_1.default.join(getSolutionFolderPath(), fileName);
+    return filePath;
+}
+exports.getSolutionFilePath = getSolutionFilePath;
+function getSolutionFileNameAndPath(name) {
+    const fileName = getSolutionFileName(name);
+    const filePath = getSolutionFilePath(name);
+    return { fileName, filePath };
+}
+exports.getSolutionFileNameAndPath = getSolutionFileNameAndPath;
+function replaceEnvVars(value) {
+    if (!value) {
+        return value;
+    }
+    if (typeof value === 'string') {
+        return value.replace(/\${env\.([A-Z_]+)}/g, (_, name) => {
+            const envValue = process.env[name];
+            if (envValue === undefined) {
+                throw new output_js_1.CommandError(`Environment variable ${name} is not set`);
+            }
+            return envValue;
+        });
+    }
+    if (Array.isArray(value)) {
+        return value.map(replaceEnvVars);
+    }
+    if (typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value).map(([key, value]) => [key, replaceEnvVars(value)]));
+    }
+    return value;
+}
+exports.replaceEnvVars = replaceEnvVars;
+exports.BasicResourceConfigSchema = zod_1.z.object({
+    type: zod_1.z.string(),
+    slug: zod_1.z.string().optional(),
+    id: zod_1.z.string().optional(),
+    name: zod_1.z.string(),
+    description: zod_1.z.string().optional(),
+    properties: zod_1.z.record(zod_1.z.unknown()),
+});
+exports.BotResourceConfigSchema = exports.BasicResourceConfigSchema.extend({
+    type: zod_1.z.literal('bot'),
+    properties: zod_1.z.object({
+        model: zod_1.z.string().optional(),
+        backstory: zod_1.z.string().optional(),
+        datasetId: zod_1.z.string().optional(),
+        skillsetId: zod_1.z.string().optional(),
+        moderation: zod_1.z.boolean().optional(),
+        privacy: zod_1.z.boolean().optional(),
+    }),
+});
+exports.DatasetResourceConfigSchema = exports.BasicResourceConfigSchema.extend({
+    type: zod_1.z.literal('dataset'),
+    properties: zod_1.z.object({}),
+});
+exports.SkillsetResourceConfigSchema = exports.BasicResourceConfigSchema.extend({
+    type: zod_1.z.literal('skillset'),
+    properties: zod_1.z.object({}),
+});
+exports.WidgetIntegrationResourceConfigSchema = exports.BasicResourceConfigSchema.extend({
+    type: zod_1.z.literal('widgetIntegration'),
+    properties: zod_1.z.object({}),
+});
+exports.SitemapIntegrationResourceConfigSchema = exports.BasicResourceConfigSchema.extend({
+    type: zod_1.z.literal('sitemapIntegration'),
+    properties: zod_1.z.object({
+        url: zod_1.z.string().url(),
+        datasetId: zod_1.z.string(),
+    }),
+});
+exports.ResourceConfigSchema = zod_1.z.union([
+    exports.BotResourceConfigSchema,
+    exports.DatasetResourceConfigSchema,
+    exports.SkillsetResourceConfigSchema,
+    exports.WidgetIntegrationResourceConfigSchema,
+    exports.SitemapIntegrationResourceConfigSchema,
+]);
+exports.SolutionConfigSchema = zod_1.z.object({
+    version: zod_1.z.literal(1),
+    resources: zod_1.z.array(exports.ResourceConfigSchema),
+});
+class Resource {
+    constructor(config) {
+        this.config = config;
+    }
+    get type() {
+        return this.config.type;
+    }
+    get slug() {
+        var _a;
+        return ((_a = this.config.slug) !== null && _a !== void 0 ? _a : this.config.name.toLowerCase().replace(/\W/g, '_').replace(/_+/g, '_'));
+    }
+    get id() {
+        return this.config.id;
+    }
+    get name() {
+        return this.config.name;
+    }
+    get description() {
+        return this.config.description;
+    }
+    get baseClient() {
+        const client = new sdk_1.default({
+            secret: (0, env_js_1.getSECRET)(),
+            runAsUserId: (0, env_js_1.getRUNAS_USERID)(),
+        });
+        return client;
+    }
+    get client() {
+        throw new Error('Not implemented');
+    }
+    async sync() {
+        if (this.config.id) {
+            await this.client.update(this.config.id, {
+                ...this.config.properties,
+                name: this.config.name,
+                description: this.config.description,
+            });
+        }
+        else {
+            const { id } = await this.client.create({
+                ...this.config.properties,
+                name: this.config.name,
+                description: this.config.description,
+            });
+            this.config.id = id;
+        }
+    }
+}
+exports.Resource = Resource;
+class BotResource extends Resource {
+    get client() {
+        return this.baseClient.bot;
+    }
+}
+exports.BotResource = BotResource;
+class DatasetResource extends Resource {
+    get client() {
+        return this.baseClient.dataset;
+    }
+}
+exports.DatasetResource = DatasetResource;
+class SkillsetResource extends Resource {
+    get client() {
+        return this.baseClient.skillset;
+    }
+}
+exports.SkillsetResource = SkillsetResource;
+class WidgetIntegrationResource extends Resource {
+    get client() {
+        return this.baseClient.integration.widget;
+    }
+}
+exports.WidgetIntegrationResource = WidgetIntegrationResource;
+class SitemapIntegrationResource extends Resource {
+    get client() {
+        return this.baseClient.integration.sitemap;
+    }
+}
+exports.SitemapIntegrationResource = SitemapIntegrationResource;
+class Solution {
+    constructor(config) {
+        this.config = config;
+    }
+    get baseClient() {
+        const client = new sdk_1.default({
+            secret: (0, env_js_1.getSECRET)(),
+            runAsUserId: (0, env_js_1.getRUNAS_USERID)(),
+        });
+        return client;
+    }
+    get resources() {
+        return this.config.resources.map((resource) => {
+            if (resource.type === 'bot') {
+                return new BotResource(resource);
+            }
+            else if (resource.type === 'dataset') {
+                return new DatasetResource(resource);
+            }
+            else if (resource.type === 'skillset') {
+                return new SkillsetResource(resource);
+            }
+            else if (resource.type === 'widgetIntegration') {
+                return new WidgetIntegrationResource(resource);
+            }
+            else if (resource.type === 'sitemapIntegration') {
+                return new SitemapIntegrationResource(resource);
+            }
+            else {
+                throw new Error(`Unknown resource type: ${resource.type}`);
+            }
+        });
+    }
+    get bots() {
+        return (this.resources.filter((resource) => resource instanceof BotResource));
+    }
+    get bot() {
+        return getArrayBackedObject(this.bots);
+    }
+    get datasets() {
+        return (this.resources.filter((resource) => resource instanceof DatasetResource));
+    }
+    get dataset() {
+        return getArrayBackedObject(this.datasets);
+    }
+    get skillsets() {
+        return (this.resources.filter((resource) => resource instanceof SkillsetResource));
+    }
+    get skillset() {
+        return getArrayBackedObject(this.skillsets);
+    }
+    get widgetIntegrations() {
+        return (this.resources.filter((resource) => resource instanceof WidgetIntegrationResource));
+    }
+    get widgetIntegration() {
+        return getArrayBackedObject(this.widgetIntegrations);
+    }
+    get sitemapIntegrations() {
+        return (this.resources.filter((resource) => resource instanceof SitemapIntegrationResource));
+    }
+    get sitemapIntegration() {
+        return getArrayBackedObject(this.sitemapIntegrations);
+    }
+    async sync() {
+        await Promise.all(this.resources.map((resource) => resource.sync()));
+    }
+}
+exports.Solution = Solution;
+Solution.list = async function () {
+    await promises_1.default.mkdir(getSolutionFolderPath(), { recursive: true });
+    const files = await promises_1.default.readdir('.chatbotkit/solutions');
+    return files
+        .filter((file) => file.endsWith('.json'))
+        .map((file) => file.replace(/\.json$/, ''));
+};
+Solution.create = async function (name) {
+    await promises_1.default.mkdir('.chatbotkit/solutions', { recursive: true });
+    const fileName = getSolutionFileName(name);
+    const filePath = getSolutionFilePath(name);
+    if (await promises_1.default.stat(filePath).catch(() => null)) {
+        throw new output_js_1.CommandError(`Solution ${fileName} already exists`);
+    }
+    const config = {
+        version: 1,
+        resources: [],
+    };
+    await promises_1.default.writeFile(filePath, JSON.stringify(config, null, 2));
+};
+Solution.delete = async function (name) {
+    const fileName = getSolutionFileName(name);
+    const filePath = getSolutionFilePath(name);
+    if (!(await promises_1.default.stat(filePath).catch(() => null))) {
+        throw new output_js_1.CommandError(`Solution ${fileName} does not exist`);
+    }
+    await promises_1.default.unlink(filePath);
+};
+Solution.load = async function (config) {
+    let solutionConfig;
+    if (typeof config === 'string') {
+        const { fileName, filePath } = getSolutionFileNameAndPath(config);
+        if (!(await promises_1.default.stat(filePath).catch(() => null))) {
+            throw new output_js_1.CommandError(`Solution ${fileName} does not exist`);
+        }
+        try {
+            solutionConfig = JSON.parse(await promises_1.default.readFile(filePath, 'utf8'));
+        }
+        catch (error) {
+            throw new output_js_1.CommandError(`Failed to load solution ${fileName}: ${error.message}`);
+        }
+    }
+    else {
+        solutionConfig = config;
+    }
+    const parsedConfig = exports.SolutionConfigSchema.safeParse(solutionConfig);
+    if (!parsedConfig.success) {
+        throw new output_js_1.CommandError(`Invalid solution configuration`);
+    }
+    parsedConfig.data = replaceEnvVars(parsedConfig.data);
+    return new Solution(parsedConfig.data);
+};
+Solution.save = async function (name, solution) {
+    const filePath = getSolutionFilePath(name);
+    await promises_1.default.writeFile(filePath, JSON.stringify(solution.config, null, 2));
+};
+class ArrayBackedObject {
+    constructor(array) {
+        this.array = array;
+        return new Proxy(this, {
+            get: (target, property) => {
+                const item = target.array.find((item) => { var _a; return ((_a = (item)) === null || _a === void 0 ? void 0 : _a.slug) === property; });
+                if (item) {
+                    return item;
+                }
+                return undefined;
+            },
+        });
+    }
+}
+exports.ArrayBackedObject = ArrayBackedObject;
+function getArrayBackedObject(array) {
+    return new ArrayBackedObject(array);
+}
+exports.getArrayBackedObject = getArrayBackedObject;