@surph_ai/sdk 0.0.1

package/base/vinely-base/src/server/utils/Auth.ts

@@ -0,0 +1,235 @@
+import { Response, NextFunction, Express } from 'express'
+import crypto from 'crypto'
+import passport from "passport"
+import { Strategy as GoogleStrategy } from "passport-google-oauth20"
+import APIMgr from './APIMgr.js'
+
+const COOKIE_NAME: string = process.env.COOKIE_NAME || ''
+const USER_CACHE: any = {}
+
+const GOOGLE_CLIENT_ID: string = process.env.GOOGLE_CLIENT_ID as string
+const GOOGLE_CLIENT_SECRET: string = process.env.GOOGLE_CLIENT_SECRET as string
+const GOOGLE_CALLBACK_URL: string = process.env.GOOGLE_CALLBACK_URL as string
+
+const generateSalt = () => {
+  return new Promise((resolve, reject) => {
+    const byteSize = 16
+    crypto.randomBytes(byteSize, (err, salt) => {
+      if (err) {
+        reject(err)
+        return
+      }
+
+      resolve(salt.toString('base64'))
+    })
+  })
+}
+
+const hashPw = (password: string, salt: string) => {
+  return new Promise((resolve, reject) => {
+    const defaultIterations = 10000
+    const defaultKeyLength = 64
+    // const saltBase64 = new Buffer(salt, 'base64')
+    const saltBase64 = Buffer.from(salt, 'base64')
+    const digest = 'sha512'
+
+    crypto.pbkdf2(
+      password,
+      saltBase64,
+      defaultIterations,
+      defaultKeyLength,
+      digest,
+      (err, key) => {
+        if (err) {
+          reject(err)
+          return
+        }
+
+        resolve(key.toString('base64'))
+      }
+    )
+  })
+}
+
+const authenticate = async (password: string, profile: any) => {
+  const hashed = await hashPw(password, profile.auth.salt)
+  return (hashed === profile.auth.pw)
+}
+
+const setToken = (res: Response, cookieValue: string, tknName?: string) => {
+  const token = tknName || process.env.COOKIE_NAME as string
+  // console.log('\nSET TOKEN: ' + token + ': ' + cookieValue + '\n')
+  const ONE_DAY = 24 * 60 * 60 * 1000
+  const domain = (process.env.TURBO_ENV === 'local') ? 'localhost' : '.vinely.ai'
+
+  // const cookieStr = cookieValue || ''
+  res.cookie(token, cookieValue, {
+    maxAge: 14 * ONE_DAY,
+    httpOnly: true,
+    domain,
+  })
+}
+
+const clearToken = (res: Response, tknName?: string) => {
+  const token = tknName || process.env.COOKIE_NAME as string
+  const domain = (process.env.TURBO_ENV === 'local') ? 'localhost' : '.vinely.ai'
+  res.clearCookie(token, { domain })
+}
+
+const sessionMiddleware = async (req: any, res: Response, next: NextFunction) => {
+  if (!req.cookies) {
+    console.log('SESSION NOT FOUND: ')
+    return next()
+  }
+
+  const cookie = req.cookies[COOKIE_NAME]
+  if (!cookie) {
+    console.log('NO VINLEY TKN: ' + JSON.stringify(req.cookies))
+    return next()
+  }
+
+  if (cookie === 'anon') {
+    console.log('NOT LOGGED IN: ' + JSON.stringify(req.cookies))
+    return next()
+  }
+
+  try {
+    const session = JSON.parse(cookie)
+    // session.user = '68bb5f2b6d70d5c695588dd4' // hayden
+    // session.user = '68bf432cdcf8995ba8c48519' // tess
+
+    let user = USER_CACHE[session.user]
+    if (user) {
+      req._session = user
+    } else {
+      const { payload } = await APIMgr.get(`user/${session.user}`, null, null)
+      delete payload.auth
+      delete payload.email
+
+      USER_CACHE[session.user] = payload
+      req._session = payload
+    }
+  } catch (error) {
+    res.clearCookie(COOKIE_NAME) // invalidate token
+  } finally {
+    next()  
+  }
+}
+
+const setupPassport = (app: Express) => {
+  passport.use(new GoogleStrategy({
+    clientID: GOOGLE_CLIENT_ID,
+    clientSecret: GOOGLE_CLIENT_SECRET,
+    // callbackURL: "http://localhost:8080/oauth/google/callback"
+    callbackURL: GOOGLE_CALLBACK_URL
+  }, (accessToken, refreshToken, profile, done) => {
+
+    // TODO: check if user exists in DB or create a new one
+    console.log('GOOGLE PROFILE: ' + JSON.stringify(profile))
+    return done(null, profile);
+  }));
+
+  app.use(passport.initialize())
+  // app.use(passport.session())
+
+  // Serialize/deserialize user
+  passport.serializeUser((user: any, done) => {
+    done(null, user)
+  })
+
+  passport.deserializeUser((user: any, done) => {
+    done(null, user)
+  })
+
+  app.get(
+    '/oauth/google',
+    passport.authenticate("google", { scope: ["profile", "email"] })
+  )
+
+  app.get(
+    '/oauth/google/callback',
+    passport.authenticate("google", { session: false, failureRedirect: "/" }),
+    async (req, res) => {
+      const userData = req.user as any
+      const user = userData._json
+
+      /*
+      {
+        "sub": "105065442288013194527",
+        "name": "Joe Rogan",
+        "given_name": "Joe",
+        "family_name": "Rogan",
+        "picture": "https://lh3.googleusercontent.com/a/ACg8ocIefrpbU2qhABOKkJW3Ro_1_47nOBnYGI2uAp4H5h4BXvIk2w=s96-c",
+        "email": "joe.rogan@gmail.com",
+        "email_verified": true
+      }
+      */
+
+      const { payload } = await APIMgr.get('user', { email: user.email }, null)
+
+      if (payload.length > 0) { // user already registerd
+        const currentUser = payload[0]
+
+        if (currentUser.auth.type !== 'google') {
+          res.status(403).json({
+            error: 'User not registered with google'
+          })
+
+          return
+        }
+
+        setToken(res, JSON.stringify({ user: currentUser._id }))
+        res.redirect('/')
+        return
+      }
+
+      const { token } = await registerUser(user, 'google')
+      setToken(res, token)
+      res.redirect('/')
+    }
+  )
+}
+
+const registerUser = async (user: any, type: string) => {
+  const { email } = user
+
+  const formattedEmail = email.toLowerCase().trim()
+  const params: any = {
+    email: formattedEmail,
+    username: formattedEmail.split('@')[0]
+  }
+
+  const auth: any = { type } // email, google, linkedin, etc
+
+  if (type === 'email') {
+    const password = user.password
+    auth.salt = await generateSalt()
+    auth.pw = await hashPw(password, auth.salt)
+  }
+
+  if (type === 'google') {
+    auth.googleId = user.sub
+  }
+
+  params.auth = auth
+  const { payload } = await APIMgr.post('user', params, null)
+  delete payload.auth
+
+  const profile = payload
+
+  return {
+    user: profile,
+    token: JSON.stringify({ user: profile._id })
+  }
+}
+
+export {
+  generateSalt,
+  hashPw,
+  authenticate,
+  setToken,
+  clearToken,
+  sessionMiddleware,
+  setupPassport,
+  registerUser
+}

package/base/vinely-base/src/server/utils/fetchManifest.ts

@@ -0,0 +1,15 @@
+import axios from 'axios'
+
+export default async () => {
+  const url = `https://vinely.s3.us-east-1.amazonaws.com/sites/${process.env.VLY_APP}/manifest.txt`
+
+  const { data } = await axios({
+    url,
+    method: 'get',
+    headers: {
+      Accept: 'application/json'
+    }
+  })
+
+  return data
+}

package/base/vinely-base/src/server/utils/mcp-auth.ts

@@ -0,0 +1,251 @@
+import { OAuthClientProvider, UnauthorizedError } from "@modelcontextprotocol/sdk/client/auth.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { OAuthClientInformation, OAuthClientInformationFull, OAuthTokens, OAuthClientMetadata } from "@modelcontextprotocol/sdk/shared/auth.js";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+
+export class WebOAuthClientProvider implements OAuthClientProvider {
+  private _redirectUrl: string | URL;
+  //private _clientMetadata: OAuthClientMetadata;
+  private _clientInformation?: OAuthClientInformation | undefined;
+  private _tokens?: OAuthTokens | undefined;
+  private _codeVerifier?: string | undefined;
+  private _redirect: (url: URL) => Promise<void>;
+
+  constructor(redirectUrl: URL,
+    redirect: (url: URL) => Promise<void>) {
+    this._redirectUrl = redirectUrl;
+    // TODO: May need to take this in dynamically to support variation
+    // amongst MCP servers
+    // this._clientMetadata = clientMetadata;
+    this._redirect = redirect;
+  }
+
+  get redirectUrl(): string | URL {
+    return this._redirectUrl
+  }
+  
+  get clientMetadata(): OAuthClientMetadata {
+    return {
+      redirect_uris: [ this._redirectUrl.toString() ],
+      scope: "mcp:tools",
+      token_endpoint_auth_method: "client_secret_post",
+      grant_types: [ "authorization_code", "refresh_token" ],
+      response_types: [ "code" ],
+      client_name: "Test Web OAuth Client",
+      client_uri: undefined,            // TODO: Add client URI
+
+      // JWKS auth
+      jwks_uri: undefined,
+      jwks: undefined,
+
+      // Other identifying fields
+      logo_uri: undefined,              // TODO: Add logo URI
+      tos_uri: undefined,               // TODO: Add TOS URI
+      policy_uri: undefined,            // TODO: Add policy URI
+      contacts: undefined,              // TODO: Add contacts
+      software_id: undefined,           // TODO: Add software ID
+      software_version: "0.1.0",        // TODO: Add software version
+      software_statement: undefined,    // TODO: Add software statement
+    }
+  }
+
+  // TODO: State parameters are a good thing?
+  // state?(): string | Promise<string> {
+  //   throw new Error("Method not implemented.");
+  // }
+
+  clientInformation(): OAuthClientInformation | undefined | 
+      Promise<OAuthClientInformation | undefined> {
+    return this._clientInformation;
+  }
+
+  saveClientInformation?(clientInformation: OAuthClientInformationFull): void | Promise<void> {
+    this._clientInformation = clientInformation;
+  }
+
+  tokens(): OAuthTokens | undefined | Promise<OAuthTokens | undefined> {
+    return this._tokens;
+  }
+  saveTokens(tokens: OAuthTokens): void | Promise<void> {
+    this._tokens = tokens;
+  }
+  
+  redirectToAuthorization(authorizationUrl: URL): void | Promise<void> {
+    this._redirect(authorizationUrl);
+  }
+
+  codeVerifier(): string | Promise<string> {
+    if (!this._codeVerifier) {
+      throw new Error("Code verifier not set.");
+    }
+
+    return this._codeVerifier;
+  }
+  saveCodeVerifier(codeVerifier: string): void | Promise<void> {
+    this._codeVerifier = codeVerifier;
+  }
+
+  // addClientAuthentication?(headers: Headers, params: URLSearchParams, url: string | URL, metadata?: AuthorizationServerMetadata): void | Promise<void> {
+  //   throw new Error("Method not implemented.");
+  // }
+  // validateResourceURL?(serverUrl: string | URL, resource?: string): Promise<URL | undefined> {
+  //   throw new Error("Method not implemented.");
+  // }
+  // invalidateCredentials?(scope: "all" | "client" | "tokens" | "verifier"): void | Promise<void> {
+  //   throw new Error("Method not implemented.");
+  // }
+};
+
+// NextJs blows this shit away while chunking
+// const mcpAuthProviders = new Map<URL, WebOAuthClientProvider>();
+type McpAuthProvidersStore = Map<string, WebOAuthClientProvider>;
+
+type MCPActiveAuthFlow = {
+  clientName: string,
+  url: URL,
+  transport: StreamableHTTPClientTransport,
+  mcpClient: Client
+};
+
+// NextJs blows this shit away while chunking
+//const mcpAuthFlows = new Map<string, MCPActiveAuthFlow>();
+type McpAuthFlowsStore = Map<string, MCPActiveAuthFlow>;
+
+// Extend globalThis to include some extra state
+declare global {
+  var __mcpAuthFlows: McpAuthFlowsStore | undefined;
+  var __mcpProviders: McpAuthProvidersStore | undefined;
+}
+
+const mcpProviders: McpAuthProvidersStore = (globalThis.__mcpProviders
+    ?? (globalThis.__mcpProviders = new Map<string, WebOAuthClientProvider>())) as McpAuthProvidersStore;
+
+const mcpAuthFlows: McpAuthFlowsStore = (globalThis.__mcpAuthFlows 
+    ?? (globalThis.__mcpAuthFlows = new Map<string, MCPActiveAuthFlow>())) as McpAuthFlowsStore;
+
+export const hasAuthProvider = (mcpUrl: URL): boolean => {
+  const url = mcpUrl.toString()
+  if (!mcpProviders.has(url)) {
+    return false
+  }
+
+  return true
+}
+
+export const getAuthProvider = (mcpUrl: URL): any => {
+  const url = mcpUrl.toString();
+  if (!mcpProviders.has(url)) {
+    // throw new Error("No auth provider found for MCP URL: " + mcpUrl);
+    return null
+  }
+
+  return mcpProviders.get(url) as WebOAuthClientProvider;
+};
+
+export const setupAuthProvider = async (mcpClientName: string, mcpUrl: URL,
+    version: string = "0.0.1"): Promise<URL | undefined> => 
+{
+  console.log("setupAuthProvider");
+
+  // TODO: Generate unique cryptographically secure flow IDs to prevent auth flow collisions
+  const flowId = "abc123";
+
+  let redirectUrl = undefined;
+
+  // Create a new provider
+  const provider = new WebOAuthClientProvider(
+    // new URL(`http://localhost:3000/api/v1/mcp/auth/${flowId}`),
+    new URL(`http://localhost:${process.env.PORT}/api/mcp/auth`),
+    async (url: URL) => {
+      console.debug(`Redirecting to: ${url}`);
+
+      // Closure; we'll await later and return this
+      redirectUrl = url;
+    }
+  );
+
+  // Trigger the authentication flow by attempting to connect
+  const transport = new StreamableHTTPClientTransport(mcpUrl, {
+    authProvider: provider,
+  });
+
+  const mcpClient = new Client({
+      name: mcpClientName,
+      version,
+  }, { capabilities: {} });
+
+  // Persist some stateful bits
+  // TODO: Consider how to serialize these in a serverless manner and determine the extent
+  //  to which they even need to be serialized
+  mcpProviders.set(mcpUrl.toString(), provider)
+  mcpAuthFlows.set(flowId, {
+    clientName: mcpClientName,
+    url: mcpUrl,
+    transport,
+    mcpClient
+  });
+
+  try {
+    await mcpClient.connect(transport);
+
+    // Authentication was successful, apparently
+  }
+  catch (error) {
+    if (error instanceof UnauthorizedError) {
+      // Expected failure; authentication is in progress (presumably); return the redirect
+      if (redirectUrl) {
+        return redirectUrl
+      }
+
+      throw new Error("Expected a redirect URL to be generated.");
+    }
+    else {
+      console.error("Error establishing initial MCP connection:", error);
+      throw error;
+    }
+  }
+  finally {
+    // Close the connection - for now
+    await mcpClient.close();
+  }
+}
+
+export const handleMCPAuthCallback = async (req: any, res: any) => {
+  console.log("handleMCPAuthCallback");
+  const { code } = req.query
+  if (!code) {
+    res.status(400).send('Missing code')
+    return
+  }
+
+  // TODO: Parameterize this
+  if (!mcpAuthFlows.has("abc123")) {
+    res.status(400).send('No active authentication flow found.')
+    return
+  }
+
+  const { url, clientName, transport, mcpClient } = mcpAuthFlows.get("abc123") as MCPActiveAuthFlow;
+
+  // TODO: check if we need to reuse the same transport to do this
+  // ... upon reviewing source, I don't think we do. 
+  // Just need persisted clientInformation in the provider.
+  await transport.finishAuth(code)
+
+  console.log('TEST 3: ' + JSON.stringify(mcpProviders.get(url.toString())))
+
+  // Try to connect to confirm it is setup; note: need a new transport
+  const testTransport = new StreamableHTTPClientTransport(url, {
+    authProvider: mcpProviders.get(url.toString())
+  })
+
+  try {
+    await mcpClient.connect(testTransport);
+  }
+  catch (error) {
+    console.error("Error finalizing authentication for MCP connection:", error);
+    throw error;
+  }
+
+  // res.send('Authentication complete. You can close this window.')
+  res.redirect('/')
+}

package/base/vinely-base/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "outDir": "./build",
+    "rootDir": "./src",
+    "jsx": "react",
+    "moduleResolution": "node",
+    "module": "es2020",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/server/**/**/*", "declarations.d.ts"],
+  "exclude": ["node_modules"]
+}

package/base/vinely-base/views/landing.html

@@ -0,0 +1,187 @@
+<!DOCTYPE html>
+<html dir="ltr" lang="en-US">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
+  <meta http-equiv="X-UA-Compatible" content="ie=edge">
+  <meta http-equiv="Content-Language" content="en" />
+
+  <title>Vinely</title>
+  <link rel="shortcut icon" href="https://lh3.googleusercontent.com/MpnmfR3zYPTojA03QbhGgwIHucmH5s4G2vbIlADYhODL488MQt_BuVztv9LYmJbhwkScYN0DIXuh4d10YMsLbWXT">
+  <link rel="stylesheet" href="{{{CDN}}}/css/globals-2.css" />
+  <link rel="stylesheet" href="{{{CDN}}}/dist/css/katex.min.css" />
+  <style>
+    .m-auto {
+      margin: auto;
+    }
+
+    .fw-600 {
+      font-weight: 600;
+    }
+
+    .reference-container {
+      transition: all 0.4s linear;
+      background: #1f2121;
+      width: 60%;
+      border-radius: 12px;
+      padding: 20px;
+      line-height: 20px;
+      border-bottom: 1px solid #2b2c2c;
+    }
+
+    .header {
+      position: fixed;
+      width: -webkit-fill-available;
+      width: -moz-available;
+      z-index: 1;
+      background: rgba(0,0,0,0);
+      backdrop-filter: blur(10px);
+      border-bottom: 1px solid #191a1a;
+      transition: all 0.2s linear;
+      /* box-shadow: 0px -9px 12px 8px #888888; */
+    }
+
+    .border-border {
+      border-color: #ece6e70d !important;
+    }
+
+    textarea {
+      color: #e8e8e3;
+      font-weight: 200;
+      background-color: #1f2121;
+      padding-top: 10px;
+      border-top-right-radius: 16px;
+      border-top-left-radius: 16px;
+    }
+
+    .text-default {
+      color: '#e8e8e3'
+    }
+
+    .color-accent {
+      color: #94ccff !important;
+    }
+
+    .bg-sidebar {
+      background: #1f2121 !important;
+    }
+
+    .text-center {
+      text-align: center;
+    }
+
+    .sidebar-list {
+      font-size: 14px;
+      line-height: 1.7;
+    }
+
+    .card-preview {
+      width: 100%;
+      height: 100%;
+      background: #1f2121;
+      border-radius: 12px;
+      border: 1px solid #ece6e70d;
+      color: #fff;
+      padding: 9px;
+      overflow: hidden;
+      transition: all 0.25s linear;
+    }
+
+    .card-preview:hover {
+      border: 1px solid #666;
+    }
+
+    .card-preview h5 {
+      font-size: 14px;
+      margin-top: 6px;
+    }
+
+    .card-preview p {
+      font-size: 12px;
+      font-weight: 100;
+      line-height: 1.7;
+    }
+
+    .card-preview hr {
+      border-color: #ece6e70d;
+      margin-top: 16px;
+      margin-bottom: 8px;
+    }
+
+    .card-preview small {
+      font-size: 12px;
+      font-weight: 200;
+      color: #999;
+    }
+
+    .thread-preview {
+      height: 256px;
+      transition: all 0.25s ease-in-out;
+      cursor: pointer;
+    }
+
+    .markdown {
+      width: 100%;
+      padding: 8rem 14rem;
+      color: #fff;
+    }
+
+    .markdown p {
+      margin-bottom: 24px;
+    }
+
+    .markdown li {
+      margin-bottom: 24px;
+    }
+
+    .markdown small {
+      opacity: 0.5;
+    }
+
+    .message-user {
+      display: flex;
+      flex-direction: row-reverse;
+    }
+
+    .message-user p {
+      background: #333;
+      padding: 16px;
+      border-radius: 12px;
+    }
+
+    .effect-shine {
+      mask-image: linear-gradient(-75deg, rgba(0,0,0,.6) 30%, #000 50%, rgba(0,0,0,.6) 70%);
+      -webkit-mask-image: linear-gradient(-75deg, rgba(0,0,0,.6) 30%, #000 50%, rgba(0,0,0,.6) 70%);
+      mask-size: 200%;
+      -webkit-mask-size: 200%;
+      animation: shine 2s infinite;
+    }
+
+    @-webkit-keyframes shine {
+      from {
+        -webkit-mask-position: 150%;
+      }
+      
+      to {
+        -webkit-mask-position: -50%;
+      }
+    }
+
+    @keyframes shine {
+      from {
+        mask-position: 150%;
+      }
+      
+      to {
+        mask-position: -50%;
+      }
+    }
+  </style>
+</head>
+
+<body style="background: #191a1a;">
+  <div id="root" style="background: #191a1a;"></div>
+
+  {{>imports}}
+</body>
+</html>

package/base/vinely-base/views/partials/imports.dev.html

@@ -0,0 +1,3 @@
+<script>window.__CONTEXT__ = {{{context}}}</script>
+<script type="text/javascript" src="/dist/dev/commons.js"></script>
+<script type="text/javascript" src="/dist/dev/app.js"></script>