transloadit 4.7.3 → 4.7.6

package/src/cli/commands/auth.ts

@@ -7,6 +7,7 @@ import {
   assemblyInstructionsSchema,
 } from '../../alphalib/types/template.ts'
 import type { OptionalAuthParams } from '../../apiTypes.ts'
+import { mintBearerTokenWithCredentials } from '../../bearerToken.ts'
 import { Transloadit } from '../../Transloadit.ts'
 import { readCliInput, requireEnvCredentials } from '../helpers.ts'
 import { UnauthenticatedCommand } from './BaseCommand.ts'
@@ -194,155 +195,6 @@ export interface RunSmartSigOptions {
   providedInput?: string
 }
 
-export interface RequestTokenOptions {
-  endpoint?: string
-  aud?: string
-}
-
-const tokenErrorSchema = z
-  .object({
-    error: z.string(),
-    message: z.string().optional(),
-  })
-  .passthrough()
-
-const tokenSuccessSchema = z
-  .object({
-    access_token: z.string().min(1),
-  })
-  .passthrough()
-
-const buildBasicAuthHeaderValue = (credentials: { authKey: string; authSecret: string }): string =>
-  `Basic ${Buffer.from(`${credentials.authKey}:${credentials.authSecret}`, 'utf8').toString('base64')}`
-
-const isLoopbackHost = (hostname: string): boolean =>
-  hostname === 'localhost' || hostname === '::1' || hostname.startsWith('127.')
-
-type TokenBaseResult = { ok: true; baseUrl: URL } | { ok: false; error: string }
-
-const normalizeTokenBaseEndpoint = (raw?: string): TokenBaseResult => {
-  const baseRaw = (raw || process.env.TRANSLOADIT_ENDPOINT || 'https://api2.transloadit.com').trim()
-
-  let url: URL
-  try {
-    url = new URL(baseRaw)
-  } catch {
-    return {
-      ok: false,
-      error:
-        'Invalid endpoint URL. Use --endpoint https://api2.transloadit.com (or set TRANSLOADIT_ENDPOINT).',
-    }
-  }
-
-  if (url.username || url.password) {
-    return { ok: false, error: 'Endpoint must not include username/password.' }
-  }
-  if (url.search || url.hash) {
-    return { ok: false, error: 'Endpoint must not include query string or hash.' }
-  }
-
-  if (url.protocol !== 'https:') {
-    if (url.protocol === 'http:' && isLoopbackHost(url.hostname)) {
-      // Allowed for local development only.
-    } else {
-      return {
-        ok: false,
-        error:
-          'Refusing to send credentials to a non-HTTPS endpoint. Use https://... (or http://localhost for local development).',
-      }
-    }
-  }
-
-  // If someone pasted the token URL, normalize it back to the API base to avoid /token/token.
-  const pathLower = url.pathname.toLowerCase()
-  if (pathLower === '/token' || pathLower === '/token/') {
-    url.pathname = '/'
-  }
-
-  if (!url.pathname.endsWith('/')) {
-    url.pathname = `${url.pathname}/`
-  }
-
-  return { ok: true, baseUrl: url }
-}
-
-async function requestTokenWithCredentials(
-  credentials: { authKey: string; authSecret: string },
-  options: RequestTokenOptions = {},
-): Promise<OutputResult> {
-  const endpointResult = normalizeTokenBaseEndpoint(options.endpoint)
-  if (!endpointResult.ok) {
-    return { ok: false, error: endpointResult.error }
-  }
-
-  const url = new URL('token', endpointResult.baseUrl).toString()
-  const aud = (options.aud ?? 'mcp').trim() || 'mcp'
-
-  const body = new URLSearchParams({ grant_type: 'client_credentials', aud }).toString()
-
-  let res: Response
-  const controller = new AbortController()
-  const timeout = setTimeout(() => controller.abort(), 15_000)
-  try {
-    res = await fetch(url, {
-      method: 'POST',
-      // Never follow redirects with Basic Auth credentials.
-      redirect: 'error',
-      signal: controller.signal,
-      headers: {
-        Authorization: buildBasicAuthHeaderValue(credentials),
-        Accept: 'application/json',
-        'Content-Type': 'application/x-www-form-urlencoded',
-      },
-      body,
-    })
-  } catch (err) {
-    clearTimeout(timeout)
-    if (err instanceof Error && err.name === 'AbortError') {
-      return { ok: false, error: 'Failed to mint bearer token: request timed out after 15s.' }
-    }
-    const message = err instanceof Error ? err.message : String(err)
-    return { ok: false, error: `Failed to mint bearer token: ${message}` }
-  } finally {
-    clearTimeout(timeout)
-  }
-
-  const text = await res.text()
-  const trimmed = text.trim()
-  let parsedJson: unknown = null
-  try {
-    parsedJson = trimmed ? JSON.parse(trimmed) : null
-  } catch {
-    parsedJson = null
-  }
-
-  if (res.ok) {
-    if (parsedJson == null) {
-      return { ok: false, error: 'Token response was not valid JSON.' }
-    }
-    const parsed = tokenSuccessSchema.safeParse(parsedJson)
-    if (!parsed.success) {
-      return { ok: false, error: 'Token response did not include an access_token.' }
-    }
-    return { ok: true, output: trimmed }
-  }
-
-  const parsedError = tokenErrorSchema.safeParse(parsedJson)
-  if (parsedError.success) {
-    return {
-      ok: false,
-      error: parsedError.data.message
-        ? `${parsedError.data.error}: ${parsedError.data.message}`
-        : parsedError.data.error,
-    }
-  }
-
-  return {
-    ok: false,
-    error: `Token request failed (${res.status}): ${trimmed || res.statusText}`,
-  }
-}
-
 export async function runSig(options: RunSigOptions = {}): Promise<void> {
   const credentialsResult = requireEnvCredentials()
   if (!credentialsResult.ok) {
@@ -520,6 +372,11 @@ export class TokenCommand extends UnauthenticatedCommand {
     description: 'Token audience (default: mcp).',
   })
 
+  scope = Option.String('--scope', {
+    description:
+      'Comma-separated list of scopes to request (defaults to auth key scopes). Example: assemblies:write,templates:read',
+  })
+
   protected override async run(): Promise<number | undefined> {
     const credentialsResult = requireEnvCredentials()
     if (!credentialsResult.ok) {
@@ -527,13 +384,14 @@ export class TokenCommand extends UnauthenticatedCommand {
       return 1
     }
 
-    const result = await requestTokenWithCredentials(credentialsResult.credentials, {
+    const result = await mintBearerTokenWithCredentials(credentialsResult.credentials, {
       endpoint: this.endpoint,
       aud: this.aud,
+      scope: this.scope,
     })
 
     if (result.ok) {
-      process.stdout.write(`${result.output}\n`)
+      process.stdout.write(`${result.raw}\n`)
       return undefined
     }
 

package/src/cli/commands/index.ts

@@ -1,7 +1,7 @@
 import { Builtins, Cli } from 'clipanion'
 
 import packageJson from '../../../package.json' with { type: 'json' }
-
+import { intentCommands } from '../intentCommands.ts'
 import {
   AssembliesCreateCommand,
   AssembliesDeleteCommand,
@@ -10,9 +10,7 @@ import {
   AssembliesListCommand,
   AssembliesReplayCommand,
 } from './assemblies.ts'
-
 import { SignatureCommand, SmartCdnSignatureCommand, TokenCommand } from './auth.ts'
-
 import { BillsGetCommand } from './bills.ts'
 import { DocsRobotsGetCommand, DocsRobotsListCommand } from './docs.ts'
 import { NotificationsReplayCommand } from './notifications.ts'
@@ -71,5 +69,10 @@ export function createCli(): Cli {
   cli.register(DocsRobotsListCommand)
   cli.register(DocsRobotsGetCommand)
 
+  // Intent-first commands
+  for (const command of intentCommands) {
+    cli.register(command)
+  }
+
   return cli
 }

package/src/cli/commands/templates.ts

@@ -5,12 +5,11 @@ import { Command, Option } from 'clipanion'
 import rreaddir from 'recursive-readdir'
 import { z } from 'zod'
 import { tryCatch } from '../../alphalib/tryCatch.ts'
-import type { Steps } from '../../alphalib/types/template.ts'
-import { stepsSchema } from '../../alphalib/types/template.ts'
 import type { TemplateContent } from '../../apiTypes.ts'
 import type { Transloadit } from '../../Transloadit.ts'
 import { createReadStream, formatAPIError, streamToBuffer } from '../helpers.ts'
 import type { IOutputCtl } from '../OutputCtl.ts'
+import { parseStepsInputJson } from '../stepsInput.ts'
 import ModifiedLookup from '../template-last-modified.ts'
 import type { TemplateFile } from '../types.ts'
 import { ensureError, isTransloaditAPIError, TemplateFileDataSchema } from '../types.ts'
@@ -60,16 +59,11 @@ export async function create(
   try {
     const buf = await streamToBuffer(createReadStream(file))
 
-    const parsed: unknown = JSON.parse(buf.toString())
-    const validated = stepsSchema.safeParse(parsed)
-    if (!validated.success) {
-      throw new Error(`Invalid template steps format: ${validated.error.message}`)
-    }
+    const steps = parseStepsInputJson(buf.toString())
 
     const result = await client.createTemplate({
       name,
-      // Steps (validated) is assignable to StepsInput at runtime; cast for TS
-      template: { steps: validated.data } as TemplateContent,
+      template: { steps } as TemplateContent,
     })
     output.print(result.id, result)
     return result
@@ -106,23 +100,18 @@ export async function modify(
   try {
     const buf = await streamToBuffer(createReadStream(file))
 
-    let steps: Steps | null = null
+    let steps: TemplateContent['steps'] | null = null
     let newName = name
 
     if (buf.length > 0) {
-      const parsed: unknown = JSON.parse(buf.toString())
-      const validated = stepsSchema.safeParse(parsed)
-      if (!validated.success) {
-        throw new Error(`Invalid template steps format: ${validated.error.message}`)
-      }
-      steps = validated.data
+      steps = parseStepsInputJson(buf.toString()) as TemplateContent['steps']
     }
 
     if (!name || buf.length === 0) {
       const tpl = await client.getTemplate(template)
       if (!name) newName = tpl.name
       if (buf.length === 0 && tpl.content.steps) {
-        steps = tpl.content.steps
+        steps = tpl.content.steps as TemplateContent['steps']
       }
     }
 

package/src/cli/fileProcessingOptions.ts

@@ -0,0 +1,294 @@
+import { Option } from 'clipanion'
+import * as t from 'typanion'
+
+export interface SharedCliOptionDocumentation {
+  description: string
+  example: string
+  flags: string
+  required: string
+  type: string
+}
+
+interface SharedCliOptionDefinition {
+  docs: SharedCliOptionDocumentation
+  optionFlags: string
+}
+
+interface SharedCliOptionExports<T> {
+  docs: (description?: string) => SharedCliOptionDocumentation
+  option: (description?: string) => T
+}
+
+export interface SharedFileProcessingValidationInput {
+  explicitInputCount: number
+  singleAssembly: boolean
+  watch: boolean
+  watchRequiresInputsMessage: string
+}
+
+const inputPathsOptionDefinition = {
+  docs: {
+    flags: '--input, -i',
+    type: 'path | dir | url | -',
+    required: 'varies',
+    example: 'input.file',
+    description: 'Provide an input path, directory, URL, or - for stdin',
+  },
+  optionFlags: '--input,-i',
+} as const satisfies SharedCliOptionDefinition
+
+const recursiveOptionDefinition = {
+  docs: {
+    flags: '--recursive, -r',
+    type: 'boolean',
+    required: 'no',
+    example: 'false',
+    description: 'Enumerate input directories recursively',
+  },
+  optionFlags: '--recursive,-r',
+} as const satisfies SharedCliOptionDefinition
+
+const deleteAfterProcessingOptionDefinition = {
+  docs: {
+    flags: '--delete-after-processing, -d',
+    type: 'boolean',
+    required: 'no',
+    example: 'false',
+    description: 'Delete input files after they are processed',
+  },
+  optionFlags: '--delete-after-processing,-d',
+} as const satisfies SharedCliOptionDefinition
+
+const reprocessStaleOptionDefinition = {
+  docs: {
+    flags: '--reprocess-stale',
+    type: 'boolean',
+    required: 'no',
+    example: 'false',
+    description: 'Process inputs even if output is newer',
+  },
+  optionFlags: '--reprocess-stale',
+} as const satisfies SharedCliOptionDefinition
+
+const watchOptionDefinition = {
+  docs: {
+    flags: '--watch, -w',
+    type: 'boolean',
+    required: 'no',
+    example: 'false',
+    description: 'Watch inputs for changes',
+  },
+  optionFlags: '--watch,-w',
+} as const satisfies SharedCliOptionDefinition
+
+const singleAssemblyOptionDefinition = {
+  docs: {
+    flags: '--single-assembly',
+    type: 'boolean',
+    required: 'no',
+    example: 'false',
+    description: 'Pass all input files to a single assembly instead of one assembly per file',
+  },
+  optionFlags: '--single-assembly',
+} as const satisfies SharedCliOptionDefinition
+
+const concurrencyOptionDefinition = {
+  docs: {
+    flags: '--concurrency, -c',
+    type: 'number',
+    required: 'no',
+    example: '5',
+    description: 'Maximum number of concurrent assemblies (default: 5)',
+  },
+  optionFlags: '--concurrency,-c',
+} as const satisfies SharedCliOptionDefinition
+
+const printUrlsOptionDefinition = {
+  docs: {
+    flags: '--print-urls',
+    type: 'boolean',
+    required: 'no',
+    example: 'false',
+    description: 'Print temporary result URLs after completion',
+  },
+  optionFlags: '--print-urls',
+} as const satisfies SharedCliOptionDefinition
+
+function getSharedCliOptionDocumentation(
+  definition: SharedCliOptionDefinition,
+  description = definition.docs.description,
+): SharedCliOptionDocumentation {
+  return {
+    ...definition.docs,
+    description,
+  }
+}
+
+function arrayOption(
+  definition: SharedCliOptionDefinition,
+  description = definition.docs.description,
+): string[] {
+  return Option.Array(definition.optionFlags, {
+    description,
+  }) as unknown as string[]
+}
+
+function booleanOption(
+  definition: SharedCliOptionDefinition,
+  description = definition.docs.description,
+): boolean {
+  return Option.Boolean(definition.optionFlags, false, {
+    description,
+  }) as unknown as boolean
+}
+
+function createArrayOptionExports(
+  definition: SharedCliOptionDefinition,
+): SharedCliOptionExports<string[]> {
+  return {
+    docs: (description = definition.docs.description) =>
+      getSharedCliOptionDocumentation(definition, description),
+    option: (description = definition.docs.description) => arrayOption(definition, description),
+  }
+}
+
+function createBooleanOptionExports(
+  definition: SharedCliOptionDefinition,
+): SharedCliOptionExports<boolean> {
+  return {
+    docs: (description = definition.docs.description) =>
+      getSharedCliOptionDocumentation(definition, description),
+    option: (description = definition.docs.description) => booleanOption(definition, description),
+  }
+}
+
+const inputPathsOptionExports = createArrayOptionExports(inputPathsOptionDefinition)
+const recursiveOptionExports = createBooleanOptionExports(recursiveOptionDefinition)
+const deleteAfterProcessingOptionExports = createBooleanOptionExports(
+  deleteAfterProcessingOptionDefinition,
+)
+const reprocessStaleOptionExports = createBooleanOptionExports(reprocessStaleOptionDefinition)
+const watchOptionExports = createBooleanOptionExports(watchOptionDefinition)
+const singleAssemblyOptionExports = createBooleanOptionExports(singleAssemblyOptionDefinition)
+
+export function getInputPathsOptionDocumentation(
+  description = inputPathsOptionDefinition.docs.description,
+): SharedCliOptionDocumentation {
+  return inputPathsOptionExports.docs(description)
+}
+
+export function inputPathsOption(
+  description = inputPathsOptionDefinition.docs.description,
+): string[] {
+  return inputPathsOptionExports.option(description)
+}
+
+export function getRecursiveOptionDocumentation(
+  description = recursiveOptionDefinition.docs.description,
+): SharedCliOptionDocumentation {
+  return recursiveOptionExports.docs(description)
+}
+
+export function recursiveOption(description = recursiveOptionDefinition.docs.description): boolean {
+  return recursiveOptionExports.option(description)
+}
+
+export function getDeleteAfterProcessingOptionDocumentation(
+  description = deleteAfterProcessingOptionDefinition.docs.description,
+): SharedCliOptionDocumentation {
+  return deleteAfterProcessingOptionExports.docs(description)
+}
+
+export function deleteAfterProcessingOption(
+  description = deleteAfterProcessingOptionDefinition.docs.description,
+): boolean {
+  return deleteAfterProcessingOptionExports.option(description)
+}
+
+export function getReprocessStaleOptionDocumentation(
+  description = reprocessStaleOptionDefinition.docs.description,
+): SharedCliOptionDocumentation {
+  return reprocessStaleOptionExports.docs(description)
+}
+
+export function reprocessStaleOption(
+  description = reprocessStaleOptionDefinition.docs.description,
+): boolean {
+  return reprocessStaleOptionExports.option(description)
+}
+
+export function getWatchOptionDocumentation(
+  description = watchOptionDefinition.docs.description,
+): SharedCliOptionDocumentation {
+  return watchOptionExports.docs(description)
+}
+
+export function watchOption(description = watchOptionDefinition.docs.description): boolean {
+  return watchOptionExports.option(description)
+}
+
+export function getSingleAssemblyOptionDocumentation(
+  description = singleAssemblyOptionDefinition.docs.description,
+): SharedCliOptionDocumentation {
+  return singleAssemblyOptionExports.docs(description)
+}
+
+export function singleAssemblyOption(
+  description = singleAssemblyOptionDefinition.docs.description,
+): boolean {
+  return singleAssemblyOptionExports.option(description)
+}
+
+export function getConcurrencyOptionDocumentation(
+  description = concurrencyOptionDefinition.docs.description,
+): SharedCliOptionDocumentation {
+  return getSharedCliOptionDocumentation(concurrencyOptionDefinition, description)
+}
+
+export function concurrencyOption(
+  description = concurrencyOptionDefinition.docs.description,
+): number | undefined {
+  return Option.String(concurrencyOptionDefinition.optionFlags, {
+    description,
+    validator: t.applyCascade(t.isNumber(), [t.isAtLeast(1)]),
+  }) as unknown as number | undefined
+}
+
+export function getPrintUrlsOptionDocumentation(
+  description = printUrlsOptionDefinition.docs.description,
+): SharedCliOptionDocumentation {
+  return getSharedCliOptionDocumentation(printUrlsOptionDefinition, description)
+}
+
+export function printUrlsOption(description = printUrlsOptionDefinition.docs.description): boolean {
+  return Option.Boolean(printUrlsOptionDefinition.optionFlags, {
+    description,
+  }) as unknown as boolean
+}
+
+export function countProvidedInputs({
+  inputBase64,
+  inputs,
+}: {
+  inputBase64?: string[]
+  inputs?: string[]
+}): number {
+  return (inputs ?? []).length + (inputBase64 ?? []).length
+}
+
+export function validateSharedFileProcessingOptions({
+  explicitInputCount,
+  singleAssembly,
+  watch,
+  watchRequiresInputsMessage,
+}: SharedFileProcessingValidationInput): string | undefined {
+  if (watch && explicitInputCount === 0) {
+    return watchRequiresInputsMessage
+  }
+
+  if (watch && singleAssembly) {
+    return '--single-assembly cannot be used with --watch'
+  }
+
+  return undefined
+}