@scout9/app 1.0.0-alpha.0.0.1

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@scout9/app",
+  "version": "1.0.0-alpha.0.0.1",
+  "description": "Build and deploy your Scout9 app for SMS auto reply",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/Scout9Official/scout9-nodejs.git"
+  },
+  "scripts": {
+    "postinstall": "node postinstall.js",
+    "types": "npx -p typescript tsc src/**/*.ts --declaration --allowJs --emitDeclarationOnly --esModuleInterop --outDir dist/types"
+  },
+  "type": "module",
+  "bin": {
+    "scout9-app": "./scout9-app.js"
+  },
+  "files": [
+    "src",
+    "!src/**/*.spec.js",
+    "!src/core/**/fixtures",
+    "!src/core/**/test",
+    "types",
+    "scout9-app.js",
+    "postinstall.js"
+  ],
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./types/index.d.ts",
+      "import": "./src/exports/index.js"
+    }
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/archiver": "^6.0.2",
+    "@types/jest": "^29.5.11",
+    "ts-jest": "^29.1.1",
+    "typescript": "^5.3.3"
+  },
+  "dependencies": {
+    "archiver": "^6.0.1",
+    "decompress": "^4.2.1",
+    "dotenv": "^16.3.1",
+    "glob": "^10.3.10",
+    "kleur": "^4.1.5",
+    "moment": "^2.29.4",
+    "node-fetch": "^3.3.2",
+    "sade": "^1.8.1",
+    "zod": "^3.22.4"
+  },
+  "engines": {
+    "node": ">=18.13"
+  }
+}

package/postinstall.js

@@ -0,0 +1,2 @@
+console.log('@scout9/app installed');
+// @TODO run any synchronous post-install processes here

package/scout9-app.js

@@ -0,0 +1 @@
+import './src/cli';

package/src/cli.js

@@ -0,0 +1,35 @@
+import fs from 'node:fs';
+import sade from 'sade';
+import path from 'node:path';
+import { Scout9Platform } from './platform.js';
+
+// const pkg = JSON.parse(fs.readFileSync(new URL('../package.json'), 'utf-8'));
+// const pkg = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf-8'));
+const prog = sade('scout9-auto-reply').version('0.0.1');
+
+prog
+  .command('build')
+  .describe('Builds your scout9 auto reply app')
+  .option('--mode', 'Specify a mode for loading environment variables', 'development')
+  .action(async ({ mode }) => {
+    if (!fs.existsSync('.env')) {
+      console.warn(`Missing ${path.resolve('.env')} — skipping`);
+      return;
+    }
+    return Scout9Platform.build({cwd: process.cwd(), mode});
+  });
+
+
+prog
+  .command('deploy')
+  .describe('Deploy your scout9 auto reply app')
+  .option('--mode', 'Specify a mode for loading environment variables', 'development')
+  .action(async ({ mode }) => {
+    if (!fs.existsSync('.env')) {
+      console.warn(`Missing ${path.resolve('.env')} — skipping`);
+      return;
+    }
+    return Scout9Platform.build({cwd: process.cwd(), mode});
+  });
+
+prog.parse(process.argv, { unknown: (arg) => `Unknown option: ${arg}` });

package/src/core/config/agents.js

@@ -0,0 +1,5 @@
+
+export default async function loadAgentConfig({cwd = process.cwd(), folder = 'src'} = {}) {
+  console.log('@TODO implement loadAgentConfig');
+  return [];
+}

package/src/core/config/entities.js

@@ -0,0 +1,110 @@
+import { globSync } from 'glob';
+import path from 'node:path';
+import {
+  entitiesRootProjectConfigurationSchema,
+  entityApiConfigurationSchema,
+  entityConfigurationSchema,
+  entityRootProjectConfigurationSchema
+} from '../../runtime/index.js';
+import { checkVariableType, requireOptionalProjectFile, requireProjectFile } from '../../utils/index.js';
+
+async function loadEntityApiConfig(cwd, filePath) {
+  const dir = path.dirname(filePath);
+  const extension = path.extname(filePath);
+  const apiFilePath = path.join(dir, `api${extension}`);
+  const root = cwd.split('/').pop();
+  const x = apiFilePath.replace(cwd, '').split('/').slice(1).join('/');
+
+  const mod = await requireOptionalProjectFile(x);
+  if (mod) {
+    const config = {};
+    const methods = ['GET', 'UPDATE', 'QUERY', 'PUT', 'PATCH', 'DELETE'];
+    for (const key in mod) {
+      if (methods.includes(key)) {
+        config[key] = true;
+      }
+    }
+    entityApiConfigurationSchema.parse(config);
+    return config;
+  } else {
+    return null;
+  }
+}
+
+export default async function loadEntitiesConfig(
+  {cwd = process.cwd(), folder = 'src'} = {}
+) {
+  console.log('loadEntitiesConfig', {cwd, folder});
+  const config = [];
+  const paths = globSync(path.resolve(cwd, `${folder}/entities/**/{index,config,api}.{ts,js}`));
+  const data = [];
+  for (const path of paths) {
+    const segments = path.split('/');
+    const srcIndex = segments.findIndex((segment, index) => segment === folder && segments[index + 1] === 'entities');
+    const parents = segments.slice(srcIndex + 2, -1).reverse(); // +2 to skip "${folder}" and "entities"
+    if (parents.length > 0) {
+      const api = await loadEntityApiConfig(cwd, path);
+      data.push({path, parents, api});
+    } else {
+      console.log(`WARNING: "${path}" Is not a valid entity path, must be contained in a named folder under entities/`);
+    }
+  }
+
+  const specialEntities = ['agents'];
+
+  for (const {path, parents, api} of data) {
+    let entityConfig = {};
+    const fileName = path.split('/')?.pop()?.split('.')?.[0];
+    if (!fileName) throw new Error(`Invalid file name "${path}"`);
+    const isSpecial = specialEntities.some(se => parents.includes(se));
+    if ((fileName === 'index' || fileName === 'config') && !isSpecial) {
+      const entityConfigHandler = await requireProjectFile(path).then(mod => mod.default);
+      // Check if entityConfig is a function or object
+      const entityType = checkVariableType(entityConfigHandler);
+      switch (entityType) {
+        case 'async function':
+        case 'function':
+          entityConfig = await entityConfigHandler();
+          break;
+        case 'object':
+          entityConfig = entityConfigHandler;
+          break;
+        default:
+          throw new Error(`Invalid entity type (${entityType}) returned at "${path}"`);
+      }
+
+      // Validate entity configuration
+      const result = entityConfigurationSchema.safeParse(entityConfig, {path: ['entities', config.length]});
+      if (!result.success) {
+        throw result.error;
+      }
+    } else if (isSpecial && (fileName === 'index' || fileName === 'config')) {
+      // If this is a special entity file, then ignore as we will capture it another method
+      continue;
+    }
+
+    // Validate project configuration
+    const entityProjectConfig = {
+      ...entityConfig,
+      entity: parents[0],
+      entities: parents,
+      api
+    };
+    entityRootProjectConfigurationSchema.parse(entityProjectConfig);
+
+    config.push(entityProjectConfig);
+  }
+
+  if (!config.some(c => c.entity === 'customers')) {
+    throw new Error(`Missing required entity: "entities/customers"`);
+  }
+  if (!config.some(c => c.entity === '[customer]')) {
+    throw new Error(`Missing required entity: "entities/customers/[customer]"`);
+  }
+
+  // Validate the config
+  entitiesRootProjectConfigurationSchema.parse(config);
+
+  return config;
+}
+

package/src/core/config/index.js

@@ -0,0 +1,31 @@
+import { config } from 'dotenv';
+import fs from 'node:fs';
+import path from 'node:path';
+import loadAgentConfig from './agents.js';
+import loadEntitiesConfig from './entities.js';
+import loadProjectConfig from './project.js';
+import loadWorkflowsConfig from './workflow.js';
+
+
+export function loadEnvConfig({ cwd = process.cwd()} = {}) {
+  const configFilePath = path.resolve(cwd, './.env');
+  config({path: configFilePath});
+  if (!process.env.SCOUT9_API_KEY) {
+    const exists = fs.existsSync(configFilePath);
+    if (!exists) {
+      throw new Error(`Missing .env file with SCOUT9_API_KEY`);
+    } else {
+      throw new Error('Missing SCOUT9_API_KEY within .env file');
+    }
+  }
+}
+export async function loadConfig({ cwd = process.cwd(), folder = 'src'} = {}) {
+  // Load globals
+  loadEnvConfig({cwd});
+  return {
+    ...await loadProjectConfig({cwd, folder}),
+    entities: await loadEntitiesConfig({cwd, folder}),
+    agents: await loadAgentConfig({cwd, folder}),
+    workflows: await loadWorkflowsConfig({cwd, folder})
+  }
+}

package/src/core/config/project.js

@@ -0,0 +1,17 @@
+import path from 'node:path';
+import { requireProjectFile } from '../../utils/index.js';
+import { globSync } from 'glob';
+
+export default async function loadProjectConfig({cwd = process.cwd(), folder = 'src'} = {}) {
+  console.log('loadProjectConfig', {cwd, folder});
+  const paths = globSync(path.resolve(cwd, `${folder}/index.{ts,js}`));
+  if (paths.length === 0) {
+    throw new Error(`Missing main project entry file ${folder}/index.{js|ts}`);
+  } else if (paths.length > 1) {
+    throw new Error(`Multiple main project entry files found ${folder}/index.{js|ts}`);
+  }
+  const [filePath] = paths;
+  const project = await requireProjectFile(filePath).then(mod => mod.default);
+  // @TODO validation type check with zod
+  return project;
+}

package/src/core/config/workflow.js

@@ -0,0 +1,46 @@
+import { globSync } from 'glob';
+import path from 'node:path';
+import {
+  WorkflowConfigurationSchema,
+  WorkflowsConfigurationSchema
+} from '../../runtime/index.js';
+
+
+export default async function loadWorkflowsConfig(
+  {
+    cwd = process.cwd(),
+    folder = 'src'
+  } = {}
+) {
+  console.log('loadWorkflowsConfig', {cwd, folder});
+  const config = globSync(path.resolve(cwd, `${folder}/workflows/**/workflow.{ts,js}`))
+    .map((path) => {
+      const segments = path.split('/');
+      const srcIndex = segments.findIndex((segment, index) => segment === folder && segments[index + 1] === 'workflows');
+      const parents = segments.slice(srcIndex + 2, -1).reverse(); // +2 to skip "${folder}" and "workflows"
+      return {path, parents};
+    })
+    .filter(path => {
+      if (path.parents.length > 0) {
+        return true;
+      } else {
+        console.log(`WARNING: "${path}" Is not a valid entity path, must be contained in a named folder under workflows/`);
+      }
+    })
+    .map(({path, parents}) => {
+
+      // Validate project configuration
+      const workflowConfig = {
+        entity: parents[0],
+        entities: parents,
+      }
+      WorkflowConfigurationSchema.parse(workflowConfig);
+
+      return workflowConfig;
+    });
+
+  // Validate the config
+  WorkflowsConfigurationSchema.parse(config);
+
+  return config;
+}

package/src/core/index.js

@@ -0,0 +1,167 @@
+import archiver from 'archiver';
+import { globSync } from 'glob';
+import { exec } from 'node:child_process';
+import fss from 'node:fs';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import fetch, {FormData} from 'node-fetch';
+import { runInVM } from '../runtime/index.js';
+import { checkVariableType, requireProjectFile } from '../utils/index.js';
+
+
+
+async function runNpmRunBuild({cwd = process.cwd()} = {}) {
+  return new Promise((resolve, reject) => {
+    exec('npm run build', {cwd}, (error, stdout, stderr) => {
+      if (error) {
+        console.error(`Build failed: ${error.message}`);
+        return reject(error);
+      }
+      console.log('Build successful');
+      return resolve(undefined);
+    });
+  });
+}
+
+
+function zipDirectory(source, out) {
+  const archive = archiver('zip', {zlib: {level: 9}});
+  const stream = fss.createWriteStream(out);
+
+  return new Promise((resolve, reject) => {
+    archive
+      .directory(source, false)
+      .on('error', err => reject(err))
+      .pipe(stream);
+
+    stream.on('close', () => resolve(undefined));
+    archive.finalize();
+  });
+}
+
+async function deployZipDirectory(zipFilePath) {
+
+
+  const form = new FormData();
+  const blob = new Blob([await fs.readFile(zipFilePath)], {type: 'application/zip'});
+  form.set("file", blob, path.basename(zipFilePath), {contentType: 'application/zip'});
+  form.set("foo", "bar");
+
+  // @TODO append signature secret header
+  const response = await fetch(`https://pocket-guide.vercel.app/api/b/platform/upload`, {
+    method: 'POST',
+    body: form,
+    headers: {
+      'Authorization': process.env.SCOUT9_API_KEY || ''
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`Server responded with ${response.status}: ${response.statusText}`);
+  }
+
+  console.log('File sent successfully');
+  return true;
+}
+
+async function downloadAndUnpackZip(outputDir) {
+  const downloadLocalResponse = await fetch(
+    `https://pocket-guide.vercel.app/api/b/platform/download`,
+    {
+      headers: {
+        'Authorization': process.env.SCOUT9_API_KEY || ''
+      }
+    }
+  );
+  if (!downloadLocalResponse.ok) {
+    throw new Error(`Error downloading project file ${downloadLocalResponse.statusText}`);
+  }
+
+  try {
+    const buffer = await downloadLocalResponse.arrayBuffer();
+    const decompress = require('decompress');
+    await decompress(buffer, outputDir + '/build');
+
+    console.log('Files unpacked successfully at ' + outputDir + '/build');
+
+    return outputDir + '/build';
+  } catch (error) {
+    console.error('Error unpacking file:', error);
+    throw error;
+  }
+}
+
+export async function getApp({cwd = process.cwd(), folder = 'src', ignoreAppRequire = false} = {}) {
+  const indexTsPath = path.resolve(cwd, folder, 'index.ts');
+  const indexJsPath = path.join(cwd, folder, 'index.js');
+  let exe = '';
+  if (fss.existsSync(indexTsPath)) {
+    exe = path.extname(indexTsPath);
+  } else if (fss.existsSync(indexJsPath)) {
+    exe = path.extname(indexJsPath);
+  } else {
+    throw new Error(`Missing main project entry file ${folder}/index.{js|ts}`);
+  }
+  const filePath = path.resolve(cwd, folder, `app${exe}`);
+  let app;
+  if (!ignoreAppRequire) {
+    app = await requireProjectFile(filePath).then(mod => mod.default);
+    const type = checkVariableType(app);
+    if (!(type === 'function' || type === 'async function')) {
+      throw new Error(`App must return a default function, received "${type}"`);
+    }
+  }
+  return {app, exe, filePath, fileName: `app${exe}`}
+}
+
+
+/**
+ * Runs a given project container from scout9 to given environment
+ */
+export async function run(event, {cwd = process.cwd()} = {}) {
+
+  // @TODO use scout9/admin
+  await downloadAndUnpackZip(path.resolve(cwd, 'tmp'));
+
+  const {filePath, fileName} = await getApp({cwd, folder: 'tmp/build', ignoreAppRequire: true});
+
+  return runInVM(event, {folder: path.resolve(cwd, 'tmp/build'), filePath, fileName});
+}
+
+/**
+ * Builds a local project
+ */
+export async function build({cwd = process.cwd()} = {}, config) {
+  // 1. Lint: Run validation checks
+
+  // Check if app looks good
+  await getApp({cwd, folder: 'src'});
+
+  // Check if workflows look good
+  console.log('@TODO check if workflows are properly written');
+
+  // 2. Build code in user's project
+  await runNpmRunBuild({cwd});
+
+
+  // 3. Remove unnecessary files
+  const files = globSync(path.resolve(cwd, 'build/**/*(*.test.*|*.spec.*)'))
+  for (const file of files) {
+    await fs.unlink(file);
+  }
+
+  // 3. Run tests
+  // console.log('@TODO run tests');
+}
+
+/**
+ * Deploys a local project to scout9
+ */
+export async function deploy({cwd = process.cwd()}) {
+  const zipFilePath = path.join(cwd, 'build.zip');
+  await zipDirectory(path.resolve(cwd, 'build'), zipFilePath);
+
+  console.log('Project zipped successfully.');
+
+  const response = await deployZipDirectory(zipFilePath);
+  console.log('Response from Firebase Function:', response);
+}

package/src/exports.js

@@ -0,0 +1,49 @@
+import { Scout9Platform } from './platform.js';
+import { EventResponse } from './runtime/index.js';
+
+export { EventResponse } from './runtime/index.js';
+// export * from './types';
+export * from './testing-tools/index.js';
+
+export async function run(
+  event,
+  {cwd = process.cwd()} = {},
+) {
+  return Scout9Platform.run(event, {cwd})
+}
+export async function sendEvent(
+  event,
+  {cwd = process.cwd()} = {},
+) {
+  return Scout9Platform.run(event, {cwd})
+}
+
+/**
+ * @param data {T}
+ * @param init {ResponseInit | undefined}
+ * @returns {EventResponse<T>}
+ */
+export function json(data, init) {
+  // TODO deprecate this in favour of `Response.json` when it's
+  // more widely supported
+  const body = JSON.stringify(data);
+
+  // we can't just do `text(JSON.stringify(data), init)` because
+  // it will set a default `content-type` header. duplicated code
+  // means less duplicated work
+  const headers = new Headers(init?.headers);
+  if (!headers.has('content-length')) {
+    headers.set('content-length', encoder.encode(body).byteLength.toString());
+  }
+
+  if (!headers.has('content-type')) {
+    headers.set('content-type', 'application/json');
+  }
+
+  return new EventResponse(data, {
+    ...init,
+    headers
+  });
+}
+
+const encoder = new TextEncoder();

package/src/index.js

@@ -0,0 +1 @@
+export * from './exports.js';

package/src/platform.js

@@ -0,0 +1,71 @@
+import colors from 'kleur';
+import { z } from 'zod';
+import { build as _build, deploy as _deploy, run as _run } from './core/index.js';
+import { loadConfig, loadEnvConfig } from './core/config/index.js';
+import { coalesceToError } from './utils/index.js';
+
+export const Scout9Platform = {
+
+  /**
+   * Builds & Deploys the project
+   */
+  deploy:  async function ({cwd = process.cwd()} = {}) {
+    try {
+      const config = await loadConfig({cwd, folder: 'src'});
+      await _build({cwd}, config);
+      await _deploy({cwd});
+      return config;
+    } catch (e) {
+      this.handleError(e);
+    }
+  },
+
+  /**
+   * Builds the project
+   */
+  build: async function({cwd = process.cwd(), mode = 'development'} = {}) {
+    try {
+      const config = await loadConfig({cwd, folder: 'src'});
+      await _build({cwd}, config);
+      return config;
+    } catch (e) {
+      this.handleError(e);
+    }
+  },
+
+  /**
+   * Runs the project in a container
+   */
+  run: async function (
+    event,
+    {cwd = process.cwd(), mode = 'remote'}
+  ) {
+    if (mode !== 'remote') {
+      throw new Error(`Unimplemented mode "${mode}"`);
+    }
+    try {
+      loadEnvConfig({cwd});
+      return _run(event, {cwd});
+    } catch (e) {
+      this.handleError(e);
+      throw e;
+    }
+  },
+  handleError: function (e) {
+    const error = coalesceToError(e);
+
+    if (error.name === 'SyntaxError') throw error;
+
+    console.error(colors.bold().red(`> ${error.message}`));
+    if (error instanceof z.ZodError) {
+      console.error(error.issues.map(i => colors.red(`${colors.bold(`\tZod Error (${i.code}): `)}"${i.message}" ${JSON.stringify(i.path)}`)).join('\n'));
+      console.error(colors.gray(JSON.stringify(error.format(), null, 2)));
+    }
+
+    if (error.stack) {
+      console.error(colors.gray(error.stack.split('\n').slice(0).join('\n')));
+    }
+
+    process.exit(1);
+  }
+}

package/src/runtime/client/agent.js

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+import { zId } from './utils.js';
+import { MessageSchema } from './message.js';
+
+export const customerValueSchema = z.union([z.boolean(), z.number(), z.string()]);
+
+export const customerSchema = z.object({
+  firstName: z.string().optional(),
+  lastName: z.string().optional(),
+  name: z.string(),
+  email: z.string().nullable().optional(),
+  phone: z.string().nullable().optional(),
+  img: z.string().nullable().optional(),
+  neighborhood: z.string().nullable().optional(),
+  city: z.string().nullable().optional(),
+  country: z.string().nullable().optional(),
+  line1: z.string().nullable().optional(),
+  line2: z.string().nullable().optional(),
+  postal_code: z.string().nullable().optional(),
+  state: z.string().nullable().optional(),
+  town: z.string().nullable().optional(),
+  joined: z.string().nullable().optional(),
+  stripe: z.string().nullable().optional(),
+  stripeDev: z.string().nullable().optional()
+}).catchall(customerValueSchema);
+
+export const agentConfigurationSchema = z.object({
+  id: zId('Agent ID', z.string({description: 'Unique ID for agent'})),
+  firstName: z.string({description: 'Agent first name'}).optional(),
+  lastName: z.string({description: 'Agent last name'}).optional(),
+  inactive: z.boolean({description: 'Agent is inactive'}).optional(),
+  programmablePhoneNumber: z.string({description: 'Programmable phone number'}).optional(),
+  programmablePhoneNumberSid: z.string({description: 'Programmable phone number SID'}).optional(),
+  programmableEmail: z.string({description: 'Email address from Scout9 gmail subdomain'}).optional(),
+  forwardEmail: z.string({description: 'Email address to forward to'}).optional(),
+  forwardPhone: z.string({description: 'Phone number to forward to'}).optional(),
+  title: z.string({description: 'Agent title '}).optional().default('Agent'),
+  context: z.string({description: 'Context of the agent'}).optional().default('You represent the agent when they are away'),
+  includedLocations: z.array(z.string({description: 'Locations the agent is included in'})).optional(),
+  excludedLocations: z.array(z.string({description: 'Locations the agent is excluded from'})).optional(),
+  model: z.enum(['Scout9', 'bard', 'openai']).optional().default('openai'),
+  transcripts: z.array(z.array(MessageSchema)).optional(),
+  audioRef: z.array(z.any()).optional()
+});