uniweb 0.8.14 → 0.8.16

package/src/commands/template.js

@@ -0,0 +1,230 @@
+/**
+ * Template Command
+ *
+ * Publish a site as a cloud template.
+ *
+ * Usage:
+ *   uniweb template publish                  # Reads template name from site.yml `template:` field
+ *   uniweb template publish --name my-tpl    # Override template name
+ *   uniweb template publish --title "My Tpl" # Display title
+ *   uniweb template publish --description "A starter template"
+ *   uniweb template publish --registry <url> # Publish to a specific registry URL
+ */
+
+import { existsSync } from 'node:fs'
+import { readFile, readdir } from 'node:fs/promises'
+import { resolve, join, relative } from 'node:path'
+import yaml from 'js-yaml'
+
+import { ensureAuth } from '../utils/auth.js'
+import { findWorkspaceRoot, findSites, classifyPackage } 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 named flag from args.
+ * @param {string[]} args
+ * @param {string} flag - e.g. '--name'
+ * @returns {string|null}
+ */
+function parseFlag(args, flag) {
+  const idx = args.indexOf(flag)
+  if (idx === -1 || !args[idx + 1]) return null
+  return args[idx + 1]
+}
+
+// Build infrastructure files to exclude from templates
+const EXCLUDED_FILES = new Set([
+  'package.json', 'package-lock.json', 'pnpm-lock.yaml',
+  'vite.config.js', 'vite.config.ts',
+  'index.html', 'main.js', 'main.ts',
+])
+const EXCLUDED_DIRS = new Set([
+  'node_modules', 'dist', '.git', '.vite',
+])
+
+/**
+ * Resolve the site directory to publish as a template.
+ *
+ * Priority:
+ * 1. In a site directory → use it
+ * 2. site.yml in cwd (non-package site, e.g. cloud site) → use it
+ * 3. At workspace root, one site → use it
+ * 4. At workspace root, multiple → error
+ * 5. No site → educational error
+ */
+async function resolveSiteDir() {
+  const cwd = process.cwd()
+
+  // Check if current directory is a site package
+  const type = await classifyPackage(cwd)
+  if (type === 'site') return cwd
+
+  // Check for site.yml directly (non-package site, e.g. cloud site)
+  if (existsSync(join(cwd, 'site.yml'))) 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) {
+      error('Multiple sites found. Run this command from inside the site directory.')
+      process.exit(1)
+    }
+  }
+
+  error('No site found. Run this command from a site directory (must contain site.yml).')
+  process.exit(1)
+}
+
+/**
+ * Recursively read all files in a directory, returning { relativePath: base64Content }.
+ * Skips build infrastructure files and directories.
+ */
+async function readAllFiles(dir, baseDir = dir) {
+  const files = {}
+  const entries = await readdir(dir, { withFileTypes: true })
+
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name)
+    if (entry.isDirectory()) {
+      if (EXCLUDED_DIRS.has(entry.name)) continue
+      Object.assign(files, await readAllFiles(fullPath, baseDir))
+    } else if (entry.isFile()) {
+      if (EXCLUDED_FILES.has(entry.name)) continue
+      const relPath = relative(baseDir, fullPath)
+      const content = await readFile(fullPath)
+      files[relPath] = content.toString('base64')
+    }
+  }
+
+  return files
+}
+
+/**
+ * Main template command dispatcher.
+ */
+export async function template(args = []) {
+  const subcommand = args[0]
+
+  if (subcommand === 'publish') {
+    await templatePublish(args.slice(1))
+    return
+  }
+
+  const prefix = getCliPrefix()
+  error(subcommand ? `Unknown subcommand: template ${subcommand}` : 'Missing subcommand')
+  console.log('')
+  console.log(`${colors.bright}Usage:${colors.reset}`)
+  console.log(`  ${prefix} template publish    Publish a site as a cloud template`)
+  console.log('')
+  console.log(`${colors.bright}Options:${colors.reset}`)
+  console.log(`  --name <name>        Template registry name (overrides site.yml \`template:\` field)`)
+  console.log(`  --title <title>      Display title (overrides site.yml \`name:\` field)`)
+  console.log(`  --description <txt>  Description`)
+  console.log(`  --registry <url>     Registry URL (default: http://localhost:4001)`)
+  process.exit(1)
+}
+
+/**
+ * Publish a site directory as a cloud template.
+ */
+async function templatePublish(args) {
+  const registryUrl = parseFlag(args, '--registry')
+  const nameOverride = parseFlag(args, '--name')
+  const titleOverride = parseFlag(args, '--title')
+  const descOverride = parseFlag(args, '--description')
+
+  // 1. Resolve site directory
+  const siteDir = await resolveSiteDir()
+
+  // 2. Read and parse site.yml
+  const siteYmlPath = join(siteDir, 'site.yml')
+  if (!existsSync(siteYmlPath)) {
+    error('No site.yml found in this directory')
+    process.exit(1)
+  }
+
+  const siteYmlContent = await readFile(siteYmlPath, 'utf8')
+  const siteConfig = yaml.load(siteYmlContent) || {}
+
+  // 3. Determine template name: --name flag > site.yml `template:` field > directory name
+  const templateName = nameOverride || siteConfig.template || siteDir.split('/').pop()
+
+  if (!siteConfig.foundation) {
+    error('site.yml must declare a foundation')
+    process.exit(1)
+  }
+
+  // 4. Collect all content files (skip build infrastructure)
+  info(`Collecting files from ${colors.dim}${siteDir}${colors.reset}`)
+  const files = await readAllFiles(siteDir)
+  const fileCount = Object.keys(files).length
+
+  if (fileCount === 0) {
+    error('No files found to publish')
+    process.exit(1)
+  }
+
+  console.log(`  ${colors.dim}${fileCount} files${colors.reset}`)
+
+  // 5. Authenticate
+  const token = await ensureAuth({ command: 'Publishing template' })
+
+  // 6. Build payload
+  const url = registryUrl || process.env.UNIWEB_REGISTRY_URL || 'http://localhost:4001'
+
+  const payload = { name: templateName, files }
+  if (titleOverride || siteConfig.name) {
+    payload.title = titleOverride || siteConfig.name
+  }
+  if (descOverride) payload.description = descOverride
+
+  // 7. Publish via API
+  info(`Publishing template ${colors.bright}${templateName}${colors.reset} to ${url}`)
+
+  const headers = { 'Content-Type': 'application/json' }
+  if (token) headers['Authorization'] = `Bearer ${token}`
+
+  const res = await fetch(`${url}/api/templates`, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify(payload),
+  })
+
+  const body = await res.json()
+
+  if (!res.ok) {
+    error(body.error || `Server error (${res.status})`)
+    process.exit(1)
+  }
+
+  console.log('')
+  success(`Published template ${colors.bright}${templateName}${colors.reset}`)
+  console.log(`  ${colors.dim}Foundation: ${body.foundation}${colors.reset}`)
+  console.log(`  ${colors.dim}Files: ${body.filesCount}${colors.reset}`)
+}
+
+export default template

package/src/index.js

@@ -5,24 +5,37 @@
  *
  * Scaffolds new Uniweb sites and foundations, builds projects, and generates docs.
  *
+ * Install globally:
+ *   npm i -g uniweb
+ *
  * Usage:
- *   npx uniweb create [project-name]
- *   npx uniweb create --template marketing
- *   npx uniweb add foundation [name]
- *   npx uniweb build
- *   npx uniweb docs                          # Generate COMPONENTS.md from schema
+ *   uniweb create [project-name]
+ *   uniweb create --template marketing
+ *   uniweb add foundation [name]
+ *   uniweb build
+ *   uniweb docs
+ *
+ * Global install delegation:
+ *   When installed globally, project-bound commands (build, docs, etc.) are
+ *   delegated to the project-local CLI if one exists in node_modules. This
+ *   ensures version alignment between the CLI and @uniweb/build.
  */
 
-import { existsSync } from 'node:fs'
-import { execSync } from 'node:child_process'
-import { resolve, join, relative } from 'node:path'
+import { existsSync, readFileSync } from 'node:fs'
+import { execSync, spawn as spawnChild } from 'node:child_process'
+import { resolve, join, relative, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
 import prompts from 'prompts'
-import { build } from './commands/build.js'
-import { docs } from './commands/docs.js'
 import { doctor } from './commands/doctor.js'
 import { i18n } from './commands/i18n.js'
 import { inspect } from './commands/inspect.js'
 import { add } from './commands/add.js'
+import { login } from './commands/login.js'
+import { publish } from './commands/publish.js'
+import { deploy } from './commands/deploy.js'
+import { invite } from './commands/invite.js'
+import { handoff } from './commands/handoff.js'
+import { template } from './commands/template.js'
 import {
   resolveTemplate,
   parseTemplateId,
@@ -31,6 +44,7 @@ import { validateTemplate } from './templates/validator.js'
 import { scaffoldWorkspace, scaffoldFoundation, scaffoldSite, applyContent, applyStarter, mergeTemplateDependencies } from './utils/scaffold.js'
 import { detectPackageManager, filterCmd, installCmd, runCmd } from './utils/pm.js'
 import { isNonInteractive, getCliPrefix, stripNonInteractiveFlag, formatOptions } from './utils/interactive.js'
+import { findWorkspaceRoot } from './utils/workspace.js'
 
 // Colors for terminal output
 const colors = {
@@ -73,6 +87,108 @@ function title(message) {
   console.log(`\n${colors.cyan}${colors.bright}${message}${colors.reset}\n`)
 }
 
+// CLI version (read once, lazily)
+const __dirname = dirname(fileURLToPath(import.meta.url))
+let _cliVersion = null
+function getCliVersion() {
+  if (!_cliVersion) {
+    const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8'))
+    _cliVersion = pkg.version
+  }
+  return _cliVersion
+}
+
+/**
+ * Commands that always run from the global CLI (no project context needed)
+ */
+const STANDALONE_COMMANDS = new Set([
+  'create', '--help', '-h', '--version', '-v', 'login',
+])
+
+/**
+ * Check if this CLI is running from a global install.
+ * When installed globally, process.argv[1] points outside any node_modules.
+ * When run via npx or as a local dependency, it's inside node_modules.
+ */
+function isGlobalInstall() {
+  const scriptPath = process.argv[1]
+  if (!scriptPath) return false
+  // Normalize path separators for Windows compatibility
+  return !scriptPath.split('/').includes('node_modules') &&
+         !scriptPath.split('\\').includes('node_modules')
+}
+
+/**
+ * Find the project-local CLI entry point, if one exists.
+ * Walks up from cwd looking for node_modules/uniweb/src/index.js.
+ */
+function findLocalCli() {
+  let dir = process.cwd()
+  while (true) {
+    const localCli = join(dir, 'node_modules', 'uniweb', 'src', 'index.js')
+    if (existsSync(localCli)) return localCli
+    const parent = dirname(dir)
+    if (parent === dir) break
+    dir = parent
+  }
+  return null
+}
+
+/**
+ * Delegate execution to the project-local CLI.
+ * Spawns the local CLI with the same arguments and inherits stdio.
+ * Warns if the local version differs from the global version.
+ */
+function delegateToLocal(localCliPath) {
+  // Check for version mismatch between global and local CLI
+  try {
+    const localPkgPath = join(dirname(localCliPath), '..', 'package.json')
+    const localPkg = JSON.parse(readFileSync(localPkgPath, 'utf8'))
+    const globalVersion = getCliVersion()
+    if (localPkg.version && localPkg.version !== globalVersion) {
+      const yellow = '\x1b[33m'
+      const dim = '\x1b[2m'
+      const reset = '\x1b[0m'
+      console.error(`${yellow}Note:${reset} Global CLI is ${dim}${globalVersion}${reset}, project has ${dim}${localPkg.version}${reset} ${dim}(using project version)${reset}`)
+    }
+  } catch { /* ignore — version check is best-effort */ }
+
+  return new Promise((resolve, reject) => {
+    const child = spawnChild(
+      process.execPath,
+      [localCliPath, ...process.argv.slice(2)],
+      { stdio: 'inherit' }
+    )
+    child.on('close', (code) => process.exit(code ?? 0))
+    child.on('error', reject)
+  })
+}
+
+/**
+ * Import a command module that may depend on @uniweb/build.
+ * Provides a helpful error when the dependency can't be resolved
+ * (e.g., running a project-bound command from a global install
+ * outside a project directory).
+ */
+async function importProjectCommand(modulePath) {
+  try {
+    return await import(modulePath)
+  } catch (err) {
+    if (err.code === 'ERR_MODULE_NOT_FOUND' && err.message?.includes('@uniweb/')) {
+      error('This command must be run from inside a Uniweb project.')
+      log('')
+      log(`Make sure you're in a project directory with dependencies installed:`)
+      log(`  ${colors.cyan}cd your-project${colors.reset}`)
+      log(`  ${colors.cyan}npm install${colors.reset}`)
+      log('')
+      log(`Or create a new project:`)
+      log(`  ${colors.cyan}uniweb create my-project${colors.reset}`)
+      process.exit(1)
+    }
+    throw err
+  }
+}
+
 /**
  * Create a project using the new package template flow (default)
  */
@@ -299,21 +415,55 @@ async function main() {
   const command = args[0]
   const pm = detectPackageManager()
 
+  // Handle --version / -v
+  if (command === '--version' || command === '-v') {
+    console.log(`uniweb ${getCliVersion()}`)
+    return
+  }
+
+  // Global install launcher: delegate project-bound commands to local CLI
+  const global = isGlobalInstall()
+  if (global && command && !STANDALONE_COMMANDS.has(command)) {
+    const localCli = findLocalCli()
+    if (localCli) {
+      await delegateToLocal(localCli)
+      return
+    }
+    // No local CLI found — fall through and try to run the command directly.
+    // Commands that need @uniweb/build will get a helpful error via importProjectCommand().
+  }
+
+  // Start non-blocking update check for global installs
+  let showUpdateNotification = () => {}
+  if (global) {
+    try {
+      const { startUpdateCheck } = await import('./utils/update-check.js')
+      showUpdateNotification = startUpdateCheck(getCliVersion())
+    } catch {
+      // Update check is optional — don't fail if the module is missing
+    }
+  }
+
   // Show help
   if (!command || command === '--help' || command === '-h') {
     showHelp()
+    await showUpdateNotification()
     return
   }
 
-  // Handle build command
+  // Handle build command (dynamic import — depends on @uniweb/build)
   if (command === 'build') {
+    const { build } = await importProjectCommand('./commands/build.js')
     await build(args.slice(1))
+    await showUpdateNotification()
     return
   }
 
-  // Handle docs command
+  // Handle docs command (dynamic import — depends on @uniweb/build)
   if (command === 'docs') {
+    const { docs } = await importProjectCommand('./commands/docs.js')
     await docs(args.slice(1))
+    await showUpdateNotification()
     return
   }
 
@@ -341,6 +491,42 @@ async function main() {
     return
   }
 
+  // Handle publish command
+  if (command === 'publish') {
+    await publish(args.slice(1))
+    return
+  }
+
+  // Handle deploy command
+  if (command === 'deploy') {
+    await deploy(args.slice(1))
+    return
+  }
+
+  // Handle login command
+  if (command === 'login') {
+    await login(args.slice(1))
+    return
+  }
+
+  // Handle invite command
+  if (command === 'invite') {
+    await invite(args.slice(1))
+    return
+  }
+
+  // Handle handoff command
+  if (command === 'handoff') {
+    await handoff(args.slice(1))
+    return
+  }
+
+  // Handle template command
+  if (command === 'template') {
+    await template(args.slice(1))
+    return
+  }
+
   // Handle create command
   if (command !== 'create') {
     error(`Unknown command: ${command}`)
@@ -350,6 +536,17 @@ async function main() {
 
   title('Uniweb Project Generator')
 
+  // Guard: prevent creating nested workspaces
+  const existingRoot = findWorkspaceRoot(process.cwd())
+  if (existingRoot) {
+    error(`Already inside a Uniweb workspace: ${existingRoot}`)
+    log(`\nTo add packages to this workspace, use:`)
+    log(`  ${colors.cyan}uniweb add foundation [name]${colors.reset}`)
+    log(`  ${colors.cyan}uniweb add site [name]${colors.reset}`)
+    log(`  ${colors.cyan}uniweb add foundation --from <template>${colors.reset}\n`)
+    process.exit(1)
+  }
+
   // Parse arguments
   let projectName = args[1]
   let templateType = null  // null = use new package template flow
@@ -562,23 +759,31 @@ async function main() {
     log(`  ${colors.cyan}${runCmd(pm, 'dev')}${colors.reset}`)
   }
   log('')
+
+  await showUpdateNotification()
 }
 
 function showHelp() {
   log(`
-${colors.cyan}${colors.bright}Uniweb CLI${colors.reset}
+${colors.cyan}${colors.bright}Uniweb CLI${colors.reset} ${colors.dim}v${getCliVersion()}${colors.reset}
 
 ${colors.bright}Usage:${colors.reset}
-  npx uniweb <command> [options]
+  uniweb <command> [options]
 
 ${colors.bright}Commands:${colors.reset}
   create [name]      Create a new project
   add <type> [name]  Add a foundation, site, or extension to a project
   build              Build the current project
+  deploy             Deploy a site to Uniweb hosting
+  publish            Publish a foundation to the Uniweb Registry
+  invite <email>     Create a foundation invite for a client
+  handoff <email>    Hand off a site to a client
   inspect <path>     Inspect parsed content shape of a markdown file or folder
   docs               Generate component documentation
   doctor             Diagnose project configuration issues
   i18n <cmd>         Internationalization (extract, sync, status)
+  template publish   Publish a site as a cloud template
+  login              Log in to your Uniweb account
 
 ${colors.bright}Create Options:${colors.reset}
   --template <type>  Project template (default: starter)
@@ -594,9 +799,37 @@ ${colors.bright}Add Subcommands:${colors.reset}
   add section <name>      Add a section type to a foundation (--foundation)
 
 ${colors.bright}Global Options:${colors.reset}
+  --version, -v        Show version
   --non-interactive    Fail with usage info instead of prompting
                        Auto-detected when CI=true or no TTY (pipes, agents)
 
+${colors.bright}Publish Options:${colors.reset}
+  --local            Publish to the local registry (.unicloud/) instead of Uniweb Registry
+  --edit-access <p>  Set edit access policy: "open" or "restricted" (default: restricted)
+  --dry-run          Show what would be published without uploading
+
+${colors.bright}Invite Options:${colors.reset}
+  --uses <n>         Max sites per invite (default: 1)
+  --expires <days>   Days until expiry (default: 30)
+  --version <n>      Major version to license (default: current)
+  --list             List invites for your foundation
+  --revoke <id>      Revoke an invite
+  --resend <id>      Resend an invite
+
+${colors.bright}Handoff Options:${colors.reset}
+  --site <id>        Site identifier (default: auto-generated)
+  --web              Show web-based handoff instructions instead
+
+${colors.bright}Template Options:${colors.reset}
+  --name <name>      Template registry name (overrides site.yml template: field)
+  --title <title>    Display title (overrides site.yml name: field)
+  --description <t>  Description
+  --registry <url>   Registry URL (default: http://localhost:4001)
+
+${colors.bright}Deploy Options:${colors.reset}
+  --prod             Deploy to production (default: preview URL)
+  --dry-run          Show what would be deployed without uploading
+
 ${colors.bright}Build Options:${colors.reset}
   --target <type>    Build target (foundation, site) - auto-detected if not specified
   --prerender        Force pre-rendering (overrides site.yml)
@@ -633,22 +866,26 @@ ${colors.bright}Template Types:${colors.reset}
   https://github.com/user/repo  GitHub URL
 
 ${colors.bright}Examples:${colors.reset}
-  npx uniweb create my-project                           # Foundation + site + starter content
-  npx uniweb create my-project --template none           # Foundation + site, no content
-  npx uniweb create my-project --blank                   # Empty workspace
-  npx uniweb create my-project --template marketing      # Official template
-  npx uniweb create my-project --template ./my-template  # Local template
+  uniweb create my-project                           # Foundation + site + starter content
+  uniweb create my-project --template none           # Foundation + site, no content
+  uniweb create my-project --blank                   # Empty workspace
+  uniweb create my-project --template marketing      # Official template
+  uniweb create my-project --template ./my-template  # Local template
 
   cd my-project
-  npx uniweb add project docs                            # Add docs/foundation/ + docs/site/
-  npx uniweb add project docs --from academic            # Co-located pair + academic content
-  npx uniweb add foundation                              # Add foundation at root
-  npx uniweb add site blog --foundation marketing        # Add site wired to marketing
-  npx uniweb add extension effects --site site           # Add extensions/effects/
-
-  npx uniweb build
-  npx uniweb build --target foundation
-  cd foundation && npx uniweb docs                       # Generate COMPONENTS.md
+  uniweb add project docs                            # Add docs/foundation/ + docs/site/
+  uniweb add project docs --from academic            # Co-located pair + academic content
+  uniweb add foundation                              # Add foundation at root
+  uniweb add site blog --foundation marketing        # Add site wired to marketing
+  uniweb add extension effects --site site           # Add extensions/effects/
+
+  uniweb build
+  uniweb build --target foundation
+  cd foundation && uniweb docs                       # Generate COMPONENTS.md
+
+${colors.bright}Install:${colors.reset}
+  npm i -g uniweb          Global install (recommended)
+  npx uniweb <command>     Run without installing
 `)
 }