deploy (#34)

* try to deploy next

* bind webhook almost working

* lint

* health check endpoint

* sanitize rsa key

* add kv test

* remove chache from health

* health log

* health log

Author: jurgob

.gitignore

@@ -28,6 +28,7 @@ yarn-error.log*
 .env.development.local
 .env.test.local
 .env.production.local
+.env.deploy*
 
 # turbo
 .turbo

fly.toml

@@ -0,0 +1,22 @@
+# fly.toml app configuration file generated for ws-bot on 2023-10-16T12:54:39+01:00
+#
+# See https://fly.io/docs/reference/configuration/ for information about how to use this file.
+#
+
+app = "ws-bot"
+primary_region = "lhr"
+
+[build]
+  dockerfile = "multichannel-app/ws-bot-backend/Dockerfile"
+  build-target = "runner"
+
+[http_service]
+  internal_port = 8080
+  force_https = true
+  auto_stop_machines = true
+  auto_start_machines = true
+  min_machines_running = 0
+  processes = ["app"]
+
+[env]
+  WS_BOT_PORT=8080

multichannel-app/README.md

@@ -19,20 +19,26 @@ VONAGE_API_KEY="<your vonage api key>"
 VONAGE_API_SECRET="<your vonage account secret>"
 VONAGE_APPLICATION_ID="<your vonage application id>"
 VONAGE_PRIVATE_KEY="<your vonage api key>"
-NEXT_PUBLIC_SUPABASE_URL=http://localhost:54321
-NEXT_PUBLIC_SUPABASE_ANON_KEY=<random string>
-DEVICE_REFRESH_TOKEN_SECRET=<random string>
-DEVICE_CODE_SALT=<random string>
 LOCALTUNNEL=true
 VONAGE_LVN=<your lvn>
+NEXT_PUBLIC_VONAGE_LVN=<your lvn (same as above)>
 ENABLE_FACEBOOK=false
 VONAGE_ENDPOINT=https://api-us-3.vonage.com/v1
 WEBHOOK_PATH=api/
 TUNNEL_PORT=3000
+
+KV_REST_API_READ_ONLY_TOKEN="AnoCASQgZGMxNGQwN2EtNWFjZS00ZDMwLWIxNTYtNmM2N2VhMjhmZWZjyGaGY9p6iFYqlhfeJtEfa91OI88tHO6QJGg9avRxNs0="
+KV_REST_API_TOKEN="AXoCASQgZGMxNGQwN2EtNWFjZS00ZDMwLWIxNTYtNmM2N2VhMjhmZWZjNDU2ZDA1ODhiZWFhNDYzOGE2Y2I4NDg5ODcxNmUzOTY="
+KV_REST_API_URL="https://glowing-gar-31234.kv.vercel-storage.com"
+KV_URL="redis://default:456d0588beaa4638a6cb84898716e396@glowing-gar-31234.kv.vercel-storage.com:31234"
+
+#ws bot
 WS_BOT_PORT=3001
-GOOGLE_APPLICATION_CREDENTIALS="<your project path>/reference-client_sdk-ios-android-js-node-deno-usecases/gapp-creds.json"
-OPENAI_API_KEY="<openai org id>"
-OPENAI_ORG_ID="<openai org id>"
+OPENAI_API_KEY=
+OPENAI_ORG_ID=
+GOOGLE_PRIVATE_KEY=
+GOOGLE_CLIENT_EMAIL=
+GOOGLE_CLIENT_ID=
 
 ```
 
@@ -50,5 +56,30 @@ then run
 npm run dev:multichannel-app 
 ```
 
+### how to deploy
+
+#### ws bot on fly.io
+
+first install flyctr and loging 
+
+then set the secrets:
+
+``` 
+cat .env | grep 'GOOGLE\|OPENAI' > .env.deploy.flyio
+fly secrets import < .env.deploy.flyio
+
+```
+
+then deploy with: 
+
+```
+fly deploy
+```
+
+#### frontedn on next
+
+
+
+
 
 <!-- TODO: Add instructions -->

multichannel-app/frontend/app/@dash/(dash)/chat/@conversation/[id]/LinkPreview.tsx

@@ -5,7 +5,6 @@ import { VonageClientProvider } from '@vonage/client-sdk-react';
 
 
 import { UserProfileWidget } from './UserProfileWidget.server';
-import { getUserProfile } from './utils';
 
 import '@vonage/client-sdk-react/dist/vonage-client-sdk-react.css';
 import { Database } from 'supabase-helpers';

multichannel-app/frontend/app/@dash/(dash)/layout.tsx

@@ -1,5 +1,7 @@
 'use client';
+// @ts-ignore
 import { experimental_useFormState as useFormState } from 'react-dom';
+// @ts-ignore
 import { experimental_useFormStatus as useFormStatus } from 'react-dom';
 import { handleLogin } from './loginActions';
 import { defaultLoginState } from './types';

multichannel-app/frontend/app/@dash/(dash)/utils.ts

@@ -0,0 +1,124 @@
+import { getToken } from '../../token';
+export const revalidate = 0;
+const VONAGE_API_KEY = process.env.VONAGE_API_KEY;
+const VONAGE_API_SECRET = process.env.VONAGE_API_SECRET;
+const VONAGE_LVN = process.env.VONAGE_LVN;
+const VONAGE_APPLICATION_ID = process.env.VONAGE_APPLICATION_ID;
+
+
+export const GET = async (_req: Request) => {
+    try {
+    const phone_number = VONAGE_LVN;
+    const application_id = VONAGE_APPLICATION_ID;
+    const endpoint = process.env.ENDPOINT;
+    const webhooks_host = process.env.VERCEL_URL ? `https://${process.env.VERCEL_URL}`:endpoint;
+    const WEBHOOKS_URL = `${webhooks_host}/api`;
+    const api_key = VONAGE_API_KEY;
+    const api_secret = VONAGE_API_SECRET;
+    const dev_api_token = Buffer.from((`${api_key}:${api_secret}`)).toString('base64');
+    const capabilities = {
+        voice: {
+            webhooks: {
+                answer_url: {
+                    address: `${WEBHOOKS_URL}/webhook-voice-answer`,
+                    http_method: 'POST'
+                },
+                event_url: {
+                    address: `${WEBHOOKS_URL}/webhook-voice-event`,
+                    http_method: 'POST'
+                }
+            },
+        },
+        rtc: {
+            webhooks: {
+                event_url: {
+                    address: `${WEBHOOKS_URL}/webhook-rtc-event`,
+                    http_method: 'POST'
+                }
+            },
+        },
+        messages: {
+            webhooks: {
+                inbound_url: {
+                    address: `${WEBHOOKS_URL}/webhook-message-inbound`,
+                    http_method: 'POST'
+                },
+                status_url: {
+                    address: `${WEBHOOKS_URL}/webhook-status-event`,
+                    http_method: 'POST'
+                }
+            },
+        },
+
+    };
+
+
+
+    const newAppRes = await fetch(`https://api.nexmo.com/v2/applications/${application_id}`, {
+        body: JSON.stringify({
+            'name': 'Multichannel app',
+            capabilities
+        }),
+        method: 'PUT',
+        headers: { 
+            'Authorization': `basic ${dev_api_token}`,
+            'Content-Type': 'application/json'
+        }
+    }).then(res => {
+        if(!res.ok){
+            console.error('update webhooks', res);
+           throw Error(res.statusText);
+        }else {
+            return res.json();
+        }
+    });
+    
+    const requestLVN ={
+        'country':'GB',
+        'msisdn': phone_number as string,
+        app_id: application_id as string,
+        moHttpUrl: '',
+        voiceCallbackType: 'app',
+        voiceCallbackValue: application_id as string,
+    };
+    
+    const bindLvnRes = fetch('https://rest.nexmo.com/number/update', {
+        method: 'PUT',
+        body: new URLSearchParams(requestLVN),
+        headers: { 
+            'Content-Type': 'application/x-www-form-urlencoded' ,
+            'Authorization': `basic ${dev_api_token}`,
+    
+        }
+    }).then(res => {
+        if(!res.ok){
+          console.error(res);
+        }else {
+            return res.json();
+        }
+    });
+
+
+    return new Response(JSON.stringify({ 
+        env: {
+            VONAGE_API_KEY,
+            VONAGE_API_SECRET,
+            VONAGE_LVN,
+            WEBHOOKS_URL,
+            dev_api_token
+        },
+        newAppRes,
+        bindLvnRes
+     }), {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+    });
+    } catch(err){
+        return new Response(JSON.stringify({ 
+            err
+        }), {
+            status: 500,
+            headers: { 'Content-Type': 'application/json' },
+        });
+    }
+};

multichannel-app/frontend/app/@login/Login.tsx

@@ -1,4 +1,5 @@
 import { getToken } from '../token';
+export const revalidate = 0;
 
 export const GET = async (_req: Request) => {
     return new Response(JSON.stringify({ token: await getToken() }), {

multichannel-app/frontend/app/api/admin/bind/route.ts

@@ -0,0 +1,103 @@
+import { kv } from '@vercel/kv';
+import { getToken } from '../token';
+
+type HealthResponseKeys = 'ping'| 'ws_bot_ping' | 'application' | 'env_vars' | 'token' | 'kv';
+type HealthResponse = {
+    healthy: {
+        [key in HealthResponseKeys]?: boolean
+    },
+    error_message: {
+        [key in HealthResponseKeys]?: string 
+    }
+}
+type TestResult =  { type: HealthResponseKeys, healty: boolean, err?: string};
+
+function assignResult(resp: HealthResponse, res: TestResult): HealthResponse {
+    if(res.healty){
+        resp.healthy[res.type] = true;
+    }else{
+        resp.healthy[res.type] = false;
+        resp.error_message[res.type] = res.err as string;
+    }
+    return resp;
+}
+
+function networkTestGet(url: string, type: HealthResponseKeys): Promise<TestResult> {
+    return fetch(url,{
+        cache: 'no-cache',
+        headers : { 
+            'Content-Type': 'application/json',
+            'Accept': 'application/json'
+        }
+    }).then((res) => {
+        if(!res.ok){
+            return res.text().then(text => ({
+                healty: false,
+                err: text as string
+            }));
+        }
+        return res.json().then(res => {
+            return { healty: true };
+        });    
+    }).catch(err => ({
+        healty: false,
+        err: `error getting this url: ${url}. ${err.toString()}`
+    })).then(res => ({
+        ...res,
+        type
+    })); 
+
+}
+
+export const GET = async (_req: Request) => {
+    
+    
+    const endpoint = process.env.ENDPOINT;
+    const webhooks_host = process.env.VERCEL_URL ? `https://${process.env.VERCEL_URL}`:endpoint;
+
+    const ws_bot_url = process.env.WS_BOT_URL;
+    const pingRes: Promise<TestResult> = networkTestGet(`${webhooks_host}/api/ping`, 'ping');
+    const wsBotPingRes: Promise<TestResult> = networkTestGet(`${ws_bot_url}/ping`, 'ws_bot_ping');
+
+    const tokenRes:Promise<TestResult> = getToken()
+        .then(token => ({
+            healty: true
+        })).catch(err => ({
+            healty: false,
+            err: err as string
+        })).then((res ) => ({
+            ...res,
+            type: 'token'
+        }));
+
+    const kvTestRes: Promise<TestResult> = kv.set('test', 'test').then(val => kv.del('test'))
+        .then(res => ({healty: true }))
+        .catch(err => ({
+            healty: false,
+            err: err as string
+        }))
+        .then((res ) => ({
+            ...res,
+            type: 'kv'
+        }));
+
+    const resp:HealthResponse = {
+        healthy: {},
+        error_message: {}
+    };
+    const responses: TestResult[] = await Promise.all<TestResult>([
+        pingRes,
+        wsBotPingRes,
+        tokenRes,
+        kvTestRes]);
+    
+    responses.forEach(result =>{
+        assignResult(resp, result);
+    })
+    ;
+    
+    return new Response(JSON.stringify(resp), {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+    });
+};