@uniweb/build 0.18.4 → 0.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/build",
-  "version": "0.18.4",
+  "version": "0.19.0",
   "description": "Build tooling for the Uniweb Component Web Platform",
   "type": "module",
   "exports": {
@@ -59,16 +59,16 @@
     "js-yaml": "^4.1.0",
     "sharp": "^0.35.3",
     "yaml": "^2.5.0",
-    "@uniweb/schemas": "^0.2.10",
+    "@uniweb/content-writer": "^0.3.3",
+    "@uniweb/projections": "^0.2.8",
     "@uniweb/theming": "^0.1.15",
-    "@uniweb/projections": "^0.2.7",
-    "@uniweb/content-writer": "^0.3.3"
+    "@uniweb/schemas": "^0.2.10"
   },
   "optionalDependencies": {
     "@uniweb/content-reader": "^1.2.2",
+    "@uniweb/runtime": "^0.11.7",
     "@uniweb/schemas": "^0.2.10",
-    "@uniweb/runtime": "^0.11.4",
-    "@uniweb/semantic-parser": "^1.2.1"
+    "@uniweb/semantic-parser": "^1.2.2"
   },
   "peerDependencies": {
     "vite": "^5.0.0 || ^6.0.0 || ^7.0.0",
@@ -77,7 +77,7 @@
     "@tailwindcss/vite": "^4.0.0",
     "@vitejs/plugin-react": "^4.0.0 || ^5.0.0",
     "vite-plugin-svgr": "^4.0.0",
-    "@uniweb/core": "^0.8.4"
+    "@uniweb/core": "^0.8.5"
   },
   "peerDependenciesMeta": {
     "vite": {

package/src/site/deploy-config.js

@@ -110,6 +110,29 @@ function validate(doc, path) {
   if (doc.targets !== undefined && (typeof doc.targets !== 'object' || Array.isArray(doc.targets))) {
     throw new Error(`${path}: \`targets\` must be a map.`)
   }
+  // A site has exactly ONE Uniweb identity — `site.yml::$uuid`, a single scalar,
+  // set by the create and never moved. So two targets naming `host: uniweb` cannot
+  // both be coherent: whichever one `default:` selects is the site, and the other
+  // silently describes a site that does not exist. The per-target `backend` key
+  // makes that look expressible, which is exactly why it is worth rejecting rather
+  // than leaving to be discovered.
+  //
+  // *(Diego, 2026-08-12: multiple deploys are not expected in general, and are not
+  // allowed for Uniweb Cloud specifically — the only host that reads `$uuid` at
+  // all. Every other host is stateless from the CLI's side, so any number of those
+  // targets is fine.)*
+  if (doc.targets && typeof doc.targets === 'object' && !Array.isArray(doc.targets)) {
+    const uniwebTargets = Object.entries(doc.targets)
+      .filter(([, t]) => t && typeof t === 'object' && t.host === 'uniweb')
+      .map(([name]) => name)
+    if (uniwebTargets.length > 1) {
+      throw new Error(
+        `${path}: only one target may use \`host: uniweb\` — found ${uniwebTargets.length} (${uniwebTargets.join(', ')}). ` +
+          'A site has a single Uniweb identity (site.yml::$uuid), so a second Uniweb target cannot describe a different site. ' +
+          'Keep one, or point the others at a third-party host.'
+      )
+    }
+  }
   if (doc.autoSave !== undefined && !VALID_AUTOSAVE.has(doc.autoSave)) {
     throw new Error(
       `${path}: \`autoSave\` must be one of: ${[...VALID_AUTOSAVE].join(', ')}.`

package/src/uwx/index.js

@@ -43,6 +43,7 @@ export {
   siteProjectToDocument,
   emitSiteSyncPackage,
   writeSiteEntityUuid,
+  writeSiteOrg,
   extensionDeclaration,
   isExtensionUrl,
   isSiteRelativeExtensionUrl,

package/src/uwx/site-project.js

@@ -106,6 +106,16 @@ const INFO_TO_SITE_YML = {
   // render time and never enters `info`.
   submit: 'submit',
   agents: 'agents',
+  // Authored-only, like `submit` above — a host's assistant endpoint is offered
+  // through `config.services` and resolved at render time, so it never enters
+  // `info` and a pull cannot launder it into authored config.
+  //
+  // ⚠️ One asymmetry worth knowing: push STRIPS credential-shaped keys, so a
+  // block that carried an `apiKey` comes back without it and the pull rewrites
+  // the author's file minus that line. That is intended — the key must not be
+  // there and the push already warned — but it is the one case where a pull
+  // removes something the author typed.
+  assistant: 'assistant',
   paths: 'paths',
   data: 'data',
   template: 'template',

package/src/uwx/site.js

@@ -68,6 +68,46 @@ function setIf(obj, key, value) {
   if (value !== undefined) obj[key] = value
 }
 
+// Credential-shaped keys, mirroring the set the delivery edge strips on the
+// reading side. Deliberately the SAME list rather than a stricter one, so the
+// two guards are visibly twins and a key added to one is obviously owed to the
+// other.
+const CREDENTIAL_KEYS = ['apiKey', 'api_key', 'key', 'token', 'secret']
+
+/**
+ * Drop credential-shaped keys out of an authored service block.
+ *
+ * An authored block crosses into backend storage here and is served from there
+ * in a published payload — which is world-readable. So a credential in
+ * `site.yml` is not merely untidy, it is disclosed. The host's secret store is
+ * the only right home, resolved at request time.
+ *
+ * Warns rather than throwing: the fix belongs to the author, a failed push
+ * helps nobody, and the block is still useful without the key. Returns the
+ * value untouched when there is nothing to strip, so `setIf`'s absent-vs-empty
+ * behaviour is unchanged — a block that carried ONLY a credential arrives as
+ * `{}` rather than vanishing, keeping the mistake visible where the author
+ * looks for it.
+ *
+ * @param {*} block - the authored value, any shape
+ * @param {string} label - the site.yml key, for the warning
+ * @returns {*} the block, minus anything credential-shaped
+ */
+function stripCredentials(block, label) {
+  if (!block || typeof block !== 'object' || Array.isArray(block)) return block
+  const found = CREDENTIAL_KEYS.filter(key => key in block)
+  if (found.length === 0) return block
+
+  console.warn(
+    `uwx/site: dropped ${found.join(', ')} from \`${label}:\` — authored config is published ` +
+      'world-readable, so a credential belongs in the host secret store, never in site.yml.'
+  )
+
+  const cleaned = { ...block }
+  for (const key of found) delete cleaned[key]
+  return cleaned
+}
+
 // page_sections and layout_sections share this content shape.
 // processMarkdownFile only destructures type/component/preset/input/props/
 // fetch/data/id out of frontmatter, so `background:` and `theme:` stay
@@ -700,6 +740,22 @@ export async function siteProjectToDocument(siteRoot, opts = {}) {
   // excluded branch becomes both discoverable AND summarized by the index.
   // (The CLI lane reads site.yml directly and honors it either way.)
   setIf(info, 'agents', siteYml.agents)
+  // `assistant` — the site's own declaration for an AI assistant: where it
+  // lives (`endpoint`, read by kit's `resolveService`) plus authored settings a
+  // host reads (`system` persona, model hints). Same family as
+  // `search`/`submit`, and here for the reason spelled out above them — the
+  // bundle lane spreads all of site.yml while this one is an allowlist, so
+  // without this line the block works on a static host and vanishes silently
+  // on the synced lane.
+  //
+  // ⚠️ That is not hypothetical: this replaces `intelligence.yml`, a SEPARATE
+  // file, which needed a bespoke line in each lane and got one in only the
+  // bundle lane — so an authored persona never reached a hosted site at all.
+  // A key inside site.yml cannot repeat that, because only this lane needs a
+  // line. (kb/framework/architecture/assistant-config.md)
+  //
+  // ⛔ Credentials are stripped, not trusted — see `stripCredentials`.
+  setIf(info, 'assistant', stripCredentials(siteYml.assistant, 'assistant'))
   setIf(info, 'paths', siteYml.paths)
   setIf(info, 'data', siteYml.data ?? siteYml.fetch)
   // `app` — the deployment's `@uniweb/app-spec` reference (a bare uuid string),
@@ -804,3 +860,53 @@ export async function emitSiteSyncPackage(siteRoot, opts = {}) {
 export function writeSiteEntityUuid(siteRoot, uuid) {
   return upsertYamlScalar(join(siteRoot, 'site.yml'), '$uuid', uuid)
 }
+
+/**
+ * Record the org the site was CREATED under (`site.yml::$org`), beside `$uuid`.
+ *
+ * The org is consumed at exactly one moment — the `as_org` on the create that
+ * mints `$uuid` — and after that the uuid carries the ownership binding. So this
+ * is not a knob the backend re-reads; it is the answer to *"whose workspace is
+ * this site's storage charged to?"*, which `$uuid` alone cannot answer and which
+ * otherwise costs a backend round-trip (or is simply unknowable from the repo).
+ *
+ * Stored as the BARE handle, never `@handle`: `upsertYamlScalar` writes the value
+ * verbatim, and `@` is a reserved YAML indicator, so a plain scalar may not start
+ * with one — `$org: @acme` is a parse error. The bare form is also the canonical
+ * one everywhere else (`deriveScope` returns it, `createOrg` echoes it as
+ * `org.handle`, `validateHandle` validates it); the `@` is display sugar the
+ * reader re-adds.
+ *
+ * Safe to add to `site.yml` because the sync lane is an explicit allowlist
+ * (`info.*` above is built key by key), so this never rides the wire.
+ *
+ * ⛔ NOT `deploy.yml`, though that file already holds the bound `backend` and the
+ * two look like the same class of fact. Four reasons, and the first is the one that
+ * settles it:
+ *
+ *  1. CARDINALITY. `deploy.yml` is multi-TARGET and `backend` sits *under* a target,
+ *     so its shape says "this may vary per target." An org may not: one site has one
+ *     owning org, fixed at create and preserved on replace. `$org` is a property of
+ *     `$uuid`, which is singular and lives here — filing it under a target would
+ *     encode a freedom that does not exist.
+ *  2. WHO WRITES. Three paths mint a site (`ensureSiteExists`, the media-less push's
+ *     content-lane create, and `clone` seeding an existing one) and **none of them
+ *     write `deploy.yml`** — only `deploy` and `publish` call `recordLastDeploy`. The
+ *     record would exist or not depending on which verb the developer reached for.
+ *  3. SUPPRESSIBLE. `recordLastDeploy` is a no-op under `autoSave: off` / `--no-save`.
+ *     Turning off deploy *receipts* would silently drop an *ownership* record.
+ *  4. SEMANTICS. `deploy.yml` describes the act of shipping (`lastDeploy` is a
+ *     receipt) and is optional entirely. But `push` creates a site and never
+ *     publishes — a site can exist, be owned, and accrue storage charges without
+ *     ever being deployed. Ownership does not belong in a record of a deploy that
+ *     may not have happened.
+ *
+ * `backend` answers *where this ships*; `$org` answers *whose this is*.
+ *
+ * @param {string} siteRoot
+ * @param {string} handle - the bare org handle (no leading `@`)
+ * @returns {boolean} true if site.yml changed
+ */
+export function writeSiteOrg(siteRoot, handle) {
+  return upsertYamlScalar(join(siteRoot, 'site.yml'), '$org', handle)
+}