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

package/dist/esm/src/definitionsManager.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+import { DefinitionInfo } from '@kapeta/local-cluster-config';
+export declare const SAMPLE_PLAN_NAME = "kapeta/sample-java-chat-plan";
+declare class DefinitionsManager {
+    private resolveDefinitionsAndSamples;
+    private prepareSample;
+    private applyFilters;
+    getDefinitions(kindFilter?: string | string[]): Promise<DefinitionInfo[]>;
+    exists(ref: string): Promise<boolean>;
+    getProviderDefinitions(): Promise<DefinitionInfo[]>;
+    getDefinition(ref: string): Promise<DefinitionInfo | undefined>;
+    getLatestDefinition(name: string): Promise<DefinitionInfo | undefined>;
+    getVersions(assetName: string): Promise<DefinitionInfo[]>;
+    clearCache(): void;
+}
+export declare const definitionsManager: DefinitionsManager;
+export {};

package/dist/esm/src/definitionsManager.js

@@ -0,0 +1,171 @@
+"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.definitionsManager = exports.SAMPLE_PLAN_NAME = void 0;
+const local_cluster_config_1 = __importDefault(require("@kapeta/local-cluster-config"));
+const nodejs_utils_1 = require("@kapeta/nodejs-utils");
+const cacheManager_1 = require("./cacheManager");
+const nodejs_api_client_1 = require("@kapeta/nodejs-api-client");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const yaml_1 = __importDefault(require("yaml"));
+const nodejs_registry_utils_1 = require("@kapeta/nodejs-registry-utils");
+const progressListener_1 = require("./progressListener");
+const path_1 = __importDefault(require("path"));
+exports.SAMPLE_PLAN_NAME = 'kapeta/sample-java-chat-plan';
+function getRenamed(definition, targetHandle) {
+    const originalUri = (0, nodejs_utils_1.parseKapetaUri)(definition.definition.metadata.name);
+    return `${targetHandle}/${originalUri.name}`;
+}
+function applyHandleChange(definition, targetHandle) {
+    definition.definition.metadata.name = getRenamed(definition, targetHandle);
+    // We also change the visibility to private
+    definition.definition.metadata.visibility = 'private';
+    return definition;
+}
+function normalizeFilters(kindFilter) {
+    let resolvedFilters = [];
+    if (kindFilter) {
+        if (Array.isArray(kindFilter)) {
+            resolvedFilters = [...kindFilter];
+        }
+        else {
+            resolvedFilters = [kindFilter];
+        }
+    }
+    return resolvedFilters.map((k) => k.toLowerCase());
+}
+class DefinitionsManager {
+    async resolveDefinitionsAndSamples() {
+        const definitions = local_cluster_config_1.default.getDefinitions();
+        const samplePlan = definitions.find((d) => d.version === 'local' && d.definition.metadata.name === exports.SAMPLE_PLAN_NAME);
+        if (!samplePlan) {
+            return definitions;
+        }
+        // We will only rewrite the sample plan once since we change the handle to be the users handle
+        const api = new nodejs_api_client_1.KapetaAPI();
+        if (!api.hasToken()) {
+            // Not logged in yet, so we can't rewrite the sample plan
+            return definitions;
+        }
+        const profile = await api.getCurrentIdentity();
+        if (!profile) {
+            // Not logged in yet, so we can't rewrite the sample plan
+            return definitions;
+        }
+        try {
+            await this.prepareSample(definitions, samplePlan, profile);
+        }
+        catch (e) {
+            console.warn('Failed to prepare sample plan', e);
+        }
+        // Return the rewritten definitions
+        return local_cluster_config_1.default.getDefinitions();
+    }
+    async prepareSample(definitions, samplePlan, profile) {
+        const newName = getRenamed(samplePlan, profile.handle);
+        if (definitions.some((d) => d.definition.metadata.name === newName && d.version === 'local')) {
+            // We already have a local version of the sample plan
+            return definitions;
+        }
+        console.log('Rewriting sample plan to use handle %s', profile.handle);
+        applyHandleChange(samplePlan, profile.handle);
+        const planDef = samplePlan.definition;
+        const blockRefs = new Set();
+        planDef.spec.blocks.forEach((b) => {
+            const blockUri = (0, nodejs_utils_1.parseKapetaUri)(b.block.ref);
+            if (blockUri.version === 'local') {
+                blockRefs.add(blockUri.id);
+                b.block.ref = (0, nodejs_utils_1.normalizeKapetaUri)(`${profile.handle}/${blockUri.name}:local`);
+            }
+        });
+        // Rewrite all blocks that are referenced by the sample plan
+        const rewrittenBlocks = Array.from(blockRefs)
+            .map((ref) => definitions.find((d) => (0, nodejs_utils_1.normalizeKapetaUri)(d.definition.metadata.name + ':' + d.version) === (0, nodejs_utils_1.normalizeKapetaUri)(ref)))
+            .filter((d) => d !== undefined)
+            .map((d) => applyHandleChange(d, profile.handle));
+        // Persist the rewritten assets
+        const progressListener = new progressListener_1.ProgressListener();
+        const rewrittenAssets = [samplePlan, ...rewrittenBlocks];
+        const originalRefs = [`${exports.SAMPLE_PLAN_NAME}:local`, ...Array.from(blockRefs)];
+        // Store the original paths on the assets - we'll need them later
+        for (const asset of rewrittenAssets) {
+            asset.path = await fs_extra_1.default.readlink(asset.path);
+            asset.ymlPath = path_1.default.join(asset.path, path_1.default.basename(asset.ymlPath));
+        }
+        // Uninstall the original assets
+        // This removes the symlinks
+        console.log('Uninstalling original assets', originalRefs);
+        try {
+            await nodejs_registry_utils_1.Actions.uninstall(progressListener, originalRefs);
+        }
+        catch (err) {
+            console.warn('Failed to uninstall original assets', err);
+        }
+        for (const asset of rewrittenAssets) {
+            console.log('Updating %s ', asset.ymlPath);
+            await fs_extra_1.default.writeFile(asset.ymlPath, yaml_1.default.stringify(asset.definition));
+            console.log('Linking %s ', asset.path);
+            await nodejs_registry_utils_1.Actions.link(progressListener, asset.path);
+        }
+        console.log('Rewrite done for sample plan');
+    }
+    applyFilters(definitions, kindFilter) {
+        if (kindFilter.length === 0) {
+            return definitions;
+        }
+        return definitions.filter((d) => {
+            return kindFilter.includes(d.definition.kind.toLowerCase());
+        });
+    }
+    async getDefinitions(kindFilter) {
+        kindFilter = normalizeFilters(kindFilter);
+        const definitions = await (0, cacheManager_1.doCached)('definitionsManager:all', () => this.resolveDefinitionsAndSamples());
+        return this.applyFilters(definitions, kindFilter);
+    }
+    async exists(ref) {
+        return !!(await this.getDefinition(ref));
+    }
+    async getProviderDefinitions() {
+        return (0, cacheManager_1.doCached)('definitionsManager:providers', () => local_cluster_config_1.default.getProviderDefinitions());
+    }
+    async getDefinition(ref) {
+        const uri = (0, nodejs_utils_1.parseKapetaUri)(ref);
+        const definitions = await this.getDefinitions();
+        return definitions.find((d) => {
+            if (!uri.version) {
+                return d.definition.metadata.name.toLowerCase() === uri.fullName.toLowerCase();
+            }
+            return (0, nodejs_utils_1.parseKapetaUri)(`${d.definition.metadata.name}:${d.version}`).equals(uri);
+        });
+    }
+    async getLatestDefinition(name) {
+        const definitions = await this.getDefinitions();
+        const allVersions = definitions.filter((d) => {
+            return d.version !== 'local' && d.definition.metadata.name === name;
+        });
+        if (allVersions.length === 0) {
+            return;
+        }
+        allVersions.sort((a, b) => {
+            return (0, nodejs_utils_1.parseVersion)(a.version).compareTo((0, nodejs_utils_1.parseVersion)(b.version)) * -1;
+        });
+        return allVersions[0];
+    }
+    async getVersions(assetName) {
+        const uri = (0, nodejs_utils_1.parseKapetaUri)(assetName);
+        const definitions = await this.getDefinitions();
+        return definitions.filter((d) => {
+            return d.definition.metadata.name === uri.fullName;
+        });
+    }
+    clearCache() {
+        cacheManager_1.cacheManager.removePrefix('definitionsManager:');
+    }
+}
+exports.definitionsManager = new DefinitionsManager();

package/dist/esm/src/filesystem/routes.d.ts

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

package/dist/esm/src/filesystem/routes.js

@@ -0,0 +1,105 @@
+"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 stringBody_1 = require("../middleware/stringBody");
+const filesystemManager_1 = require("../filesystemManager");
+const cors_1 = require("../middleware/cors");
+let router = (0, express_promise_router_1.default)();
+router.use('/', cors_1.corsHandler);
+router.get('/root', (req, res) => {
+    res.send(filesystemManager_1.filesystemManager.getRootFolder());
+});
+router.get('/project/root', (req, res) => {
+    res.send(filesystemManager_1.filesystemManager.getProjectRootFolder());
+});
+router.use('/project/root', stringBody_1.stringBody);
+router.post('/project/root', (req, res) => {
+    filesystemManager_1.filesystemManager.setProjectRootFolder(req.stringBody ?? '');
+    res.sendStatus(204);
+});
+router.get('/editor', (req, res) => {
+    res.send(filesystemManager_1.filesystemManager.getEditor());
+});
+router.use('/editor', stringBody_1.stringBody);
+router.post('/editor', (req, res) => {
+    filesystemManager_1.filesystemManager.setEditor(req.stringBody ?? '');
+    res.sendStatus(204);
+});
+router.get('/release-channel', (req, res) => {
+    res.send(filesystemManager_1.filesystemManager.getReleaseChannel());
+});
+router.use('/release-channel', stringBody_1.stringBody);
+router.post('/release-channel', (req, res) => {
+    filesystemManager_1.filesystemManager.setReleaseChannel(req.stringBody ?? '');
+    res.sendStatus(204);
+});
+router.get('/show-pixel-grid', (req, res) => {
+    res.send(filesystemManager_1.filesystemManager.getShowPixelGrid());
+});
+router.use('/show-pixel-grid', stringBody_1.stringBody);
+router.post('/show-pixel-grid', (req, res) => {
+    filesystemManager_1.filesystemManager.setShowPixelGrid(req?.stringBody === 'true' ?? false);
+    res.sendStatus(204);
+});
+router.get('/snap-to-pixel-grid', (req, res) => {
+    res.send(filesystemManager_1.filesystemManager.getSnapToPixelGrid());
+});
+router.use('/snap-to-pixel-grid', stringBody_1.stringBody);
+router.post('/snap-to-pixel-grid', (req, res) => {
+    filesystemManager_1.filesystemManager.setSnapToPixelGrid(req?.stringBody === 'true' ?? false);
+    res.sendStatus(204);
+});
+router.use('/', (req, res, next) => {
+    if (!req.query.path) {
+        res.status(400).send({ error: 'Missing required query parameter "path"' });
+        return;
+    }
+    next();
+});
+router.get('/list', async (req, res) => {
+    let pathArg = req.query.path;
+    try {
+        res.send(await filesystemManager_1.filesystemManager.readDirectory(pathArg));
+    }
+    catch (err) {
+        res.status(400).send({ error: '' + err });
+    }
+});
+router.get('/readfile', async (req, res) => {
+    let pathArg = req.query.path;
+    try {
+        res.send(await filesystemManager_1.filesystemManager.readFile(pathArg));
+    }
+    catch (err) {
+        res.status(400).send({ error: '' + err });
+    }
+});
+router.put('/mkdir', async (req, res) => {
+    let pathArg = req.query.path;
+    try {
+        await filesystemManager_1.filesystemManager.createFolder(pathArg);
+        res.sendStatus(204);
+    }
+    catch (err) {
+        res.status(400).send({ error: '' + err });
+    }
+});
+router.use('/writefile', stringBody_1.stringBody);
+router.post('/writefile', async (req, res) => {
+    let pathArg = req.query.path;
+    try {
+        await filesystemManager_1.filesystemManager.writeFile(pathArg, req.stringBody ?? '');
+        res.sendStatus(204);
+    }
+    catch (err) {
+        res.status(400).send({ error: '' + err });
+    }
+});
+exports.default = router;

package/dist/esm/src/filesystemManager.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+/// <reference types="node" />
+declare class FilesystemManager {
+    writeFile(path: string, data: string | Buffer): Promise<void>;
+    createFolder(path: string): Promise<void>;
+    readDirectory(path: string): Promise<{
+        path: string;
+        folder: boolean;
+    }[]>;
+    readFile(path: string): Promise<Buffer>;
+    getRootFolder(): string;
+    getProjectRootFolder(): string | undefined;
+    setProjectRootFolder(folder: string): void;
+    getEditor(): string | undefined;
+    setEditor(editor: string): void;
+    getReleaseChannel(): string | undefined;
+    setReleaseChannel(channel: string): void;
+    getShowPixelGrid(): boolean | undefined;
+    setShowPixelGrid(show: boolean): void;
+    getSnapToPixelGrid(): boolean | undefined;
+    setSnapToPixelGrid(snap: boolean): void;
+}
+export declare const filesystemManager: FilesystemManager;
+export {};

package/dist/esm/src/filesystemManager.js

@@ -0,0 +1,118 @@
+"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.filesystemManager = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const storageService_1 = require("./storageService");
+const SECTION_ID = 'filesystem';
+const PROJECT_ROOT = 'project_root';
+const EDITOR = 'editor';
+const RELEASE_CHANNEL = 'release_channel';
+const SHOW_PIXEL_GRID = 'show_pixel_grid';
+const SNAP_TO_PIXEL_GRID = 'snap_to_pixel_grid';
+function isFile(path) {
+    try {
+        return fs_1.default.statSync(path).isFile();
+    }
+    catch (error) {
+        return false;
+    }
+}
+class FilesystemManager {
+    async writeFile(path, data) {
+        const dirName = path_1.default.dirname(path);
+        if (!fs_1.default.existsSync(dirName)) {
+            fs_extra_1.default.mkdirpSync(dirName, {});
+        }
+        fs_1.default.writeFileSync(path, data);
+    }
+    async createFolder(path) {
+        return new Promise((resolve, reject) => {
+            fs_1.default.mkdir(path, (err) => {
+                if (err) {
+                    err.message += '. You can only create one single folder at a time.';
+                    reject(err.message);
+                    return;
+                }
+                resolve();
+            });
+        });
+    }
+    async readDirectory(path) {
+        return new Promise((resolve, reject) => {
+            let response = [];
+            fs_1.default.readdir(path, (err, files) => {
+                if (err) {
+                    reject(new Error(err));
+                    return;
+                }
+                files.forEach((file) => {
+                    response.push({
+                        path: path_1.default.join(path, file),
+                        folder: fs_1.default.lstatSync(path_1.default.join(path, file)).isDirectory(),
+                    });
+                });
+                resolve(response);
+            });
+        });
+    }
+    async readFile(path) {
+        return new Promise((resolve, reject) => {
+            if (!isFile(path)) {
+                reject(new Error('The path provided is invalid.Please check that the path and file name that were provided are spelled correctly. '));
+            }
+            else {
+                fs_1.default.readFile(path, (err, data) => {
+                    if (err) {
+                        reject(new Error(err.message));
+                        return;
+                    }
+                    resolve(data);
+                });
+            }
+        });
+    }
+    getRootFolder() {
+        return require('os').homedir();
+    }
+    getProjectRootFolder() {
+        return storageService_1.storageService.get(SECTION_ID, PROJECT_ROOT);
+    }
+    setProjectRootFolder(folder) {
+        storageService_1.storageService.put(SECTION_ID, PROJECT_ROOT, folder);
+    }
+    getEditor() {
+        return storageService_1.storageService.get(SECTION_ID, EDITOR);
+    }
+    setEditor(editor) {
+        storageService_1.storageService.put(SECTION_ID, EDITOR, editor);
+    }
+    // Should we put this in its own manager service?
+    getReleaseChannel() {
+        return storageService_1.storageService.get('app', RELEASE_CHANNEL);
+    }
+    setReleaseChannel(channel) {
+        storageService_1.storageService.put('app', RELEASE_CHANNEL, channel);
+    }
+    getShowPixelGrid() {
+        return storageService_1.storageService.get('app', SHOW_PIXEL_GRID, true);
+    }
+    setShowPixelGrid(show) {
+        storageService_1.storageService.put('app', SHOW_PIXEL_GRID, show);
+    }
+    getSnapToPixelGrid() {
+        return storageService_1.storageService.get('app', SNAP_TO_PIXEL_GRID, false);
+    }
+    setSnapToPixelGrid(snap) {
+        storageService_1.storageService.put('app', SNAP_TO_PIXEL_GRID, snap);
+    }
+}
+exports.filesystemManager = new FilesystemManager();

package/dist/esm/src/identities/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/esm/src/identities/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 nodejs_api_client_1 = require("@kapeta/nodejs-api-client");
+const cors_1 = require("../middleware/cors");
+const router = (0, express_promise_router_1.default)();
+router.use('/', cors_1.corsHandler);
+router.get('/current', async (req, res) => {
+    const api = new nodejs_api_client_1.KapetaAPI();
+    if (api.hasToken()) {
+        try {
+            res.json(await api.getCurrentIdentity());
+            return;
+        }
+        catch (e) {
+            console.error(e);
+        }
+    }
+    res.status(200).json(null);
+});
+router.get('/:identityId/memberships', async (req, res) => {
+    const api = new nodejs_api_client_1.KapetaAPI();
+    if (api.hasToken()) {
+        res.send(await api.getMemberships(req.params.identityId));
+    }
+    else {
+        res.send([]);
+    }
+});
+exports.default = router;

package/dist/esm/src/instanceManager.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+import { EnvironmentType, InstanceInfo, LogEntry } from './types';
+import { Task } from './taskManager';
+import { InstanceOperator } from '@kapeta/sdk-config';
+export declare class InstanceManager {
+    private _interval;
+    private readonly _instances;
+    private readonly instanceLocks;
+    constructor();
+    private checkInstancesLater;
+    getInstances(): InstanceInfo[];
+    getInstancesForPlan(systemId: string): Promise<InstanceInfo[]>;
+    getInstance(systemId: string, instanceId: string): InstanceInfo | undefined;
+    private exclusive;
+    private isLocked;
+    getLogs(systemId: string, instanceId: string): Promise<LogEntry[]>;
+    saveInternalInstance(instance: InstanceInfo): Promise<InstanceInfo>;
+    /**
+     * Method is called when instance is started from the Kapeta SDKs (e.g. NodeJS SDK)
+     * which self-registers with the cluster service locally on startup.
+     */
+    registerInstanceFromSDK(systemId: string, instanceId: string, info: Omit<InstanceInfo, 'systemId' | 'instanceId'>): Promise<InstanceInfo | undefined>;
+    private getHealthUrl;
+    markAsStopped(systemId: string, instanceId: string): Promise<void>;
+    startAllForPlan(systemId: string): Promise<Task<InstanceInfo[]>>;
+    stopAllForPlan(systemId: string): Task<void>;
+    getInstanceOperator(systemId: string, instanceId: string, environment?: EnvironmentType, ensureContainer?: boolean): Promise<InstanceOperator<any, any>>;
+    stop(systemId: string, instanceId: string): Promise<void>;
+    private stopInner;
+    start(systemId: string, instanceId: string, checkForSingleton?: boolean): Promise<InstanceInfo | Task<InstanceInfo>>;
+    /**
+     * Stops an instance but does not remove it from the list of active instances
+     *
+     * It will be started again next time the system checks the status of the instance
+     *
+     * We do it this way to not cause the user to wait for the instance to start again
+     */
+    prepareForRestart(systemId: string, instanceId: string): Promise<void>;
+    stopAll(): Promise<void>;
+    private stopInstances;
+    private save;
+    private checkInstances;
+    private getExternalStatus;
+    private requestInstanceStatus;
+    private isSingletonOperator;
+    private getKindForAssetRef;
+    /**
+     * Get the kind of an asset. Use the maxDepth parameter to specify how deep to look for the
+     * kind. For example, if maxDepth is 2, the method will look for the kind of the asset and then
+     * the kind of the kind.
+     * @param assetRef The asset reference
+     * @param maxDepth The maximum depth to look for the kind
+     * @returns The kind of the asset or null if not found
+     */
+    private getDeepKindForAssetRef;
+    private isUsingKind;
+    private getAllInstancesForKind;
+    /**
+     * Get the ids for all block instances except the ones of the specified kind
+     * @param systemId The plan reference id
+     * @param kind The kind to exclude. Can be a string or an array of strings
+     * @returns An array of block instance ids
+     */
+    private getAllInstancesExceptKind;
+}
+export declare const instanceManager: InstanceManager;