@ossy/cli 1.16.10 → 1.17.3

package/src/file.js

@@ -0,0 +1,99 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+/** @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',
+  '.pdf': 'application/pdf',
+  '.mp4': 'video/mp4',
+  '.webm': 'video/webm',
+  '.mp3': 'audio/mpeg',
+  '.wav': 'audio/wav',
+}
+
+/**
+ * Best-effort MIME type from extension. Falls back to `application/octet-stream`.
+ * @param {string} filePath
+ * @returns {string}
+ */
+export function guessContentType (filePath) {
+  const ext = path.extname(filePath).toLowerCase()
+  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.
+ * @param {string} filePath absolute or cwd-relative
+ * @returns {{ absPath: string, name: string, size: number, type: string }}
+ */
+export function prepareFileUpload (filePath) {
+  if (!filePath || typeof filePath !== 'string') {
+    throw new Error('--file: missing path')
+  }
+  const absPath = path.resolve(filePath)
+  let stat
+  try {
+    stat = fs.statSync(absPath)
+  } catch (err) {
+    if (err && err.code === 'ENOENT') {
+      throw new Error(`--file: not found: ${filePath}`)
+    }
+    throw new Error(`--file: cannot stat ${filePath}: ${err.message || err}`)
+  }
+  if (!stat.isFile()) {
+    throw new Error(`--file: not a regular file: ${filePath}`)
+  }
+  return {
+    absPath,
+    name: path.basename(absPath),
+    size: stat.size,
+    type: guessContentType(absPath),
+  }
+}

package/src/index.js

@@ -2,11 +2,12 @@
 import fs from 'node:fs'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
-import { build } from '@ossy/app'
-import * as Cms from './cms/cli.js'
-import * as Init from './init/cli.js'
-import { publish } from './publish/cli.js'
+import * as Auth from './auth/cli.js'
+import * as Call from './call/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))
 const pkg = JSON.parse(
@@ -19,12 +20,18 @@ Command line tool for the Ossy platform.
 Usage:
   ossy <command> [options]
 
-Commands:
-  init [dir]              Scaffold a new Ossy app
-  build                   Production build of the app in the current directory
-  publish                 Deploy a site and upload templates / site artifacts
-  cms <subcommand>        Resource template workflows: upload | validate
-  registry <subcommand>   Container registry helpers: ecr-push-credentials
+Local utilities:
+  auth <subcommand>       Sign in / out and check status: login | logout | status
+  workspace <subcommand>  Manage active workspace: use | list | current
+  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):
+  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)
 
 Options:
   -h, --help              Show this help, or for a command: ossy <command> --help
@@ -32,51 +39,68 @@ Options:
 `
 
 const SUBCOMMAND_HELP = {
-  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]
-  Deploy via @ossy/deployment-tools, then optionally upload resource templates
-  and site artifacts.
+  auth: `ossy auth <subcommand>
+  Subcommands:
+    login    Save an Ossy API token under ~/.config/ossy/credentials.json
+    logout   Delete the saved token
+    status   Print logged-in user, active workspace, and config paths
 
-Options:
-  -a, --authentication        Ossy API JWT (or set OSSY_API_KEY)
-  -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
+Options (login):
+  -t, --token   Ossy API JWT (otherwise prompts in a TTY)
+  --api-url     API base URL (default: https://api.ossy.se/api/v0)
+`,
+  workspace: `ossy workspace <subcommand>
+  Subcommands:
+    use <id>   Set the active workspace (saved to ~/.config/ossy/config.json)
+    list       List workspaces the current user can access
+    current    Print the active workspace id
 `,
-  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)
+  -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:
     ecr-push-credentials  Fetch a short-lived ECR password for docker login
+                          (wraps the SDK action registry.ecr-push-credentials;
+                          adds --format github-actions and password masking)
 
 Options:
-  -a, --authentication  Ossy API JWT (or set OSSY_API_KEY)
-  --workspace-id        Workspace id
+  -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\`)
   --format              json | github-actions
 `,
 }
@@ -102,24 +126,28 @@ if (restArgs.some(isHelpFlag) && SUBCOMMAND_HELP[command]) {
 }
 
 const run = async () => {
-  if (command === 'registry') {
-    await Registry.handler(restArgs)
+  if (command === 'auth') {
+    await Auth.handler(restArgs)
     return
   }
-  if (command === 'cms') {
-    Cms.handler(restArgs)
+  if (command === 'workspace') {
+    await Workspace.handler(restArgs)
     return
   }
-  if (command === 'init') {
-    Init.init(restArgs)
+  if (command === 'call') {
+    await Call.handler(restArgs)
     return
   }
-  if (command === 'publish') {
-    await publish(restArgs)
+  if (command === 'upload-dir') {
+    await UploadDir.handler(restArgs)
+    return
+  }
+  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,7 @@
 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'
 
@@ -24,18 +25,18 @@ export async function ecrPushCredentials (options) {
 
   let token
   try {
-    token = requireCmsAuthentication(
-      parsed['--authentication'] || process.env.OSSY_API_KEY,
+    token = requireAppAuthentication(
+      getAuth({ flag: parsed['--authentication'] }),
       'registry ecr-push-credentials'
     )
   } catch (e) {
-    console.error(e?.message || '[@ossy/cli] registry ecr-push-credentials: need --authentication (-a) or OSSY_API_KEY')
+    console.error(e?.message || '[@ossy/cli] registry ecr-push-credentials: need --authentication (-a), OSSY_API_KEY, or `ossy auth login`')
     process.exit(1)
   }
 
-  const workspaceId = parsed['--workspace-id'] || process.env.OSSY_WORKSPACE_ID || ''
-  if (!workspaceId.trim()) {
-    console.error('[@ossy/cli] registry ecr-push-credentials: pass --workspace-id (-w) or set OSSY_WORKSPACE_ID')
+  const workspaceId = getWorkspaceId({ flag: parsed['--workspace-id'] })
+  if (!workspaceId) {
+    console.error('[@ossy/cli] registry ecr-push-credentials: pass --workspace-id (-w), set OSSY_WORKSPACE_ID, or run `ossy workspace use <id>`')
     process.exit(1)
   }
 
@@ -46,7 +47,7 @@ export async function ecrPushCredentials (options) {
     method: 'POST',
     headers: {
       authorization: token,
-      workspaceId: workspaceId.trim(),
+      workspaceId,
       'content-type': 'application/json',
     },
     body: '{}',

package/src/state.js

@@ -0,0 +1,115 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+
+const DEFAULT_API_URL = 'https://api.ossy.se/api/v0'
+
+function configDir () {
+  const xdg = process.env.XDG_CONFIG_HOME
+  if (xdg && xdg.trim()) return path.join(xdg.trim(), 'ossy')
+  return path.join(os.homedir(), '.config', 'ossy')
+}
+
+function ensureDir () {
+  const dir = configDir()
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 })
+  return dir
+}
+
+function credentialsPath () { return path.join(configDir(), 'credentials.json') }
+function configPath () { return path.join(configDir(), 'config.json') }
+
+/** @returns {{ apiUrl?: string, token?: string } | null} */
+export function readCredentials () {
+  try {
+    return JSON.parse(fs.readFileSync(credentialsPath(), 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+/** @param {{ apiUrl?: string, token: string }} creds */
+export function writeCredentials (creds) {
+  ensureDir()
+  fs.writeFileSync(credentialsPath(), JSON.stringify(creds, null, 2), { mode: 0o600 })
+}
+
+export function deleteCredentials () {
+  try { fs.unlinkSync(credentialsPath()) } catch { /* not logged in */ }
+}
+
+/** @returns {{ workspaceId?: string } | null} */
+export function readConfig () {
+  try {
+    return JSON.parse(fs.readFileSync(configPath(), 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+/** @param {{ workspaceId?: string }} cfg */
+export function writeConfig (cfg) {
+  ensureDir()
+  fs.writeFileSync(configPath(), JSON.stringify(cfg, null, 2))
+}
+
+function stripBearer (token) {
+  return String(token ?? '').trim().replace(/^Bearer\s+/i, '').trim()
+}
+
+/**
+ * Resolve the Ossy API JWT used for authenticated requests.
+ * Order: explicit flag > OSSY_API_KEY env > saved credentials.
+ * @param {{ flag?: string }} [opts]
+ * @returns {string | null}
+ */
+export function getAuth ({ flag } = {}) {
+  const fromFlag = stripBearer(flag)
+  if (fromFlag) return fromFlag
+  const fromEnv = stripBearer(process.env.OSSY_API_KEY)
+  if (fromEnv) return fromEnv
+  const fromFile = stripBearer(readCredentials()?.token)
+  if (fromFile) return fromFile
+  return null
+}
+
+/**
+ * Order: explicit absolute flag > OSSY_API_URL env > saved credentials > default.
+ * Relative paths in the flag are ignored (matches existing publish behavior).
+ * @param {{ flag?: string }} [opts]
+ * @returns {string}
+ */
+export function getApiUrl ({ flag } = {}) {
+  if (flag && /^https?:\/\//i.test(String(flag).trim())) {
+    return String(flag).trim().replace(/\/$/, '')
+  }
+  const fromEnv = String(process.env.OSSY_API_URL ?? '').trim()
+  if (fromEnv) return fromEnv.replace(/\/$/, '')
+  const fromFile = String(readCredentials()?.apiUrl ?? '').trim()
+  if (/^https?:\/\//i.test(fromFile)) return fromFile.replace(/\/$/, '')
+  return DEFAULT_API_URL
+}
+
+/**
+ * Order: explicit flag > OSSY_WORKSPACE_ID env > saved active workspace.
+ * Project-scoped commands (publish/cms) keep reading from src/config.js separately.
+ * @param {{ flag?: string }} [opts]
+ * @returns {string | null}
+ */
+export function getWorkspaceId ({ flag } = {}) {
+  const fromFlag = String(flag ?? '').trim()
+  if (fromFlag) return fromFlag
+  const fromEnv = String(process.env.OSSY_WORKSPACE_ID ?? '').trim()
+  if (fromEnv) return fromEnv
+  const fromFile = String(readConfig()?.workspaceId ?? '').trim()
+  if (fromFile) return fromFile
+  return null
+}
+
+export function describeStatePaths () {
+  return {
+    dir: configDir(),
+    credentials: credentialsPath(),
+    config: configPath(),
+  }
+}