@ossy/cli 1.16.10 → 1.17.3

package/src/app/publish.js

@@ -0,0 +1,206 @@
+import path from 'path'
+import { existsSync } from 'fs'
+import arg from 'arg'
+import * as Sdk from '@ossy/sdk'
+import { logInfo, logError } from '../log.js'
+import { resolveAppConfigPath } from '../resolve-app-config-path.js'
+import { getAuth } from '../state.js'
+import { walk } from '../upload-dir/cli.js'
+import { prepareFileUpload, uploadFileToUrl } from '../file.js'
+import {
+  postResourceTemplates,
+  requireAppAuthentication,
+  resolveApiBaseUrlForUpload,
+} from './upload-resource-templates.js'
+import { readAppConfig } from './load-config.js'
+
+function normaliseLoc (loc) {
+  let s = loc.replace(/\/+$/, '')
+  if (!s.startsWith('/')) s = '/' + s
+  return s
+}
+
+export async function publish (options) {
+  const parsedArgs = arg({
+    '--authentication': String,
+    '-a': '--authentication',
+    '--config': String,
+    '-c': '--config',
+    '--build-dir': String,
+    '--build-dest': String,
+    '--skip-resource-templates': Boolean,
+    '--api-url': String,
+  }, { argv: options })
+
+  const configFlag = parsedArgs['--config']
+  const configPath = resolveAppConfigPath(configFlag)
+
+  if (!configPath || !existsSync(configPath)) {
+    logError({
+      message: configFlag
+        ? `[@ossy/cli] app publish: config not found: ${configFlag}`
+        : '[@ossy/cli] app publish: no config file. Pass --config (-c) or add src/config.js.',
+    })
+    process.exit(1)
+  }
+
+  const config = readAppConfig(configPath)
+  const { workspaceId, apiUrl: configApiUrl, domain, resourceTemplates } = config
+
+  if (!workspaceId) {
+    logError({ message: '[@ossy/cli] app publish: no workspaceId in config' })
+    process.exit(1)
+  }
+
+  const apiBaseUrl = resolveApiBaseUrlForUpload({
+    flag: parsedArgs['--api-url'],
+    envVar: process.env.OSSY_API_URL,
+    configApiUrl,
+  })
+
+  let authToken
+  try {
+    authToken = requireAppAuthentication(
+      getAuth({ flag: parsedArgs['--authentication'] }),
+      'publish'
+    )
+  } catch (e) {
+    logError({ message: e?.message || '[@ossy/cli] app publish: authentication required.' })
+    process.exit(1)
+  }
+
+  // Step 1: upload resource templates
+  if (!parsedArgs['--skip-resource-templates']) {
+    if (Array.isArray(resourceTemplates) && resourceTemplates.length > 0) {
+      logInfo({ message: '[@ossy/cli] app publish: uploading resource templates…' })
+      const res = await postResourceTemplates({
+        apiBaseUrl,
+        token: authToken,
+        workspaceId,
+        resourceTemplates,
+      })
+      if (!res.ok) {
+        const text = await res.text().catch(() => '')
+        logError({
+          message: `[@ossy/cli] app publish: resource template upload failed: HTTP ${res.status}${text ? ` — ${text.slice(0, 200)}` : ''}`,
+        })
+        process.exit(1)
+      }
+      logInfo({ message: '[@ossy/cli] app publish: resource templates uploaded' })
+    } else {
+      logInfo({ message: '[@ossy/cli] app publish: no resource templates in config, skipping' })
+    }
+  }
+
+  // Step 2: upload build/ to CMS
+  const packageRoot = path.join(path.dirname(configPath), '..')
+  const buildDir = parsedArgs['--build-dir']
+    ? path.resolve(parsedArgs['--build-dir'])
+    : path.join(packageRoot, 'build')
+
+  const remoteDest = parsedArgs['--build-dest']
+    ? normaliseLoc(parsedArgs['--build-dest'])
+    : domain
+      ? `/sites/${domain}`
+      : null
+
+  if (!remoteDest) {
+    logError({
+      message: '[@ossy/cli] app publish: no domain in config and no --build-dest specified',
+    })
+    process.exit(1)
+  }
+
+  if (!existsSync(buildDir)) {
+    logError({
+      message: `[@ossy/cli] app publish: build directory not found: ${buildDir}. Run \`ossy app build\` first.`,
+    })
+    process.exit(1)
+  }
+
+  const sdk = Sdk.SDK.of({
+    apiUrl: apiBaseUrl,
+    workspaceId,
+    authorization: authToken,
+  })
+
+  const { dirs, files } = walk(buildDir)
+  logInfo({
+    message: `[@ossy/cli] app publish: uploading build (${files.length} file${files.length === 1 ? '' : 's'}) to ${remoteDest}…`,
+  })
+
+  const createDir = Sdk.ResourcesCreateDirectory
+  const uploadAction = Sdk.ResourcesUpload
+
+  let errors = 0
+
+  for (const d of dirs) {
+    const rel = d.slice(buildDir.length)
+    const parent = normaliseLoc(remoteDest + path.dirname(rel))
+    const name = path.basename(d)
+    try {
+      await sdk.makeRequest(createDir)({ location: parent, name })
+    } catch (err) {
+      const status = err && err.status
+      if (status !== 409 && status !== 422) {
+        logError({
+          message: `[@ossy/cli] app publish: mkdir failed for ${parent}/${name}: ${err?.message ?? err}`,
+        })
+        errors++
+      }
+    }
+  }
+
+  for (const f of files) {
+    const rel = f.slice(buildDir.length)
+    const remoteDir = normaliseLoc(remoteDest + path.dirname(rel))
+
+    let fileMeta
+    try {
+      fileMeta = prepareFileUpload(f)
+    } catch (err) {
+      logError({ message: `[@ossy/cli] app publish: cannot read file ${f}: ${err.message}` })
+      errors++
+      continue
+    }
+
+    let result
+    try {
+      result = await sdk.makeRequest(uploadAction)({
+        location: remoteDir,
+        name: fileMeta.name,
+        type: fileMeta.type,
+        size: fileMeta.size,
+      })
+    } catch (err) {
+      logError({ message: `[@ossy/cli] app publish: upload failed for ${f}: ${err?.message ?? err}` })
+      errors++
+      continue
+    }
+
+    const uploadUrl = result?.content?.uploadUrl
+    if (!uploadUrl) {
+      logError({ message: `[@ossy/cli] app publish: no uploadUrl in response for ${f}` })
+      errors++
+      continue
+    }
+
+    try {
+      await uploadFileToUrl(fileMeta, uploadUrl)
+    } catch (err) {
+      logError({ message: `[@ossy/cli] app publish: S3 PUT failed for ${f}: ${err.message}` })
+      errors++
+    }
+  }
+
+  if (errors > 0) {
+    logError({
+      message: `[@ossy/cli] app publish: done with ${errors} error${errors === 1 ? '' : 's'}`,
+    })
+    process.exit(1)
+  }
+
+  logInfo({
+    message: `[@ossy/cli] app publish: done — ${files.length} file${files.length === 1 ? '' : 's'} uploaded to ${remoteDest}`,
+  })
+}

package/src/{cms → app}/upload-resource-templates.js

@@ -14,7 +14,7 @@ export function normalizeAuthorizationToken (token) {
  * @param {string} label e.g. "Resource template upload"
  * @returns {string} normalized JWT
  */
-export function requireCmsAuthentication (token, label) {
+export function requireAppAuthentication (token, label) {
   const normalized = normalizeAuthorizationToken(token)
   if (!normalized) {
     throw new Error(

package/src/auth/cli.js

@@ -0,0 +1,135 @@
+import readline from 'node:readline/promises'
+import { stdin as input, stdout as output } from 'node:process'
+import arg from 'arg'
+import { logInfo, logError } from '../log.js'
+import {
+  readCredentials,
+  writeCredentials,
+  deleteCredentials,
+  getAuth,
+  getApiUrl,
+  getWorkspaceId,
+  describeStatePaths,
+} from '../state.js'
+
+function stripBearer (t) {
+  return String(t ?? '').trim().replace(/^Bearer\s+/i, '').trim()
+}
+
+async function promptHidden (question) {
+  // Tokens contain dots; avoid leaking partial input in shell history. Echo is left on
+  // because Node's tty masking is fiddly across platforms — paste-and-press-enter is
+  // the documented flow. We could revisit with a real prompt lib later.
+  const rl = readline.createInterface({ input, output })
+  try {
+    return (await rl.question(question)).trim()
+  } finally {
+    rl.close()
+  }
+}
+
+async function login (options) {
+  const parsed = arg({
+    '--token': String,
+    '-t': '--token',
+    '--api-url': String,
+  }, { argv: options })
+
+  let token = parsed['--token']
+  if (!token) {
+    if (!input.isTTY) {
+      logError({
+        message:
+          '[@ossy/cli] auth login: pass --token <jwt> or run interactively in a TTY.',
+      })
+      process.exit(1)
+    }
+    token = await promptHidden('Paste your Ossy API token: ')
+  }
+
+  const normalized = stripBearer(token)
+  if (!normalized) {
+    logError({ message: '[@ossy/cli] auth login: empty token.' })
+    process.exit(1)
+  }
+
+  const apiUrl = getApiUrl({ flag: parsed['--api-url'] })
+
+  let me = null
+  try {
+    const res = await fetch(`${apiUrl}/users/me`, {
+      headers: { Authorization: normalized, 'Content-Type': 'application/json' },
+    })
+    if (!res.ok) {
+      logError({
+        message: `[@ossy/cli] auth login: token rejected by ${apiUrl}/users/me (HTTP ${res.status})`,
+      })
+      process.exit(1)
+    }
+    me = await res.json().catch(() => null)
+  } catch (error) {
+    logError({ message: `[@ossy/cli] auth login: could not reach ${apiUrl}`, error })
+    process.exit(1)
+  }
+
+  writeCredentials({ apiUrl, token: normalized })
+  logInfo({
+    message: `[@ossy/cli] Logged in as ${me?.email || me?.id || 'user'} on ${apiUrl}`,
+  })
+}
+
+function logout () {
+  deleteCredentials()
+  logInfo({ message: '[@ossy/cli] Logged out' })
+}
+
+async function status () {
+  const creds = readCredentials()
+  const paths = describeStatePaths()
+  const apiUrl = getApiUrl()
+  const workspaceId = getWorkspaceId()
+
+  if (!creds?.token) {
+    console.log(
+      `Not logged in. Run \`ossy auth login\` to save credentials at ${paths.credentials}.`
+    )
+    return
+  }
+
+  const auth = getAuth()
+  let userInfo = null
+  let live = false
+  try {
+    const res = await fetch(`${apiUrl}/users/me`, {
+      headers: { Authorization: auth, 'Content-Type': 'application/json' },
+    })
+    if (res.ok) {
+      userInfo = await res.json().catch(() => null)
+      live = true
+    }
+  } catch {
+    // network failure → just report offline status
+  }
+
+  console.log(`API URL:    ${apiUrl}`)
+  console.log(
+    `User:       ${live ? (userInfo?.email || userInfo?.id || 'unknown') : '(token rejected — try `ossy auth login`)'}`
+  )
+  console.log(
+    `Workspace:  ${workspaceId || '(none — run `ossy workspace use <id>`)'}`
+  )
+  console.log(`Creds file: ${paths.credentials}`)
+  console.log(`Config:     ${paths.config}`)
+}
+
+export async function handler (args) {
+  const [sub, ...rest] = args
+  if (sub === 'login') return await login(rest)
+  if (sub === 'logout') return logout()
+  if (sub === 'status') return await status()
+  logError({
+    message:
+      '[@ossy/cli] auth: unknown subcommand. Use: ossy auth login | logout | status',
+  })
+  process.exit(1)
+}

package/src/call/cli.js

@@ -0,0 +1,311 @@
+import * as Sdk from '@ossy/sdk'
+import { logError } from '../log.js'
+import { getAuth, getApiUrl, getWorkspaceId } from '../state.js'
+import { prepareFileUpload, uploadFileToUrl } from '../file.js'
+
+const ACTIONS = Object.values(Sdk).filter(
+  (v) =>
+    v
+    && typeof v === 'object'
+    && typeof v.id === 'string'
+    && typeof v.endpoint === 'string'
+    && typeof v.method === 'string'
+)
+
+const ACTION_BY_ID = new Map(ACTIONS.map((a) => [a.id, a]))
+
+function listActionsByDomain () {
+  const grouped = new Map()
+  for (const action of ACTIONS) {
+    const domain = action.id.split('.')[0]
+    if (!grouped.has(domain)) grouped.set(domain, [])
+    grouped.get(domain).push(action.id)
+  }
+  for (const [, ids] of grouped) ids.sort()
+  return new Map([...grouped.entries()].sort(([a], [b]) => a.localeCompare(b)))
+}
+
+function buildHelp () {
+  const grouped = listActionsByDomain()
+  const blocks = []
+  for (const [domain, ids] of grouped) {
+    blocks.push(`  ${domain}\n${ids.map((id) => `    ${id}`).join('\n')}`)
+  }
+  return `ossy call <action.id> [--key value]... [--json '{...}'] [options]
+
+Generic dispatcher for any Ossy API action. Flags become payload fields
+(--first-name -> firstName); --json '{...}' is merged on top.
+
+Options:
+  --json '{...}'         Provide payload as JSON (merged with --key value flags)
+  --file <path>          Attach a local file: derives name/type/size as defaults
+                         and PUTs the bytes if the response returns content.uploadUrl
+  -w, --workspace-id     Override active workspace id (sent as workspaceId header)
+  -a, --authentication   Override API token (otherwise resolved from state/env)
+  --api-url              Override API base URL
+  --raw                  Print response body without JSON pretty-printing
+
+Per-action help:
+  ossy call <action.id> --help
+
+Available actions:
+
+${blocks.join('\n\n')}
+`
+}
+
+function actionHelp (action) {
+  const def = action.payload ? `Default payload:\n  ${JSON.stringify(action.payload)}\n\n` : ''
+  return `${action.id}  ${action.method} ${action.endpoint}
+
+${def}Examples:
+  ossy call ${action.id} --key value --other value
+  ossy call ${action.id} --json '{"key":"value"}'
+`
+}
+
+function kebabToCamel (str) {
+  return str.replace(/-([a-z])/g, (_, c) => c.toUpperCase())
+}
+
+const RESERVED_FLAGS_NEEDING_VALUE = new Set([
+  '--json',
+  '--workspace-id', '-w',
+  '--authentication', '-a',
+  '--api-url',
+  '--file',
+])
+
+function parseCallArgs (argv) {
+  const out = {
+    actionId: null,
+    payload: {},
+    workspaceId: null,
+    authentication: null,
+    apiUrl: null,
+    raw: false,
+    json: null,
+    file: null,
+    explicitPayloadKeys: new Set(),
+    help: false,
+  }
+
+  let i = 0
+  while (i < argv.length) {
+    const arg = argv[i]
+
+    if (arg === '--help' || arg === '-h') {
+      out.help = true
+      i++
+      continue
+    }
+    if (arg === '--raw') {
+      out.raw = true
+      i++
+      continue
+    }
+
+    // `--key=value` form, including reserved flags
+    if (arg.startsWith('--') && arg.includes('=')) {
+      const eq = arg.indexOf('=')
+      const key = arg.slice(2, eq)
+      const value = arg.slice(eq + 1)
+      if (key === 'json') out.json = value
+      else if (key === 'workspace-id') out.workspaceId = value
+      else if (key === 'authentication') out.authentication = value
+      else if (key === 'api-url') out.apiUrl = value
+      else if (key === 'file') out.file = value
+      else {
+        const camel = kebabToCamel(key)
+        out.payload[camel] = value
+        out.explicitPayloadKeys.add(camel)
+      }
+      i++
+      continue
+    }
+
+    // Reserved space-separated flags
+    if (RESERVED_FLAGS_NEEDING_VALUE.has(arg)) {
+      const value = argv[i + 1]
+      if (arg === '--json') out.json = value
+      else if (arg === '--workspace-id' || arg === '-w') out.workspaceId = value
+      else if (arg === '--authentication' || arg === '-a') out.authentication = value
+      else if (arg === '--api-url') out.apiUrl = value
+      else if (arg === '--file') out.file = value
+      i += 2
+      continue
+    }
+
+    // Action.id is the first non-flag positional
+    if (!arg.startsWith('-') && out.actionId === null) {
+      out.actionId = arg
+      i++
+      continue
+    }
+
+    // Generic --key (value | true)
+    if (arg.startsWith('--')) {
+      const key = arg.slice(2)
+      const camel = kebabToCamel(key)
+      const next = argv[i + 1]
+      if (next === undefined || next.startsWith('-')) {
+        out.payload[camel] = true
+        out.explicitPayloadKeys.add(camel)
+        i++
+      } else {
+        out.payload[camel] = next
+        out.explicitPayloadKeys.add(camel)
+        i += 2
+      }
+      continue
+    }
+
+    // Stray positional after the action id — ignore
+    i++
+  }
+
+  if (out.json) {
+    let parsed
+    try {
+      parsed = JSON.parse(out.json)
+    } catch (e) {
+      throw new Error(`--json: invalid JSON (${e.message})`)
+    }
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      throw new Error('--json: must be a JSON object')
+    }
+    for (const k of Object.keys(parsed)) out.explicitPayloadKeys.add(k)
+    Object.assign(out.payload, parsed)
+  }
+
+  return out
+}
+
+function isResponseLike (value) {
+  return (
+    value
+    && typeof value === 'object'
+    && typeof value.status === 'number'
+    && typeof value.text === 'function'
+    && typeof value.headers === 'object'
+    && typeof value.headers.get === 'function'
+  )
+}
+
+async function call (args) {
+  let parsed
+  try {
+    parsed = parseCallArgs(args)
+  } catch (err) {
+    logError({ message: `[@ossy/cli] call: ${err.message}` })
+    process.exit(1)
+  }
+
+  if (parsed.help && !parsed.actionId) {
+    console.log(buildHelp())
+    return
+  }
+
+  if (!parsed.actionId) {
+    console.log(buildHelp())
+    return
+  }
+
+  const action = ACTION_BY_ID.get(parsed.actionId)
+  if (!action) {
+    logError({
+      message: `[@ossy/cli] call: unknown action "${parsed.actionId}". Run \`ossy call --help\` for the list.`,
+    })
+    process.exit(1)
+  }
+
+  if (parsed.help) {
+    console.log(actionHelp(action))
+    return
+  }
+
+  const auth = getAuth({ flag: parsed.authentication })
+  const apiUrl = getApiUrl({ flag: parsed.apiUrl })
+  const workspaceId = getWorkspaceId({ flag: parsed.workspaceId })
+
+  const sdk = Sdk.SDK.of({
+    apiUrl,
+    workspaceId: workspaceId || undefined,
+    authorization: auth || undefined,
+  })
+
+  let fileMeta = null
+  if (parsed.file) {
+    try {
+      fileMeta = prepareFileUpload(parsed.file)
+    } catch (err) {
+      logError({ message: `[@ossy/cli] call: ${err.message}` })
+      process.exit(1)
+    }
+    if (!parsed.explicitPayloadKeys.has('name')) parsed.payload.name = fileMeta.name
+    if (!parsed.explicitPayloadKeys.has('type')) parsed.payload.type = fileMeta.type
+    if (!parsed.explicitPayloadKeys.has('size')) parsed.payload.size = fileMeta.size
+  }
+
+  let result
+  try {
+    result = await sdk.makeRequest(action)(parsed.payload)
+  } catch (err) {
+    if (isResponseLike(err)) {
+      const text = await err.text().catch(() => '')
+      process.stderr.write(`HTTP ${err.status}${err.statusText ? ' ' + err.statusText : ''}\n`)
+      if (text) process.stderr.write(text + '\n')
+      process.exit(1)
+    }
+    if (typeof err === 'string') {
+      process.stderr.write(err + '\n')
+      process.exit(1)
+    }
+    if (err && err.message) {
+      process.stderr.write(`${err.message}\n`)
+      process.exit(1)
+    }
+    process.stderr.write(JSON.stringify(err) + '\n')
+    process.exit(1)
+  }
+
+  if (isResponseLike(result)) {
+    if (parsed.raw) {
+      const text = await result.text().catch(() => '')
+      if (text) process.stdout.write(text.endsWith('\n') ? text : text + '\n')
+    } else {
+      console.log(JSON.stringify({ status: result.status }, null, 2))
+    }
+    return
+  }
+
+  if (fileMeta) {
+    const uploadUrl = result && result.content && result.content.uploadUrl
+    if (uploadUrl) {
+      try {
+        await uploadFileToUrl(fileMeta, uploadUrl)
+      } catch (err) {
+        process.stderr.write(`[@ossy/cli] call: upload PUT failed: ${err.message || err}\n`)
+        process.exit(1)
+      }
+    } else {
+      process.stderr.write(
+        '[@ossy/cli] call: --file was provided but the response did not include content.uploadUrl; nothing was uploaded.\n'
+      )
+    }
+  }
+
+  if (parsed.raw) {
+    process.stdout.write(
+      typeof result === 'string'
+        ? (result.endsWith('\n') ? result : result + '\n')
+        : JSON.stringify(result) + '\n'
+    )
+    return
+  }
+
+  console.log(JSON.stringify(result, null, 2))
+}
+
+export const handler = call
+export { parseCallArgs, ACTIONS, ACTION_BY_ID, listActionsByDomain, buildHelp, actionHelp }