@seamapi/cli 0.0.1 → 0.4.0

package/src/lib/interact-for-blueprint-object.ts

@@ -0,0 +1,274 @@
+import type { Parameter } from '@seamapi/blueprint'
+import prompts from 'prompts'
+
+import { interactForAccessCode } from './interact-for-access-code.js'
+import { interactForAcsEntrance } from './interact-for-acs-entrance.js'
+import { interactForAcsSystem } from './interact-for-acs-system.js'
+import { interactForAcsUser } from './interact-for-acs-user.js'
+import { interactForArray } from './interact-for-array.js'
+import { interactForConnectedAccount } from './interact-for-connected-account.js'
+import { interactForCustomMetadata } from './interact-for-custom-metadata.js'
+import { interactForDevice } from './interact-for-device.js'
+import { interactForTimestamp } from './interact-for-timestamp.js'
+import { interactForUserIdentity } from './interact-for-user-identity.js'
+import type { ContextHelpers } from './types.js'
+import { ellipsis } from './util/ellipsis.js'
+
+const ergonomicPropOrder = [
+  'name',
+  'connected_account_id',
+  'device_id',
+  'access_code_id',
+  'user_identity_id',
+  'code',
+  'starts_at',
+  'ends_at',
+]
+
+export const interactForBlueprintObject = async (
+  args: {
+    command: string[]
+    parameters: Parameter[]
+    params: Record<string, any>
+    isSubProperty?: boolean
+    subPropertyPath?: string
+  },
+  ctx: ContextHelpers,
+): Promise<any> => {
+  // Clone args and args params so that we can mutate it
+  args = { ...args, params: { ...args.params } }
+
+  const properties = Object.fromEntries(
+    args.parameters.map((parameter) => [parameter.name, parameter]),
+  )
+  const required = args.parameters
+    .filter((parameter) => parameter.isRequired)
+    .map((parameter) => parameter.name)
+
+  const haveAllRequiredParams = required.every((k) => args.params[k])
+
+  const should_auto_submit =
+    !ctx.is_interactive && haveAllRequiredParams && !args.isSubProperty
+  if (should_auto_submit) {
+    return args.params
+  }
+
+  const propSortScore = (prop: string) => {
+    if (required.includes(prop)) return 100 - ergonomicPropOrder.indexOf(prop)
+    if (args.params[prop] !== undefined) {
+      return 50 - Object.keys(args.params).indexOf(prop)
+    }
+    return ergonomicPropOrder.indexOf(prop)
+  }
+
+  const cmdPath = `/${args.command.join('/').replace(/-/g, '_')}`
+  const parameterSelectionMessage = args.isSubProperty
+    ? `Editing "${args.subPropertyPath}"`
+    : `[${cmdPath}] Parameters`
+
+  console.log('')
+  const { paramToEdit } = await prompts({
+    name: 'paramToEdit',
+    message: parameterSelectionMessage,
+    type: 'autocomplete',
+    choices: [
+      ...(haveAllRequiredParams && !args.isSubProperty
+        ? [
+            {
+              value: 'done',
+              title: `[Make API Call] ${cmdPath}`,
+            },
+          ]
+        : []),
+      ...(haveAllRequiredParams && args.isSubProperty
+        ? [
+            {
+              title: `[Save]`,
+              value: 'done',
+            },
+          ]
+        : []),
+      ...Object.keys(properties)
+        .map((k) => {
+          return {
+            title: k + (required.includes(k) ? '*' : ''),
+            value: k,
+            description:
+              args.params[k] !== undefined
+                ? typeof args.params[k] === 'object'
+                  ? ellipsis(JSON.stringify(args.params[k]), 60)
+                  : `[${args.params[k]}]`
+                : undefined,
+          }
+        })
+        .sort((a, b) => propSortScore(b.value) - propSortScore(a.value)),
+      ...(args.isSubProperty
+        ? [
+            {
+              title: `[Leave Empty]`,
+              value: 'empty',
+            },
+          ]
+        : []),
+      {
+        title: `[Back]`,
+        value: 'back',
+      },
+    ],
+  })
+
+  if (paramToEdit === 'empty') {
+    return undefined
+  }
+
+  if (paramToEdit === 'done') {
+    // TODO check for required
+    return args.params
+  }
+
+  if (paramToEdit === 'back') {
+    if (args.subPropertyPath) {
+      return args.params
+    }
+
+    return '[Back]'
+  }
+
+  const prop = properties[paramToEdit]
+
+  if (paramToEdit === 'device_id') {
+    args.params[paramToEdit] = await interactForDevice()
+    return interactForBlueprintObject(args, ctx)
+  } else if (paramToEdit === 'access_code_id') {
+    args.params[paramToEdit] = await interactForAccessCode(args.params as any)
+    return interactForBlueprintObject(args, ctx)
+  } else if (paramToEdit === 'connected_account_id') {
+    const connected_account_id = await interactForConnectedAccount()
+    args.params[paramToEdit] = connected_account_id
+    return interactForBlueprintObject(args, ctx)
+  } else if (
+    paramToEdit === 'user_identity_id' ||
+    paramToEdit === 'user_identity_ids'
+  ) {
+    const user_identity_id = await interactForUserIdentity()
+    args.params[paramToEdit] =
+      paramToEdit === 'user_identity_ids'
+        ? [user_identity_id]
+        : user_identity_id
+    return interactForBlueprintObject(args, ctx)
+  } else if (paramToEdit.endsWith('acs_system_id')) {
+    args.params[paramToEdit] = await interactForAcsSystem()
+    return interactForBlueprintObject(args, ctx)
+  } else if (paramToEdit.endsWith('acs_user_id')) {
+    args.params[paramToEdit] = await interactForAcsUser()
+    return interactForBlueprintObject(args, ctx)
+  } else if (paramToEdit.endsWith('acs_entrance_id')) {
+    args.params['acs_entrance_id'] = await interactForAcsEntrance()
+    return interactForBlueprintObject(args, ctx)
+  } else if (
+    paramToEdit.endsWith('_at') ||
+    paramToEdit === 'since' ||
+    paramToEdit.endsWith('_before') ||
+    paramToEdit.endsWith('_after')
+  ) {
+    args.params[paramToEdit] = await interactForTimestamp()
+    return interactForBlueprintObject(args, ctx)
+  } else if (paramToEdit === 'custom_metadata') {
+    args.params[paramToEdit] = await interactForCustomMetadata(
+      args.params[paramToEdit] || {},
+    )
+    return interactForBlueprintObject(args, ctx)
+  }
+
+  if (prop) {
+    if (['string', 'id', 'datetime'].includes(prop.format)) {
+      let value
+      if (prop.format === 'datetime') {
+        value = await interactForTimestamp()
+      } else {
+        value = (
+          await prompts({
+            name: 'value',
+            message: `${paramToEdit}:`,
+            type: 'text',
+          })
+        ).value
+      }
+      args.params[paramToEdit] = value
+      return interactForBlueprintObject(args, ctx)
+    } else if (prop.format === 'enum') {
+      const value = (
+        await prompts({
+          name: 'value',
+          message: `${paramToEdit}:`,
+          type: 'select',
+          choices: prop.values.map((v) => ({
+            title: v.name,
+            value: v.name,
+          })),
+        })
+      ).value
+      args.params[paramToEdit] = value
+      return interactForBlueprintObject(args, ctx)
+    } else if (prop.format === 'boolean') {
+      const { value } = await prompts({
+        name: 'value',
+        message: `${paramToEdit}:`,
+        type: 'toggle',
+        initial: true,
+        active: 'true',
+        inactive: 'false',
+      })
+
+      args.params[paramToEdit] = value
+
+      return interactForBlueprintObject(args, ctx)
+    } else if (prop.format === 'list' && prop.itemFormat === 'enum') {
+      const value = (
+        await prompts({
+          name: 'value',
+          message: `${paramToEdit}:`,
+          type: 'autocompleteMultiselect',
+          choices: prop.itemEnumValues.map((v) => ({
+            title: v.name,
+            value: v.name,
+          })),
+        })
+      ).value
+      args.params[paramToEdit] = value
+      return interactForBlueprintObject(args, ctx)
+    } else if (prop.format === 'list') {
+      args.params[paramToEdit] = await interactForArray(
+        args.params[paramToEdit] || [],
+        `Edit the list for ${paramToEdit}`,
+      )
+      return interactForBlueprintObject(args, ctx)
+    } else if (prop.format === 'object') {
+      args.params[paramToEdit] = await interactForBlueprintObject(
+        {
+          command: args.command,
+          params: {},
+          parameters: prop.parameters,
+          isSubProperty: true,
+          subPropertyPath: paramToEdit,
+        },
+        ctx,
+      )
+      return interactForBlueprintObject(args, ctx)
+    } else if (prop.format === 'number') {
+      const { value } = await prompts({
+        name: 'value',
+        message: `${paramToEdit}:`,
+        type: 'number',
+      })
+
+      args.params[paramToEdit] = value
+
+      return interactForBlueprintObject(args, ctx)
+    }
+  }
+
+  throw new Error(
+    `Didn't know how to handle Blueprint parameter for property: "${paramToEdit}"`,
+  )
+}

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

@@ -0,0 +1,22 @@
+import { getCommandBlueprintDef } from './get-command-blueprint-def.js'
+import { interactForBlueprintObject } from './interact-for-blueprint-object.js'
+import type { ContextHelpers } from './types.js'
+
+export const interactForCommandParams = async (
+  args: {
+    command: string[]
+    params: Record<string, any>
+  },
+  ctx: ContextHelpers,
+): Promise<any> => {
+  const endpoint = getCommandBlueprintDef(args.command, ctx)
+
+  return interactForBlueprintObject(
+    {
+      command: args.command,
+      params: args.params,
+      parameters: endpoint.request.parameters,
+    },
+    ctx,
+  )
+}

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,86 @@
+import type { CustomMetadata } from '@seamapi/types/connect'
+import prompts from 'prompts'
+
+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()
+}