@seamapi/cli 0.24.0 → 0.25.0

package/package.json

@@ -1,22 +1,18 @@
 {
   "name": "@seamapi/cli",
-  "version": "0.24.0",
+  "version": "0.25.0",
   "description": "A command-line interface (CLI) for interacting with the Seam API.",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",
   "exports": {
     ".": {
-      "import": {
-        "types": "./index.d.ts",
-        "default": "./index.js"
-      }
+      "types": "./index.d.ts",
+      "default": "./index.js"
     },
     "./cli": {
-      "import": {
-        "types": "./bin/cli.d.ts",
-        "default": "./bin/cli.js"
-      }
+      "types": "./bin/cli.d.ts",
+      "default": "./bin/cli.js"
     }
   },
   "module": "index.js",
@@ -76,13 +72,13 @@
     "report": "vitest run --coverage"
   },
   "engines": {
-    "node": ">=22.11.0",
+    "node": ">=22.12.0",
     "npm": ">=10.0.0"
   },
   "devEngines": {
     "runtime": {
       "name": "node",
-      "version": "^24.11.0 || ^22.11.0",
+      "version": "^24.11.0 || ^22.12.0",
       "onFail": "warn"
     },
     "packageManager": {
@@ -94,8 +90,8 @@
   "dependencies": {
     "@clack/prompts": "^1.7.0",
     "@seamapi/blueprint": "1.5.0",
-    "@seamapi/http": "2.2.0",
-    "@seamapi/wizard": "0.7.0",
+    "@seamapi/http": "2.3.0",
+    "@seamapi/wizard": "0.8.0",
     "chalk": "^6.0.0",
     "command-line-usage": "^7.0.4",
     "configstore": "^8.0.0",

package/src/bin/cli.ts

@@ -29,7 +29,7 @@ import { createSeamApi, type SeamApi } from 'lib/http/api.js'
 import { interactForCommandSelection } from 'lib/interactions/index.js'
 import { getOutput, setOutput } from 'lib/output/get-output.js'
 import { createOutput } from 'lib/output/output.js'
-import { readStdinJson } from 'lib/output/read-stdin-json.js'
+import { parseJsonParams, readStdinJson } from 'lib/output/read-stdin-json.js'
 import { resolveOutputFormat } from 'lib/output/resolve-output-format.js'
 import { setAuthOverrides } from 'lib/overrides.js'
 import { canPrompt } from 'lib/prompt.js'
@@ -168,7 +168,14 @@ async function cli(args: ParsedArgs, argv: string[]) {
 
   // Params piped or redirected in, e.g., `seam devices list < params.json`.
   const pipedParams = await readStdinJson()
-  const stdinParams: Record<string, any> = { ...pipedParams }
+  const rawParams =
+    args['raw'] == null ? null : parseJsonParams(String(args['raw']), '--raw')
+  // Inline raw params take precedence over piped params, while ordinary
+  // command arguments still take precedence over both.
+  const stdinParams: Record<string, any> = {
+    ...pipedParams,
+    ...rawParams,
+  }
 
   const auth = resolveAuth(config)
   let seamApi: Promise<SeamApi> | null = null

package/src/lib/args/parse.ts

@@ -35,6 +35,7 @@ export const cliFlags: string[] = [
   'h',
   'help',
   'json',
+  'raw',
   'remote_schema',
   'update',
   'version',

package/src/lib/auth/validate-token.ts

@@ -3,7 +3,7 @@ import {
   isPersonalAccessToken,
   SeamHttp,
   SeamHttpWithoutWorkspace,
-} from '@seamapi/http/connect'
+} from '@seamapi/http'
 
 import { resolveAuth } from 'lib/context.js'
 

package/src/lib/blueprint/source-remote.ts

@@ -9,7 +9,7 @@ import { resolveAuth } from 'lib/context.js'
 export const createRemoteBlueprint = async (): Promise<Blueprint> => {
   const [{ createBlueprint }, { getOpenapiSchema }] = await Promise.all([
     import('@seamapi/blueprint'),
-    import('@seamapi/http/connect'),
+    import('@seamapi/http'),
   ])
   const openapi = await getOpenapiSchema(resolveAuth().endpoint)
 

package/src/lib/commands/local/wizard.ts

@@ -1,6 +1,6 @@
 import { join } from 'node:path'
 
-import { isApiKey } from '@seamapi/http/connect'
+import { isApiKey } from '@seamapi/http'
 import type { StorageAdapter, WizardAdapter, WizardAuth } from '@seamapi/wizard'
 import Configstore from 'configstore'
 

package/src/lib/commands/spec.ts

@@ -104,6 +104,14 @@ export const globalFlags: CommandFlag[] = [
     takesValue: false,
     isRequired: false,
   },
+  {
+    long: 'raw',
+    short: null,
+    description: 'Pass request parameters as an inline JSON object.',
+    values: [],
+    takesValue: true,
+    isRequired: false,
+  },
   {
     long: 'non-interactive',
     short: 'y',

package/src/lib/http/api.ts

@@ -1,4 +1,4 @@
-import { type SeamHttp, SeamHttpRequest } from '@seamapi/http/connect'
+import { type SeamHttp, SeamHttpRequest } from '@seamapi/http'
 
 import type { AuthContext } from 'lib/context.js'
 

package/src/lib/http/client.ts

@@ -3,7 +3,7 @@ import {
   isPersonalAccessToken,
   SeamHttp,
   SeamHttpWithoutWorkspace,
-} from '@seamapi/http/connect'
+} from '@seamapi/http'
 
 import { type AuthContext, resolveAuth } from 'lib/context.js'
 import { tokenEnvVar, workspaceIdEnvVar } from 'lib/env.js'

package/src/lib/http/memory-seam-api.ts

@@ -1,7 +1,4 @@
-import {
-  SeamHttpApiError,
-  SeamHttpInvalidInputError,
-} from '@seamapi/http/connect'
+import { SeamHttpApiError, SeamHttpInvalidInputError } from '@seamapi/http'
 
 import type { ApiRequestOptions, SeamApi, SeamApiRequest } from './api.js'
 

package/src/lib/http/request.ts

@@ -1,7 +1,4 @@
-import {
-  isSeamHttpApiError,
-  type SeamHttpApiError,
-} from '@seamapi/http/connect'
+import { isSeamHttpApiError, type SeamHttpApiError } from '@seamapi/http'
 import chalk from 'chalk'
 
 import type { Output } from 'lib/output/output.js'

package/src/lib/interactions/access-code.ts

@@ -3,13 +3,16 @@ import { getSeam } from 'lib/http/client.js'
 import { interactForDevice } from './device.js'
 import { interactForResource } from './resource.js'
 
-export const interactForAccessCode = async ({
-  // The key is a Seam API parameter name: callers pass the blueprint params
-  // bag through as-is, so only the binding may be camelCase.
-  device_id: deviceId,
-}: {
-  device_id?: string
-}) => {
+export const interactForAccessCode = async (
+  {
+    // The key is a Seam API parameter name: callers pass the blueprint params
+    // bag through as-is, so only the binding may be camelCase.
+    device_id: deviceId,
+  }: {
+    device_id?: string
+  },
+  initialValue?: string,
+) => {
   const seam = await getSeam()
 
   if (!deviceId) {
@@ -19,6 +22,7 @@ export const interactForAccessCode = async ({
   return interactForResource({
     resourceName: 'access_code',
     fetchResources: () => seam.accessCodes.list({ device_id: deviceId }),
+    initialValue,
     toChoice: (accessCode) => ({
       title: accessCode.name ?? '<No Name>',
       value: accessCode.access_code_id,

package/src/lib/interactions/acs-entrance.ts

@@ -2,12 +2,13 @@ import { getSeam } from 'lib/http/client.js'
 
 import { interactForResource } from './resource.js'
 
-export const interactForAcsEntrance = async () => {
+export const interactForAcsEntrance = async (initialValue?: string) => {
   const seam = await getSeam()
 
   return interactForResource({
     resourceName: 'ACS entrance',
     fetchResources: () => seam.acs.entrances.list(),
+    initialValue,
     toChoice: (entrance) => ({
       title: entrance.display_name ?? '<No Name>',
       value: entrance.acs_entrance_id,

package/src/lib/interactions/acs-system.ts

@@ -2,13 +2,20 @@ import { getSeam } from 'lib/http/client.js'
 
 import { interactForResource } from './resource.js'
 
-export const interactForAcsSystem = async (message?: string) => {
+export const interactForAcsSystem = async ({
+  message,
+  initialValue,
+}: {
+  message?: string | undefined
+  initialValue?: string | undefined
+} = {}) => {
   const seam = await getSeam()
 
   return interactForResource({
     resourceName: 'ACS system',
     fetchResources: () => seam.acs.systems.list(),
     message,
+    initialValue,
     toChoice: (system) => ({
       title: `${system.name} ${system.external_type_display_name}`,
       value: system.acs_system_id,

package/src/lib/interactions/acs-user.ts

@@ -3,16 +3,17 @@ import { getSeam } from 'lib/http/client.js'
 import { interactForAcsSystem } from './acs-system.js'
 import { interactForResource } from './resource.js'
 
-export const interactForAcsUser = async () => {
+export const interactForAcsUser = async (initialValue?: string) => {
   const seam = await getSeam()
 
-  const acsSystemId = await interactForAcsSystem(
-    'What acs_system does the acs_user belong to?',
-  )
+  const acsSystemId = await interactForAcsSystem({
+    message: 'What acs_system does the acs_user belong to?',
+  })
 
   return interactForResource({
     resourceName: 'ACS user',
     fetchResources: () => seam.acs.users.list({ acs_system_id: acsSystemId }),
+    initialValue,
     toChoice: (user) => ({
       title: `${user.display_name} ${user.email_address}`,
       value: user.acs_user_id,

package/src/lib/interactions/action-attempt-poll.ts

@@ -1,4 +1,4 @@
-import type { ActionAttemptsGetResponse } from '@seamapi/http/connect'
+import type { ActionAttemptsGetResponse } from '@seamapi/http'
 
 import { getSeam } from 'lib/http/client.js'
 import { getOutput } from 'lib/output/get-output.js'

package/src/lib/interactions/blueprint-object.ts

@@ -207,32 +207,47 @@ export const interactForBlueprintObject = async (
       }
     }
 
+    const current = args.params[paramToEdit]
+
     if (paramToEdit === 'device_id') {
-      args.params[paramToEdit] = await interactForDevice()
+      args.params[paramToEdit] = await interactForDevice(toText(current))
       return interactForBlueprintObject(args, ctx)
     } else if (paramToEdit === 'access_code_id') {
-      args.params[paramToEdit] = await interactForAccessCode(args.params as any)
+      args.params[paramToEdit] = await interactForAccessCode(
+        args.params as any,
+        toText(current),
+      )
       return interactForBlueprintObject(args, ctx)
     } else if (paramToEdit === 'connected_account_id') {
-      const connectedAccountId = await interactForConnectedAccount()
+      const connectedAccountId = await interactForConnectedAccount(
+        toText(current),
+      )
       args.params[paramToEdit] = connectedAccountId
       return interactForBlueprintObject(args, ctx)
     } else if (
       paramToEdit === 'user_identity_id' ||
       paramToEdit === 'user_identity_ids'
     ) {
-      const userIdentityId = await interactForUserIdentity()
+      const userIdentityId = await interactForUserIdentity(
+        paramToEdit === 'user_identity_ids'
+          ? toTextList(current)[0]
+          : toText(current),
+      )
       args.params[paramToEdit] =
         paramToEdit === 'user_identity_ids' ? [userIdentityId] : userIdentityId
       return interactForBlueprintObject(args, ctx)
     } else if (paramToEdit.endsWith('acs_system_id')) {
-      args.params[paramToEdit] = await interactForAcsSystem()
+      args.params[paramToEdit] = await interactForAcsSystem({
+        initialValue: toText(current),
+      })
       return interactForBlueprintObject(args, ctx)
     } else if (paramToEdit.endsWith('acs_user_id')) {
-      args.params[paramToEdit] = await interactForAcsUser()
+      args.params[paramToEdit] = await interactForAcsUser(toText(current))
       return interactForBlueprintObject(args, ctx)
     } else if (paramToEdit.endsWith('acs_entrance_id')) {
-      args.params['acs_entrance_id'] = await interactForAcsEntrance()
+      args.params['acs_entrance_id'] = await interactForAcsEntrance(
+        toText(args.params['acs_entrance_id']),
+      )
       return interactForBlueprintObject(args, ctx)
     } else if (
       paramToEdit.endsWith('_at') ||
@@ -240,14 +255,14 @@ export const interactForBlueprintObject = async (
       paramToEdit.endsWith('_before') ||
       paramToEdit.endsWith('_after')
     ) {
-      args.params[paramToEdit] = await interactForTimestamp()
+      args.params[paramToEdit] = await interactForTimestamp(toText(current))
       return interactForBlueprintObject(args, ctx)
     } else if (
       paramToEdit === 'custom_metadata' ||
       paramToEdit === 'custom_metadata_has'
     ) {
       args.params[paramToEdit] = await interactForCustomMetadata(
-        args.params[paramToEdit] || {},
+        toRecord(current),
       )
       return interactForBlueprintObject(args, ctx)
     }
@@ -256,10 +271,11 @@ export const interactForBlueprintObject = async (
       if (['string', 'id', 'datetime'].includes(prop.format)) {
         let value
         if (prop.format === 'datetime') {
-          value = await interactForTimestamp()
+          value = await interactForTimestamp(toText(current))
         } else {
           value = await promptText({
             message: withBackHint(`${paramToEdit}:`),
+            initialValue: toText(current),
           })
         }
         args.params[paramToEdit] = value
@@ -271,13 +287,14 @@ export const interactForBlueprintObject = async (
             label: v.name,
             value: v.name,
           })),
+          initialValue: toText(current),
         })
         args.params[paramToEdit] = value
         return interactForBlueprintObject(args, ctx)
       } else if (prop.format === 'boolean') {
         const value = await promptConfirm({
           message: withBackHint(`${paramToEdit}:`),
-          initialValue: true,
+          initialValue: toBoolean(current) ?? true,
           active: 'true',
           inactive: 'false',
         })
@@ -292,12 +309,13 @@ export const interactForBlueprintObject = async (
             label: v.name,
             value: v.name,
           })),
+          initialValues: toTextList(current),
         })
         args.params[paramToEdit] = value
         return interactForBlueprintObject(args, ctx)
       } else if (prop.format === 'list') {
         args.params[paramToEdit] = await interactForArray(
-          args.params[paramToEdit] || [],
+          toTextList(current),
           `Edit the list for ${paramToEdit}`,
         )
         return interactForBlueprintObject(args, ctx)
@@ -305,7 +323,7 @@ export const interactForBlueprintObject = async (
         args.params[paramToEdit] = await interactForBlueprintObject(
           {
             command: args.command,
-            params: {},
+            params: toRecord(current),
             parameters: prop.parameters,
             isSubProperty: true,
             subPropertyPath: paramToEdit,
@@ -316,6 +334,7 @@ export const interactForBlueprintObject = async (
       } else if (prop.format === 'number') {
         const value = await promptNumber({
           message: withBackHint(`${paramToEdit}:`),
+          initialValue: toNumber(current),
         })
 
         args.params[paramToEdit] = value
@@ -332,3 +351,33 @@ export const interactForBlueprintObject = async (
     `Didn't know how to handle Blueprint parameter for property: "${paramToEdit}"`,
   )
 }
+
+/*
+ * A parameter's current value in the shape its editor starts from, so that
+ * editing a parameter that already has a value continues from that value
+ * instead of from nothing — whether it came from an argument, from the JSON
+ * piped in, or from an earlier trip through this menu.
+ *
+ * Params are passed through as given, so a value need not match the format
+ * its parameter documents: the JSON piped in is arbitrary, and a schema can
+ * change under a script. A value the editor cannot start from is left out of
+ * it, which opens the editor as an unset parameter does, rather than
+ * rendering a value of the wrong type as text to edit.
+ */
+
+const toText = (value: unknown): string | undefined =>
+  typeof value === 'string' ? value : undefined
+
+const toNumber = (value: unknown): number | undefined =>
+  typeof value === 'number' ? value : undefined
+
+const toBoolean = (value: unknown): boolean | undefined =>
+  typeof value === 'boolean' ? value : undefined
+
+const toTextList = (value: unknown): string[] =>
+  Array.isArray(value) ? value.filter((item) => typeof item === 'string') : []
+
+const toRecord = (value: unknown): Record<string, any> =>
+  typeof value === 'object' && value !== null && !Array.isArray(value)
+    ? (value as Record<string, any>)
+    : {}

package/src/lib/interactions/connected-account.ts

@@ -1,12 +1,13 @@
 import { getSeam } from 'lib/http/client.js'
 
 import { interactForResource } from './resource.js'
-export const interactForConnectedAccount = async () => {
+export const interactForConnectedAccount = async (initialValue?: string) => {
   const seam = await getSeam()
 
   return interactForResource({
     resourceName: 'connected_account',
     fetchResources: () => seam.connectedAccounts.list(),
+    initialValue,
     toChoice: (connectedAccount) => {
       const identifiers = Object.values(
         connectedAccount.user_identifier ?? {},

package/src/lib/interactions/custom-metadata.ts

@@ -53,10 +53,16 @@ export const interactForCustomMetadata = async (
           message: withBackHint('Enter a key to add or edit:'),
         })
 
+        // Editing an existing key continues from the value it has, so a value
+        // is corrected rather than retyped.
+        const currentValue = updatedCustomMetadata[newKey]
+
         let newValue: string | boolean = await promptText({
           message: withBackHint(
             'Enter the new value to add or edit (or null to delete):',
           ),
+          initialValue:
+            currentValue == null ? undefined : currentValue.toString(),
         })
         if (newKey) {
           if (newValue === 'false' || newValue === 'true') {

package/src/lib/interactions/device.ts

@@ -1,12 +1,13 @@
 import { getSeam } from 'lib/http/client.js'
 
 import { interactForResource } from './resource.js'
-export const interactForDevice = async () => {
+export const interactForDevice = async (initialValue?: string) => {
   const seam = await getSeam()
 
   return interactForResource({
     resourceName: 'device',
     fetchResources: () => seam.devices.list(),
+    initialValue,
     toChoice: (device) => ({
       title: device.properties.name ?? '<No Name>',
       value: device.device_id,

package/src/lib/interactions/login.ts

@@ -1,4 +1,4 @@
-import { isApiKey, isPersonalAccessToken } from '@seamapi/http/connect'
+import { isApiKey, isPersonalAccessToken } from '@seamapi/http'
 import chalk from 'chalk'
 
 import { assertMutable, storeToken } from 'lib/auth/operations.js'

package/src/lib/interactions/resource.ts

@@ -12,11 +12,14 @@ export const interactForResource = async <Resource>({
   fetchResources,
   toChoice,
   message = `Select a ${resourceName}:`,
+  initialValue,
 }: {
   resourceName: string
   fetchResources: () => Promise<Resource[]>
   toChoice: (resource: Resource) => ResourceChoice
   message?: string | undefined
+  /** The resource already chosen, for the list to open on. */
+  initialValue?: string | undefined
 }) => {
   const resources = await withLoading(
     `Fetching ${resourceName.replace(/_/g, ' ')}s...`,
@@ -30,5 +33,6 @@ export const interactForResource = async <Resource>({
       const { title, value, description } = toChoice(resource)
       return { label: title, value, hint: description }
     }),
+    initialValue,
   })
 }

package/src/lib/interactions/timestamp.ts

@@ -1,11 +1,14 @@
 import { promptText, withBackHint } from 'lib/prompt.js'
 
-export const interactForTimestamp = async () => {
+export const interactForTimestamp = async (currentValue?: string) => {
   const now = new Date().toISOString()
   const timestamp = await promptText({
     message: withBackHint('Enter a timestamp:'),
     placeholder: now,
     defaultValue: now,
+    // A timestamp already given is offered for editing, rather than making
+    // the user type it out again to shift it by an hour.
+    initialValue: currentValue,
     validate: (value) => {
       if (value == null || value === '') return undefined
       if (Number.isNaN(new Date(value).getTime())) {

package/src/lib/interactions/user-identity.ts

@@ -2,12 +2,13 @@ import { getSeam } from 'lib/http/client.js'
 
 import { interactForResource } from './resource.js'
 
-export const interactForUserIdentity = async () => {
+export const interactForUserIdentity = async (initialValue?: string) => {
   const seam = await getSeam()
 
   return interactForResource({
     resourceName: 'user_identity',
     fetchResources: () => seam.userIdentities.list(),
+    initialValue,
     toChoice: (userIdentity) => ({
       title: `${userIdentity.email_address} "${userIdentity.full_name}: ${userIdentity.user_identity_key}`,
       value: userIdentity.user_identity_id,

package/src/lib/interactions/workspace-id.ts

@@ -1,4 +1,4 @@
-import { SeamHttpWithoutWorkspace } from '@seamapi/http/connect'
+import { SeamHttpWithoutWorkspace } from '@seamapi/http'
 
 import { assertMutable, selectWorkspace } from 'lib/auth/operations.js'
 import { getConfig } from 'lib/config/index.js'

package/src/lib/memory-prompt.ts

@@ -3,6 +3,7 @@ import type {
   PromptChoice,
   PromptClient,
   PromptConfirmOptions,
+  PromptMultiselectOptions,
   PromptNumberOptions,
   PromptSelectOptions,
   PromptTextOptions,
@@ -19,6 +20,9 @@ export interface PromptQuestion {
     | 'autocompleteMultiselect'
   message: string
   choices?: Array<PromptChoice<unknown>>
+  /** What the question was seeded with — what the user sees to edit. */
+  initialValue?: unknown
+  initialValues?: unknown[] | undefined
 }
 
 /** Scripted in place of an answer to dismiss that prompt. */
@@ -44,35 +48,53 @@ export class MemoryPromptClient implements PromptClient {
 
   canPrompt = (): boolean => true
 
-  text = async ({ message }: PromptTextOptions): Promise<string> =>
-    this.answer({ kind: 'text', message }) as string
+  text = async ({
+    message,
+    initialValue,
+  }: PromptTextOptions): Promise<string> =>
+    this.answer({ kind: 'text', message, initialValue }) as string
 
-  number = async ({ message }: PromptNumberOptions): Promise<number> =>
-    this.answer({ kind: 'number', message }) as number
+  number = async ({
+    message,
+    initialValue,
+  }: PromptNumberOptions): Promise<number> =>
+    this.answer({ kind: 'number', message, initialValue }) as number
 
-  confirm = async ({ message }: PromptConfirmOptions): Promise<boolean> =>
-    this.answer({ kind: 'confirm', message }) as boolean
+  confirm = async ({
+    message,
+    initialValue,
+  }: PromptConfirmOptions): Promise<boolean> =>
+    this.answer({ kind: 'confirm', message, initialValue }) as boolean
 
   select = async <Value>({
     message,
     choices,
+    initialValue,
   }: PromptSelectOptions<Value>): Promise<Value> =>
-    this.answer({ kind: 'select', message, choices }) as Value
+    this.answer({ kind: 'select', message, choices, initialValue }) as Value
 
   autocomplete = async <Value>({
     message,
     choices,
+    initialValue,
   }: PromptSelectOptions<Value>): Promise<Value> =>
-    this.answer({ kind: 'autocomplete', message, choices }) as Value
+    this.answer({
+      kind: 'autocomplete',
+      message,
+      choices,
+      initialValue,
+    }) as Value
 
   autocompleteMultiselect = async <Value>({
     message,
     choices,
-  }: PromptSelectOptions<Value>): Promise<Value[]> =>
+    initialValues,
+  }: PromptMultiselectOptions<Value>): Promise<Value[]> =>
     this.answer({
       kind: 'autocompleteMultiselect',
       message,
       choices,
+      initialValues,
     }) as Value[]
 
   private answer(question: PromptQuestion): unknown {