@surph_ai/cli 0.0.1

package/toolserver/routes/index.js

@@ -0,0 +1,8 @@
+const { Router } = require('express')
+const router = Router()
+
+router.get('/', (req, res, next) => {
+  res.render('index', {})
+})
+
+module.exports = router

package/toolserver/routes/tool.js

@@ -0,0 +1,118 @@
+const fs = require('fs')
+const path = require('path')
+const os = require('os')
+const { Router, response } = require('express')
+const { pathToFileURL } = require('url')
+const manifest = require('../../../../../manifest.json')
+
+const SESSION_DIR = path.resolve(__dirname, '../../../../../.surph')
+const SESSION_FILE = path.join(SESSION_DIR, 'session.json')
+
+const toolsPath = pathToFileURL(
+  path.resolve(__dirname, '../../../../../dist/tools/index.js')
+).href
+
+const loadTool = () => import(toolsPath).then((mod) => mod.default)
+
+const router = Router()
+
+const handler = async (event, tool) => {
+  const { args, context, user } = event
+  let payload = null
+  let errorMsg = null
+  try {
+    payload = await tool({ args, context, user })
+  } catch (error) {
+    errorMsg = error instanceof Error ? error.message : String(error)
+  } finally {
+    const resp = { success: errorMsg === null ? true : false }
+
+    if (payload)
+      resp.payload = payload
+    
+    if (errorMsg !== null)
+      resp.error = errorMsg
+
+    return resp
+  }
+}
+
+router.get('/', async (req, res, next) => {
+  const surphUser = req.headers['x-surph-user']
+  if (surphUser) {
+    try {
+      // console.log('SAVE SURPH USER: ' + surphUser)
+      fs.mkdirSync(SESSION_DIR, { recursive: true, mode: 0o700 })
+      fs.writeFileSync(
+        SESSION_FILE,
+        JSON.stringify({
+          userId: surphUser,
+          updatedAt: new Date().toISOString()
+        }, null, 2),
+        { mode: 0o600 }
+      )
+    } catch (error) {
+      console.warn('[sdk] session write failed:', error.message)
+    }  
+  }
+
+  try {
+    res.json({ response: manifest })
+  } catch (error) {
+    res.json({
+      response: {
+        success: false,
+        error: error.message
+      }
+    })
+  }
+})
+
+router.get('/test', async (req, res, next) => {
+  try {
+    if (Object.keys(req.query).length === 0) {
+      throw new Error('No arguments provided.')
+    }
+
+    const context = req.query._context || null
+    const user = req.query._user || null
+    const params = { args: req.query, context, user }
+
+    const toolRunner = await loadTool()
+    const response = await handler(params, toolRunner)
+    res.json({ response })
+  } catch (error) {
+    res.json({
+      response: {
+        success: false,
+        error: error.message
+      }
+    })
+  }
+})
+
+router.post('/custom', async (req, res, next) => {
+  try {
+    const { name, args, tool, user = null, context = null } = req.body;
+    if (process.env.SURPH_TOOL !== tool.slug) {
+      throw new Error(`Invalid tool ${tool.slug}. Check .env file.`)
+    }
+
+    const toolRunner = await loadTool()
+    const response = await handler({ args, context, user }, toolRunner)
+    if (response.error) {
+      throw new Error(response.error);
+    }
+
+    res.json({ response })
+  } catch (error) {
+    res.json({
+      response: {
+        success: false,
+        error: error.message
+      }
+    })
+  }
+})
+
+module.exports = router

package/toolserver/templates/index.html

@@ -0,0 +1,20 @@
+<!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>Surph AI</title>
+  <link rel="shortcut icon" href="https://lh3.googleusercontent.com/MpnmfR3zYPTojA03QbhGgwIHucmH5s4G2vbIlADYhODL488MQt_BuVztv9LYmJbhwkScYN0DIXuh4d10YMsLbWXT">
+  <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css">
+  <link rel="stylesheet" href="https://cdn.turbo360-dev.com/admin/assets/scaffold/css/style.min.css" />
+</head>
+
+<body>
+  <div class="container pt-5">
+    <h1>Welcome to Surph AI</h1>
+  </div>
+</body>
+</html>

package/types.d.ts

@@ -0,0 +1,73 @@
+// Type definitions for @surph_ai/sdk
+// These describe the runtime contract the tool server hands to each tool's default export.
+
+export type OAuthProvider = 'google' | 'github' | (string & {});
+
+export interface GoogleOAuth {
+  accessToken: string;
+  refreshToken?: string;
+  /** ISO-8601 timestamp for when accessToken expires. */
+  expiresAt: string;
+  /** OAuth scopes granted by the user. */
+  scopes: string[];
+  /** ISO-8601 timestamp for when the user first connected the provider. */
+  connectedAt: string;
+}
+
+export interface UserOAuth {
+  google?: GoogleOAuth;
+  [provider: string]: unknown;
+}
+
+export interface UserAuth {
+  type: OAuthProvider;
+  /** Provider-issued stable identifier for the user (e.g. Google 'sub'). */
+  id: string;
+}
+
+export interface User {
+  _id: string;
+  firstName?: string;
+  lastName?: string;
+  email: string;
+  username: string;
+  avatar?: string;
+  tags?: string[];
+  following?: string[];
+  notifications?: unknown[];
+  type?: 'claimed' | 'anonymous' | (string & {});
+  auth?: UserAuth;
+  timestamp?: string;
+  lastVisit?: string;
+  identifiers?: string[];
+  tools?: string[];
+  oauth?: UserOAuth;
+}
+
+/**
+ * Per-invocation context. Currently opaque — populated by the caller (chat
+ * server, deployed harness, etc.). Cast to a more specific shape inside the
+ * tool if you know what your caller sends.
+ */
+export type ToolContext = Record<string, unknown> | null;
+
+export interface ToolHandlerInput<TArgs = Record<string, unknown>> {
+  args: TArgs;
+  context: ToolContext;
+  user: User;
+}
+
+export type ToolHandler<
+  TArgs = Record<string, unknown>,
+  TResult = unknown,
+> = (input: ToolHandlerInput<TArgs>) => Promise<TResult> | TResult;
+
+export interface Surph {
+  fetchUser(username: string): Promise<User>;
+  fetchContext(slug: string | ToolContext): Promise<unknown>;
+  searchContext(ctxSlug: string, query: string): Promise<unknown>;
+  search(query: string, ctxSlug?: string | null): Promise<unknown>;
+  toolHandler(tool: string, args?: Record<string, unknown>): Promise<unknown>;
+}
+
+export declare const surph: Surph;

package/utils/index.js

@@ -0,0 +1,275 @@
+const fs = require('fs')
+const colors = require('colors/safe')
+const dotenv = require('dotenv')
+const MODE_0666 = parseInt('0666', 8)
+
+module.exports = {
+
+  /*
+	isTurboApp: function(){
+		var packageJson = null
+		var env = null
+		try {
+			packageJson = fs.readFileSync('package.json', 'utf8')
+			var json = JSON.parse(packageJson)
+			var dependencies = json.dependencies
+			if (dependencies.turbo360==null || dependencies.vertex360==null){
+				return {
+					isTurboApp: false,
+					missing: 'turbo360 and/or vertex 360',
+					reason: 'Missing turbo360 and/or vertex 360 dependencies'
+				}
+			}
+
+			var envData = fs.readFileSync('.env', 'utf8')
+			env = dotenv.parse(envData)
+			var turboEnv = env['TURBO_ENV']
+			if (turboEnv == null){
+				return {
+					isTurboApp: false,
+					missing: 'TURBO_ENV environment variable',
+					reason: 'Missing TURBO_ENV environment variable. Please set "TURBO_ENV=dev" in the .env file'
+				}
+			}
+
+			// this is definitely a turbo project
+			return {
+				isTurboApp: true,
+				turboEnv: turboEnv,
+				turbo360: dependencies.turbo360,
+				vertex360: dependencies.vertex360
+			}
+		}
+		catch(err){
+			// console.log('ERR - ' + err.message)
+			var missing = (packageJson == null) ? 'package.json' : '.env'
+			var reason = (packageJson == null) ? 'Missing package.json file' : 'Missing .env file. Please add .env file with "TURBO_ENV=dev" variable set.'
+			return {
+				isTurboApp: false,
+				missing: missing,
+				reason: reason
+			}
+		}
+	},
+
+	defaultTurboDeploy: function() {
+		var turboDeployString = '## Do NOT check this file into version control\n'
+		turboDeployString += '\nBUCKET=<AWS_HOST_BUCKET>'
+		turboDeployString += '\nAWS_KEY=<AWS_KEY>'
+		turboDeployString += '\nAWS_SECRET=<AWS_SECRET>'
+		turboDeployString += '\nAWS_ACCT=<AWS_ACCT>'
+		turboDeployString += '\nAWS_ROLE=<AWS_ROLE>'
+		turboDeployString += '\nAWS_REGION=<AWS_REGION>'
+		return turboDeployString
+	},
+  */
+
+	defaultEnv: function() {
+		var envString = '## Do NOT check this file into version control\n'
+		envString += '\nTURBO_ENV=dev'
+		envString += '\nTURBO_CDN=https://cdn.turbo360-vertex.com'
+		envString += '\nSESSION_SECRET=YOUR_SESSION_SECRET'
+		envString += '\nTURBO_APP_ID=<TURBO_APP_ID>'
+		envString += '\nTMP_DIR=/tmp'
+		envString += '\nTURBO_API_KEY=<TURBO_API_KEY>'
+		envString += '\nTURBO_APP_SLUG=<TURBO_APP_SLUG>'
+		return envString
+	},
+
+	validateEnv: function(env, fields) { // fields is an array
+		if (!fields) {
+			// required env values to deploy:
+			fields = [
+				{text:'TURBO_CDN', min:20, placeholder:'https://cdn.turbo360-vertex.com'},
+				{text:'TURBO_APP_SLUG', min:6, placeholder:'<TURBO_APP_SLUG>'},
+				{text:'TURBO_API_KEY', min:20, placeholder:'<TURBO_API_KEY>'},
+				{text:'TURBO_APP_ID', min:20, placeholder:'<TURBO_APP_ID>'}
+			]
+		}
+
+		var missing = null
+		fields.forEach(function(field){
+			// e.g. - {text:"TURBO_APP_ID", min:20}
+			var key = field.text
+			if (env[key] == null){
+				missing = key
+				return
+			}
+			
+			if (env[key] == field.placeholder){ // still default placeholder string
+				missing = key
+				return
+			}
+
+			if (env[key].length < field.min){ // doesn't meet min str length
+				missing = key
+				return
+			}			
+		})
+
+		return missing
+	},
+
+	write: (path, str, mode = MODE_0666) => {
+		fs.writeFileSync(path, str, { mode })
+		// console.log('   \x1b[36mcreate\x1b[0m : ' + path)
+	},
+
+	// readFile: function(filepath, errMessage){
+	// 	return new Promise(function(resolve, reject){
+	// 		fs.readFile(filepath, 'utf8', function(err, data) {
+	// 			if (err) {
+	// 				var error = (errMessage) ? Error(errMessage) : err
+	// 				reject(error)
+	// 				return
+	// 			}
+
+	// 			resolve(data)
+	// 		})
+	// 	})
+	// },
+
+	readFile: (filepath, encoding = 'utf8') => {
+		// if (!encoding)
+		// 	encoding = 'utf8'
+
+		try {
+			const file = fs.readFileSync(filepath, encoding)
+			return file
+		} catch (error) {
+			return null
+		}
+	},
+
+  printError: (error) => {
+    if (error.response) {
+      const { data } = error.response
+      const errorText = `${colors.red(`\nError: `)} ${colors.white(`${data.error}\n`)}`
+      console.log(errorText)
+
+      return
+    }
+
+    const errorText = `${colors.red(`\nError: `)} ${colors.white(`${error.message}\n`)}`
+    console.log(errorText)
+  }
+
+  /*
+	postRequest: function(endpoint, params){
+		return new Promise(function(resolve, reject){
+			superagent
+			.post(endpoint)
+			.send(params)
+			.set('Accept', 'application/json')
+			.end(function(err, response){
+				// console.log('POST CALLBACK: ' + JSON.stringify(response))
+				if (err){
+					// console.log('err 1: ' + err)
+					if (!response){
+						reject(err)
+						return
+					}
+
+					if (response.text){
+						try {
+							var parsed = JSON.parse(response.text)
+							var message = parsed.message || 'Something went wrong. Please try again.'
+							reject(new Error(message))
+							return
+						} catch(parseError){
+
+						}
+					}
+
+					reject(err)
+					return
+				}
+
+				if (response.body.confirmation != 'success'){
+					// console.log('POST ERROR: ' + JSON.stringify(response))
+					reject(new Error(response.body.message))
+					return
+				}
+
+				resolve(response.body)
+			})
+		})
+	},
+
+	putRequest: function(endpoint, params){
+		return new Promise(function(resolve, reject){
+			superagent
+			.put(endpoint)
+			.send(params)
+			.set('Accept', 'application/json')
+			.end(function(err, response){
+				if (err){
+					if (!response){
+						reject(err)
+						return
+					}
+
+					if (response.text){
+						try {
+							var parsed = JSON.parse(response.text)
+							var message = parsed.message || 'Something went wrong. Please try again.'
+							reject(new Error(message))
+							return
+						} catch(parseError){
+
+						}
+					}
+
+					reject(err)
+					return
+				}
+
+				if (response.body.confirmation != 'success'){
+					// console.log('POST ERROR: ' + JSON.stringify(response))
+					reject(new Error(response.body.message))
+					return
+				}
+
+				resolve(response.body)
+			})
+		})
+	},
+
+	getRequest: function(endpoint){
+		return new Promise(function(resolve, reject){
+			superagent
+			.get(endpoint)
+			.set('Accept', 'application/json')
+			.end(function(err, response){
+				if (err){
+					if (!response){
+						reject(err)
+						return
+					}
+
+					if (response.text){
+						try {
+							var parsed = JSON.parse(response.text)
+							var message = parsed.message || 'Something went wrong. Please try again.'
+							reject(new Error(message))
+							return
+						} catch(parseError){
+
+						}
+					}
+
+					reject(err)
+					return
+				}
+
+				if (response.body.confirmation != 'success'){
+					reject(new Error(response.body.message))
+					return
+				}
+
+				resolve(response.body)
+			})
+		})
+	}
+  */
+}