@ossy/cli 1.16.10 → 1.17.3

package/src/upload-dir/cli.js

@@ -0,0 +1,270 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import * as Sdk from '@ossy/sdk'
+import { logInfo, logError } from '../log.js'
+import { getAuth, getApiUrl, getWorkspaceId } from '../state.js'
+import { prepareFileUpload, uploadFileToUrl } from '../file.js'
+
+const HELP = `ossy upload-dir <localDir> <remoteLocation> [options]
+
+Recursively mirror a local directory into the Ossy CMS.
+Creates folders first (parents before children), then uploads every file.
+Per-item errors are logged and skipped; exit code is non-zero if any failed.
+
+Arguments:
+  <localDir>         Path to the local directory to upload
+  <remoteLocation>   Remote location to mirror into (e.g. /my-folder)
+
+Options:
+  --dry-run            Print what would happen without making any API calls
+  -a, --authentication Ossy API JWT (or set OSSY_API_KEY, or run \`ossy auth login\`)
+  -w, --workspace-id   Workspace id (or set OSSY_WORKSPACE_ID, or run \`ossy workspace use\`)
+  --api-url            Override API base URL
+  -h, --help           Show this help
+
+Example:
+  ossy upload-dir ./public /my-folder
+  ossy upload-dir ./public /my-folder --dry-run
+`
+
+/**
+ * Walk a local directory tree.
+ * Returns dirs breadth-first (parents before children) and files in discovery order.
+ * @param {string} absRoot
+ * @returns {{ dirs: string[], files: string[] }}
+ */
+export function walk (absRoot) {
+  const dirs = []
+  const files = []
+
+  function recurse (dir) {
+    let entries
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true })
+    } catch (err) {
+      throw new Error(`Cannot read directory ${dir}: ${err.message}`)
+    }
+    const sorted = [...entries].sort((a, b) => a.name.localeCompare(b.name))
+    const subdirs = []
+    for (const entry of sorted) {
+      const full = path.join(dir, entry.name)
+      if (entry.isDirectory()) {
+        dirs.push(full)
+        subdirs.push(full)
+      } else if (entry.isFile()) {
+        files.push(full)
+      }
+    }
+    for (const sub of subdirs) recurse(sub)
+  }
+
+  recurse(absRoot)
+  return { dirs, files }
+}
+
+/**
+ * Parse argv for the upload-dir command.
+ * @param {string[]} argv
+ * @returns {{ localDir: string|null, remoteLocation: string|null, dryRun: boolean, authentication: string|null, workspaceId: string|null, apiUrl: string|null, help: boolean }}
+ */
+export function parseArgs (argv) {
+  const out = {
+    localDir: null,
+    remoteLocation: null,
+    dryRun: false,
+    authentication: null,
+    workspaceId: null,
+    apiUrl: null,
+    help: false,
+  }
+
+  const NEEDS_VALUE = new Set(['--authentication', '-a', '--workspace-id', '-w', '--api-url'])
+
+  let i = 0
+  while (i < argv.length) {
+    const arg = argv[i]
+
+    if (arg === '--help' || arg === '-h') { out.help = true; i++; continue }
+    if (arg === '--dry-run') { out.dryRun = true; i++; continue }
+
+    if (arg.startsWith('--') && arg.includes('=')) {
+      const eq = arg.indexOf('=')
+      const key = arg.slice(2, eq)
+      const val = arg.slice(eq + 1)
+      if (key === 'authentication') out.authentication = val
+      else if (key === 'workspace-id') out.workspaceId = val
+      else if (key === 'api-url') out.apiUrl = val
+      i++; continue
+    }
+
+    if (NEEDS_VALUE.has(arg)) {
+      const val = argv[i + 1]
+      if (arg === '--authentication' || arg === '-a') out.authentication = val
+      else if (arg === '--workspace-id' || arg === '-w') out.workspaceId = val
+      else if (arg === '--api-url') out.apiUrl = val
+      i += 2; continue
+    }
+
+    if (!arg.startsWith('-')) {
+      if (out.localDir === null) { out.localDir = arg; i++; continue }
+      if (out.remoteLocation === null) { out.remoteLocation = arg; i++; continue }
+    }
+
+    i++
+  }
+
+  return out
+}
+
+/**
+ * Normalise a remote location path: leading slash, no trailing slash.
+ * @param {string} loc
+ * @returns {string}
+ */
+function normaliseLoc (loc) {
+  let s = loc.replace(/\/+$/, '')
+  if (!s.startsWith('/')) s = '/' + s
+  return s
+}
+
+export async function handler (args) {
+  const parsed = parseArgs(args)
+
+  if (parsed.help) {
+    console.log(HELP)
+    return
+  }
+
+  if (!parsed.localDir || !parsed.remoteLocation) {
+    logError({ message: '[@ossy/cli] upload-dir: provide <localDir> and <remoteLocation>. Run `ossy upload-dir --help`.' })
+    process.exit(1)
+  }
+
+  const absRoot = path.resolve(parsed.localDir)
+  if (!fs.existsSync(absRoot) || !fs.statSync(absRoot).isDirectory()) {
+    logError({ message: `[@ossy/cli] upload-dir: not a directory: ${parsed.localDir}` })
+    process.exit(1)
+  }
+
+  const remoteBase = normaliseLoc(parsed.remoteLocation)
+
+  let dirs, files
+  try {
+    ;({ dirs, files } = walk(absRoot))
+  } catch (err) {
+    logError({ message: `[@ossy/cli] upload-dir: ${err.message}` })
+    process.exit(1)
+  }
+
+  const dryRun = parsed.dryRun
+  if (dryRun) {
+    console.log(`[dry-run] upload-dir ${absRoot} → ${remoteBase}`)
+    console.log(`[dry-run] ${dirs.length} director${dirs.length === 1 ? 'y' : 'ies'}, ${files.length} file${files.length === 1 ? '' : 's'}`)
+    for (const d of dirs) {
+      const rel = d.slice(absRoot.length)
+      const parent = normaliseLoc(remoteBase + path.dirname(rel))
+      const name = path.basename(d)
+      console.log(`[dry-run] mkdir  ${parent}/${name}`)
+    }
+    for (const f of files) {
+      const rel = f.slice(absRoot.length)
+      const remoteDir = normaliseLoc(remoteBase + path.dirname(rel))
+      console.log(`[dry-run] upload ${f} → ${remoteDir}`)
+    }
+    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,
+  })
+
+  const createDir = Sdk.ResourcesCreateDirectory
+  const uploadAction = Sdk.ResourcesUpload
+
+  let dirsMade = 0
+  let filesUploaded = 0
+  let errors = 0
+
+  // Create directories (breadth-first so parents always exist first)
+  for (const d of dirs) {
+    const rel = d.slice(absRoot.length)
+    const parent = normaliseLoc(remoteBase + path.dirname(rel))
+    const name = path.basename(d)
+    logInfo({ message: `[@ossy/cli] upload-dir: mkdir ${parent}/${name}` })
+    try {
+      await sdk.makeRequest(createDir)({ location: parent, name })
+      dirsMade++
+    } catch (err) {
+      // Treat "already exists" (HTTP 409 / 422 / resource conflict) as success
+      const status = err && err.status
+      if (status === 409 || status === 422) {
+        logInfo({ message: `[@ossy/cli] upload-dir: dir already exists, skipping: ${parent}/${name}` })
+        dirsMade++
+      } else {
+        const msg = err && err.message ? err.message : String(err)
+        logError({ message: `[@ossy/cli] upload-dir: mkdir failed for ${parent}/${name}: ${msg}` })
+        errors++
+      }
+    }
+  }
+
+  // Upload files
+  for (const f of files) {
+    const rel = f.slice(absRoot.length)
+    const remoteDir = normaliseLoc(remoteBase + path.dirname(rel))
+    logInfo({ message: `[@ossy/cli] upload-dir: upload ${f} → ${remoteDir}` })
+
+    let fileMeta
+    try {
+      fileMeta = prepareFileUpload(f)
+    } catch (err) {
+      logError({ message: `[@ossy/cli] upload-dir: 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) {
+      const msg = err && err.message ? err.message : String(err)
+      logError({ message: `[@ossy/cli] upload-dir: upload failed for ${f}: ${msg}` })
+      errors++
+      continue
+    }
+
+    const uploadUrl = result && result.content && result.content.uploadUrl
+    if (!uploadUrl) {
+      logError({ message: `[@ossy/cli] upload-dir: no uploadUrl in response for ${f}` })
+      errors++
+      continue
+    }
+
+    try {
+      await uploadFileToUrl(fileMeta, uploadUrl)
+      filesUploaded++
+    } catch (err) {
+      logError({ message: `[@ossy/cli] upload-dir: S3 PUT failed for ${f}: ${err.message}` })
+      errors++
+    }
+  }
+
+  const summary = `${dirsMade} director${dirsMade === 1 ? 'y' : 'ies'} created, ${filesUploaded} file${filesUploaded === 1 ? '' : 's'} uploaded`
+  if (errors > 0) {
+    logError({ message: `[@ossy/cli] upload-dir: done with ${errors} error${errors === 1 ? '' : 's'} — ${summary}` })
+    process.exit(1)
+  } else {
+    logInfo({ message: `[@ossy/cli] upload-dir: done — ${summary}` })
+  }
+}

package/src/workspace/cli.js

@@ -0,0 +1,84 @@
+import { logInfo, logError } from '../log.js'
+import {
+  readConfig,
+  writeConfig,
+  getAuth,
+  getApiUrl,
+  getWorkspaceId,
+} from '../state.js'
+
+function ensureAuth () {
+  const auth = getAuth()
+  if (!auth) {
+    logError({
+      message: '[@ossy/cli] Not logged in. Run `ossy auth login` first.',
+    })
+    process.exit(1)
+  }
+  return auth
+}
+
+function use (options) {
+  const id = options[0]
+  if (!id) {
+    logError({ message: '[@ossy/cli] workspace use: pass a workspace id.' })
+    process.exit(1)
+  }
+  writeConfig({ ...(readConfig() || {}), workspaceId: id })
+  logInfo({ message: `[@ossy/cli] Active workspace: ${id}` })
+}
+
+async function list () {
+  const auth = ensureAuth()
+  const apiUrl = getApiUrl()
+
+  let res
+  try {
+    res = await fetch(`${apiUrl}/workspaces`, {
+      headers: { Authorization: auth, 'Content-Type': 'application/json' },
+    })
+  } catch (error) {
+    logError({ message: `[@ossy/cli] workspace list: could not reach ${apiUrl}`, error })
+    process.exit(1)
+  }
+
+  if (!res.ok) {
+    logError({
+      message: `[@ossy/cli] workspace list: HTTP ${res.status} from ${apiUrl}/workspaces`,
+    })
+    process.exit(1)
+  }
+
+  const workspaces = await res.json().catch(() => null)
+  if (!Array.isArray(workspaces) || workspaces.length === 0) {
+    console.log('No workspaces found.')
+    return
+  }
+
+  const active = getWorkspaceId()
+  for (const w of workspaces) {
+    const marker = w.id === active ? '* ' : '  '
+    console.log(`${marker}${w.id}\t${w.name || ''}`)
+  }
+}
+
+function current () {
+  const id = getWorkspaceId()
+  if (!id) {
+    console.log('(no active workspace)')
+    return
+  }
+  console.log(id)
+}
+
+export async function handler (args) {
+  const [sub, ...rest] = args
+  if (sub === 'use') return use(rest)
+  if (sub === 'list') return await list()
+  if (sub === 'current') return current()
+  logError({
+    message:
+      '[@ossy/cli] workspace: unknown subcommand. Use: ossy workspace use <id> | list | current',
+  })
+  process.exit(1)
+}

package/src/publish/cli.js

@@ -1,180 +0,0 @@
-import { existsSync } from 'fs'
-import { spawn } from 'child_process'
-import arg from 'arg'
-import { logInfo, logError } from '../log.js'
-import { resolveAppConfigPath } from '../resolve-app-config-path.js'
-import {
-  readWebsiteConfigDeployFields,
-  resolvePlatformFromDeployments
-} from './resolve-config.js'
-import { maybeUploadResourceTemplatesAfterPublish } from './resource-templates-after-publish.js'
-import { maybeUploadSiteArtifactsAfterPublish } from './site-artifacts-after-publish.js'
-import { requireCmsAuthentication } from '../cms/upload-resource-templates.js'
-
-const DEPLOYMENT_TOOLS = '@ossy/deployment-tools'
-
-function runNpxDeploymentTools (deploymentArgs) {
-  const args = ['--yes', DEPLOYMENT_TOOLS, 'deployment', ...deploymentArgs]
-  logInfo({ message: `[@ossy/cli] publish: npx ${DEPLOYMENT_TOOLS} deployment ${deploymentArgs[0]} …` })
-  return new Promise((resolvePromise, reject) => {
-    const npx = process.platform === 'win32' ? 'npx.cmd' : 'npx'
-    const child = spawn(npx, args, { stdio: 'inherit' })
-    child.on('error', reject)
-    child.on('close', (code) => {
-      if (code === 0) resolvePromise()
-      else reject(new Error(`npx exited with code ${code}`))
-    })
-  })
-}
-
-/**
- * Publish container deployments: default = one site (`deployment deploy`);
- * `--all` = `deployment deploy-all` for the platform.
- *
- * Requires **`--authentication`** (Ossy API JWT) or **`OSSY_API_KEY`**. Container
- * deployments target **ECR** (`registry` in deployments JSON); the worker pulls
- * with **IAM** (`aws ecr get-login-password`). No registry password is sent on the queue.
- */
-export async function publish (options) {
-  const parsedArgs = arg({
-    '--authentication': String,
-    '-a': '--authentication',
-    '--domain': String,
-    '-d': '--domain',
-    '--platform': String,
-    '-p': '--platform',
-    '--config': String,
-    '-c': '--config',
-    '--platforms-path': String,
-    '-pp': '--platforms-path',
-    '--deployments-path': String,
-    '-dp': '--deployments-path',
-    '--all': Boolean,
-    '--skip-resource-templates': Boolean,
-    '--skip-site-artifacts': Boolean,
-    '--site-artifacts-build-dir': String,
-    '--api-url': String,
-  }, { argv: options })
-
-  const platformsPath = parsedArgs['--platforms-path']
-  const deploymentsPath = parsedArgs['--deployments-path']
-
-  const apiUrlForTemplates = parsedArgs['--api-url']
-
-  let apiToken
-  try {
-    apiToken = requireCmsAuthentication(
-      parsedArgs['--authentication'] || process.env.OSSY_API_KEY,
-      'publish'
-    )
-  } catch (e) {
-    logError({
-      message:
-        e?.message
-        || '[@ossy/cli] publish: pass --authentication (-a) or set OSSY_API_KEY (Ossy API JWT).',
-    })
-    process.exit(1)
-  }
-
-  if (!platformsPath || !deploymentsPath) {
-    logError({
-      message: '[@ossy/cli] publish: --platforms-path (-pp) and --deployments-path (-dp) are required.'
-    })
-    process.exit(1)
-  }
-
-  const configFlag = parsedArgs['--config']
-  let configPath = resolveAppConfigPath(configFlag)
-  if (configFlag) {
-    if (!configPath || !existsSync(configPath)) {
-      logError({ message: `[@ossy/cli] publish: --config file not found: ${configFlag}` })
-      process.exit(1)
-    }
-  }
-
-  const skipResourceTemplates = parsedArgs['--skip-resource-templates']
-  const skipSiteArtifacts = parsedArgs['--skip-site-artifacts']
-  const siteArtifactsBuildDir = parsedArgs['--site-artifacts-build-dir']
-
-  const fromConfig = configPath ? readWebsiteConfigDeployFields(configPath) : {}
-
-  if (parsedArgs['--all']) {
-    let targetPlatform = parsedArgs['--platform'] || fromConfig.platform
-    if (!targetPlatform) {
-      logError({
-        message: '[@ossy/cli] publish --all: pass --platform (-p) or set platform in src/config.js (or --config).'
-      })
-      process.exit(1)
-    }
-    logInfo({ message: `[@ossy/cli] publish --all: platform=${targetPlatform}` })
-    await runNpxDeploymentTools([
-      'deploy-all',
-      '-p', targetPlatform,
-      '--platforms-path', platformsPath,
-      '--deployments-path', deploymentsPath,
-    ])
-    if (!skipResourceTemplates && configPath) {
-      await maybeUploadResourceTemplatesAfterPublish({
-        configPath,
-        cmsToken: apiToken,
-        apiUrlFlag: apiUrlForTemplates,
-      })
-    }
-    if (!skipSiteArtifacts && configPath) {
-      await maybeUploadSiteArtifactsAfterPublish({
-        configPath,
-        cmsToken: apiToken,
-        apiUrlFlag: apiUrlForTemplates,
-        buildDir: siteArtifactsBuildDir,
-      })
-    }
-    return
-  }
-
-  let targetDomain = parsedArgs['--domain'] || fromConfig.domain
-  let targetPlatform = parsedArgs['--platform'] || fromConfig.platform
-
-  if (!targetPlatform && targetDomain && deploymentsPath) {
-    const resolved = resolvePlatformFromDeployments(deploymentsPath, targetDomain)
-    if (resolved && typeof resolved === 'object' && resolved.ambiguous) {
-      logError({
-        message: `[@ossy/cli] publish: domain "${targetDomain}" matches multiple platforms (${resolved.platforms.join(', ')}). Set platform in src/config.js or pass --platform (-p).`
-      })
-      process.exit(1)
-    }
-    targetPlatform = resolved
-  }
-
-  if (!targetDomain || !targetPlatform) {
-    logError({
-      message: '[@ossy/cli] publish: need --domain (-d) and --platform (-p), or src/config.js / --config with domain (and optional platform); platform can be inferred from deployments when domain is unique.'
-    })
-    process.exit(1)
-  }
-
-  logInfo({ message: `[@ossy/cli] publish: domain=${targetDomain} platform=${targetPlatform}` })
-
-  await runNpxDeploymentTools([
-    'deploy',
-    '-d', targetDomain,
-    '-p', targetPlatform,
-    '--platforms-path', platformsPath,
-    '--deployments-path', deploymentsPath,
-  ])
-
-  if (!skipResourceTemplates && configPath) {
-    await maybeUploadResourceTemplatesAfterPublish({
-      configPath,
-      cmsToken: apiToken,
-      apiUrlFlag: apiUrlForTemplates,
-    })
-  }
-  if (!skipSiteArtifacts && configPath) {
-    await maybeUploadSiteArtifactsAfterPublish({
-      configPath,
-      cmsToken: apiToken,
-      apiUrlFlag: apiUrlForTemplates,
-      buildDir: siteArtifactsBuildDir,
-    })
-  }
-}

package/src/publish/resolve-config.js

@@ -1,44 +0,0 @@
-import { readFileSync } from 'fs'
-import { resolve } from 'path'
-import { globSync } from 'glob'
-
-/**
- * Reads string `domain` / `platform` from a site `src/config.js` without executing it
- * (config is often ESM with package-only imports).
- *
- * @param {string} configPath
- * @returns {{ domain?: string, platform?: string }}
- */
-export function readWebsiteConfigDeployFields (configPath) {
-  const abs = resolve(configPath)
-  const source = readFileSync(abs, 'utf8')
-
-  const pick = (key) => {
-    const m = source.match(new RegExp(`${key}\\s*:\\s*['"]([^'"]+)['"]`))
-    return m ? m[1] : undefined
-  }
-
-  const domain = pick('domain')
-  const platform = pick('platform') || pick('targetDeploymentPlatform')
-
-  return { domain, platform }
-}
-
-/**
- * @param {string} deploymentsGlob
- * @param {string} domain
- * @returns {string | undefined | { ambiguous: true, platforms: string[] }}
- */
-export function resolvePlatformFromDeployments (deploymentsGlob, domain) {
-  const filePaths = globSync(deploymentsGlob, { ignore: 'node_modules/**' })
-  const deployments = filePaths.flatMap((p) => JSON.parse(readFileSync(p, 'utf8')))
-  const matches = deployments.filter((d) => d.domain === domain)
-  if (matches.length === 0) {
-    return undefined
-  }
-  const platforms = [...new Set(matches.map((d) => d.targetDeploymentPlatform))]
-  if (platforms.length > 1) {
-    return { ambiguous: true, platforms }
-  }
-  return platforms[0]
-}

package/src/publish/resource-templates-after-publish.js

@@ -1,75 +0,0 @@
-import { logInfo } from '../log.js'
-import { readPublishFieldsFromWebsiteConfig } from './load-website-config.js'
-import {
-  postResourceTemplates,
-  requireCmsAuthentication,
-  resolveApiBaseUrlForUpload,
-} from '../cms/upload-resource-templates.js'
-
-/**
- * After a successful deployment, sync `resourceTemplates` from app config to the workspace API.
- */
-export async function maybeUploadResourceTemplatesAfterPublish ({
-  configPath,
-  cmsToken,
-  apiUrlFlag,
-}) {
-  const config = readPublishFieldsFromWebsiteConfig(configPath)
-  const workspaceId = config.workspaceId
-  const resourceTemplates = config.resourceTemplates
-
-  if (!workspaceId) {
-    logInfo({
-      message:
-        '[@ossy/cli] publish: skipping resource template upload (no workspaceId in config)',
-    })
-    return
-  }
-  if (!Array.isArray(resourceTemplates) || resourceTemplates.length === 0) {
-    logInfo({
-      message:
-        '[@ossy/cli] publish: skipping resource template upload (resourceTemplates missing or empty)',
-    })
-    return
-  }
-
-  const apiBaseUrl = resolveApiBaseUrlForUpload({
-    flag: apiUrlFlag,
-    envVar: process.env.OSSY_API_URL,
-    configApiUrl: config?.apiUrl,
-  })
-  const uploadUrl = `${apiBaseUrl.replace(/\/$/, '')}/resource-templates`
-  const authToken = requireCmsAuthentication(
-    cmsToken,
-    'Resource template upload'
-  )
-
-  logInfo({
-    message: `[@ossy/cli] publish: uploading resource templates → POST ${uploadUrl}`,
-  })
-
-  const response = await postResourceTemplates({
-    apiBaseUrl,
-    token: authToken,
-    workspaceId,
-    resourceTemplates,
-  })
-
-  if (!response.ok) {
-    const text = await response.text().catch(() => '')
-    const hint404 =
-      response.status === 404
-        ? ` Wrong host or path: requested ${uploadUrl}. Confirm OSSY_API_URL / --api-url points at the Ossy API base including /api/v0.`
-        : ''
-    const hint401 =
-      response.status === 401
-        ? ' Use an Ossy API JWT with --authentication (or OSSY_API_KEY in CI), not a non-API deploy token.'
-        : ''
-    throw new Error(
-      `Resource template upload failed: HTTP ${response.status}${hint404}${hint401}${
-        text ? ` — ${text.slice(0, 200)}` : ''
-      }`
-    )
-  }
-  logInfo({ message: '[@ossy/cli] publish: resource templates uploaded' })
-}