uniweb 1.2.0 → 1.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uniweb",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "Create structured Vite + React sites with content/code separation",
   "type": "module",
   "bin": {
@@ -41,8 +41,8 @@
     "js-yaml": "^4.1.0",
     "prompts": "^2.4.2",
     "tar": "^7.0.0",
-    "@uniweb/content-writer": "~1.0.1",
     "@uniweb/core": "~1.1.0",
+    "@uniweb/content-writer": "~1.0.1",
     "@uniweb/semantic-parser": "~1.5.1",
     "@uniweb/schemas": "~1.0.1"
   },

package/src/backend/client.js

@@ -843,7 +843,9 @@ export class BackendClient {
    * shipped backend-side — collab backend↔framework):
    *   { published: boolean, last_pushed_at?: string, last_published_at?: string, draft_dirty?: boolean }
    * `draft_dirty` = never-published, or the synced draft changed since the last
-   * publish ("pushed but not published").
+   * publish ("pushed but not published"). Since 2026-10-13 it also carries `editors`:
+   * who has the site open in the app right now, and on what — `status --remote` shows
+   * it (`describeEditors`, commands/status.js).
    *
    * ⭐ **The backend also serves a LIVE-SITE record here, and nothing in this CLI reads
    * it yet** (shipped 2026-08-29; documented here so it is not lost twice):

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,9 +1,9 @@
 {
   "schemaVersion": 1,
-  "generatedAt": "2026-10-13T20:52:47.988Z",
+  "generatedAt": "2026-10-14T18:03:31.718Z",
   "packages": {
     "@uniweb/api": {
-      "version": "1.1.0"
+      "version": "1.1.1"
     },
     "@uniweb/build": {
       "version": "1.1.1"