@kapeta/local-cluster-service 0.43.3 → 0.45.0

package/src/storm/events.ts

@@ -0,0 +1,169 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+
+export type StormResourceType =
+    | 'API'
+    | 'DATABASE'
+    | 'CLIENT'
+    | 'JWTPROVIDER'
+    | 'JWTCONSUMER'
+    | 'WEBFRAGMENT'
+    | 'WEBPAGE'
+    | 'SMTPCLIENT'
+    | 'EXTERNAL_API'
+    | 'SUBSCRIBER'
+    | 'PUBLISHER'
+    | 'QUEUE'
+    | 'EXCHANGE';
+
+export type StormBlockType = 'BACKEND' | 'FRONTEND' | 'GATEWAY' | 'MQ' | 'CLI' | 'DESKTOP';
+
+export interface StormBlockInfo {
+    type: StormBlockType;
+    name: string;
+    description: string;
+    resources: {
+        type: StormResourceType;
+        name: string;
+        description: string;
+    }[];
+}
+
+export interface StormBlockInfoFilled extends StormBlockInfo {
+    apis: string[];
+    types: string[];
+    models: string[];
+    screens: ScreenTemplate[];
+}
+
+export interface StormEventCreateBlock {
+    type: 'CREATE_BLOCK';
+    reason: string;
+    created: number;
+    payload: StormBlockInfo;
+}
+
+export interface StormConnection {
+    fromComponent: string;
+    fromResource: string;
+    fromResourceType: StormResourceType;
+    toComponent: string;
+    toResource: string;
+    toResourceType: StormResourceType;
+}
+
+export interface StormEventCreateConnection {
+    type: 'CREATE_CONNECTION';
+    reason: string;
+    created: number;
+    payload: StormConnection;
+}
+
+export interface StormEventCreatePlanProperties {
+    type: 'CREATE_PLAN_PROPERTIES';
+    reason: string;
+    created: number;
+    payload: {
+        name: string;
+        description: string;
+    };
+}
+
+export interface StormEventInvalidResponse {
+    type: 'INVALID_RESPONSE';
+    reason: string;
+    created: number;
+    payload: {
+        error: string;
+    };
+}
+
+export interface StormEventPlanRetry {
+    type: 'PLAN_RETRY' | 'PLAN_RETRY_FAILED';
+    reason: string;
+    created: number;
+    payload: {
+        error: string;
+    };
+}
+
+export interface StormEventCreateDSL {
+    type: 'CREATE_API' | 'CREATE_TYPE' | 'CREATE_MODEL';
+    reason: string;
+    created: number;
+    payload: {
+        blockName: string;
+        content: string;
+    };
+}
+
+export interface StormEventError {
+    type: 'INVALID_RESPONSE' | 'ERROR_INTERNAL';
+    reason: string;
+    created: number;
+    payload: {
+        error: string;
+    };
+}
+
+export interface ScreenTemplate {
+    name: string;
+    template: string;
+    description: string;
+    url: string;
+}
+
+export interface StormEventScreen {
+    type: 'SCREEN';
+    reason: string;
+    created: number;
+    payload: {
+        blockName: string;
+        name: string;
+        template: string;
+        description: string;
+        url: string;
+    };
+}
+
+export interface StormEventScreenCandidate {
+    type: 'SCREEN_CANDIDATE';
+    reason: string;
+    created: number;
+    payload: {
+        name: string;
+        description: string;
+        url: string;
+    };
+}
+
+export interface StormEventFile {
+    type: 'FILE';
+    reason: string;
+    created: number;
+    payload: {
+        filename: string;
+        content: string;
+        blockRef: string;
+    };
+}
+
+export interface StormEventDone {
+    type: 'DONE';
+    created: number;
+}
+
+export type StormEvent =
+    | StormEventCreateBlock
+    | StormEventCreateConnection
+    | StormEventCreatePlanProperties
+    | StormEventInvalidResponse
+    | StormEventPlanRetry
+    | StormEventCreateDSL
+    | StormEventError
+    | StormEventScreen
+    | StormEventScreenCandidate
+    | StormEventFile
+    | StormEventDone;

package/src/storm/routes.ts

@@ -0,0 +1,143 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+
+import Router from 'express-promise-router';
+import { Response } from 'express';
+import { corsHandler } from '../middleware/cors';
+import { stringBody } from '../middleware/stringBody';
+import { KapetaBodyRequest } from '../types';
+import { StormContextRequest, StormFileImplementationPrompt, StormFileInfo, StormStream } from './stream';
+import { stormClient } from './stormClient';
+import { StormEvent } from './events';
+import { resolveOptions, StormEventParser } from './event-parser';
+import { StormCodegen } from './codegen';
+
+const router = Router();
+
+router.use('/', corsHandler);
+router.use('/', stringBody);
+
+router.post('/:handle/all', async (req: KapetaBodyRequest, res: Response) => {
+    const handle = req.params.handle;
+
+    try {
+        const stormOptions = await resolveOptions();
+
+        const eventParser = new StormEventParser(stormOptions);
+
+        console.log('Got prompt', req.stringBody);
+        const aiRequest: StormContextRequest = JSON.parse(req.stringBody ?? '{}');
+        const metaStream = await stormClient.createMetadata(aiRequest.prompt, aiRequest.history);
+
+        res.set('Content-Type', 'application/x-ndjson');
+
+        metaStream.on('data', (data: StormEvent) => {
+            eventParser.addEvent(data);
+        });
+
+        await streamStormPartialResponse(metaStream, res);
+
+        if (!eventParser.isValid()) {
+            // We can't continue if the meta stream is invalid
+            res.write({
+                type: 'ERROR_INTERNAL',
+                payload: { error: eventParser.getError() },
+                reason: 'Failed to generate system',
+                created: Date.now(),
+            } satisfies StormEvent);
+            res.end();
+            return;
+        }
+        const result = eventParser.toResult(handle);
+
+        console.log('RESULT\n', JSON.stringify(result, null, 2));
+
+        const stormCodegen = new StormCodegen(aiRequest.prompt, result.blocks);
+
+        const codegenStream = streamStormPartialResponse(stormCodegen.getStream(), res);
+
+        await stormCodegen.process();
+
+        await codegenStream;
+
+        sendDone(res);
+    } catch (err: any) {
+        sendError(err, res);
+    }
+});
+
+router.post('/metadata', async (req: KapetaBodyRequest, res: Response) => {
+    const aiRequest: StormContextRequest = JSON.parse(req.stringBody ?? '{}');
+    const result = await stormClient.createMetadata(aiRequest.prompt, aiRequest.history);
+
+    await streamStormResponse(result, res);
+});
+
+router.post('/services/implement', async (req: KapetaBodyRequest, res: Response) => {
+    const aiRequest: StormContextRequest<StormFileImplementationPrompt> = JSON.parse(req.stringBody ?? '{}');
+    const result = await stormClient.createServiceImplementation(aiRequest.prompt, aiRequest.history);
+
+    await streamStormResponse(result, res);
+});
+
+router.post('/ui/implement', async (req: KapetaBodyRequest, res: Response) => {
+    const aiRequest: StormContextRequest<StormFileImplementationPrompt> = JSON.parse(req.stringBody ?? '{}');
+    const result = await stormClient.createUIImplementation(aiRequest.prompt, aiRequest.history);
+
+    await streamStormResponse(result, res);
+});
+
+async function streamStormResponse(result: StormStream, res: Response) {
+    res.set('Content-Type', 'application/x-ndjson');
+
+    await streamStormPartialResponse(result, res);
+
+    sendDone(res);
+}
+
+function sendDone(res: Response) {
+    res.write(
+        JSON.stringify({
+            type: 'DONE',
+            created: Date.now(),
+        } satisfies StormEvent) + '\n'
+    );
+
+    res.end();
+}
+
+function sendError(err: Error, res: Response) {
+    console.error('Failed to send prompt', err);
+    if (res.headersSent) {
+        res.write(
+            JSON.stringify({
+                type: 'ERROR_INTERNAL',
+                created: Date.now(),
+                payload: { error: err.message },
+                reason: 'Failed while sending prompt',
+            } satisfies StormEvent) + '\n'
+        );
+    } else {
+        res.status(400).send({ error: err.message });
+    }
+}
+
+function streamStormPartialResponse(result: StormStream, res: Response) {
+    return new Promise<void>((resolve, reject) => {
+        result.on('data', (data) => {
+            res.write(JSON.stringify(data) + '\n');
+        });
+
+        result.on('error', (err) => {
+            reject(err);
+        });
+
+        result.on('end', () => {
+            resolve();
+        });
+    });
+}
+
+export default router;

package/src/storm/stormClient.ts

@@ -0,0 +1,114 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+import { KapetaAPI } from '@kapeta/nodejs-api-client';
+import { getRemoteUrl } from '../utils/utils';
+import readLine from 'node:readline/promises';
+import { Readable } from 'node:stream';
+import {
+    ConversationItem,
+    StormContextRequest,
+    StormFileImplementationPrompt,
+    StormFileInfo,
+    StormStream,
+} from './stream';
+
+export const STORM_ID = 'storm';
+
+class StormClient {
+    private readonly _baseUrl: string;
+
+    constructor() {
+        this._baseUrl = getRemoteUrl('ai-service', 'https://ai.kapeta.com');
+    }
+
+    private createOptions(path: string, method: string, body: StormContextRequest): RequestInit & { url: string } {
+        const url = `${this._baseUrl}${path}`;
+        const headers: { [k: string]: string } = {
+            'Content-Type': 'application/json',
+        };
+        const api = new KapetaAPI();
+        if (api.hasToken()) {
+            //headers['Authorization'] = `Bearer ${api.getAccessToken()}`; //TODO: Enable authentication
+        }
+
+        return {
+            url,
+            method: method,
+            body: JSON.stringify(body),
+            headers,
+        };
+    }
+
+    private async send<T = string>(
+        path: string,
+        body: StormContextRequest<T>,
+        method: string = 'POST'
+    ): Promise<StormStream> {
+        const stringPrompt = typeof body.prompt === 'string' ? body.prompt : JSON.stringify(body.prompt);
+
+        const options = this.createOptions(path, method, {
+            prompt: stringPrompt,
+            history: body.history,
+        });
+
+        const out = new StormStream(stringPrompt, body.history);
+
+        const response = await fetch(options.url, options);
+
+        if (response.status !== 200) {
+            throw new Error(
+                `Got error response from ${options.url}: ${response.status}\nContent: ${await response.text()}`
+            );
+        }
+
+        const jsonLStream = readLine.createInterface(Readable.fromWeb(response.body!));
+
+        jsonLStream.on('line', (line) => {
+            out.addJSONLine(line);
+        });
+
+        jsonLStream.on('error', (error) => {
+            out.emit('error', error);
+        });
+
+        jsonLStream.on('pause', () => {
+            console.log('paused');
+        });
+
+        jsonLStream.on('resume', () => {
+            console.log('resumed');
+        });
+
+        jsonLStream.on('close', () => {
+            out.end();
+        });
+
+        return out;
+    }
+
+    public createMetadata(prompt: string, history?: ConversationItem[]) {
+        return this.send('/v2/all', {
+            history: history ?? [],
+            prompt: prompt,
+        });
+    }
+
+    public createUIImplementation(prompt: StormFileImplementationPrompt, history?: ConversationItem[]) {
+        return this.send<StormFileImplementationPrompt>('/v2/ui/merge', {
+            history: history ?? [],
+            prompt,
+        });
+    }
+
+    public createServiceImplementation(prompt: StormFileImplementationPrompt, history?: ConversationItem[]) {
+        console.log('SENDING SERVICE PROMPT', JSON.stringify(prompt, null, 2));
+        return this.send<StormFileImplementationPrompt>('/v2/services/merge', {
+            history: history ?? [],
+            prompt,
+        });
+    }
+}
+
+export const stormClient = new StormClient();

package/src/storm/stream.ts

@@ -0,0 +1,88 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+import { EventEmitter } from 'node:events';
+import { StormEvent } from './events';
+import { AIFileTypes, GeneratedFile } from '@kapeta/codegen';
+
+export class StormStream extends EventEmitter {
+    private history: ConversationItem[];
+    private lines: string[] = [];
+
+    constructor(prompt: string = '', history?: ConversationItem[]) {
+        super();
+        this.history = history ?? [];
+        this.history.push({
+            role: 'user',
+            content: prompt,
+        });
+    }
+
+    addJSONLine(line: string) {
+        try {
+            this.lines.push(line);
+            const event = JSON.parse(line);
+            if (!event.created) {
+                event.created = Date.now();
+            }
+            this.emit('data', event);
+        } catch (e: any) {
+            this.emit('error', e);
+        }
+    }
+
+    end() {
+        this.history.push({
+            role: 'model',
+            content: this.lines.join('\n'),
+        });
+        this.emit('end');
+    }
+
+    on(event: 'end', listener: () => void): this;
+    on(event: 'error', listener: (e: Error) => void): this;
+    on(event: 'data', listener: (data: StormEvent) => void): this;
+    on(event: string, listener: (...args: any[]) => void): this {
+        return super.on(event, listener);
+    }
+
+    emit(event: 'end'): boolean;
+    emit(event: 'error', e: Error): boolean;
+    emit(event: 'data', data: StormEvent): boolean;
+    emit(eventName: string | symbol, ...args: any[]): boolean {
+        return super.emit(eventName, ...args);
+    }
+
+    waitForDone() {
+        return new Promise<void>((resolve, reject) => {
+            this.on('error', (err) => {
+                reject(err);
+            });
+
+            this.on('end', () => {
+                resolve();
+            });
+        });
+    }
+}
+
+export interface ConversationItem {
+    role: 'user' | 'model';
+    content: string;
+}
+
+export interface StormContextRequest<T = string> {
+    history?: ConversationItem[];
+    prompt: T;
+}
+
+export interface StormFileInfo extends GeneratedFile {
+    type: AIFileTypes;
+}
+
+export interface StormFileImplementationPrompt {
+    context: StormFileInfo[];
+    template: StormFileInfo;
+    prompt: string;
+}

package/src/types.ts

@@ -7,6 +7,7 @@ import express from 'express';
 import { Connection, Resource } from '@kapeta/schemas';
 import { StringBodyRequest } from './middleware/stringBody';
 import { KapetaRequest } from './middleware/kapeta';
+import { EnrichedAsset } from './assetManager';
 
 export const KIND_RESOURCE_OPERATOR = 'core/resource-type-operator';
 export const KIND_BLOCK_TYPE = 'core/block-type';
@@ -90,9 +91,11 @@ export type ProxyRequestHandler = (req: StringBodyRequest, res: express.Response
 export interface ProxyRequestInfo {
     address: string;
     connection: Connection;
-    providerResource: Resource;
-    consumerResource: Resource;
     consumerPath: string;
+    consumerResource: Resource;
+    consumerBlockAsset: EnrichedAsset;
+    providerResource: Resource;
+    providerBlockAsset: EnrichedAsset;
 }
 
 export interface SimpleResponse {

package/src/utils/BlockInstanceRunner.ts

@@ -367,12 +367,14 @@ export class BlockInstanceRunner {
                             // If the bind is optional, we skip it if the host path does not exist
                             options = options.filter((opt) => opt !== 'optional');
                             if (!FSExtra.existsSync(host)) {
-                                console.log(`Skipping optional bind: ${bind} for block: ${blockInstance.id}`)
+                                console.log(`Skipping optional bind: ${bind} for block: ${blockInstance.id}`);
                                 return '';
                             }
                         }
 
-                        return `${toLocalBindVolume(host)}:${container}${options.length > 0 ? ':' + options.join(':') : ''}`;
+                        return `${toLocalBindVolume(host)}:${container}${
+                            options.length > 0 ? ':' + options.join(':') : ''
+                        }`;
                     }).filter((bind: string) => Boolean(bind)),
                 ],
                 PortBindings,