uniweb 1.1.0 → 1.2.1

package/src/commands/status.js

@@ -7,15 +7,17 @@
  * `uniweb push` runs) — no auth, no backend round-trip.
  *
  * `--remote` adds the backend signals (may prompt for login, like `git fetch`):
- *   - whether the synced draft differs from what's live (publish needed), and
- *   - whether a newer foundation version is registered than the site pins.
+ *   - whether the synced draft differs from what's live (publish needed),
+ *   - whether a newer foundation version is registered than the site pins, and
+ *   - who has the site open in the app right now, and on what (`describeEditors`).
  * Those use ASSUMED endpoints (see kb shipping-verbs-and-freshness.md §6.5); until
  * the backend exposes them, `--remote` degrades silently to the local view.
  *
  * Usage:
  *   uniweb status            Sync identity + unpushed content + foundation ref (local)
  *   uniweb status --remote   Also: whether the backend still holds the site, draft-vs-live,
- *                            and a newer-registered-foundation check
+ *                            a newer-registered-foundation check, and who has it open in
+ *                            the app
  *   uniweb status --json     One JSON line (adds a `remote` object under --remote, whose
  *                            `site_state` is live / gone / unknown — `gone` only on the
  *                            backend's own word that it holds no such site)
@@ -28,7 +30,7 @@ import { join } from 'node:path'
 import yaml from 'js-yaml'
 
 import { resolveSiteDir } from './deploy.js'
-import { probeUnpushed } from '../backend/site-sync.js'
+import { probeUnpushed, readItemUuids, unitFilesOf } from '../backend/site-sync.js'
 import { resolveWorkspace } from '../backend/workspace.js'
 import {
   BackendClient,
@@ -75,6 +77,79 @@ function foundationRef(siteYml) {
   return typeof f === 'string' ? f : f.ref || null
 }
 
+// What an item that this copy has not synced is called — by its Section on the site.
+const ITEM_KIND = { pages: 'a page', page_sections: 'a section', layout_sections: 'a layout section' }
+
+/**
+ * Who has the site open in the app right now, and on what — the status's `editors`
+ * (backend, since 2026-10-13), as lines a developer can follow up on. Each tab's item is
+ * named by the file it is in this copy, and by its kind and route when this copy has not
+ * synced it (`fileByItemUuid`).
+ *
+ * ⛔ Two ways not to read it. `changed_at` is the item's last change by ANYONE — this
+ * author, another, a push — so it says when the item last changed, never what this
+ * person did. And it is presence, not a lock: nothing refuses or warns a push over it.
+ *
+ * @param {object[]} editors - `[{ person: { uuid, handle, brief }, tabs: [{ page, item }] }]`
+ * @param {object} [opts]
+ * @param {(uuid: string) => string|null} [opts.fileOf] - an item's file in this copy
+ * @param {number} [opts.now] - for "3 min ago"
+ * @returns {{ person: string, tabs: string[] }[]} a tab with nothing open is left out
+ */
+export function describeEditors(editors, { fileOf = () => null, now = Date.now() } = {}) {
+  return editors.map((editor) => ({
+    person: personLabel(editor?.person),
+    tabs: (editor?.tabs || []).map((tab) => tabLabel(tab, fileOf, now)).filter(Boolean)
+  }))
+}
+
+function personLabel(person) {
+  const name = person?.brief?.display_name
+  const handle = person?.handle ? `@${person.handle}` : null
+  if (name && handle) return `${name} (${handle})`
+  return name || handle || `someone (${person?.uuid || 'unnamed'})`
+}
+
+function tabLabel(tab, fileOf, now) {
+  const item = tab?.item
+  if (!item?.uuid) return null
+  const route = tab.page?.route || null
+  const file = fileOf(item.uuid)
+  const what = file
+    ? `${file}${route ? ` (${route})` : ''}`
+    : `${ITEM_KIND[item.section] || 'an item'} not in this copy${route ? ` (${route})` : ''}`
+  const when = sinceLabel(item.changed_at, now)
+  return when ? `${what} · changed ${when}` : what
+}
+
+function sinceLabel(iso, now) {
+  const t = Date.parse(iso)
+  if (Number.isNaN(t)) return null
+  const min = Math.floor(Math.max(0, now - t) / 60_000)
+  if (min < 1) return 'just now'
+  if (min < 60) return `${min} min ago`
+  const h = Math.floor(min / 60)
+  if (h < 24) return `${h} h ago`
+  const d = Math.floor(h / 24)
+  return `${d} day${d === 1 ? '' : 's'} ago`
+}
+
+/**
+ * An item's file in this copy, from its uuid: `sync.json` keeps each unit's uuid on
+ * `backend` by its path (`items`, banked from every push and pull), and `unitFilesOf`
+ * finds the file the author keeps it in (`1-hero.md` for `hero.md`). Null for an item
+ * this copy has not synced — one added in the app since its last pull.
+ */
+export function fileByItemUuid(siteDir, backend) {
+  const unitOf = new Map(
+    Object.entries(readItemUuids(siteDir, backend)).map(([unit, uuid]) => [String(uuid).toLowerCase(), unit])
+  )
+  return (uuid) => {
+    const unit = unitOf.get(String(uuid).toLowerCase())
+    return unit ? (unitFilesOf(siteDir, unit)[0] ?? unit) : null
+  }
+}
+
 // A versioned registry ref `@org/name@1.2.3` → its scoped name `@org/name` and
 // pinned version `1.2.3`. A bare/local/unversioned ref → nulls.
 function splitFoundationRef(fnd) {
@@ -263,6 +338,20 @@ export async function status(args = []) {
         )
       }
     }
+    // An array is the backend's answer, `[]` included; no key is a backend that does not
+    // say, and then neither do we.
+    if (Array.isArray(site?.editors)) {
+      if (!site.editors.length) {
+        say.dim('Nobody has this site open in the app.')
+      } else {
+        say.info('Open in the app now:')
+        const fileOf = fileByItemUuid(siteDir, probeBackend)
+        for (const { person, tabs } of describeEditors(site.editors, { fileOf })) {
+          console.log(`    ${person}${tabs.length ? '' : ', with nothing open'}`)
+          for (const tab of tabs) console.log(`      ${c.dim}${tab}${c.reset}`)
+        }
+      }
+    }
     if (
       fdnLatest?.latest_version &&
       fndVersion &&

package/src/framework-index.json

@@ -1,12 +1,12 @@
 {
   "schemaVersion": 1,
-  "generatedAt": "2026-10-13T18:18:01.170Z",
+  "generatedAt": "2026-10-14T18:03:31.718Z",
   "packages": {
     "@uniweb/api": {
-      "version": "1.1.0"
+      "version": "1.1.1"
     },
     "@uniweb/build": {
-      "version": "1.1.0"
+      "version": "1.1.1"
     },
     "@uniweb/content-reader": {
       "version": "1.2.8"

package/src/utils/config.js

@@ -18,10 +18,16 @@ import { existsSync, readFileSync } from 'node:fs'
 import { readFile, writeFile } from 'node:fs/promises'
 import { join } from 'node:path'
 import { homedir } from 'node:os'
-import yaml from 'js-yaml'
 import { filterCmd } from './pm.js'
 import { writeJsonPreservingStyleAsync } from './json-file.js'
 import { loggedInOriginOf, readSessionFileSync } from './session-file.js'
+import {
+  WORKSPACE_FILE,
+  readWorkspacePatterns,
+  patternsCover,
+  editWorkspaceFilePackages,
+  renderWorkspaceFile
+} from './workspace-packages.js'
 
 // ── Backend origin ─────────────────────────────────────────────
 
@@ -214,59 +220,88 @@ export const DEFAULT_BACKEND_ORIGIN = 'https://uniweb.app'
 /**
  * Read workspace package globs.
  * Tries pnpm-workspace.yaml first, falls back to package.json workspaces.
+ * The folders they name: `workspacePackages` (./workspace-packages.js).
  * @param {string} rootDir - Workspace root directory
  * @returns {Promise<{packages: string[]}>}
  */
 export async function readWorkspaceConfig(rootDir) {
-  // Try pnpm-workspace.yaml first
-  const configPath = join(rootDir, 'pnpm-workspace.yaml')
-  if (existsSync(configPath)) {
-    const content = await readFile(configPath, 'utf-8')
-    const config = yaml.load(content)
-    return { packages: config?.packages || [] }
-  }
-
-  // Fall back to package.json workspaces
-  const pkg = await readRootPackageJson(rootDir)
-  if (Array.isArray(pkg.workspaces)) {
-    return { packages: pkg.workspaces }
-  }
-
-  return { packages: [] }
+  return { packages: readWorkspacePatterns(rootDir).patterns }
 }
 
 /**
- * Write pnpm-workspace.yaml
+ * Make the folder at `relPath` a workspace package.
+ *
+ * Nothing is written for a folder a pattern already covers — it is a package
+ * already. ⛔ Until 2026-10-13 its own path was added beside the pattern, and
+ * discovery listed it twice. Otherwise `entry` — the folder itself, unless a
+ * pattern is given for it — is added to each manifest that does not cover it:
+ *
+ * - pnpm-workspace.yaml's `packages:` list, edited in place: comments and every
+ *   other key stay as they were. ⛔ Until 2026-10-13 the file was rewritten from
+ *   its `packages` alone, deleting `onlyBuiltDependencies` and `allowBuilds` with
+ *   the comments that explain them. A workspace without the file (a blank one, at
+ *   its first `add`) gets it from the workspace template, as `create` writes it.
+ * - package.json's `workspaces`, which npm and yarn read.
+ *
  * @param {string} rootDir - Workspace root directory
- * @param {{packages: string[]}} config
+ * @param {string} relPath - The package's folder, workspace-relative
+ * @param {{ entry?: string }} [options] - `entry`: a pattern to list for it instead
  */
-export async function writeWorkspaceConfig(rootDir, config) {
-  const configPath = join(rootDir, 'pnpm-workspace.yaml')
-  const content = yaml.dump(config, { flowLevel: -1, quotingType: '"' })
-  await writeFile(configPath, content)
+export async function registerWorkspacePackage(rootDir, relPath, { entry = relPath } = {}) {
+  const { source, patterns } = readWorkspacePatterns(rootDir)
+  const ymlPath = join(rootDir, WORKSPACE_FILE)
+  if (!patternsCover(patterns, relPath)) {
+    if (source === WORKSPACE_FILE) {
+      const text = await readFile(ymlPath, 'utf-8')
+      await writeFile(ymlPath, editedWorkspaceFile(text, (list) => [...list, entry], entry))
+    } else {
+      await writeFile(ymlPath, renderWorkspaceFile([...patterns, entry]))
+    }
+  }
+
+  const pkg = await readRootPackageJson(rootDir)
+  const workspaces = Array.isArray(pkg.workspaces) ? pkg.workspaces : []
+  if (!patternsCover(workspaces, relPath)) {
+    pkg.workspaces = [...workspaces, entry]
+    await writeRootPackageJson(rootDir, pkg)
+  }
 }
 
 /**
- * Add a glob pattern to pnpm-workspace.yaml if not already present
- * @param {string} rootDir - Workspace root directory
- * @param {string} glob - Glob pattern to add
+ * A package folder moved from `oldPath` to `newPath`: rename its entry in each
+ * manifest that lists it by path — a pattern is left as written — then register
+ * the new path, in case it has moved out from under the pattern that covered it.
+ *
+ * @param {string} rootDir
+ * @param {string} oldPath
+ * @param {string} newPath
  */
-export async function addWorkspaceGlob(rootDir, glob) {
-  const config = await readWorkspaceConfig(rootDir)
-  if (!config.packages.includes(glob)) {
-    config.packages.push(glob)
-    await writeWorkspaceConfig(rootDir, config)
+export async function moveWorkspacePackage(rootDir, oldPath, newPath) {
+  const { source, patterns } = readWorkspacePatterns(rootDir)
+  if (source === WORKSPACE_FILE && patterns.includes(oldPath)) {
+    const ymlPath = join(rootDir, WORKSPACE_FILE)
+    const text = await readFile(ymlPath, 'utf-8')
+    const rename = (list) => list.map((p) => (p === oldPath ? newPath : p))
+    await writeFile(ymlPath, editedWorkspaceFile(text, rename, newPath))
   }
-
-  // Sync workspaces array in package.json (for npm compatibility)
   const pkg = await readRootPackageJson(rootDir)
-  if (!pkg.workspaces) {
-    pkg.workspaces = []
-  }
-  if (!pkg.workspaces.includes(glob)) {
-    pkg.workspaces.push(glob)
+  if (Array.isArray(pkg.workspaces) && pkg.workspaces.includes(oldPath)) {
+    pkg.workspaces = pkg.workspaces.map((p) => (p === oldPath ? newPath : p))
     await writeRootPackageJson(rootDir, pkg)
   }
+  await registerWorkspacePackage(rootDir, newPath)
+}
+
+/** The edited file, or an error that says what to add by hand — the file is never rewritten. */
+function editedWorkspaceFile(text, edit, entry) {
+  const next = editWorkspaceFilePackages(text, edit)
+  if (next == null) {
+    throw new Error(
+      `Could not edit the packages: list in ${WORKSPACE_FILE} in place, and it is not rewritten ` +
+        `whole. Add "${entry}" to it by hand.`
+    )
+  }
+  return next
 }
 
 /**
@@ -352,66 +387,39 @@ export function computeRootScripts(sites, pm = 'pnpm') {
  */
 export async function updateRootScripts(rootDir, sites, pm = 'pnpm') {
   const pkg = await readRootPackageJson(rootDir)
-  const newScripts = computeRootScripts(sites, pm)
+  const unique = sites.filter((s, i) => sites.findIndex((o) => o.path === s.path) === i)
+  const newScripts = computeRootScripts(unique, pm)
+  const scripts = { ...(pkg.scripts || {}) }
 
   // If we're adding a second site, rename existing dev/preview to dev:{firstName}
-  if (sites.length === 2 && pkg.scripts?.dev) {
-    const firstName = sites[0].name
+  if (unique.length === 2 && scripts.dev) {
+    const firstName = unique[0].name
     // Only rename if the existing dev script references the first site's name
-    if (pkg.scripts.dev.includes(firstName)) {
-      pkg.scripts[`dev:${firstName}`] = pkg.scripts.dev
-      pkg.scripts[`preview:${firstName}`] = pkg.scripts.preview
-    }
-  }
-
-  pkg.scripts = { ...pkg.scripts, ...newScripts }
-  await writeRootPackageJson(rootDir, pkg)
-}
-
-// Resolve a workspace glob pattern to actual directories
-export async function resolveGlob(rootDir, pattern) {
-  const clean = pattern.replace(/^["']|["']$/g, '')
-
-  if (clean.endsWith('/*')) {
-    // Pattern like "foundations/*" - list subdirectories
-    const baseDir = clean.slice(0, -2)
-    const fullPath = join(rootDir, baseDir)
-    if (!existsSync(fullPath)) return []
-    try {
-      const { readdirSync } = await import('node:fs')
-      const entries = readdirSync(fullPath, { withFileTypes: true })
-      return entries
-        .filter((e) => e.isDirectory() && !e.name.startsWith('.'))
-        .map((e) => join(baseDir, e.name))
-    } catch {
-      return []
+    if (scripts.dev.includes(firstName)) {
+      scripts[`dev:${firstName}`] = scripts.dev
+      scripts[`preview:${firstName}`] = scripts.preview
     }
   }
 
-  if (clean.startsWith('*/')) {
-    // Pattern like "*/foundation" - find subdirs with this child
-    const suffix = clean.slice(2)
-    const { readdirSync } = await import('node:fs')
-    try {
-      const entries = readdirSync(rootDir, { withFileTypes: true })
-      return entries
-        .filter(
-          (e) =>
-            e.isDirectory() &&
-            !e.name.startsWith('.') &&
-            e.name !== 'node_modules'
-        )
-        .filter((e) => existsSync(join(rootDir, e.name, suffix)))
-        .map((e) => join(e.name, suffix))
-    } catch {
-      return []
-    }
+  // ⭐ The per-site scripts this CLI writes are regenerated from the sites there are
+  // now, and one it wrote for a site that is gone — renamed, moved, removed — goes.
+  // A script whose command is not one the CLI writes is the user's, and stays.
+  // ⛔ Until 2026-10-13 they were only ever added: after `rename site blog journal`,
+  // `dev:blog` still ran `uniweb dev blog`, a site that no longer existed.
+  for (const [key, value] of Object.entries(scripts)) {
+    if (key in newScripts) continue
+    const m = /^(dev|preview):(.+)$/.exec(key)
+    if (m && cliSiteScripts(m[1], m[2]).includes(value)) delete scripts[key]
   }
 
-  // Direct path like "foundation" or "site"
-  if (existsSync(join(rootDir, clean))) {
-    return [clean]
-  }
+  pkg.scripts = { ...scripts, ...newScripts }
+  await writeRootPackageJson(rootDir, pkg)
+}
 
-  return []
+/** Every command this CLI has written for the `dev:<site>` / `preview:<site>` script. */
+function cliSiteScripts(kind, site) {
+  return kind === 'dev'
+    ? [`uniweb dev ${site}`, filterCmd('pnpm', site, 'dev'), filterCmd('npm', site, 'dev')]
+    : [filterCmd('pnpm', site, 'preview'), filterCmd('npm', site, 'preview')]
 }
+

package/src/utils/discover.js

@@ -24,7 +24,7 @@ import { existsSync } from 'node:fs'
 import { readFile } from 'node:fs/promises'
 import { join } from 'node:path'
 import { classifyPackage } from '@uniweb/build'
-import { readWorkspaceConfig, resolveGlob } from './config.js'
+import { workspacePackages } from './workspace-packages.js'
 
 /**
  * Discover foundations in the workspace.
@@ -45,30 +45,27 @@ export async function discoverSites(rootDir) {
 }
 
 async function discoverByKind(rootDir, kind) {
-  const { packages } = await readWorkspaceConfig(rootDir)
   const out = []
 
-  for (const pattern of packages) {
-    const dirs = await resolveGlob(rootDir, pattern)
-    for (const dir of dirs) {
-      const fullPath = join(rootDir, dir)
-      if (classifyPackage(fullPath) !== kind) continue
+  // The workspace's packages as pnpm reads its patterns — each folder once.
+  for (const dir of workspacePackages(rootDir)) {
+    const fullPath = join(rootDir, dir)
+    if (classifyPackage(fullPath) !== kind) continue
 
-      // Read package.json for the package name. Synthesize one from
-      // the directory if it's missing or malformed — we still want
-      // the package to surface in pickers.
-      const pkgPath = join(fullPath, 'package.json')
-      let name = dir.split('/').pop()
-      if (existsSync(pkgPath)) {
-        try {
-          const pkg = JSON.parse(await readFile(pkgPath, 'utf-8'))
-          if (pkg.name) name = pkg.name
-        } catch {
-          // keep directory-derived name
-        }
+    // Read package.json for the package name. Synthesize one from
+    // the directory if it's missing or malformed — we still want
+    // the package to surface in pickers.
+    const pkgPath = join(fullPath, 'package.json')
+    let name = dir.split('/').pop()
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(await readFile(pkgPath, 'utf-8'))
+        if (pkg.name) name = pkg.name
+      } catch {
+        // keep directory-derived name
       }
-      out.push({ name, path: dir })
     }
+    out.push({ name, path: dir })
   }
 
   return out

package/src/utils/placement.js

@@ -96,6 +96,12 @@ export const EXTENSION_KIND = {
  * @returns {{ relativePath: string, packageName: string }}
  */
 export function resolvePlacement(rootDir, name, opts, kind) {
+  // 0. `--project` names the folder itself (rule 4), so a name or a `--path` beside it
+  //    names a second one: refused, never ignored (`projectConflictLines`).
+  if (opts.project && (name || opts.path)) {
+    return { projectConflict: true, relativePath: null, packageName: null }
+  }
+
   // 1. --path is a PARENT directory. The folder is `<path>/<name>` if a
   //    name was given, or `<path>` itself if not (the path's last segment
   //    is then taken as the package name).
@@ -149,3 +155,52 @@ export function resolvePlacement(rootDir, name, opts, kind) {
     packageName: kind.defaultPkg
   }
 }
+
+/**
+ * What to say when `--project` came with a name or a `--path` — the first line an
+ * error, the rest the commands that do what was meant.
+ *
+ * `--project <p>` is the co-located shorthand: it places a project's one foundation
+ * at `<p>/src/` and its one site at `<p>/site/`, and names nothing else. A name beside
+ * it asks for a different folder, which naming the folder says plainly.
+ * ⛔ Until 2026-10-13 the name won without a word: `add site fitness --project
+ * memberships` created `fitness/` at the workspace root.
+ *
+ * @param {'foundation'|'site'|'extension'} kind
+ * @param {string|null} name - the name given, if any
+ * @param {{ project: string, path?: string }} opts
+ * @param {string} command - how to run the verb: `uniweb add site`, `uniweb clone <uuid>`
+ * @returns {string[]}
+ */
+export function projectConflictLines(kind, name, opts, command) {
+  const p = opts.project
+  if (!name) {
+    return [
+      `--project and --path both name the folder — use one.`,
+      `  ${command} --project ${p}      ${kind === 'site' ? `${p}/site/` : `${p}/src/`}`,
+      `  ${command} --path ${opts.path}`
+    ]
+  }
+  if (kind === 'extension') {
+    return [
+      `--project places a project's foundation or site; an extension goes in the folder you name.`,
+      `  ${command} ${p}/extensions/${name}`
+    ]
+  }
+  if (kind === 'site') {
+    return [
+      `--project ${p} places the project's one site, at ${p}/site/, and takes no name.`,
+      `For a site named "${name}" in ${p}, name its folder — a project with several sites keeps them in ${p}/sites/:`,
+      `  ${command} ${p}/sites/${name}`,
+      `Or the project's one site:`,
+      `  ${command} --project ${p}`
+    ]
+  }
+  return [
+    `--project ${p} places the project's foundation, at ${p}/src/, and takes no name.`,
+    `For a foundation named "${name}" in ${p}, name its folder:`,
+    `  ${command} ${p}/${name}`,
+    `Or the project's foundation:`,
+    `  ${command} --project ${p}`
+  ]
+}

package/src/utils/scaffold.js

@@ -37,7 +37,7 @@ export async function scaffoldWorkspace(targetDir, context, options = {}) {
   registerVersions(getVersionsForTemplates())
 
   // Skip pnpm-workspace.yaml for blank workspaces (no packages yet).
-  // The `add` command creates it on demand via addWorkspaceGlob().
+  // The `add` command creates it on demand (registerWorkspacePackage), from this template.
   // Without this, pnpm fails with ERR_PNPM_NO_IMPORTER_MANIFEST_FOUND
   // because an empty packages: [] makes pnpm search parent directories.
   const skip = context.workspaceGlobs?.length ? [] : ['pnpm-workspace.yaml']