uniweb 0.8.14 → 0.8.16

package/src/utils/auth.js

@@ -0,0 +1,150 @@
+/**
+ * Credential Storage
+ *
+ * Manages authentication credentials at ~/.uniweb/auth.json.
+ * User-global (not workspace-local) — you publish as yourself, not as a project.
+ *
+ * Used by `login`, `publish`, and `deploy` commands.
+ */
+
+import { existsSync } from 'node:fs'
+import { readFile, writeFile, mkdir, unlink } from 'node:fs/promises'
+import { join } from 'node:path'
+import { homedir } from 'node:os'
+
+/**
+ * Get the ~/.uniweb/ directory path.
+ * @returns {string}
+ */
+export function getAuthDir() {
+  return join(homedir(), '.uniweb')
+}
+
+/**
+ * Get the ~/.uniweb/auth.json file path.
+ * @returns {string}
+ */
+export function getAuthPath() {
+  return join(getAuthDir(), 'auth.json')
+}
+
+/**
+ * Read stored credentials.
+ * @returns {Promise<{ token: string, email: string, expiresAt?: string } | null>}
+ */
+export async function readAuth() {
+  const authPath = getAuthPath()
+  if (!existsSync(authPath)) return null
+
+  try {
+    return JSON.parse(await readFile(authPath, 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Write credentials to storage.
+ * @param {{ token: string, email: string, expiresAt?: string }} auth
+ */
+export async function writeAuth(auth) {
+  const dir = getAuthDir()
+  await mkdir(dir, { recursive: true })
+  await writeFile(join(dir, 'auth.json'), JSON.stringify(auth, null, 2))
+}
+
+/**
+ * Remove stored credentials.
+ */
+export async function clearAuth() {
+  const authPath = getAuthPath()
+  if (existsSync(authPath)) {
+    await unlink(authPath)
+  }
+}
+
+/**
+ * Check if credentials are expired.
+ * @param {{ expiresAt?: string }} auth
+ * @returns {boolean}
+ */
+export function isExpired(auth) {
+  if (!auth?.expiresAt) return false
+  return new Date(auth.expiresAt) < new Date()
+}
+
+/**
+ * Ensure the user is authenticated. If not, prompt inline login.
+ * Returns the auth token on success, exits the process on cancel.
+ *
+ * @param {Object} options
+ * @param {string} options.command - The command that needs auth (for messaging)
+ * @returns {Promise<string>} Bearer token
+ */
+export async function ensureAuth({ command = 'This command' } = {}) {
+  const auth = await readAuth()
+
+  if (auth?.token && !isExpired(auth)) {
+    return auth.token
+  }
+
+  // Need to log in
+  const prompts = (await import('prompts')).default
+
+  if (auth && isExpired(auth)) {
+    console.log(`\x1b[33mSession expired.\x1b[0m ${command} requires a Uniweb account.\n`)
+  } else {
+    console.log(`${command} requires a Uniweb account.\n`)
+  }
+
+  const { action } = await prompts({
+    type: 'select',
+    name: 'action',
+    message: 'What would you like to do?',
+    choices: [
+      { title: 'Log in (paste token from uniweb.app/cli-login)', value: 'login' },
+      { title: 'Cancel', value: 'cancel' },
+    ],
+  }, {
+    onCancel: () => {
+      process.exit(0)
+    },
+  })
+
+  if (action !== 'login') {
+    process.exit(0)
+  }
+
+  const response = await prompts([
+    {
+      type: 'text',
+      name: 'email',
+      message: 'Email:',
+      validate: (v) => (v && v.includes('@') ? true : 'Enter a valid email'),
+    },
+    {
+      type: 'password',
+      name: 'token',
+      message: 'Token:',
+      validate: (v) => (v ? true : 'Token is required'),
+    },
+  ], {
+    onCancel: () => {
+      process.exit(0)
+    },
+  })
+
+  if (!response.email || !response.token) {
+    process.exit(1)
+  }
+
+  await writeAuth({
+    token: response.token,
+    email: response.email,
+    expiresAt: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString(),
+  })
+
+  console.log(`\n\x1b[32m✓\x1b[0m Logged in as \x1b[1m${response.email}\x1b[0m\n`)
+
+  return response.token
+}

package/src/utils/registry.js

@@ -0,0 +1,361 @@
+/**
+ * Local Foundation Registry
+ *
+ * Manages published foundations in .unicloud/registry/.
+ * Same on-disk format as scripts/platform/registry.js, so
+ * scripts/platform/serve.js can still serve them.
+ *
+ * Layout:
+ *   .unicloud/
+ *     registry/
+ *       index.json                  # { "name": { versions: { "1.0.0": { ... } } } }
+ *       packages/
+ *         name/
+ *           1.0.0/
+ *             foundation.js
+ *             schema.json
+ *             assets/...
+ */
+
+import { existsSync } from 'node:fs'
+import { readFile, writeFile, readdir, mkdir, cp } from 'node:fs/promises'
+import { join, dirname, relative } from 'node:path'
+
+import { findWorkspaceRoot } from './workspace.js'
+
+/**
+ * Get the .unicloud/registry/ directory path.
+ * Looks for workspace root first; falls back to cwd.
+ * @param {string} [startDir]
+ * @returns {string}
+ */
+export function getRegistryDir(startDir = process.cwd()) {
+  const root = findWorkspaceRoot(startDir)
+  const base = root || startDir
+  return join(base, '.unicloud', 'registry')
+}
+
+/**
+ * Sanitize a package name for filesystem use.
+ * '@org/pkg' → '@org__pkg'
+ * @param {string} name
+ * @returns {string}
+ */
+function sanitizeName(name) {
+  return name.replace(/\//g, '__')
+}
+
+/**
+ * Local registry — stores published foundations in .unicloud/registry/
+ */
+export class LocalRegistry {
+  constructor(startDir) {
+    this.registryDir = getRegistryDir(startDir)
+    this.indexPath = join(this.registryDir, 'index.json')
+    this.packagesDir = join(this.registryDir, 'packages')
+  }
+
+  async _readIndex() {
+    if (!existsSync(this.indexPath)) return {}
+    return JSON.parse(await readFile(this.indexPath, 'utf8'))
+  }
+
+  async _writeIndex(index) {
+    await mkdir(this.registryDir, { recursive: true })
+    await writeFile(this.indexPath, JSON.stringify(index, null, 2))
+  }
+
+  /**
+   * Check if a specific version exists.
+   * @param {string} name
+   * @param {string} version
+   * @returns {Promise<boolean>}
+   */
+  async exists(name, version) {
+    const index = await this._readIndex()
+    return !!index[name]?.versions?.[version]
+  }
+
+  /**
+   * Get all published versions for a package.
+   * @param {string} name
+   * @returns {Promise<Object>}
+   */
+  async getVersions(name) {
+    const index = await this._readIndex()
+    return index[name]?.versions || {}
+  }
+
+  /**
+   * Publish a foundation to the local registry.
+   * Copies the dist directory and updates the index.
+   * @param {string} name
+   * @param {string} version
+   * @param {string} distDir - Path to the foundation's dist/ directory
+   * @param {Object} [metadata] - Additional metadata (publishedBy, etc.)
+   */
+  async publish(name, version, distDir, metadata = {}) {
+    const safeName = sanitizeName(name)
+    const destDir = join(this.packagesDir, safeName, version)
+
+    await mkdir(destDir, { recursive: true })
+    await cp(distDir, destDir, { recursive: true })
+
+    const index = await this._readIndex()
+    if (!index[name]) {
+      index[name] = { versions: {} }
+    }
+    index[name].versions[version] = {
+      publishedAt: new Date().toISOString(),
+      ...metadata,
+    }
+    await this._writeIndex(index)
+  }
+
+  /**
+   * Get the filesystem path for a published package version.
+   * @param {string} name
+   * @param {string} version
+   * @returns {string}
+   */
+  getPackagePath(name, version) {
+    return join(this.packagesDir, sanitizeName(name), version)
+  }
+}
+
+/**
+ * Create a local registry instance.
+ * @param {string} [startDir]
+ * @returns {LocalRegistry}
+ */
+export function createLocalRegistry(startDir) {
+  return new LocalRegistry(startDir)
+}
+
+/**
+ * Remote registry — publishes foundations to a cloud server via HTTP.
+ */
+export class RemoteRegistry {
+  /**
+   * @param {string} apiUrl - Registry server URL (e.g. "http://localhost:4001")
+   * @param {string} [token] - Bearer token for authentication
+   */
+  constructor(apiUrl, token) {
+    this.apiUrl = apiUrl.replace(/\/$/, '')
+    this.token = token
+  }
+
+  /**
+   * Fetch the registry index from the server.
+   * @returns {Promise<Object>}
+   */
+  async _fetchIndex() {
+    const res = await fetch(`${this.apiUrl}/`)
+    if (!res.ok) throw new Error(`Registry request failed: ${res.status}`)
+    return res.json()
+  }
+
+  /**
+   * Check if a specific version exists on the remote.
+   * @param {string} name
+   * @param {string} version
+   * @returns {Promise<boolean>}
+   */
+  async exists(name, version) {
+    try {
+      const index = await this._fetchIndex()
+      return !!index[name]?.versions?.[version]
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Get all published versions for a package.
+   * @param {string} name
+   * @returns {Promise<Object>}
+   */
+  async getVersions(name) {
+    const index = await this._fetchIndex()
+    return index[name]?.versions || {}
+  }
+
+  /**
+   * Publish a foundation to the remote registry.
+   * Reads files from distDir, encodes as base64, and POSTs to the server.
+   *
+   * @param {string} name
+   * @param {string} version
+   * @param {string} distDir - Path to the foundation's dist/ directory
+   * @param {Object} [metadata] - Additional metadata
+   * @returns {Promise<{ name: string, version: string, filesCount: number }>}
+   */
+  async publish(name, version, distDir, metadata = {}) {
+    // Walk distDir recursively and encode files as base64
+    const files = {}
+    const entries = await readdir(distDir, { 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(distDir, fullPath)
+      const content = await readFile(fullPath)
+      files[relPath] = content.toString('base64')
+    }
+
+    const { editAccess, ...restMetadata } = metadata
+    const payload = { name, version, files, metadata: restMetadata }
+    if (editAccess) {
+      payload.editAccess = editAccess
+    }
+
+    const headers = { 'Content-Type': 'application/json' }
+    if (this.token) {
+      headers['Authorization'] = `Bearer ${this.token}`
+    }
+
+    const res = await fetch(`${this.apiUrl}/foundations`, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(payload),
+    })
+
+    const body = await res.json()
+
+    if (!res.ok) {
+      if (res.status === 409) {
+        throw Object.assign(new Error(body.error || `${name}@${version} already exists`), { code: 'CONFLICT' })
+      }
+      if (res.status === 401) {
+        throw Object.assign(new Error(body.error || 'Unauthorized'), { code: 'UNAUTHORIZED' })
+      }
+      throw new Error(body.error || `Server error (${res.status})`)
+    }
+
+    return body
+  }
+
+  /**
+   * Common fetch helper with auth headers.
+   * @param {string} url
+   * @param {Object} [options]
+   * @returns {Promise<Response>}
+   */
+  _authHeaders() {
+    const headers = { 'Content-Type': 'application/json' }
+    if (this.token) {
+      headers['Authorization'] = `Bearer ${this.token}`
+    }
+    return headers
+  }
+
+  /**
+   * Create a foundation invite.
+   * @param {string} foundationName
+   * @param {Object} payload - { email, majorVersion, maxUses?, expiresInDays? }
+   * @returns {Promise<Object>}
+   */
+  async createInvite(foundationName, payload) {
+    const res = await fetch(`${this.apiUrl}/api/foundations/${foundationName}/invites`, {
+      method: 'POST',
+      headers: this._authHeaders(),
+      body: JSON.stringify(payload),
+    })
+    const body = await res.json()
+    if (!res.ok) {
+      throw Object.assign(new Error(body.error || `Server error (${res.status})`), { statusCode: res.status })
+    }
+    return body
+  }
+
+  /**
+   * List invites for a foundation.
+   * @param {string} foundationName
+   * @returns {Promise<Array>}
+   */
+  async listInvites(foundationName) {
+    const res = await fetch(`${this.apiUrl}/api/foundations/${foundationName}/invites`, {
+      headers: this._authHeaders(),
+    })
+    const body = await res.json()
+    if (!res.ok) {
+      throw Object.assign(new Error(body.error || `Server error (${res.status})`), { statusCode: res.status })
+    }
+    return body.invites || []
+  }
+
+  /**
+   * Revoke a foundation invite.
+   * @param {string} foundationName
+   * @param {string} inviteId
+   * @returns {Promise<Object>}
+   */
+  async revokeInvite(foundationName, inviteId) {
+    const res = await fetch(`${this.apiUrl}/api/foundations/${foundationName}/invites/${inviteId}`, {
+      method: 'DELETE',
+      headers: this._authHeaders(),
+    })
+    const body = await res.json()
+    if (!res.ok) {
+      throw Object.assign(new Error(body.error || `Server error (${res.status})`), { statusCode: res.status })
+    }
+    return body
+  }
+
+  /**
+   * Resend a foundation invite.
+   * @param {string} foundationName
+   * @param {string} inviteId
+   * @returns {Promise<Object>}
+   */
+  async resendInvite(foundationName, inviteId) {
+    const res = await fetch(`${this.apiUrl}/api/foundations/${foundationName}/invites/${inviteId}/resend`, {
+      method: 'POST',
+      headers: this._authHeaders(),
+    })
+    const body = await res.json()
+    if (!res.ok) {
+      throw Object.assign(new Error(body.error || `Server error (${res.status})`), { statusCode: res.status })
+    }
+    return body
+  }
+
+  /**
+   * Create a site record on Unicloud.
+   * @param {string} siteId
+   * @param {Object} options
+   * @param {Object} options.foundation - { name }
+   * @returns {Promise<Object>}
+   */
+  async createSite(siteId, { foundation }) {
+    const res = await fetch(`${this.apiUrl}/api/sites`, {
+      method: 'POST',
+      headers: this._authHeaders(),
+      body: JSON.stringify({ siteId, foundation }),
+    })
+    const body = await res.json()
+    if (!res.ok) {
+      throw Object.assign(new Error(body.error || `Server error (${res.status})`), { statusCode: res.status })
+    }
+    return body
+  }
+
+  /**
+   * Transfer site ownership.
+   * @param {string} siteId
+   * @param {string} newOwner - Email of the new owner
+   * @returns {Promise<Object>}
+   */
+  async transferSiteOwnership(siteId, newOwner) {
+    const res = await fetch(`${this.apiUrl}/api/sites/${siteId}/owner`, {
+      method: 'PATCH',
+      headers: this._authHeaders(),
+      body: JSON.stringify({ newOwner }),
+    })
+    const body = await res.json()
+    if (!res.ok) {
+      throw Object.assign(new Error(body.error || `Server error (${res.status})`), { statusCode: res.status })
+    }
+    return body
+  }
+}

package/src/utils/update-check.js

@@ -0,0 +1,105 @@
+/**
+ * Lightweight Update Notification
+ *
+ * Checks the npm registry for newer versions of the CLI.
+ * Runs at most once per day, caches results in ~/.uniweb/update-check.json.
+ * Uses Node 20+ built-in fetch — no external dependencies.
+ */
+
+import { homedir } from 'node:os'
+import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+const CHECK_INTERVAL = 24 * 60 * 60 * 1000 // 1 day
+const STATE_DIR = join(homedir(), '.uniweb')
+const STATE_FILE = join(STATE_DIR, 'update-check.json')
+
+/**
+ * Compare two semver strings.
+ * Returns 1 if a > b, -1 if a < b, 0 if equal.
+ */
+function compareSemver(a, b) {
+  const pa = a.split('.').map(Number)
+  const pb = b.split('.').map(Number)
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] || 0) > (pb[i] || 0)) return 1
+    if ((pa[i] || 0) < (pb[i] || 0)) return -1
+  }
+  return 0
+}
+
+/**
+ * Read cached update check state.
+ */
+function readState() {
+  try {
+    if (existsSync(STATE_FILE)) {
+      return JSON.parse(readFileSync(STATE_FILE, 'utf8'))
+    }
+  } catch { /* ignore corrupt cache */ }
+  return {}
+}
+
+/**
+ * Write update check state to disk.
+ */
+function writeState(state) {
+  try {
+    if (!existsSync(STATE_DIR)) mkdirSync(STATE_DIR, { recursive: true })
+    writeFileSync(STATE_FILE, JSON.stringify(state))
+  } catch { /* ignore write errors */ }
+}
+
+/**
+ * Print update notification to stderr (doesn't interfere with piped output).
+ */
+function printNotification(current, latest) {
+  const yellow = '\x1b[33m'
+  const cyan = '\x1b[36m'
+  const dim = '\x1b[2m'
+  const reset = '\x1b[0m'
+  console.error('')
+  console.error(`${yellow}Update available:${reset} ${dim}${current}${reset} → ${cyan}${latest}${reset}`)
+  console.error(`${dim}Run${reset} npm i -g uniweb ${dim}to update${reset}`)
+}
+
+/**
+ * Start a non-blocking update check.
+ *
+ * Returns a function that, when called (optionally awaited), prints
+ * the notification if a newer version was found.
+ *
+ * @param {string} currentVersion - The currently running CLI version
+ * @returns {Function} Call at the end of command execution to show notification
+ */
+export function startUpdateCheck(currentVersion) {
+  let notification = null
+  const state = readState()
+
+  // Use cached result if checked recently
+  if (state.lastCheck && (Date.now() - state.lastCheck) < CHECK_INTERVAL) {
+    if (state.latestVersion && compareSemver(state.latestVersion, currentVersion) > 0) {
+      notification = state.latestVersion
+    }
+    return () => {
+      if (notification) printNotification(currentVersion, notification)
+    }
+  }
+
+  // Background fetch (non-blocking)
+  const fetchPromise = fetch('https://registry.npmjs.org/uniweb/latest')
+    .then(r => r.json())
+    .then(data => {
+      const latest = data.version
+      writeState({ lastCheck: Date.now(), latestVersion: latest })
+      if (compareSemver(latest, currentVersion) > 0) {
+        notification = latest
+      }
+    })
+    .catch(() => { /* network error — ignore silently */ })
+
+  return async () => {
+    await fetchPromise
+    if (notification) printNotification(currentVersion, notification)
+  }
+}

package/src/versions.js

@@ -61,7 +61,7 @@ export function getResolvedVersions() {
   if (resolvedVersions) return resolvedVersions
 
   const pkg = getCliPackageJson()
-  const deps = { ...pkg.dependencies, ...pkg.devDependencies }
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies, ...pkg.peerDependencies }
 
   // All @uniweb/* packages are now direct dependencies of the CLI.
   // When publishing with pnpm, workspace:* gets resolved to actual versions.