@ossy/cli 1.16.11 → 1.17.4

package/src/file.js

@@ -41,6 +41,32 @@ export function guessContentType (filePath) {
   return MIME_BY_EXT[ext] || 'application/octet-stream'
 }
 
+/**
+ * PUT file bytes to a presigned S3 upload URL.
+ * Throws on network error or non-2xx response.
+ * @param {{ absPath: string, size: number, type: string }} fileMeta
+ * @param {string} uploadUrl
+ * @returns {Promise<void>}
+ */
+export async function uploadFileToUrl (fileMeta, uploadUrl) {
+  const { readFile } = await import('node:fs/promises')
+  const body = await readFile(fileMeta.absPath)
+  const res = await fetch(uploadUrl, {
+    method: 'PUT',
+    headers: {
+      'Content-Type': fileMeta.type,
+      'Content-Length': String(fileMeta.size),
+    },
+    body,
+  })
+  if (!res.ok) {
+    const t = await res.text().catch(() => '')
+    throw new Error(
+      `S3 PUT failed: HTTP ${res.status}${t ? ' — ' + t.slice(0, 200) : ''}`
+    )
+  }
+}
+
 /**
  * Stat a local file and derive metadata for an upload payload.
  * Throws if the path doesn't exist or isn't a regular file.

package/src/index.js

@@ -2,13 +2,11 @@
 import fs from 'node:fs'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
-import { build } from '@ossy/app'
 import * as Auth from './auth/cli.js'
 import * as Call from './call/cli.js'
-import * as Cms from './cms/cli.js'
-import * as Init from './init/cli.js'
-import { publish } from './publish/cli.js'
+import * as App from './app/cli.js'
 import * as Registry from './registry/cli.js'
+import * as UploadDir from './upload-dir/cli.js'
 import * as Workspace from './workspace/cli.js'
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
@@ -25,20 +23,15 @@ Usage:
 Local utilities:
   auth <subcommand>       Sign in / out and check status: login | logout | status
   workspace <subcommand>  Manage active workspace: use | list | current
-  init [dir]              Scaffold a new Ossy app
-  build                   Production build of the app in the current directory
-  cms validate            Validate src/config.js (workspaceId + resourceTemplates)
+  app <subcommand>        App commands: init | build | upload | validate | publish
 
 Action dispatcher (any Ossy SDK action, no per-action wiring needed):
   call <action.id>        Run \`ossy call --help\` for the full catalog
 
 Workflows (wrap one or more actions with extra ergonomics):
-  cms upload              Upload resource templates from src/config.js
-                          (wraps workspaces.import-resource-templates)
+  upload-dir <dir> <loc>  Recursively upload a local directory to the CMS
   registry <subcommand>   ecr-push-credentials (wraps registry.ecr-push-credentials,
                           adds --format github-actions and password masking)
-  publish                 Deploy via @ossy/deployment-tools, then upload
-                          resource templates and site build artifacts
 
 Options:
   -h, --help              Show this help, or for a command: ossy <command> --help
@@ -62,48 +55,42 @@ Options (login):
     list       List workspaces the current user can access
     current    Print the active workspace id
 `,
-  init: `ossy init [dir]
-  Scaffold a new Ossy app in [dir] (defaults to current directory).
-  Creates src/home.page.jsx, src/config.js, and package.json (if missing).
-`,
-  build: `ossy build
-  Run the production build for the app in the current directory.
-  See the @ossy/app README for build options.
-`,
-  publish: `ossy publish [options]
-  Multi-step workflow: deploy via @ossy/deployment-tools (temporary), then
-  optionally upload resource templates and site build artifacts. The deploy
-  step is intended to go away once the platform reacts to artifact events;
-  the CMS upload steps are equivalent to:
-    workspaces.import-resource-templates  (resource templates)
-    /site-artifacts/presign-batch + /commit-batch  (site artifacts)
-
-Options:
-  -a, --authentication        Ossy API JWT (or set OSSY_API_KEY, or run \`ossy auth login\`)
-  -d, --domain                Site domain
-  -p, --platform              Target deployment platform
-  -c, --config                Path to src/config.js
-  --platforms-path            Path to platforms.json
-  --deployments-path          Glob for deployments JSON files
-  --all                       Deploy all sites for the platform
-  --skip-resource-templates   Skip post-deploy resource-template upload
-  --skip-site-artifacts       Skip post-deploy site-artifact upload
-  --site-artifacts-build-dir  Override the site build directory
-  --api-url                   API base URL for CMS calls
-`,
-  cms: `ossy cms <subcommand>
+  app: `ossy app <subcommand>
   Subcommands:
+    init      Scaffold a new Ossy app (default dir: current directory)
+    build     Production build of the app in the current directory
     upload    Upload resource templates from src/config.js to the workspace
               (wraps the SDK action workspaces.import-resource-templates)
     validate  Validate ossy app config and resource templates locally
+    publish   Upload resource templates and build/ to the CMS
+              (resource templates + build files to /sites/{domain})
 
 Options (upload):
   -a, --authentication  Ossy API JWT (or set OSSY_API_KEY, or run \`ossy auth login\`)
   -c, --config          Path to src/config.js
-  --api-url             API base URL for CMS calls
+  --api-url             API base URL for API calls
 
 Options (validate):
   -c, --config          Path to src/config.js
+
+Options (publish):
+  -a, --authentication      Ossy API JWT (or set OSSY_API_KEY, or run \`ossy auth login\`)
+  -c, --config              Path to src/config.js
+  --build-dir               Override build directory (default: <package>/build)
+  --build-dest              Override remote CMS location (default: /sites/{domain})
+  --skip-resource-templates Skip resource template upload
+  --api-url                 API base URL for API calls
+`,
+  'upload-dir': `ossy upload-dir <localDir> <remoteLocation> [options]
+  Recursively mirror a local directory into the Ossy CMS.
+  Creates parent directories first, then uploads every file.
+  Per-item errors are logged and skipped; exit code is non-zero if any failed.
+
+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
 `,
   registry: `ossy registry <subcommand>
   Subcommands:
@@ -151,24 +138,16 @@ const run = async () => {
     await Call.handler(restArgs)
     return
   }
-  if (command === 'registry') {
-    await Registry.handler(restArgs)
-    return
-  }
-  if (command === 'cms') {
-    Cms.handler(restArgs)
+  if (command === 'upload-dir') {
+    await UploadDir.handler(restArgs)
     return
   }
-  if (command === 'init') {
-    Init.init(restArgs)
-    return
-  }
-  if (command === 'publish') {
-    await publish(restArgs)
+  if (command === 'registry') {
+    await Registry.handler(restArgs)
     return
   }
-  if (command === 'build') {
-    await build(restArgs)
+  if (command === 'app') {
+    await App.handler(restArgs)
     return
   }
   console.error(`[@ossy/cli] Unknown command: ${command}`)

package/src/registry/ecr-push-credentials.js

@@ -1,6 +1,6 @@
 import arg from 'arg'
 import { appendFileSync } from 'fs'
-import { requireCmsAuthentication } from '../cms/upload-resource-templates.js'
+import { requireAppAuthentication } from '../app/upload-resource-templates.js'
 import { getAuth, getWorkspaceId } from '../state.js'
 
 const DEFAULT_API_URL = 'https://api.ossy.se/api/v0'
@@ -25,7 +25,7 @@ export async function ecrPushCredentials (options) {
 
   let token
   try {
-    token = requireCmsAuthentication(
+    token = requireAppAuthentication(
       getAuth({ flag: parsed['--authentication'] }),
       'registry ecr-push-credentials'
     )

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/publish/cli.js

@@ -1,181 +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'
-import { getAuth } from '../state.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(
-      getAuth({ flag: parsedArgs['--authentication'] }),
-      'publish'
-    )
-  } catch (e) {
-    logError({
-      message:
-        e?.message
-        || '[@ossy/cli] publish: pass --authentication (-a), set OSSY_API_KEY, or run `ossy auth login`.',
-    })
-    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]
-}