@kapeta/local-cluster-service 0.0.0-96f91ef

package/dist/cjs/src/RepositoryWatcher.js

@@ -0,0 +1,332 @@
+"use strict";
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepositoryWatcher = void 0;
+const chokidar_1 = __importDefault(require("chokidar"));
+const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-config"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const node_path_1 = __importDefault(require("node:path"));
+const yaml_1 = __importDefault(require("yaml"));
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
+const lodash_1 = __importDefault(require("lodash"));
+const socketManager_1 = require("./socketManager");
+const cacheManager_1 = require("./cacheManager");
+const node_events_1 = require("node:events");
+const assetManager_1 = require("./assetManager");
+const KAPETA_YML_RX = /^kapeta.ya?ml$/;
+let definitions;
+let definitionTimeout;
+function getDefinitionsDebounced() {
+    if (definitionTimeout) {
+        clearTimeout(definitionTimeout);
+        definitionTimeout = undefined;
+    }
+    if (!definitions) {
+        definitions = local_cluster_config_1.default.getDefinitions();
+    }
+    else {
+        definitionTimeout = setTimeout(() => {
+            definitionTimeout = undefined;
+            definitions = undefined;
+        }, 500);
+    }
+    return definitions;
+}
+class RepositoryWatcher extends node_events_1.EventEmitter {
+    watcher;
+    disabled = false;
+    baseDir;
+    allDefinitions = [];
+    symbolicLinks = {};
+    sourceOfChange = new Map();
+    constructor() {
+        super();
+        this.baseDir = local_cluster_config_1.default.getRepositoryBasedir();
+    }
+    setDisabled(disabled) {
+        this.disabled = disabled;
+    }
+    watch() {
+        if (!fs_extra_1.default.existsSync(this.baseDir)) {
+            fs_extra_1.default.mkdirpSync(this.baseDir);
+        }
+        this.allDefinitions = local_cluster_config_1.default.getDefinitions();
+        try {
+            this.watcher = chokidar_1.default.watch(this.baseDir, {
+                followSymlinks: false,
+                ignorePermissionErrors: true,
+                disableGlobbing: true,
+                persistent: true,
+                depth: 2,
+                ignored: (path) => this.ignoreFile(path),
+            });
+            this.watcher.on('all', this.handleFileChange.bind(this));
+            this.watcher.on('error', (error) => {
+                console.log('Error watching repository', error);
+            });
+            this.watcher.on('ready', () => {
+                console.log('Watching local repository for provider changes: %s', this.baseDir);
+            });
+        }
+        catch (e) {
+            // Fallback to run without watch mode due to potential platform issues.
+            // https://nodejs.org/docs/latest/api/fs.html#caveats
+            console.log('Unable to watch for changes. Changes to assets will not update automatically.', e);
+            return;
+        }
+    }
+    async setSourceOfChangeFor(file, source) {
+        this.sourceOfChange.set(file, source);
+        try {
+            const realPath = await fs_extra_1.default.realpath(file);
+            if (realPath !== file) {
+                this.sourceOfChange.set(realPath, source);
+            }
+        }
+        catch (e) {
+            // Ignore
+        }
+    }
+    async clearSourceOfChangeFor(file) {
+        this.sourceOfChange.delete(file);
+        try {
+            const realPath = await fs_extra_1.default.realpath(file);
+            if (realPath !== file) {
+                this.sourceOfChange.delete(realPath);
+            }
+        }
+        catch (e) {
+            // Ignore
+        }
+    }
+    async unwatch() {
+        if (!this.watcher) {
+            return;
+        }
+        this.symbolicLinks = {};
+        await this.watcher.close();
+        this.watcher = undefined;
+    }
+    async getAssetIdentity(path) {
+        const baseName = node_path_1.default.basename(path);
+        let handle, name, version;
+        if (path.startsWith(this.baseDir)) {
+            const relativePath = node_path_1.default.relative(this.baseDir, path);
+            // Inside the repo we can use the path to determine the handle, name and version
+            [handle, name, version] = relativePath.split(node_path_1.default.sep);
+            if (!handle || !name || !version) {
+                // Do nothing with this
+                return;
+            }
+            return {
+                handle,
+                name,
+                version,
+            };
+        }
+        if (!KAPETA_YML_RX.test(baseName)) {
+            // Do nothing with this
+            return;
+        }
+        // Outside the repo we need to use the file content to determine the handle, name
+        // Version is always 'local'
+        version = 'local';
+        try {
+            const definition = yaml_1.default.parse((await fs_extra_1.default.readFile(path)).toString());
+            const uri = (0, nodejs_utils_1.parseKapetaUri)(definition.metadata.name);
+            handle = uri.handle;
+            name = uri.name;
+            return {
+                handle,
+                name,
+                version,
+            };
+        }
+        catch (e) {
+            // Ignore issues in the YML file
+            return;
+        }
+    }
+    async handleFileChange(eventName, path) {
+        if (!path) {
+            return;
+        }
+        if (this.disabled) {
+            return;
+        }
+        const assetIdentity = await this.getAssetIdentity(path);
+        if (!assetIdentity) {
+            return;
+        }
+        // If this is false it's because we're watching a symlink target
+        const withinRepo = path.startsWith(this.baseDir);
+        if (withinRepo && assetIdentity.version === 'local' && path.endsWith(node_path_1.default.sep + 'local')) {
+            // This is likely a symlink target
+            if (eventName === 'add') {
+                //console.log('Checking if we should add symlink target', handle, name, version, path);
+                await this.addSymlinkTarget(path);
+            }
+            if (eventName === 'unlink') {
+                await this.removeSymlinkTarget(path);
+            }
+            if (eventName === 'change') {
+                await this.updateSymlinkTarget(path);
+            }
+        }
+        const repoPath = this.getRepositoryPath(assetIdentity);
+        if (eventName === 'change' &&
+            !withinRepo &&
+            assetIdentity.version === 'local' &&
+            node_path_1.default.basename(path) === 'kapeta.yml' &&
+            (await this.exists(path)) &&
+            !(await this.exists(repoPath))) {
+            // This happens when a local asset is renamed
+            const oldPath = lodash_1.default.findKey(this.symbolicLinks, (link) => link === path);
+            if (oldPath) {
+                await fs_extra_1.default.unlink(oldPath);
+                await assetManager_1.assetManager.importFile(path);
+                return;
+            }
+        }
+        const sourceOfChange = this.sourceOfChange.get(path) ?? 'filesystem';
+        await this.checkForChange(assetIdentity, sourceOfChange);
+        // We consume the sourceOfChange when the file is changed
+        this.sourceOfChange.delete(path);
+    }
+    getRepositoryPath(assetIdentity) {
+        return node_path_1.default.join(this.baseDir, assetIdentity.handle, assetIdentity.name, assetIdentity.version);
+    }
+    async checkForChange(assetIdentity, sourceOfChange) {
+        const ymlPath = node_path_1.default.join(this.getRepositoryPath(assetIdentity), 'kapeta.yml');
+        const newDefinitions = getDefinitionsDebounced();
+        const newDefinition = newDefinitions.find((d) => d.ymlPath === ymlPath);
+        let currentDefinition = this.allDefinitions.find((d) => d.ymlPath === ymlPath);
+        const ymlExists = await this.exists(ymlPath);
+        let type;
+        if (ymlExists) {
+            if (currentDefinition) {
+                if (newDefinition && lodash_1.default.isEqual(currentDefinition, newDefinition)) {
+                    //Definition was not changed
+                    return;
+                }
+                type = 'updated';
+            }
+            else if (newDefinition) {
+                type = 'added';
+                currentDefinition = newDefinition;
+            }
+            else {
+                //Other definition was added / updated - ignore
+                return;
+            }
+        }
+        else {
+            if (currentDefinition) {
+                //Something was removed
+                type = 'removed';
+            }
+            else {
+                //Other definition was removed - ignore
+                return;
+            }
+        }
+        const payload = {
+            type,
+            definition: newDefinition?.definition ?? currentDefinition?.definition,
+            asset: assetIdentity,
+            sourceOfChange,
+        };
+        this.allDefinitions = newDefinitions;
+        //console.log('Asset changed', payload);
+        socketManager_1.socketManager.emitGlobal('asset-change', payload);
+        this.emit('change', payload);
+        cacheManager_1.cacheManager.flush();
+    }
+    async exists(path) {
+        try {
+            await fs_extra_1.default.access(path);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    async removeSymlinkTarget(path) {
+        if (this.symbolicLinks[path]) {
+            //console.log('Unwatching symlink target %s => %s', path, this.symbolicLinks[path]);
+            this.watcher?.unwatch(this.symbolicLinks[path]);
+            delete this.symbolicLinks[path];
+        }
+    }
+    async updateSymlinkTarget(path) {
+        if (this.symbolicLinks[path]) {
+            //console.log('Updating symlink target %s => %s', path, this.symbolicLinks[path]);
+            this.watcher?.unwatch(this.symbolicLinks[path]);
+            delete this.symbolicLinks[path];
+            await this.addSymlinkTarget(path);
+        }
+    }
+    async addSymlinkTarget(path) {
+        try {
+            // Make sure we're not watching the symlink target
+            await this.removeSymlinkTarget(path);
+            let symbolicLink = false;
+            try {
+                const stat = await fs_extra_1.default.lstat(path);
+                symbolicLink = stat.isSymbolicLink();
+            }
+            catch (e) { }
+            if (symbolicLink) {
+                try {
+                    const realPath = node_path_1.default.join(await fs_extra_1.default.realpath(path), 'kapeta.yml');
+                    if (await this.exists(realPath)) {
+                        //console.log('Watching symlink target %s => %s', path, realPath);
+                        this.watcher?.add(realPath);
+                        this.symbolicLinks[path] = realPath;
+                    }
+                }
+                catch (e) {
+                    // Remove the symlink - it's broken
+                    await fs_extra_1.default.remove(path);
+                }
+            }
+        }
+        catch (e) {
+            // Ignore
+            console.warn('Failed to check local symlink target', e);
+        }
+    }
+    ignoreFile(path) {
+        if (!path.startsWith(this.baseDir)) {
+            return false;
+        }
+        if (path.includes(node_path_1.default.sep + 'node_modules' + node_path_1.default.sep)) {
+            return true;
+        }
+        const filename = node_path_1.default.basename(path);
+        if (filename.startsWith('.')) {
+            return true;
+        }
+        const relativePath = node_path_1.default.relative(this.baseDir, path).split(node_path_1.default.sep);
+        try {
+            if (fs_extra_1.default.statSync(path).isDirectory()) {
+                if (relativePath.length > 3) {
+                    return true;
+                }
+                return false;
+            }
+        }
+        catch (e) {
+            // Didn't exist - dont ignore
+            return false;
+        }
+        return !/^kapeta\.ya?ml$/.test(filename);
+    }
+}
+exports.RepositoryWatcher = RepositoryWatcher;

package/dist/cjs/src/ai/aiClient.d.ts

@@ -0,0 +1,20 @@
+import { PlanContext } from './transform';
+export type PromptResult = {
+    explanation: string;
+    response: string;
+    context?: PlanContext;
+};
+export interface AIMessage {
+    content: string;
+    role: 'user' | 'assistant';
+}
+export interface AIRequest {
+    messages: AIMessage[];
+}
+declare class AIClient {
+    private readonly _baseUrl;
+    constructor();
+    sendPrompt(handle: string, body: AIRequest): Promise<PromptResult>;
+}
+export declare const aiClient: AIClient;
+export {};

package/dist/cjs/src/ai/aiClient.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aiClient = void 0;
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+const request_1 = __importDefault(require("request"));
+const transform_1 = require("./transform");
+const nodejs_api_client_1 = require("@kapeta/nodejs-api-client");
+const utils_1 = require("../utils/utils");
+class AIClient {
+    _baseUrl;
+    constructor() {
+        this._baseUrl = (0, utils_1.getRemoteUrl)('ai-service', 'https://ai.kapeta.com');
+    }
+    async sendPrompt(handle, body) {
+        const url = `${this._baseUrl}/v1/plan?type=chat`;
+        const headers = {};
+        const api = new nodejs_api_client_1.KapetaAPI();
+        if (api.hasToken()) {
+            headers['Authorization'] = `Bearer ${await api.getAccessToken()}`;
+        }
+        const options = {
+            url,
+            method: 'POST',
+            json: true,
+            body,
+            headers,
+        };
+        return new Promise((resolve, reject) => {
+            (0, request_1.default)(options, async (error, response, application) => {
+                if (error) {
+                    console.error(error);
+                    reject(error);
+                }
+                if (response.statusCode !== 200) {
+                    console.log('Prompt failed', response.statusCode, response.body);
+                    reject(new Error(`Invalid response code: ${response.statusCode}`));
+                    return;
+                }
+                try {
+                    if (application?.name) {
+                        const planContext = await (0, transform_1.transformToPlan)(handle, application);
+                        resolve({
+                            explanation: application.explanation,
+                            response: application.response ?? application.explanation ?? 'Plan was generated',
+                            context: planContext,
+                        });
+                    }
+                    else {
+                        resolve({
+                            explanation: application.explanation,
+                            response: application.response ??
+                                application.explanation ??
+                                'I did not understand your request. Please rephrase.',
+                        });
+                    }
+                }
+                catch (err) {
+                    console.error(err);
+                    resolve({
+                        explanation: '',
+                        response: 'I did not understand your request. Please rephrase.',
+                    });
+                }
+            });
+        });
+    }
+}
+exports.aiClient = new AIClient();

package/dist/cjs/src/ai/routes.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+/// <reference types="express" />
+declare const router: import("express").Router;
+export default router;

package/dist/cjs/src/ai/routes.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_promise_router_1 = __importDefault(require("express-promise-router"));
+const cors_1 = require("../middleware/cors");
+const stringBody_1 = require("../middleware/stringBody");
+const aiClient_1 = require("./aiClient");
+const yaml_1 = __importDefault(require("yaml"));
+const router = (0, express_promise_router_1.default)();
+router.use('/', cors_1.corsHandler);
+router.use('/', stringBody_1.stringBody);
+router.post('/prompt/:handle', async (req, res) => {
+    const handle = req.params.handle;
+    try {
+        const aiRequest = JSON.parse(req.stringBody ?? '{}');
+        const result = await aiClient_1.aiClient.sendPrompt(handle, aiRequest);
+        if (req.accepts('application/yaml')) {
+            res.set('Content-Type', 'application/yaml');
+            res.send(yaml_1.default.stringify(result));
+        }
+        else {
+            res.json(result);
+        }
+    }
+    catch (err) {
+        console.error('Failed to send prompt', err);
+        res.status(400).send({ error: err.message });
+        return;
+    }
+});
+exports.default = router;

package/dist/cjs/src/ai/transform.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+import { BlockDefinition, Plan } from '@kapeta/schemas';
+import { Application } from './types';
+export type PlanContext = {
+    plan: Plan;
+    blocks: BlockDefinition[];
+};
+export declare const transformToPlan: (handle: string, application: Application) => Promise<PlanContext>;