@sentio/cli 1.37.5-rc.7 → 2.0.0-development

package/src/commands/login-server.ts

@@ -1,119 +0,0 @@
-import express from 'express'
-import { getAuthConfig, getFinalizedHost } from '../config'
-import url, { URL } from 'url'
-import fetch from 'node-fetch'
-import { getCliVersion } from '../utils'
-import { WriteKey } from '../key'
-import chalk from 'chalk'
-import http from 'http'
-import os from 'os'
-import * as crypto from 'crypto'
-
-interface AuthParams {
-  serverPort: number
-  sentioHost: string
-  codeVerifier: string
-}
-
-const app = express()
-
-let server: http.Server
-let authParams: AuthParams
-
-export function startServer(params: AuthParams) {
-  authParams = params
-  server = app.listen(params.serverPort)
-}
-
-app.get('/callback', async (req, res) => {
-  res.end('login success, please go back to CLI to continue')
-  const host = getFinalizedHost(authParams.sentioHost)
-  const code = req.query.code
-  if (!code || (code as string).length == 0) {
-    return
-  }
-
-  // exchange token
-  const tokenResRaw = await getToken(host, code as string)
-  if (!tokenResRaw.ok) {
-    console.error(chalk.red('request token error, code:', tokenResRaw.status, tokenResRaw.statusText))
-    return
-  }
-  const tokenRes = await tokenResRaw.json()
-  const accessToken = tokenRes['access_token']
-
-  // check if the account is ready
-  const userResRaw = await getUser(host, accessToken)
-  if (!userResRaw.ok) {
-    if (userResRaw.status == 401) {
-      console.error(chalk.red('please sign up on sentio first'))
-    } else {
-      console.error(chalk.red('get user error, code:', userResRaw.status, userResRaw.statusText))
-    }
-    return
-  }
-  const userRes = await userResRaw.json()
-  if (!userRes.emailVerified) {
-    console.error(chalk.red('please verify your email first'))
-    return
-  }
-
-  // create API key
-  const apiKeyName = `${os.hostname()}-${crypto.randomBytes(4).toString('hex')}`
-  const createApiKeyResRaw = await createApiKey(host, apiKeyName, 'sdk_generated', accessToken)
-  if (!createApiKeyResRaw.ok) {
-    console.error(chalk.red('create api key error, code:', createApiKeyResRaw.status, createApiKeyResRaw.statusText))
-    return
-  }
-  const createApiKeyRes = await createApiKeyResRaw.json()
-  const apiKey = createApiKeyRes['key']
-  WriteKey(host, apiKey)
-  console.log(chalk.green('login success, new API key: ' + apiKey))
-
-  server.close()
-})
-
-async function getToken(host: string, code: string) {
-  const authConf = getAuthConfig(host)
-  const params = new url.URLSearchParams({
-    grant_type: 'authorization_code',
-    client_id: authConf.clientId,
-    code_verifier: authParams.codeVerifier,
-    code: code,
-    redirect_uri: `http://localhost:${authParams.serverPort}/callback`,
-  })
-  return fetch(`${authConf.domain}/oauth/token`, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/x-www-form-urlencoded',
-    },
-    body: params.toString(),
-  })
-}
-
-async function createApiKey(host: string, name: string, source: string, accessToken: string) {
-  const createApiKeyUrl = new URL('/api/v1/keys', host)
-  return fetch(createApiKeyUrl, {
-    method: 'POST',
-    headers: {
-      Authorization: 'Bearer ' + accessToken,
-      version: getCliVersion(),
-    },
-    body: JSON.stringify({
-      name: name,
-      scopes: ['write:project'],
-      source: source,
-    }),
-  })
-}
-
-async function getUser(host: string, accessToken: string) {
-  const getUserUrl = new URL('/api/v1/users', host)
-  return fetch(getUserUrl, {
-    method: 'GET',
-    headers: {
-      Authorization: 'Bearer ' + accessToken,
-      version: getCliVersion(),
-    },
-  })
-}

package/src/commands/run-create.ts

@@ -1,126 +0,0 @@
-import commandLineArgs from 'command-line-args'
-import commandLineUsage from 'command-line-usage'
-import path from 'path'
-import fs from 'fs-extra'
-import chalk from 'chalk'
-import latestVersion from 'latest-version'
-
-export async function runCreate(argv: string[]) {
-  const optionDefinitions = [
-    {
-      name: 'help',
-      alias: 'h',
-      type: Boolean,
-      description: 'Display this usage guide.',
-    },
-    {
-      name: 'name',
-      alias: 'n',
-      defaultOption: true,
-      type: String,
-      description: 'Project name',
-    },
-    {
-      name: 'directory',
-      alias: 'd',
-      description: '(Optional) The root direct new project will be created, default current working dir',
-      type: String,
-    },
-    {
-      name: 'chain-type',
-      alias: 'c',
-      description:
-        'The type of project you want to create, can be evm, aptos, solana, raw (if you want to start from scratch and support multiple types of chains)',
-      type: String,
-      defaultValue: 'evm',
-    },
-  ]
-
-  const options = commandLineArgs(optionDefinitions, { argv })
-  const usage = commandLineUsage([
-    {
-      header: 'Create a template project',
-      content: 'sentio create <name>',
-    },
-    {
-      header: 'Options',
-      optionList: optionDefinitions,
-    },
-  ])
-
-  if (options.help || !options.name) {
-    console.log(usage)
-  } else {
-    const chainType: string = options['chain-type'].toLowerCase()
-    switch (chainType) {
-      case 'evm':
-        break
-      case 'aptos':
-        break
-      case 'raw':
-        break
-      case 'solana':
-        break
-      default:
-        console.error(chalk.red('non supported chain-type for template creation, use --help for more information.'))
-        console.log(usage)
-        process.exit(1)
-    }
-    const templateFolder = path.resolve(__dirname, '../../templates', chainType)
-    const projectName = options.name || 'default'
-
-    const rootDir = options.directory || process.cwd()
-    const dstFolder = path.resolve(rootDir, projectName)
-    if (fs.existsSync(dstFolder)) {
-      console.error(chalk.red("can't create project '" + projectName + "', directory already existed"))
-      process.exit(1)
-    }
-
-    fs.copySync(templateFolder, dstFolder, {
-      filter: (src, _) => {
-        // TODO read from .gitignore to be more reliable
-        if (
-          src.endsWith('types') ||
-          src.endsWith('dist') ||
-          src.endsWith('node_modules') ||
-          src.endsWith('.lock') ||
-          src.endsWith('dist')
-        ) {
-          return false
-        }
-        return true
-      },
-      overwrite: false,
-    })
-    if (options.name) {
-      const sentioYamlPath = path.resolve(dstFolder, 'sentio.yaml')
-      fs.writeFileSync(sentioYamlPath, 'project: ' + projectName + '\n', { flag: 'w+' })
-
-      const packageJsonPath = path.resolve(dstFolder, 'package.json')
-      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'))
-
-      const sdkVersion = '^' + (await latestVersion('@sentio/sdk'))
-      packageJson.dependencies['@sentio/sdk'] = sdkVersion
-
-      switch (chainType) {
-        case 'aptos':
-          packageJson.dependencies['@sentio/sdk-aptos'] = sdkVersion
-          break
-        case 'solana':
-          packageJson.dependencies['@sentio/sdk-solana'] = sdkVersion
-          break
-        default:
-      }
-
-      const cliVersion = '^' + (await latestVersion('@sentio/cli'))
-      packageJson.devDependencies['@sentio/cli'] = cliVersion
-      packageJson.name = projectName
-
-      // Don't add directly to avoid deps issue
-      packageJson.scripts.postinstall = 'sentio gen'
-
-      fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2))
-    }
-    console.log(chalk.green("successfully create project '" + projectName + "'"))
-  }
-}

package/src/commands/run-login.ts

@@ -1,111 +0,0 @@
-import commandLineArgs from 'command-line-args'
-import commandLineUsage from 'command-line-usage'
-import { getAuthConfig, getFinalizedHost } from '../config'
-import { startServer } from './login-server'
-import url, { URL } from 'url'
-import * as crypto from 'crypto'
-import chalk from 'chalk'
-import { WriteKey } from '../key'
-import fetch from 'node-fetch'
-import open from 'open'
-
-const port = 20000
-
-export function runLogin(argv: string[]) {
-  const optionDefinitions = [
-    {
-      name: 'help',
-      alias: 'h',
-      type: Boolean,
-      description: 'Display this usage guide.',
-    },
-    {
-      name: 'host',
-      description: '(Optional) Override Sentio Host name',
-      type: String,
-    },
-    {
-      name: 'api-key',
-      type: String,
-      description: '(Optional) Your API key',
-    },
-  ]
-  const options = commandLineArgs(optionDefinitions, { argv })
-
-  const host = getFinalizedHost(options.host)
-  if (options.help) {
-    const usage = commandLineUsage([
-      {
-        header: 'Login to Sentio',
-        content: 'sentio login',
-      },
-      {
-        header: 'Options',
-        optionList: optionDefinitions,
-      },
-    ])
-    console.log(usage)
-  } else if (options['api-key']) {
-    console.log(chalk.blue('login to ' + host))
-    const apiKey = options['api-key']
-    checkKey(host, apiKey).then((res) => {
-      if (res.status == 200) {
-        WriteKey(host, apiKey)
-        console.log(chalk.green('login success'))
-      } else {
-        console.error(chalk.red('login failed, code:', res.status, res.statusText))
-      }
-    })
-  } else {
-    // https://auth0.com/docs/get-started/authentication-and-authorization-flow/call-your-api-using-the-authorization-code-flow-with-pkce
-    const verifier = base64URLEncode(crypto.randomBytes(32))
-    const challenge = base64URLEncode(sha256(verifier))
-
-    const conf = getAuthConfig(host)
-    if (conf.domain === '') {
-      console.error(chalk.red('invalid host, try login with an API key if it is a dev env'))
-      return
-    }
-    const authURL = new URL(conf.domain + `/authorize?`)
-    const params = new url.URLSearchParams({
-      response_type: 'code',
-      code_challenge: challenge,
-      code_challenge_method: 'S256',
-      client_id: conf.clientId,
-      redirect_uri: `http://localhost:${port}/callback`,
-      audience: conf.audience,
-      prompt: 'login',
-    })
-    authURL.search = params.toString()
-
-    console.log('Continue your authorization in the browser')
-    open(authURL.toString()).catch((reason) => {
-      console.error(chalk.red('Unable to open browser: ' + reason))
-      console.error(chalk.red('Open this url in your browser: ' + authURL.toString()))
-    })
-
-    startServer({
-      serverPort: port,
-      sentioHost: options.host,
-      codeVerifier: verifier,
-    })
-  }
-}
-
-function base64URLEncode(str: Buffer) {
-  return str.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '')
-}
-
-function sha256(str: string) {
-  return crypto.createHash('sha256').update(str).digest()
-}
-
-async function checkKey(host: string, apiKey: string) {
-  const checkApiKeyUrl = new URL('/api/v1/processors/check_key', host)
-  return fetch(checkApiKeyUrl, {
-    method: 'GET',
-    headers: {
-      'api-key': apiKey,
-    },
-  })
-}

package/src/commands/run-version.ts

@@ -1,38 +0,0 @@
-import commandLineArgs from 'command-line-args'
-import commandLineUsage from 'command-line-usage'
-import { getCliVersion, getSdkVersion } from '../utils'
-import * as console from 'console'
-
-export function runVersion(argv: string[]) {
-  const optionDefinitions = [
-    {
-      name: 'help',
-      alias: 'h',
-      type: Boolean,
-      description: 'Display this usage guide.',
-    },
-  ]
-  const options = commandLineArgs(optionDefinitions, { argv })
-
-  if (options.help) {
-    const usage = commandLineUsage([
-      {
-        header: 'Show current version',
-        content: 'sentio version',
-      },
-      {
-        header: 'Options',
-        optionList: optionDefinitions,
-      },
-    ])
-    console.log(usage)
-  } else {
-    console.log('CLI Version: ', getCliVersion())
-    const sdkVersion = getSdkVersion()
-    if (sdkVersion) {
-      console.log('SDK Version: ', sdkVersion)
-    } else {
-      console.log('SDK Not installed for this project')
-    }
-  }
-}

package/src/config.ts

@@ -1,72 +0,0 @@
-const HostMap: { [host: string]: string } = {
-  local: 'http://localhost:10000',
-  test: 'https://test.sentio.xyz',
-  staging: 'https://staging.sentio.xyz',
-  prod: 'https://app.sentio.xyz',
-}
-
-export interface SentioProjectConfig {
-  project: string
-  host: string
-  // source: string
-  build: boolean
-  // targets: Target[]
-  debug: boolean
-}
-
-export function getFinalizedHost(host: string): string {
-  if (host === undefined || host === '') {
-    host = 'prod'
-  }
-  return HostMap[host] ?? host
-}
-
-export function getAuthConfig(host: string): { domain: string; clientId: string; audience: string } {
-  let domain = '',
-    clientId = '',
-    audience = ''
-  switch (host) {
-    case HostMap['local']:
-      domain = 'https://sentio-dev.us.auth0.com'
-      clientId = 'qGDisObqQbcPeRA8k02POPZ2Df4KVCna'
-      audience = 'http://localhost:8080/v1'
-      break
-    case HostMap['prod']:
-      domain = 'https://auth.sentio.xyz'
-      clientId = 'xd80PeuvuZVHpBFh7yEdlSZdtE5mTpGe'
-      audience = 'https://app.sentio.xyz/api/v1'
-      break
-    case HostMap['test']:
-    case HostMap['staging']:
-      domain = 'https://auth.test.sentio.xyz'
-      clientId = 'qXVvovHaOE37SndxTZJxCKgZjw1axPax'
-      audience = 'https://test.sentio.xyz/api/v1'
-      break
-    default:
-      break
-  }
-  return { domain, clientId, audience }
-}
-
-export function finalizeHost(config: SentioProjectConfig) {
-  config.host = getFinalizedHost(config.host)
-}
-
-export function FinalizeProjectName(config: SentioProjectConfig, owner: string | undefined) {
-  if (owner) {
-    let name = config.project
-    if (name.includes('/')) {
-      name = config.project.split('/')[1]
-    }
-    config.project = [owner, name].join('/')
-  }
-}
-
-// export interface Target {
-//   chain: string
-//   abisDir?: string
-// }
-//
-// // Supported target chain, lower case
-// export const EVM = 'evm'
-// export const SOLANA = 'solana'

package/src/key.ts

@@ -1,43 +0,0 @@
-import path from 'path'
-import fs from 'fs'
-import os from 'os'
-
-const homeDir = os.homedir()
-const sentioDir = path.join(homeDir, '.sentio')
-const configFile = path.join(sentioDir, 'config.json')
-
-interface SentioKeyConfig {
-  [key: string]: {
-    api_keys: string
-  }
-}
-
-export function WriteKey(host: string, api_key: string) {
-  const sentioDir = path.join(homeDir, '.sentio')
-  if (!fs.existsSync(sentioDir)) {
-    fs.mkdirSync(sentioDir, { recursive: true })
-  }
-  let config: SentioKeyConfig = {}
-  if (fs.existsSync(configFile)) {
-    const content = fs.readFileSync(configFile, 'utf8')
-    config = JSON.parse(content)
-  }
-  const hostConfig = config[host] || { api_keys: {} }
-  hostConfig.api_keys = api_key
-  config[host] = hostConfig
-  fs.writeFileSync(configFile, JSON.stringify(config, null, 2))
-}
-
-export function ReadKey(host: string): string | undefined {
-  if (!fs.existsSync(sentioDir)) {
-    return undefined
-  }
-  const configFile = path.join(sentioDir, 'config.json')
-  if (fs.existsSync(configFile)) {
-    const content = fs.readFileSync(configFile, 'utf8')
-    const config = JSON.parse(content)
-    return config[host]?.api_keys
-  } else {
-    return undefined
-  }
-}