@carthooks/arcubase-cli 0.1.7 → 0.1.9

package/src/runtime/body_loader.ts

@@ -11,6 +11,17 @@ function parseJSONFile(filePath: string, label: string): unknown {
 
 export function loadBodyFromFlags(flags: Record<string, string | boolean>): unknown | undefined {
   const bodyFile = typeof flags['body-file'] === 'string' ? flags['body-file'] : undefined
+  const bodyJSON = typeof flags['body-json'] === 'string' ? flags['body-json'] : undefined
+  if (bodyFile && bodyJSON) {
+    throw new CLIError('BODY_JSON_CONFLICT', 'use either --body-file or --body-json, not both', 2)
+  }
+  if (bodyJSON !== undefined) {
+    try {
+      return JSON.parse(bodyJSON)
+    } catch {
+      throw new CLIError('INVALID_BODY_JSON', 'body json is invalid', 2)
+    }
+  }
   if (!bodyFile) return undefined
   return parseJSONFile(bodyFile, 'body')
 }

package/src/runtime/command_registry.ts

@@ -3,50 +3,22 @@ import { adminCommands, userCommands } from '../generated/command_registry.gener
 export { adminCommands, userCommands }
 
 export type CommandScope = 'admin' | 'user'
-type GeneratedCommandDef = (typeof adminCommands)[number] | (typeof userCommands)[number]
-
-type CustomCommandDef = {
-  scope: CommandScope
-  module: string
-  functionName: string
-  commandPath: readonly [string, string]
-  method: string
-  endpoint: string
-  endpointParams: readonly string[]
-  controller: string
-  requestType: string | null
-  scalarParams: readonly { name: string; type: string; hasDefault: boolean }[]
-  responseType: string
-}
-
-export type CommandDef = GeneratedCommandDef | CustomCommandDef
-
-const customAdminCommands: readonly CustomCommandDef[] = [
-  {
-    scope: 'admin',
-    module: 'app',
-    functionName: 'inventory',
-    commandPath: ['app', 'inventory'],
-    method: 'GET',
-    endpoint: '/apps',
-    endpointParams: [],
-    controller: 'Runtime.AppInventory',
-    requestType: null,
-    scalarParams: [],
-    responseType: 'AppInventoryRespVO',
-  },
-] as const
-
-const customUserCommands: readonly CustomCommandDef[] = []
+export type CommandDef = (typeof adminCommands)[number] | (typeof userCommands)[number]
 
 export function listCommands(scope: CommandScope): readonly CommandDef[] {
-  return scope === 'admin'
-    ? [...adminCommands, ...customAdminCommands]
-    : [...userCommands, ...customUserCommands]
+  return scope === 'admin' ? adminCommands : userCommands
 }
 
-export function findCommand(scope: CommandScope, moduleName: string, commandName: string): CommandDef | null {
-  return listCommands(scope).find((item) => item.commandPath[0] === moduleName && item.commandPath[1] === commandName) ?? null
+export function findCommand(scope: CommandScope, moduleName: string, commandName?: string | null): CommandDef | null {
+  return listCommands(scope).find((item) => {
+    if (item.commandPath[0] !== moduleName) {
+      return false
+    }
+    if (item.commandPath.length === 1) {
+      return !commandName
+    }
+    return item.commandPath[1] === commandName
+  }) ?? null
 }
 
 export function listModules(scope: CommandScope): string[] {
@@ -77,7 +49,7 @@ function levenshtein(a: string, b: string): number {
 export type CommandSuggestion = {
   scope: CommandScope
   moduleName: string
-  commandName: string
+  commandName: string | null
   binary: 'arcubase-admin' | 'arcubase'
   score: number
 }
@@ -86,9 +58,10 @@ export function findCommandSuggestions(moduleName: string, commandName: string,
   const suggestions: CommandSuggestion[] = []
   for (const scope of ['admin', 'user'] as const) {
     for (const command of listCommands(scope)) {
-      const [candidateModule, candidateCommand] = command.commandPath
+      const candidateModule = command.commandPath[0]
+      const candidateCommand: string | null = command.commandPath.length > 1 ? command.commandPath[1] ?? null : null
       const moduleScore = candidateModule === moduleName ? 0 : levenshtein(candidateModule, moduleName || '')
-      const commandScore = candidateCommand === commandName ? 0 : levenshtein(candidateCommand, commandName || '')
+      const commandScore = candidateCommand === commandName ? 0 : levenshtein(candidateCommand ?? '', commandName || '')
       const score = commandScore * 3 + moduleScore
       suggestions.push({
         scope,
@@ -100,6 +73,11 @@ export function findCommandSuggestions(moduleName: string, commandName: string,
     }
   }
   return suggestions
-    .sort((a, b) => a.score - b.score || a.binary.localeCompare(b.binary) || a.moduleName.localeCompare(b.moduleName) || a.commandName.localeCompare(b.commandName))
+    .sort((a, b) =>
+      a.score - b.score ||
+      a.binary.localeCompare(b.binary) ||
+      a.moduleName.localeCompare(b.moduleName) ||
+      (a.commandName ?? '').localeCompare(b.commandName ?? ''),
+    )
     .slice(0, limit)
 }

package/src/runtime/execute.ts

@@ -9,12 +9,12 @@ import { renderUploadHelp, uploadLocalFile } from './upload.js'
 
 export type CommandExecutionSummary = {
   scope: CommandScope
-  commandPath: readonly [string, string]
+  commandPath: readonly string[]
   method: string
   endpoint: string
   requestType: string | null
   pathFlags: readonly string[]
-  scalarFlags: readonly string[]
+  queryFlags: readonly string[]
 }
 
 type CustomUploadSummary = {
@@ -23,127 +23,19 @@ type CustomUploadSummary = {
   data: ReturnType<typeof summarizeUploadResult>
 }
 
-type AppInventoryItem = {
-  id: string
-  name: string
-  entities: Array<{ id: string; name: string }>
-}
-
 function summarizeUploadResult(value: Awaited<ReturnType<typeof uploadLocalFile>>) {
   return value
 }
 
-function parseJSONResponse(raw: string): unknown {
-  if (!raw) return null
-  try {
-    return JSON.parse(raw)
-  } catch {
-    return raw
-  }
-}
-
-function unwrapResponseData(payload: unknown): unknown {
-  return isRecord(payload) && 'data' in payload ? payload.data : payload
-}
-
-function formatUpstreamError(payload: unknown): string {
-  if (typeof payload === 'string') {
-    return payload
-  }
-  if (isRecord(payload) && isRecord(payload.error) && typeof payload.error.message === 'string') {
-    return payload.error.message
-  }
-  return JSON.stringify(payload)
-}
-
-function extractApps(payload: unknown): Array<{ id: string; name: string }> {
-  const data = unwrapResponseData(payload)
-  if (!Array.isArray(data)) return []
-  return data
-    .filter((item): item is Record<string, unknown> => isRecord(item))
-    .filter((item) => item.id !== undefined && typeof item.name === 'string')
-    .map((item) => ({
-      id: String(item.id),
-      name: item.name as string,
-    }))
-}
-
-function extractEntities(payload: unknown): Array<{ id: string; name: string }> {
-  const data = unwrapResponseData(payload)
-  if (!Array.isArray(data)) return []
-  return data
-    .filter((item): item is Record<string, unknown> => isRecord(item))
-    .filter((item) => item.id !== undefined && typeof item.name === 'string')
-    .map((item) => ({
-      id: String(item.id),
-      name: item.name as string,
-    }))
-}
-
-async function executeAppInventory(runtimeEnv: RuntimeEnv, fetchImpl: typeof fetch) {
-  const appsResponse = await fetchImpl(buildURL(runtimeEnv.ARCUBASE_BASE_URL, '/apps'), {
-    method: 'GET',
-    headers: buildRequestHeaders(runtimeEnv),
-  })
-  const appsRaw = await appsResponse.text()
-  const appsPayload = parseJSONResponse(appsRaw)
-  if (!appsResponse.ok) {
-    throw new CLIError('UPSTREAM_REQUEST_FAILED', formatUpstreamError(appsPayload), 1)
-  }
-  if (isRecord(appsPayload) && appsPayload.error) {
-    throw new CLIError('UPSTREAM_BODY_ERROR', formatUpstreamError(appsPayload), 1, {
-      endpoint: '/apps',
-      method: 'GET',
-      upstreamError: appsPayload.error,
-    })
-  }
-  const apps = extractApps(appsPayload)
-  const items: AppInventoryItem[] = []
-  for (const app of apps) {
-    const entitiesResponse = await fetchImpl(buildURL(runtimeEnv.ARCUBASE_BASE_URL, `/apps/${encodeURIComponent(app.id)}/entities`), {
-      method: 'POST',
-      headers: {
-        ...buildRequestHeaders(runtimeEnv),
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify({}),
-    })
-    const entitiesRaw = await entitiesResponse.text()
-    const entitiesPayload = parseJSONResponse(entitiesRaw)
-    if (!entitiesResponse.ok) {
-      throw new CLIError('UPSTREAM_REQUEST_FAILED', formatUpstreamError(entitiesPayload), 1)
-    }
-    if (isRecord(entitiesPayload) && entitiesPayload.error) {
-      throw new CLIError('UPSTREAM_BODY_ERROR', formatUpstreamError(entitiesPayload), 1, {
-        endpoint: `/apps/${app.id}/entities`,
-        method: 'POST',
-        upstreamError: entitiesPayload.error,
-      })
-    }
-    items.push({
-      ...app,
-      entities: extractEntities(entitiesPayload),
-    })
-  }
-  return {
-    kind: 'result',
-    commandPath: ['app', 'inventory'] as const,
-    status: 200,
-    data: {
-      apps: items,
-    },
-  }
-}
-
 export function renderRootHelp(scope: CommandScope): string {
   const binary = scope === 'admin' ? 'arcubase-admin' : 'arcubase'
   const items = listModules(scope).map((item) => `  - ${item}`)
   return [
-    `${binary} <module> <command> [flags]`,
+    `${binary} <command> [subcommand] [flags]`,
     '',
     ...(scope === 'admin'
-      ? ['use arcubase-admin for app, entity shell, and schema management', '']
-      : ['use arcubase for rows, search, selection actions, and bulk actions', '']),
+      ? ['use arcubase-admin for app, table, access-rule, and workflow management', '']
+      : ['use arcubase for entry, table, row, upload, profile, and workflow actions', '']),
     'modules:',
     ...items,
     ...(scope === 'user' ? ['','special commands:','  - upload <local-file>'] : []),
@@ -153,62 +45,69 @@ export function renderRootHelp(scope: CommandScope): string {
 export function renderModuleHelp(scope: CommandScope, moduleName: string): string {
   const items = listModuleCommands(scope, moduleName)
   if (items.length === 0) {
-    const suggestions = findCommandSuggestions(moduleName, '').map((item) => `${item.binary} ${item.moduleName} ${item.commandName}`)
+    const suggestions = findCommandSuggestions(moduleName, '').map((item) => `${item.binary} ${item.moduleName}${item.commandName ? ` ${item.commandName}` : ''}`)
     throw new CLIError('UNKNOWN_MODULE', `unknown module: ${moduleName}`, 2, suggestions.length > 0 ? { suggestions } : undefined)
   }
+  if (items.length === 1 && items[0].commandPath.length === 1) {
+    return renderCommandHelp(scope, moduleName)
+  }
   return [
     `${scope === 'admin' ? 'arcubase-admin' : 'arcubase'} ${moduleName} <command> [flags]`,
     '',
     ...(scope === 'admin'
-      ? ['use arcubase-admin for app, entity shell, and schema management', '']
-      : ['use arcubase for rows, search, selection actions, and bulk actions', '']),
+      ? ['use arcubase-admin for app, table, access-rule, and workflow management', '']
+      : ['use arcubase for entry, table, row, upload, profile, and workflow actions', '']),
     'commands:',
-    ...items.map((item) => `  - ${item.commandPath[1]}`),
+    ...items.filter((item) => item.commandPath.length > 1).map((item) => `  - ${item.commandPath[1]}`),
   ].join('\n')
 }
 
 function buildUnknownCommandDetails(scope: CommandScope, moduleName: string, commandName: string): { suggestions?: string[]; reason?: string; hint?: string } | undefined {
-  const suggestions = findCommandSuggestions(moduleName, commandName).map((item) => `${item.binary} ${item.moduleName} ${item.commandName}`)
-  if (scope === 'admin' && moduleName === 'workflow' && suggestions.some((item) => item.startsWith('arcubase rows '))) {
-    return {
-      suggestions,
-      reason: `${moduleName} ${commandName} is not a valid command group; use arcubase rows for row operations`,
-      hint: `use: arcubase rows ${commandName}`,
-    }
-  }
+  const suggestions = findCommandSuggestions(moduleName, commandName).map((item) => `${item.binary} ${item.moduleName}${item.commandName ? ` ${item.commandName}` : ''}`)
   return suggestions.length > 0 ? { suggestions } : undefined
 }
 
-export function renderCommandHelp(scope: CommandScope, moduleName: string, commandName: string): string {
+export function renderCommandHelp(scope: CommandScope, moduleName: string, commandName?: string): string {
   const command = findCommand(scope, moduleName, commandName)
   if (!command) {
-    throw new CLIError('UNKNOWN_COMMAND', `unknown command: ${moduleName} ${commandName}`, 2, buildUnknownCommandDetails(scope, moduleName, commandName))
+    throw new CLIError('UNKNOWN_COMMAND', `unknown command: ${moduleName}${commandName ? ` ${commandName}` : ''}`, 2, buildUnknownCommandDetails(scope, moduleName, commandName ?? ''))
   }
   const docHints = [
     ...getCommandDocHints(`${scope}.${command.module}.${command.functionName}`),
     ...(command.requestType ? getDocHints(command.requestType) : []),
   ].filter((item, index, list) => list.findIndex((candidate) => candidate.file === item.file) === index)
+  const pathFlags = command.pathParams.filter((item) => !getFixedValue(item)).map((item) => `--${item.flag}`)
+  const queryFlags = command.queryParams.filter((item) => !getFixedValue(item)).map((item) => `--${item.flag}`)
   return [
-    `${scope === 'admin' ? 'arcubase-admin' : 'arcubase'} ${moduleName} ${commandName}`,
+    `${scope === 'admin' ? 'arcubase-admin' : 'arcubase'} ${command.commandPath.join(' ')}`,
     `method: ${command.method}`,
     `endpoint: ${normalizeExternalEndpoint(command.endpoint)}`,
-    command.requestType ? `body: ${command.requestType} via --body-file` : 'body: none',
-    'query flags: --query-file',
-    command.endpointParams.length ? `path flags: ${command.endpointParams.map((item) => `--${item.replace(/_/g, '-')}`).join(', ')}` : 'path flags: none',
-    command.scalarParams.length ? `scalar flags: ${command.scalarParams.map((item) => `--${item.name.replace(/([A-Z])/g, '-$1').toLowerCase()}`).join(', ')}` : 'scalar flags: none',
-    ...(scope === 'admin' && moduleName === 'entity' && commandName === 'admin-save-entity'
+    command.requestType ? `body: ${command.requestType} via --body-file or --body-json` : 'body: none',
+    queryFlags.length ? `query flags: ${queryFlags.join(', ')}, --query-file` : 'query flags: --query-file',
+    pathFlags.length ? `path flags: ${pathFlags.join(', ')}` : 'path flags: none',
+    ...(scope === 'admin' && command.commandPath[0] === 'table' && command.commandPath[1] === 'update-schema'
       ? [
           'next step:',
           '  - switch to arcubase for row operations',
-          '  - row insert: arcubase rows insert-entity --app-id <app_id> --entity-id <entity_id> --body-file insert.json',
-          '  - row query: arcubase rows query-entity --app-id <app_id> --entity-id <entity_id> --body-file query.json',
+          '  - row create: arcubase row create --app-id <app_id> --table-id <table_id> --body-file insert.json',
+          '  - row query: arcubase row query --app-id <app_id> --table-id <table_id> --body-file query.json',
         ]
       : []),
-    ...(scope === 'admin' && moduleName === 'app' && commandName === 'inventory'
+    ...(scope === 'admin' && command.commandPath[0] === 'access-rule' && command.commandPath[1] === 'update'
       ? [
-          'purpose:',
-          '  - list all accessible apps and each app entity list in one call sequence',
-          '  - use this before asking the user for app_id',
+          'body-json examples:',
+          '  - enable: {"update":["enabled"],"enabled":true}',
+          '  - rename: {"update":["name"],"name":"Sales read only"}',
+          '  - update options: {"update":["options"],"options":{"user_scope":[{"type":"user","id":123}]}}',
+        ]
+      : []),
+    ...(scope === 'admin' && command.commandPath[0] === 'access-rule' && command.commandPath[1] === 'assign-users'
+      ? [
+          'body-json example:',
+          '  - {"update":["user_scope"],"options":{"user_scope":[{"type":"user","id":123}]}}',
+          'success requires:',
+          '  - result.enabled must be true',
+          '  - result.options.user_scope must contain the assigned user ids',
         ]
       : []),
     ...(docHints.length > 0
@@ -234,15 +133,22 @@ function coerceScalar(value: string, typeText: string): any {
   return value
 }
 
-function resolveEndpoint(endpoint: string, flags: Record<string, string | boolean>): string {
-  let resolved = endpoint
-  for (const placeholder of [...endpoint.matchAll(/:([A-Za-z0-9_]+)/g)].map((match) => match[1])) {
-    const flagName = placeholder.replace(/_/g, '-')
-    const value = flagValue(flags, flagName)
+function getFixedValue(value: object): string | undefined {
+  if (!('fixedValue' in value)) {
+    return undefined
+  }
+  const fixedValue = (value as { fixedValue?: unknown }).fixedValue
+  return typeof fixedValue === 'string' ? fixedValue : undefined
+}
+
+function resolveEndpoint(command: NonNullable<ReturnType<typeof findCommand>>, flags: Record<string, string | boolean>): string {
+  let resolved: string = command.endpoint
+  for (const mapping of command.pathParams) {
+    const value = getFixedValue(mapping) ?? flagValue(flags, mapping.flag)
     if (!value) {
-      throw new CLIError('MISSING_PATH_FLAG', `missing required flag --${flagName}`, 2)
+      throw new CLIError('MISSING_PATH_FLAG', `missing required flag --${mapping.flag}`, 2)
     }
-    resolved = resolved.replace(`:${placeholder}`, encodeURIComponent(value))
+    resolved = resolved.replace(`:${mapping.param}`, encodeURIComponent(value))
   }
   return resolved
 }
@@ -252,11 +158,10 @@ function buildScalarQuery(command: ReturnType<typeof findCommand>, flags: Record
     return undefined
   }
   const out: Record<string, any> = {}
-  for (const scalar of command.scalarParams) {
-    const flagName = scalar.name.replace(/([A-Z])/g, '-$1').toLowerCase()
-    const value = flagValue(flags, flagName)
+  for (const scalar of command.queryParams) {
+    const value = getFixedValue(scalar) ?? flagValue(flags, scalar.flag)
     if (value === undefined) continue
-    out[scalar.name] = coerceScalar(value, scalar.type)
+    out[scalar.key] = coerceScalar(value, scalar.type)
   }
   return Object.keys(out).length > 0 ? out : undefined
 }
@@ -292,7 +197,7 @@ async function fetchEntityFields(
   entityId: string,
   fetchImpl: typeof fetch,
 ): Promise<Map<number, EntityFieldInfo>> {
-  const response = await fetchImpl(buildURL(runtimeEnv.ARCUBASE_BASE_URL, `/entity/${encodeURIComponent(appId)}/${encodeURIComponent(entityId)}`), {
+  const response = await fetchImpl(buildURL(runtimeEnv.ARCUBASE_BASE_URL, `/api/entity/${encodeURIComponent(appId)}/${encodeURIComponent(entityId)}`), {
     method: 'GET',
     headers: buildRequestHeaders(runtimeEnv),
   })
@@ -315,7 +220,7 @@ async function fetchEntityFields(
           ? upstreamError
           : JSON.stringify(upstreamError)
     throw new CLIError('UPSTREAM_BODY_ERROR', upstreamMessage, 1, {
-      endpoint: `/entity/${appId}/${entityId}`,
+      endpoint: `/api/entity/${appId}/${entityId}`,
       method: 'GET',
       upstreamError,
     })
@@ -359,7 +264,7 @@ async function validateFileFieldPayloads(
     return
   }
   const appId = flagValue(flags, 'app-id')
-  const entityId = flagValue(flags, 'entity-id')
+  const entityId = flagValue(flags, 'table-id')
   if (!appId || !entityId) {
     return
   }
@@ -445,6 +350,51 @@ function throwBodyValidationFailure(message: string, requestType: string, path:
   })
 }
 
+function stringArray(value: unknown): string[] {
+  return Array.isArray(value) ? value.filter((item): item is string => typeof item === 'string') : []
+}
+
+function requireUpdateContains(
+  scope: CommandScope,
+  command: NonNullable<ReturnType<typeof findCommand>>,
+  body: Record<string, unknown>,
+  field: string,
+) {
+  if (!(field in body)) return
+  const update = stringArray(body.update)
+  if (!update.includes(field)) {
+    throwBodyValidationFailure(
+      `body.update must include "${field}" when body.${field} is present. Example: {"update":["${field}"],"${field}":${field === 'enabled' ? 'true' : '"value"'}}`,
+      command.requestType ?? 'AppIngressUpdateReqVO',
+      'body.update',
+      scope,
+      command,
+    )
+  }
+}
+
+function validateActionSpecificRawBody(
+  scope: CommandScope,
+  command: NonNullable<ReturnType<typeof findCommand>>,
+  body: unknown,
+) {
+  if (!isRecord(body) || !command.requestType) {
+    return
+  }
+
+  if (scope === 'admin' && command.commandPath[0] === 'access-rule' && command.commandPath[1] === 'assign-users') {
+    if ('users' in body || 'allowedUsers' in body) {
+      throwBodyValidationFailure(
+        'access-rule assign-users does not accept users or allowedUsers; use body.options.user_scope with {"update":["user_scope"],"options":{"user_scope":[{"type":"user","id":123}]}}',
+        command.requestType,
+        'body.options.user_scope',
+        scope,
+        command,
+      )
+    }
+  }
+}
+
 function validateActionSpecificBody(
   scope: CommandScope,
   command: NonNullable<ReturnType<typeof findCommand>>,
@@ -455,7 +405,46 @@ function validateActionSpecificBody(
     return
   }
 
-  if (command.module === 'rows' && command.functionName === 'queryEntitySelection') {
+  if (scope === 'admin' && command.commandPath[0] === 'access-rule' && command.commandPath[1] === 'update') {
+    requireUpdateContains(scope, command, body, 'enabled')
+    requireUpdateContains(scope, command, body, 'name')
+    requireUpdateContains(scope, command, body, 'options')
+  }
+
+  if (scope === 'admin' && command.commandPath[0] === 'access-rule' && command.commandPath[1] === 'assign-users') {
+    const update = stringArray(body.update)
+    const options = isRecord(body.options) ? body.options : undefined
+    const userScope = options && Array.isArray(options.user_scope) ? options.user_scope : undefined
+    if ('users' in body || 'allowedUsers' in body) {
+      throwBodyValidationFailure(
+        'access-rule assign-users does not accept users or allowedUsers; use body.options.user_scope with {"update":["user_scope"],"options":{"user_scope":[{"type":"user","id":123}]}}',
+        command.requestType,
+        'body.options.user_scope',
+        scope,
+        command,
+      )
+    }
+    if (!update.includes('user_scope')) {
+      throwBodyValidationFailure(
+        'access-rule assign-users requires body.update to include "user_scope"',
+        command.requestType,
+        'body.update',
+        scope,
+        command,
+      )
+    }
+    if (!userScope || userScope.length === 0) {
+      throwBodyValidationFailure(
+        'access-rule assign-users requires non-empty body.options.user_scope',
+        command.requestType,
+        'body.options.user_scope',
+        scope,
+        command,
+      )
+    }
+  }
+
+  if (command.commandPath[0] === 'row' && command.commandPath[1] === 'selection-action') {
     const action = flagValue(flags, 'action')
     const selection = body.selection
     if (!isRecord(selection) || typeof selection.type !== 'string') {
@@ -469,7 +458,7 @@ function validateActionSpecificBody(
     if (action === 'query') {
       if (type === 'condition') {
         throwBodyValidationFailure(
-          'selection.type=condition is not supported for action=query; use selection.type=ids or selection.type=all, or use rows query-entity for search conditions',
+          'selection.type=condition is not supported for action=query; use selection.type=ids or selection.type=all, or use row query for search conditions',
           command.requestType,
           'body.selection.type',
           scope,
@@ -510,10 +499,10 @@ export function summarizeCommand(scope: CommandScope, moduleName: string, comman
     scope,
     commandPath: command.commandPath,
     method: command.method,
-    endpoint: normalizeExternalEndpoint(command.endpoint),
+    endpoint: command.endpoint,
     requestType: command.requestType,
-    pathFlags: command.endpointParams,
-    scalarFlags: command.scalarParams.map((item) => item.name.replace(/([A-Z])/g, '-$1').toLowerCase()),
+    pathFlags: command.pathParams.filter((item) => !getFixedValue(item)).map((item) => item.flag),
+    queryFlags: command.queryParams.filter((item) => !getFixedValue(item)).map((item) => item.flag),
   }
 }
 
@@ -551,7 +540,8 @@ export async function executeCLI(scope: CommandScope, argv: string[], env?: Runt
   if (!moduleName) {
     return { kind: 'help', text: renderRootHelp(scope) }
   }
-  if (!commandName) {
+  const singleTokenCommand = !commandName ? findCommand(scope, moduleName) : null
+  if (!commandName && !singleTokenCommand) {
     return { kind: 'help', text: renderModuleHelp(scope, moduleName) }
   }
   if (hasFlag(parsed.flags, 'help')) {
@@ -562,23 +552,25 @@ export async function executeCLI(scope: CommandScope, argv: string[], env?: Runt
 
   const command = findCommand(scope, moduleName, commandName)
   if (!command) {
-    throw new CLIError('UNKNOWN_COMMAND', `unknown command: ${moduleName} ${commandName}`, 2, buildUnknownCommandDetails(scope, moduleName, commandName))
-  }
-  if (scope === 'admin' && moduleName === 'app' && commandName === 'inventory') {
-    return executeAppInventory(runtimeEnv, fetchImpl)
+    throw new CLIError('UNKNOWN_COMMAND', `unknown command: ${moduleName}${commandName ? ` ${commandName}` : ''}`, 2, buildUnknownCommandDetails(scope, moduleName, commandName ?? ''))
   }
 
-  const endpoint = normalizeExternalEndpoint(resolveEndpoint(command.endpoint, parsed.flags))
+  const endpoint = resolveEndpoint(command, parsed.flags)
   const scalarQuery = buildScalarQuery(command, parsed.flags)
   const fileQuery = loadQueryFromFlags(parsed.flags)
   const query = { ...(scalarQuery ?? {}), ...(fileQuery ?? {}) }
   const body = loadBodyFromFlags(parsed.flags)
   let validatedBody = body
 
+  if (!command.requestType && body !== undefined) {
+    throw new CLIError('BODY_JSON_NOT_SUPPORTED', `command does not accept a request body: ${moduleName} ${commandName}`, 2)
+  }
+
   if (command.requestType) {
     if (body === undefined) {
-      throw new CLIError('MISSING_BODY_FILE', `command requires --body-file for ${command.requestType}`, 2)
+      throw new CLIError('MISSING_BODY_FILE', `command requires --body-file or --body-json for ${command.requestType}`, 2)
     }
+    validateActionSpecificRawBody(scope, command, body)
     const schema = getBodySchema(command.requestType)
     if (schema) {
       const parsedBody = schema.safeParse(body)

package/src/runtime/http.ts

@@ -22,7 +22,7 @@ export function normalizeExternalEndpoint(endpoint: string): string {
 }
 
 export function buildURL(baseURL: string, endpoint: string, query?: Record<string, any>): string {
-  const url = new URL(normalizeExternalEndpoint(endpoint), baseURL.endsWith('/') ? baseURL : `${baseURL}/`)
+  const url = new URL(endpoint, baseURL.endsWith('/') ? baseURL : `${baseURL}/`)
   if (query) {
     for (const [key, value] of Object.entries(query)) {
       if (value === undefined || value === null) continue

package/src/runtime/upload.ts

@@ -64,7 +64,7 @@ function requireTokenPayload(payload: UploadTokenResponse): NonNullable<UploadTo
           ? upstreamError
           : JSON.stringify(upstreamError)
     throw new CLIError('UPSTREAM_BODY_ERROR', message, 1, {
-      endpoint: '/upload/token',
+      endpoint: '/api/upload/token',
       method: 'POST',
       traceId: typeof payload.trace_id === 'string' ? payload.trace_id : undefined,
       upstreamError,
@@ -116,7 +116,7 @@ export async function uploadLocalFile(
   const { absolutePath, bytes } = readUploadSource(sourcePath)
   const filename = (options.filename && options.filename.trim()) || path.basename(absolutePath)
 
-  const tokenResponse = await fetchImpl(buildURL(env.ARCUBASE_BASE_URL, '/upload/token'), {
+  const tokenResponse = await fetchImpl(buildURL(env.ARCUBASE_BASE_URL, '/api/upload/token'), {
     method: 'POST',
     headers: {
       ...buildRequestHeaders(env),
@@ -131,7 +131,7 @@ export async function uploadLocalFile(
   const tokenParsed = parseJSONResponse(tokenRaw)
   if (!tokenResponse.ok) {
     throw new CLIError('UPLOAD_TOKEN_REQUEST_FAILED', typeof tokenParsed === 'string' ? tokenParsed : JSON.stringify(tokenParsed), 1, {
-      endpoint: '/upload/token',
+      endpoint: '/api/upload/token',
       method: 'POST',
     })
   }