@ossy/cli 0.16.1 → 0.16.4

package/README.md

@@ -9,8 +9,8 @@ Unified CLI for the Ossy platform: app dev/build and CMS workflows.
 | `init [dir]` | Scaffold a new Ossy app (default: current directory) |
 | `dev` | Start dev server with watch (uses `src/*.page.jsx` or `src/pages.jsx`, `src/config.js`) |
 | `build` | Production build |
-| `publish` | Queue a container deployment via `@ossy/deployment-tools` (see below) |
-| `cms upload` | Upload resource templates to your workspace |
+| `publish` | Queue a container deployment via `@ossy/deployment-tools`, then upload `resourceTemplates` and **site build artifacts** (S3 presign + CMS resource) when `workspaceId` is set (see below) |
+| `cms upload` | Upload resource templates only (same API as publish’s upload step) |
 | `cms validate` | Validate ossy config and resource templates |
 
 ## App: dev & build
@@ -39,6 +39,10 @@ npx @ossy/cli publish \
 - **`--config`** — Path to another `config.js` if not `./src/config.js`.
 - If `platform` is omitted but `domain` is set (from flags or config), it is inferred from `deployments.json` when that domain appears under exactly one `targetDeploymentPlatform`.
 - **`--all`** — Runs `deployment deploy-all` for the platform; requires `--platform` or `platform` in config.
+- **Resource templates** — After a successful deploy, the CLI loads `./src/config.js` (or `--config`). If it exports **`workspaceId`** and a non-empty **`resourceTemplates`** array, they are **POST**ed to **`{api}/resource-templates`** with the **`workspaceId`** header (same as the CMS). Skipped when **`--skip-resource-templates`** is set, or when `workspaceId` / `resourceTemplates` are missing.
+- **Site artifacts** — If **`workspaceId`** is set and **`build/`** exists next to `src/` (i.e. run **`npm run build`** first), the CLI calls **`/site-artifacts/presign-batch`**, **PUT**s each file to S3, then **`/site-artifacts/commit-batch`** so a **`@ossy/platform/site-artifact-batch`** resource is created in the CMS. Skipped with **`--skip-site-artifacts`**, when there is no **`build/`**, or when **`workspaceId`** is missing. Override the build output directory with **`--site-artifacts-build-dir`** (absolute or cwd-relative).
+- **`--cms-authentication`** — Optional token used only for CMS/API steps (templates + site artifacts); defaults to **`--authentication`** (deployment token).
+- **`--api-url`** — Optional API base for CMS calls (e.g. `https://api.ossy.se/api/v0`). Otherwise **`OSSY_API_URL`**, else an **absolute** `apiUrl` from config, else `https://api.ossy.se/api/v0`. Relative app `apiUrl` values (e.g. `/@ossy`) are ignored unless you pass **`--api-url`** or set **`OSSY_API_URL`**.
 
 Requires network access so `npx` can run `@ossy/deployment-tools`.
 
@@ -47,16 +51,20 @@ Requires network access so `npx` can run `@ossy/deployment-tools`.
 Upload resource templates to your workspace so they can be used in the UI.
 
 ```bash
-npx @ossy/cli cms upload --authentication <cms-api-token> --ossy-file ossy.json
+npx @ossy/cli cms upload --authentication <cms-api-token> --config src/config.js
+# optional: --api-url https://api.ossy.se/api/v0  (or set OSSY_API_URL)
 ```
 
+When **`--config`** is omitted, **`./src/config.js`** is used if it exists (same as **`publish`**).
+
 ### Config consistency
 
-- **App** (`dev`, `build`): `--config` → app config (`src/config.js` by default)
-- **CMS** (`cms upload`): `--ossy-file` → workspace config with `workspaceId` and `resourceTemplates`
+- **App** (`dev`, `build`), **CMS** (`cms upload` / `cms validate`), and **publish** all use **`--config`** (`-c`) for the app / workspace config file (`src/config.js` by default when present).
 
 ### Workflow example
 
+Prefer **`publish`** so deploy and template upload run together (see **Publish** above). For template-only updates, `cms upload` still works.
+
 ```yaml
 name: "[CMS] Upload resource templates"
 
@@ -76,7 +84,7 @@ jobs:
         run: |
           npx --yes @ossy/cli cms upload \
             --authentication ${{ secrets.CMS_API_TOKEN }} \
-            --ossy-file ossy.json
+            --config src/config.js
 ```
 
 ### cms validate
@@ -84,17 +92,18 @@ jobs:
 Validate an ossy config file before uploading:
 
 ```bash
-npx @ossy/cli cms validate --ossy-file ossy.json
+npx @ossy/cli cms validate --config src/config.js
 ```
 
-Defaults to `ossy.json` in the current directory when `--ossy-file` is omitted.
+When **`--config`** is omitted, **`./src/config.js`** is used if it exists.
 
 ### Arguments
 
 | Argument | Description | Required |
 |----------|-------------|----------|
 | --authentication, -a | Your CMS API token | Yes (upload only) |
-| --ossy-file | Path to file with `workspaceId` and `resourceTemplates` | Yes (upload), optional (validate) |
+| --config, -c | App config (`workspaceId`, `resourceTemplates`, …) | Optional if `./src/config.js` exists |
+| --api-url | API base URL for upload (`…/api/v0`) | No |
 
 ## init
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ossy/cli",
-  "version": "0.16.1",
+  "version": "0.16.4",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ossy-se/packages.git"
@@ -17,7 +17,7 @@
   "license": "MIT",
   "bin": "./src/index.js",
   "dependencies": {
-    "@ossy/app": "^0.15.1",
+    "@ossy/app": "^0.15.4",
     "arg": "^5.0.2",
     "glob": "^10.3.10"
   },
@@ -29,5 +29,5 @@
     "/src",
     "README.md"
   ],
-  "gitHead": "19917b325524994f304813ba9d81e52a79da544e"
+  "gitHead": "f9c6ce7e08475bc0c96cae92e1eff3404964e315"
 }

package/src/cms/cli.js

@@ -1,66 +1,79 @@
-import { resolve } from 'path'
 import { readFileSync, existsSync } from 'fs'
+import { pathToFileURL } from 'url'
 import arg from 'arg'
 import { logInfo, logError } from '../log.js'
-
-const Api = {
-  uploadResourceTemplates: (apiUrl, token, workspaceId, resourceTemplates) => {
-    const endpoint = `${apiUrl}/workspaces/${workspaceId}/resource-templates`
-    const fetchOptions = {
-      method: 'POST',
-      headers: { 'Authorization': token, 'Content-Type': 'application/json' },
-      body: JSON.stringify(resourceTemplates)
-    }
-    return fetch(endpoint, fetchOptions)
-  }
-}
+import { resolveAppConfigPath } from '../resolve-app-config-path.js'
+import {
+  postResourceTemplates,
+  resolveApiBaseUrlForUpload,
+} from './upload-resource-templates.js'
 
 const resolveConfigImport = (filePath) =>
   filePath.endsWith('json')
     ? Promise.resolve(JSON.parse(readFileSync(filePath, 'utf8')))
-    : import(filePath)
+    : import(pathToFileURL(filePath).href)
 
 const upload = (options) => {
   const parsedArgs = arg({
     '--authentication': String,
     '--a': '--authentication',
-    '--ossy-file': String,
+    '--config': String,
+    '-c': '--config',
+    '--api-url': String,
   }, { argv: options })
 
   const token = parsedArgs['--authentication']
-  const ossyFilePath = parsedArgs['--ossy-file']
+  const apiUrlFlag = parsedArgs['--api-url']
 
   if (!token) {
     logError({ message: '[@ossy/cli] No token provided. Use --authentication or -a' })
     process.exit(1)
   }
-  if (!ossyFilePath) {
-    logError({ message: '[@ossy/cli] No config file provided. Use --ossy-file' })
+
+  const filePath = resolveAppConfigPath(parsedArgs['--config'])
+  if (!filePath) {
+    logError({
+      message:
+        '[@ossy/cli] No config file. Pass --config (-c) or add src/config.js in the current directory.',
+    })
+    process.exit(1)
+  }
+  if (!existsSync(filePath)) {
+    logError({ message: `[@ossy/cli] Config not found: ${filePath}` })
     process.exit(1)
   }
 
   logInfo({ message: '[@ossy/cli] Reading config...' })
-  const filePath = resolve(ossyFilePath)
 
   return resolveConfigImport(filePath)
     .then((module) => {
       const config = module?.default ?? module
-      const apiUrl = config?.apiUrl || 'https://api.ossy.se/api/v0'
       const workspaceId = config?.workspaceId
       const resourceTemplates = config?.resourceTemplates
 
       if (!workspaceId) {
-        logError({ message: '[@ossy/cli] No workspaceId in ossy file' })
+        logError({ message: '[@ossy/cli] No workspaceId in config' })
         process.exit(1)
       }
       if (!resourceTemplates) {
-        logError({ message: '[@ossy/cli] No resourceTemplates in ossy file' })
+        logError({ message: '[@ossy/cli] No resourceTemplates in config' })
         process.exit(1)
       }
 
+      const apiBaseUrl = resolveApiBaseUrlForUpload({
+        flag: apiUrlFlag,
+        envVar: process.env.OSSY_API_URL,
+        configApiUrl: config?.apiUrl,
+      })
+
       logInfo({ message: '[@ossy/cli] Uploading resource templates...' })
 
-      return Api.uploadResourceTemplates(apiUrl, token, workspaceId, resourceTemplates)
+      return postResourceTemplates({
+        apiBaseUrl,
+        token,
+        workspaceId,
+        resourceTemplates,
+      })
         .then((response) => {
           if (!response.ok) throw new Error(`Upload failed: ${response.status}`)
           logInfo({ message: '[@ossy/cli] Done' })
@@ -78,14 +91,20 @@ const upload = (options) => {
 
 const validate = (options) => {
   const parsedArgs = arg({
-    '--ossy-file': String,
+    '--config': String,
+    '-c': '--config',
   }, { argv: options })
 
-  const ossyFilePath = parsedArgs['--ossy-file']
-  const filePath = ossyFilePath ? resolve(ossyFilePath) : resolve('ossy.json')
-
+  const filePath = resolveAppConfigPath(parsedArgs['--config'])
+  if (!filePath) {
+    logError({
+      message:
+        '[@ossy/cli] Config not found. Pass --config (-c) or add src/config.js in the current directory.',
+    })
+    process.exit(1)
+  }
   if (!existsSync(filePath)) {
-    logError({ message: `[@ossy/cli] File not found: ${filePath}. Use --ossy-file` })
+    logError({ message: `[@ossy/cli] Config not found: ${filePath}` })
     process.exit(1)
   }
 

package/src/cms/upload-resource-templates.js

@@ -0,0 +1,41 @@
+/**
+ * POST workspace-imported resource templates to the Ossy API.
+ * @param {{ apiBaseUrl: string, token: string, workspaceId: string, resourceTemplates: unknown[] }} opts
+ * @returns {Promise<Response>}
+ */
+export function postResourceTemplates ({
+  apiBaseUrl,
+  token,
+  workspaceId,
+  resourceTemplates,
+}) {
+  const base = apiBaseUrl.replace(/\/$/, '')
+  const url = `${base}/resource-templates`
+  return fetch(url, {
+    method: 'POST',
+    headers: {
+      Authorization: token,
+      'Content-Type': 'application/json',
+      workspaceId,
+    },
+    body: JSON.stringify(resourceTemplates),
+  })
+}
+
+/**
+ * Resolves API base URL for uploads (no trailing slash).
+ * Relative `apiUrl` in app config (e.g. `/@ossy`) is ignored; use flag or OSSY_API_URL.
+ */
+export function resolveApiBaseUrlForUpload ({ flag, envVar, configApiUrl }) {
+  if (flag && String(flag).trim()) {
+    return String(flag).replace(/\/$/, '')
+  }
+  if (envVar && String(envVar).trim()) {
+    return String(envVar).replace(/\/$/, '')
+  }
+  const raw = configApiUrl
+  if (typeof raw === 'string' && /^https?:\/\//i.test(raw.trim())) {
+    return raw.trim().replace(/\/$/, '')
+  }
+  return 'https://api.ossy.se/api/v0'
+}

package/src/index.js

@@ -7,7 +7,9 @@ import { publish } from './publish/cli.js'
 const [,, command, ...restArgs] = process.argv
 
 if (!command) {
-  console.error('[@ossy/cli] No command provided. Usage: ossy dev | build | publish | init | cms <subcommand>')
+  console.error(
+    '[@ossy/cli] No command provided. Usage: ossy dev | build [--worker] | publish | init | cms <subcommand>'
+  )
   process.exit(1)
 }
 

package/src/publish/cli.js

@@ -1,12 +1,14 @@
 import { existsSync } from 'fs'
-import { resolve as pathResolve } from 'path'
 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'
 
 const DEPLOYMENT_TOOLS = '@ossy/deployment-tools'
 
@@ -43,7 +45,12 @@ export async function publish (options) {
     '-pp': '--platforms-path',
     '--deployments-path': String,
     '-dp': '--deployments-path',
-    '--all': Boolean
+    '--all': Boolean,
+    '--skip-resource-templates': Boolean,
+    '--skip-site-artifacts': Boolean,
+    '--site-artifacts-build-dir': String,
+    '--api-url': String,
+    '--cms-authentication': String
   }, { argv: options })
 
   const username = parsedArgs['--username']
@@ -64,17 +71,22 @@ export async function publish (options) {
     process.exit(1)
   }
 
-  let configPath = parsedArgs['--config']
-  if (!configPath) {
-    const cwdConfig = pathResolve(process.cwd(), 'src/config.js')
-    if (existsSync(cwdConfig)) {
-      configPath = cwdConfig
+  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)
     }
-  } else if (!existsSync(pathResolve(configPath))) {
-    logError({ message: `[@ossy/cli] publish: --config file not found: ${configPath}` })
-    process.exit(1)
   }
 
+  const skipResourceTemplates = parsedArgs['--skip-resource-templates']
+  const skipSiteArtifacts = parsedArgs['--skip-site-artifacts']
+  const siteArtifactsBuildDir = parsedArgs['--site-artifacts-build-dir']
+  const apiUrlForTemplates = parsedArgs['--api-url']
+  const cmsAuthentication =
+    parsedArgs['--cms-authentication'] || authentication
+
   const fromConfig = configPath ? readWebsiteConfigDeployFields(configPath) : {}
 
   if (parsedArgs['--all']) {
@@ -94,6 +106,21 @@ export async function publish (options) {
       '-pp', platformsPath,
       '-dp', deploymentsPath
     ])
+    if (!skipResourceTemplates && configPath) {
+      await maybeUploadResourceTemplatesAfterPublish({
+        configPath,
+        cmsToken: cmsAuthentication,
+        apiUrlFlag: apiUrlForTemplates,
+      })
+    }
+    if (!skipSiteArtifacts && configPath) {
+      await maybeUploadSiteArtifactsAfterPublish({
+        configPath,
+        cmsToken: cmsAuthentication,
+        apiUrlFlag: apiUrlForTemplates,
+        buildDir: siteArtifactsBuildDir,
+      })
+    }
     return
   }
 
@@ -129,4 +156,20 @@ export async function publish (options) {
     '-pp', platformsPath,
     '-dp', deploymentsPath
   ])
+
+  if (!skipResourceTemplates && configPath) {
+    await maybeUploadResourceTemplatesAfterPublish({
+      configPath,
+      cmsToken: cmsAuthentication,
+      apiUrlFlag: apiUrlForTemplates,
+    })
+  }
+  if (!skipSiteArtifacts && configPath) {
+    await maybeUploadSiteArtifactsAfterPublish({
+      configPath,
+      cmsToken: cmsAuthentication,
+      apiUrlFlag: apiUrlForTemplates,
+      buildDir: siteArtifactsBuildDir,
+    })
+  }
 }

package/src/publish/load-website-config.js

@@ -0,0 +1,12 @@
+import { resolve } from 'path'
+import { pathToFileURL } from 'url'
+
+/**
+ * Loads app `config.js` (ESM) for publish-side steps (e.g. resource template upload).
+ * @param {string} configPath Absolute or cwd-relative path to config file
+ */
+export async function loadWebsiteConfig (configPath) {
+  const abs = resolve(configPath)
+  const mod = await import(pathToFileURL(abs).href)
+  return mod.default ?? mod
+}

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

@@ -0,0 +1,59 @@
+import { logInfo } from '../log.js'
+import { loadWebsiteConfig } from './load-website-config.js'
+import {
+  postResourceTemplates,
+  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 = await loadWebsiteConfig(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,
+  })
+
+  logInfo({ message: '[@ossy/cli] publish: uploading resource templates…' })
+
+  const response = await postResourceTemplates({
+    apiBaseUrl,
+    token: cmsToken,
+    workspaceId,
+    resourceTemplates,
+  })
+
+  if (!response.ok) {
+    const text = await response.text().catch(() => '')
+    throw new Error(
+      `Resource template upload failed: HTTP ${response.status}${
+        text ? ` — ${text.slice(0, 200)}` : ''
+      }`
+    )
+  }
+  logInfo({ message: '[@ossy/cli] publish: resource templates uploaded' })
+}

package/src/publish/site-artifacts-after-publish.js

@@ -0,0 +1,201 @@
+import { readdir, stat, readFile } from 'fs/promises'
+import { existsSync } from 'fs'
+import path from 'path'
+import { logInfo } from '../log.js'
+import { loadWebsiteConfig } from './load-website-config.js'
+import { resolveApiBaseUrlForUpload } from '../cms/upload-resource-templates.js'
+
+const MAX_FILES = 200
+
+/** @type {Record<string, string>} */
+const MIME_BY_EXT = {
+  '.js': 'application/javascript',
+  '.mjs': 'application/javascript',
+  '.cjs': 'application/javascript',
+  '.css': 'text/css',
+  '.html': 'text/html',
+  '.htm': 'text/html',
+  '.json': 'application/json',
+  '.map': 'application/json',
+  '.svg': 'image/svg+xml',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.webp': 'image/webp',
+  '.ico': 'image/x-icon',
+  '.woff': 'font/woff',
+  '.woff2': 'font/woff2',
+  '.ttf': 'font/ttf',
+  '.txt': 'text/plain',
+  '.xml': 'application/xml',
+  '.webmanifest': 'application/manifest+json',
+}
+
+export function guessContentType (filePath) {
+  const ext = path.extname(filePath).toLowerCase()
+  return MIME_BY_EXT[ext] || 'application/octet-stream'
+}
+
+/**
+ * @param {string} buildDir absolute path to `build/` output
+ * @returns {Promise<{ absPath: string, relativePath: string, size: number }[]>}
+ */
+export async function collectBuildFiles (buildDir) {
+  const out = []
+
+  async function walk (dir, rel = '') {
+    const entries = await readdir(dir, { withFileTypes: true })
+    for (const e of entries) {
+      const abs = path.join(dir, e.name)
+      const relPath = rel ? `${rel}/${e.name}` : e.name
+      if (e.isDirectory()) {
+        await walk(abs, relPath)
+      } else {
+        const st = await stat(abs)
+        out.push({
+          absPath: abs,
+          relativePath: relPath.split(path.sep).join('/'),
+          size: st.size,
+        })
+      }
+    }
+  }
+
+  await walk(buildDir)
+  return out
+}
+
+function workspaceHeaders (token, workspaceId) {
+  return {
+    Authorization: token,
+    'Content-Type': 'application/json',
+    workspaceId,
+  }
+}
+
+/**
+ * After deploy: upload `build/` to S3 via presigned URLs and commit a CMS resource (`@ossy/platform/site-artifact-batch`).
+ */
+export async function maybeUploadSiteArtifactsAfterPublish ({
+  configPath,
+  cmsToken,
+  apiUrlFlag,
+  buildDir: buildDirOpt,
+}) {
+  const config = await loadWebsiteConfig(configPath)
+  const workspaceId = config?.workspaceId
+
+  if (!workspaceId) {
+    logInfo({
+      message:
+        '[@ossy/cli] publish: skipping site artifacts (no workspaceId in config)',
+    })
+    return
+  }
+
+  const packageRoot = path.join(path.dirname(configPath), '..')
+  const buildDir = buildDirOpt
+    ? path.resolve(buildDirOpt)
+    : path.join(packageRoot, 'build')
+
+  if (!existsSync(buildDir)) {
+    logInfo({
+      message: `[@ossy/cli] publish: skipping site artifacts (no build at ${buildDir}; run npm run build first)`,
+    })
+    return
+  }
+
+  const apiBaseUrl = resolveApiBaseUrlForUpload({
+    flag: apiUrlFlag,
+    envVar: process.env.OSSY_API_URL,
+    configApiUrl: config?.apiUrl,
+  })
+
+  const files = await collectBuildFiles(buildDir)
+  if (files.length === 0) {
+    logInfo({ message: '[@ossy/cli] publish: skipping site artifacts (build directory is empty)' })
+    return
+  }
+  if (files.length > MAX_FILES) {
+    throw new Error(
+      `[@ossy/cli] publish: site artifact upload supports at most ${MAX_FILES} files; build has ${files.length}`
+    )
+  }
+
+  logInfo({ message: `[@ossy/cli] publish: uploading ${files.length} site artifact file(s) to CMS…` })
+
+  const presignRes = await fetch(`${apiBaseUrl}/site-artifacts/presign-batch`, {
+    method: 'POST',
+    headers: workspaceHeaders(cmsToken, workspaceId),
+    body: JSON.stringify({
+      files: files.map((f) => ({
+        path: f.relativePath,
+        contentType: guessContentType(f.relativePath),
+        contentLength: f.size,
+      })),
+    }),
+  })
+
+  if (!presignRes.ok) {
+    const text = await presignRes.text().catch(() => '')
+    throw new Error(
+      `Site artifact presign failed: HTTP ${presignRes.status}${text ? ` — ${text.slice(0, 300)}` : ''}`
+    )
+  }
+
+  /** @type {{ batchId: string, files: { path: string, key: string, uploadUrl: string, contentType: string, contentLength: number }[] }} */
+  const presignJson = await presignRes.json()
+  const { batchId, files: uploadSlots } = presignJson
+
+  if (!batchId || !Array.isArray(uploadSlots) || uploadSlots.length !== files.length) {
+    throw new Error('[@ossy/cli] publish: invalid presign-batch response')
+  }
+
+  const byPath = new Map(uploadSlots.map((s) => [s.path, s]))
+
+  for (const local of files) {
+    const slot = byPath.get(local.relativePath)
+    if (!slot?.uploadUrl) {
+      throw new Error(`[@ossy/cli] publish: presign response missing entry for ${local.relativePath}`)
+    }
+    const body = await readFile(local.absPath)
+    if (body.length !== local.size) {
+      throw new Error(`[@ossy/cli] publish: file size mismatch for ${local.relativePath}`)
+    }
+    const putRes = await fetch(slot.uploadUrl, {
+      method: 'PUT',
+      headers: {
+        'Content-Type': slot.contentType,
+        'Content-Length': String(slot.contentLength),
+      },
+      body,
+    })
+    if (!putRes.ok) {
+      const t = await putRes.text().catch(() => '')
+      throw new Error(
+        `S3 PUT failed for ${local.relativePath}: HTTP ${putRes.status}${t ? ` — ${t.slice(0, 200)}` : ''}`
+      )
+    }
+  }
+
+
+  const commitRes = await fetch(`${apiBaseUrl}/site-artifacts/commit-batch`, {
+    method: 'POST',
+    headers: workspaceHeaders(cmsToken, workspaceId),
+    body: JSON.stringify({
+      batchId,
+      paths: files.map((f) => f.relativePath),
+      name: batchId,
+    }),
+  })
+
+  if (!commitRes.ok) {
+    const text = await commitRes.text().catch(() => '')
+    throw new Error(
+      `Site artifact commit failed: HTTP ${commitRes.status}${text ? ` — ${text.slice(0, 300)}` : ''}`
+    )
+  }
+
+  logInfo({ message: '[@ossy/cli] publish: site artifacts uploaded and CMS resource created' })
+}

package/src/resolve-app-config-path.js

@@ -0,0 +1,15 @@
+import { resolve } from 'path'
+import { existsSync } from 'fs'
+
+/**
+ * Resolves app config path: explicit `--config` or `./src/config.js` when it exists (cwd-relative).
+ * @param {string | undefined} configFlag
+ * @returns {string | null} Absolute path, or null when no default exists and flag omitted.
+ */
+export function resolveAppConfigPath (configFlag) {
+  if (configFlag) {
+    return resolve(configFlag)
+  }
+  const fallback = resolve(process.cwd(), 'src/config.js')
+  return existsSync(fallback) ? fallback : null
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 Ossy
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.