fix(core): update

package.json

@@ -10,23 +10,24 @@
   "license": "MIT",
   "scripts": {
     "test": "(tstest test/)",
-    "start": "(node --max_old_space_size=100 ./cli.js)",
+    "start": "(node --max_old_space_size=250 ./cli.js)",
     "startTs": "(node cli.ts.js)",
     "localPublish": ""
   },
   "devDependencies": {
     "@git.zone/tsbuild": "^2.1.17",
     "@git.zone/tsrun": "^1.2.8",
-    "@git.zone/tstest": "^1.0.28",
+    "@git.zone/tstest": "^1.0.88",
     "@git.zone/tswatch": "^2.0.1",
-    "@push.rocks/tapbundle": "^5.0.3"
+    "@push.rocks/tapbundle": "^5.0.17"
   },
   "dependencies": {
-    "@api.global/typedrequest": "^3.0.4",
-    "@api.global/typedserver": "^3.0.20",
+    "@anthropic-ai/sdk": "^0.18.0",
+    "@api.global/typedrequest": "^3.0.19",
+    "@api.global/typedserver": "^3.0.27",
     "@api.global/typedsocket": "^3.0.0",
     "@apiclient.xyz/cloudflare": "^6.0.3",
-    "@apiclient.xyz/letterxpress": "^1.0.16",
+    "@apiclient.xyz/letterxpress": "^1.0.17",
     "@push.rocks/projectinfo": "^5.0.1",
     "@push.rocks/qenv": "^6.0.5",
     "@push.rocks/smartdata": "^5.0.7",
@@ -38,10 +39,11 @@
     "@push.rocks/smartrequest": "^2.0.21",
     "@push.rocks/smartrx": "^3.0.7",
     "@push.rocks/smartstate": "^2.0.0",
-    "@serve.zone/interfaces": "^1.0.34",
-    "@tsclass/tsclass": "^4.0.51",
+    "@serve.zone/interfaces": "^1.0.47",
+    "@tsclass/tsclass": "^4.0.52",
     "mailauth": "^4.6.5",
-    "mailparser": "^3.6.7",
+    "mailparser": "^3.6.9",
+    "openai": "^4.29.1",
     "uuid": "^9.0.1"
   }
 }

test/test.ts

@@ -0,0 +1,5 @@
+import { tap, expect } from '@push.rocks/tapbundle';
+
+tap.test('should create a platform service', async () => {});
+
+tap.start();

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@serve.zone/platformservice',
-  version: '1.0.6',
+  version: '1.0.7',
   description: 'contains the platformservice container with mail, sms, letter, ai services.'
 }

ts/aibridge/aibridge.classes.aibridge.ts

@@ -0,0 +1,50 @@
+import * as plugins from './aibridge.plugins.js';
+import * as paths from './aibridge.paths.js';
+import { AiBridgeDb } from './aibridge.classes.aibridgedb.js';
+import { OpenAiBridge } from './aibridge.classes.openaibridge.js';
+
+export class AiBridge {
+  public projectinfo: plugins.projectinfo.ProjectInfo;
+  public serverInstance: plugins.loleServiceserver.ServiceServer;
+  public serviceQenv = new plugins.qenv.Qenv('./', './.nogit');
+  public aibridgeDb: AiBridgeDb;
+
+  public openAiBridge: OpenAiBridge;
+
+  public typedrouter = new plugins.typedrequest.TypedRouter();
+
+  public async start() {
+    this.aibridgeDb = new AiBridgeDb(this);
+    await this.aibridgeDb.start();
+    this.projectinfo = new plugins.projectinfo.ProjectInfo(paths.packageDir);
+    this.openAiBridge = new OpenAiBridge(this);
+    await this.openAiBridge.start();
+
+    // server
+    this.serverInstance = new plugins.loleServiceserver.ServiceServer({
+      serviceDomain: 'aibridge.lossless.one',
+      serviceName: 'aibridge',
+      serviceVersion: this.projectinfo.npm.version,
+      addCustomRoutes: async (serverArg) => {
+        // any custom route configs go here
+      },
+    });
+
+    // lets implemenet the actual typedrequest functions
+    this.typedrouter.addTypedHandler<plugins.lointAiBridge.requests.IReq_Chat>(new plugins.typedrequest.TypedHandler('chat', async reqArg => {
+      const resultChat = await this.openAiBridge.chat(reqArg.chat.systemMessage, reqArg.chat.messages[reqArg.chat.messages.length - 1].content, reqArg.chat.messages);
+      return {
+        chat: reqArg.chat,
+        latestMessage: resultChat.message.content,
+      }
+    }))
+
+    await this.serverInstance.start();
+    this.serverInstance.typedServer.typedrouter.addTypedRouter(this.typedrouter);
+  }
+
+  public async stop() {
+    await this.serverInstance.stop();
+    await this.aibridgeDb.stop();
+  }
+}

ts/aibridge/aibridge.classes.aibridgedb.ts

@@ -0,0 +1,25 @@
+import * as plugins from './aibridge.plugins.js';
+import { AiBridge } from './aibridge.classes.aibridge.js';
+
+export class AiBridgeDb {
+  public smartdataDb: plugins.smartdata.SmartdataDb;
+  public aibridgeRef: AiBridge;
+
+  constructor(aibridgeRefArg: AiBridge) {
+    this.aibridgeRef = aibridgeRefArg;
+  }
+
+  public async start() {
+    this.smartdataDb = new plugins.smartdata.SmartdataDb({
+      mongoDbUser: await this.aibridgeRef.serviceQenv.getEnvVarOnDemand('MONGO_DB_USER'),
+      mongoDbName: await this.aibridgeRef.serviceQenv.getEnvVarOnDemand('MONGO_DB_NAME'),
+      mongoDbPass: await this.aibridgeRef.serviceQenv.getEnvVarOnDemand('MONGO_DB_PASS'),
+      mongoDbUrl: await this.aibridgeRef.serviceQenv.getEnvVarOnDemand('MONGO_DB_URL'),
+    });
+    await this.smartdataDb.init();
+  }
+
+  public async stop() {
+    await this.smartdataDb.close();
+  }
+}

ts/aibridge/aibridge.classes.openaibridge.ts

@@ -0,0 +1,58 @@
+import { AiBridge } from './aibridge.classes.aibridge.js';
+import * as plugins from './aibridge.plugins.js';
+import * as paths from './aibridge.paths.js';
+
+export class OpenAiBridge {
+  public aiBridgeRef: AiBridge;
+  public openAiApiClient: plugins.openai.default;
+  constructor(aiBridgeRefArg: AiBridge) {
+    this.aiBridgeRef = aiBridgeRefArg;
+  }
+
+  public async start() {
+    const openAiToken = await this.aiBridgeRef.serviceQenv.getEnvVarOnDemand('OPENAI_TOKEN');
+    this.openAiApiClient = new plugins.openai.default({
+      apiKey: openAiToken,
+      dangerouslyAllowBrowser: true,
+    });
+  }
+
+  public async stop() {}
+
+  public async chat(
+    systemMessage: string,
+    userMessage: string,
+    messageHistory: {
+      role: 'assistant' | 'user';
+      content: string;
+    }[]
+  ) {
+    const result = await this.openAiApiClient.chat.completions.create({
+      model: 'gpt-3.5-turbo-16k-0613',
+      messages: [
+        { role: 'system', content: systemMessage },
+        ...messageHistory,
+        { role: 'user', content: userMessage },
+      ],
+    });
+    return {
+      message: result.choices[0].message,
+    };
+  }
+
+  public async audio(messageArg: string) {
+    const done = plugins.smartpromise.defer();
+    const result = await this.openAiApiClient.audio.speech.create({
+      model: 'tts-1-hd',
+      input: messageArg,
+      voice: 'nova',
+      response_format: 'mp3',
+      speed: 1,
+    });
+    const stream = result.body.pipe(plugins.smartfile.fsStream.createWriteStream(plugins.path.join(paths.nogitDir, 'output.mp3')));
+    stream.on('finish', () => {
+      done.resolve();
+    });
+    return done.promise;
+  }
+}

ts/aibridge/aibridge.paths.ts

@@ -0,0 +1,16 @@
+import * as plugins from './aibridge.plugins.js';
+
+export const packageDir = plugins.path.join(
+  plugins.smartpath.get.dirnameFromImportMetaUrl(import.meta.url),
+  '../'
+);
+
+export const assetsDir = plugins.path.join(
+  packageDir,
+  './assets/'
+);
+
+export const nogitDir = plugins.path.join(
+  packageDir,
+  './.nogit/'
+);

ts/aibridge/aibridge.plugins.ts

@@ -0,0 +1,32 @@
+// node native
+import * as path from 'path';
+
+export { path };
+
+// @losslessone_private scope
+import * as loleServiceserver from '@losslessone_private/lole-serviceserver';
+import * as lointAiBridge from '@losslessone_private/loint-aibridge';
+
+export { loleServiceserver, lointAiBridge };
+
+// apiglobal scope
+import * as typedrequest from '@api.global/typedrequest';
+
+export {
+  typedrequest,
+}
+
+// pushrocks scope
+import * as projectinfo from '@push.rocks/projectinfo';
+import * as qenv from '@push.rocks/qenv';
+import * as smartdata from '@push.rocks/smartdata';
+import * as smartfile from '@push.rocks/smartfile';
+import * as smartpath from '@push.rocks/smartpath';
+import * as smartpromise from '@push.rocks/smartpromise';
+
+export { projectinfo, qenv, smartdata, smartfile, smartpath, smartpromise };
+
+// thirdparty scope
+import * as antrophic from '@anthropic-ai/sdk';
+import * as openai from 'openai';
+export { antrophic as anthropic, openai };

ts/aibridge/index.ts

@@ -0,0 +1,17 @@
+import { AiBridge } from './aibridge.classes.aibridge.js';
+
+export {
+  AiBridge,
+}
+
+let aibridgeInstance: AiBridge;
+export const runCli = async () => {
+  aibridgeInstance = new AiBridge();
+  await aibridgeInstance.start();
+};
+
+export const stop = async () => {
+  if (aibridgeInstance) {
+    await aibridgeInstance.stop();
+  }
+};

ts/letter/classes.letterservice.ts

@@ -9,9 +9,33 @@ export interface ILetterConstructorOptions {
 export class LetterService {
   public platformServiceRef: SzPlatformService;
   public options: ILetterConstructorOptions;
+  public letterxpressAccount: plugins.letterxpress.LetterXpressAccount;
+  public typedrouter = new plugins.typedrequest.TypedRouter();
 
   constructor(platformServiceRefArg: SzPlatformService, optionsArg: ILetterConstructorOptions) {
     this.platformServiceRef = platformServiceRefArg;
     this.options = optionsArg;
+    this.platformServiceRef.typedrouter.addTypedRouter(this.typedrouter);
+
+    this.typedrouter.addTypedHandler<
+      plugins.servezoneInterfaces.platformservice.letter.IRequest_SendLetter
+    >(new plugins.typedrequest.TypedHandler('sendLetter', async dataArg => {
+      if(dataArg.needsCover) {
+        
+      }
+      return {
+        processId: '',
+      }
+    }));
   }
+
+  public async start() {
+    this.letterxpressAccount = new plugins.letterxpress.LetterXpressAccount({
+      username: this.options.letterxpressUser,
+      apiKey: this.options.letterxpressToken,
+    });
+    await this.letterxpressAccount.start();
+  }
+
+  public async stop() {}
 }