uniweb 0.8.14 → 0.8.16

package/src/commands/invite.js

@@ -0,0 +1,326 @@
+/**
+ * Invite Command
+ *
+ * Creates, lists, revokes, and resends foundation invites.
+ *
+ * Usage:
+ *   uniweb invite <email>                     # Create invite (1 use, 30 days)
+ *   uniweb invite <email> --uses 5            # Multi-use invite
+ *   uniweb invite <email> --expires 60        # 60-day expiry
+ *   uniweb invite --list                      # List invites for your foundation
+ *   uniweb invite --revoke <inviteId>         # Revoke an invite
+ *   uniweb invite --resend <inviteId>         # Resend an invite
+ */
+
+import { existsSync } from 'node:fs'
+import { readFile } from 'node:fs/promises'
+import { resolve, join } from 'node:path'
+import { execSync } from 'node:child_process'
+
+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. '--uses'
+ * @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 publish.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} invite ...${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}\`invite\` lets you authorize a client to create sites with your${colors.reset}`)
+  console.log(`  ${colors.dim}foundation — they get their own site, set up automatically.${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, role: schema._self?.role }
+  } 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: 'Creating invite' })
+
+  const registryUrl = parseFlag(args, '--registry')
+  const url = registryUrl || process.env.UNIWEB_REGISTRY_URL || 'http://localhost:4001'
+
+  return new RemoteRegistry(url, token)
+}
+
+/**
+ * Handle --list flag.
+ */
+async function handleList(args) {
+  const foundationDir = await resolveFoundationDir(args)
+  const { name } = await readSchema(foundationDir)
+  const registry = await createRegistry(args)
+
+  info(`Listing invites for ${colors.bright}${name}${colors.reset}...`)
+
+  try {
+    const invites = await registry.listInvites(name)
+
+    if (invites.length === 0) {
+      console.log(`\n  No invites found for ${name}.`)
+      return
+    }
+
+    console.log('')
+    for (const inv of invites) {
+      const statusColor = inv.status === 'active' ? colors.green
+        : inv.status === 'revoked' ? colors.red
+        : colors.yellow
+      console.log(`  ${statusColor}${inv.status}${colors.reset}  ${inv.email}  v${inv.majorVersion}  ${inv.usedCount}/${inv.maxUses} uses  ${colors.dim}${inv.inviteId}${colors.reset}`)
+    }
+    console.log('')
+  } catch (err) {
+    error(err.message)
+    process.exit(1)
+  }
+}
+
+/**
+ * Handle --revoke flag.
+ */
+async function handleRevoke(args, inviteId) {
+  const foundationDir = await resolveFoundationDir(args)
+  const { name } = await readSchema(foundationDir)
+  const registry = await createRegistry(args)
+
+  info(`Revoking invite ${colors.dim}${inviteId}${colors.reset}...`)
+
+  try {
+    const result = await registry.revokeInvite(name, inviteId)
+    console.log('')
+    success(`Revoked invite for ${colors.bright}${result.email}${colors.reset}`)
+  } catch (err) {
+    error(err.message)
+    process.exit(1)
+  }
+}
+
+/**
+ * Handle --resend flag.
+ */
+async function handleResend(args, inviteId) {
+  const foundationDir = await resolveFoundationDir(args)
+  const { name } = await readSchema(foundationDir)
+  const registry = await createRegistry(args)
+
+  info(`Resending invite ${colors.dim}${inviteId}${colors.reset}...`)
+
+  try {
+    const result = await registry.resendInvite(name, inviteId)
+    console.log('')
+    success(`Resent invite to ${colors.bright}${result.email}${colors.reset}`)
+  } catch (err) {
+    error(err.message)
+    process.exit(1)
+  }
+}
+
+/**
+ * Handle create invite (default action).
+ */
+async function handleCreate(args, email) {
+  const foundationDir = await resolveFoundationDir(args)
+  const { name, version, role } = await readSchema(foundationDir)
+  const registry = await createRegistry(args)
+
+  // Parse options
+  const versionFlag = parseFlag(args, '--version')
+  const majorVersion = versionFlag
+    ? parseInt(versionFlag, 10)
+    : parseInt(version.split('.')[0], 10)
+
+  const usesFlag = parseFlag(args, '--uses')
+  const maxUses = usesFlag ? parseInt(usesFlag, 10) : 1
+
+  const expiresFlag = parseFlag(args, '--expires')
+  const expiresInDays = expiresFlag ? parseInt(expiresFlag, 10) : 30
+
+  if (isNaN(majorVersion)) {
+    error('Could not determine major version. Use --version to specify.')
+    process.exit(1)
+  }
+
+  info(`Creating invite for ${colors.bright}${email}${colors.reset} → ${name} v${majorVersion}...`)
+
+  try {
+    const invite = await registry.createInvite(name, {
+      email,
+      majorVersion,
+      maxUses,
+      expiresInDays,
+    })
+
+    const isExtension = role === 'extension'
+
+    console.log('')
+    success(`Invite created`)
+    console.log('')
+    console.log(`  ${colors.dim}ID:${colors.reset}       ${invite.inviteId}`)
+    console.log(`  ${colors.dim}To:${colors.reset}       ${invite.email}`)
+    console.log(`  ${colors.dim}For:${colors.reset}      ${name} v${invite.majorVersion}${isExtension ? '  (extension)' : ''}`)
+    console.log(`  ${colors.dim}Uses:${colors.reset}     ${invite.maxUses}`)
+    console.log(`  ${colors.dim}Expires:${colors.reset}  ${new Date(invite.expiresAt).toLocaleDateString()}`)
+    console.log(`  ${colors.dim}Link:${colors.reset}     ${colors.cyan}${registry.apiUrl}/invite/${invite.inviteId}${colors.reset}`)
+    console.log('')
+    if (isExtension) {
+      console.log(`  ${colors.dim}When ${invite.email} adds ${name} to their site${colors.reset}`)
+      console.log(`  ${colors.dim}on uniweb.app or Studio, it will be authorized automatically.${colors.reset}`)
+    } else {
+      console.log(`  ${colors.dim}When ${invite.email} creates a site with ${name}${colors.reset}`)
+      console.log(`  ${colors.dim}on uniweb.app or Studio, it will be authorized automatically.${colors.reset}`)
+    }
+  } catch (err) {
+    error(err.message)
+    process.exit(1)
+  }
+}
+
+/**
+ * Main invite command handler.
+ */
+export async function invite(args = []) {
+  // Dispatch based on flags
+  if (args.includes('--list')) {
+    await handleList(args)
+    return
+  }
+
+  const revokeId = parseFlag(args, '--revoke')
+  if (revokeId) {
+    await handleRevoke(args, revokeId)
+    return
+  }
+
+  const resendId = parseFlag(args, '--resend')
+  if (resendId) {
+    await handleResend(args, resendId)
+    return
+  }
+
+  // Default: create invite — first positional arg is the email
+  const email = args.find(a => !a.startsWith('--') && a.includes('@'))
+  if (!email) {
+    error('Email is required.')
+    console.log('')
+    console.log(`  ${colors.dim}Usage: ${getCliPrefix()} invite <email> [--uses N] [--expires N]${colors.reset}`)
+    console.log(`  ${colors.dim}       ${getCliPrefix()} invite --list${colors.reset}`)
+    console.log(`  ${colors.dim}       ${getCliPrefix()} invite --revoke <id>${colors.reset}`)
+    console.log(`  ${colors.dim}       ${getCliPrefix()} invite --resend <id>${colors.reset}`)
+    process.exit(1)
+  }
+
+  await handleCreate(args, email)
+}
+
+export default invite

package/src/commands/login.js

@@ -0,0 +1,87 @@
+/**
+ * Login Command
+ *
+ * Authenticates with the Uniweb platform. Stores credentials at ~/.uniweb/auth.json.
+ *
+ * Phase 1: Token-paste flow only.
+ * Phase 2: Browser-based OAuth with token-paste fallback.
+ *
+ * Usage:
+ *   uniweb login
+ */
+
+import prompts from 'prompts'
+import { writeAuth, readAuth, isExpired } from '../utils/auth.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}`)
+}
+
+/**
+ * Main login command handler
+ */
+export async function login(args = []) {
+  // Check if already logged in
+  const existing = await readAuth()
+  if (existing && !isExpired(existing)) {
+    console.log(`Already logged in as ${colors.bright}${existing.email}${colors.reset}`)
+    console.log(`${colors.dim}Run \`uniweb login\` again to switch accounts.${colors.reset}`)
+    console.log('')
+  }
+
+  console.log('Log in to your Uniweb account at uniweb.app.')
+  console.log('')
+
+  // Phase 1: token-paste flow
+  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 (from uniweb.app/cli-login):',
+      validate: (v) => (v ? true : 'Token is required'),
+    },
+  ], {
+    onCancel: () => {
+      console.log('\nLogin cancelled.')
+      process.exit(0)
+    },
+  })
+
+  if (!response.email || !response.token) {
+    error('Login cancelled.')
+    process.exit(1)
+  }
+
+  // Store credentials
+  await writeAuth({
+    token: response.token,
+    email: response.email,
+    expiresAt: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString(),
+  })
+
+  console.log('')
+  success(`Logged in as ${colors.bright}${response.email}${colors.reset}`)
+}
+
+export default login

package/src/commands/publish.js

@@ -0,0 +1,300 @@
+/**
+ * Publish Command
+ *
+ * Publishes a foundation to the Uniweb Registry.
+ *
+ * Usage:
+ *   uniweb publish                          # Publish to remote registry
+ *   uniweb publish --local                  # Publish to local registry (.unicloud/)
+ *   uniweb publish --registry <url>         # Publish to a specific registry URL
+ *   uniweb publish --edit-access open       # Anyone can edit in Studio (default: restricted)
+ *   uniweb publish --dry-run                # Show what would be published
+ */
+
+import { existsSync } from 'node:fs'
+import { readFile } from 'node:fs/promises'
+import { resolve, join } from 'node:path'
+import { execSync } from 'node:child_process'
+
+import { createLocalRegistry, RemoteRegistry } from '../utils/registry.js'
+import { ensureAuth, readAuth } from '../utils/auth.js'
+import { findWorkspaceRoot, findFoundations, findSites, 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 foundation directory to publish.
+ *
+ * Priority:
+ * 1. In a foundation directory → use it
+ * 2. At workspace root, one foundation → use it
+ * 3. At workspace root, multiple → prompt (or error if non-interactive)
+ * 4. No foundation → educational error
+ *
+ * @param {string[]} args
+ * @returns {Promise<string>} Absolute path to the foundation directory
+ */
+async function resolveFoundationDir(args) {
+  const cwd = process.cwd()
+  const prefix = getCliPrefix()
+
+  // Check if current directory is a foundation
+  const type = await classifyPackage(cwd)
+  if (type === 'foundation') {
+    return cwd
+  }
+
+  // Check workspace
+  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 to publish.')
+        console.log('')
+        for (const f of foundations) {
+          console.log(`  ${colors.cyan}cd ${f} && ${prefix} publish${colors.reset}`)
+        }
+        process.exit(1)
+      }
+
+      const choice = await promptSelect('Which foundation?', foundations)
+      if (!choice) {
+        console.log('\nPublish cancelled.')
+        process.exit(0)
+      }
+      return resolve(workspaceRoot, choice)
+    }
+  }
+
+  // No foundation found — educational error
+  error('No foundation found in this workspace.')
+  console.log('')
+  console.log(`  ${colors.dim}\`publish\` registers your foundation so clients you invite can${colors.reset}`)
+  console.log(`  ${colors.dim}create and manage their own sites with it.${colors.reset}`)
+  console.log('')
+  console.log(`  ${colors.dim}To publish, run this command from a foundation directory, or from a${colors.reset}`)
+  console.log(`  ${colors.dim}workspace root that contains a foundation.${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]
+}
+
+/**
+ * Parse --edit-access <policy> from args.
+ * @param {string[]} args
+ * @returns {'open'|'restricted'|null}
+ */
+function parseEditAccess(args) {
+  const idx = args.indexOf('--edit-access')
+  if (idx === -1 || !args[idx + 1]) return null
+  const value = args[idx + 1]
+  if (value !== 'open' && value !== 'restricted') {
+    error(`Invalid --edit-access value: "${value}". Must be "open" or "restricted".`)
+    process.exit(1)
+  }
+  return value
+}
+
+/**
+ * Main publish command handler
+ */
+export async function publish(args = []) {
+  const isLocal = args.includes('--local')
+  const isDryRun = args.includes('--dry-run')
+  const registryUrl = parseRegistryUrl(args)
+  const editAccess = parseEditAccess(args)
+
+  // 1. Resolve foundation directory
+  const foundationDir = await resolveFoundationDir(args)
+
+  // Verify it's actually a foundation (has src/foundation.js)
+  if (!existsSync(join(foundationDir, 'src', 'foundation.js'))) {
+    error('Not a foundation directory (no src/foundation.js)')
+    process.exit(1)
+  }
+
+  // 2. Auto-build if dist/ is missing
+  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)
+    }
+  }
+
+  // 3. Read name and version from meta/schema.json
+  let schema
+  try {
+    schema = JSON.parse(await readFile(schemaJson, 'utf8'))
+  } catch (err) {
+    error(`Failed to read dist/meta/schema.json: ${err.message}`)
+    process.exit(1)
+  }
+
+  const name = schema._self?.name
+  const version = schema._self?.version
+
+  if (!name || !version) {
+    error('dist/meta/schema.json missing _self.name or _self.version')
+    console.log(`${colors.dim}  Ensure your package.json has "name" and "version" fields.${colors.reset}`)
+    process.exit(1)
+  }
+
+  // 4. Create registry (local or remote)
+  const isRemote = !isLocal
+  let registry
+
+  if (isLocal) {
+    registry = createLocalRegistry(foundationDir)
+  } else {
+    // Remote publish — ensure authenticated (inline login if needed)
+    const token = await ensureAuth({ command: 'Publishing' })
+
+    const url = registryUrl || process.env.UNIWEB_REGISTRY_URL || 'http://localhost:4001'
+    registry = new RemoteRegistry(url, token)
+  }
+
+  const registryLabel = isLocal ? 'local registry' : `registry`
+
+  // 5. Check for duplicates
+  if (await registry.exists(name, version)) {
+    console.log('')
+    error(`${colors.bright}${name}@${version}${colors.reset} is already published.`)
+    console.log('')
+    console.log(`  Bump the version in foundation.js to publish an update:`)
+    console.log(`    ${colors.dim}export const version = '${bumpPatch(version)}'${colors.reset}`)
+    process.exit(1)
+  }
+
+  // 6. Dry-run check
+  if (isDryRun) {
+    console.log('')
+    info(`Would publish ${colors.bright}${name}@${version}${colors.reset} to ${registryLabel}`)
+    console.log(`  ${colors.dim}Source: ${distDir}${colors.reset}`)
+    if (isLocal) {
+      console.log(`  ${colors.dim}Target: ${registry.getPackagePath(name, version)}${colors.reset}`)
+    } else {
+      console.log(`  ${colors.dim}Target: ${registry.apiUrl}${colors.reset}`)
+    }
+    return
+  }
+
+  // 7. Publish
+  info(`Publishing ${colors.bright}${name}@${version}${colors.reset} to ${registryLabel}...`)
+
+  // Resolve the publisher's identity
+  const auth = isLocal ? null : await readAuth()
+  const publishMetadata = {
+    publishedBy: auth?.email || (isLocal ? 'local' : 'cli'),
+  }
+  if (editAccess) {
+    publishMetadata.editAccess = editAccess
+  }
+
+  try {
+    await registry.publish(name, version, distDir, publishMetadata)
+  } catch (err) {
+    if (err.code === 'CONFLICT') {
+      error(`${colors.bright}${name}@${version}${colors.reset} already exists on the registry.`)
+      console.log(`  Bump the version in foundation.js to publish an update.`)
+      process.exit(1)
+    }
+    if (err.code === 'UNAUTHORIZED') {
+      error('Authentication failed.')
+      console.log(`  Run ${colors.cyan}${getCliPrefix()} login${colors.reset} to refresh your credentials.`)
+      process.exit(1)
+    }
+    throw err
+  }
+
+  const prefix = getCliPrefix()
+  const isExtension = schema._self?.role === 'extension'
+  console.log('')
+  success(`Published ${colors.bright}${name}@${version}${colors.reset}${isExtension ? '  (extension)' : ''}`)
+  if (editAccess) {
+    console.log(`  ${colors.dim}Edit access: ${editAccess}${colors.reset}`)
+  }
+
+  // Cross-promotion: working with clients (remote only), deploy (if workspace has a site)
+  if (isRemote) {
+    console.log('')
+    if (isExtension) {
+      console.log(`  ${colors.bright}Authorize a client to use this extension:${colors.reset}`)
+      console.log(`    ${colors.bright}${prefix} invite <email>${colors.reset}    Client adds this extension to their site`)
+    } else {
+      console.log(`  ${colors.bright}Working with clients:${colors.reset}`)
+      console.log(`    ${colors.bright}${prefix} invite <email>${colors.reset}    Client creates their own site with your foundation`)
+      console.log(`    ${colors.bright}${prefix} handoff <email>${colors.reset}   Create a web or local site and hand it off to a client`)
+    }
+  }
+  const workspaceRoot = findWorkspaceRoot(foundationDir)
+  if (workspaceRoot) {
+    const sites = await findSites(workspaceRoot)
+    if (sites.length > 0) {
+      console.log('')
+      console.log(`  ${colors.dim}Tip: Run \`${prefix} deploy\` for a conventional static bundle deployment.${colors.reset}`)
+    }
+  }
+}
+
+/**
+ * Bump the patch version of a semver string.
+ * @param {string} version - e.g. "1.0.0"
+ * @returns {string} - e.g. "1.0.1"
+ */
+function bumpPatch(version) {
+  const parts = version.split('.')
+  if (parts.length !== 3) return version
+  parts[2] = String(Number(parts[2]) + 1)
+  return parts.join('.')
+}
+
+export default publish