transloadit 4.8.0 → 4.8.2

package/src/cli/helpers.ts

@@ -1,30 +1,295 @@
 import fs from 'node:fs'
 import fsp from 'node:fs/promises'
+import { homedir } from 'node:os'
+import path from 'node:path'
 import type { Readable } from 'node:stream'
+import { parse as parseDotenv } from 'dotenv'
 import { isAPIError } from './types.ts'
 
-const MISSING_CREDENTIALS_MESSAGE =
-  'Missing credentials. Please set TRANSLOADIT_KEY and TRANSLOADIT_SECRET environment variables.'
+export type CliKeySecretCredentials = { authKey: string; authSecret: string }
+export type CliAuthToken = { authToken: string }
+export type CliAuth = CliKeySecretCredentials | CliAuthToken
+type CliEnvSource = {
+  name: 'env' | 'credentialsFile'
+  values: Record<string, string | undefined>
+}
+
+let loadedProjectDotenvPath: string | undefined
+let projectDotenvInjectedValues: Record<string, string> | undefined
+let projectDotenvPreviousValues: Record<string, string | undefined> | undefined
+let shellEnvBeforeProjectDotenv: Record<string, string | undefined> | undefined
+
+type LoadCliEnvSourcesResult = {
+  loadError?: string
+  shellEnvSource: CliEnvSource
+  sources: CliEnvSource[]
+}
+
+export type ResolvedCliConfig = {
+  auth?: CliAuth
+  credentials?: CliKeySecretCredentials
+  credentialsEndpoint?: string
+  endpoint?: string
+  loadError?: string
+}
+
+function normalizeEnvValue(value: string | undefined): string | undefined {
+  const trimmed = value?.trim()
+  return trimmed ? trimmed : undefined
+}
+
+function getConfiguredCredentialsFilePath(): string {
+  const configuredPath = normalizeEnvValue(process.env.TRANSLOADIT_CREDENTIALS_FILE)
+  if (configuredPath != null) {
+    return path.resolve(configuredPath)
+  }
+
+  return path.join(homedir(), '.transloadit', 'credentials')
+}
+
+function getProjectDotenvPath(): string {
+  return path.resolve(process.cwd(), '.env')
+}
+
+function getDisplayPath(filePath: string): string {
+  const normalizedHome = path.resolve(homedir())
+  const normalizedFilePath = path.resolve(filePath)
+  if (normalizedFilePath === normalizedHome) return '~'
+  if (normalizedFilePath.startsWith(`${normalizedHome}${path.sep}`)) {
+    return `~${normalizedFilePath.slice(normalizedHome.length)}`
+  }
+
+  return normalizedFilePath
+}
+
+export function buildMissingCredentialsMessage(): string {
+  return [
+    'Missing credentials.',
+    '',
+    'Looked for TRANSLOADIT_KEY + TRANSLOADIT_SECRET in this order:',
+    '1. Shell env: TRANSLOADIT_KEY / TRANSLOADIT_SECRET',
+    `2. Current directory .env: ${getProjectDotenvPath()}`,
+    `3. Credentials file: ${getDisplayPath(getConfiguredCredentialsFilePath())}`,
+  ].join('\n')
+}
+
+export function buildMissingAuthMessage(): string {
+  return [
+    'Missing authentication.',
+    '',
+    'Looked for TRANSLOADIT_AUTH_TOKEN or TRANSLOADIT_KEY + TRANSLOADIT_SECRET in this order:',
+    '1. Shell env: TRANSLOADIT_AUTH_TOKEN, or TRANSLOADIT_KEY / TRANSLOADIT_SECRET',
+    `2. Current directory .env: ${getProjectDotenvPath()}`,
+    `3. Credentials file: ${getDisplayPath(getConfiguredCredentialsFilePath())}`,
+  ].join('\n')
+}
+
+function readEnvFile(
+  filePath: string,
+): { ok: true; source: CliEnvSource } | { ok: false; error: string } | null {
+  if (!fs.existsSync(filePath)) return null
+
+  try {
+    return {
+      ok: true,
+      source: {
+        name: 'credentialsFile',
+        values: parseDotenv(fs.readFileSync(filePath)),
+      },
+    }
+  } catch (err) {
+    if (!(err instanceof Error)) {
+      throw new Error(`Was thrown a non-error: ${err}`)
+    }
+    return { ok: false, error: `Failed to read ${filePath}: ${err.message}` }
+  }
+}
+
+export function loadProjectDotenvIntoProcessEnv(): string | undefined {
+  const projectDotenvPath = getProjectDotenvPath()
+  if (loadedProjectDotenvPath !== projectDotenvPath) {
+    restoreProjectDotenvFromProcessEnv()
+    shellEnvBeforeProjectDotenv = { ...process.env }
+    loadedProjectDotenvPath = projectDotenvPath
+  }
+
+  const projectDotenvResult = readEnvFile(projectDotenvPath)
+  if (projectDotenvResult == null) {
+    restoreProjectDotenvFromProcessEnv()
+    projectDotenvInjectedValues = undefined
+    projectDotenvPreviousValues = undefined
+    return undefined
+  }
+
+  if (!projectDotenvResult.ok) return projectDotenvResult.error
+  if (projectDotenvInjectedValues != null) return undefined
+
+  const previousValues: Record<string, string | undefined> = {}
+  const injectedValues: Record<string, string> = {}
+  for (const [key, value] of Object.entries(projectDotenvResult.source.values)) {
+    if (value == null) continue
+    if (normalizeEnvValue(process.env[key]) != null) continue
+    previousValues[key] = process.env[key]
+    process.env[key] = value
+    injectedValues[key] = value
+  }
+
+  projectDotenvPreviousValues = previousValues
+  projectDotenvInjectedValues = injectedValues
+  return undefined
+}
+
+function getShellEnvValues(): Record<string, string | undefined> {
+  if (loadedProjectDotenvPath === getProjectDotenvPath() && shellEnvBeforeProjectDotenv != null) {
+    return shellEnvBeforeProjectDotenv
+  }
+
+  return { ...process.env }
+}
+
+function restoreProjectDotenvFromProcessEnv(): void {
+  if (projectDotenvInjectedValues == null || projectDotenvPreviousValues == null) return
+
+  for (const [key, injectedValue] of Object.entries(projectDotenvInjectedValues)) {
+    if (process.env[key] !== injectedValue) continue
+
+    const previousValue = projectDotenvPreviousValues[key]
+    if (previousValue == null) {
+      delete process.env[key]
+      continue
+    }
+
+    process.env[key] = previousValue
+  }
+
+  projectDotenvInjectedValues = undefined
+  projectDotenvPreviousValues = undefined
+}
+
+function loadCliEnvSources(): LoadCliEnvSourcesResult {
+  const shellEnvSource: CliEnvSource = {
+    name: 'env',
+    values: getShellEnvValues(),
+  }
+  const loadErrors: string[] = []
+
+  const projectDotenvLoadError = loadProjectDotenvIntoProcessEnv()
+  if (projectDotenvLoadError != null) {
+    loadErrors.push(projectDotenvLoadError)
+  }
+
+  const sources: CliEnvSource[] = [
+    {
+      name: 'env',
+      values: { ...process.env },
+    },
+  ]
+
+  const credentialsFilePath = getConfiguredCredentialsFilePath()
+  const credentialsFileResult = readEnvFile(credentialsFilePath)
+  if (credentialsFileResult?.ok === true) {
+    sources.push(credentialsFileResult.source)
+  } else if (credentialsFileResult?.ok === false) {
+    loadErrors.push(credentialsFileResult.error)
+  } else if (normalizeEnvValue(process.env.TRANSLOADIT_CREDENTIALS_FILE) != null) {
+    loadErrors.push(`Configured credentials file does not exist: ${credentialsFilePath}`)
+  }
+
+  return {
+    shellEnvSource,
+    sources,
+    ...(loadErrors[0] ? { loadError: loadErrors[0] } : {}),
+  }
+}
 
-type EnvCredentials = { authKey: string; authSecret: string }
+function getSourceValue(source: CliEnvSource, keys: string[]): string | undefined {
+  for (const key of keys) {
+    const value = normalizeEnvValue(source.values[key])
+    if (value != null) return value
+  }
 
-function getEnvCredentials(): { authKey: string; authSecret: string } | null {
-  const authKey = process.env.TRANSLOADIT_KEY ?? process.env.TRANSLOADIT_AUTH_KEY
-  const authSecret = process.env.TRANSLOADIT_SECRET ?? process.env.TRANSLOADIT_AUTH_SECRET
+  return undefined
+}
 
-  if (!authKey || !authSecret) return null
+function getSourceCredentials(source: CliEnvSource): CliKeySecretCredentials | undefined {
+  const authKey = getSourceValue(source, ['TRANSLOADIT_KEY', 'TRANSLOADIT_AUTH_KEY'])
+  const authSecret = getSourceValue(source, ['TRANSLOADIT_SECRET', 'TRANSLOADIT_AUTH_SECRET'])
+  if (authKey == null || authSecret == null) return undefined
 
   return { authKey, authSecret }
 }
 
-type RequireEnvCredentialsResult =
-  | { ok: true; credentials: EnvCredentials }
+function getSourceAuthToken(source: CliEnvSource): CliAuthToken | undefined {
+  const authToken = getSourceValue(source, ['TRANSLOADIT_AUTH_TOKEN'])
+  if (authToken == null) return undefined
+
+  return { authToken }
+}
+
+function resolveEndpointForSource(
+  source: CliEnvSource | undefined,
+  shellEnvSource: CliEnvSource,
+): string | undefined {
+  const shellEndpoint = getSourceValue(shellEnvSource, ['TRANSLOADIT_ENDPOINT'])
+  if (shellEndpoint != null) return shellEndpoint
+  if (source == null) return undefined
+
+  return getSourceValue(source, ['TRANSLOADIT_ENDPOINT'])
+}
+
+export function resolveCliConfig(): ResolvedCliConfig {
+  const { loadError, shellEnvSource, sources } = loadCliEnvSources()
+  let auth: CliAuth | undefined
+  let authSource: CliEnvSource | undefined
+  let credentials: CliKeySecretCredentials | undefined
+  let credentialsSource: CliEnvSource | undefined
+
+  for (const source of sources) {
+    if (auth == null) {
+      const authToken = getSourceAuthToken(source)
+      if (authToken != null) {
+        auth = authToken
+        authSource = source
+      } else {
+        const sourceCredentials = getSourceCredentials(source)
+        if (sourceCredentials != null) {
+          auth = sourceCredentials
+          authSource = source
+        }
+      }
+    }
+
+    if (credentials != null) continue
+
+    const sourceCredentials = getSourceCredentials(source)
+    if (sourceCredentials != null) {
+      credentials = sourceCredentials
+      credentialsSource = source
+    }
+  }
+
+  return {
+    ...(auth != null ? { auth } : {}),
+    ...(credentials != null ? { credentials } : {}),
+    ...(authSource != null
+      ? { endpoint: resolveEndpointForSource(authSource, shellEnvSource) }
+      : {}),
+    ...(credentialsSource != null
+      ? { credentialsEndpoint: resolveEndpointForSource(credentialsSource, shellEnvSource) }
+      : {}),
+    ...(loadError != null ? { loadError } : {}),
+  }
+}
+
+type RequireCliCredentialsResult =
+  | { ok: true; credentials: CliKeySecretCredentials }
   | { ok: false; error: string }
 
-export function requireEnvCredentials(): RequireEnvCredentialsResult {
-  const credentials = getEnvCredentials()
-  if (credentials == null) return { ok: false, error: MISSING_CREDENTIALS_MESSAGE }
-  return { ok: true, credentials }
+export function requireCliCredentials(): RequireCliCredentialsResult {
+  const { credentials, loadError } = resolveCliConfig()
+  if (credentials != null) return { ok: true, credentials }
+  if (loadError != null) return { ok: false, error: loadError }
+  return { ok: false, error: buildMissingCredentialsMessage() }
 }
 
 export function createReadStream(file: string): Readable {

package/src/cli/intentCommands.ts

@@ -278,7 +278,7 @@ function inferExamples(
     }
 
     return [
-      ['Run the command', `transloadit ${spec.paths.join(' ')} --input input.mp4 --out output/`],
+      ['Run the command', `transloadit ${spec.paths.join(' ')} --input input.mp4 --output output/`],
     ]
   }
 
@@ -310,7 +310,7 @@ function inferExamples(
   }
 
   const outputMode = spec.intentDefinition.outputMode ?? 'file'
-  parts.push('--out', inferOutputPath(spec.paths, outputMode, fieldSpecs))
+  parts.push('--output', inferOutputPath(spec.paths, outputMode, fieldSpecs))
 
   return [['Run the command', parts.join(' ')]]
 }
@@ -355,11 +355,13 @@ function resolveRobotIntent(definition: RobotIntentDefinition): BuiltIntentComma
       input.kind === 'none'
         ? {
             execution,
+            defaultOutputPath: inferOutputPath(paths, outputMode, fieldSpecs),
             outputDescription: 'Write the result to this path',
             outputMode,
           }
         : {
             commandLabel,
+            defaultOutputPath: inferOutputPath(paths, outputMode, fieldSpecs),
             execution,
             inputPolicy: input.inputPolicy,
             outputDescription:
@@ -388,18 +390,18 @@ function getIntentDetails({
   robot: string
 }): string {
   if (inputMode === 'none') {
-    return `Runs \`${robot}\` and writes the result to \`--out\`.`
+    return `Runs \`${robot}\` and writes the result to \`--output\`.`
   }
 
   if (defaultSingleAssembly) {
-    return `Runs \`${robot}\` for the provided inputs and writes the result to \`--out\`.`
+    return `Runs \`${robot}\` for the provided inputs and writes the result to \`--output\`.`
   }
 
   if (outputMode === 'directory') {
-    return `Runs \`${robot}\` on each input file and writes the results to \`--out\`.`
+    return `Runs \`${robot}\` on each input file and writes the results to \`--output\`.`
   }
 
-  return `Runs \`${robot}\` on each input file and writes the result to \`--out\`.`
+  return `Runs \`${robot}\` on each input file and writes the result to \`--output\`.`
 }
 
 function resolveSemanticIntent(definition: SemanticIntentDefinition): BuiltIntentCommandDefinition {
@@ -415,6 +417,7 @@ function resolveSemanticIntent(definition: SemanticIntentDefinition): BuiltInten
     runnerKind: descriptor.runnerKind,
     intentDefinition: {
       commandLabel: paths.join(' '),
+      defaultOutputPath: descriptor.defaultOutputPath,
       execution: descriptor.execution,
       inputPolicy: descriptor.inputPolicy,
       outputDescription: descriptor.outputDescription,
@@ -430,12 +433,13 @@ function resolveTemplateIntent(
   const spec: BuiltIntentCommandDefinition = {
     className: `${toPascalCase(paths)}Command`,
     description: `Run ${stripTrailingPunctuation(definition.templateId)}`,
-    details: `Runs the \`${definition.templateId}\` template and writes the outputs to \`--out\`.`,
+    details: `Runs the \`${definition.templateId}\` template and writes the outputs to \`--output\`.`,
     examples: [],
     paths,
     runnerKind: 'standard',
     intentDefinition: {
       commandLabel: paths.join(' '),
+      defaultOutputPath: inferOutputPath(paths, outputMode, []),
       execution: {
         kind: 'template',
         templateId: definition.templateId,