uniweb 0.8.14 → 0.8.16

package/src/commands/deploy.js

@@ -0,0 +1,272 @@
+/**
+ * Deploy Command
+ *
+ * Deploys a built site to Uniweb hosting.
+ *
+ * Usage:
+ *   uniweb deploy                          # Deploy to Uniweb hosting
+ *   uniweb deploy --local                  # Deploy to local server (no auth)
+ *   uniweb deploy --registry <url>         # Deploy to a specific server URL
+ *   uniweb deploy --dry-run                # Show what would be deployed
+ *   uniweb deploy --prod                   # Deploy to production (future)
+ */
+
+import { existsSync } from 'node:fs'
+import { readFile, readdir } from 'node:fs/promises'
+import { resolve, join, basename, relative } from 'node:path'
+import { execSync } from 'node:child_process'
+
+import { ensureAuth } from '../utils/auth.js'
+import { findWorkspaceRoot, findSites, findFoundations, classifyPackage, promptSelect } from '../utils/workspace.js'
+import { isNonInteractive, getCliPrefix } from '../utils/interactive.js'
+
+// Colors for terminal output
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  dim: '\x1b[2m',
+  cyan: '\x1b[36m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m',
+}
+
+function success(message) {
+  console.log(`${colors.green}✓${colors.reset} ${message}`)
+}
+
+function error(message) {
+  console.error(`${colors.red}✗${colors.reset} ${message}`)
+}
+
+function info(message) {
+  console.log(`${colors.cyan}→${colors.reset} ${message}`)
+}
+
+/**
+ * Resolve the site directory to deploy.
+ *
+ * Priority:
+ * 1. In a site directory → use it
+ * 2. At workspace root, one site → use it
+ * 3. At workspace root, multiple → prompt (or error if non-interactive)
+ * 4. No site → educational error with alternatives
+ *
+ * @param {string[]} args
+ * @returns {Promise<string>} Absolute path to the site directory
+ */
+async function resolveSiteDir(args) {
+  const cwd = process.cwd()
+  const prefix = getCliPrefix()
+
+  // Check if current directory is a site
+  const type = await classifyPackage(cwd)
+  if (type === 'site') {
+    return cwd
+  }
+
+  // Check workspace
+  const workspaceRoot = findWorkspaceRoot(cwd)
+  if (workspaceRoot) {
+    const sites = await findSites(workspaceRoot)
+
+    if (sites.length === 1) {
+      return resolve(workspaceRoot, sites[0])
+    }
+
+    if (sites.length > 1) {
+      if (isNonInteractive(args)) {
+        error('Multiple sites found. Specify which one to deploy.')
+        console.log('')
+        for (const s of sites) {
+          console.log(`  ${colors.cyan}cd ${s} && ${prefix} deploy${colors.reset}`)
+        }
+        process.exit(1)
+      }
+
+      const choice = await promptSelect('Which site?', sites)
+      if (!choice) {
+        console.log('\nDeploy cancelled.')
+        process.exit(0)
+      }
+      return resolve(workspaceRoot, choice)
+    }
+  }
+
+  // No site found — educational error
+  error('No site found in this workspace.')
+  console.log('')
+  console.log(`  ${colors.dim}\`deploy\` uploads your built site to Uniweb hosting.${colors.reset}`)
+  console.log('')
+  console.log(`  ${colors.dim}The site is a standard Vite build — you can also upload dist/${colors.reset}`)
+  console.log(`  ${colors.dim}to any static host.${colors.reset}`)
+  process.exit(1)
+}
+
+/**
+ * Parse --registry <url> from args.
+ * @param {string[]} args
+ * @returns {string|null}
+ */
+function parseRegistryUrl(args) {
+  const idx = args.indexOf('--registry')
+  if (idx === -1 || !args[idx + 1]) return null
+  return args[idx + 1]
+}
+
+/**
+ * Derive a siteId from the site's package.json or directory name.
+ * @param {string} siteDir
+ * @returns {Promise<string>}
+ */
+async function deriveSiteId(siteDir) {
+  const pkgPath = join(siteDir, 'package.json')
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(await readFile(pkgPath, 'utf8'))
+      if (pkg.name) return pkg.name
+    } catch {
+      // Fall through
+    }
+  }
+  return basename(siteDir)
+}
+
+/**
+ * Walk a directory recursively and collect all files as base64.
+ * @param {string} dir
+ * @returns {Promise<Object<string, string>>} Map of relative paths to base64 content
+ */
+async function collectFiles(dir) {
+  const files = {}
+  const entries = await readdir(dir, { withFileTypes: true, recursive: true })
+
+  for (const entry of entries) {
+    if (!entry.isFile()) continue
+    const fullPath = join(entry.parentPath || entry.path, entry.name)
+    const relPath = relative(dir, fullPath)
+    const content = await readFile(fullPath)
+    files[relPath] = content.toString('base64')
+  }
+
+  return files
+}
+
+/**
+ * Main deploy command handler
+ */
+export async function deploy(args = []) {
+  const isLocal = args.includes('--local')
+  const isDryRun = args.includes('--dry-run')
+  const registryUrl = parseRegistryUrl(args)
+  const prefix = getCliPrefix()
+
+  // 1. Resolve site directory
+  const siteDir = await resolveSiteDir(args)
+
+  // 2. Check auth (unless --local)
+  let token = null
+  if (!isLocal) {
+    token = await ensureAuth({ command: 'Deploying' })
+  }
+
+  // 3. Auto-build if dist/ is missing
+  const distDir = join(siteDir, 'dist')
+  const indexHtml = join(distDir, 'index.html')
+
+  if (!existsSync(indexHtml)) {
+    console.log(`${colors.yellow}⚠${colors.reset} No build found. Building site...`)
+    console.log('')
+    execSync('npx uniweb build', {
+      cwd: siteDir,
+      stdio: 'inherit',
+    })
+    console.log('')
+
+    if (!existsSync(indexHtml)) {
+      error('Build did not produce dist/index.html')
+      process.exit(1)
+    }
+  }
+
+  // 4. Derive siteId
+  const siteId = await deriveSiteId(siteDir)
+
+  // 5. Collect files from dist/
+  const files = await collectFiles(distDir)
+  const filesCount = Object.keys(files).length
+
+  // 6. Dry-run check
+  if (isDryRun) {
+    console.log('')
+    info(`Would deploy ${colors.bright}${siteId}${colors.reset} (${filesCount} files)`)
+    console.log(`  ${colors.dim}Source: ${distDir}${colors.reset}`)
+    const serverUrl = registryUrl || process.env.UNIWEB_REGISTRY_URL || 'http://localhost:4001'
+    console.log(`  ${colors.dim}Target: ${serverUrl}/sites/${siteId}/${colors.reset}`)
+    return
+  }
+
+  // 7. Deploy
+  const serverUrl = registryUrl || process.env.UNIWEB_REGISTRY_URL || 'http://localhost:4001'
+  info(`Deploying ${colors.bright}${siteId}${colors.reset} (${filesCount} files)...`)
+
+  const headers = { 'Content-Type': 'application/json' }
+  if (token) {
+    headers['Authorization'] = `Bearer ${token}`
+  }
+
+  const payload = {
+    siteId,
+    files,
+    metadata: {
+      deployedBy: isLocal ? 'local' : 'cli',
+    },
+  }
+
+  let res
+  try {
+    res = await fetch(`${serverUrl}/deploy`, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(payload),
+    })
+  } catch (err) {
+    error(`Could not connect to ${serverUrl}`)
+    console.log('')
+    console.log(`  ${colors.dim}Make sure the cloud server is running:${colors.reset}`)
+    console.log(`    ${colors.cyan}cd packages/cloud && pnpm dev${colors.reset}`)
+    process.exit(1)
+  }
+
+  const body = await res.json()
+
+  if (!res.ok) {
+    if (res.status === 401) {
+      error('Authentication failed.')
+      console.log(`  Run ${colors.cyan}${prefix} login${colors.reset} to refresh your credentials.`)
+      process.exit(1)
+    }
+    error(body.error || `Deploy failed (${res.status})`)
+    process.exit(1)
+  }
+
+  console.log('')
+  success(`Deployed ${colors.bright}${siteId}${colors.reset}`)
+
+  const siteUrl = body.siteUrl
+    ? `${serverUrl}${body.siteUrl}`
+    : `${serverUrl}/sites/${siteId}/`
+  console.log(`  ${colors.cyan}${siteUrl}${colors.reset}`)
+
+  // Cross-promotion: if workspace has a foundation, tip about publish
+  const workspaceRoot = findWorkspaceRoot(siteDir)
+  if (workspaceRoot) {
+    const foundations = await findFoundations(workspaceRoot)
+    if (foundations.length > 0) {
+      console.log('')
+      console.log(`  ${colors.dim}Tip: Run \`${prefix} publish\` to register your foundation and invite clients.${colors.reset}`)
+    }
+  }
+}
+
+export default deploy

package/src/commands/doctor.js

@@ -379,7 +379,7 @@ export async function doctor(args = []) {
         message: `Foundation not built: ${matchingFoundation.name}`
       })
       warn(`Foundation not built yet`)
-      log(`  ${colors.dim}Run: npx uniweb build${colors.reset}`)
+      log(`  ${colors.dim}Run: uniweb build${colors.reset}`)
     } else {
       success(`Foundation built: dist/foundation.js exists`)
     }
@@ -431,7 +431,7 @@ export async function doctor(args = []) {
         message: `Extension not built: ${ext.name}`
       })
       warn(`Extension not built yet`)
-      log(`  ${colors.dim}Run: npx uniweb build${colors.reset}`)
+      log(`  ${colors.dim}Run: uniweb build${colors.reset}`)
     } else {
       success(`Extension built: dist/foundation.js exists`)
     }

package/src/commands/handoff.js

@@ -0,0 +1,254 @@
+/**
+ * Handoff Command
+ *
+ * Creates a site record on Unicloud and transfers ownership to a client.
+ * The developer builds content locally and hands off a licensed, registered site.
+ *
+ * Usage:
+ *   uniweb handoff <email>                    # Register site + transfer to client
+ *   uniweb handoff <email> --site <id>        # Specify site ID (default: auto-generated)
+ *   uniweb handoff <email> --web              # Show web-based handoff instructions
+ */
+
+import { existsSync } from 'node:fs'
+import { readFile } from 'node:fs/promises'
+import { resolve, join } from 'node:path'
+import { execSync } from 'node:child_process'
+import { randomUUID } from 'node:crypto'
+
+import { RemoteRegistry } from '../utils/registry.js'
+import { ensureAuth } from '../utils/auth.js'
+import { findWorkspaceRoot, findFoundations, classifyPackage, promptSelect } from '../utils/workspace.js'
+import { isNonInteractive, getCliPrefix } from '../utils/interactive.js'
+
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  dim: '\x1b[2m',
+  cyan: '\x1b[36m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m',
+}
+
+function success(message) {
+  console.log(`${colors.green}✓${colors.reset} ${message}`)
+}
+
+function error(message) {
+  console.error(`${colors.red}✗${colors.reset} ${message}`)
+}
+
+function info(message) {
+  console.log(`${colors.cyan}→${colors.reset} ${message}`)
+}
+
+/**
+ * Parse a flag value from args.
+ * @param {string[]} args
+ * @param {string} flag - e.g. '--site'
+ * @returns {string|null}
+ */
+function parseFlag(args, flag) {
+  const idx = args.indexOf(flag)
+  if (idx === -1 || !args[idx + 1]) return null
+  return args[idx + 1]
+}
+
+/**
+ * Resolve the foundation directory (same logic as invite.js).
+ */
+async function resolveFoundationDir(args) {
+  const cwd = process.cwd()
+  const prefix = getCliPrefix()
+
+  const type = await classifyPackage(cwd)
+  if (type === 'foundation') return cwd
+
+  const workspaceRoot = findWorkspaceRoot(cwd)
+  if (workspaceRoot) {
+    const foundations = await findFoundations(workspaceRoot)
+
+    if (foundations.length === 1) {
+      return resolve(workspaceRoot, foundations[0])
+    }
+
+    if (foundations.length > 1) {
+      if (isNonInteractive(args)) {
+        error('Multiple foundations found. Specify which one.')
+        console.log('')
+        for (const f of foundations) {
+          console.log(`  ${colors.cyan}cd ${f} && ${prefix} handoff ...${colors.reset}`)
+        }
+        process.exit(1)
+      }
+
+      const choice = await promptSelect('Which foundation?', foundations)
+      if (!choice) {
+        console.log('\nCancelled.')
+        process.exit(0)
+      }
+      return resolve(workspaceRoot, choice)
+    }
+  }
+
+  error('No foundation found in this workspace.')
+  console.log('')
+  console.log(`  ${colors.dim}\`handoff\` creates a site record for your foundation and transfers${colors.reset}`)
+  console.log(`  ${colors.dim}ownership to a client — they get a licensed, ready-to-use project.${colors.reset}`)
+  console.log('')
+  console.log(`  ${colors.dim}Run this command from a foundation directory or workspace root.${colors.reset}`)
+  process.exit(1)
+}
+
+/**
+ * Read foundation name and version from dist/meta/schema.json, auto-building if needed.
+ */
+async function readSchema(foundationDir) {
+  const distDir = join(foundationDir, 'dist')
+  const foundationJs = join(distDir, 'foundation.js')
+  const schemaJson = join(distDir, 'meta', 'schema.json')
+
+  if (!existsSync(foundationJs) || !existsSync(schemaJson)) {
+    console.log(`${colors.yellow}⚠${colors.reset} No build found. Building foundation...`)
+    console.log('')
+    execSync('npx uniweb build --target foundation', {
+      cwd: foundationDir,
+      stdio: 'inherit',
+    })
+    console.log('')
+
+    if (!existsSync(foundationJs) || !existsSync(schemaJson)) {
+      error('Build did not produce dist/foundation.js and dist/meta/schema.json')
+      process.exit(1)
+    }
+  }
+
+  try {
+    const schema = JSON.parse(await readFile(schemaJson, 'utf8'))
+    const name = schema._self?.name
+    const version = schema._self?.version
+
+    if (!name || !version) {
+      error('dist/meta/schema.json missing _self.name or _self.version')
+      process.exit(1)
+    }
+
+    return { name, version }
+  } catch (err) {
+    error(`Failed to read dist/meta/schema.json: ${err.message}`)
+    process.exit(1)
+  }
+}
+
+/**
+ * Create a RemoteRegistry instance with auth.
+ */
+async function createRegistry(args) {
+  const token = await ensureAuth({ command: 'Handing off' })
+
+  const registryUrl = parseFlag(args, '--registry')
+  const url = registryUrl || process.env.UNIWEB_REGISTRY_URL || 'http://localhost:4001'
+
+  return new RemoteRegistry(url, token)
+}
+
+/**
+ * Handle --web flag: show web-based handoff guidance.
+ */
+function showWebHandoff(email, name) {
+  console.log('')
+  info(`Web-based handoff`)
+  console.log('')
+  console.log(`  1. Create a site on ${colors.cyan}uniweb.app${colors.reset} using ${colors.bright}${name}${colors.reset}`)
+  console.log(`  2. Add pages and content`)
+  console.log(`  3. Transfer ownership to ${colors.bright}${email}${colors.reset}:`)
+  console.log(`     ${colors.dim}Settings → Transfer site${colors.reset}`)
+  console.log('')
+  console.log(`  ${colors.dim}The license stays with the site — the client can edit${colors.reset}`)
+  console.log(`  ${colors.dim}and publish immediately.${colors.reset}`)
+}
+
+/**
+ * Main handoff command handler.
+ */
+export async function handoff(args = []) {
+  const prefix = getCliPrefix()
+
+  // Extract email (first positional arg with @)
+  const email = args.find(a => !a.startsWith('--') && a.includes('@'))
+  if (!email) {
+    error('Email is required.')
+    console.log('')
+    console.log(`  ${colors.dim}Usage: ${prefix} handoff <email> [--site <id>] [--web]${colors.reset}`)
+    console.log('')
+    console.log(`  ${colors.dim}Creates a site record for your foundation and transfers ownership${colors.reset}`)
+    console.log(`  ${colors.dim}to the client. They get a licensed project, ready to use.${colors.reset}`)
+    process.exit(1)
+  }
+
+  const foundationDir = await resolveFoundationDir(args)
+  const { name, version } = await readSchema(foundationDir)
+
+  // --web: guidance-only, no API call
+  if (args.includes('--web')) {
+    showWebHandoff(email, name)
+    return
+  }
+
+  const registry = await createRegistry(args)
+
+  // Derive site ID
+  const siteIdFlag = parseFlag(args, '--site')
+  const siteId = siteIdFlag || `${name}-${randomUUID().slice(0, 6)}`
+
+  info(`Creating site ${colors.bright}${siteId}${colors.reset} with ${name} v${version}...`)
+
+  // 1. Create site record
+  let siteResult
+  try {
+    siteResult = await registry.createSite(siteId, { foundation: { name } })
+  } catch (err) {
+    if (err.statusCode === 409) {
+      error(`Site "${siteId}" already exists.`)
+      console.log(`  ${colors.dim}Use --site <id> to specify a different site identifier.${colors.reset}`)
+      process.exit(1)
+    }
+    if (err.statusCode === 404) {
+      error(err.message)
+      console.log(`  ${colors.dim}Make sure your foundation is published: ${prefix} publish${colors.reset}`)
+      process.exit(1)
+    }
+    error(err.message)
+    process.exit(1)
+  }
+
+  // 2. Transfer ownership to client
+  info(`Transferring to ${colors.bright}${email}${colors.reset}...`)
+
+  try {
+    await registry.transferSiteOwnership(siteId, email)
+  } catch (err) {
+    error(`Site created but transfer failed: ${err.message}`)
+    console.log(`  ${colors.dim}Site "${siteId}" is registered. Transfer manually:${colors.reset}`)
+    console.log(`  ${colors.dim}  PATCH /api/sites/${siteId}/owner  { "newOwner": "${email}" }${colors.reset}`)
+    process.exit(1)
+  }
+
+  // 3. Show result
+  console.log('')
+  success(`Site created and transferred`)
+  console.log('')
+  console.log(`  ${colors.dim}Site:${colors.reset}        ${colors.bright}${siteId}${colors.reset}`)
+  console.log(`  ${colors.dim}Foundation:${colors.reset}  ${name} v${version.split('.')[0]}`)
+  console.log(`  ${colors.dim}Owner:${colors.reset}       ${email}`)
+  console.log(`  ${colors.dim}License:${colors.reset}     ${siteResult.license ? `${colors.green}✓${colors.reset} granted` : `${colors.yellow}⚠${colors.reset} not granted`}`)
+  console.log('')
+  console.log(`  ${colors.bright}Next steps:${colors.reset}`)
+  console.log(`    1. Add ${colors.cyan}id: ${siteId}${colors.reset} to your site.yml`)
+  console.log(`    2. Share the site files with ${colors.bright}${email}${colors.reset}`)
+  console.log(`       ${colors.dim}(git repo, zip, shared drive — any method works)${colors.reset}`)
+  console.log(`    3. Client opens the project in Uniweb Studio`)
+}
+
+export default handoff