@seamapi/cli 0.0.1 → 0.5.0

package/src/lib/interact-for-command-selection.ts

@@ -0,0 +1,107 @@
+import { isDeepStrictEqual as isEqual } from 'node:util'
+
+import prompts from 'prompts'
+
+import type { ContextHelpers } from './types.js'
+
+const uniqBy = <T>(items: T[], keyOf: (item: T) => unknown): T[] => {
+  const seen = new Set<unknown>()
+  return items.filter((item) => {
+    const key = keyOf(item)
+    if (seen.has(key)) return false
+    seen.add(key)
+    return true
+  })
+}
+
+const ergonomicOrder = ['create', 'list', 'get', 'update', 'unlock_door']
+
+function ergonomicSort(aStr: string, bStr: string) {
+  let a = ergonomicOrder.indexOf(aStr)
+  if (a === -1) a = ergonomicOrder.length
+  let b = ergonomicOrder.indexOf(bStr)
+  if (b === -1) b = ergonomicOrder.length
+
+  return a > b ? 1 : a < b ? -1 : 0
+}
+
+export async function interactForCommandSelection(
+  commandPath: string[],
+  helpers: ContextHelpers,
+) {
+  const commands = helpers.blueprint.routes
+    .flatMap((route) => route.endpoints)
+    .map((endpoint) =>
+      endpoint.path.replace(/_/g, '-').replace(/^\//, '').split('/'),
+    )
+    .concat([
+      ['login'],
+      ['logout'],
+      ['config', 'reveal-location'],
+      ['config', 'use-remote-api-defs'],
+      ['select', 'workspace'],
+      ['select', 'server'],
+      ['health', 'get-health'],
+    ])
+
+  const possibleCommands = uniqBy(
+    commandPath.length === 0
+      ? commands
+      : commands.filter((cmd) =>
+          isEqual(cmd.slice(0, commandPath.length), commandPath),
+        ),
+    (v) => v[commandPath.length],
+  )
+
+  if (possibleCommands.length === 0) {
+    throw new Error('No possible commands')
+  }
+
+  if (
+    possibleCommands.length === 1 &&
+    possibleCommands[0]?.length === commandPath.length
+  ) {
+    return commandPath
+  }
+
+  // Add dynamic 'back' command for sub-commands to allow returning
+  // to previous level.
+  if (commandPath.length > 0) {
+    possibleCommands.push([...commandPath, '[Back]'])
+  }
+
+  const commandPathStr = commandPath.join('/').replace(/-/g, '_')
+
+  const res = await prompts({
+    name: 'Command',
+    type: 'autocomplete',
+    choices: [
+      ...possibleCommands.map((cmd) => ({
+        title:
+          cmd?.[commandPath.length] ?? `[Call /${commandPathStr} Directly]`,
+        value: cmd?.[commandPath.length] ?? '<none>',
+      })),
+    ].sort((a, b) => ergonomicSort(a.value, b.value)),
+    message: `Select a command: /${commandPathStr}`,
+  })
+
+  if (res?.Command === undefined) {
+    throw new Error('Bailed')
+  }
+
+  if (res?.Command === '<none>') {
+    return commandPath
+  }
+
+  const newCommandPath = [...commandPath, res.Command]
+
+  const fullCommand = possibleCommands.find((cmd) =>
+    isEqual(newCommandPath, cmd),
+  )
+
+  if (!fullCommand) {
+    return interactForCommandSelection(newCommandPath, helpers)
+  }
+
+  return fullCommand
+}

package/src/lib/interact-for-connected-account.ts

@@ -0,0 +1,24 @@
+import { getSeam } from './get-seam.js'
+import { interactForResource } from './interact-for-resource.js'
+export const interactForConnectedAccount = async () => {
+  const seam = await getSeam()
+
+  return interactForResource({
+    resourceName: 'connected_account',
+    fetchResources: () => seam.connectedAccounts.list(),
+    toChoice: (connectedAccount) => {
+      const identifiers = Object.values(
+        connectedAccount.user_identifier ?? {},
+      ).filter((value): value is string => typeof value === 'string')
+
+      return {
+        title:
+          connectedAccount.user_identifier?.email ??
+          identifiers[0] ??
+          '<No Name>',
+        value: connectedAccount.connected_account_id,
+        description: `${connectedAccount.account_type} ${connectedAccount.connected_account_id}`,
+      }
+    },
+  })
+}

package/src/lib/interact-for-custom-metadata.ts

@@ -0,0 +1,89 @@
+import prompts from 'prompts'
+
+// Structurally the CustomMetadata of @seamapi/types, spelled out here so the
+// published declarations do not depend on a development-only package.
+type CustomMetadata = Record<string, string | boolean>
+
+type UpdatedCustomMetadata = {
+  [x: string]: string | boolean | null
+}
+
+export const interactForCustomMetadata = async (
+  custom_metadata: CustomMetadata,
+) => {
+  const updated_custom_metadata: UpdatedCustomMetadata = { ...custom_metadata }
+
+  const displayCurrentCustomMetadata = () => {
+    console.log('custom_metadata:')
+    if (Object.keys(updated_custom_metadata).length > 0) {
+      Object.keys(updated_custom_metadata).forEach((key, index) => {
+        console.log(`${index + 1}: ${key}: ${updated_custom_metadata[key]}`)
+      })
+    } else {
+      console.log('The custom metadata param is empty.')
+    }
+  }
+
+  let action: string
+
+  do {
+    displayCurrentCustomMetadata()
+
+    const response = await prompts({
+      type: 'select',
+      name: 'action',
+      message: 'Choose an action:',
+      choices: [
+        { title: 'Add an item to params', value: 'add' },
+        { title: 'Remove an item from params', value: 'remove' },
+        { title: 'Finish editing params', value: 'done' },
+      ],
+    })
+
+    action = response.action
+
+    if (action === 'add') {
+      const { newKey } = await prompts({
+        type: 'text',
+        name: 'newKey',
+        message: 'Enter a key to add or edit:',
+      })
+
+      let { newValue } = await prompts({
+        type: 'text',
+        name: 'newValue',
+        message: 'Enter the new value to add or edit (or null to delete):',
+      })
+      if (newKey) {
+        if (newValue === 'false' || newValue === 'true') {
+          newValue = Boolean(newValue)
+        }
+        if (newValue === 'null') {
+          updated_custom_metadata[newKey] = null
+        } else {
+          updated_custom_metadata[newKey] = newValue
+        }
+      }
+    } else if (action === 'remove') {
+      const { custom_key_to_remove } = await prompts({
+        type: 'select',
+        name: 'custom_key_to_remove',
+        message: 'Choose a key-value pair to remove from params:',
+        choices: Object.keys(updated_custom_metadata).map(
+          (custom_metadata_key) => {
+            return {
+              title: `${custom_metadata_key}: ${updated_custom_metadata[custom_metadata_key]}`,
+              value: custom_metadata_key,
+            }
+          },
+        ),
+      })
+
+      if (custom_key_to_remove) {
+        delete custom_metadata[custom_key_to_remove]
+      }
+    }
+  } while (action !== 'done')
+
+  return updated_custom_metadata
+}

package/src/lib/interact-for-device.ts

@@ -0,0 +1,15 @@
+import { getSeam } from './get-seam.js'
+import { interactForResource } from './interact-for-resource.js'
+export const interactForDevice = async () => {
+  const seam = await getSeam()
+
+  return interactForResource({
+    resourceName: 'device',
+    fetchResources: () => seam.devices.list(),
+    toChoice: (device) => ({
+      title: device.properties.name ?? '<No Name>',
+      value: device.device_id,
+      description: `${device.device_type} ${device.device_id}`,
+    }),
+  })
+}

package/src/lib/interact-for-login.ts

@@ -0,0 +1,53 @@
+import { isApiKey, isPersonalAccessToken } from '@seamapi/http/connect'
+import chalk from 'chalk'
+import prompts from 'prompts'
+
+import { getConfigStore } from './get-config-store.js'
+import { getServer } from './get-server.js'
+import { interactForWorkspaceId } from './interact-for-workspace-id.js'
+import { withLoading } from './util/with-loading.js'
+import { validateToken } from './validate-token.js'
+
+export const interactForLogin = async () => {
+  const config = await getConfigStore()
+
+  if (getServer().includes('localhost')) {
+    console.log(
+      `You're using a local Seam Connect instance, you can enter the API Key to your local user, you can create a new user from:\n\n${getServer()}/admin/create_user_with_api_key`,
+    )
+  } else {
+    console.log(
+      `To login, navigate to the URL below and create a new Personal Access Token (PAT) and paste the PAT in the provided box:\n\nhttps://console.seam.co/settings/access-tokens\n\n`,
+    )
+  }
+
+  console.log(
+    chalk.gray(
+      '> Note: You can enter an API Key here for single-workspace access',
+    ),
+  )
+
+  const { pat } = await prompts({
+    name: 'pat',
+    type: 'text',
+    message: 'Personal Access Token:',
+  })
+  const token = pat?.trim()
+
+  if (!token) {
+    throw new Error('No token provided')
+  }
+
+  if (isPersonalAccessToken(token)) {
+    await interactForWorkspaceId(token)
+  } else if (isApiKey(token)) {
+    await withLoading('Validating API key...', () => validateToken(token))
+  } else {
+    throw new Error(
+      'Invalid token: expected a Personal Access Token or API Key',
+    )
+  }
+
+  config.set(`${getServer()}.pat`, token)
+  console.log(`Token saved! You may begin using the CLI!`)
+}

package/src/lib/interact-for-resource.ts

@@ -0,0 +1,34 @@
+import prompts from 'prompts'
+
+import { withLoading } from './util/with-loading.js'
+
+export interface ResourceChoice {
+  title: string
+  value: string
+  description?: string
+}
+
+export const interactForResource = async <Resource>({
+  resourceName,
+  fetchResources,
+  toChoice,
+  message = `Select a ${resourceName}:`,
+}: {
+  resourceName: string
+  fetchResources: () => Promise<Resource[]>
+  toChoice: (resource: Resource) => ResourceChoice
+  message?: string | undefined
+}) => {
+  const resources = await withLoading(
+    `Fetching ${resourceName.replace(/_/g, ' ')}s...`,
+    fetchResources,
+  )
+  const { resourceId } = await prompts({
+    name: 'resourceId',
+    type: 'autocomplete',
+    message,
+    choices: resources.map(toChoice),
+  })
+
+  return resourceId as string
+}

package/src/lib/interact-for-server-selection.ts

@@ -0,0 +1,46 @@
+import { randomBytes } from 'node:crypto'
+
+import prompts from 'prompts'
+
+import { getConfigStore } from './get-config-store.js'
+import { getServer } from './get-server.js'
+
+export async function interactForServerSelection() {
+  const servers = [
+    'http://localhost:3020',
+    'https://connect.getseam.com',
+    'https://fakeseamconnect.seam.vc',
+  ]
+
+  const { server } = await prompts([
+    {
+      type: 'select',
+      name: 'server',
+      message: 'Select a server:',
+      choices: servers.map((server) => ({ title: server, value: server })),
+    },
+  ])
+
+  const config = getConfigStore()
+  if (server === servers[2]) {
+    let { userUrlSeed } = await prompts([
+      {
+        type: 'text',
+        name: 'userUrlSeed',
+        message:
+          'You can input a custom server URL or leave this field empty to use a new fakeserver.',
+      },
+    ])
+
+    if (userUrlSeed.trim().length === 0) {
+      userUrlSeed = randomBytes(5).toString('hex')
+    }
+    config.set('server', `https://${userUrlSeed}.fakeseamconnect.seam.vc`)
+    config.set(`${getServer()}.pat`, `seam_apikey1_token`)
+    console.log(`PAT set to use fakeseamconnect with "seam_apikey1_token"`)
+  } else {
+    config.set('server', server)
+  }
+  config.delete('current_workspace_id')
+  console.log(`Server set to ${server}`)
+}

package/src/lib/interact-for-timestamp.ts

@@ -0,0 +1,10 @@
+import prompts from 'prompts'
+export const interactForTimestamp = async () => {
+  const { timestamp } = await prompts({
+    name: 'timestamp',
+    type: 'date',
+    message: 'Enter a timestamp:',
+  })
+
+  return timestamp.toISOString()
+}

package/src/lib/interact-for-use-remote-api-defs.ts

@@ -0,0 +1,27 @@
+import prompts from 'prompts'
+
+import { getConfigStore } from './get-config-store.js'
+
+export async function interactForUseRemoteApiDefs() {
+  const { use_remote_api_defs } = await prompts([
+    {
+      type: 'select',
+      name: 'use_remote_api_defs',
+      message: 'Always use remote API Definitions?',
+      choices: [
+        {
+          title: 'Yes',
+          value: true,
+        },
+        {
+          title: 'No',
+          value: false,
+        },
+      ],
+    },
+  ])
+
+  const config = getConfigStore()
+  config.set('use_remote_api_defs', use_remote_api_defs)
+  console.log(`Use remote API Definitions: ${use_remote_api_defs}`)
+}

package/src/lib/interact-for-user-identity.ts

@@ -0,0 +1,16 @@
+import { getSeam } from './get-seam.js'
+import { interactForResource } from './interact-for-resource.js'
+
+export const interactForUserIdentity = async () => {
+  const seam = await getSeam()
+
+  return interactForResource({
+    resourceName: 'user_identity',
+    fetchResources: () => seam.userIdentities.list(),
+    toChoice: (userIdentity) => ({
+      title: `${userIdentity.email_address} "${userIdentity.full_name}: ${userIdentity.user_identity_key}`,
+      value: userIdentity.user_identity_id,
+      description: userIdentity.user_identity_id,
+    }),
+  })
+}

package/src/lib/interact-for-workspace-id.ts

@@ -0,0 +1,37 @@
+import { SeamHttpWithoutWorkspace } from '@seamapi/http/connect'
+import prompts from 'prompts'
+
+import { getConfigStore } from './get-config-store.js'
+import { getSeamMultiWorkspace } from './get-seam.js'
+import { getServer } from './get-server.js'
+import { withLoading } from './util/with-loading.js'
+
+export const interactForWorkspaceId = async (personalAccessToken?: string) => {
+  const config = getConfigStore()
+  const seam = personalAccessToken
+    ? SeamHttpWithoutWorkspace.fromPersonalAccessToken(personalAccessToken, {
+        endpoint: getServer(),
+      })
+    : await getSeamMultiWorkspace()
+
+  const workspaces = await withLoading('Fetching workspaces...', () =>
+    seam.workspaces.list(),
+  )
+  const { workspaceId } = await prompts({
+    name: 'workspaceId',
+    type: 'select',
+    message: 'Select a workspace:',
+    choices: workspaces.map((workspace: any) => ({
+      title: workspace.name,
+      value: workspace.workspace_id,
+      description: workspace.workspace_id,
+    })),
+  })
+
+  if (workspaceId) {
+    config.set('current_workspace_id', workspaceId)
+    return workspaceId
+  }
+
+  throw new Error('Bailed')
+}

package/src/lib/types.ts

@@ -0,0 +1,6 @@
+import type { ApiBlueprint } from './get-api-blueprint.js'
+
+export interface ContextHelpers {
+  blueprint: ApiBlueprint
+  is_interactive: boolean
+}

package/src/lib/util/ellipsis.ts

@@ -0,0 +1,4 @@
+export const ellipsis = (str: string, len: number) => {
+  if (str.length <= len) return str
+  return str.slice(0, len - 3) + '...'
+}

package/src/lib/util/request-seam-api.ts

@@ -0,0 +1,43 @@
+import chalk from 'chalk'
+
+import { getSeam } from 'lib/get-seam.js'
+
+import { withLoading } from './with-loading.js'
+
+export const RequestSeamApi = async ({
+  path,
+  params,
+}: {
+  path: string
+  params: Record<string, any>
+}) => {
+  const seam = await getSeam()
+
+  logRequest(path, params)
+
+  const response = await withLoading('Making request...', () =>
+    seam.client.post(path, params, {
+      validateStatus: () => true,
+    }),
+  )
+
+  logResponse(response)
+
+  return response
+}
+
+const logResponse = (response: { status: number; data: unknown }) => {
+  if (response.status >= 400) {
+    console.log(chalk.red(`\n\n[${response.status}]\n`))
+  } else {
+    console.log(chalk.green(`\n\n[${response.status}]`))
+  }
+  console.dir(response.data, { depth: null })
+  console.log('\n')
+}
+
+const logRequest = (apiPath: string, params: Record<string, any>) => {
+  console.log(`\n\n${chalk.green(apiPath)}`)
+  console.log(`Request Params:`)
+  console.log(params)
+}

package/src/lib/util/with-loading.ts

@@ -0,0 +1,16 @@
+import { createSpinner } from 'nanospinner'
+
+export const withLoading = async <T>(
+  message: string,
+  fn: () => Promise<T>,
+): Promise<T> => {
+  const spinner = createSpinner(message).start()
+  try {
+    const result = await fn()
+    spinner.success()
+    return result
+  } catch (error) {
+    spinner.error()
+    throw error
+  }
+}

package/src/lib/validate-token.ts

@@ -0,0 +1,28 @@
+import {
+  isApiKey,
+  isPersonalAccessToken,
+  SeamHttp,
+  SeamHttpWithoutWorkspace,
+} from '@seamapi/http/connect'
+
+import { getServer } from './get-server.js'
+
+export const validateToken = async (token: string, workspaceId?: string) => {
+  const options = { endpoint: getServer() }
+
+  if (isPersonalAccessToken(token)) {
+    const seam = workspaceId
+      ? SeamHttp.fromPersonalAccessToken(token, workspaceId, options)
+      : SeamHttpWithoutWorkspace.fromPersonalAccessToken(token, options)
+    await seam.workspaces.list()
+    return
+  }
+
+  if (isApiKey(token)) {
+    const seam = SeamHttp.fromApiKey(token, options)
+    await seam.workspaces.list()
+    return
+  }
+
+  throw new Error('Invalid token: expected a Personal Access Token or API Key')
+}

package/src/lib/version.ts

@@ -0,0 +1,3 @@
+const seamapiCliVersion = '0.5.0'
+
+export default seamapiCliVersion

package/src/lib/index.ts

@@ -1 +0,0 @@
-export { todo } from './todo.js'

package/src/lib/todo.ts

@@ -1 +0,0 @@
-export const todo = (x: string): string => x